import rhinoscriptsyntax as rs import random as ran import flipped_classroom_lib as fc reload(fc) rs.DeleteObjects(rs.AllObjects()) ############################################################### # Your Panel functions... ############################################################### def my_panel(points, scale): #rs.AddSrfPt(points) # default face (P0,P1,P2,P3) = points # name points in quad list rs.AddLine(P0,P2) # make first diagonal line d_cen1 = rs.VectorDivide(rs.VectorAdd(P0,P2),2) # calculate center of first diagonal rs.AddPoint(d_cen1) # put point at first diagonal center rs.AddLine(P1,P3) # create second diagonal line d_cen2 = rs.VectorDivide(rs.VectorAdd(P1,P3),2) # calculate center of second diagonal rs.AddPoint(d_cen2) # put point at second diagonal center center_pt = rs.VectorDivide(rs.VectorAdd(d_cen1,d_cen2),2) # calculate center between diagonal center points rs.AddPoint(center_pt) # put point at true center point if not(rs.PointCompare(d_cen1,d_cen2)): # make sure the two center points are not identical rs.AddLine(d_cen1,d_cen2) # draw line between diagonal center points #prepare vectors for cross product to get normal vec1 = rs.VectorSubtract(P0, center_pt) vec2 = rs.VectorSubtract(center_pt, P3) normal = rs.VectorCrossProduct(vec1, vec2) #calculate face normal at true center point u_normal = rs.VectorUnitize(normal) #unitize this normal vector (length 1) su_normal = rs.VectorScale(u_normal, scale) #scale unitized normal vector normal_pt = rs.VectorAdd(center_pt, su_normal) # find point at tip of normal vector rs.AddPoint(normal_pt) # put point normal_pt rs.AddLine(center_pt, normal_pt) # line to show centered normal vector #create pyramid rs.AddSrfPt([P0, normal_pt, P1]) rs.AddSrfPt([P1, normal_pt, P2]) rs.AddSrfPt([P2, normal_pt, P3]) rs.AddSrfPt([P3, normal_pt, P0]) def my_panel_frame(points, scale, offset, scale1): (P0,P1,P2,P3) = points # name points in quad list d_cen1 = rs.VectorDivide(rs.VectorAdd(P0,P2),2) # calculate center of first diagonal d_cen2 = rs.VectorDivide(rs.VectorAdd(P1,P3),2) # calculate center of second diagonal center_pt = rs.VectorDivide(rs.VectorAdd(d_cen1,d_cen2),2) # calculate center between diagonal center points #prepare vectors for cross product to get normal vec1 = rs.VectorSubtract(P0, center_pt) vec2 = rs.VectorSubtract(center_pt, P3) normal = rs.VectorCrossProduct(vec1, vec2) #calculate face normal at true center point u_normal = rs.VectorUnitize(normal) #unitize this normal vector (length 1) su_normal = rs.VectorScale(u_normal, scale) #scale unitized normal vector normal_pt = rs.VectorAdd(center_pt, su_normal) # find point at tip of normal vector #rs.AddPoint(normal_pt) # put point normal_pt #rs.AddLine(center_pt, normal_pt) # line to show centered normal vector line1= rs.AddPolyline([P0,P1]) line2= rs.AddPolyline([P1,P2]) line3= rs.AddPolyline([P2,P3]) line4= rs.AddPolyline([P3,P0]) rad = 1.5 fillet1=rs.AddFilletCurve(line1,line2, radius=rad) fillet2=rs.AddFilletCurve(line2,line3, radius=rad) fillet3=rs.AddFilletCurve(line3,line4, radius=rad) fillet4=rs.AddFilletCurve(line4,line1, radius=rad) list1 = rs.CurveFilletPoints(line1,line2, radius=rad, return_points=True) list2 = rs.CurveFilletPoints(line2,line3, radius=rad, return_points=True) list3 = rs.CurveFilletPoints(line3,line4, radius=rad, return_points=True) list4 = rs.CurveFilletPoints(line4,line1, radius=rad, return_points=True) real1 = rs.AddPolyline([list4[1], list1[0]]) real2 = rs.AddPolyline([list1[1], list2[0]]) real3 = rs.AddPolyline([list2[1], list3[0]]) real4 = rs.AddPolyline([list3[1], list4[0]]) rs.DeleteObjects([line1,line2,line3,line4]) pline = rs.JoinCurves([real1,fillet1,real2,fillet2,real3,fillet3,real4,fillet4]) # make closed pline #linke rimline rimline2_vector= rs.VectorAdd(list1[1],list2[0]) rimline2_center=rs.VectorDivide(rimline2_vector,2) rimlinepoint2_1 = rs.VectorAdd(list2[0],rs.VectorScale(rs.VectorSubtract(list1[1],list2[0]),0.9)) rimlinepoint2_2 = rs.VectorAdd(rimline2_center,u_normal) rimlinepoint2_3 = rs.VectorAdd(list2[0],rs.VectorScale(rs.VectorSubtract(list1[1],list2[0]),0.1)) #rs.AddLine([0,0,0],rs.VectorSubtract(list1[1],list2[0])) rimline2 = rs.AddCurve([list1[1],rimlinepoint2_1,rimlinepoint2_2,rimlinepoint2_3,list2[0]], degree=3) #rechte rimline rimline4_vector= rs.VectorAdd(list3[1],list4[0]) rimline4_center=rs.VectorDivide(rimline4_vector,2) rimlinepoint4_1 = rs.VectorAdd(list3[1],rs.VectorScale(rs.VectorSubtract(list4[0],list3[1]),0.9)) rimlinepoint4_2 = rs.VectorAdd(rimline4_center,u_normal) rimlinepoint4_3 = rs.VectorAdd(list3[1],rs.VectorScale(rs.VectorSubtract(list4[0],list3[1]),0.1)) rimline4 = rs.AddCurve([list4[0],rimlinepoint4_1,rimlinepoint4_2,rimlinepoint4_3,list3[1]], degree=3) rim = rs.JoinCurves([real1,fillet1,rimline2,fillet2,real3,fillet3,rimline4,fillet4]) rs.MoveObject(rim,u_normal) #off_l = rs.OffsetCurve(pline, center_pt, offset, u_normal) off_l = rs.ScaleObject(pline, center_pt, [offset,offset,offset], copy=True) #s_points = rs.CurvePoints(off_l) #create front of frame rs.AddLoftSrf([pline, off_l]) bullaugenline2 = rs.AddCurve([list1[0],P1,rimline2_center,P2,list2[1]], degree=3) bullaugenline4 = rs.AddCurve([list3[0],P3,rimline4_center,P0,list4[1]], degree=3) bullauge_gross=rs.JoinCurves([real1,bullaugenline2,real3,bullaugenline4]) off_l_s = rs.CopyObject(bullauge_gross, su_normal) off_1_ss = rs.ScaleObject(off_l_s, center_pt, [scale1,scale1,scale1/1.3], copy=False) rs.RebuildCurve(off_1_ss, point_count=30) rs.AddLoftSrf([pline,rim]) rs.AddLoftSrf([rim,off_1_ss]) rs.AddLoftSrf([off_l,off_1_ss]) rs.DeleteObjects([rim,off_1_ss,off_l_s,off_l,rimline2,rimline4,pline,fillet1,fillet2,fillet3,fillet4,real1,real2,real3,real4,bullauge_gross,bullaugenline2,bullaugenline4]) # ss_points = rs.CurvePoints(off_l_s) # surface0=rs.AddSrfPt([ss_points[0], s_points[0],s_points[1], ss_points[1]]) # surface1=rs.AddSrfPt([ss_points[1], s_points[1],s_points[2], ss_points[2]]) # rs.AddSrfPt([ss_points[2], s_points[2],s_points[3], ss_points[3]]) # rs.AddSrfPt([ss_points[3], s_points[3],s_points[0], ss_points[0]]) # rs.AddSrfPt([P0, ss_points[0],ss_points[1], P1]) # rs.AddSrfPt([P1, ss_points[1],ss_points[2], P2]) # rs.AddSrfPt([P2, ss_points[2],ss_points[3], P3]) # rs.AddSrfPt([P3, ss_points[3],ss_points[0], P0]) ############################################################### rs.EnableRedraw(False) quad = [[0,0,0], [10,0,0], [10,0,12], [0,0,12]] quad = [[0,0,0], [12,0,0], [12,0,10], [0,0,10]] #quad = [[0,0,0], [10,4,0], [10,4,12], [0,0,12]] #quad = [[0,0,0], [10,0,0], [10,2,12], [0,2,12]] #quad = [[0,0,0], [10,0,0], [8,2,12], [2,2,12]] #quad = [[0,0,0], [10,2,0], [10,-2,12], [0,2,10]] result_list = fc.PEF_single_face(quad) #result_list = fc.PEF_face(10, 4, 12, 10, 0) #result_list = fc.PEF_face_w(7, 10, 8.0, 5.0, 30, 2.0) #result_list = fc.PEF_pantheon() p_list = result_list[0] # Pointlist, contains single points e_list = result_list[1] # Horizontal Edgelist, contains lists with two points ve_list = result_list[2] # Vertical Edgelist, contains lists with two points f_list = result_list[3] # Facelist, contans lists with four points (quads) zcol = result_list[4] # number of levels of faces xcol = result_list[5] # number of faces in one level print "there are " + str(len(p_list)) + " points and " + str(len(f_list)) + " faces on " + str(zcol) + " levels, "+str(xcol)+" per level!" if 1: for i in range(zcol): for j in range(xcol): points = f_list[i*xcol+j] scale = ran.uniform(4, 13) scale1 = ran.uniform(0.3, 0.5) my_panel_frame(f_list[i*xcol+j], scale, 0.8, scale1) #rs.AddSrfPt(f_list[i*xcol+j]) ############################################################################# # DOTS to explain the lists ############################################################################# if 0: # put a dot on each point and create a Point for i,pt in enumerate(p_list): rs.AddPoint(pt) cmd = "-Dot {} {} _Enter ".format(i,pt) rs.Command(cmd, False) if 0: # put a dot on each horizontal edge and create a line for i,e in enumerate(e_list): rs.AddLine(e[0],e[1]) cmd = "-Dot {} {} _Enter ".format(i,e[0]) rs.Command(cmd, False) if 0: # put a dot on each vertical edge and create a line for i,ve in enumerate(ve_list): rs.AddLine(ve[0],ve[1]) cmd = "-Dot {} {} _Enter ".format(i,ve[0]) rs.Command(cmd, False) if 0: # put a dot on each face and create a surface for i, quad in enumerate(f_list): rs.AddSrfPt(quad) cmd = "-Dot {} {} _Enter ".format(i,quad[0]) rs.Command(cmd, False) ############################################################################# # Some experiments with the lists ############################################################################# if 0: for i, quad in enumerate(f_list): if i%2: rs.AddSrfPt(quad) if 0: for i in range(zcol): for j in range(xcol): if (i+j)%2: rs.AddSrfPt(f_list[i*xcol+j]) if 0: # last row in pantheon ceiling is flat for i in range(zcol): for j in range(xcol): if i != zcol-1: points = f_list[i*xcol+j] scale = ran.uniform(0.5,8.5) my_panel(f_list[i*xcol+j], scale) else: rs.AddSrfPt(f_list[i*xcol+j]) if 0: for i in range(zcol): for j in range(xcol): points = f_list[i*xcol+j] (P0,P1,P2,P3) = points cpoints=[P0,P1,P2,P3,P0] plinea = rs.AddCurve(cpoints,2) plineb = rs.AddCurve(cpoints,3) #loftsurf = rs.AddLoftSrf([plinea, plineb]) rs.Command("-_Loft selid {} selid {} _Enter _Enter _Enter".format(plinea, plineb), False) loftsurf = rs.FirstObject() rs.OffsetSurface(loftsurf, .2, both_sides=True, create_solid=True) if 0: for line in e_list: mline = rs.AddLine(line[0], line[1]) rs.AddPipe(mline, 0, 0.3, cap=2) for line in ve_list: mline = rs.AddLine(line[0], line[1]) rs.AddPipe(mline, 0, 0.2, cap=2) rs.EnableRedraw(True)