def main(): objs = rs.VisibleObjects() cutLevel = 12 rs.EnableRedraw(False) objsCopy = rs.CopyObjects(objs) splitModel(objsCopy, cutLevel) rs.EnableRedraw(True)
def addJoin(lns, nJoins, xThick, yThick): joins = [] joins_3 = [] points = rs.DivideCurve(lns, nJoins) lenP = len(points) for i in range(lenP): joins.append(rs.AddPoint(points[i])) joins_2 = rs.CopyObjects(joins, [xThick, yThick, 0]) joins_2.remove(joins_2[0]) joins_2.append([0, 0, 0]) for j in range(0, len(joins), 2): c = j + 2 addList(joins, joins_2, joins_3, j, c) joins_3.remove(joins_3[len(joins_3) - 1]) joins_3.remove(joins_3[len(joins_3) - 1]) joined = rs.AddPolyline(joins_3) rs.DeleteObject(lns) return joined
def CopyObjectsToLayer(): "Copy selected objects to a different layer" # Get the objects to copy objectIds = rs.GetObjects("Select objects") # Get all layer names layerNames = rs.LayerNames() if (objectIds == None or layerNames == None): return # Make sure select objects are unselected rs.UnselectObjects(objectIds) layerNames.sort() # Get the destination layer layer = rs.ComboListBox(layerNames, "Destination Layer <" + rs.CurrentLayer() + ">") if layer: # Add the new layer if necessary if (not rs.IsLayer(layer)): rs.AddLayer(layer) # Copy the objects newObjectIds = rs.CopyObjects(objectIds) # Set the layer of the copied objects [rs.ObjectLayer(id, layer) for id in newObjectIds] # Select the newly copied objects rs.SelectObjects(newObjectIds)
def duplicateAndRotate(): obj_ids = rs.GetObjects("Select object(s) to duplicate and rotate", 0, True, True) if obj_ids is None: return box = rs.BoundingBox(obj_ids) if not isinstance(box, list): return origin = rs.PointDivide(rs.PointAdd(box[0], box[6]), 2) endpt = rs.GetPoint("To point") ndups = rs.GetInteger("Number of duplications") maxd = rs.GetReal("Max Distance") translation = rs.VectorCreate(endpt, origin) for i in range(0, ndups, 1): xr = random() if random() < 0.5 else -1 * random() yr = random() if random() < 0.5 else -1 * random() zr = random() if random() < 0.5 else -1 * random() newpt = [xr * maxd, yr * maxd, zr * maxd] translation1 = rs.VectorCreate(endpt, newpt) translation2 = rs.VectorCreate(translation1, origin) copied_obj_ids = rs.CopyObjects(obj_ids, translation2) xyp = rs.WorldXYPlane() rs.RotateObjects(copied_obj_ids, newpt, random() * 360, xyp[0]) rs.RotateObjects(copied_obj_ids, newpt, random() * 360, xyp[1]) rs.RotateObjects(copied_obj_ids, newpt, random() * 360, xyp[2])
def cut_building_volumes(terrain_section_breps, bldg_section_breps): """ input: list of lists of extruded terrain breps and section breps. first level of list is section heights, second level is breps. output: the new terrain breps """ #boolean problem is caused by non-manifold error. need to scale the B_breps prior to booleaning. new_terrain_section_breps = [] for i, brep_level in enumerate(terrain_section_breps): new_level_terrain_section_breps = [] for A_brep in brep_level: #rs.ObjectLayer(A_brep,"s10") #debug B_breps = rs.CopyObjects(bldg_section_breps[i]) #[rs.ObjectLayer(B_brep,"s11") for B_brep in B_breps] #debug boolean_result = rs.BooleanDifference([A_brep], B_breps, False) if boolean_result: c = [rs.CopyObject(x) for x in boolean_result] rs.DeleteObjects(boolean_result) new_level_terrain_section_breps.extend(c) else: new_level_terrain_section_breps.append(rs.CopyObject(A_brep)) #print new_level_terrain_section_breps rs.DeleteObjects(A_brep) rs.DeleteObjects(B_breps) rs.DeleteObjects(B_breps) #possibly not needed rs.DeleteObjects(boolean_result) #rs.ObjectLayer(new_level_terrain_section_breps,"s3") new_terrain_section_breps.append(new_level_terrain_section_breps) return new_terrain_section_breps
def transformMatrix(): obj_ids = rs.GetObjects("Select object(s) from which to create matrix", 0, True, True) if obj_ids is None: return box = rs.BoundingBox(obj_ids) if not isinstance(box, list): return origin = rs.PointDivide(rs.PointAdd(box[0], box[6]), 2) endpt = rs.GetPoint("To point") newpt = [1, 1, 1] translation1 = rs.VectorCreate(endpt, newpt) translation2 = rs.VectorCreate(translation1, origin) copied_obj_ids = rs.CopyObjects(obj_ids, translation2) for obj in copied_obj_ids: matrix = [] degrees = 90.0 # Some angle radians = math.radians(degrees) c = math.cos(radians) s = math.sin(radians) matrix.append([c, -s, 0, 0]) matrix.append([s, c, 0, 0]) matrix.append([0, 0, 1, 0]) matrix.append([0, 0, 0, 1]) pprint.pprint(matrix) rs.ScaleObject(obj, newpt, [3, 1, -9]) plane = rs.ViewCPlane() pprint.pprint(plane) rs.RotateObject(obj, newpt, uniform(0, 360), plane.XAxis) rs.RotateObject(obj, newpt, uniform(0, 360), plane.YAxis) rs.RotateObject(obj, newpt, uniform(0, 360), plane.ZAxis)
def testDuplications(): print("\n testDuplications commands \n") obj_ids = rs.GetObjects( "Select object(s) from which to create the rectangular matrix", 0, True, True) if obj_ids is None: return box = rs.BoundingBox(obj_ids) if not isinstance(box, list): return origin = rs.PointDivide(rs.PointAdd(box[0], box[6]), 2) nXdups = rs.GetInteger("Duplications X", 1, 1) rXdups = rs.GetReal("Duplications X rand", 0, 0, 100) / 100 nYdups = rs.GetInteger("Duplications Y", 1, 1) rYdups = rs.GetReal("Duplications Y rand", 0, 0, 100) / 100 nZdups = rs.GetInteger("Duplications Z", 1, 1) rZdups = rs.GetReal("Duplications Z rand", 0, 0, 100) / 100 rKeep = 1 - rs.GetReal("Percent to erase", 0, 0, 100) / 100 endpt = rs.GetPoint("To point") calc_val_real = lambda val, rand: val + random.uniform( -rand * val, rand * val) calc_val_int = lambda val, rand: val + int( round(random.uniform(-rand * val, rand * val))) xspace = 3 yspace = 3 zspace = 3 xdups = calc_val_int(nXdups, rXdups) ydups = calc_val_int(nYdups, rYdups) zdups = calc_val_int(nZdups, rZdups) translations = [] # Copy Points with Spacing for k in range(zdups): for j in range(ydups): for i in range(xdups): newpt = [ origin[0] + i * xspace, origin[1] + j * yspace, origin[2] + k * zspace ] translations = translations + [rs.VectorCreate(endpt, newpt)] nObjs = len(translations) print(nObjs) objs_to_keep = random.sample(range(nObjs), int(round(nObjs * rKeep))) translations = [translations[i] for i in objs_to_keep] copied_objs = [] for tr in translations: copied_objs = copied_objs + rs.CopyObjects(obj_ids, tr)
def copyToOrigin(objs): #get left bottom selection_base = rs.GetPoint("Pick export base point") #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]) return rs.CopyObjects(objs, rs.VectorReverse(vector))
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 change_object_layers(guids, layName, copy=False): """change layer of objects. params: [guids], str layName. bool copy return: new objects on layer (or original objects with reassigned layer if copy==False)""" if (not rs.IsLayer(layName)): add_layer(layName, sd.Color.White) if copy == True: guids = rs.CopyObjects(guids) [rs.ObjectLayer(id, layName) for id in guids] return guids
def change_object_layers(guids, layName, copy): if (not rs.IsLayer(layName)): add_layer(layName, sd.Color.White) if copy == True: guids = rs.CopyObjects(guids) [rs.ObjectLayer(id, layName) for id in guids] [rs.ObjectPrintWidthSource(id, 0) for id in guids] [rs.ObjectPrintColorSource(id, 0) for id in guids] [rs.ObjectColorSource(id, 0) for id in guids] return guids
def checkPos(objs): # if ok, start export copies = rs.CopyObjects( objs) copies = ce.explodeBlock( copies ) # filter objects to only curves and points copies = filterObjects(copies) if not ce.checkCurvePosition(copies): rs.DeleteObjects(copies) return False rs.DeleteObjects(copies)
def genFuncObj_Site(self): s = site_obj(self.site) pts = s.getPts() s.displayPts() poly_list = [] for i in self.req_obj: for j in range(i.getNumber()): obj = i T = False k = 0 this_gen_poly = None while (T == False and k < 50): x = random.randint(1, len(pts) - 2) p = pts[x - 1] q = pts[x] r = pts[x + 1] poly = obj.getConfig1(p, q, r) sum = 0 if (poly is not None and len(poly) > 0): sum = 0 if (poly_list and len(poly_list) > 0): for m in poly_list: polyY = rs.AddPolyline(m) G = self.checkPoly(poly, polyY) rs.DeleteObject(polyY) if (G == False): sum += 1 break if (sum == 0): T = True if (poly not in poly_list): this_gen_poly = poly poly_list.append(poly) elif (poly is not None and len(poly) > 0): if (poly not in poly_list): this_gen_poly = poly poly_list.append(poly) k += 1 if (this_gen_poly is not None): i.setGenPoly(rs.AddPolyline(this_gen_poly)) for i in self.req_obj: poly = i.getGenPoly() num_flrs = i.getNumFloors() num_crvs = len(i.getGenPoly()) fin_num_flrs = int(num_flrs / num_crvs) i.setNumFloors(fin_num_flrs) for j in poly: i.genIntPoly(j) npoly = i.getReqPoly() for k in range(fin_num_flrs): rs.CopyObjects(npoly, [0, 0, 4 * k]) pass
def main(): objs = rs.VisibleObjects() cutLevel = 12 rs.EnableRedraw(False) objsCopy = rs.CopyObjects(objs) splitModel(objsCopy, cutLevel) makePlan() rs.DeleteObjects(rs.ObjectsByGroup("Above")) rs.DeleteObjects(rs.ObjectsByGroup("Below")) cutAtPlan(cutLevel, False) rs.Command('_SelDupAll _delete') cutAtPlan(cutLevel, True) rs.Command('_SelDup _delete') rs.EnableRedraw(True)
def MakePlan(elevation, viewDepthZ, geos): objs = rs.CopyObjects(geos) rs.HideObjects(geos) ############################################################################ print "Cutting Plan" allCrvs = [] #Make plane plane = Rhino.Geometry.Plane(rs.coerce3dpoint((0, 0, elevation)), rs.coerce3dvector((0, 0, 1))) planeNeg = Rhino.Geometry.Plane(rs.coerce3dpoint((0, 0, viewDepthZ)), rs.coerce3dvector((0, 0, 1))) ############################################################################ #Partition the geometry partitionedObjs = PartitionGeometry(objs, elevation, viewDepthZ) ############################################################################ #Intersection Curves #interCrvs = IntersectGeos(partitionedObjs[1], plane) ############################################################################ #Split Geometry #Get the bottom half of intersecting objs belowObjs = SplitGeometry(partitionedObjs[1], plane) print "A" #Get the top half of that previous geometry visibleObjs = SplitGeometry(partitionedObjs[0] + belowObjs, planeNeg, -1) rs.SelectObjects(visibleObjs) objs2del = rs.InvertSelectedObjects() rs.DeleteObjects(objs2del) print "A" ############################################################################ #Make 2D allCrvs += ProjectPlan(visibleObjs, plane) rs.DeleteObjects(visibleObjs) print "Plan Cut" rs.ShowObjects(geos) rs.HideObjects(allCrvs) return allCrvs
def get_preview_geometry(arr_curves): """duplicate the geometry for extension""" arr_exploded = [] arr_lines = [] for x in arr_curves: if rs.IsLine(x): arr_exploded.append(x) for i in xrange(len(arr_curves)): if rs.IsLine(arr_curves[i]): arr_lines.append(arr_curves[i]) arr_preview_exploded = rs.ExplodeCurves(arr_curves,False) arr_preview_lines = rs.CopyObjects(arr_lines) #Get locked objects return arr_preview_exploded + arr_preview_lines
def send2CAD(objs, newCoord, CADinMeters): if CADinMeters: transVec = rs.VectorCreate(newCoord, [0,0,0]) else: transVec = rs.VectorScale(newCoord, .001) newObjs = rs.CopyObjects(objs, transVec) if CADinMeters: rs.ScaleObjects(newObjs, [0,0,0], [.001,.001,.001]) print "scaled" rs.SelectObjects(newObjs) loc = " D:\\temp.dwg" rs.Command('_-Export '+loc+' _Enter') rs.DeleteObjects(newObjs) print "Sent" return None
def make_join(edge, n_joins, dx, dy, inner, truncate): pts = rs.DivideCurve(edge, n_joins) outer_pts, inner_pts, pairs_ordered = [], [], [] extrapt = None outer_pts = rs.AddPoints(pts) inner_pts = rs.CopyObjects(outer_pts, [dx, dy, 0]) if inner == True: extrapt = outer_pts[0] outer_pts = outer_pts[1:] else: extrapt = inner_pts[0] inner_pts = inner_pts[1:] pairs_o = zip(outer_pts[0::2], outer_pts[1::2]) pairs_i = zip(inner_pts[0::2], inner_pts[1::2]) if inner is True: pairs_ordered = flatten(zip(pairs_i, pairs_o)) endpts = [inner_pts[-2], inner_pts[-1]] else: pairs_ordered = flatten(zip(pairs_o, pairs_i)) endpts = [outer_pts[-2], outer_pts[-1]] pairs_ordered = pairs_ordered + endpts if truncate is True: v = rs.VectorUnitize( rs.VectorCreate(pairs_ordered[0], pairs_ordered[1])) v = rs.VectorScale(v, T_OBOX) rs.MoveObject(pairs_ordered[-1], v) rs.MoveObject(pairs_ordered[0], rs.VectorReverse(v)) pl = rs.AddPolyline(pairs_ordered) rs.DeleteObject(extrapt) rs.DeleteObjects(outer_pts) rs.DeleteObjects(inner_pts) return pl
if not HV3: HV3 = HV1 if not DiagV2: DiagV2 = DiagV1 if not DiagV3: DiagV3 = 9 if not No_Shed: No_Shed = 2 if not Plano: Plano = rs.WorldXYPlane() #decompoe o plano de trabalho nos componentes Origem e os eixos xyz pOr, eX, eY, eZ = Plano #-Copiando Curva inicial Curva = rs.CopyObjects(Curva, 10 * eY) BzSup1 = rs.coercecurve(Curva) #----Primeiro ponto do Eixo de Simetria---- #A variável Eixo_de_Simetria por entrada um float entre o e 1 ou #uma reta que intercepta a Curva no ponto do eixo #caso seja um float: if type(Eixo_de_Simetria) == float: #ptX1 = coordenadas da curva no ponto de interceção com o eixo de simetria #vct1 = tangente da curva no ponto #prm1 = parametro da curva no ponto ptX1, vtc1, prm1 = gh.EvaluateLength(BzSup1, Eixo_de_Simetria, True) ptAux = gh.Move(ptX1, -eY)[0] #-desenhando linha do Exio de simetria Eixo_de_Simetria = rs.AddLine(ptX1, ptAux) #caso seja uma linha
for j in xrange(len(points) - 1): if j < (len(points) - 2): vertex_ = [(c_index, int(j), int(j) + 1, int(j) + 1)] # print(vertex_) m = rs.AddMesh(points, vertex_) meshes.append(m) else: vertex_ = [(c_index, int(j), 0, 0)] # print(vertex_) m = rs.AddMesh(points, vertex_) meshes.append(m) mesh_joined = rs.JoinMeshes(meshes) return mesh_joined points = point_polyline(CURVE) # print(points) point_cp_0 = rs.coerce3dpointlist(rs.CopyObjects(points)) point_cp_1 = rs.coerce3dpointlist(rs.CopyObjects(points)) step = construct_mesh_step(point_cp_0) center = construct_mesh_center(point_cp_1) POINTS_ = points MESH_STEP_ = step MESH_CENTER_ = center
def createRectangularMatrix(): print("\n createRectangularMatrix commands \n") obj_ids = rs.GetObjects( "Select object(s) from which to create the rectangular matrix", 0, True, True) if obj_ids is None: return box = rs.BoundingBox(obj_ids) if not isinstance(box, list): return origin = rs.PointDivide(rs.PointAdd(box[0], box[6]), 2) nXdups = rs.GetInteger("Duplications X", 1, 1) rXdups = rs.GetReal("Duplications X rand", 0, 0, 100) / 100 nYdups = rs.GetInteger("Duplications Y", 1, 1) rYdups = rs.GetReal("Duplications Y rand", 0, 0, 100) / 100 nZdups = rs.GetInteger("Duplications Z", 1, 1) rZdups = rs.GetReal("Duplications Z rand", 0, 0, 10) / 100 nXspace = rs.GetReal("Spacing X", 1, 0) rXspace = rs.GetReal("Spacing X rand", 0, 0, 100) nYspace = rs.GetReal("Spacing Y", 1, 0) rYspace = rs.GetReal("Spacing Y rand", 0, 0, 100) nZspace = rs.GetReal("Spacing Z", 1, 0) rZspace = rs.GetReal("Spacing Z rand", 0, 0, 100) nXscale = rs.GetReal("Scale X", 1, 0) rXscale = rs.GetReal("Scale X rand", 0, 0, 100) nYscale = rs.GetReal("Scale Y", 1, 0) rYscale = rs.GetReal("Scale Y rand", 0, 0, 100) nZscale = rs.GetReal("Scale Z", 1, 0) rZscale = rs.GetReal("Scale Z rand", 0, 0, 100) nXrotate = rs.GetReal("Rotate X", 0, 0) rXrotate = rs.GetReal("Rotate X rand", 0, 0, 100) nYrotate = rs.GetReal("Rotate Y", 0, 0) rYrotate = rs.GetReal("Rotate Y rand", 0, 0, 100) nZrotate = rs.GetReal("Rotate Z", 0, 0) rZrotate = rs.GetReal("Rotate Z rand", 0, 0, 100) endpt = rs.GetPoint("To point") calc_val_real = lambda val, rand: val + uniform(-rand * val, rand * val) calc_val_int = lambda val, rand: val + int( round(uniform(-rand * val, rand * val))) xdups = calc_val_int(nXdups, rXdups) ydups = calc_val_int(nYdups, rYdups) zdups = calc_val_int(nZdups, rZdups) xspace = calc_val_real(nXspace, rXspace) yspace = calc_val_real(nYspace, rYspace) zspace = calc_val_real(nZspace, rZspace) xscale = calc_val_real(nXscale, rXscale) yscale = calc_val_real(nYscale, rYscale) zscale = calc_val_real(nZscale, rZscale) xrotate = calc_val_real(nXrotate, rXrotate) yrotate = calc_val_real(nYrotate, rYrotate) zrotate = calc_val_real(nZrotate, rZrotate) # Copy Points with Spacing for k in range(zdups): for j in range(ydups): for i in range(xdups): newpt = [ origin[0] + i * xspace, origin[1] + j * yspace, origin[2] + k * zspace ] translation1 = rs.VectorCreate(endpt, newpt) # translation2 = rs.VectorCreate(translation1, origin) copied_obj_ids = rs.CopyObjects(obj_ids, translation1) for obj in copied_obj_ids: rs.ScaleObject(obj, newpt, [xscale, yscale, zscale]) plane = rs.ViewCPlane() rs.RotateObject(obj, newpt, xrotate, plane.XAxis) rs.RotateObject(obj, newpt, yrotate, plane.YAxis) rs.RotateObject(obj, newpt, zrotate, plane.ZAxis)
def matchWObj(self, geoList): ref = rs.AddPoint(0, 0, 0) vec = rs.VectorCreate(rs.AddPoint(self.WObj), ref) rot = rs.RotateObjects(geoList, rs.AddPoint(0, 0, 0), -90, copy=True) return rs.CopyObjects(rot, vec)
def testDuplicationsAndSpaceAndScaleAndRotate(): print("\n testDuplicationsAndSpaceAndScaleAndRotate commands \n") obj_ids = rs.GetObjects( "Select object(s) from which to create the rectangular matrix", 0, True, True) if obj_ids is None: return box = rs.BoundingBox(obj_ids) if not isinstance(box, list): return origin = rs.PointDivide(rs.PointAdd(box[0], box[6]), 2) nXdups = rs.GetInteger("Max Duplications X", 1, 1) nYdups = rs.GetInteger("Max Duplications Y", 1, 1) nZdups = rs.GetInteger("Max Duplications Z", 1, 1) nXspace = rs.GetReal("Spacing X", 1, 0) rXspace = rs.GetReal("Spacing X rand", 0, 0, 100) / 100 nYspace = rs.GetReal("Spacing Y", 1, 0) rYspace = rs.GetReal("Spacing Y rand", 0, 0, 100) / 100 nZspace = rs.GetReal("Spacing Z", 1, 0) rZspace = rs.GetReal("Spacing Z rand", 0, 0, 100) / 100 nXscale = rs.GetReal("Scale X", 1, 0) rXscale = rs.GetReal("Scale X rand", 0, 0, 100) / 100 nYscale = rs.GetReal("Scale Y", 1, 0) rYscale = rs.GetReal("Scale Y rand", 0, 0, 100) / 100 nZscale = rs.GetReal("Scale Z", 1, 0) rZscale = rs.GetReal("Scale Z rand", 0, 0, 100) / 100 nXrotate = rs.GetReal("Rotate X", 0, 0, 360) rXrotate = rs.GetReal("Rotate X rand", 0, 0, 100) / 100 nYrotate = rs.GetReal("Rotate Y", 0, 0, 360) rYrotate = rs.GetReal("Rotate Y rand", 0, 0, 100) / 100 nZrotate = rs.GetReal("Rotate Z", 0, 0, 360) rZrotate = rs.GetReal("Rotate Z rand", 0, 0, 100) / 100 rKeep = 1 - rs.GetReal("Percent to erase", 0, 0, 100) / 100 endpt = rs.GetPoint("To point") sample_near_val = lambda val, rand: random.uniform(-rand * val, rand * val) translations = [] # Copy Points with Spacing for k in range(nZdups): for j in range(nYdups): for i in range(nXdups): newpt = [ origin[0] + i * nXspace + sample_near_val(nXspace, rXspace), origin[1] + j * nYspace + sample_near_val(nYspace, rYspace), origin[2] + k * nZspace + sample_near_val(nZspace, rZspace) ] translations = translations + [rs.VectorCreate(endpt, newpt)] nObjs = len(translations) objs_to_keep = random.sample(range(nObjs), int(round(nObjs * rKeep))) translations = [translations[i] for i in objs_to_keep] copied_objs = [] for tr in translations: copied_objs = copied_objs + rs.CopyObjects(obj_ids, tr) for obj in copied_objs: bb = rs.BoundingBox(obj) if bb: center_point = rs.PointDivide(rs.PointAdd(bb[0], bb[6]), 2) # pt = rs.SurfaceVolumeCentroid(obj) rs.ScaleObject(obj, center_point, [ nXscale + sample_near_val(nXscale, rXscale), nYscale + sample_near_val(nYscale, rYscale), nZscale + sample_near_val(nZscale, rZscale) ]) plane = rs.ViewCPlane() rs.RotateObject(obj, center_point, nXrotate + sample_near_val(nXrotate, rXrotate), plane.XAxis) rs.RotateObject(obj, center_point, nYrotate + sample_near_val(nYrotate, rYrotate), plane.YAxis) rs.RotateObject(obj, center_point, nZrotate + sample_near_val(nZrotate, rZrotate), plane.ZAxis)
def divideLR(self, ptList): Llist = rs.CopyObjects(ptList[0:][::2]) Rlist = rs.CopyObjects(ptList[1:][::2]) self.shift(Rlist, 4) return Llist, Rlist
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)
def CopyObjectsToLayer(objs, layer): copies = rs.CopyObjects(objs) rs.ObjectLayer(copies, layer)
def lb_generate_analysis(self): try: if self.m_test_points == None: print "missing grid objects" return #prepare paramters window_groups = [] #not included yet in eto interface name = 'default_name'#not included yet in eto interface sun_path_panel = list(self.Parents)[-1].get_sun_path_panel() sun_vectors = sun_path_panel.m_vectors hoys = sun_path_panel.m_hoys timestep = sun_path_panel.m_timestep #hb objects data hb_object_ids = self.m_hb_object_ids hb_object_types, hb_object_mats = self.lb_get_hb_objects_data() #project data folder = self.m_project_path_picker.FilePath filename = self.m_project_name_text_box.Text save_file_only = self.m_save_file_check_box.Checked #turn off last results layers if 'Eto_DisplayLayerIndex' in sc.sticky and sc.sticky['Eto_DisplayLayerIndex']: last_layer_index = sc.sticky['Eto_DisplayLayerIndex'] last_layer = Rhino.RhinoDoc.ActiveDoc.Layers.FindIndex(last_layer_index) last_layer_name = rs.LayerName(last_layer.Id, True) last_parentLayer = rs.LayerName(last_layer.ParentLayerId, True) rs.LayerVisible(last_parentLayer, False) results_layer = None # generate one analysis merging points/vector and meshes points_item = [] vectors_item = [] for index in range(len(self.m_test_points)): points_item += self.m_test_points[index] vectors_item += self.m_pts_vectors[index] mesh_item = self.m_output_mesh.pop(0) if len(self.m_output_mesh): mesh_item.Append(self.m_output_mesh) rs.EnableRedraw(False) LadybugEto.generateAnalysis(points_item, vectors_item, name, window_groups, sun_vectors, hoys, timestep, hb_object_ids, hb_object_types, hb_object_mats, folder, filename, save_file_only, [mesh_item]) #consolidate multiple result objects into one layer (workaround to #solve current ladybug_ResultVisualization.bakeObjects behaviour) layer_index = sc.sticky['Eto_DisplayLayerIndex'] last_layer = Rhino.RhinoDoc.ActiveDoc.Layers.FindIndex(layer_index) last_layer_name = rs.LayerName(last_layer.Id, True) p_layer_name = rs.LayerName(last_layer.ParentLayerId, True) #use first analysis layers if index == 0: results_layer_index = layer_index results_layer = last_layer_name results_p_layer = p_layer_name #delte all subsequent analysis layers elif last_layer_name <> results_layer: #Move all objects to analysis layer and delete layers objects_id = rs.ObjectsByLayer(last_layer_name) res = list(rs.ObjectLayer(obj_id, results_layer) for obj_id in objects_id) rs.DeleteLayer(last_layer_name) rs.DeleteLayer(p_layer_name) rs.EnableRedraw(True) #replace the sticky to results layer used sc.sticky['Eto_DisplayLayerIndex'] = results_layer_index #copy original analysis surfaces hb objects to analisys layer created rs.EnableRedraw(False) #copy analysis grid new_layer_name = rs.AddLayer(results_p_layer+"::Analysis_grid_objects", color=Color.Red) gridsurfs_ids = list(item.Tag for item in self.m_gridsurfs_list_box.Items) new_grid_objects = rs.CopyObjects(gridsurfs_ids) res = list(rs.ObjectLayer(obj_id, new_layer_name) for obj_id in new_grid_objects) #copy hb objects new_layer_name = rs.AddLayer(results_p_layer+"::HB_objects", color=Color.LightGreen) new_grid_objects = rs.CopyObjects(self.m_hb_object_ids) res = list(rs.ObjectLayer(obj_id, new_layer_name) for obj_id in new_grid_objects) rs.EnableRedraw(True) except Exception as e: print e
def findFitness(point): def testArrangement(sortedCurves, factor): totalBox = rs.BoundingBox(sortedCurves) sqrtSource = rs.Distance(totalBox[0], totalBox[1]) minLength = sqrtSource**0.5 minLength = minLength**factor def meetsLength(len, startCrv, endCrv): objects = [startCrv, endCrv] boundingBox = rs.BoundingBox(objects, in_world_coords=True) curLen = rs.Distance(boundingBox[0], boundingBox[1]) if curLen >= len: return True else: return False #Then, defining a list of the resulting lists. listOfLists = [] s = 0 #"Start" e = 0 #"End" #Loop that splits the list into smaller lists. while True: if (s + e) == len(sortedCurves) or s == len(sortedCurves): listOfLists.append(sortedCurves[s:s + e]) break elif meetsLength(minLength, sortedCurves[s], sortedCurves[s + e]) == True: listOfLists.append(sortedCurves[s:s + e]) s = s + e e = 1 continue else: e += 1 continue #Now to move them vertically. First, like with the horizontal movement, we need to create a function that finds the vertical offset between each line. def findVOffset(curCrv): currentBox = rs.BoundingBox(curCrv, in_world_coords=True) vHeight = rs.Distance(currentBox[0], currentBox[3]) offset = vHeight * 1.125 offset = 0 - offset return offset #And to move them. for i in range(len(listOfLists)): if i == len(listOfLists) - 1: break else: rs.MoveObject( listOfLists[i + 1], rs.VectorCreate(findAnchorPoint(listOfLists[i]), findAnchorPoint(listOfLists[i + 1]))) rs.MoveObject(listOfLists[i + 1], (0, findVOffset(listOfLists[i + 1]), 0)) sList = rs.CopyObjects(oList) rs.ShowObjects(sList) testArrangement(sList, point[0]) shapeBox = rs.BoundingBox(sList) width = rs.Distance(shapeBox[0], shapeBox[1]) height = rs.Distance(shapeBox[0], shapeBox[3]) numerator = abs(width - height) denominator = width + height denominator = denominator / 2 fitness = numerator / denominator fitness = fitness * 100 rs.DeleteObjects(sList) return fitness
def main(): global g_instances global g_parts global g_indent global g_materials #print(sys.version_info) # (2, 7, 0, 'beta', 0) dlg = rc.UI.SaveFileDialog() dlg.DefaultExt = "model" dlg.Filter = "RocketScience 3D Model (*.model)" dlg.InitialDirectory = os.path.dirname(sc.doc.Path) if not dlg.ShowSaveDialog(): return None selectedObjects = rs.SelectedObjects() objects = [] origin = [0, 0, 0] for object in selectedObjects: name = rs.ObjectName(object) type = rs.ObjectType(object) if type == rs.filter.point: if name.startswith("Origin"): origin = rs.PointCoordinates(object) else: objects.append(object) print("Processing " + str(len(objects)) + " object(s)") print("Origin is [%.2f,%.2f,%.2f]" % (origin[0], origin[1], origin[2])) rootInstance = \ { "name" : "*", "fullName" : "*", "type" : "*", "xform" : None, "parents" : [], "parts" : [], "touched" : False, } g_instances.append(rootInstance) objectsCopied = rs.CopyObjects(objects, rs.VectorScale(origin, -1)) for object in objectsCopied: processObject(object, [rootInstance]) output = open(dlg.FileName, "w") #output.write("# i <instance-type> <instance-name> " # "<parent-instance-name>\n") #output.write("# x <x-axis-x> <y-axis-x> <z-axis-x> <translation-x>\n") #output.write("# x <x-axis-y> <y-axis-y> <z-axis-y> <translation-y>\n") #output.write("# x <x-axis-z> <y-axis-z> <z-axis-z> <translation-z>\n") #output.write("# m <material-name> <ambient> <diffuse> <emission>\n") #output.write("# p <part-name> <instance-name> <material-name> " # "<vertices> <triangles>\n") #output.write("# v <pos-x> <pos-y> <pox-z> <norm-x> <norm-y> <norm-z>\n") #output.write("# t <vertex-1> <vertex-2> <vertex-3>\n") #output.write("\n") g_instances.sort(key=instanceSortKey) for instance in g_instances: parentCount = len(instance["parents"]) indent = g_indent * (parentCount - 1) parentName = "*" if instance["parents"]: parentName = instance["parents"][-1]["name"] line = format( "i%s %s %s %s" % (indent, instance["type"], instance["fullName"], parentName)) print(line) output.write(line + "\n") if parentCount < 1: xform = rc.Geometry.Transform(1.0) else: xform = instance["xform"] indent += " " output.write("x " + indent + formatHexFloats( [xform.M00, xform.M01, xform.M02, xform.M03], True) + "\n") output.write("x " + indent + formatHexFloats( [xform.M10, xform.M11, xform.M12, xform.M13], True) + "\n") output.write("x " + indent + formatHexFloats( [xform.M20, xform.M21, xform.M22, xform.M23], True) + "\n") for materialName, materialIdx in g_materials.iteritems(): material = sc.doc.Materials[materialIdx] ambient = material.AmbientColor diffuse = material.DiffuseColor emission = material.EmissionColor line = format( "m %s %s" % (materialName, formatColors([ambient, diffuse, emission]))) print(line) output.write(line + "\n") g_parts.sort(key=partSortKey) for part in g_parts: mesh = part["mesh"] line = format( "p %s %s %s %d %d" % (part["name"], part["instance"]["fullName"], part["material"], mesh.Vertices.Count, mesh.Faces.Count)) print(line) output.write(line + "\n") indent = " " for vertexIdx in range(0, mesh.Vertices.Count): vertex = mesh.Vertices[vertexIdx] normal = mesh.Normals[vertexIdx] output.write("v " + indent + formatHexFloats( [vertex.X, vertex.Y, vertex.Z, normal.X, normal.Y, normal.Z]) + "\n") line = lineInit = "t" + indent for faceIdx in range(0, mesh.Faces.Count): face = mesh.Faces[faceIdx] if not face.IsTriangle: print("WARNING: Non-triangle face %d" % (faceIdx)) part = format(" %d %d %d" % (face.A, face.B, face.C)) if len(line) + len(part) > 100: output.write(line + "\n") line = lineInit line += part if len(line) > 0: output.write(line + "\n") output.close()
"WindowVisibility"): #Panel has a window? panelBlockList += item[0].GetPanelProperty( "BlockInstances") panelBlockList = panelBlockList[0:-1:int( stepNumber)] #Nth panel filtering #--Collect current objects in key layers before exploding targeted blocks initDocGlassSet = set(rs.ObjectsByLayer("_P_Glass")) initDocMullionSet = set(rs.ObjectsByLayer("_P_Mullions")) initDocShadingSet = set(rs.ObjectsByLayer("_P_Shading")) initDocWallSet = set(rs.ObjectsByLayer("_P_Wall")) #Explode blocks of seleted panels tmpPanelElements = [] tmpPanelBlockList = rs.CopyObjects(panelBlockList) for tmpPanelBlock in tmpPanelBlockList: tmpPanelElements += rs.ExplodeBlockInstance(tmpPanelBlock) #--Collect new objects in key layers newDocGlassSet = set(rs.ObjectsByLayer("_P_Glass")) newDocMullionSet = set(rs.ObjectsByLayer("_P_Mullions")) newDocShadingSet = set(rs.ObjectsByLayer("_P_Shading")) newDocWallSet = set(rs.ObjectsByLayer("_P_Wall")) #Store Ladybug elements and delete leftovers lbGlassSet = set() lbMullionSet = set() lbShadingSet = set() lbWallSet = set() lbGlassSet = newDocGlassSet - initDocGlassSet