import rhinoscriptsyntax as rs
import random as ran
import math

#cleanup and start from scratch
rs.DeleteObjects(rs.AllObjects())

rs.EnableRedraw(False)

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

#variables

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

#unit: meters

#optionals
three_dim=1         #on/off switch for the three dimensional pathway (if it is zero, the bridge is flat, if it is one, the bridge is three dimensional)   
glass=1             #if this is set to zero, there is no glass in the dome, if it is set to one, there is glass
floor=0             #switch for floor (takes a lot of time and computing power if the turns are high)


#variables for baseline (arc sequence)
z_var_max=7         #how much the z value varies, if the bridge is three dimensional (dont set too high, because it will distort the bridge)
z_var_min=0.05      #how much the z value varies (at minimum), if the bridge is three dimensional
turns=3             #how many times whole pavillon way curves/turns ("wendungen")
arc_length=30       #how long an arc is (combination of turns and arc length determine the length of the bridge)
up_downs=arc_length/2          #how many ups and downs there are in the pavillon way (not two many), in relation to the length of the curve/number of turns

perc=80             #how likely the points are to move up (how many of them move up, in percent) - important for random factor later

#variables for bridge
width=4             #width of bridge, also distance between columns (so the pavillons are square(ish))
thick=0.5           #thickness of bridge part
stripe=0.3          #thickness of the stripe outside of the column (should be set higher than the column radius)
length=1            #initialising variable
pod_len_o=1         #length of podest at start
pod_len=pod_len_o+0.25      #derived value for the length of the podest

#if the flow/offset produces distorted results, up the arc length or reduce the width

#variables for columns on top of the bridge
hgt=2.7             #height (distance between bridge floor and start of dome)
hel_th=0.05         #helix radius for the columns
hel_pip=0.08        #radius for piping the helices
base_th=0.15        #radius for base (gets lofted later)
base_hgt=0.15       #total height of the base of the column

#hel_th should be smaller than hel_pip (otherwise the helices are visible)

#variables for columns under the bridge
thick_col_max=0.20  #radius for cylindric column below bridge at the bottom
thick_col_min=0.15  #radius for cylindric column below bridge at the top
var_arc=0.5         #how low the arc below the bridge goes under the line
size_base_2=0.55    #how big the base of the column is (should be at least twice as big as thick_col_max)
base_hgt_2=0.5      #base height for the big column below
size_cap=0.55       #how big the top of the column is (at its maximum)
cap_hgt=1           #height for top of column (in total)
arc_col_thick=0.1   #thickness of the arcs below
arc_col_offs=0.1    #how far the arcs are set back
thresh=1            #threshold: how high the z-value at a certain point has to be to create columns under, should be higher than base_hgt-thick
threshold=thresh+arc_col_thick+thick    #derived value so the arc sits correctly
vis_arc=0.8         #value that determines how much of the arc is visible

#variables for domes
hgt_dome=2.5        #dome height (from bottom to peak in the middle)
arc_hgt=1.5         #arc on the side of the pavilion height (should be lower than hgt_dome)
pip_dome=0.05       #piping radius of the structural arcs in the dome
pip_dome_dec=0.03   #piping radius of the decorative curves in the dome
dome_top_hgt=0.5    #height of the top part of the dome
dome_top_rad=0.1    #maximum radius of the top part of the dome


#floor pattern (with leaves)
rows=260            #the longer the bridge is, the higher this has to be to achieve the same effect
cols=5              #the wider the bridge is, the higher this has to be to achieve the same effect
l_hgt=1             #initialising variable
l_width=1           #initialising variable
pip_floor=0.05      #pipe radius for floor pattern

#lists
pts=[]              #list for all the points for the bridge
inner_pts=[]        #list for the points on the inner curve
outer_pts=[]        #list for the points on the outer curve
cls=[]              #list for columns
bridge=[]           #list for bridge
domes=[]            #list for domes
flow_obj=[]         #list for all objects that are subjected to the flow command
leaves=[]           #list for all leaves (curves)
pattern=[]          #list for all leaves (pipes)
l_glass=[]          #list for glass surfaces
leaf1=[]            #list for wip leaves
leaf2=[]            #list for wip leaves 2

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

