def make_stem_pieces(b): obj1 = [] h = (b.tof[0].chine_hab - b.tof[1].chine_hab) * ( b.tof[0].section - b.chine) / (b.tof[1].section - b.tof[0].section) + b.tof[0].chine_hab p1 = [b.chine, 0, h] obj1.append(rs.AddLine([0, 0, b.bow], p1)) obj1.append(rs.AddLine([0, 0, b.bow], [b.stem_width, 0, b.bow])) obj1.append( rs.AddLine([b.stem_width, 0, b.bow], ss(p1, [b.stem_width, 0, 0]))) obj1.append(rs.AddLine(ss(p1, [b.stem_width, 0, 0]), p1)) obj1 = rs.MoveObjects(rs.JoinCurves(obj1, delete_input=True), sm(-1, p1)) obj2 = [] h = (b.tof[-1].chine_hab - b.tof[-2].chine_hab) * (b.loa - b.aft - b.tof[-1].section) / ( b.tof[-1].section - b.tof[-2].section) + b.tof[-1].chine_hab p2 = [b.loa - b.aft, 0, h] obj2.append(rs.AddLine([b.loa, 0, b.stern], p2)) obj2.append( rs.AddLine([b.loa, 0, b.stern], [b.loa - b.stem_width, 0, b.stern])) obj2.append( rs.AddLine([b.loa - b.stem_width, 0, b.stern], ss(p2, [-b.stem_width, 0, 0]))) obj2.append(rs.AddLine(ss(p2, [-b.stem_width, 0, 0]), p2)) obj2 = rs.MoveObjects(rs.JoinCurves(obj2, delete_input=True), sm(-1, p2)) return rs.RotateObjects(obj1 + obj2, [0, 0, 0], 90, [1, 0, 0])
def tree_gen(self, radius, height): result = [] summary = [] if radius < self.terminal_radius: if self.for_reals: result.append(self.get_leaf()) summary.append("leaf") else: if self.for_reals: result.append(self.twig_gen(radius, radius, height)) summary.append("twig " + str(radius) + " " + str(height)) subs = [] sub_radius = radius * self.radius_fraction sub_height = height * self.height_fraction sub_angle_y = self.bend for i in range(self.density): sub_angle_z = (i + (0.5 * random.random())) * (360 / self.density) sub, sub_summary = self.tree_gen(sub_radius, sub_height) if self.for_reals: sub = rs.RotateObjects(sub, (0,0,0), sub_angle_y, (0,1,0)) sub = rs.RotateObjects(sub, (0,0,0), sub_angle_z, (0,0,1)) sub = rs.MoveObjects(sub, (0,0,height)) subs += sub summary.append(sub_summary) center, center_summary = self.tree_gen(sub_radius, sub_height) if self.for_reals: center = rs.MoveObjects(center, (0,0,height)) result += subs + center summary.append(center_summary) return result, summary
def place_box(self): myBox1 = box() box1 = myBox1.console(self.data[2], 0, 0) myBox2 = box() box2 = myBox2.console(self.data[1], 1, (self.data[1][0] - self.data[0][0] - 2 * cut2) / 2.0) myBox3 = box() box3 = myBox3.console(self.data[0], 1, (self.data[1][0] - self.data[0][0] - 2 * cut2) / 2.0) rs.MoveObjects(box1, (0, 0, myBox1.height / 2.0)) rs.MoveObjects(box2, (0, 0, myBox2.height / 2.0 + cut2)) rs.MoveObjects(box3, (0, 0, myBox3.height / 2.0 + 2 * cut2))
def rMove(vector): objs = rs.GetObjects("Select objs") if objs != None: rs.MoveObjects(objs, vector) objs = None vector = vector + inputvec rMove(vector)
def unroll(self): x = 0 for i in range(len(self.srfList)): g = rs.AddGroup() s, p = rs.UnrollSurface(self.srfList[i], False, self.unrollList[i]) s = rs.JoinSurfaces(s, True) p = rs.MoveObjects(p, [x, self.name * 10, 0]) s = rs.MoveObject(s, [x, self.name * 10, 0]) b = rs.DuplicateSurfaceBorder(s, 1) rs.ObjectLayer(b, "cut") rs.AddObjectsToGroup(b, g) rs.AddObjectsToGroup(p, g) bb = rs.BoundingBox(s) x += fabs(bb[0].X - bb[1].X) + 1 t = rs.AddText( str(self.name) + "-" + str(i), util.averagePt(rs.CurvePoints(b)), 0.3) t = util.makeEngravingFont(t) rs.AddObjectsToGroup(t, g) rs.DeleteObjects(s)
def update(self): print('update') #delete last generated objects try: rs.DeleteObjects(self.generatedObjs) self.generatedObjs = [] except: print('exception in delete generated object') divWidth = 600 crv = self.baseCrv if not rs.IsObject(crv): print('crv is not an object') return if not rs.IsPolyline(crv): pts = rs.DivideCurveEquidistant(crv, divWidth) rail = rs.AddPolyline(pts) else: rail = rs.CopyObject(crv) pts = rs.CurveEditPoints(rail) if len(pts) < 3: print('too little points') return #find vectors to move and orient the profile vect = pts[1] - pts[0] vect = rs.VectorUnitize(vect) a = rs.VectorAngle(vect, (0, 1, 0)) - 90 #load the component path = self.loadPath component = None try: component = importComponent(path) except: print('exception on importing module') if component is None: print('component is None') return None #rs.MoveObjects(component.breps,pts[0]) #rs.RotateObjects(component.breps,pts[0],a) for b in component.breps: self.generatedObjs.append(b) oriented = orientObjAlongPolyPts(b, pts) print('pts count:', len(pts), ' num gen:', len(oriented)) rs.MoveObjects(component.polys, pts[0]) rs.RotateObjects(component.polys, pts[0], a) for c in component.polys: self.generatedObjs.append(c) mesh = meshSwipPolyAlongPoly(c, rail) self.generatedObjs.append(mesh) rs.DeleteObject(rail) print('generated obj count:', len(self.generatedObjs)) rs.AddGroup('gen') rs.AddObjectsToGroup(self.generatedObjs, 'gen')
def moveSrftoZ(srf): domainU = rs.SurfaceDomain(srf, 0) domainV = rs.SurfaceDomain(srf, 1) u = domainU[1] / 2.0 v = domainV[1] / 2.0 point = rs.EvaluateSurface(srf, u, v) # vec = [0, 0, point.Z] # vec = rs.VectorReverse(vec) # vec = [0,0,vec.Z] rs.MoveObjects(srf, rs.VectorReverse([0, 0, point.Z]))
def moveToOrigin(objs, origin): #box = rs.BoundingBox(objs) if origin: #selection_base = [box[0].X, box[0].Y, box[0].Z] vector = rs.VectorSubtract(origin, [0, 0, 0]) objs = rs.MoveObjects(objs, rs.VectorReverse(vector)) return True else: return False
def moveToOrigin(allObjects, CADinMilli): cadOrigin = rs.GetDocumentData("Project Info", "CAD coordinate (X,Y,Z)") cadOrigin = cadOrigin.split(",") try: moveVec = rs.VectorCreate([0,0,0], [float(cadOrigin[0]), float(cadOrigin[1]), float(cadOrigin[2])]) except: print "Move to origin FAILED. Make sure CAD Coordinate has been correctly entered into Project Info." return if CADinMilli: moveVec = rs.VectorScale(moveVec, .001) rs.MoveObjects(allObjects,moveVec) return
def convertToPolylines(obj): # get object properties text = rs.TextObjectText(obj) pt = rs.TextObjectPoint(obj) origin = rs.coerce3dpoint([0,0,0]) ht = rs.TextObjectHeight(obj) object_layer = rs.ObjectLayer(obj) plane = rs.TextObjectPlane(obj) diff = rs.coerce3dpoint([pt.X, pt.Y, pt.Z]) p1 = rs.WorldXYPlane() matrix = rs.XformRotation4(p1.XAxis, p1.YAxis, p1.ZAxis, plane.XAxis, plane.YAxis, plane.ZAxis) rs.DeleteObject(obj) # set current layer to put strings in prevlayer = rs.CurrentLayer() layer = rs.AddLayer('temptextlayer') rs.CurrentLayer('temptextlayer') # split text at enters text = text.split('\r\n') opts='GroupOutput=No FontName="timfont" Italic=No Bold=No Height='+ str(ht) opts+=" Output=Curves AllowOpenCurves=Yes LowerCaseAsSmallCaps=No AddSpacing=No " origin.Y += ht * len(text) *1.2 for item in text: rs.Command("_-TextObject " + opts + '"'+item+'"' + " " + str(origin) , False) origin.Y -= ht *1.5 #restore current layer rs.CurrentLayer(prevlayer) #select newly created texts polylines = rs.ObjectsByLayer('temptextlayer') # transform to old position rs.TransformObjects(polylines, matrix, copy=False) rs.MoveObjects(polylines, diff) rs.ObjectLayer(polylines, object_layer) return polylines
def GroupMove(rectOutlineList, objects, objCenter, rotatedAngle, movingCenter): for objs, rect, center, rotAngle, centerStart in zip( objects, rectOutlineList, objCenter, rotatedAngle, movingCenter): # rotate everything by center with rotatedAngle rs.RotateObjects(objs, center, rotAngle) # find vector to move from obj location to rectangle(obj center to rect center) boxCenter = rs.CurveAreaCentroid(rect)[0] moveVector = rs.VectorCreate(boxCenter, center) # check if object is in box rectPt = rs.PolylineVertices(rect) rectPt = PointsReorder(rectPt, 1) if rs.Distance(rectPt[0], rectPt[1]) > rs.Distance( rectPt[1], rectPt[2]): rs.RotateObjects(objs, center, 90) rs.MoveObjects(objs, moveVector)
def convertTextToPolylines2(obj): # get object properties text = rs.TextObjectText(obj) pt = rs.TextObjectPoint(obj) origin = rs.coerce3dpoint([0, 0, 0]) ht = rs.TextObjectHeight(obj) object_layer = rs.ObjectLayer(obj) plane = rs.TextObjectPlane(obj) diff = rs.coerce3dpoint([pt.X, pt.Y, pt.Z]) p1 = rs.WorldXYPlane() #restore view cplane rs.ViewCPlane(None, p1) matrix = rs.XformRotation4(p1.XAxis, p1.YAxis, p1.ZAxis, plane.XAxis, plane.YAxis, plane.ZAxis) rs.DeleteObject(obj) # split text at enters text = text.split('\r\n') opts = 'GroupOutput=No FontName="' + EXPORT_FONT + '" Italic=No Bold=No Height=' + str( ht) opts += " Output=Curves AllowOpenCurves=Yes LowerCaseAsSmallCaps=No AddSpacing=No " n_lines = len(text) origin.Y += 1.6 * ht * (len(text) - 1) polylines = [] for item in text: rs.Command( "_-TextObject " + opts + '"' + item + '"' + " " + str(origin), False) polylines += rs.LastCreatedObjects() origin.Y -= ht * 1.6 rs.ObjectLayer(polylines, object_layer) polylines = rs.ScaleObjects(polylines, (0, 0, 0), (0.7, 1, 1), True) # transform to old position rs.TransformObjects(polylines, matrix, copy=False) rs.MoveObjects(polylines, diff) return polylines
def moveToOrigin(objs): #get left bottom rs.EnableRedraw(True) selection_base = rs.GetPoint("Pick export base point") rs.EnableRedraw(False) #box = rs.BoundingBox(objs) if selection_base: #selection_base = [box[0].X, box[0].Y, box[0].Z] vector = rs.VectorSubtract(selection_base, [0, 0, 0]) objs = rs.MoveObjects(objs, rs.VectorReverse(vector)) return True else: return False
def get_brep_plan_cut(brep, cut_height, tolerance): """cut a brep at a certain height. returns list of geometry.polycurve tolerance should be the document tolerance. NOTE: attempts to join the curves.""" bb = rs.BoundingBox(brep) height = rs.Distance(bb[0], bb[4]) #get middle section and get polycurve midplane_pts = rs.MoveObjects(bb[0:4], [0, 0, cut_height]) plane = rs.PlaneFromPoints(bb[0], bb[1], bb[3]) rs.DeleteObjects(midplane_pts) bool_merged = Rhino.Geometry.Brep.MergeCoplanarFaces(brep, tolerance) g = Rhino.Geometry.Intersect.Intersection.BrepPlane(brep, plane, tolerance) g_polycurves = g[1] g_polycurves = Rhino.Geometry.Curve.JoinCurves(g_polycurves, tolerance) return g_polycurves
def TruncateWorldCoordinate(): try: # Get setout point point = rs.GetPoint("Pick Point for World Coordinate value") if point: rs.EnableRedraw(False) northing = round(point.Y, 5) easting = round(point.X, 5) # Add origin layer and lock it rs.AddLayer("_ORIGIN_", (255, 0, 0), visible=True, locked=True) originPoint = rs.AddPoint(point) # Move all objects to origin allObj = rs.AllObjects() vector = rs.VectorCreate((0, 0, 0), point) rs.MoveObjects(allObj, vector) # Draw origin marker` circle = rs.AddCircle(originPoint, 1) quads = rs.EllipseQuadPoints(circle) line1 = rs.AddLine(quads[0], quads[1]) line2 = rs.AddLine(quads[2], quads[3]) # Draw text marker and designate a name text = rs.AddText((" E " + str(easting) + " N " + str(northing)), originPoint, 0.5) rs.ObjectName(text, "_ORIGIN_TEXT_") rs.ObjectName(originPoint, "_ORIGIN_POINT_") # Move geometry to locked origin layer rs.ObjectLayer([circle, line1, line2, originPoint, text], "_ORIGIN_") rs.EnableRedraw(True) except: print("Failed to execute") rs.EnableRedraw(True) return
def RestoreWorldCoordinate(): try: rs.EnableRedraw(False) # retreive northing and easting from text object obj = rs.ObjectsByName("_ORIGIN_TEXT_") if obj: text = rs.TextObjectText(obj) textList = text.split() easting = float(textList[1]) northing = float(textList[3]) # create reference coordinates to make vector orPoint = (easting, northing, 0) point = rs.PointCoordinates(rs.ObjectsByName("_ORIGIN_POINT_")) vector = rs.VectorCreate(orPoint, point) # move all objects back to original origin point allObj = rs.AllObjects() rs.MoveObjects(allObj, vector) # delete coordinate geometry isCurrent = rs.IsLayerCurrent("_ORIGIN_") if isCurrent == False: rs.PurgeLayer("_ORIGIN_") if isCurrent == True: defaultCheck = rs.IsLayer("Default") if defaultCheck == True: rs.CurrentLayer("Default") rs.PurgeLayer("_ORIGIN_") if defaultCheck == False: rs.AddLayer("Default") rs.CurrentLayer("Default") rs.PurgeLayer("_ORIGIN_") rs.EnableRedraw(True) except: print("Failed to execute") rs.EnableRedraw(True) return
def get_frame_brep(outline_srf, border_thickness, thickness): """get the frame brep. This is a solid that is booleaned with the slices of terrain to make a border when border mode is on.""" edge_crvs = rs.DuplicateEdgeCurves(outline_srf) outline_crv = rs.JoinCurves(edge_crvs) pt, _ = rs.CurveAreaCentroid(outline_crv) inner_crv = rs.OffsetCurve(outline_crv, pt, border_thickness, [0, 0, 1]) rs.MoveObjects([outline_crv, inner_crv], [0, 0, thickness * 2]) path_line = rs.AddLine([0, 0, 0], [0, 0, -thickness * 4]) inner_brep = rs.ExtrudeCurve(inner_crv, path_line) outer_brep = rs.ExtrudeCurve(outline_crv, path_line) rs.CapPlanarHoles(inner_brep) rs.CapPlanarHoles(outer_brep) frame_brep = rs.BooleanDifference([outer_brep], [inner_brep]) rs.DeleteObjects([outline_crv, inner_crv]) rs.DeleteObjects(edge_crvs) rs.DeleteObject(path_line) return frame_brep
def draw_coaming(c): pts = [[0, 0, 0]] half = [[(i + 1) * c.spacing, c.points[i], 0] for i in range(len(c.points))] pts.extend(half) pts.append([c.length, 0, 0]) half = [[(i + 1) * c.spacing, -c.points[i], 0] for i in range(len(c.points))] half.reverse() pts.extend(half) pts.append([0, 0, 0]) crv = rs.AddInterpCurve(pts, degree=3, knotstyle=0, start_tangent=[0, 1, 0], end_tangent=[0, 1, 0]) strip = [crv, rs.OffsetCurve(crv, [-1, 0, 0], c.width1)] rs.CopyObjects(strip, [0, c.beam + 2 * c.width1, 0]) strip2 = [rs.CopyObjects(crv), rs.OffsetCurve(crv, [-1, 0, 0], c.width2)] rs.MoveObjects(strip2, [0, -c.beam - c.width1 - c.width2, 0])
def createTable(partlist): if not "partlistgroup" in rs.GroupNames(): rs.AddGroup("partlistgroup") #clean the group group = sc.doc.Groups.FindName("partlistgroup") objs = sc.doc.ActiveDoc.Groups.GroupMembers(group.Index) rs.DeleteObjects(objs) #rs.DeleteObjects twidth = 100 def addTexts(texts, y): for i, text in enumerate(texts): if i == 0: a = 6 just = Rhino.Geometry.TextJustification.BottomRight elif i == 1: a = 9.5 just = Rhino.Geometry.TextJustification.BottomLeft else: a = 14 + twidth just = Rhino.Geometry.TextJustification.BottomRight plane = Rhino.Geometry.Plane.WorldXY plane.Origin = Rhino.Geometry.Point3d(a, y - 4, 0) textobject = sc.doc.Objects.AddText(text, plane, 2.0, 'Courier New', False, False, just) rs.AddObjectToGroup(textobject, "partlistgroup") def addBorders(i, y): start = Rhino.Geometry.Point3d(0, y - 6, 0) end = Rhino.Geometry.Point3d(16 + twidth, y - 6, 0) line = sc.doc.Objects.AddLine(start, end) #bottom border rs.AddObjectToGroup(line, "partlistgroup") if i == 0: #add top border trans = Rhino.Geometry.Transform.Translation(0, 6, 0) h_line = Rhino.Geometry.Line(start, end) h_line.Transform(trans) line = sc.doc.Objects.AddLine(h_line) rs.AddObjectToGroup(line, "partlistgroup") #add vertical lines v_start = Rhino.Geometry.Point3d(0, y, 0) v_end = Rhino.Geometry.Point3d(0, y - 6, 0) v_line = Rhino.Geometry.Line(v_start, v_end) line = sc.doc.Objects.AddLine(v_line) rs.AddObjectToGroup(line, "partlistgroup") trans = Rhino.Geometry.Transform.Translation(8, 0, 0) v_line.Transform(trans) line = sc.doc.Objects.AddLine(v_line) rs.AddObjectToGroup(line, "partlistgroup") trans = Rhino.Geometry.Transform.Translation(twidth, 0, 0) v_line.Transform(trans) line = sc.doc.Objects.AddLine(v_line) rs.AddObjectToGroup(line, "partlistgroup") trans = Rhino.Geometry.Transform.Translation(8, 0, 0) v_line.Transform(trans) line = sc.doc.Objects.AddLine(v_line) rs.AddObjectToGroup(line, "partlistgroup") y = len(partlist) * 6 for i, texts in enumerate(partlist): addTexts(texts, y) addBorders(i, y) y -= 6 #sc.doc.Views.Redraw() group = sc.doc.Groups.FindName("partlistgroup") objs = sc.doc.ActiveDoc.Groups.GroupMembers(group.Index) rs.MoveObjects(objs, (10, 10, 0))
#lineFrom = rs.GetPoint("Plane From:") #lineTo = rs.GetPoint("Plane To:") #distance = rs.Distance(lineFrom, lineTo) #plane = rs.LinePlane([lineFrom, lineTo]) #rs.AddPlaneSurface( plane, distance, distance ) distance = rs.Distance(s1, e1) plane = rs.LinePlane([s1, e1]) p1 = rs.AddPlaneSurface(plane, distance, distance) rs.HideObject(p1) distance = rs.Distance(s2, e2) plane = rs.LinePlane([s2, e2]) p2 = rs.AddPlaneSurface(plane, distance, distance) rs.HideObject(p2) l1 = rs.AddLine(s1, e1) l2 = rs.AddLine(s2, e2) if l1: points1 = rs.DivideCurve(l1, 20) for point in points1: rs.AddPoint(point) rs.MoveObjects(points1, y) if l2: points2 = rs.DivideCurve(l2, 20) for point in points2: rs.AddPoint(point)
def draw_frame_layout(s, keel_str, chine_str, gunwale_str, deck_str, diam, bdiam): objs = [] t = [0, 2 * s.gunwale_hb, 0] r = 90 # t = [0,0,0] # r = 0 objs.append( rs.AddLine([s.section, 0, s.keel_hab], [s.section, s.chine_hb, s.chine_hab])) objs.append( rs.AddLine([s.section, s.chine_hb, s.chine_hab], [s.section, s.gunwale_hb, s.gunwale_hab])) objs.append( rs.AddLine([s.section, s.gunwale_hb, s.gunwale_hab], [s.section, s.deckridge_hb, s.deckridge_hab])) if (s.deckridge_hb != 0): objs.append( rs.AddLine([s.section, s.deckridge_hb, s.deckridge_hab], [s.section, 0., s.deckridge_hab])) objs.extend(rs.MirrorObjects(objs, [0, 0, 0], [1, 0, 0], copy=True)) objs = rs.JoinCurves(objs, delete_input=True) #ins = rs.OffsetCurve(objs,[s.section,0,.5*s.deckridge_hab],s.width + .75*deck_str.width,normal=[1,0,0]) # if not ins: ins = [] ins = [] rs.DeleteObjects(objs) chine_edge = make_chine_edge([s.section, s.chine_hb, s.chine_hab], [s.section, s.gunwale_hb, s.gunwale_hab], chine_str.thickness, gunwale_str.thickness, chine_str.width, gunwale_str.width, [s.section, s.deckridge_hb, s.deckridge_hab]) keel_edge = make_keel_edge([s.section, 0, s.keel_hab], [s.section, s.chine_hb, s.chine_hab], keel_str.thickness, keel_str.width, [s.section, s.gunwale_hb, s.gunwale_hab]) deck_edge = make_deck_edge([s.section, s.gunwale_hb, s.gunwale_hab], [s.section, s.deckridge_hb, s.deckridge_hab], deck_str.thickness, gunwale_str.thickness, deck_str.width, [s.section, s.chine_hb, s.chine_hab], s.deck_string_place) edges = chine_edge + keel_edge + deck_edge edges.extend(rs.MirrorObjects(edges, [0, 0, 0], [1, 0, 0], copy=True)) edges = rs.JoinCurves(edges, delete_input=True) edges.extend( rs.OffsetCurve(edges, [s.section, 0, .5 * s.deckridge_hab], s.width, normal=[1, 0, 0], style=3)) g = rs.AddGroup() rs.AddObjectsToGroup(edges, g) # if s.num-1 in [0,2,5,7]: if 1: p = [s.section, 0, 0] plane = rs.PlaneFromNormal(p, [1, 0, 0]) holes = [ rs.MoveObject( rs.AddCircle(plane, diam / 2), [0, 1.5 * deck_str.thickness, s.keel_hab + deck_str.width]) ] holes.extend(rs.MirrorObjects(holes, p, ss(p, [1, 0, 0]), copy=True)) else: holes = [] rs.MoveObjects( rs.RotateObjects(ins + edges + holes, [s.section, 0, s.keel_hab], r, [0, 1, 0]), t)
def MultiUnroll(): msg = "Select surface/polysurface objects to unroll" brepIDs = rs.GetObjects(msg, 8 + 16, preselect=True) if not brepIDs: return msg = "Select curves and/or points to unroll with surfaces, or Enter to continue" otherIDs = rs.GetObjects(msg, 1 + 4 + 8192) if "MultiUR_Numbering" in sc.sticky: user_num = sc.sticky["MultiUR_Numbering"] else: user_num = True if "MultiUR_Explode" in sc.sticky: user_exp = sc.sticky["MultiUR_Explode"] else: user_exp = False if "MultiUR_Properties" in sc.sticky: user_prop = sc.sticky["MultiUR_Properties"] else: user_prop = False if "MultiUR_Spacing" in sc.sticky: user_space = sc.sticky["MultiUR_Spacing"] else: user_space = 1.0 if "MultiUR_XLimit" in sc.sticky: user_xl = sc.sticky["MultiUR_XLimit"] else: user_xl = 0 prompt = "Start point for unrolls - press Enter for world 0" msg = [ "NumberObjects", "Explode", "KeepProperties", "LayoutSpacing", "XExtents" ] ini = [user_num, user_exp, user_prop, user_space, user_xl] limits = [["No", "Yes"], ["No", "Yes"], ["No", "Yes"], [True, 0], [True, 0]] result = CommandLineOptions(prompt, msg, ini, limits) if not result: return x_extents = result[4] new_sp = result[5] #initialize max_y = new_sp.Y x_origin = new_sp.X exceed_warning = False ur_number = 0 no_unroll = 0 crvs = [] pts = [] dots = [] tol = sc.doc.ModelAbsoluteTolerance #get underlying geometry objects objs = [sc.doc.Objects.Find(objID).Geometry for objID in brepIDs] if otherIDs: for objID in otherIDs: if rs.IsCurve(objID): crvs.append(sc.doc.Objects.Find(objID).Geometry) elif rs.IsPoint(objID): pts.append(sc.doc.Objects.Find(objID).Geometry) else: dots.append(sc.doc.Objects.Find(objID).Geometry) #run the unroller rs.EnableRedraw(False) for i, obj in enumerate(objs): if isinstance(obj, Rhino.Geometry.Extrusion): obj = obj.ToBrep() ur = Rhino.Geometry.Unroller(obj) if result[1]: ur.ExplodeOutput = True if len(crvs) > 0: for crv in crvs: ur.AddFollowingGeometry(crv) if len(pts) > 0: for pt in pts: ur.AddFollowingGeometry(pt) if len(dots) > 0: for dot in dots: ur.AddFollowingGeometry(dot) unroll = ur.PerformUnroll() if unroll[0]: #something was unrolled ur_number += 1 if result[1]: ur_objs = unroll[0] else: ur_objs = Rhino.Geometry.Brep.JoinBreps(unroll[0], tol) ur_IDs = [sc.doc.Objects.AddBrep(ur_obj) for ur_obj in ur_objs] bb = rs.BoundingBox(ur_IDs) if x_extents > 0: if bb[3].Y - bb[0].Y > max_y: max_y = bb[3].Y - bb[0].Y if bb[1].X - bb[0].X > x_extents: x_extents = bb[1].X - bb[0].X exceed_warning = True if new_sp.X + bb[1].X > (x_origin + x_extents): #need to reset start point to x_origin, y_max new_sp.X = x_origin new_sp.Y += max_y + result[3] move_vec = new_sp - bb[0] if unroll[1]: ur_crv_IDs = [ sc.doc.Objects.AddCurve(ur_obj) for ur_obj in unroll[1] ] ur_IDs.extend(ur_crv_IDs) if unroll[2]: ur_pt_IDs = [ sc.doc.Objects.AddPoint(ur_obj) for ur_obj in unroll[2] ] ur_IDs.extend(ur_pt_IDs) if unroll[3]: ur_dot_IDs = [ sc.doc.Objects.AddTextDot(ur_obj) for ur_obj in unroll[3] ] ur_IDs.extend(ur_dot_IDs) if result[2]: #keep properties (MatchAttributes() causes problems with grouping) TransferColorLayer(ur_IDs, brepIDs[i]) if result[0]: #number objects and group AddDotToObjCtr(ur_IDs, str(ur_number), result[2]) #add number dot to original object AddDotToObjCtr([brepIDs[i]], ur_number, result[2]) #move all objs into position rs.MoveObjects(ur_IDs, move_vec) new_sp = (bb[1] + (move_vec + Rhino.Geometry.Vector3d(result[3], 0, 0))) else: no_unroll += 1 #Clean up, store settings, report sc.sticky["MultiUR_Numbering"] = result[0] sc.sticky["MultiUR_Explode"] = result[1] sc.sticky["MultiUR_Properties"] = result[2] sc.sticky["MultiUR_Spacing"] = result[3] sc.sticky["MultiUR_XLimit"] = x_extents if exceed_warning: us = rs.UnitSystemName(abbreviate=True) msg = "At least one of the unrolled objects exceeded the X extents limit!\n" msg += "Limit has been extended to {:.2f} {} ".format(x_extents, us) msg += "to allow all objects to unroll." rs.MessageBox(msg, 48) msg = "Sucessfully unrolled {} objects".format(len(brepIDs) - no_unroll) if no_unroll > 0: msg += " | Unable to unroll {} objects".format(no_unroll) print msg
def drawEhombusTilingByRegularOffsetLine(emblem): tmpObjs = [] # self.rhomboids for rhomboid in emblem.rhomboids: objs = [] # 中点長方形の対角四角形 for i in range(len(rhomboid.midPts)): p0 = rhomboid.midPts[i] if (i == 0): nextMidPt = rhomboid.midPts[i + 1] prevtMidPt = rhomboid.midPts[len(rhomboid.midPts) - 1] elif (i == len(rhomboid.midPts) - 1): nextMidPt = rhomboid.midPts[0] prevtMidPt = rhomboid.midPts[i - 1] else: nextMidPt = rhomboid.midPts[i + 1] prevtMidPt = rhomboid.midPts[i - 1] p1 = rs.VectorAdd(p0, nextMidPt) p1 = rs.VectorDivide(p1, 2.0) p2 = rhomboid.ellipsePts[0] p3 = rs.VectorAdd(p0, prevtMidPt) p3 = rs.VectorDivide(p3, 2.0) pts = [p0, p1, p2, p3, p0] obj = rs.AddPolyline(pts) if (i % 2 == 0): rs.ObjectLayer(obj, "srf%s" % rhomboid.lines[1].no) else: rs.ObjectLayer(obj, "srf%s" % rhomboid.lines[0].no) objs.append(obj) # 外周面 pts = [] for pt in rhomboid.pts: pts.append(pt) pts.append(pts[0]) obj = rs.AddPolyline(pts) rs.ObjectLayer(obj, "srfRhomboid") objs.append(obj) # 外周線 for i in range(len(rhomboid.pts)): if (i == len(rhomboid.pts) - 1): obj = rs.AddLine(rhomboid.pts[i], rhomboid.pts[0]) else: obj = rs.AddLine(rhomboid.pts[i], rhomboid.pts[i + 1]) rs.ObjectLayer(obj, "lineBlack") objs.append(obj) # rotate xform = rs.XformRotation2(rhomboid.rotateAng, [0, 0, 1], [0, 0, 0]) rs.TransformObjects(objs, xform) # move rs.MoveObjects(objs, rhomboid.movePt) # text txt = "%s" % (rhomboid.name) pt = rhomboid.getAbsolutePt(rhomboid.ellipsePts[0]) height = 1.2 pt = [pt[0], pt[1] + height / 2.0, pt[2]] obj = rs.AddText(txt, pt, height, font, font_style=0, justification=2 + 65536) rs.ObjectLayer(obj, "textRhomboid") objs.append(obj) # tmpObjs for obj in objs: tmpObjs.append(obj) # move to center pts = rs.BoundingBox(tmpObjs) center = rs.VectorAdd(pts[0], pts[2]) center = rs.VectorScale(center, 0.5) center = rs.VectorSubtract([0, 0, 0], center) rs.MoveObjects(tmpObjs, center) return tmpObjs
#SHL Architects #Sean Lamb 29-05-2019 #[email protected] #Example use of ws_lib package. Run in Rhino Python Interpreter. import System.Drawing as sd import rhinoscriptsyntax as rs import shl-toolbox.lib.layers as wla reload(wla) import shl-toolbox.lib.rhino_util as wru reload(wru) wla.add_layer("t1",sd.Color.Aqua) layerlist = "Layer 01" rhobjs = wla.get_layer_objects(layerlist) x = 5 guids = wru.docobj_to_guid(rhobjs) y = 10 rs.MoveObjects(guids,[20,20,0]) wla.change_object_layers(guids,"t1")
pattern_A.append(rs.AddLine(joins[i],joins[i+1])) #----------Generate pattern B----------# joins_2 = [] joins_2.append(a) p_2 = rs.CopyObject(a,[(d/2),0,0]) joins_2.append(p_2) for i in range (1, (xint+1)): c_2 = rs.CopyObject(p_2,[l,0,0]) joins_2.append(c_2) p_2 = rs.CopyObject(c_2,[d,0,0]) joins_2.append(p_2) pattern_B = [] for i in range (1, (len(joins_2)-1), 2): pattern_B.append(rs.AddLine(joins_2[i],joins_2[i+1])) p_B = rs.MoveObjects(pattern_B, [0,s,0]) for i in range (0, (xint_2-1), 2): pattern_A = rs.CopyObjects(pattern_A, [0,s*2,0]) p_B = rs.CopyObjects(p_B, [0,s*2,0]) rs.DeleteObjects(joins) rs.DeleteObjects(joins_2) rs.DeleteObject(obj_0) rs.EnableRedraw(True)
import rhinoscriptsyntax as rs import Rhino import Rhino.Geometry as rg doc = Rhino.RhinoDoc.ActiveDoc ###insert clipboard object at point cmd = "'_Paste" rs.Command(cmd, False) objs = rs.LastCreatedObjects(select=True) destination = rs.GetPoint("Choose a point to place object") #calculate initial point and placement point pt = rs.CurveStartPoint(objs[0]) dx = destination[0] - pt[0] dy = destination[1] - pt[1] dz = destination[2] - pt[2] translation = [dx, dy, dz] rs.MoveObjects(objs, translation)
def ScatterBlocks(): try: ################################################################################ # GET OBJECTS AND VARIABLE # ################################################################################ obj = rs.GetObject(message="Select surface to scatter on", filter=8 | 16 | 32, preselect=False, select=False, custom_filter=None, subobjects=False) if not obj: return blocks = rs.GetObjects(message="Select blocks to scatter", filter=4096, group=True, preselect=False, select=False, objects=None, minimum_count=1, maximum_count=0, custom_filter=None) if not blocks: return scatterNum = rs.GetInteger( message="Enter scatter amount", number=100, minimum=1, maximum=10000) if not scatterNum: return userScale = rs.GetReal( "enter scale multiplyer (0 for no scaling)", number=0, minimum=None, maximum=None) userRotation = rs.GetBoolean( "random rotation of blocks?", ("Rotation", "No", "Yes"), (True)) if not userRotation: return isMesh = rs.IsMesh(obj) ptBucket = 0 pointList = [] blockList = [] worldZVector = (rs.WorldXYPlane()).ZAxis rs.EnableRedraw(False) def MeshBrep(brep_id, params): brep = rs.coercebrep(brep_id) if brep: mesh = Rhino.Geometry.Mesh() mesh_parts = Rhino.Geometry.Mesh.CreateFromBrep(brep, params) for mesh_part in mesh_parts: mesh.Append(mesh_part) mesh.Compact() return mesh def TestMeshBrep(): mesh_params = Rhino.Geometry.MeshingParameters.Coarse mesh_brep = MeshBrep(obj, mesh_params) if mesh_brep: mesh = sc.doc.Objects.AddMesh(mesh_brep) return mesh def chunks(lst, n): # list split generator for i in xrange(0, len(lst), n): yield lst[i:i + n] if isMesh == False: mesh = TestMeshBrep() else: mesh = obj # Get and format vertex points in mesh, format from point3d object to float list meshVerts = rs.MeshFaces(mesh, face_type=False) totalArea = rs.MeshArea(mesh) meshFaceCount = rs.MeshFaceCount(mesh) PT01 = meshVerts[0::3] PT01S = [] for i in PT01: i = (i.X, i.Y, i.Z) PT01S.append(i) PT02 = meshVerts[1::3] PT02S = [] for i in PT02: i = (i.X, i.Y, i.Z) PT02S.append(i) PT03 = meshVerts[2::3] PT03S = [] for i in PT03: i = (i.X, i.Y, i.Z) PT03S.append(i) # format list together in order to loop through triangleList = zip(PT01S, PT02S, PT03S) ################################################################################ # POINT SCATTER LOOP # ################################################################################ # loop through the three vertexes forming individual triangles for i in triangleList: a = i[0] # triangle vert 1 b = i[1] # triangle vert 2 c = i[2] # triangle vert 3 # Find area of triangle dist01 = rs.Distance(a, b) dist02 = rs.Distance(a, c) dist03 = rs.Distance(b, c) # Herons formula to find area of triangle by sides s = (dist01 + dist02 + dist03) / 2 tArea = math.sqrt(s*(s-dist01)*(s-dist02)*(s-dist03)) # assign portion of points base on area of triangle, if assignment of points is lower then one, add that to the next assignment numPtsPerUnit = totalArea[1] / scatterNum ptAllocation = tArea / numPtsPerUnit ptBucket = ptBucket + ptAllocation if ptBucket < 1: continue else: pointShare = int(math.floor(ptBucket)) ptBucket = 0 # Vectors from origin to either corner of triangle ac = rs.VectorCreate(c, a) ab = rs.VectorCreate(b, a) originVector = rs.VectorCreate(a, (0, 0, 0)) # Generate random numbers between 0,1. Random scatter onto triangle for i in range(pointShare): r1 = random.random() r2 = random.random() if r1 + r2 < 1: p = r1 * ac + r2 * ab else: p = (1 - r1) * ac + (1 - r2) * ab points = rs.AddPoint(p) pointList.append(points) rs.MoveObjects(points, originVector) ################################################################################ # MOVE BLOCKS TO POINTS WITH ROTATION / SCALE # ################################################################################ # shuffle point list then split list by the number of blocks to scatter. Copy blocks to split lists random.shuffle(pointList) ptDivision = int(len(pointList) / len(blocks)) genList = chunks(pointList, ptDivision) blockIndex = 0 for pts in genList: # looping through split point list and blocks and copying blocks to scatter blockPt = rs.BlockInstanceInsertPoint(blocks[blockIndex]) for pt in pts: vector = rs.VectorCreate(pt, blockPt) newBlock = rs.CopyObject(blocks[blockIndex], vector) # create list of blocks for later modification blockList.append(newBlock) if blockIndex < (len(blocks) - 1): blockIndex += 1 # apply random scaling and rotation to blocks if userRotation[0] == True: for block in blockList: centerPt = rs.BlockInstanceInsertPoint(block) angle = random.randint(0, 360) rs.RotateObject(block, centerPt, angle, worldZVector) for block in blockList: centerPt = rs.BlockInstanceInsertPoint(block) scale = random.uniform((userScale/4), userScale) rs.ScaleObject(block, centerPt, (scale, scale, scale)) # If a mesh was created, delete it, general cleanup if isMesh == False: rs.DeleteObject(mesh) rs.DeleteObjects(pointList) rs.EnableRedraw(True) except: print("Failed to execute") rs.EnableRedraw(True) return
biggestY = ydist #create a bounding polyine #not necessary but help see the border polyline = rs.AddPolyline(boxpts[0:4]) #define endpoint of xmove vector xpt = [xdist + offset, 0, 0] #set totalX totalX = totalX + xdist + offset #define xmove vector xmove = rs.VectorCreate(origin, xpt) #add objects to the moved list moved.append(joined) moved.append(polyline) #move all the objects rs.MoveObjects(moved, xmove) #increment the column count columncount += 1 #check to see if the columncount is evenly divisible by the row #if it is we need to move the column if columncount % row == 0: #get the biggestY value and add the offset #I call this the formfeed (like a typewriter) formfeed = biggestY + offset #That makes this the carrigeReturn #Ding! carrigeReturn = [-totalX, formfeed, 0] move = rs.VectorCreate(origin, carrigeReturn) #We then move all the objects back and reset the #biggestY and totalX values
__author__ = "dfmd" __version__ = "2019.07.12" import rhinoscriptsyntax as rs surfaces = rs.GetObjects("Surfaces", rs.filter.surface,True,True) tol = 10 y_distance = 0 if surfaces: try: rs.EnableRedraw(False) for srf in surfaces: urolled_srf = rs.UnrollSurface(srf, explode=False) bounding_box = rs.BoundingBox(urolled_srf) y_distance += rs.Distance(bounding_box[0],bounding_box[3]) + tol move_vector = rs.VectorCreate((0,0,0),(0,y_distance,0)) rs.MoveObjects(urolled_srf,move_vector) rs.EnableRedraw(True) except Exception as e: print('Error: %s' % e)
def drawRhombusOnRegularOffsetLine(emblem): tmpObjs = [] for rhomboid in emblem.rhomboids: objs = [] # 中点長方形の対角四角形 for i in range(len(rhomboid.midPts)): p0 = rhomboid.midPts[i] if (i == 0): nextMidPt = rhomboid.midPts[i + 1] prevtMidPt = rhomboid.midPts[len(rhomboid.midPts) - 1] elif (i == len(rhomboid.midPts) - 1): nextMidPt = rhomboid.midPts[0] prevtMidPt = rhomboid.midPts[i - 1] else: nextMidPt = rhomboid.midPts[i + 1] prevtMidPt = rhomboid.midPts[i - 1] p1 = rs.VectorAdd(p0, nextMidPt) p1 = rs.VectorDivide(p1, 2.0) p2 = rhomboid.ellipsePts[0] p3 = rs.VectorAdd(p0, prevtMidPt) p3 = rs.VectorDivide(p3, 2.0) pts = [p0, p1, p2, p3, p0] obj = rs.AddPolyline(pts) if (i % 2 == 0): rs.ObjectLayer(obj, "srf%s" % rhomboid.lines[1].no) else: rs.ObjectLayer(obj, "srf%s" % rhomboid.lines[0].no) objs.append(obj) # 外周面 pts = [] for pt in rhomboid.pts: pts.append(pt) pts.append(pts[0]) obj = rs.AddPolyline(pts) rs.ObjectLayer(obj, "srfRhomboid") objs.append(obj) # 外周線 for i in range(len(rhomboid.pts)): if (i == len(rhomboid.pts) - 1): obj = rs.AddLine(rhomboid.pts[i], rhomboid.pts[0]) else: obj = rs.AddLine(rhomboid.pts[i], rhomboid.pts[i + 1]) rs.ObjectLayer(obj, "lineBlack") objs.append(obj) # move to center objs = rs.MoveObjects(objs, [ -rhomboid.ellipsePts[0][0], -rhomboid.ellipsePts[0][1], -rhomboid.ellipsePts[0][2] ]) # rotate xform = rs.XformRotation2(rhomboid.rotateAng, [0, 0, 1], [0, 0, 0]) rs.TransformObjects(objs, xform) # move pts = rs.LineLineIntersection( [rhomboid.lines[0].sPt, rhomboid.lines[0].ePt], [rhomboid.lines[1].sPt, rhomboid.lines[1].ePt]) rs.MoveObjects(objs, pts[0]) # tmpObjs for obj in objs: tmpObjs.append(obj) return tmpObjs