def get_reference_vector(b_obj): """pick a reference vector for deciding surface category. note that we can't pick [0,1,0] because the brep might be on a 45deg angle.""" base_ref_vect = rs.VectorCreate([0,1,0],[0,0,0]) up = rs.coerce3dvector([0,0,1]) down = rs.coerce3dvector([0,0,-1]) epsilon = 0.5 faces = b_obj.Faces print faces.Count ref_faces = [] ref_angle_rotation = 90 for k in faces: v = k.NormalAt(0.5,0.5) #top and botom of extrusion have IsSurface = False (why?) if not (v.EpsilonEquals(up,epsilon) or v.EpsilonEquals(down,epsilon)): ref_faces.append(k) angle = rs.VectorAngle(v,base_ref_vect) angle = angle%90 print angle ref_angle_rotation = min(ref_angle_rotation,angle) new_ref_vector = rs.VectorRotate(base_ref_vect,ref_angle_rotation,[0,0,1]) #debug: verify this angle is good # for k in faces: # v = k.NormalAt(0.5,0.5) #top and botom of extrusion have IsSurface = False (why?) # if not (v.EpsilonEquals(up,epsilon) or v.EpsilonEquals(down,epsilon)): # ref_faces.append(k) # angle = rs.VectorAngle(v,new_ref_vector) # angle = angle%180 # print angle return new_ref_vector
def MoveWithVector (treeIn, profPointTreeIn, vectorTreeIn, thicknessIn, angleIn, treeOut): profMax = GridCornerBig (profPointTreeIn) profMin = GridCornerSmall (profPointTreeIn) max = GridCornerBig (treeIn) for i in range(treeIn.BranchCount): treeBranch = treeIn.Branch(i) treePath = treeIn.Path(i) profBranch = profPointTreeIn.Branch(i) vectorBranch = vectorTreeIn.Branch(i) thicknessBranch = thicknessIn.Branch(i) angleBranch = angleIn.Branch(i) for j in range(treeBranch.Count): elem = treeBranch[j] profPoint = profBranch [j] vector = vectorBranch [j] v = thicknessBranch [j] angle = angleBranch [j] if type != 0: elemLapos = rs.AddPoint (elem.X,elem.Y,0) elemLapos = rs.coerce3dvector (elemLapos) #angle = rs.VectorAngle ([1,0,0], elemLapos) betaRad = math.radians (beta) gammaRad = math.radians (angle) if gammaRad > betaRad/2: gammaRad = gammaRad - betaRad/2 else: gammaRad = betaRad/2 - gammaRad v = (math.cos (betaRad/2)) / (math.cos (gammaRad)) *v vec = rs.coerce3dpoint (vector) rotVecX = vec.X rotVecZ = vec.Y rotVecY = vec.Z rotVec = rs.AddPoint (rotVecX, rotVecY, rotVecZ) rotVec = rs.coerce3dpoint (rotVec) ORIGO = rs.AddPoint (0,0,0) ORIGO = rs.coerce3dpoint (ORIGO) VECTOR = rs.RotateObject(rotVec, ORIGO, angle, [0,0,1]) vector = rs.coerce3dvector (VECTOR) vector = vector * v elem = rs.coerce3dpoint (elem) MovePoint = rs.MoveObject (elem, vector) MovePoint = rs.coerce3dpoint (MovePoint) treeOut.Add (elem, treePath)
def VectorInternalDivision(vector1, vector2, ratio1, ratio2): vector1 = rs.coerce3dvector(vector1) vector2 = rs.coerce3dvector(vector2) return rs.VectorDivide( rs.VectorAdd(rs.VectorScale(vector1, ratio2), rs.VectorScale(vector2, ratio1)), ratio1 + ratio2)
def Orthogonal(vecIn): vecIn = rs.VectorUnitize(vecIn) # Pick any vector which isn't aligned to the input otherVec = rs.coerce3dvector((1.0, 0.0, 0.0)) if abs(rs.VectorDotProduct(vecIn, otherVec)) > 0.99: otherVec = rs.coerce3dvector((0.0, 1.0, 0.0)) # Create a unit length orthogonal to both the other one, and the original one return rs.VectorUnitize(rs.VectorCrossProduct(vecIn, otherVec))
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_face_category(f,v): """pick category: 0: side srfs that get extended 1: side srfs that get shortened 2: top surfaces""" normal = f.NormalAt(0.5,0.5) epsilon = 0.5 up = rs.coerce3dvector([0,0,1]) down = rs.coerce3dvector([0,0,-1]) compare_angle = min(rs.VectorAngle(normal,v),rs.VectorAngle(normal,rs.VectorReverse(v))) if normal.EpsilonEquals(up,epsilon) or normal.EpsilonEquals(down,epsilon): return 2 elif 88 < compare_angle < 92: return 1 else: return 0
def IntersectGeo(obj, level): tolerance = rs.UnitAbsoluteTolerance() plane = rc.Geometry.Plane(rs.coerce3dpoint((0, 0, level)), rs.coerce3dvector((0, 0, 1))) finalCurves = [] #BLOCKS if rs.IsBlockInstance(obj): matrix = rs.BlockInstanceXform(obj) blockObjs = rs.BlockObjects(rs.BlockInstanceName(obj)) for eachBlockObj in blockObjs: newCopy = rs.CopyObject(eachBlockObj) xformedObj = rs.TransformObject(newCopy, matrix) #EXTRUSIONS if isinstance(xformedObj, rc.Geometry.Extrusion): temp = sc.doc.Objects.AddBrep(xformedObj.ToBrep(False)) xformedObj = rs.coercebrep(temp) rs.DeleteObject(temp) #BREPS IN BLOCK result = IntersectBrepPlane(xformedObj, plane) if result is None: continue for each in result: if each is not None: finalCurves.append(each) rs.DeleteObject(xformedObj) #MESHES IN BLOCK <---This code might not be necessary result = IntersectMeshPlane(xformedObj, plane) if result is None: continue for each in result: if each is not None: finalCurves.append(each) rs.DeleteObject(xformedObj) #BREPS elif rs.IsBrep(obj): result = IntersectBrepPlane(obj, plane) if result is None: return None for each in result: if each is not None: finalCurves.append(each) #MESHES elif rs.IsMesh(obj): result = IntersectMeshPlane(obj, plane) if result is None: return None for each in result: if each is not None: finalCurves.append(each) return finalCurves
def get_surface_outline(b_geo): """get the surface outline and project to the surface's baseplane.""" initial_boundary_guids = [] initial_boundary_crv = [] bb = rs.BoundingBox(b_geo) proj_plane = Rhino.Geometry.Plane.WorldXY proj_plane.Translate(rs.coerce3dvector([0, 0, bb[0].Z])) for e in b_geo.Edges: initial_boundary_crv.append( Rhino.Geometry.Curve.ProjectToPlane(e.EdgeCurve, proj_plane)) joined_boundary_crv = Rhino.Geometry.Curve.JoinCurves( initial_boundary_crv, D_TOL) if len(joined_boundary_crv) == 1: return joined_boundary_crv else: print "Script Error: more than one surface boundary outline. Please save this file and report error." return None
def ImportLighthouseSensorsFromJSON(filename): print "Reading", filename contents = file(filename).read() if "{" not in contents: raise Exception("Malformed JSON") header = contents[0:contents.find('{')] print header try: layername = os.path.splitext(os.path.basename(filename))[0].lower() except: layername = "sensors" jsonstr = contents[contents.find('{'):] data = json.loads(jsonstr) originalLayer = rs.CurrentLayer() layername = rs.AddLayer(layername) rs.CurrentLayer(layername) rs.LayerColor(layername, RandomSaturatedColor()) groupName = rs.AddGroup(layername) SENSOR_RADIUS_MM = 3.0 SENSOR_NORMAL_LENGTH_MM = 8.0 for point, normal in zip(data['modelPoints'], data['modelNormals']): position = rs.coerce3dvector([x * 1000.0 for x in point]) normal = rs.VectorUnitize(normal) normalOrthoA = Orthogonal(normal) normalOrthoB = rs.VectorCrossProduct(normalOrthoA, normal) objID = rs.AddCircle3Pt(position + SENSOR_RADIUS_MM * normalOrthoA, position - SENSOR_RADIUS_MM * normalOrthoA, position + SENSOR_RADIUS_MM * normalOrthoB) rs.AddObjectToGroup(objID, groupName) objID = rs.AddLine(position, position + SENSOR_NORMAL_LENGTH_MM * normal) rs.AddObjectToGroup(objID, groupName) rs.CurrentLayer(originalLayer)
def get_building_footprints(building_breps, planes): """extract the footprints from the buildings""" #rs.EnableRedraw() plane_sections = [] slice_depth = [] for b in building_breps: for i, p in enumerate(planes): s = get_section(rs.coercebrep(b), p) if s: plane_sections.append(s[0]) slice_depth.append(i) break for section, d in zip(plane_sections, slice_depth): k = wrh.add_curve_to_layer(section, 1) #rs.ObjectLayer(k,"Default") #print section m = zip(plane_sections, slice_depth) new_boolean_list = [] for item in m: if item[1] > 0: transformation = Rhino.Geometry.Transform.Translation( rs.coerce3dvector([0, 0, -THICKNESS])) new_crv = item[0].Transform(transformation) new_level = item[1] - 1 new_boolean_list.append((new_crv, new_level)) else: new_boolean_list.append(item) a, b = zip(*new_boolean_list) #for section,d in zip(a,b): # print section, d #rs.Redraw() #rs.EnableRedraw(False) return
def ProfileCurveThings (treeIn, profCrv, profPointTreeOut, vectorTreeOut, vectorLineTree, tOut): MaxCoord = GridCornerBig (treeIn) x_max = MaxCoord.X y_max = MaxCoord.Y z_max = MaxCoord.Z profPointList = [] profVecDirection = [] vectorList = [] curvatureTree = datatree [sys.Object] () directionTree = datatree [sys.Object] () Crv = rs.coercecurve (profCrv) start = rs.CurveStartPoint (Crv) end = rs.CurveEndPoint (Crv) if start.Y > end.Y : Crv = rh.Geometry.Curve.Reverse (Crv) for i in range(treeIn.BranchCount): treeBranch = treeIn.Branch(i) treePath = treeIn.Path(i) for j in range(treeBranch.Count): elem = treeBranch[j] x = elem.X y = elem.Y z = elem.Z Yarany = y / y_max crvPoint = rh.Geometry.Curve.PointAtNormalizedLength(profCrv, Yarany) crvPoint = rs.coerce3dpoint (crvPoint) t = rs.CurveClosestPoint (profCrv, crvPoint) curvature = rs.CurveCurvature(profCrv, t)[4] tangent = rs.CurveCurvature(profCrv, t)[1] angle1 = rs.VectorAngle ([0,1,0], curvature) angle2 = rs.VectorAngle ([0,1,0], tangent) curvatureRot = curvature curvatureRot = rs.coerce3dpoint (curvatureRot) rs.RotateObject (curvatureRot, [0,0,0], 90, [0,0,1]) curvatureRot = rs.coerce3dvector (curvatureRot) angle = rs.VectorAngle (curvatureRot, tangent) curvature = rs.coerce3dpoint(curvature) if 179.99 < angle <180.01: angleDirect = 0 else: angleDirect = 1 profPointList.append (crvPoint) profVecDirection.append (angleDirect) vectorList.append (curvature) curvatureTree.Add (curvature, treePath) profPointTreeOut.Add (crvPoint, treePath) directionTree.Add (angleDirect, treePath) tOut.Add (Yarany, treePath) profPoint_x_List = [] for i in range (profPointList.Count): profPoint = profPointList [i] profPoint_x = profPoint.X profPoint_x_List.append (profPoint_x) a = 0 for i in range (profPoint_x_List.Count): x = profPoint_x_List [i] Xabs = math.fabs (x) if Xabs > a: b = i a = Xabs c = x directByMax = profVecDirection [b] vectorByMax = vectorList [b] pointByMax = profPointList [b] stableByMax = pointByMax pointX = math.fabs (stableByMax.X) moveByMax = pointByMax unitVecByMax = rs.VectorUnitize (vectorByMax) rs.MoveObject (moveByMax, 5* unitVecByMax) moveX = math.fabs (moveByMax.X) if moveX > pointX: mirror = 1 else: mirror = 0 for i in range(curvatureTree.BranchCount): treeBranch = curvatureTree.Branch(i) treePath = curvatureTree.Path(i) pointBranch = profPointTreeOut.Branch(i) directionBranch = directionTree.Branch(i) for j in range(treeBranch.Count): curvature = treeBranch [j] crvPoint = pointBranch [j] direction = directionBranch [j] curvature = rs.coerce3dpoint(curvature) if mirror == 0: if direction != directByMax: rs.RotateObject (curvature, [0,0,0], 180, [0,0,1]) if mirror == 1: if direction == directByMax: rs.RotateObject (curvature, [0,0,0], 180, [0,0,1]) curvature = rs.coerce3dvector(curvature) unitCrvVec = rs.VectorUnitize (curvature) if c < 0: unitCrvVec2 = - unitCrvVec else: unitCrvVec2 = unitCrvVec unitCrvVec = rs.coerce3dvector (unitCrvVec) unitCrvVec2 = rs.coerce3dvector (unitCrvVec2) moveCrvPoint = crvPoint + (unitCrvVec*5) moveCrvPoint = rs.coerce3dpoint (moveCrvPoint) vectorLine = rs.AddLine (crvPoint, moveCrvPoint) vectorTreeOut.Add (unitCrvVec2, treePath) vectorLineTree.Add (vectorLine, treePath)
def FixedFractureGen(n, aspect_ratio=None, sides=None): """ A function to add a fixed number of circles in a cube. It also writes data to fracture data text file for regenerating fracture networks. """ if fracture_shape == 'circle': # initialize a to store fractures fracture_list = [] # a loop to insert the fixed number of fractures for i in range(n): #layer name for the frcature layer_name = "FRACTURE_" + str(i + 1) #create an istance of Fracture class frac = Fracture() #store fracture name frac.fracture_name = layer_name #generate origin for fracture origin = GeneratePoint(boxlength) #store farcture center frac.fracture_center = origin #convert the origin to a plane plane = InclinePlane(origin) #add layer and color rs.AddLayer(layer_name, rs.CreateColor(0, 255, 0)) #make current layer rs.CurrentLayer(layer_name) #insert the fracture in the domain my_circle = rs.AddCircle(plane, radius) #circle_list.append(my_circle) surf = rs.AddPlanarSrf(my_circle) #delete initial fracture drawn which is a curve rs.DeleteObject(my_circle) #save fracture's GUID frac.fracture_GUID = surf[0] #append fracture into fracture list fracture_list.append(frac) elif fracture_shape == 'ellipse': #list to store fracture surface GUIDs fracture_list = [] for i in range(n): #layer name for the frcature layer_name = "FRACTURE_" + str(i + 1) #create an istance of Fracture class frac = Fracture() frac.fracture_name = layer_name #generate fracture origin origin = GeneratePoint(boxlength) frac.fracture_center = origin #plane for fracture plane = InclinePlane(origin) #calculate r_y ry = radius / aspect_ratio #create layer for fracture rs.AddLayer(layer_name, rs.CreateColor(0, 255, 0)) rs.CurrentLayer(layer_name) #draw ellipse fracture = rs.AddEllipse(plane, radius, ry) # write the plane, r_x and r_y to file for re-plotting ##file.write("\n" + str(plane[0]) + "," + str(plane[1]) + "," + str(plane[2]) + "," + str(radius) + ","+ str(ry)) #make fracture a surface frac_surf = rs.AddPlanarSrf(fracture) #delete initial fracture drawn which is a curve rs.DeleteObject(fracture) #append surface GUID to list of fracture surfaces frac.fracture_GUID = frac_surf[0] fracture_list.append(frac) elif fracture_shape == 'polygon': #list to store fracture surface GUIDs fracture_list = [] #write the shape type ##file.write('\npolygon\n') for i in range(n): layer_name = "FRACTURE_" + str(i + 1) frac = Fracture() frac.fracture_name = layer_name #theta in radian theta_rad = (2 * math.pi) / sides #theta in degree (interior angles) theta_deg = theta_rad * (180 / math.pi) #generate origin origin = GeneratePoint(boxlength) frac.fracture_center = origin #create a 3D point object which isn't visible to the rhino document pt_01 = rs.coerce3dvector( [radius + origin[0], origin[1], origin[2]]) #empty list to store all points points = [] #a rotation axis ax = rs.coerce3dvector([0, 0, 1]) #loop to generate points for polygon vertices #file.write("\n") for j in range(sides): #rotation transform with rotation from the origin trans = rs.XformRotation2(theta_deg * j, ax, origin) #transform the original 3D point and append to list points.append(rs.PointTransform(pt_01, trans)) # append the initial point to close the polygon points.append(pt_01) # create layer for fracture # layer_name = "FRACTURE_" + str(i+1) rs.AddLayer(layer_name, rs.CreateColor(0, 255, 0)) rs.CurrentLayer(layer_name) # get GUID of created polygon polygon = rs.AddPolyline(points) # polygon = rs.AddPolyline(points) plane = InclinePlane(origin, boxlength) cob = rs.XformChangeBasis(rs.WorldXYPlane(), plane) shear2d = rs.XformIdentity() shear2d[0, 2] = math.tan(math.radians(45.0)) cob_inverse = rs.XformChangeBasis(plane, rs.WorldXYPlane()) temp = rs.XformMultiply(shear2d, cob) xform = rs.XformMultiply(cob_inverse, temp) fracture = rs.TransformObjects(polygon, xform, False) # make fracture a surface frac_surf = rs.AddPlanarSrf(fracture) # delete initial fracture drawn which is a curve rs.DeleteObject(fracture) frac.fracture_GUID = frac_surf[0] fracture_list.append(frac) return fracture_list
def RandomFractureGen(frac_min, frac_max, radius_min, radius_max, aspect_min=None, aspect_max=None, polysize_min=None, polysize_max=None): """ Funtions to generate fractures of random number and sizes Parameters ---------- frac_min: int minimum number of fractures to generate frac_max: int maximum number of fractures to generate radius_min: float minimum size of fractures radius_max: float maximum number of fractures to generate aspect_min: float minimum aspect ratio fpr ellipses (Default:None) aspect_max: float maximum aspect ratio fpr ellipses (Default:None) polysize_min: int minimum size of polygon (Default:None) polysize_max: int maximum size of polygon (Default:None) """ # randomly determine the number of fractures to generate num_frac = random.randint(frac_min, frac_max) # open file and append to it file = open(path, 'a') if fracture_shape == 'circle': # write the shape type file.write('\ncircle') # initialize list to store fractures fracture_list = [] # loop to generate fractures for i in range(num_frac): # name the layer layer_name = "FRACTURE_" + str(i + 1) # an instance of fracture object frac = Fracture() # get fracture name frac.fracture_name = layer_name # generate fracture center origin = GeneratePoint(boxlength) # store fracture center frac.fracture_center = origin # convert the origin to a plane plane = InclinePlane(origin, boxlength) # add layer and create color for it rs.AddLayer(layer_name, rs.CreateColor(0, 255, 0)) # make layer current layer rs.CurrentLayer(layer_name) # generate fracture size radius = FractureSize(size_dist, radius_min, radius_max) # insert the circle in the domain my_circle = rs.AddCircle(plane, radius) # write the plane and radius to file for re-plotting file.write("\n" + str(plane[0]) + "," + str(plane[1]) + "," + str(plane[2]) + "," + str(radius)) surf = rs.AddPlanarSrf(my_circle) # delete initial fracture drawn which is a curve rs.DeleteObject(my_circle) # set fracture guid into its object frac.fracture_GUID = surf[0] fracture_list.append(frac) elif fracture_shape == 'ellipse': # initialize list to store fractures fracture_list = [] # write the shape type file.write('\nellipse') for i in range(num_frac): # name the layer layer_name = "FRACTURE_" + str(i + 1) # an instance of fracture object frac = Fracture() # get fracture name frac.fracture_name = layer_name # generate fracture center origin = GeneratePoint(boxlength) # store fracture center frac.fracture_center = origin # plane for fracture plane = InclinePlane(origin, boxlength) # randomly generate radius(rx) radius = FractureSize(size_dist, radius_min, radius_max) # randomly generate aspect ratio aspect_ratio = random.randint(aspect_min, aspect_max) # calculate r_y ry = radius / aspect_ratio # add layer with color rs.AddLayer(layer_name, rs.CreateColor(0, 255, 0)) # make current layer rs.CurrentLayer(layer_name) # draw fracture fracture = rs.AddEllipse(plane, radius, ry) # write the plane, r_x and r_y to file for re-plotting file.write("\n" + str(plane[0]) + "," + str(plane[1]) + "," + str(plane[2]) + "," + str(radius) + "," + str(ry)) # make fracture a surface frac_surf = rs.AddPlanarSrf(fracture) # delete initial fracture drawn which is a curve rs.DeleteObject(fracture) # set fracture guid into its object frac.fracture_GUID = frac_surf[0] # append fracture guid to list fracture_list.append(frac) elif fracture_shape == 'polygon': # initialize list to store fractures fracture_list = [] # write the shape type file.write('\npolygon\n') for i in range(num_frac): # name the layer layer_name = "FRACTURE" + str(i + 1) # an instance of fracture class frac = Fracture() # get farcture name frac.fracture_name = layer_name # randomly determine the sides of the polygon sides = random.randint(polysize_min, polysize_max) # theta in radian theta_rad = (2 * math.pi) / sides # theta in degree (interior angles) theta_deg = theta_rad * (180 / math.pi) # generate origin origin = GeneratePoint(boxlength) # save fracture center frac.fracture_center = origin # randomly generate radius(rx) radius = FractureSize(size_dist, radius_min, radius_max) # create a 3D point object which isn't visible to the rhino document pt_01 = rs.coerce3dvector( [radius + origin[0], origin[1], origin[2]]) # empty list to store all points points = [] # a rotation axis ax = rs.coerce3dvector([0, 0, 1]) # loop to generate points for polygon vertices for j in range(sides): # rotation transform with rotation from the origin trans = rs.XformRotation2(theta_deg * j, ax, origin) # transform the original 3D point and append to list points.append(rs.PointTransform(pt_01, trans)) if j == 0: file.write( str(rs.PointTransform(pt_01, trans)[0]) + "," + str(rs.PointTransform(pt_01, trans)[1]) + "," + str(rs.PointTransform(pt_01, trans)[2]) + ",") if j != 0: file.write( str(rs.PointTransform(pt_01, trans)[0]) + "," + str(rs.PointTransform(pt_01, trans)[1]) + "," + str(rs.PointTransform(pt_01, trans)[2]) + ",") # append the initial point to close the polygon points.append(pt_01) file.write( str(pt_01[0]) + "," + str(pt_01[1]) + "," + str(pt_01[2]) + ",") # create layer for fracture layer_name = "FRACTURE_" + str(i + 1) rs.AddLayer(layer_name, rs.CreateColor(0, 255, 0)) rs.CurrentLayer(layer_name) # get GUID of created polygon polygon = rs.AddPolyline(points) # get the plane plane = InclinePlane(origin, boxlength) # transform the polygon to the plane cob = rs.XformChangeBasis(rs.WorldXYPlane(), plane) shear2d = rs.XformIdentity() shear2d[0, 2] = math.tan(math.radians(45.0)) cob_inverse = rs.XformChangeBasis(plane, rs.WorldXYPlane()) temp = rs.XformMultiply(shear2d, cob) xform = rs.XformMultiply(cob_inverse, temp) fracture = rs.TransformObjects(polygon, xform, False) # write to file #file.write(str(origin[0]) + "," + str(origin[1]) + "," + str(origin[2])+ "," ) file.write( str(plane[0]) + "," + str(plane[1]) + "," + str(plane[2]) + "," + str(sides) + "\n") # make fracture a surface frac_surf = rs.AddPlanarSrf(fracture) # delete initial fracture drawn which is a curve rs.DeleteObject(fracture) # set fracture guid into its objects frac.fracture_GUID = frac_surf[0] # append fracture guid to list fracture_list.append(frac) # close file file.close() return fracture_list
1, 1, 1) #(non uniform scale can throw error someimtes(ex.cirles)) rotationZ = 0 isTilable = False isTrimmed = False dblWindowVoidDepth = 0 customSystem = None #check for object type : Brep or dynamicGeometry instance if _geometry and _geometry[0]: if type(_geometry[0]) == rc.Geometry.Brep: newCustomGeometry = _geometry elif str(type(_geometry[0])) == "<type 'instance'>": newCustomGeometry = _geometry[0] if numInputs > 1 and upAxisVector <> None: vecUpAxis = rs.coerce3dvector(upAxisVector) if numInputs > 2 and placementVector <> None: vecPlacement = rs.coerce3dvector(placementVector) if numInputs > 3 and scaleVector <> None: vecScaleFactor = rs.coerce3dvector(scaleVector) if numInputs > 4 and rotation <> None: rotationZ = eval(str(rotation)) if numInputs > 5 and tilable <> None: isTilable = tilable if numInputs > 6 and trimToPanelSize <> None: isTrimmed = trimToPanelSize if numInputs > 7 and windowVoidDepth <> None: dblWindowVoidDepth = windowVoidDepth customSystem = [ newCustomGeometry, vecPlacement, vecScaleFactor, vecUpAxis, isTilable, rotationZ, dblWindowVoidDepth, isTrimmed ] else:
def rc_cut_plan(boundary_brep, cut_heights, floor_guids, use_epsilon): bb = rs.BoundingBox(boundary_brep) max_z = bb[4].Z min_z = bb[0].Z crv_list, layer_list, refpt_list, bdims_list = [[], [], [], []] for i, guids in enumerate(floor_guids): if not (min_z < cut_heights[i] < max_z): continue outline_crv, internals, refpt, bdims = process_floor( guids, boundary_brep, cut_heights[i]) mp = Rhino.Geometry.AreaMassProperties.Compute(outline_crv) outline_crv_centroid = mp.Centroid corner_style = Rhino.Geometry.CurveOffsetCornerStyle.Sharp offset_crv = outline_crv.Offset(outline_crv_centroid, rs.coerce3dvector([0, 0, 1]), THICKNESS, D_TOL, corner_style) offset_crv_geometry = offset_crv[0] crv_list.append([[offset_crv_geometry], internals]) layer_list.append([LCUT_INDICES[1], LCUT_INDICES[2]]) refpt_list.append(refpt) bdims_list.append(bdims) #...brep conversion may be necessary if len(crv_list) == 0: print "Error: Cut planes do not intersect the envelope brep" return None #set base for output. xbase = 0 ybase = 0 #set the amount to move up from the bottom of the brep for cutting the lower outline. #this should be replaced by a projection of the bottom face of the brep. epsilon = D_TOL * 2 select_items = [] increment = max(d.X for d in bdims_list) + GAP_SIZE * 1 dplane_list = get_drawing_planes(bdims_list, rs.WorldXYPlane(), GAP_SIZE) refplane_list = [rs.MovePlane(rs.WorldXYPlane(), pt) for pt in refpt_list] for i, floor in enumerate(crv_list): t = Rhino.Geometry.Transform.ChangeBasis(dplane_list[i], refplane_list[i]) for j, layer_crvs in enumerate(floor): for c in layer_crvs: c.Transform(t) select_items.extend( wru.add_curves_to_layer(layer_crvs, layer_list[i][j])) labelpt = (bdims_list[i].X / 2 + dplane_list[i].Origin.X, bdims_list[i].Y / 2 + dplane_list[i].OriginY, 0) td = rs.AddTextDot(str(i + 1), labelpt) rs.ObjectLayer(td, "XXX_LCUT_00-GUIDES") select_items.append(td) rs.UnselectAllObjects() rs.SelectObjects(select_items) rs.Redraw() rs.EnableRedraw(True)
if not openStudioIsReady: print "Problem loading OSM. Have you let HB fly?" else: osm = ops.Model() # BREP for i in range(len(breps)): brep = breps[i] osm_space = ops.Space(osm) osm_space.setName("space_{}".format(i)) # ghlib methods faces = ghlib.components.DeconstructBrep(rs.coercebrep(brep))[0] brep_vec = rs.coerce3dvector(ghlib.components.Area(brep)[1]) # SURFACES for j in range(len(faces)): face = faces[j] edges = ghlib.components.DeconstructBrep(face)[1] face_curve = rc.Geometry.Curve.JoinCurves(edges, TOL)[0] nc = face_curve.ToNurbsCurve() points = [nc.Points[i_].Location for i_ in xrange(nc.Points.Count)] points.pop() # Sort the face normals of your space ndist, rndist = get_norm_dist(face_curve, points, brep_vec)