###################################
### DM2_w25# Chiara Schoeninger ###
### Johanna Dohnal # Frauenhaus ### 
###################################

##############################
import rhinoscriptsyntax as rs
import random, time, sys   ###
import os
sys.path.append("P:/")     ###
import DM_lib as dm        ###
##############################      

rs.UnitSystem(4)                                            # meters = 4, cm = 3 etc
rs.ShowGrid(None, False)                                    # grid > False = off
rs.ShowGridAxes(None, False)                                 # y/y/z axen display > False/True = off/on
rs.Command("cplane w t enter", False)				        # cPlane World Top

dm.PointRadius(displayModeX=0, rad=3, styl=3)               # 0 => wireframe | info: (.., verbose=1)
dm.PointRadius(displayModeX=1, rad=4, styl=1)               # 1 => shaded    | info: (.., verbose=1)
dm.PointRadius(displayModeX=2, rad=2, styl=0)               # 2 => rendered  | info: (.., verbose=1)
dm.printDisplay(state=True, scale=1000)                     # nomen est omen
rs.EnableRedraw(False)

dm.newEmptyLayer("Frauenhaus", [250, 100, 0])               # macht mir eine neue Leere Layer und loescht alles in ihr
rs.Redraw()

#Brick 
BrickLength = 1.2*32/36
#BrickDepth = 1.115
BrickDepth = BrickLength*0.5
BrickHight = 0.8

#upperpoints
#p1 = rs.AddPoint(BrickLength, 0, BrickHight)
#p2 = rs.AddPoint(0, 0, BrickHight)
#p3 = rs.AddPoint(0, BrickDepth, BrickHight)
#p4 = rs.AddPoint(BrickLength, BrickDepth, BrickHight)
#lower
#p5 = rs.AddPoint(BrickLength, 0, 0)
#p6 = rs.AddPoint(0, BrickDepth, 0)
#p7 = rs.AddPoint(BrickLength, BrickDepth, 0)
#p8 = rs.AddPoint(0, 0, 0)



def Brick(p, angel):
    p1 = rs.AddPoint(rs.VectorAdd(p, [BrickLength, 0, BrickHight]))
    p2 = rs.AddPoint(rs.VectorAdd(p, [0, 0, BrickHight]))
    p3 = rs.AddPoint(rs.VectorAdd(p, [0, BrickDepth, BrickHight]))
    p4 = rs.AddPoint(rs.VectorAdd(p, [BrickLength, BrickDepth, BrickHight]))
    p5 = rs.AddPoint(rs.VectorAdd(p, [BrickLength, 0, 0]))
    p6 = rs.AddPoint(rs.VectorAdd(p, [0, BrickDepth, 0]))
    p7 = rs.AddPoint(rs.VectorAdd(p, [BrickLength, BrickDepth, 0]))
    p8 = rs.AddPoint(p)
    
    curve1 = rs.AddCurve([p1, p2],1)
    curve2 = rs.AddCurve([p2, p3],1)
    curve3 = rs.AddCurve([p3, p4],1)
    curve4 = rs.AddCurve([p4, p1],1)
    curve5 = rs.AddCurve([p5, p7],1)
    curve6 = rs.AddCurve([p6, p7],1)
    curve7 = rs.AddCurve([p6, p8],1)
    curve8 = rs.AddCurve([p8, p5],1)
    curve9 = rs.AddCurve([p1, p5],1)
    curve10 = rs.AddCurve([p2, p8],1)
    curve11 = rs.AddCurve([p3, p6],1)
    curve12 = rs.AddCurve([p4, p7],1)
    
    rs.RotateObjects([p1, p2, p3, p4, p5, p6, p7, p8, curve1, curve2, curve3, curve4, curve5, curve6, curve7, curve8, curve9, curve10, curve11, curve12], p8, angel)
    
    #rs.Redraw()
    #rs.Sleep(0)
    
    return p5
 
    
def BrickLine(p, angel, amount):
    #endPunktErsterZiegel = Brick(p, angel)
    #endPunktZweiterZiegel = Brick(endPunktErsterZiegel, angel)
    #endPunktDritterZiegel = Brick(endPunktZweiterZiegel, angel)

    for i in range(amount):
        endPointBrick = Brick(p, angel)
        p = endPointBrick
        
    return endPointBrick

def Outline(z):
    endPointBrickLine1 = BrickLine([10, 10, z], 0, 10)
    endPointBrickLine2 = BrickLine(endPointBrickLine1, 90, 1)
    endPointBrickLine3 = BrickLine(endPointBrickLine2, 0, 4)
    endPointBrickLine4 = BrickLine(endPointBrickLine3, -90, 1)
    endPointBrickLine5 = BrickLine(endPointBrickLine4, 0, 10)
    endPointBrickLine6 = BrickLine(endPointBrickLine5, 90, 10)
    endPointBrickLine7 = BrickLine(endPointBrickLine6, 180, 24)
    endPointBrickLine8 = BrickLine(endPointBrickLine7, -90, 10)

