###########################################
###  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)
rs.EnableRedraw(0)

#Referenzobjekt = siege Yamaha SV250/SV255



#### ACHTUNG ! # SELECTION FILTERS MUESSEN AKTIVIERT SEIN ####



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


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

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)


KorpusCurve_0 = rs.AddCurve (KorpusCurveCoords_0,2 ) 

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 ]                                            
KorpusCurve_1_coords = [ p06, p07, p08, p09, p10 ]                                            
KorpusCurve_1 = rs.AddCurve (KorpusCurveCoords_1, 2 )
rs.ObjectColor( KorpusCurve_1, [0,0,200])


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

anz = 400
KorpusCurve_0_coords = rs.DivideCurve (KorpusCurve_0, anz, create_points= 0 )
KorpusCurve_1_coords = rs.DivideCurve (KorpusCurve_1, int(anz*0.5),  create_points= 0 )



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


dm.newEmptyLayer("Korpus_QS", [0,0,0])

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

if 1:
    circDiv = 4
    allCoordsLists = []
    zuwachs = -0.5
    factor = 0.7
    alphaZuwachs = zuwachs/(len(KorpusCurve_0_coords)-1)
    for i,cor in enumerate(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-alphaZuwachs*i)* factor)              #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

    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), [0,0,0])


circDiv = 4
allCoordsLists = []
# print len(KorpusCurve_1_coords)
zuwachs = -0.5
deltaZuwachs = zuwachs/(len(KorpusCurve_1_coords)-1)
for i,cor in enumerate(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 1+deltaZuwachs*i
    circ = rs.AddCircle ( planeX, 1+deltaZuwachs*i)                #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), [0,0,0])


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

#colors = [88,57,39]    #braun
#colors = [200,0,0]      #rot
colors = [0,0,0]      #schwarz

dm.newEmptyLayer("Neck", colors)
dm.newEmptyLayer("FLOW::Neck", colors)

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] )
nCrv_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] )
nCrv_1 = 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] )
nCrv_2 = 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] )
nCrv_3 = rs.AddCurve(Neck_QS_Coords_3, 1)


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

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

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

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

anzX = 400
neckCoords_0 = rs.DivideCurve(NeckEdge_0, anzX, create_points=0)                
neckCoords_1 = rs.DivideCurve(NeckEdge_1, anzX, create_points=0)
neckCoords_2 = rs.DivideCurve(NeckEdge_2, anzX, create_points=0)
neckCoords_3 = rs.DivideCurve(NeckEdge_3, anzX, create_points=0)
NeckCoords = [neckCoords_0, neckCoords_1, neckCoords_2, neckCoords_3]

i=4
for i in range(anzX+1):
    coords = []
    for coordList in NeckCoords:
       coords.append( coordList[i] )
    coords.append( coords[0])
    rs.AddCurve( coords, 1 )


#rs.AddCurve ( NeckCoords, 1)




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


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


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]
HeadEdge_0 = rs.AddCurve(HeadEdge_0, 1)

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

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

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


anzY = 30
HeadCrv_0 = rs.DivideCurve(HeadEdge_0, anzY, create_points=0)          
HeadCrv_1 = rs.DivideCurve(HeadEdge_1, anzY, create_points=0)
HeadCrv_2 = rs.DivideCurve(HeadEdge_2, anzY, create_points=0)
HeadCrv_3 = rs.DivideCurve(HeadEdge_3, anzY, create_points=0)
HeadCoords = (HeadCrv_0, HeadCrv_1, HeadCrv_2, HeadCrv_3)

i=4
for i in range(anzY+1):
    coords = []
    for coordList in HeadCoords:
       coords.append( coordList[i] )
    coords.append( coords[0])
    rs.AddCurve( coords, 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 = 50
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), [0,0,0])


#Rest ##########################################################################

div = 150

#p37 = (-8, 2, .8)
#p38 = (2, 0, .8)
#p39 = (0, 8, .8)
#p40 = (-6, 6, .8)

p37 = ( 2, 2, .8)
p38 = ( -8, 0, .8)
p39 = ( -6, 8, .8)
p40 = ( 0, 6, .8)


Rest_Coords = [ p37, p38, p39, p40]
#rs.AddPoints (Rest_Coords)
Rest_Coords.append(Rest_Coords [0] )
RestCrv = rs.AddCurve(Rest_Coords, 2)


