############################
### diag @ IAM @ DM2_w25 ###
### hu_04 dmLodge_startUP_00
############################

##############################
import rhinoscriptsyntax as rs      ###
import random, time, sys            ###
sys.path.append("P:/")              ### add LW P:/ to rhino's default search path AND
sys.path.append("C:/Verena/3. Semester/DM2/4.HUE- Uebung")  ### add YOUR LW P:/WWW/user/dm2/ to rhino's default search path ...
import DM_lib as dm                 ### ... thus DM_lib.py can be found !
##############################      reload (dm)


rs.UnitSystem(4)                                        # km = 5, meters = 4, cm = 3 etc
rs.ShowGrid(None, 0)                                    # grid > 0 = off
rs.ShowGridAxes(None, 1)                                # y/y/z axen display > 0/1 = off/on
rs.ViewDisplayMode(view=None, mode="wireframe")			# shadeMode fuer current view
rs.AppearanceColor(item=0, color=[230, 230, 230])       ### item=0 => backgroundColor [R,G,B] | 230/230/230 == lightgray
rs.Command("cplane w t enter", 0)						# cPlane World Top
dm.printDisplay(0)                                      # nomen est omen

rs.EnableRedraw(0)                                      ### 4_the_MACs: try 0/1 !
rs.UnselectAllObjects()
dm.newEmptyLayer( "Default")                            
dm.newEmptyLayer( "LODGE", [32, 32, 32] )
dm.newEmptyLayer( "LODGE::setUp",  [11,  11, 111] )    ### newEmtyLayer ist 'current'
dm.newEmptyLayer( "LODGE::crv", [200,  20, 20] )
dm.newEmptyLayer( "LODGE::pnt", [ 100,  100, 100] )
rs.Redraw()
wait = 1

def info():
    ##############################################
    """ LODGE
    Generate a small archetypal house, distorted along perspective algorithms
    A setup for the development of individual panels
    Inspired by
      Albrecht Duerer's "Underweysung" (1525)
      https://de.wikipedia.org/wiki/Perspektive#Geschichte
      https://en.wikipedia.org/wiki/Albrecht_Duerer
    And
      MVRDVs "Porterlodges for the National Park De Hoge Veluwe" (1996)
      https://mvrdv.com/projects/167/hoenderloo-lodge?photo=15877
    Parameters:
      p_width (float, optional): Approx. panel width in units
      l_dist (float, optional): Approx. length of the lodge in units
      d_dist (float, optional): Approx. depth of the lodge in units
      h_dist (float, optional): Approx. height of the lodge in units
      x_pos (float, optional): Move origin of the lodge in x
      y_pos (float, optional): Move origin of the lodge in y
      d_grid (boolean, optional): Fixed depth grid on the the small sides
      d_distord (boolean, optional): Distord basic section of the house
      demo (boolean, optional): Run demo to get an object
      verbose (int, optional): talk & sleep / Print and depict generation of the lodge
    Returns:
      return[0] = list[][][] of all panels, containing groups of 4 points
      return[1] = list[][][] of just the sleeve's panels
      return[2] = list[][][] of just the right section's panels
      return[3] = list[][][] of just the left section's panels
      return[4] = list[][][] of the sections, containing groups of 5 points
      return[5] = list[][] of all the cvs on the sleeve
      return[6] = list[][] of all the cvs on the right section
      return[7] = list[][] of all the cvs on the left section
    Example:
      allData = dm.getLodge( verbose=1000, demo=1 )
      panels = allData[0]
      panels_sleeve = allData[1] // sleeve ~= hull
      panels_right = allData[2]
      panels_left = allData[3]
        sections = allData[4]
        cvs_sleeve= allData[5]
        cvs_right= allData[6]
        cvs_left= allData[7]
    ### allData = dm.getLodge( p_width=1.2, l_dist=10, d_dist=8, h_dist=6, pos_x=0, pos_y=0, d_grid=0, d_distord=1, demo=0, verbose=0 )
    """


### exec whenever ##################################
dm.allLodgeData = dm.getLodge( demo=1, verbose=0 )      ### activate this to get a new set of data
allLodgeData    = dm.allLodgeData                       ### this set of data is generated @ startUp (when DM_lib is loaded)
####################################################    ### allLodgeData = [ panels, panels_sleeve, panels_right, panels_left, sections, cvs_sleeve, cvs_right, cvs_left ]