z = 0
for i in range(0, 0):
    Outline(z)
    z += BrickHight



############################ diag
#################################
#################################

### HAUS grundriss festlegen - im "ziegel_masz"
hausLaenge = 40
hausTiefe  = 16
hausHoehe  = 20

einrueckungStart = 18
einrueckungTiefe = 1
einrueckungBreite = 4

if 0:
    hausHoehe = 1

p0 = [0,0,0]
p1 = [BrickLength*hausLaenge, 0, 0]
p2 = rs.VectorAdd(p1, [0, BrickLength*hausTiefe, 0])
p3 = rs.VectorAdd(p2, [-BrickLength*einrueckungStart, 0, 0])
p4 = rs.VectorAdd(p3, [0, -BrickLength * einrueckungTiefe, 0])
p5 = rs.VectorAdd(p4, [-BrickLength*einrueckungBreite, 0, 0])
p6 = rs.VectorAdd(p5, [0, BrickLength * einrueckungTiefe, 0])
p7 = rs.VectorAdd(p2, [-BrickLength*hausLaenge, 0,0])

grundriss_curve = rs.AddCurve( [p0, p1, p2, p3, p4, p5, p6, p7, p0], 1)


anzahl_bricks = int( rs.CurveLength(grundriss_curve) / BrickLength )
wall_coords = rs.DivideCurve( grundriss_curve, anzahl_bricks*2, 0) ### doppelte anzahl wg *halber ziegel*
wall_coords.append(wall_coords[0]) ### weil isCurveClosed
print ("bricks needed maximal = {} circa(!) pro schicht". format(anzahl_bricks) ) 

### achtung:
### fensterpositionen sind bezogen auf hausLaenge & hausTiefe !

fensters = []

#fensters.append([range(0, 4), range(5, 8)])

                #Hoehe von Boden, fensterhoehe, von linker saeule weg, breite des fensters   
#Hinten 1. Reihe ausser Tuer Mitte, da gleich alles
x = 0
fensters.append([range(4, 6), range(x+4, x+8)]) #Hinten H Links L 1Reihe R 2tes
x += 8
fensters.append([range(4, 6), range(x+7, x+13)]) #HL1R2tes
x += 13
fensters.append([range(4, 6), range(x+1, x+2)]) #HL1R3tes mini
x += 2
fensters.append([range(4, 6), range(x+5, x+11)]) #HL1R4tes
x += 11

for z in range(0, 4):
    fensters.append([range(2+z*4, 5+z*4), range(x+4, x+8)]) #Mitte hinten alle Fenster
fensters.append([range(18, 19), range(x+4, x+8)]) # Kleines oberes Fenster
x += 8

fensters.append([range(4, 6), range(x+4, x+10)]) #HR1R1tes
x += 10
fensters.append([range(4, 6), range(x+5, x+6)]) #HR1R2tes mini
x += 6
fensters.append([range(4, 6), range(x+1, x+7)]) #HR1R3tes
x += 7
fensters.append([range(4, 6), range(x+7, x+11)]) #HR1R4tes
x += 11

# Hinten Obere Reihen

for y in range(0, 3):
    for fensterX in range(0, 3):
        fensters.append([range(8+y*4, 10+y*4), range(4+fensterX*12, 10+fensterX*12)]) #Alle hinteren oberen Fenster links
        
for y in range(0, 3):
    for fensterX in range(0, 3):
        fensters.append([range(8+y*4, 10+y*4), range(46+fensterX*12, 52+fensterX*12)]) #Alle hinteren oberen Fenster rechts

#Vorne 1. Reihe
x += 36
x_start = x
fensters.append([range(4, 6), range(x+4, x+8)]) #Vorne V Links L 1Reihe R 2tes
x += 8
fensters.append([range(4, 6), range(x+7, x+13)]) #VL1R2tes
x += 13
fensters.append([range(4, 6), range(x+1, x+2)]) #VL1R3tes mini
x += 2
fensters.append([range(4, 6), range(x+5, x+11)]) #VL1R4tes
x += 11

x += 2
fensters.append([range(0, 5), range(x+4, x+8)]) #Tuer
for z in range(1, 4):
    fensters.append([range(2+z*4, 5+z*4), range(x+4, x+8)]) #Fenster ueber Tuer
fensters.append([range(18, 19), range(x+4, x+8)]) # Kleines oberes Fenster
x += 10

fensters.append([range(4, 6), range(x+4, x+10)]) #VR1R1tes
x += 10
fensters.append([range(4, 6), range(x+5, x+6)]) #VR1R2tes mini
x += 6
fensters.append([range(4, 6), range(x+1, x+7)]) #VR1R3tes
x += 7
fensters.append([range(4, 6), range(x+7, x+11)]) #VR1R4tes
x += 11

# Vorne Obere Reihen

