#######HU4  ##########
#######DUMPS Alexander####
#######07_11_2024####


import rhinoscriptsyntax as rs
import math
import random
import sys

sys.path.append("P:/WWW/adarch")  
import DM_lib as dm

rs.UnitSystem(3)
rs.ShowGrid(view=None, show=0)
rs.ShowGridAxes(view=None, show=0)
rs.ViewDisplayMode(view=None, mode="Wireframe")
rs.EnableRedraw(0)
rs.DeleteObjects(rs.AllObjects())  
#----------------------------------------------------------------------



# Parameter
radius = 500
width = 5
num_points = 5000
turns = 300  # Anzahl der Spirale

def create_spiral_mobius(radius, width, num_points, turns):  # Funktion
    points = []
    for i in range(num_points):
        theta = i * (2 * math.pi * turns / num_points)  
        
        
        r = radius
        x = r * math.cos(theta) + width * math.sin(theta / 2) * math.cos(theta)
        y = r * math.sin(theta) + width * math.sin(theta / 2) * math.sin(theta)
        z = (i / num_points) * width  # Z-Koord Spirale

        # Varianten
        x += random.uniform(-20, 200)
        y += random.uniform(-20, 200)
        z += random.uniform(-20, 200)

        # Erstelle den Punkt Liste
        point = rs.AddPoint([x, y, z])
        points.append(point)
    return points

# Spiralarschleife
mobius_points = create_spiral_mobius(radius, width, num_points, turns)

# berechnen
x_sum, y_sum, z_sum = 0, 0, 0
for pt in mobius_points:
    pt_coords = rs.PointCoordinates(pt)
    x_sum += pt_coords[0]
    y_sum += pt_coords[1]
    z_sum += pt_coords[2]

# Mitte rechnung
center = [x_sum / len(mobius_points), y_sum / len(mobius_points), z_sum / len(mobius_points)]

# Kugel
randomVec = [random.uniform(-60, 100) for i in range(3)]
anz = 300
deltaAngle = 360 / anz
kurv_points = []
# Erstelle die Punkte  Kurve
for i in range(anz):
    vecX = rs.VectorRotate(randomVec, deltaAngle * i, dm.pntRandCoords(-1, 1)[0])
    vecX = rs.VectorScale(vecX, random.uniform(0.9, 1))  # Skalierung
    vecX = rs.VectorAdd(vecX, center)
    rs.AddPoint(vecX)
    kurv_points.append(vecX)

lines = []
for i in range(len(kurv_points) - 1):
    line = rs.AddLine(kurv_points[i], mobius_points[i + 1])  # Linie zwischen den Punkten
    lines.append(line)
    rs.ObjectColor(line, [200, 0, 130] )  # Farbe auf jeden Punkt


start_color = [200, 200, 0]  # RGB
end_color = [0, 0, 255]

def interpolate_color(z, min_z, max_z, start_color, end_color):
    t = max(0, min(1, (z - min_z) / float(max_z - min_z)))
    return [max(0, min(255, int(start_color[i] + t * (end_color[i] - start_color[i])))) for i in range(3)]


# Farbverlauf
z_values = [rs.PointCoordinates(pt)[2] for pt in mobius_points]
min_z, max_z = min(z_values), max(z_values)
for i, point in enumerate(mobius_points):
    color = interpolate_color(rs.PointCoordinates(point)[2], min_z, max_z, start_color, end_color)
    rs.ObjectColor(point, color)  # Farbe