rs.MirrorObject(RestCrv, (-8,4,.8), (2,4,.8), copy=False)
#rs.RotateObject(RestCrv, (-4,4,.8), 300, axis=None, copy=False) 
RestCrvPt = rs.DivideCurve (RestCrv, div, create_points= False)
RestCrvPt += RestCrvPt
RestCrvPt += RestCrvPt

if 1:
    for i in range(div):
        p1 = RestCrvPt[i]
        p2 = RestCrvPt[i+int(div*.5)]
        RestCrvs = rs.AddLine( p1, p2 )

#Flow ##########################################################################

dm.newEmptyLayer("FLOW::base", [0,0,200])

side = 100
z = -5
p0 = [side*-0.5,side*-0.5, z]
p1 = [side*0.5,side*-0.5,  z]
p2 = [side*0.5,side*0.5,  z]
p3 = [side*-0.5,side*0.5,  z]
#base = rs.AddSrfPt( [p0, p1,p2,p3] )
if 1:
    for i in range(1):
        rs.CurrentView("Top")
        rs.DeleteObjects( rs.ObjectsByName("baseSrf*"))
        base = rs.AddSrfPt( [p0, p1,p2,p3] )
        baseCrv = rs.AddCurve( [p0, p1,p2,p3,p0], 1 )
        rs.ObjectName(base, "baseSrf")
        rs.ObjectName(baseCrv, "baseSrf_Crv")
        #rs.ZoomBoundingBox(rs.BoundingBox(base))
        rs.Redraw()
        movVec = [side*random.uniform(-0.5,0.5), side*random.uniform(-0.4,0.4), 0]
        #rs.MoveObjects( rs.ObjectsByName("baseSrf*"), movVec )
        #rs.RotateObject( base, [0,0,0], 270, axis=None, copy=False)
        rs.Redraw()
        rs.UnselectAllObjects()
        rs.Command("-SelBoundary selID "+str(baseCrv)+" enter", 0)
        rs.UnselectObject(base)
        objs = rs.SelectedObjects()
        rs.Redraw()
        rs.Sleep(2000)
    rs.CurrentView("Perspective")
    rs.Redraw()
    base = rs.ObjectsByName("baseSrf")[0]
target = rs.ObjectsByName("040_1")[0]

layers = ["Korpus_QS", "Neck", "Head" ]


#### ACHTUNG ! # SELECTION FILTERS MUESSEN AKTIVIERT SEIN ####

layers = ["Neck" ]
#layers = layers+layers
#layers = layers+layers
rs.UnselectAllObjects()
dm.newEmptyLayer("FLOW::target", [220,0,20])
if 1:
    for lay in layers[0:]:
        dm.esc()
        print lay
        
        #objs = rs.ObjectsByLayer(lay)
        dm.newEmptyLayer("FLOW::base", [0,0,200])
        for j in range(5):                              #anzahl der geigen am berg
            rs.CurrentView("Top")
            rs.DeleteObjects( rs.ObjectsByName("baseSrf*"))
            base = rs.AddSrfPt( [p0, p1,p2,p3] )
            baseCrv = rs.AddCurve( [p0, p1,p2,p3,p0], 1 )
            rs.ObjectName(base, "baseSrf")
            rs.ObjectName(baseCrv, "baseSrf_Crv")
            rs.RotateObject( base, [0,0,0], 270, axis=None, copy=False)###test
            rs.MoveObjects( [base,baseCrv], [side*random.uniform(-0.25,0.4), side*random.uniform(-0.3,0.5), 0] )        #auswahlverschiebung
            rs.UnselectAllObjects()
            rs.Command("-SelBoundary selID "+str(baseCrv)+" enter", 0)
            rs.UnselectObject(base)
            objs = rs.SelectedObjects()
            rs.UnselectAllObjects()
            rs.Redraw()
            rs.CurrentView("Perspective")
            rs.CurrentLayer("FLOW::"+str(lay) )
            for i, obj in enumerate(objs[0:]):   #anzahl an ausgewaehlten curves 0: =alle
                dm.esc()
                dm.flowAlongSrf(obj, base, target)
                if i%10==0:
                    rs.Redraw()
                


################################################################################
if 1:
    rs.DeleteObject( KorpusCurve_0 )
    rs.DeleteObject( KorpusCurve_1 )
    
    rs.DeleteObject( nCrv_0 )
    rs.DeleteObject( nCrv_1 )
    rs.DeleteObject( nCrv_2 )
    rs.DeleteObject( nCrv_3 )
    
    rs.DeleteObject( RLine )

################################################################################