###########################################
###  WS24 DM2 HUE8 Philipp Filipovic    ###
###########################################


##############################
import rhinoscriptsyntax as rs
import random, time, sys   ###
sys.path.append("P:/")     ###
sys.path.append("P:/WWW/filipovp/")     ###
import DM_lib as dm        ### reload( dm )
##############################    
dm.PointRadius(displayModeX=0, rad=3, styl=3)



#Korpus Curve ##################################################################


dm.newEmptyLayer("Korpus_Curve", [255,0,0])
#rs.CurrentLayer("Korpus_Curve")

p00 = (-8, 13, 0)
p01 = (-12, 5, 0)
p02 = (0, 0, 0)
p03 = (12, 5, 0)
p04 = (10, 15, 0)
p05 = (0, 18, 0)

KorpusCurveCoords_0 = [ p00, p01, p02, p03, p04, p05 ]
#rs.AddPoints (KorpusCurveCoords_0)
#rs.AddCurve (KorpusCurveCoords_0, 2 )  

p06 = (7, 16, 0)
p07 = (5, 19, 0)
p08 = (10, 25, 0)
p09 = (7.5, 30, 0)
p10 = (0, 29, 0)

KorpusCurveCoords_1 = [ p06, p07, p08, p09, p10 ]
#rs.AddPoints (KorpusCurveCoords_1)
#rs.AddCurve (KorpusCurveCoords_1, 2 )  




KorpusCurve_0 = rs.AddCurve (KorpusCurveCoords_0,2 ) 
KorpusCurve_1 = rs.AddCurve (KorpusCurveCoords_1,2 )
KorpusCurve_0_coords = rs.DivideCurve (KorpusCurve_0, 20, create_points= False )
KorpusCurve_1_coords = rs.DivideCurve (KorpusCurve_1, 10,  create_points= False )

pXpara = rs.CurveClosestPoint(KorpusCurve_0, p06)
pXcor  = rs.EvaluateCurve(KorpusCurve_0, pXpara)
#rs.AddLine( p06, pXcor )
p06 = pXcor
KorpusCurveCoords_1 = [ p06, p07, p08, p09, p10 ]                                            ### ! ! ! FEHLER WENN AKTIVIERT ! ! ! ###
KorpusCurve_1_coords = [ p06, p07, p08, p09, p10 ]                                            ### ! ! ! FEHLER WENN AKTIVIERT ! ! ! ###
KorpusCurve_1 = rs.AddCurve (KorpusCurveCoords_1, 2 )

rs.EnableObjectGrips( KorpusCurve_1, 1 )
rs.ObjectGripLocations( KorpusCurve_1 , KorpusCurveCoords_1)
rs.EnableObjectGrips( KorpusCurve_1, 0 )



#Korpus Querschnitt ############################################################


dm.newEmptyLayer("Korpus_QS", [0,255,0])
#rs.CurrentLayer("Korpus_QS")
#
#for cor in KorpusCurveCoords_0:
#    pass

dom = rs.CurveDomain ( KorpusCurve_0 ) 
print "dom =", dom
dom = rs.CurveDomain ( KorpusCurve_0 ) [1]
print "dom =", dom

if 1:
    circDiv = 4
    allCoordsLists = []
    for cor in KorpusCurve_0_coords:
        paraX = rs.CurveClosestPoint( KorpusCurve_0, cor ) 
        planeX = rs.CurvePerpFrame (KorpusCurve_0, paraX)
        tanX = rs.CurveTangent(KorpusCurve_0, paraX)
        circ = rs.AddCircle ( planeX, 1)                #Schlauch Durchmesser
        rs.AddPoint( cor )
        rs.RotateObject(circ,  cor, 45.0, tanX)             #Kreis drehen
        circCoords = rs.DivideCurve(circ, circDiv, create_points=0)
        rs.DeleteObject( circ )                        #Kreise Loeschen
        allCoordsLists.append(circCoords)
        circCoords.append(circCoords[0] )
        rs.AddCurve(circCoords, 1)                     #Quadrate Loeschen
    
    #    vecHorizontal = dm.vecCurvePerpXY(KorpusCurve_0, paraX)
    #    vecHorizontal = rs.VectorScale(vecHorizontal, 3.5)
    #    pHorizontal = rs.VectorAdd(cor, vecHorizontal)
    #    rs.AddLine( cor, pHorizontal)
    
    for i in range(circDiv):
        coords = []
        for list in allCoordsLists:
            pX = list[i]
            coords.append (pX)
        rs.ObjectColor (rs.AddCurve(coords, 2), [0,100,100])
        rs.ObjectColor (rs.AddInterpCurve(coords, degree=2, knotstyle=3), [220,100,200])


circDiv = 4
allCoordsLists = []
for cor in KorpusCurve_1_coords:
    paraX = rs.CurveClosestPoint( KorpusCurve_1, cor ) 
    pntOnCrv = rs.EvaluateCurve(KorpusCurve_1, paraX)
    planeX = rs.CurvePerpFrame (KorpusCurve_1, paraX)
    tanX = rs.CurveTangent(KorpusCurve_1, paraX)
    #print tanX, planeX
    circ = rs.AddCircle ( planeX, 1)                #Schlauch Durchmesser
    rs.AddPoint( pntOnCrv )
    rs.RotateObject(circ,  pntOnCrv, 45.0, tanX)            #Kreis drehen
    circCoords = rs.DivideCurve(circ, circDiv, create_points=0)
    rs.DeleteObject( circ )                        #Kreise Loeschen
    allCoordsLists.append(circCoords)
    circCoords.append(circCoords[0] )
    rs.AddCurve(circCoords, 1)                     #Quadrate Loeschen

