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 normales_bullauge(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]) outline = rs.JoinCurves([line2,line3,line4,line1]) 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]) preline = rs.JoinCurves([real1,fillet1,real2,fillet2,real3,fillet3,real4,fillet4]) # make closed pline pline = rs.ScaleObject(preline, center_pt, [0.9,0.9,0.9], copy=False) #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) prerim = rs.JoinCurves([real1,fillet1,rimline2,fillet2,real3,fillet3,rimline4,fillet4]) rim = rs.ScaleObject(prerim, center_pt, [0.9,0.9,0.9], copy=False) 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([off_l,pline]) rs.AddLoftSrf([outline,pline]) 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]) rotate =ran.randint(-20,20) form = rs.XformRotation2(rotate, [1,0,0],[0,0,0]) vectorial=rs.VectorTransform(su_normal, form) scheibe = rs.CopyObject(bullauge_gross, rs.VectorScale(vectorial, 0.7)) scheibe = rs.ScaleObject(scheibe, center_pt, [scale1,scale1,scale1/1.3], copy=False) off_l_s = rs.CopyObject(bullauge_gross, vectorial) 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([scheibe,off_1_ss]) rs.AddLoftSrf([off_l,scheibe]) 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,outline]) def links_bullauge(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]) outline= rs.JoinCurves([line1,line4,line3]) 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], P1]) real2 = rs.AddPolyline([list1[1], list2[0]]) real3 = rs.AddPolyline([P2, list3[0]]) real4 = rs.AddPolyline([list3[1], list4[0]]) rs.DeleteObjects([line1,line2,line3,line4]) preline = rs.JoinCurves([real1,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) prerim = rs.JoinCurves([real1,real3,fillet3,rimline4,fillet4]) rim = rs.ScaleObject(prerim, rimline2_center, [0.95,0.9,0.9], copy=False) rs.MoveObject(rim,u_normal) pline = rs.ScaleObject(preline, rimline2_center, [0.95,0.9,0.9], copy=False) #off_l = rs.OffsetCurve(pline, center_pt, offset, u_normal) off_l = rs.ScaleObject(pline, rimline2_center, [offset,offset,offset], copy=True) #s_points = rs.CurvePoints(off_l) #create front of frame rs.AddLoftSrf([pline, off_l]) rs.AddLoftSrf([outline,pline]) 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,real3,bullaugenline4]) scheibe = rs.CopyObject(bullauge_gross, rs.VectorScale(su_normal, 0.7)) scheibe = rs.ScaleObject(scheibe, rimline2_center, [scale1,scale1,scale1/1.3], copy=False) off_l_s = rs.CopyObject(bullauge_gross, su_normal) off_1_ss = rs.ScaleObject(off_l_s, rimline2_center, [scale1,scale1,scale1/1.3], copy=False) readout=rs.CurvePointCount(off_1_ss) #rs.SelectObject(rim) print(readout) #rs.RebuildCurve(off_1_ss, point_count=30) rs.AddLoftSrf([pline,rim]) rs.AddLoftSrf([rim,off_1_ss]) rs.AddLoftSrf([scheibe,off_1_ss]) rs.AddLoftSrf([off_l,scheibe]) 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,outline]) def rechts_bullauge(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]) outline= rs.JoinCurves([line1,line2,line3]) 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([P0, list1[0]]) real2 = rs.AddPolyline([list1[1], list2[0]]) real3 = rs.AddPolyline([list2[1], P3]) real4 = rs.AddPolyline([list3[1], list4[0]]) rs.DeleteObjects([line1,line2,line3,line4]) preline = rs.JoinCurves([real1,fillet1,real2,fillet2,real3,]) # 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) prerim = rs.JoinCurves([real1,fillet1,rimline2,fillet2,real3]) rim = rs.ScaleObject(prerim, rimline4_center, [0.95,0.9,0.9], copy=False) rs.MoveObject(rim,u_normal) pline = rs.ScaleObject(preline, rimline4_center, [0.95,0.9,0.9], copy=False) #off_l = rs.OffsetCurve(pline, center_pt, offset, u_normal) off_l = rs.ScaleObject(pline, rimline4_center, [offset,offset,offset], copy=True) #s_points = rs.CurvePoints(off_l) #create front of frame rs.AddLoftSrf([pline, off_l]) rs.AddLoftSrf([outline,pline]) 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]) scheibe = rs.CopyObject(bullauge_gross, rs.VectorScale(su_normal, 0.7)) scheibe = rs.ScaleObject(scheibe, rimline4_center, [scale1,scale1,scale1/1.3], copy=False) off_l_s = rs.CopyObject(bullauge_gross, su_normal) off_1_ss = rs.ScaleObject(off_l_s, rimline4_center, [scale1,scale1,scale1/1.3], copy=False) readout=rs.CurvePointCount(off_1_ss) #rs.SelectObject(rim) print(readout) #rs.RebuildCurve(off_1_ss, point_count=30) rs.AddLoftSrf([pline,rim]) rs.AddLoftSrf([rim,off_1_ss]) rs.AddLoftSrf([scheibe,off_1_ss]) rs.AddLoftSrf([off_l,scheibe]) rs.DeleteObjects([rim,off_1_ss,off_l_s,off_l,rimline2,rimline4,pline,fillet1,fillet2,fillet3,fillet4,real1,real2,real3,real4,bullaugenline2,bullaugenline4,bullauge_gross,outline]) ############################################################### def dach_bullauge(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 center_line3 = rs.VectorDivide(rs.VectorAdd(P2,P3),2) cen3= rs.VectorDivide(rs.VectorAdd(P0,rs.VectorAdd(P2,rs.VectorReverse(su_normal))),2) cen4=rs.VectorDivide(rs.VectorAdd(P1,rs.VectorAdd(P3,rs.VectorReverse(su_normal))),2) centerio=rs.VectorDivide(rs.VectorAdd(cen3,cen4),2) vec3=rs.VectorSubtract(P0, centerio) vec4=rs.VectorSubtract(rs.VectorAdd(P3,rs.VectorReverse(su_normal)),centerio) true_normal=rs.VectorCrossProduct(vec3, vec4) u_true_normal=rs.VectorUnitize(true_normal) reverse_u_true_normal=rs.VectorReverse(u_true_normal) su_true_normal=rs.VectorScale(u_true_normal, scale) reverse_su_true_normal=rs.VectorReverse(su_true_normal) line1= rs.AddPolyline([P0,P1]) line2= rs.AddPolyline([P1,P2]) line3= rs.AddPolyline([P2,P3])# line4= rs.AddPolyline([P3,P0]) line5= rs.AddPolyline([P3,rs.VectorAdd(P3,rs.VectorReverse(su_normal))]) line6= rs.AddPolyline([P2,rs.VectorAdd(P2,rs.VectorReverse(su_normal))]) line7= rs.AddPolyline([rs.VectorAdd(P3,rs.VectorReverse(su_normal)),rs.VectorAdd(P2,rs.VectorReverse(su_normal))]) #outline = rs.JoinCurves([line2,line3,line4,line1]) #line3 cancelled 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) fillet5=rs.AddFilletCurve(line4,line5, radius=rad) fillet6=rs.AddFilletCurve(line2,line6, radius=rad) fillet7=rs.AddFilletCurve(line6,line7, radius=rad) fillet8=rs.AddFilletCurve(line7,line5, 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) list5 = rs.CurveFilletPoints(line4,line5, radius=rad, return_points=True) list6 = rs.CurveFilletPoints(line2,line6, radius=rad, return_points=True) list7 = rs.CurveFilletPoints(line6,line7, radius=rad, return_points=True) list8 = rs.CurveFilletPoints(line7,line5, 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]]) real5 = rs.AddPolyline([list6[1],rs.VectorAdd(P2,rs.VectorReverse(su_normal))]) real6 = rs.AddPolyline([list5[1],rs.VectorAdd(P3,rs.VectorReverse(su_normal))]) real7 = rs.AddPolyline([P0,list5[0]]) real8 = rs.AddPolyline([P1,list6[0]]) real9 = rs.AddPolyline([list6[0],list1[1]]) real10 = rs.AddPolyline([list5[0],list4[0]]) real11 = rs.AddPolyline([list6[1],list7[0]]) real12 = rs.AddPolyline([list8[1],list5[1]]) real13 = rs.AddPolyline([list8[0],list7[1]]) #outerline = rs. outline = rs.JoinCurves([line1,real8,fillet6,real5,line7,real6,fillet5,real7]) preline = rs.JoinCurves([fillet6,real11,fillet7,real13,fillet8,real12,fillet5,real10,fillet4,real1,fillet1,real9]) # make closed pline pline = rs.ScaleObject(preline, center_line3, [0.9,0.9,0.9], copy=False) rs.CurveDirectionsMatch(pline,outline) #print(outline) #rs.SelectObject([outline[0]]) # crv1 = rs.JoinCurves([real8,fillet6,real5]) # crv2 = rs.JoinCurves([real6,fillet5,real7]) # rs.AddSweep2([crv1,crv2],[line7]) rs.DeleteObjects([line1,line2,line3,line4,line5,line6]) #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) #rs.OffsetCurve(pline, [0,-1,1], 1) #prerim = rs.JoinCurves([real1,fillet1,rimline2,fillet2,real3,fillet3,rimline4,fillet4]) rim = rs.ScaleObject(pline, center_line3, [0.9,0.9,0.9], copy=True) rs.MoveObject(rim,reverse_u_true_normal) #off_l = rs.OffsetCurve(pline, center_pt, offset, u_normal) off_l = rs.ScaleObject(pline, center_line3, [offset,offset,offset], copy=True) #s_points = rs.CurvePoints(off_l) #create front of frame rs.AddLoftSrf([off_l,pline]) rs.AddLoftSrf([pline,outline]) #rs.AddLine(P0,reverse_su_true_normal) 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]) rotate =45 form = rs.XformRotation2(rotate, [1,0,0],[0,0,0]) vectorial=rs.VectorTransform(reverse_su_true_normal, form) scheibe = rs.CopyObject(pline, rs.VectorScale(reverse_su_true_normal, 0.7)) scheibe = rs.ScaleObject(scheibe, center_line3, [scale1,scale1,scale1/1.3], copy=False) off_l_s = rs.CopyObject(pline, reverse_su_true_normal) off_1_ss = rs.ScaleObject(off_l_s, center_line3, [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([scheibe,off_1_ss]) rs.AddLoftSrf([off_l,scheibe]) rs.DeleteObjects([rim,off_1_ss,off_l_s,off_l,rimline2,rimline4,pline,fillet1,fillet2,fillet3,fillet4,fillet5,fillet6,fillet7,fillet8,real1,real2,real3,real4,real5,real6,real7,real8,real9,real10,real11,real12,real13,bullauge_gross,bullaugenline2,bullaugenline4,outline,line5,line6,line7]) def erdgeschoss(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 cen1 = rs.VectorDivide(rs.VectorAdd(P0,P1),2) cen2 = rs.VectorDivide(rs.VectorAdd(P2,P3),2) line1= rs.AddPolyline([P0,P1]) line1_1=rs.AddPolyline([P0,cen1]) line1_2=rs.AddPolyline([cen1,P1]) line2= rs.AddPolyline([P1,P2]) line3= rs.AddPolyline([P2,P3]) line3_1=rs.AddPolyline([P2,cen2]) line3_2=rs.AddPolyline([cen2,P3]) line4= rs.AddPolyline([P3,P0]) line5= rs.AddPolyline([cen1,cen2]) l_cen1 = rs.VectorDivide(rs.VectorAdd(P0,cen2),2) # calculate center of first diagonal l_cen2 = rs.VectorDivide(rs.VectorAdd(cen1,P3),2) # calculate center of second diagonal center_left = rs.VectorDivide(rs.VectorAdd(l_cen1,l_cen2),2) # calculate center between diagonal center points r_cen1 = rs.VectorDivide(rs.VectorAdd(P1,cen2),2) # calculate center of first diagonal r_cen2 = rs.VectorDivide(rs.VectorAdd(cen1,P2),2) # calculate center of second diagonal center_right = rs.VectorDivide(rs.VectorAdd(r_cen1,r_cen2),2) # calculate center between diagonal center points left = rs.JoinCurves([line1_1,line5,line3_2,line4]) right= rs.JoinCurves([line1_2,line5,line3_1,line2]) left_s = rs.ScaleObject(left, center_left, [0.9,0.9,0.9], copy=True) right_s = rs.ScaleObject(right, center_right, [0.9,0.9,0.9], copy=True) rs.AddLoftSrf([left,left_s]) rs.AddLoftSrf([right,right_s]) rs.DeleteObjects([line1,line1_1,line1_2,line2,line3,line3_1,line3_2,line4,line5,left,right,left_s,right_s]) 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(7, 5, 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 0: for i in range(zcol): for j in range(xcol): points = f_list[i*xcol+j] scale = 5 scale1 = 0.7 erdgeschoss(f_list[i*xcol+j], scale, 0.7, scale1) if 1: for i in range(zcol): for j in range(xcol): points = f_list[i*xcol+j] scale = 5 scale1 = 0.6 if i==0: erdgeschoss(f_list[i*xcol+j], scale, 0.7, scale1) if i==1 and j==0: normales_bullauge(f_list[i*xcol+j], ran.uniform(2, 8), 0.7, scale1) if i==1 and j==1: links_bullauge(f_list[i*xcol+j], scale, 0.7, scale1) if i==1 and j==2: rechts_bullauge(f_list[i*xcol+j], scale, 0.7, scale1) if i==1 and j>2: normales_bullauge(f_list[i*xcol+j], ran.uniform(2, 8), 0.7, scale1) if i==2: normales_bullauge(f_list[i*xcol+j], ran.uniform(2, 8), 0.7, scale1) if i==3 and j>=2: dach_bullauge(f_list[i*xcol+j], scale, 0.7, 0.7) if i==3 and j<2: normales_bullauge(f_list[i*xcol+j], ran.uniform(2, 8), 0.7, scale1) #rs.AddSrfPt(f_list[i*xcol+j]) rs.BooleanDifference( ############################################################################# # 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)