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

##############################
import rhinoscriptsyntax as rs      ###
import random, time, sys            ###
sys.path.append("P:/WWW/limafi/dm2")              ### add LW P:/ to rhino's default search path AND
sys.path.append("P:/WWW/diag/dm2")  ### 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=[200, 200, 200])       ### 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")                          ### or LODGE::... sublayer !

def panelSimple(panel_data, forward_offset=5, count=16):
    p0, p1, p2, p3 = panel_data

    rs.AddCurve(panel_data, 1)

    line_a = rs.AddLine(p0, p2)
    line_b = rs.AddLine(p1, p3)

    pts_a = rs.DivideCurve(line_a, count, 0)
    pts_b = rs.DivideCurve(line_b, count, 0)

    for i in range(count):
        rs.AddLine(pts_a[i], pts_b[i]) #linien


def panelWelle(panel_data):
    p0, p1, p2, p3 = panel_data

    p01 = dm.pntInbetween(p0, p1, random.uniform(0.35, 0.65))
    p23 = dm.pntInbetween(p2, p3, random.uniform(0.35, 0.65))
    p03 = dm.pntInbetween(p0, p3, random.uniform(0.35, 0.65))
    p12 = dm.pntInbetween(p1, p2, random.uniform(0.35, 0.65))

    p01i = dm.pntInbetween(p01, p23, random.uniform(0.2, 0.4))
    p23i = dm.pntInbetween(p23, p01, random.uniform(0.2, 0.4))
    p03i = dm.pntInbetween(p03, p12, random.uniform(0.2, 0.4))
    p12i = dm.pntInbetween(p12, p03, random.uniform(0.2, 0.4))

    inner_points = [p0, p01i, p1, p12i, p2, p23i, p3, p03i, p0]
    inner_curve = rs.AddCurve(inner_points, 1)

    normal_vec = dm.normVec3pnts(p0, p2, p1)  #normalvektor


    outer_points = [
        rs.VectorAdd(pt, rs.VectorScale(normal_vec, random.uniform(0.1, 0.4)))
        for pt in inner_points[:-1]
    ]
    outer_points.append(outer_points[0])

    outer_curve = rs.AddCurve(outer_points, 2)

    rs.ObjectColor(inner_curve, [60, 200, 220])
    rs.ObjectColor(outer_curve, [150, 60, 200]) #fareb

    count = 180
    inner_div = rs.DivideCurve(inner_curve, count, 0)
    outer_div = rs.DivideCurve(outer_curve, count, 0)

    for i in range(count):
        line = rs.AddLine(inner_div[i], outer_div[i]) #linien verbinden 
        rs.ObjectColor(line, [10,40,140])


for i, panel_data in enumerate(allLodgeData[1][0:]):
    forward_offset = random.uniform(0.3, 1.0)
    if i % 2 == 0:
        panelWelle(panel_data)
    else:
        panelSimple(panel_data, forward_offset, count=14)




########################## 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 1 or wait:
    rs.Sleep( wait )
    rs.LayerVisible("LODGE::setUp", 0)
    rs.LayerVisible("LODGE::demo", 0)