#functions

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

def make_box(insertion=[0,0,0],xsize=0.5,ysize=10,zsize=0.2):
    corners=[[0,0,0],[xsize,0,0],[xsize,ysize,0],[0,ysize,0],
               [0,0,zsize],[xsize,0,zsize],[xsize,ysize,zsize],[0,ysize,zsize]]
    box=rs.AddBox(corners)
    rs.MoveObject(box,insertion)
    return(box)

def create_baselines():
    global help_line
    global length
    global line
    global line_offs
    global inner1
    global inner2
    points=[]           #points for creating a polyline with the arc command
    for i in range(turns):
        points.append([0,i*arc_length,0])
    cmd="-_Polyline"
    for i in range(len(points)):
        cmd += " {},{},{} Mode=Arc".format(0,points[i][1],0)
    cmd+=" _Enter"
    rs.Command(cmd)
    #move some points of the line up a bit to create a 3d walkway
    line=rs.FirstObject()
    rs.RebuildCurve(line,degree=3,point_count=turns*3)      #rebuild curve with enough points to replicate the curve
    if three_dim==1:
        rs.EnableObjectGrips(line,enable=True)              #you cannot move the object grips with the moveobject command, you have to reassign a whole set of new grips
        grips=rs.ObjectGripLocations(line)                  #list for grips
        for i in range(int(up_downs)):                      #do this as many times as up_downs is set
            index=ran.choice(range(1,len(grips)-1))         #index for grips (random choice), except for the first and the last point
            ran1=ran.uniform(0,100)
            if ran1<perc:
                ran_move=ran.uniform(z_var_min,z_var_max)   #move randomly in a range
                move_vector=[0,0,ran_move]                  #vector for moving the grips up
                new_location=rs.PointAdd(grips[index],move_vector)
                rs.ObjectGripLocation(line,index,new_location)      #move grip to new location
        rs.EnableObjectGrips(line,enable=False)
        print ("three_dim was set to one, so the bridge is three dimensional")
    else:
        print ("three_dim was set to zero, so the bridge is flat")
    length=rs.CurveLength(line)
    help_line=rs.AddLine([0,0,0],[0,length,0])          #line for flow
    line_offs=rs.OffsetCurve(line,[1,0,0],width)        #offset 3d line
    inner1=rs.OffsetCurve(line,[1,0,0],stripe)          #line for columns and domes (corresponds with inner_pts)
    inner2=rs.OffsetCurve(line_offs,[-1,0,0],stripe)    #line for columns and domes (corresponds with outer_pts)

def create_leaf(base_point):                            #function for creating leaves (with multiple points, for the floor)
    pt1=rs.PointAdd(base_point,(-l_width/2,0))          #left pt
    pt2=rs.PointAdd(base_point,(0,l_hgt/2))             #top
    pt3=rs.PointAdd(base_point,(l_width/2,0))           #right pt
    pt4=rs.PointAdd(base_point,(0,-l_hgt/2))            #bottom pt
    top_curve=rs.AddCurve([pt1,pt2,pt3])
    bottom_curve=rs.AddCurve([pt3,pt4,pt1])
    leaf=rs.JoinCurves([top_curve,bottom_curve],delete_input=True)
    return leaf

def create_floor_pattern():             #floor pattern with flow command
    leaves=[]
    l_hgt=length/rows                   #calculate height so it fits
    l_width=(width-stripe*2)/cols       #calculate width so it fits
    for i in range(rows):
        for j in range(cols):
            center_x=j*l_width
            center_y=i*l_hgt
            base_point=[center_x,center_y,0]
            leaf=create_leaf(base_point)
            if i%2:
                leaf1.append(leaf)
            else:
                leaf2.append(leaf)
    rs.MoveObjects(leaf1,[0,-l_hgt/4,0])        #move a bit so the leaves intersect
    leaves=leaf1+leaf2
    rs.MoveObjects(leaves,[stripe+l_width/2,0,-pip_floor/2])
    for i in range(len(leaves)):                #flow along the curve, then pipe
        rs.Command("_Flow _SelID {} _Enter Roadlike=Yes Copy=No _SelID {} _SelID {} 0,0,0 0,0,1 _Enter".format(leaves[i][0],help_line,line),False)
        rs.AddPipe(rs.FirstObject(),0,pip_floor)
    return(leaves)