if 1:
    for i in range(circDiv):
        coords = []
        for list in allCoordsLists:
            pX = list[i]
            coords.append (pX)
        rs.ObjectColor (rs.AddCurve(coords, 2), [0,100,100])
        rs.ObjectColor (rs.AddInterpCurve(coords, degree=2, knotstyle=3), [220,100,200])


#Neck ##########################################################################


dm.newEmptyLayer("Neck", [0,0,255])

p11 = (-1, 2, -0.7)
p12 = (1, 2, -0.7)
p13 = (1, 2, .7)
p14 = (-1, 2, .7)

Neck_QS_Coords_0 = [ p11, p12, p13, p14 ]
#rs.AddPoints (Neck_QS_Coords_0)
Neck_QS_Coords_0.append(Neck_QS_Coords_0[0] )
rs.AddCurve(Neck_QS_Coords_0, 1)


p15 = (-1.5, 18, -0.7)
p16 = (1.5, 18, -0.7)
p17 = (1.5, 18, 1.1)
p18 = (-1.5, 18, 1.1)

Neck_QS_Coords_1 = [ p15, p16, p17, p18 ]
#rs.AddPoints (Neck_QS_Coords_1)
Neck_QS_Coords_1.append(Neck_QS_Coords_1[0] )
rs.AddCurve(Neck_QS_Coords_1, 1)


p19 = (-1, 29, -0.7)
p20 = (1, 29, -0.7)
p21 = (1, 29, .7)
p22 = (-1, 29, .7)

Neck_QS_Coords_2 = [ p19, p20, p21, p22 ]
#rs.AddPoints (Neck_QS_Coords_2)
Neck_QS_Coords_2.append(Neck_QS_Coords_2[0] )
rs.AddCurve(Neck_QS_Coords_2, 1)


p23 = (-0.8, 40, -0.7)
p24 = (0.8, 40, -0.7)
p25 = (0.8, 40, .5)
p26 = (-0.8, 40, .5)

Neck_QS_Coords_3 = [ p23, p24, p25, p26 ]
#rs.AddPoints (Neck_QS_Coords_3)
Neck_QS_Coords_3.append(Neck_QS_Coords_3[0] )
rs.AddCurve(Neck_QS_Coords_3, 1)


NeckEdge_0 = [p11, p15, p19, p23]
rs.AddCurve(NeckEdge_0, 2)

NeckEdge_1 = [p12, p16, p20, p24]
rs.AddCurve(NeckEdge_1, 2)

NeckEdge_2 = [p13, p17, p21, p25]
rs.AddCurve(NeckEdge_2, 2)

NeckEdge_3 = [p14, p18, p22, p26]
rs.AddCurve(NeckEdge_3, 2)


#Head ##########################################################################


dm.newEmptyLayer("Head", [150,0,150])


p27 = (-1.5, 40, -0.7)
p28 = (1.5, 40, -0.7)
p29 = (1.5, 40, .5)
p30 = (-1.5, 40, .5)

Head_Coords_0 = [ p27, p28, p29, p30 ]
#rs.AddPoints (Head_Coords_0)
Head_Coords_0.append(Head_Coords_0[0] )
rs.AddCurve(Head_Coords_0, 1)

p31 = (-0.8, 44, -0.5)
p32 = (0.8, 44, -0.5)
p33 = (0.8, 44, .5)
p34 = (-0.8, 44, .5)

Head_Coords_1 = [ p31, p32, p33, p34 ]
#rs.AddPoints (Head_Coords_1)
Head_Coords_1.append(Head_Coords_1[0] )
rs.AddCurve(Head_Coords_1, 1)


HeadEdge_0 = [p27, p31]
rs.AddCurve(HeadEdge_0, 1)

HeadEdge_1 = [p28, p32]
rs.AddCurve(HeadEdge_1, 1)

HeadEdge_2 = [p29, p33]
rs.AddCurve(HeadEdge_2, 1)

HeadEdge_3 = [p30, p34]
rs.AddCurve(HeadEdge_3, 1)

#Head Roll #####################################################################

p35 = (-1.2, 44.4, 0)
p36 = (1.2, 44.4, 0)

HeadRoll_Coords_0 = [ p35, p36]
#rs.AddPoints (HeadRoll_Coords_0)
RLine = rs.AddCurve(HeadRoll_Coords_0)
HeadRoll_Coords_0 = rs.DivideCurve (RLine, 1, create_points= False )

circDiv = 10
allCoordsLists = []
for cor in HeadRoll_Coords_0:
    paraX = rs.CurveClosestPoint( RLine, cor ) 
    planeX = rs.CurvePerpFrame (RLine, paraX)
    circ = rs.AddCircle ( planeX, .6)                #Schlauch Durchmesser
    circCoords = rs.DivideCurve(circ,circDiv,0)
    #rs.DeleteObject( circ )                        #Kreise Loeschen
    allCoordsLists.append(circCoords)

i = 0

for i in range(circDiv):
    coords = []
    for list in allCoordsLists:
        pX = list[i]
        coords.append (pX)
    rs.ObjectColor (rs.AddCurve(coords, 2), [150,0,150])