for y in range(0, 3):
    for fensterX in range(0, 3):
        fensters.append([range(8+y*4, 10+y*4), range(x_start+4+fensterX*12, x_start+10+fensterX*12)]) #Alle vorderen oberen Fenster links
        
for y in range(0, 3):
    for fensterX in range(0, 3):
        fensters.append([range(8+y*4, 10+y*4), range(x_start+50+fensterX*12, x_start+56+fensterX*12)]) #Alle vorderen oberen Fenster rechts

#for y in range(0, 3):
#    fensters.append([range(2 + y * 4, 5 + y * 4), range(12, 15)])
#fensters.append([range(14, 15), range(12, 15)])

#fensters.append(range( 5, 8)) ### 1.wert: ungerade / 2.wert: gerade .. weil nur jd 2. wall_coord wird ziegel  / siehe unten !
#fensters.append(range(13,16))
#fensters.append(range(35,36))
#fensters.append(range(47,54))
#fensters.append(range(63,70))
for fenster in fensters:
    fensterZ = fenster[0]
    fensterX = fenster[1]
    print "fenster von Hoehe ", fensterZ[0],"bis",fensterZ[-1]+1,"und Breite",fensterX[0],"bis",fensterX[-1]+1

# Fuer Namen
global framNr
framNr = 0

path = "D:/Bilder/"
if not os.path.exists(path): os.makedirs(path)