def column(pt):
    plane=rs.AddPlaneSurface(rs.WorldXYPlane(),100,100)     #plane for splitting the columns later
    rs.ScaleObject(plane,[50,50,0],[5,5,0])
    spirals=[]                                              #list for base spirals
    sp1=rs.AddSpiral([pt[0],pt[1],hgt],pt,1.5,8,hel_th)
    sp2=rs.RotateObject(sp1,pt,120,copy=True)
    sp3=rs.RotateObject(sp2,pt,120,copy=True)
    spirals.extend([sp1,sp2,sp3])
    for sp in spirals:
        pipe=rs.AddPipe(sp,parameters=[0,1],radii=[hel_pip,hel_pip],cap=1)
        if pipe:
            cls.append(pipe)
    for cl in cls:
        if rs.IsBrep(cl):                                           #check if the object is a brep (otherwise it will not split)
            result=rs.SplitBrep(cl,plane,delete_input=True)         #split columns in half at z=0
            if result:
                cls.extend(result)
    for obj in cls:
            if rs.IsObject(obj):
                bbox=rs.BoundingBox(obj)
                min_z=min(pt[2] for pt in bbox)
                if min_z < (-thick-0.01):                           #check if parts of cls are below 0
                    rs.DeleteObject(obj)                            #delete parts below zero
    rs.DeleteObject(plane)
    return [obj for obj in cls if rs.IsObject(obj)]
    #checks all the objects if they are an object
    #some part of the cls list are not object, i have not found the reason why
    #it was too complicated to create a helix with a specific height (mathematical function required)- so i cut the columns in half at the XY Plane

def column_base(pt):        #base for the columns on top of the bridge
    circle=rs.AddCircle(pt,base_th)
    circle2=rs.MoveObject(rs.ScaleObject(circle,pt,[1.2,1.2,0],copy=True),[0,0,base_hgt/4])
    crcls=[]
    crcls.append(circle)
    crcls.append(circle2)
    crcls.append(rs.CopyObject(circle,[0,0,base_hgt/2]))
    crcls.append(rs.CopyObject(circle2,[0,0,base_hgt/2]))
    crcls.append(rs.CopyObject(circle,[0,0,base_hgt]))
    srf=rs.AddLoftSrf(crcls)
    rs.CapPlanarHoles(srf)
    return(srf)

def make_clover(p_num=8,total_radius=width,max_diameter=width,angle=90,base_point=[0,0,0]):
    #function for creating lines for the dome (from flipped_classroom_lib)
    arc_radius=total_radius/(2*math.sin(math.radians(angle/2)))       #calculate the arc radius
    total_diameter=arc_radius*2
    if total_diameter>max_diameter:         #check if total diameter exceeds max diameter
        arc_radius=max_diameter/2           #if it does, make it smaller
    c_points=[]
    cur_angle=0                             #angle starts at zero
    for i in range(p_num):
        next_point=rs.VectorRotate([arc_radius,0,0],cur_angle,[0,0,1])
        cur_angle=angle+cur_angle
        next_point=[next_point[0]+base_point[0],next_point[1]+base_point[1],next_point[2]+base_point[2]]
        c_points.append(next_point)
    c_points.append(c_points[0])        #close pattern by adding first point again as last point
    cmd="-_Polyline"
    for i in range(len(c_points)):
        cmd+= " {},{},{} Mode=Arc".format(c_points[i][0], c_points[i][1], c_points[i][2])
    cmd+=" _Enter"
    rs.Command(cmd, False)
    curve=rs.FirstObject(False)
    return curve

