##############################
###  DM2_w24  ue4          ###
###  25.10.2024            ###
##############################
import rhinoscriptsyntax as rs
import random, time, sys   ###                                              
sys.path.append("P:/")     ### add path where "DM_lib.py" can be found !!!                                              
sys.path.append("P:/DM2/")     ### add path where "DM_lib.py" can be found !!!                                              
sys.path.append("P:/WWW/limafi/dm2")     ### add path where "DM_lib.py" can be found !!!                                              
import DM_lib as dm        ### reload(dm)    
############################## 

###rueckmeldung 
#hausi nicht nur punkte, sondern auch linien 
#volume fuellen 
#mehr input, mehr kreativitaet 
#gute bilder - aussagekraeftig - weisser hintergrund - keine screenshots 
#setup nicht bei der hu 
#geometrisch soll es interessant sein 
#command liste nachschauen was wir bereits erlernt haben, selber auch eine liste schreiben 

###################################
###02_uebung
### Langmann_Sven /// _diag
### 20241011
###################################

#allRhinos = rs.AllObjects ()
#rs.DeleteObjects( allRhinos)
dm.PointRadius(displayModeX=0, rad=6, styl=3, verbose=0) #style eckig un drund einstellbar 
#markieren der punkte - setobjectdisplaymode und die darstellung aendern 
#printdisplay on - strichstaerke variieren 
rs.EnableRedraw (0)
dm.eA()
def DrawPointSphere(rad, anz):
    vecS= []
    #rad = 5.0
    vec = [rad, 0, 0]
    vecX = rs.VectorRotate (vec, 90, [0,0,1] )
    ####
    center = [0, 0, 0]
    #anz = 500
    deltaAngle = 360/anz
    ####
    for i in range(anz):
        vecX = rs.VectorRotate( vec, deltaAngle*i, dm.pntRandCoords(-1, 1)[0] )
        #vecX = rs.VectorScale( vecX, random.uniform(0.7, 1) )
        vecX = rs.VectorAdd( vecX, center )
        #rs.AddPoint( vecX )
        vecS.append(vecX)
    #rs.ObjectName( rs.AddPoints( vecS ), "sphPoints")
    return vecS #rueckgabewert von der definition - def soll nicht gleich zeichnen, sondern sammelt zuerst vektoren
    #liste wird dann zurueckgegeben 

def DrawCube(rad, rotate=0):
    ###rad= rad-2
    vecC = []
    #cords.append( [0,0,0] )
    center= [0,0,0]
    #vec= []
    
    vecC.append( rs.VectorAdd( center, rs.VectorScale( [rad,rad,-rad], 1)))  #=Vector A =0
    vecC.append( rs.VectorAdd( center, rs.VectorScale( [-rad,rad,-rad], 1))) #=Vector B =1
    vecC.append( rs.VectorAdd( center, rs.VectorScale( [rad,-rad,-rad], 1))) #=Vector C =2
    vecC.append( rs.VectorAdd( center, rs.VectorScale( [-rad,-rad,-rad], 1)))#=Vector D =3
    ###
    vecC.append( rs.VectorAdd( center, rs.VectorScale( [rad,rad,rad], 1)))   #=Vector E =4
    vecC.append( rs.VectorAdd( center, rs.VectorScale( [-rad,rad,rad], 1)))  #=Vector F =5
    vecC.append( rs.VectorAdd( center, rs.VectorScale( [rad,-rad,rad], 1)))  #=Vector G =6
    vecC.append( rs.VectorAdd( center, rs.VectorScale( [-rad,-rad,rad], 1))) #=Vector H =7
    ###
    if rotate:
        randvec = dm.pntRandCoords(-1, 1)[0]
        for i,vec in enumerate(vecC):
            vecC[i] = rs.VectorRotate( vec, 30.0, randvec )
    
    baseCrv = rs.AddCurve( [vecC[0], vecC[1], vecC[3], vecC[2], vecC[0]], 1 ) 
    topCrv  = rs.AddCurve( [vecC[4], vecC[5], vecC[7], vecC[6], vecC[4]], 1 ) 
    rightCrv  = rs.AddCurve( [vecC[0], vecC[4], vecC[6], vecC[2], vecC[0]], 1 ) 
    leftpCrv  = rs.AddCurve( [vecC[1], vecC[5], vecC[7], vecC[3], vecC[1]], 1 ) 
    ###
    for i,car in enumerate(["A","B","C","D","E","F","G","H"]):
        pass
        #rs.AddTextDot( car, [vecC[0], vecC[1], vecC[2], vecC[3],vecC[4], vecC[5], vecC[6], vecC[7]][i] )
    #rs.ObjectColor(rs.AllObjects()[5], [200,20,20] )
    #dm.textDots( vecC )
    return vecC
    