def brick_ag(pos = [0,0,0], bL=1.0, ang=90, ziegelNr=0, verbose=1):  ### bL: factor fuer ziegel_laenge / dir: richtung, winkel in grad
    global framNr
    brick_coords = [[0,0,0], [0,0,BrickHight], [0,BrickDepth,BrickHight], [0,BrickDepth,0]]
    brick_coords += [rs.VectorAdd(cor, [BrickLength*bL, 0,0]) for cor in brick_coords]
    brick_coords = [rs.VectorRotate(cor, ang, [0,0,1]) for cor in brick_coords]
    brick_coords = [rs.VectorAdd(cor, pos) for cor in brick_coords]
    p0, p1, p2, p3, p4, p5, p6, p7 = brick_coords
    curves = []
    curves.append(rs.AddCurve([p0, p1], 1))  ### vertikale kanten unten links
    curves.append(rs.AddCurve([p3, p2], 1))
    curves.append(rs.AddCurve([p7, p6], 1))
    curves.append(rs.AddCurve([p4, p5], 1))
    curves.append(rs.AddCurve([p0, p3], 1))  ### unterkante
    curves.append(rs.AddCurve([p3, p7], 1))
    curves.append(rs.AddCurve([p7, p4], 1))
    curves.append(rs.AddCurve([p4, p0], 1))
    curves.append(rs.AddCurve([p1, p2], 1))  ### oberkante
    curves.append(rs.AddCurve([p2, p6], 1))
    curves.append(rs.AddCurve([p6, p5], 1))
    curves.append(rs.AddCurve([p5, p1], 1))
    rs.ScaleObjects(curves, dm.pntCentroid(brick_coords), [0.95,0.95,0.95])
    rs.ObjectColor(curves, [250,100,150*(bL!=1)])
    
    d0 = rs.CurveDomain(curves[0])
    vorne_links_10 = rs.EvaluateCurve(curves[0], d0[0] + (d0[1] - d0[0]) * 0.1)
    vorne_links_90 = rs.EvaluateCurve(curves[0], d0[0] + (d0[1] - d0[0]) * 0.9)

    d1 = rs.CurveDomain(curves[1])
    hinten_links_10 = rs.EvaluateCurve(curves[1], d1[0] + (d1[1] - d1[0]) * 0.1)
    hinten_links_90 = rs.EvaluateCurve(curves[1], d1[0] + (d1[1] - d1[0]) * 0.9)

    d2 = rs.CurveDomain(curves[2])
    hinten_rechts_10 = rs.EvaluateCurve(curves[2], d2[0] + (d2[1] - d2[0]) * 0.9)
    hinten_rechts_90 = rs.EvaluateCurve(curves[2], d2[0] + (d2[1] - d2[0]) * 0.1)

    d3 = rs.CurveDomain(curves[3])
    vorne_rechts_10 = rs.EvaluateCurve(curves[3], d3[0] + (d3[1] - d3[0]) * 0.9)
    vorne_rechts_90 = rs.EvaluateCurve(curves[3], d3[0] + (d3[1] - d3[0]) * 0.1)

    d7 = rs.CurveDomain(curves[7])
    vorne_unten_10 = rs.EvaluateCurve(curves[7], d7[0] + (d7[1] - d7[0]) * 0.1)
    vorne_unten_90 = rs.EvaluateCurve(curves[7], d7[0] + (d7[1] - d7[0]) * 0.9)

    d5 = rs.CurveDomain(curves[5])
    hinten_unten_10 = rs.EvaluateCurve(curves[5], d5[0] + (d5[1] - d5[0]) * 0.9)
    hinten_unten_90 = rs.EvaluateCurve(curves[5], d5[0] + (d5[1] - d5[0]) * 0.1)

    d11 = rs.CurveDomain(curves[11])
    vorne_oben_10 = rs.EvaluateCurve(curves[11], d11[0] + (d11[1] - d11[0]) * 0.9)
    vorne_oben_90 = rs.EvaluateCurve(curves[11], d11[0] + (d11[1] - d11[0]) * 0.1)

    d9 = rs.CurveDomain(curves[9])
    hinten_oben_10 = rs.EvaluateCurve(curves[9], d9[0] + (d9[1] - d9[0]) * 0.1)
    hinten_oben_90 = rs.EvaluateCurve(curves[9], d9[0] + (d9[1] - d9[0]) * 0.9)

    vorne_oben_links = p1
    vorne_oben_rechts = p5
    vorne_unten_links = p0
    vorne_unten_rechts = p4
    hinten_oben_links = p2
    hinten_oben_rechts = p6
    hinten_unten_links = p3
    hinten_unten_rechts = p7

    # vorne
    curve_vorne_oben = rs.AddCurve([vorne_oben_10, vorne_oben_90], 1)
    curve_vorne_rechts = rs.AddCurve([vorne_rechts_10, vorne_rechts_90], 1)
    curve_vorne_unten = rs.AddCurve([vorne_unten_10, vorne_unten_90], 1)
    curve_vorne_links = rs.AddCurve([vorne_links_10, vorne_links_90], 1)

    # vorne rundungen
    curve_vorne_links_oben = rs.AddCurve([vorne_links_90, vorne_oben_links, vorne_oben_10], 5)
    curve_vorne_oben_rechts = rs.AddCurve([vorne_oben_90, vorne_oben_rechts, vorne_rechts_10], 5)
    curve_vorne_rechts_unten = rs.AddCurve([vorne_rechts_90, vorne_unten_rechts, vorne_unten_10], 5)
    curve_vorne_unten_links = rs.AddCurve([vorne_unten_90, vorne_unten_links, vorne_links_10], 5)

    # hinten
    curve_hinten_oben = rs.AddCurve([hinten_oben_10, hinten_oben_90], 1)
    curve_hinten_rechts = rs.AddCurve([hinten_rechts_10, hinten_rechts_90], 1)
    curve_hinten_unten = rs.AddCurve([hinten_unten_10, hinten_unten_90], 1)
    curve_hinten_links = rs.AddCurve([hinten_links_10, hinten_links_90], 1)

    # hinten rundungen
    curve_hinten_links_oben = rs.AddCurve([hinten_links_90, hinten_oben_links, hinten_oben_10], 5)
    curve_hinten_oben_rechts = rs.AddCurve([hinten_oben_90, hinten_oben_rechts, hinten_rechts_10], 5)
    curve_hinten_rechts_unten = rs.AddCurve([hinten_rechts_90, hinten_unten_rechts, hinten_unten_10], 5)
    curve_hinten_unten_links = rs.AddCurve([hinten_unten_90, hinten_unten_links, hinten_links_10], 5)

    # verbindungen
    #rs.AddCurve([vorne_oben_10, hinten_oben_10], 1)
    #rs.AddCurve([vorne_oben_90, hinten_oben_90], 1)
    #rs.AddCurve([vorne_rechts_10, hinten_rechts_10], 1)
    #rs.AddCurve([vorne_rechts_90, hinten_rechts_90], 1)
    #rs.AddCurve([vorne_unten_10, hinten_unten_10], 1)
    #rs.AddCurve([vorne_unten_90, hinten_unten_90], 1)
    #rs.AddCurve([vorne_links_10, hinten_links_10], 1)
    #rs.AddCurve([vorne_links_90, hinten_links_90], 1)
    verbindungen = []
    verbindungen.append([curve_vorne_oben, curve_hinten_oben])
    verbindungen.append([curve_vorne_unten, curve_hinten_unten])
    verbindungen.append([curve_vorne_links, curve_hinten_links])
    verbindungen.append([curve_vorne_rechts, curve_hinten_rechts])
    verbindungen.append([curve_vorne_links_oben, curve_hinten_links_oben])
    verbindungen.append([curve_vorne_oben_rechts, curve_hinten_oben_rechts])
    verbindungen.append([curve_vorne_rechts_unten, curve_hinten_rechts_unten])
    verbindungen.append([curve_vorne_unten_links, curve_hinten_unten_links])
    for paar in verbindungen:
        curve_vorne = paar[0]
        curve_hinten = paar[1]
        domain_vorne = rs.CurveDomain(curve_vorne)
        domain_hinten = rs.CurveDomain(curve_hinten)
        for t in range(6):
            t_vorne = domain_vorne[0] + (domain_vorne[1] - domain_vorne[0]) * t / 5.0
            t_hinten = domain_hinten[0] + (domain_hinten[1] - domain_hinten[0]) * t / 5.0
            punkt_vorne = rs.EvaluateCurve(curve_vorne, t_vorne)
            punkt_hinten = rs.EvaluateCurve(curve_hinten, t_hinten)
            rs.AddCurve([punkt_vorne, punkt_hinten], 1)

    # vorne/hinten senkrecht
    if 0:
        verbindungen_vertikal = []
        verbindungen_vertikal.append([curve_vorne_unten, curve_vorne_oben])
        verbindungen_vertikal.append([curve_hinten_unten, curve_hinten_oben])
        verbindungen_vertikal.append([curve_vorne_links, curve_vorne_rechts])
        verbindungen_vertikal.append([curve_hinten_links, curve_hinten_rechts])
        for paar in verbindungen_vertikal:
            curve_unten = paar[0]
            curve_oben = paar[1]
            domain_unten = rs.CurveDomain(curve_unten)
            domain_oben = rs.CurveDomain(curve_oben)
            for t in range(6):
                t_unten = domain_unten[0] + (domain_unten[1] - domain_unten[0]) * t / 5.0
                t_oben = domain_oben[0] + (domain_oben[1] - domain_oben[0]) * t / 5.0
                punkt_unten = rs.EvaluateCurve(curve_unten, t_unten)
                punkt_oben = rs.EvaluateCurve(curve_oben, t_oben)
                rs.AddCurve([punkt_unten, punkt_oben], 1)

    rs.DeleteObjects(curves)
    
    if 0:
        brick_curve  = rs.AddCurve( [p0, p1, p2, p3, p7, p6, p5, p4, p0], 1 )
        if verbose:
            rs.ExtrudeCurveStraight( rs.AddCurve([p3,p0,p4,p7,p3],1), p0, p1)
        rs.ScaleObject( rs.AllObjects()[0], dm.pntCentroid( brick_coords ), [0.98,0.98,0.98] )
        rs.ObjectColor( rs.AllObjects()[0], [250,100,150*(bL!=1)])
        rs.ObjectName( rs.AllObjects()[0], ("ziegel pos {}".format( ziegelNr ) ) )
    
    if 1:
        rs.Redraw()
        imageNameX = dm.makeName(name='frauenhaus', frameNumber=framNr, anzahl=4, format='jpg')
        rs.Command("-_viewCaptureToFile Width=640 Height=360 Scale=2 TransparentBackground="+dm.trans["png" in imageNameX]+" "+path+imageNameX, False)
    else:
        rs.Redraw()
        
    framNr += 1
    return brick_coords