def create_dome_top(pt):        #for creating the tiny detail on top of the dome, randomised outline with randomised radii of the circles
    lofts=[]                    #list for circles for lofting later
    radii=list(range(3,10))
    pts=rs.DivideCurve(rs.AddLine(pt,[pt[0],pt[1],pt[2]+dome_top_hgt]),12)          #divide curve for how many circles we need
    for i in range(len(pts)):
        if i==0:                #add one very big radius circle
            lofts.append(rs.AddCircle(pts[i],dome_top_rad))
        if i<len(pts)-5 and not i==0:
            lofts.append((rs.AddCircle(pts[i],ran.choice(radii)/100)))
        if i>len(pts)-3:        #make the top thin
            lofts.append(rs.AddCircle(pts[i],0.01))
    srf=rs.AddLoftSrf(lofts)
    rs.CapPlanarHoles(srf)
    rs.MoveObject(srf,[0,0,hgt])
    return(srf)

def dome():
    domes=[]                    #list with domes
    pipe_obj_pav=[]             #list with curves and arcs that get projected from above onto the surface
    decs=[]                     #decorational lines for dome
    decs_pip=[]                 #decorational lines that come out of the project function
    for i in range(len(inner_pts)-1):               #make lines for the center of the pavilion
        arcs=[]                                     #list with arcs for the sides
        #make lines connecting the points (3d)
        l1=rs.AddLine(inner_pts[i],outer_pts[i+1])
        l2=rs.AddLine(inner_pts[i+1],outer_pts[i])
        #make flat lines connecting the points (2d)
        fl_l1=rs.AddLine([inner_pts[i][0],inner_pts[i][1],0],[outer_pts[i+1][0],outer_pts[i+1][1],0])   #flat version of l1
        fl_l2=rs.AddLine([inner_pts[i+1][0],inner_pts[i+1][1],0],[outer_pts[i][0],outer_pts[i][1],0])   #flat version of l2
        #calculate arc points on the inner side of the dome
        arc_point_inner=rs.VectorDivide(rs.VectorAdd(inner_pts[i],inner_pts[i+1]),2)
        arc_point_inner[2]+=arc_hgt
        #calculate arc points on the outer side of the dome
        arc_point_outer=rs.VectorDivide(rs.VectorAdd(outer_pts[i],outer_pts[i+1]),2)
        arc_point_outer[2]+=arc_hgt
        #calculate arc points on the front side of the dome
        arc_point_front=rs.VectorDivide(rs.VectorAdd(inner_pts[i],outer_pts[i]),2)
        arc_point_front[2]+=arc_hgt
        #calculate arc points on the front side of the dome
        arc_point_back=rs.VectorDivide(rs.VectorAdd(inner_pts[i+1],outer_pts[i+1]),2)
        arc_point_back[2]+=arc_hgt
        #make arcs (structural)
        a1=rs.AddArc3Pt(inner_pts[i],inner_pts[i+1],arc_point_inner)        #arc on the inner side of the bridge
        a2=rs.AddArc3Pt(outer_pts[i],outer_pts[i+1],arc_point_outer)        #arc on the outer side of the bridge
        a3=rs.AddArc3Pt(inner_pts[i],outer_pts[i],arc_point_front)          #arc on the front side of the bridge
        a4=rs.AddArc3Pt(inner_pts[i+1],outer_pts[i+1],arc_point_back)       #arc on the back side of the bridge
        arcs.extend([a1,a2,a3,a4])
        #find the middle of the pavillon on the floor
        point=rs.CurveCurveIntersection(fl_l1,fl_l2)[0][1]      #middle of pavillon (on the floor)
        #find the 3d version of the middle
        intersect_line=rs.AddLine(point,[point[0],point[1],hgt*2+z_var_max])   #line from floor up crossing both l1 and l2
        pt=rs.CurveCurveIntersection(intersect_line,l2)[0][1]                  #intersecting the vertical line with l2 to get the middle
        rs.DeleteObject(intersect_line)
        #make a line for the top point of the dome (before moving everything up)
        hgt_line=rs.AddLine([pt[0],pt[1],pt[2]+hgt],[pt[0],pt[1],pt[2]+hgt_dome])
        top_dome=rs.CurvePoints(hgt_line)[-1]                   #upper most point of the dome
        create_dome_top(pt=top_dome)
        rs.DeleteObject(hgt_line)
        if i<len(inner_pts)-1:          
            #add diagonal arcs
            a5=rs.AddArc3Pt(rs.ArcMidPoint(a1),rs.ArcMidPoint(a2),top_dome)
            a6=rs.AddArc3Pt(inner_pts[i],outer_pts[i+1],top_dome)
            a7=rs.AddArc3Pt(inner_pts[i+1],outer_pts[i],top_dome)
            #add random lines for decoration in the top
            cl1=make_clover(base_point=top_dome)
            cl2=make_clover(p_num=3,total_radius=width/2,max_diameter=width,angle=90,base_point=top_dome)
            for i in range(6):
                cl3=rs.RotateObject(cl2,top_dome,60*i,copy=True)
                decs.append(cl3)
            cl4=make_clover(p_num=5,total_radius=width/2,max_diameter=width/2,angle=90,base_point=top_dome)
            cl5=make_clover(p_num=5,total_radius=width*0.9,max_diameter=width,angle=120,base_point=top_dome)
            arcs.extend([a5,a6,a7])
            decs.extend([cl1,cl2,cl4,cl5])
        #move everything up
        for a in arcs:
            rs.MoveObject(a,[0,0,hgt])
        srf=rs.AddSweep2([a1,a2],[a3,a4,a5])        #add surface for projecting onto later/and glass
        l_glass.append(srf)                         #add surface to list (for putting on a separate layer later)
        rs.MoveObjects([a6,a7],[0,0,hgt])
        pipe_obj_pav.extend([a1,a2,a3,a4,a5])
        pipe_obj_pav.extend(rs.ProjectCurveToSurface([a6,a7],srf,[0,0,-1]))         #project diagonal arcs
        rs.DeleteObjects([a6,a7])                   #delete the lines so they dont get piped later
        decs_pip.extend(rs.ProjectCurveToSurface(decs,srf,[0,0,-1]))        #project decorational lines
        if glass==0:
            rs.DeleteObject(srf)
    for obj in pipe_obj_pav:                    #add pipe to all the arcs
        rs.AddPipe(obj,0,pip_dome)
    for obj in decs_pip:                        #add pipe to all the decorational lines
        rs.AddPipe(obj,0,pip_dome_dec)
    rs.Command("_SelDup _Enter")                #delete duplicates
    rs.DeleteObjects(rs.SelectedObjects())