def DrawDiff(baseCrv, topCrv, anz):
    coords = rs.DivideCurve(baseCrv, anz, 0)
    for y,corC in enumerate(coords):
        rs.ObjectColor( rs.AddPoint( corC ), [10,10,120] )
    #coords += rs.DivideCurve(topCrv, anz, 0)
    ran = random.uniform(4,16)
    ###
    #cen = dm.pntInbetween(vecC[0], vecC[6])

    for i,corS in enumerate(vecS):
        rs.ObjectColor( rs.AddPoint( corS ), [200,20,200] )
        #for y,corC in enumerate(coords):
            #vec1 = rs.VectorSubtract( corS, corC )
            #unitVec = rs.VectorUnitize( vec1 )
            #rs.ObjectColor( rs.AddPoint( corS ), [200,20,200] )


#if( __name__ == "__main__" ): ### no good 4 nothing & DM2 !

if 1:
    rs.DeleteObjects( rs.ObjectsByType( 1 )) #objekte filtern nach typen 
    anz = 3001
    rad = 10
    edgeLen = 7
    sphVecS = DrawPointSphere(rad, anz)
    pnts = rs.AddPoints( sphVecS )
    vecC = DrawCube(edgeLen, rotate=0)

if 1: ### rookie ### #punkte ausserhalb  berechnen 
    for i,cor in enumerate(sphVecS):
        #pnt = rs.AddPoint( cor )
        if abs(cor[2]) > edgeLen or abs(cor[0]) > edgeLen:
            pass
            rs.ObjectColor( pnts[i], [200,0,0])
        else:
            rs.DeleteObject( pnts[i] )

if 0: ### desparate ###
    sphVecS = DrawPointSphere(rad, anz)
    pnts = rs.AddPoints( sphVecS )
    vecC = DrawCube(edgeLen, rotate=1)
    
    for i,cor in enumerate(sphVecS): #zaehler mitlaufen 
        #pnt = rs.AddPoint( cor )
        if abs(cor[2]) > edgeLen or abs(cor[0]) > edgeLen: #abs bei neg und pos alle werte beruecksichtigt , 2 heisst zkoordinate
            pass
            rs.ObjectColor( pnts[i], [20,220,0])
        else:
            rs.DeleteObject( pnts[i] )

if 1: ### advanced ###
    sphVecS = DrawPointSphere(rad, anz)
    pnts = rs.AddPoints( sphVecS )
    vecC = DrawCube(edgeLen, rotate=1)
    
    dm.textDots(vecC)
    centerCub = dm.pntInbetween( vecC[0], vecC[7] )
    rs.AddPoint( centerCub )
    planeA = rs.PlaneFromPoints( centerCub, dm.pntInbetween( vecC[0], vecC[4]), dm.pntInbetween( vecC[1], vecC[5] ) )
    #plane definiert ebene mit 3 punkten 
    
    #loop ueber koordinaten laufen lassen 
    #enumerate nummern fuer die koordinaten 
    nr = 0 
    for i,cor in enumerate(sphVecS[0:10]):
        print i 
        print cor
        print rs.PointCoordinates(pnts[i])
        if abs(rs.DistanceToPlane(planeA, cor)) > edgeLen:
            pass
            rs.ObjectColor( pnts[i], [20,0,220])
        else:
            pass
            rs.DeleteObject( pnts[i] )
        print nr
        nr +=1
dm.zA()