#dm.textDots(wall_coords)
    
def make_ziegelreihe( wall_coords=[], start=0):
    for i in range(start,anzahl_bricks*2, 2):
        if i<anzahl_bricks*2-2: ### letzter ziegel hat keine wall_coords[i+3]
            ang1 = rs.Angle( wall_coords[i+0], wall_coords[i+1] )[0]
            ang2 = rs.Angle( wall_coords[i+2], wall_coords[i+3] )[0]
            diff = ang1 - ang2
            if diff == -270 or diff == 90:
                bL = 1
            else:
                bL = 1-0.5*(ang2 != ang1) ### wenn ungleich > bL = 0.5 > halber ziegel bei ecke
        else:
            bL=0.5  ### wenn == anzahl_bricks*2-2 .. letzter stein
        ## fenster auslassen wenn doBrick == 0
        ## etwas tricky .. wg eckverband .. weil die ziegelLagen versetzt starten
        doBrick = 1
        zR = ziegelreihe
        for fe,fenster in enumerate(fensters):
            fensterZ = fenster[0]
            fensterX = fenster[1]
            
            #if (fe==0 and (-1<zR<4 or 6<zR<8)) or (fe==1 and 1<zR<4) or (fe==2 and zR and zR%2==1) or (fe==3 and (1<zR<5 or 5<zR<7)) or (fe==4 and zR%3==0+1) :
            if zR in fensterZ:
                ## generell loch
                if i+start in fensterX:
                    doBrick = 0
                # links
                if i+start == (fensterX[0]+start-1): # dann waere ein ganzer ziegel zu lange - daher:
                    bL=0.5
                    doBrick = 1
                # rechts: halber, nach rechts versetzter ziegel 
                if i+start == (fensterX[-1]+start):
                    bL=0.5
                    i+=1
                    doBrick = 1
        if doBrick:
            coords = brick_ag(pos=wall_coords[i], bL=bL, ang=ang1, ziegelNr=i, verbose=1)
            rs.ObjectName( rs.AllObjects()[0:1], ("ziegelNr_{}".format( int(i/1) ) ) )
            #if i==0: dm.textDots(coords )