def find_midpoint_on_crv(crv,pt1,pt2):          #find the middle between two points on a curve
    param1=rs.CurveClosestPoint(crv,pt1)
    param2=rs.CurveClosestPoint(crv,pt2)
    mid_param=(param1+param2)/2                 #find middle (math) - puts out parameter
    midpoint=rs.EvaluateCurve(crv,mid_param)    #find corresponding point to parameter
    return midpoint

def create_big_column(line,pt):                 #create base for big column
    param=rs.CurveClosestPoint(line,pt)
    normal=rs.CurveTangent(line,param)          #find tangent of point
    t_angle=rs.Angle([0,0,0],normal)[0]         #find angle of tangent
    #make bottom part of column
    box=make_box(insertion=pt,xsize=size_base_2,ysize=size_base_2,zsize=base_hgt_2)
    rs.MoveObject(box,(-size_base_2/2,-size_base_2/2,-pt[2]))
    #make top part of column (consists of two parts
    box2=make_box(insertion=pt,xsize=size_cap,ysize=size_cap,zsize=cap_hgt/2+thick/4)
    rs.MoveObject(box2,(-size_cap/2,-size_cap/2,-cap_hgt/2-thick))
    box3=make_box(insertion=pt,xsize=size_cap*0.8,ysize=size_cap*0.8,zsize=cap_hgt/4+thick/4)
    rs.MoveObject(box3,(-size_cap*0.8/2,-size_cap*0.8/2,-cap_hgt/3*2-thick))
    #align boxes
    rs.RotateObject(box,pt,t_angle-90,[0,0,1])
    rs.RotateObject(box2,pt,t_angle-90,[0,0,1])
    rs.RotateObject(box3,pt,t_angle-90,[0,0,1])