'''
' check setup - just visualization of setUp >> dont execute @ final version of homework <<                                      '
'''


wait = 0                                        ### wait some milliseconds => s.EOS rs.Sleep(..)

def myPanel( panelX ):
    pass
    p0, p1, p2, p3 = panelX
    if i<1:
        rs.AddCurve( panelX, 1)
        dm.textDots( panelX )

if 1:
    rs.CurrentLayer( "LODGE::setUp" )     
    for i, panelY in enumerate( allLodgeData[1] ):
        myPanel( panelY )

'''              
' end check setup                                                                                                                   ' 
'''


#######################################
################ HERE YOU GO AS YOU GO:

rs.CurrentLayer("LODGE::crv")

# hilfe defs
def gray(c):
    "Graustufenfarbe"
    return [c, c, c]
    

def mid(p1, p2):
    "Mittelpunkt von zwei Punkten"
    return [(p1[0]+p2[0])/2.0, (p1[1]+p2[1])/2.0, (p1[2]+p2[2])/2.0]

def offset_point(pt, vec, f):
    "verschiebt punkt entlang vektor mit faktor"
    return [pt[0]+vec[0]*f, pt[1]+vec[1]*f, pt[2]+vec[2]*f]

def draw_panel(panel_points, gray_val=150, curve_degree=1):
    "zeichnet ein panel mit vier punkten als kurve"
    if len(set([tuple(p) for p in panel_points])) <3 :
        return
    deg = min(curve_degree, len(panel_points)-1)
    try:
        crv = rs.AddCurve(panel_points, deg)
        if crv:
            rs.ObjectColor(crv, gray(gray_val))
    except:
        pl = rs.AddPolyline(panel_points + [panel_points[0]])
        if pl:
            rs.ObjectColor(pl, gray(gray_val))
    # punkte immer anzeigen
    for p in panel_points:
        pt_obj = rs.AddPoint(p)
        rs.ObjectColor(pt_obj, gray(gray_val))

#makepanels funktion definieren
def makePanels(panels, seed=0, distort=0.0):
    import random
    random.seed(seed)
    
    for i, panel in enumerate(panels):
        new_panel = []
        for pt in panel:
            dx = (random.random() - 0.5) * distort # jedem punkt wird zufaelliger versatz gegeben also unregelmaessigkeit
            dy = (random.random() - 0.5) * distort
            dz = (random.random() - 0.5) * distort
            new_pt = [pt[0] + dx, pt[1] + dy, pt[2] + dz]
            new_panel.append(new_pt)
            
        gray_val = int(80 + 150 * random.random())
        draw_panel(new_panel, gray_val=gray_val, curve_degree=1)
        
            
#eine panel ebene zeichnen
rs.CurrentLayer("LODGE::crv")
makePanels(allLodgeData[1], seed=5, distort=0.2)

# mehrere paneele 
rs.CurrentLayer("LODGE::pnt")

#mehrere varianten
for k in range(3):
    shifted = []
    for panel in allLodgeData[1]:
        shift_vec = [k*3, 0, 0]
        shifted.append([offset_point(p, shift_vec, 1) for p in panel])
    makePanels(shifted, seed=10+k, distort=0.3)
    
# mehr paneele bzgl befehl much more panels
rs.CurrentLayer("LODGE")

cols = 5 
rows = 3
distX = 3 
distY = 3

for r in range(rows):
    for c in range(cols):
        shifted = []
        for panel in allLodgeData[1]:
            shift_vec = [c*distX, r*distY, 0]
            shifted.append([offset_point(p, shift_vec, 1) for p in panel])
        makePanels(shifted, seed=r*cols+c, distort=0.15)
        











########################## HERE YOU END
#######################################


########## EOS / EndOfScript
rs.EnableRedraw(1)          ### 4_the_MACs
#dm.eDup( 1 )               ### delete duplicate objects 
dm.printDisplay(1)
dm.zA( 0.9 )
rs.CurrentLayer("Default")
if wait:
    rs.Sleep( wait )
    rs.LayerVisible("LODGE::setUp", 0)