if 1:
    for ziegelreihe in range(0, hausHoehe):
        ziegel_coords = [rs.VectorAdd( cor, [0,0,BrickHight*ziegelreihe]) for cor in wall_coords]
        print ("reihe {} - start {}". format(ziegelreihe, ziegelreihe%2))
        make_ziegelreihe( wall_coords=ziegel_coords, start=(ziegelreihe+0)%2)
        #rs.Redraw()
        #bBox = rs.BoundingBox( rs.ObjectsByLayer("Frauenhaus_OG") )
        #rs.ZoomBoundingBox(bBox)

def make_satteldach(dach_hoehe, haus_laenge, haus_tiefe):
    global framNr
    spitze = [haus_laenge / 2.0, haus_tiefe / 2.0, hausHoehe * BrickHight + dach_hoehe * BrickHight]
    
    ecke1 = [0, 0, hausHoehe * BrickHight]
    ecke2 = [haus_laenge, 0, hausHoehe * BrickHight]
    ecke3 = [haus_laenge, haus_tiefe, hausHoehe * BrickHight]
    ecke4 = [0, haus_tiefe, hausHoehe * BrickHight]

    ecke1_zu_spitze = rs.AddCurve( [ecke1, spitze], 1)
    ecke2_zu_spitze = rs.AddCurve( [ecke2, spitze], 1)
    ecke3_zu_spitze = rs.AddCurve( [ecke3, spitze], 1)
    ecke4_zu_spitze = rs.AddCurve( [ecke4, spitze], 1)

    rs.ObjectColor(ecke1_zu_spitze, [200,100,50])
    rs.ObjectColor(ecke2_zu_spitze, [200,100,50])
    rs.ObjectColor(ecke3_zu_spitze, [200,100,50])
    rs.ObjectColor(ecke4_zu_spitze, [200,100,50])

    letzte_dach_curve = None

    for y in range(dach_hoehe + 1):
        letzte_linie_nach_oben = None

        ecke1_zu_spitze_domain = rs.CurveDomain(ecke1_zu_spitze)
        ecke2_zu_spitze_domain = rs.CurveDomain(ecke2_zu_spitze)
        ecke3_zu_spitze_domain = rs.CurveDomain(ecke3_zu_spitze)
        ecke4_zu_spitze_domain = rs.CurveDomain(ecke4_zu_spitze)

        ecke1_zu_spitze_t = ecke1_zu_spitze_domain[0] + (ecke1_zu_spitze_domain[1] - ecke1_zu_spitze_domain[0]) * y / float(dach_hoehe)
        ecke2_zu_spitze_t = ecke2_zu_spitze_domain[0] + (ecke2_zu_spitze_domain[1] - ecke2_zu_spitze_domain[0]) * y / float(dach_hoehe)
        ecke3_zu_spitze_t = ecke3_zu_spitze_domain[0] + (ecke3_zu_spitze_domain[1] - ecke3_zu_spitze_domain[0]) * y / float(dach_hoehe)
        ecke4_zu_spitze_t = ecke4_zu_spitze_domain[0] + (ecke4_zu_spitze_domain[1] - ecke4_zu_spitze_domain[0]) * y / float(dach_hoehe)

        punkt_ecke1 = rs.EvaluateCurve(ecke1_zu_spitze, ecke1_zu_spitze_t)
        punkt_ecke2 = rs.EvaluateCurve(ecke2_zu_spitze, ecke2_zu_spitze_t)
        punkt_ecke3 = rs.EvaluateCurve(ecke3_zu_spitze, ecke3_zu_spitze_t)
        punkt_ecke4 = rs.EvaluateCurve(ecke4_zu_spitze, ecke4_zu_spitze_t)

        dach_curve = rs.AddCurve( [punkt_ecke1, punkt_ecke2, punkt_ecke3, punkt_ecke4, punkt_ecke1], 1)
        rs.ObjectColor(dach_curve, [250,50,50])

        if letzte_dach_curve:
            anzahl_bricks = int( rs.CurveLength(letzte_dach_curve) / BrickLength)
            dach_curve_domain = rs.CurveDomain(dach_curve)
            letzte_dach_curve_domain = rs.CurveDomain(letzte_dach_curve)

            for t in range(anzahl_bricks):
                t_dach = dach_curve_domain[0] + (dach_curve_domain[1] - dach_curve_domain[0]) * t / float(anzahl_bricks)
                t_letzte_dach = letzte_dach_curve_domain[0] + (letzte_dach_curve_domain[1] - letzte_dach_curve_domain[0]) * t / float(anzahl_bricks)

                punkt_dach = rs.EvaluateCurve(dach_curve, t_dach)
                punkt_letzte_dach = rs.EvaluateCurve(letzte_dach_curve, t_letzte_dach)

                linie_nach_oben = rs.AddCurve( [punkt_letzte_dach, punkt_dach], 1)
                rs.ObjectColor(linie_nach_oben, [250,50,50])

                if letzte_linie_nach_oben:
                    linie_nach_oben_domain = rs.CurveDomain(linie_nach_oben)
                    letzte_linie_nach_oben_domain = rs.CurveDomain(letzte_linie_nach_oben)

                    for t2 in range(6):
                        t_linie_nach_oben = linie_nach_oben_domain[0] + (linie_nach_oben_domain[1] - linie_nach_oben_domain[0]) * t2 / 5.0
                        t_letzte_linie_nach_oben = letzte_linie_nach_oben_domain[0] + (letzte_linie_nach_oben_domain[1] - letzte_linie_nach_oben_domain[0]) * t2 / 5.0

                        punkt_linie_nach_oben = rs.EvaluateCurve(linie_nach_oben, t_linie_nach_oben)
                        punkt_letzte_linie_nach_oben = rs.EvaluateCurve(letzte_linie_nach_oben, t_letzte_linie_nach_oben)

                        verbindungs_linie = rs.AddCurve( [punkt_letzte_linie_nach_oben, punkt_linie_nach_oben], 1)
                        rs.ObjectColor(verbindungs_linie,[250,50,50])

                letzte_linie_nach_oben = linie_nach_oben

                if 1:
                    rs.Redraw()
                    imageNameX = dm.makeName(name='frauenhaus', frameNumber=framNr, anzahl=4, format='jpg')
                    rs.Command("-_viewCaptureToFile Width=640 Height=360 Scale=2 TransparentBackground="+dm.trans["png" in imageNameX]+" "+path+imageNameX, False)
                else:
                    rs.Redraw()

                framNr += 1
                    
        letzte_dach_curve = dach_curve