def create_base():          #create base for bridge
    global base
    base=make_box(xsize=width,ysize=length,zsize=-thick)        #base object for bridge
    flow_obj.append(base)

def flow():
    for i in range(len(flow_obj)):
        rs.Command("_Flow _SelID {} _Enter Roadlike=Yes Copy=No _SelID {} _SelID {} 0,0,0 0,0,1 _Enter".format(flow_obj[i],help_line,line),False)

def make_bridge():          #main function for creating the bridge
    global bridge
    arc_cols=[]
    create_baselines()
    bridge=create_base()
    if floor==1:
        create_floor_pattern()
    flow()
    #make block for column and base
    cl=column(pt=[0,0,0])               #base object for block for column
    bas=column_base(pt=[0,0,-0.05])     #base object for block for base for column
    #move down column base by a bit, because if the angle is too steep, this
    block_column=rs.AddBlock(cl,[0,0,0],"block_column")
    rs.DeleteObjects(cl)                #delete base object
    block_base=rs.AddBlock(bas,[0,0,0],"block_base")
    rs.DeleteObjects(bas)               #delete base object
    #derived values for bridge
    num_dec=length/width        #length divided by width gets the total number (with some decimal points)
    num_tot=int(num_dec)        #round down the number (so we get an integer)
    pav_length=length/num_dec   #divide length by num_tot so we get a new length
    inner_pts.extend(rs.DivideCurve(inner1,num_tot,create_points=True))
    for p in inner_pts:         #add lines from the inner line to the outer line, so we get proper points
        param=rs.CurveClosestPoint(inner1,p)
        normal=rs.CurveTangent(inner1,param)    #find tangent of point
        t_angle=rs.Angle([0,0,0],normal)[0]     #find angle of tangent
        w_line=rs.AddLine(p,[p[0]+width-2*stripe,p[1],p[2]])
        rs.RotateObject(w_line,p,t_angle-90,[0,0,1])
        outer_pts.append(rs.CurvePoints(w_line)[1])
        if p[2]>threshold:      #if the z value of the point exceeds the threshold: create the base for the big column (has to be aligned)
            create_big_column(line=inner1,pt=p)
    for p in outer_pts:         #create big columns below for outer line
        if p[2]>threshold:
            create_big_column(line=inner2,pt=p)
    for i in range(len(outer_pts)-1):               #create arcs for points that are high, also columns and bases
        if outer_pts[i][2]>threshold:
            midpoint=find_midpoint_on_crv(crv=inner2,pt1=outer_pts[i],pt2=outer_pts[i+1])       #find the middle between two points (so we can place the arc properly)
            rs.AddPoint(midpoint)
            if outer_pts[i+1][2]<threshold:
                pass
            else:
                #add arc for below the bridge
                arc_col=rs.AddArc3Pt([outer_pts[i][0],outer_pts[i][1],outer_pts[i][2]-var_arc],[outer_pts[i+1][0],outer_pts[i+1][1],outer_pts[i+1][2]-var_arc],midpoint)
                param=rs.CurveClosestPoint(inner2,outer_pts[i])
                normal=rs.CurveTangent(inner2,param)        #find tangent of point
                t_angle=rs.Angle([0,0,0],normal)[0]         #find angle of tangent
                #make line normal to guideline, so we can extrude the arc properly
                w_line=rs.AddLine(outer_pts[i],[outer_pts[i][0]+stripe-arc_col_offs,outer_pts[i][1],outer_pts[i][2]])
                rs.RotateObject(w_line,outer_pts[i],t_angle-90,[0,0,1])
                srf=rs.ExtrudeCurve(arc_col,w_line)
                vector=rs.VectorCreate(rs.CurveEndPoint(w_line),rs.CurveStartPoint(w_line))
                srf2=rs.CopyObject(srf,-vector) #make the arc wider
                #line for extruding
                extr_line=rs.AddLine([outer_pts[i][0],outer_pts[i][1],outer_pts[i][2]-var_arc],[outer_pts[i][0],outer_pts[i][1],outer_pts[i][2]-var_arc-arc_col_thick-thick*vis_arc])
                rs.ExtrudeSurface(srf,extr_line)        #extrude arcs
                rs.ExtrudeSurface(srf2,extr_line)
                arc_cols.append(arc_col)
        if inner_pts[i][2]>threshold:
            midpoint2=find_midpoint_on_crv(crv=inner1,pt1=inner_pts[i],pt2=inner_pts[i+1])
            rs.AddPoint(midpoint2)
            if inner_pts[i+1][2]<threshold:
                pass
            else:
                #add arc for below the bridge
                arc_col=rs.AddArc3Pt([inner_pts[i][0],inner_pts[i][1],inner_pts[i][2]-var_arc],[inner_pts[i+1][0],inner_pts[i+1][1],inner_pts[i+1][2]-var_arc],midpoint2)
                param=rs.CurveClosestPoint(inner1,inner_pts[i])
                normal=rs.CurveTangent(inner1,param)        #find tangent of point
                t_angle=rs.Angle([0,0,0],normal)[0]         #find angle of tangent
                #make line normal to guideline, so we can extrude the arc properly
                w_line=rs.AddLine(inner_pts[i],[inner_pts[i][0]+stripe-arc_col_offs,inner_pts[i][1],inner_pts[i][2]])
                rs.RotateObject(w_line,inner_pts[i],t_angle-90,[0,0,1])
                srf=rs.ExtrudeCurve(arc_col,w_line)
                vector=rs.VectorCreate(rs.CurveEndPoint(w_line),rs.CurveStartPoint(w_line))
                srf2=rs.CopyObject(srf,-vector) #make the arc wider
                #line for extruding
                extr_line=rs.AddLine([inner_pts[i][0],inner_pts[i][1],inner_pts[i][2]-var_arc],[inner_pts[i][0],inner_pts[i][1],inner_pts[i][2]-var_arc-arc_col_thick-thick*vis_arc])
                rs.ExtrudeSurface(srf,extr_line)
                rs.ExtrudeSurface(srf2,extr_line)
                arc_cols.append(arc_col)
    pts=inner_pts+outer_pts
    for pt in pts:
        rs.InsertBlock(block_column,pt,scale=(1,1,1),angle_degrees=0,rotation_normal=(0,0,1))
        bs=rs.InsertBlock(block_base,pt,scale=(1,1,1),angle_degrees=0,rotation_normal=(0,0,1))
        rs.CopyObject(bs,[0,0,hgt-base_hgt/2])
        if pt[2]>threshold:     #add cylindric column at the base (below the bridge)
            cyl=rs.AddLine([pt[0],pt[1],0],[pt[0],pt[1],pt[2]-thick/2])
            c1=rs.AddCircle(rs.CurveStartPoint(cyl),thick_col_max)
            c2=rs.AddCircle(rs.CurveEndPoint(cyl),thick_col_min)
            srf=rs.AddLoftSrf([c1,c2])
            rs.CapPlanarHoles(srf)
    for i in range(len(pts)):
        if i==0:        #create podest for start
            box=make_box(insertion=pts[i],xsize=pod_len,ysize=width,zsize=thick)
            rs.MoveObject(box,[-pod_len+0.25,-width+stripe,-thick])
    dome()

make_bridge()

#layer for glass (everything else stays on default)
if glass==1:
    rs.AddLayer("glass")
    rs.LayerColor("glass",(255,255,0))
    rs.ObjectLayer(l_glass,"glass")

#cleanup

#delete all curves, points and duplicatese
rs.Command("_SelCrv _Enter")
rs.Command("_Selpt _Enter")
rs.Command("_SelDup _Enter")
rs.DeleteObjects(rs.SelectedObjects())

rs.EnableRedraw(True)