def make_lattenzaun(zaun_hoehe, zaun_p0, zaun_p1, zaun_p2, zaun_p3, zaun_offset):
    global framNr
    
    curve_unten = rs.AddCurve( [zaun_p0, zaun_p1, zaun_p2, zaun_p3, zaun_p0], 1)
    zaun_p0_oben = rs.VectorAdd( zaun_p0, [0,0,zaun_hoehe*BrickHight])
    zaun_p1_oben = rs.VectorAdd( zaun_p1, [0,0,zaun_hoehe*BrickHight])
    zaun_p2_oben = rs.VectorAdd( zaun_p2, [0,0,zaun_hoehe*BrickHight])
    zaun_p3_oben = rs.VectorAdd( zaun_p3, [0,0,zaun_hoehe*BrickHight])
    curve_oben = rs.AddCurve( [zaun_p0_oben, zaun_p1_oben, zaun_p2_oben, zaun_p3_oben, zaun_p0_oben], 1)

    curve_length = rs.CurveLength(curve_unten)
    anzahl_latten = int( curve_length / BrickLength )

    for i in range(anzahl_latten + 1):
        curve_unten_domain = rs.CurveDomain(curve_unten)
        curve_oben_domain = rs.CurveDomain(curve_oben)

        i_verschoben = (i + zaun_hoehe) % anzahl_latten

        t_unten = curve_unten_domain[0] + (curve_unten_domain[1] - curve_unten_domain[0]) * i / float(anzahl_latten)
        t_oben = curve_oben_domain[0] + (curve_oben_domain[1] - curve_oben_domain[0]) * i_verschoben / float(anzahl_latten)

        punkt_unten = rs.EvaluateCurve(curve_unten, t_unten)
        punkt_oben = rs.EvaluateCurve(curve_oben, t_oben)

        latten_linie = rs.AddCurve( [punkt_unten, punkt_oben], 1)
        rs.ObjectColor(latten_linie, [150,75,0])

        t_unten = curve_unten_domain[0] + (curve_unten_domain[1] - curve_unten_domain[0]) * i_verschoben / float(anzahl_latten)
        t_oben = curve_oben_domain[0] + (curve_oben_domain[1] - curve_oben_domain[0]) * i / float(anzahl_latten)

        punkt_unten = rs.EvaluateCurve(curve_unten, t_unten)
        punkt_oben = rs.EvaluateCurve(curve_oben, t_oben)

        latten_linie = rs.AddCurve( [punkt_unten, punkt_oben], 1)
        rs.ObjectColor(latten_linie, [150,75,0])

        if 1:
            rs.Redraw()
            imageNameX = dm.makeName(name='frauenhaus', frameNumber=framNr, anzahl=4, format='jpg')
            rs.Command("-_viewCaptureToFile Width=640 Height=360 Scale=2 TransparentBackground="+dm.trans["png" in imageNameX]+" "+path+imageNameX, False)
        else:
            rs.Redraw()

        framNr += 1

# Satteldach
if 1:
    # dach aufbauen mit curve
    ziegelreihe = hausHoehe
    dach_hoehe = 10
    haus_laenge_absolute = hausLaenge * BrickLength
    haus_tiefe_absolute = hausTiefe * BrickLength
    make_satteldach(dach_hoehe, haus_laenge_absolute, haus_tiefe_absolute)

# Dach
if 0:
    # Spiral Dach
    dach_curve_coords = []
    for i in range(0, hausTiefe//2):
        dach_curve_coords.append([i*BrickDepth, i*BrickDepth, hausHoehe*BrickHight])
        dach_curve_coords.append([hausLaenge*BrickLength-i*BrickDepth, i*BrickDepth, hausHoehe*BrickHight])
        dach_curve_coords.append([hausLaenge*BrickLength-i*BrickDepth, hausTiefe*BrickDepth-i*BrickDepth, hausHoehe*BrickHight])
        dach_curve_coords.append([i*BrickDepth, hausTiefe*BrickDepth-i*BrickDepth, hausHoehe*BrickHight])
        dach_curve_coords.append([i*BrickDepth, (i+1)*BrickDepth, hausHoehe*BrickHight])
    
    dach_curve = rs.AddCurve(dach_curve_coords, 1)
    anzahl_bricks = int( rs.CurveLength(dach_curve) / BrickLength )
    dach_coords = rs.DivideCurve( dach_curve, anzahl_bricks*2, 0) ### doppelte anzahl wg *halber ziegel*
    ziegelreihe = hausHoehe
    make_ziegelreihe( wall_coords=dach_coords)

if 0:
    for i in range(0, hausTiefe*2):
        dach_curve_coords = []
        dach_curve_coords.append([0, i*BrickDepth, hausHoehe*BrickHight])
        dach_curve_coords.append([hausLaenge*BrickLength+BrickLength/2, i*BrickDepth, hausHoehe*BrickHight]) # halber Ziegel am ende
        dach_curve = rs.AddCurve(dach_curve_coords, 1)
        anzahl_bricks = int( rs.CurveLength(dach_curve) / BrickLength )
        dach_coords = rs.DivideCurve( dach_curve, anzahl_bricks*2, 0) ### doppelte anzahl wg *halber ziegel*
        ziegelreihe = hausHoehe
        fenster = []
        make_ziegelreihe( wall_coords=dach_coords)
# Zaun

if 0: # Ziegel Zaun
    abstandHausLange = 4
    abstandHausTiefe = abstandHausLange
    zaunLaenge = hausLaenge + abstandHausLange * 2
    zaunTiefe = hausTiefe + abstandHausTiefe * 2
    zaunHoehe = 3

    p0 = [0, 0, 0] # wenn Start Punkt nicht 0,0,0 werden Ziegel falsch gezeichnet
    p1 = rs.VectorAdd(p0, [BrickLength*zaunLaenge, 0, 0])
    p2 = rs.VectorAdd(p1, [0, BrickLength*zaunTiefe, 0])
    p3 = rs.VectorAdd(p2, [-BrickLength*zaunLaenge, 0, 0])

    rs.MoveObjects(rs.AllObjects(), [abstandHausLange*BrickLength, abstandHausTiefe*BrickLength, 0]) # Alles umschieben um bei 0,0,0 zu zeichnen

    zaun_curve = rs.AddCurve( [p0, p1, p2, p3, p0], 1)
    anzahl_bricks = int( rs.CurveLength(zaun_curve) / BrickLength )
    dach_coords = rs.DivideCurve( zaun_curve, anzahl_bricks*2, 0) ### doppelte anzahl wg *halber ziegel*
    dach_coords.append(dach_coords[0]) ### weil isCurveClosed

    fensters = []

    for ziegelreihe in range(0, zaunHoehe):
        ziegel_coords = [rs.VectorAdd( cor, [0,0,BrickHight*ziegelreihe]) for cor in dach_coords]
        print ("reihe {} - start {}". format(ziegelreihe, ziegelreihe%2))
        make_ziegelreihe( wall_coords=ziegel_coords, start=(ziegelreihe+0)%2)
        
    rs.MoveObjects(rs.AllObjects(), [-abstandHausLange*BrickLength, -abstandHausTiefe*BrickLength, 0]) # Umschiebung rueckgaengig machen

# Lattenzaun
abstandHausLange = 4
abstandHausTiefe = abstandHausLange
zaunHoehe = 5

zaun_offset = 5

zaun_p0 = [-zaun_offset*BrickLength, -zaun_offset*BrickLength, 0]
zaun_p1 = [(hausLaenge+zaun_offset)*BrickLength, -zaun_offset*BrickLength, 0]
zaun_p2 = [(hausLaenge+zaun_offset)*BrickLength, (hausTiefe+zaun_offset)*BrickLength, 0]
zaun_p3 = [-zaun_offset*BrickLength, (hausTiefe+zaun_offset)*BrickLength, 0]

make_lattenzaun(zaunHoehe, zaun_p0, zaun_p1, zaun_p2, zaun_p3, zaun_offset)

############################
########## EOS / EndOfScript
rs.EnableRedraw(True)      ### 4_the_MACs
#dm.eDup()                 ### delete duplicate objects 
dm.printDisplay(state=True, scale=1000)
#dm.zA( 0.9 )
rs.CurrentLayer("Default")
print "done"