def offsetItems(self): self.additiveObj = rs.CopyObject( self.additiveObj, (0, 0, self.gcoder.getLayerHeight() * 0.9)) self.contactSurface = rs.CopyObject( self.contactSurface, (0, 0, self.gcoder.getLayerHeight() * 0.9)) return
def wave_line(values, r, in_d): ### interpolation dist # inter_dist = 4 * 0.5 inter_dist = in_d for i in xrange(len(values)): tmp_pt = rs.AddPoint(values[i], i * r, 0) tmp_pt_m = rs.MirrorObject(tmp_pt, (0, 0, 0), (0, 10, 0), True) # zigzag if i % 2 == 0: tmp_pt_0 = rs.CopyObject(tmp_pt) tmp_pt_0 = rs.MoveObject(tmp_pt_0, (0, -1 * (inter_dist), 0)) tmp_pt_1 = rs.CopyObject(tmp_pt) tmp_pt_1 = rs.MoveObject(tmp_pt_1, (0, 1 * (inter_dist), 0)) zigzag.append(tmp_pt_0) zigzag.append(tmp_pt_1) else: tmp_pt_0 = rs.CopyObject(tmp_pt_m) tmp_pt_0 = rs.MoveObject(tmp_pt_0, (0, -1 * (inter_dist), 0)) tmp_pt_1 = rs.CopyObject(tmp_pt_m) tmp_pt_1 = rs.MoveObject(tmp_pt_1, (0, 1 * (inter_dist), 0)) zigzag.append(tmp_pt_0) zigzag.append(tmp_pt_1) tmp_polyline = rs.AddPolyline(zigzag) return zigzag, tmp_polyline
def CheckRunLengths(runs): lengthComment = '' for i, run in enumerate(runs): dist = rs.Distance(rs.CurveStartPoint(run[0]), rs.CurveStartPoint(run[1])) if dist > 360: lengthComment += 'Run {} requires a landing\n'.format(i + 1) templine = rs.AddLine(rs.CurveStartPoint(run[0]), rs.CurveStartPoint(run[1])) mdPt = rs.CurveMidPoint(templine) vec = rs.VectorCreate(mdPt, rs.CurveStartPoint(run[0])) landingCenter = rs.CopyObject(run[0], vec) vec = rs.VectorScale(rs.VectorUnitize(vec), 30) upperLine = rs.CopyObject(landingCenter, vec) vec = rs.VectorReverse(vec) lowerLine = rs.MoveObject(landingCenter, vec) rs.DeleteObject(templine) run.insert(1, lowerLine) run.insert(2, upperLine) flatList = [] for item in runs: for each in item: flatList.append(each) pairs = [] for i in range(0, len(flatList), 2): pairs.append([flatList[i], flatList[i + 1]]) return pairs, lengthComment
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 getExtendedCrv(self, crvList, dist=50, layer_height=2.5, vecMul=.66): segmentCount = int(math.floor(dist / layer_height)) - 1 tmpList = [] fullHeight = [] for i in range(len(crvList)): extendedCrv = rs.ExtendCurveLength(crvList[i], 2, 0, dist) fullHeight.append(extendedCrv) domStart, domEnd = rs.CurveDomain(extendedCrv) trimmedCrv = rs.TrimCurve(extendedCrv, (domStart, 0)) tmpList.append(trimmedCrv) tmp = [] ###Smooth Curves### for i in range(len(tmpList)): bottomPt = rs.CurveEndPoint(tmpList[i]) zVec = rs.VectorAdd((0, 0, 0), (0, 0, dist)) topPt = rs.CopyObject(bottomPt, zVec) line = rs.AddLine(bottomPt, topPt) crvPts = rs.DivideCurve(tmpList[i], segmentCount) LinePts = rs.DivideCurve(line, segmentCount) for i in range(segmentCount): tmpVec = rs.VectorCreate(LinePts[segmentCount - i - 1], crvPts[i]) tmpVec = rs.VectorScale(tmpVec, vecMul) rs.MoveObject(crvPts[i], tmpVec) tmp.append(rs.AddInterpCurve(crvPts)) result = [] for crv in tmp: crvLen = rs.CurveLength(crv) if crvLen < dist: tmpExt = dist - crvLen result.append(rs.ExtendCurveLength(crv, 2, 0, tmpExt)) else: result.append(rs.CopyObject(crv)) return result
def draw_arc(p, theta, k): #k=-1,1 p1 = rs.AddPoint(p) p2 = rs.CopyObject(p1, polar(t, theta, 0)) p3 = rs.CopyObject(p1, polar(t / 2, theta, 0)) p4 = rs.CopyObject(p3, (0, 0, t / 4 * k)) arc = rs.AddArc3Pt(p1, p2, p4) return arc
def mergeLR(self, Llist, Rlist): assert (len(Llist) == len(Rlist)) mergedList = [] for i in range(len(Llist)): if rs.CurveLength(Llist[i]) >= rs.CurveLength(Rlist[i]): mergedList.append(rs.CopyObject(Llist[i])) else: mergedList.append(rs.CopyObject(Rlist[i])) return mergedList
def _FuselageLongitudinalGuideCurves(NoseLengthRatio, TailLengthRatio): # Internal function. Defines the four longitudinal curves that outline the # fuselage (outer mould line). FSVU, FSVL = _AirlinerFuselageSideView(NoseLengthRatio, TailLengthRatio) FSVUCurve = rs.AddCurve(FSVU) FSVLCurve = rs.AddCurve(FSVL) AFPVPort, NoseEndX, TailStartX = _AirlinerFuselagePlanView( NoseLengthRatio, TailLengthRatio) # Generate plan view PlanPortCurve = rs.AddCurve(AFPVPort) # How wide is the fuselage? (Xmin, Ymin, Zmin, Xmax, Ymax, Zmax) = act.ObjectsExtents(PlanPortCurve) # Generate a slightly wider projection surface FSVMeanCurve = rs.MeanCurve(FSVUCurve, FSVLCurve) RuleLinePort = rs.AddLine((0, 0, 0), (0, -1.1 * abs(Ymax - Ymin), 0)) FSVMCEP = rs.CurveEndPoint(FSVMeanCurve) AftLoftEdgePort = rs.CopyObject(RuleLinePort, FSVMCEP) ParallelLoftEdgePort = rs.CopyObject(FSVMeanCurve, (0, -1.1 * abs(Ymax - Ymin), 0)) LSPort = rs.AddSweep2((FSVMeanCurve, ParallelLoftEdgePort), (RuleLinePort, AftLoftEdgePort)) # Project the plan view onto the mean surface PortCurve = rs.ProjectCurveToSurface(PlanPortCurve, LSPort, (0, 0, 100)) # House-keeping rs.DeleteObjects([ LSPort, PlanPortCurve, ParallelLoftEdgePort, RuleLinePort, AftLoftEdgePort ]) # Tidy up the mean curve. This is necessary for a smooth result and removing # it can render the algorithm unstable. However, FitCurve itself may sometimes # be slightly unstable. FLength = abs(Xmax - Xmin) # establish a reference length PortCurveSimplified = rs.FitCurve(PortCurve, distance_tolerance=FLength * 0.001) StarboardCurveSimplified = act.MirrorObjectXZ(PortCurveSimplified) rs.DeleteObject(PortCurve) # Compute the actual end points of the longitudinal curves (Xmin, Ymin, Zmin, Xmax1, Ymax, Zmax) = act.ObjectsExtents(StarboardCurveSimplified) (Xmin, Ymin, Zmin, Xmax2, Ymax, Zmax) = act.ObjectsExtents(PortCurveSimplified) (Xmin, Ymin, Zmin, Xmax3, Ymax, Zmax) = act.ObjectsExtents(FSVUCurve) (Xmin, Ymin, Zmin, Xmax4, Ymax, Zmax) = act.ObjectsExtents(FSVLCurve) EndX = min([Xmax1, Xmax2, Xmax3, Xmax4]) return StarboardCurveSimplified, PortCurveSimplified, FSVUCurve, FSVLCurve, FSVMeanCurve, NoseEndX, TailStartX, EndX
def get_reference_shape(self, ref_object, target_srf_num): ref_points = ref_object.get_reference_points(target_srf_num) target_points = self.get_target_points(target_srf_num) new_shape = rs.OrientObject(rs.CopyObject(ref_object.shape), ref_points, target_points) if is_intersect(self.shape, rs.coercebrep(rs.CopyObject(new_shape))): new_shape = rs.OrientObject( rs.CopyObject(ref_object.shape), ref_object.get_target_points(self.target_face), target_points) return new_shape
def get_cut_curve(self): if self.compensation == 0: return rs.CopyObject(self.nurbs_curve) offset_distance = self.general_input["cut_diam"] * 0.5 scl_obj = rs.ScaleObject(self.nurbs_curve, self.point, (1.2, 1.2, 1), True) offset_points = rs.BoundingBox(scl_obj) rs.DeleteObject(scl_obj) offset_point_a = offset_points[0] offset_point_b = self.point if not rs.PointInPlanarClosedCurve(self.point, self.nurbs_curve): offset_point_b = self.find_point_in_curve(self.nurbs_curve) offset_a = rs.OffsetCurve(self.nurbs_curve, offset_point_a, offset_distance, None, 2) offset_b = rs.OffsetCurve(self.nurbs_curve, offset_point_b, offset_distance, None, 2) #Revisa si el offset no genero curvas separadas y si es el caso asigna la curva original como offset comparativo if not offset_a or len(offset_a) != 1: self.log.append( "offset error: el cortador no cabe en una de las curvas, se reemplazo con la curva original." ) if offset_a: rs.DeleteObjects(offset_a) offset_a = rs.CopyObject(self.nurbs_curve) if not offset_b or len(offset_b) != 1: self.log.append( "offset error: el cortador no cabe en una de las curvas, se reemplazo con la curva original." ) if offset_b: rs.DeleteObjects(offset_b) offset_b = rs.CopyObject(self.nurbs_curve) #Revisa el area para saber cual es el offset interno o externo if rs.CurveArea(offset_a) < rs.CurveArea(offset_b): in_offset = offset_a out_offset = offset_b else: in_offset = offset_b out_offset = offset_a #Responde dependiendo que compensacion se necesita if self.compensation == 1: rs.DeleteObject(in_offset) return out_offset elif self.compensation == -1: rs.DeleteObject(out_offset) return in_offset else: rs.DeleteObject(in_offset) rs.DeleteObject(out_offset) return None
def addExtlHandrail(self): hdrlPtList = [] hdrlEndPt = rs.AddPoint(rs.CurveEndPoint(self.guideCrv)) hdrlStPt = rs.AddPoint(rs.CurveStartPoint(self.guideCrv)) hdrlVec = rs.VectorCreate(hdrlStPt, hdrlEndPt) projHdrlVec = rs.VectorUnitize([hdrlVec.X, hdrlVec.Y, 0]) #Top Extension topExtEndPt = rs.CopyObject(hdrlEndPt) rs.MoveObject(topExtEndPt, rs.VectorScale(projHdrlVec, -.305)) hdrlPtList.append(topExtEndPt) #Btm Extension (tread length method) btmExtEndPt = rs.CopyObject(hdrlStPt) btmPtExtTemp = rs.CopyObject(hdrlStPt) btmVertPtExtTemp = rs.CopyObject(hdrlStPt) rs.MoveObject(btmPtExtTemp, hdrlVec) angledLineTemp = rs.AddLine(hdrlStPt, btmPtExtTemp) rs.MoveObject(btmVertPtExtTemp, [0, 0, -1]) vertLineTemp = rs.AddLine(btmVertPtExtTemp, hdrlStPt) rs.MoveObject(vertLineTemp, rs.VectorScale(projHdrlVec, self.treadLength)) btmExtPt = rs.LineLineIntersection(angledLineTemp, vertLineTemp)[0] hdrlPtList.append(hdrlEndPt) hdrlPtList.append(btmExtPt) #Make and move hdrlCrv = rs.AddPolyline(hdrlPtList) rs.MoveObject(hdrlCrv, [0, 0, self.hdrlHeight]) #move away from wall widthVec = rs.VectorUnitize( rs.VectorCreate(rs.CurveEndPoint(self.stairWidthEdge), rs.CurveStartPoint(self.stairWidthEdge))) rs.MoveObject(hdrlCrv, rs.VectorScale(widthVec, self.hdrlDistFromWall)) #cleanup rs.DeleteObject(topExtEndPt) rs.DeleteObject(hdrlEndPt) rs.DeleteObject(hdrlStPt) rs.DeleteObject(btmPtExtTemp) rs.DeleteObject(btmVertPtExtTemp) rs.DeleteObject(angledLineTemp) rs.DeleteObject(vertLineTemp) rs.DeleteObject(btmExtEndPt) return hdrlCrv
def draw_rectangle_2(p, theta): t = 1 p0 = rs.AddPoint(p) p1 = rs.CopyObject(p0, polar(t, theta + 11, 0)) p2 = rs.CopyObject(p0, polar(t, theta + 169, 0)) p3 = rs.CopyObject(p0, polar(t, theta - 169, 0)) p4 = rs.CopyObject(p0, polar(t, theta - 11, 0)) rec = [ rs.AddLine(p1, p2), rs.AddLine(p2, p3), rs.AddLine(p3, p4), rs.AddLine(p4, p1) ] return rec
def get_pocket_entry(self, z_level, translation, pocket_list): revised_list = [] last_obj = None for obj in pocket_list: if obj != "sec_plane": revised_list.append(rs.CopyObject(obj, translation)) else: if last_obj != obj: revised_list.append(obj) last_obj = obj pocket_list = revised_list for i in range(0, len(pocket_list)): crv = pocket_list[i] if crv == "sec_plane": #Cambio intermedio pep = rs.CurveEndPoint(pocket_list[i - 1]) try: nsp = rs.CurveStartPoint(pocket_list[i + 1]) except: npt = rs.CurveStartPoint(self.cut_curve) nsp = (npt[0], npt[1], z_level) points = [ rs.CurveEndPoint(pocket_list[i - 1]), (pep[0], pep[1], self.general_input["sec_plane"]), (nsp[0], nsp[1], self.general_input["sec_plane"]), nsp ] travel_line = rs.AddPolyline(points) rs.ObjectColor(travel_line, color_palette["cut"]) pocket_list[i] = travel_line return pocket_list
def SplitObject(solid, cSrf): preInnerSrf = rs.CopyObject(cSrf) innerSrfs = rs.TrimBrep(preInnerSrf, solid) if not innerSrfs: rs.DeleteObject(preInnerSrf) return [solid] solids = [] solids.append(solid) for srf in innerSrfs: newSolids = [] for obj in solids: splitObjs = rs.SplitBrep(obj, srf, True) if not splitObjs: newSolids.append(obj) else: for sObj in splitObjs: toJoin = [sObj, srf] newSolids.append(rs.JoinSurfaces(toJoin)) rs.DeleteObjects(splitObjs) solids = newSolids rs.DeleteObjects(innerSrfs) return solids
def mark_instance(pop_num, all_mark): temp_mark = [] dic3 = {} for foo in range(pop_num): dic3['allMark' + str(foo)] = foo for i in range(pop_num): dic3['allMark' + str(i)] = [] for j in range(len(all_mark)): mark_1 = rs.CopyObject(all_mark[j][0]) mark_2 = rs.CopyObject(all_mark[j][1]) mark = [mark_1, mark_2] dic3['allMark' + str(i)].append(mark) temp_mark.append(dic3['allMark' + str(i)]) return temp_mark
def innerPanel(): objs = rs.GetObjects("Select objects to add frame to", filter = 24, group = True,preselect = True) if objs is None: return dist = rs.GetReal("Offset Distance") if dist is None: return rs.EnableRedraw(False) srfs = [] for obj in objs: if rs.IsPolysurface(obj): srfs = srfs + rs.ExplodePolysurfaces(obj) else: srfs.append(rs.CopyObject(obj)) for srf in srfs: if rs.IsSurfacePlanar(srf): edgeCrvs = rs.DuplicateEdgeCurves(srf) border = rs.JoinCurves(edgeCrvs, True) innerEdge = rs.OffsetCurveOnSurface(border, srf, dist) #rs.SplitBrep(srf, innerEdge) rs.AddPlanarSrf(innerEdge) rs.DeleteObject(innerEdge) rs.DeleteObject(border) else: print "A surface was not planar" rs.DeleteObjects(srfs) rs.EnableRedraw(True)
def __init__(self): FileName = "type_data.csv" FilePath = rs.GetString( "Enter the working directory for the program : ") try: os.stat(FilePath) except: os.mkdir(FilePath) os.chdir(FilePath) site_bool = rs.GetString( 'Use default site Profile- (Y)? Or select - (N) ', 'Y').lower() n = rs.GetInteger('Enter number of variations required') if (n == 0 or n == None): n = 1 for i in range(0, 2000 * n, 2000): site = None site_crv = None if (site_bool == 'y' or site_bool == 'Y'): site = genSite(i, 0) site_crv = site.getSite() else: site_crv = rs.GetObject('pick site boundary') site_crv = rs.CopyObject(site_crv, [i, 0, 0]) m = main(FileName, site_crv) m.getInpObj() m.genFuncObj_Site() m.writeToCsv()
def addRail(obj): point1 = rs.EvaluateSurface(obj, 0, 0) vec = rs.CreateVector(0, 0, height) point2 = rs.CopyObject(point1, vec) line = rs.AddLine(point1, point2) if point2: rs.DeleteObjects(point2) return line
def tool_visualization(origin_coords, mesh, planes, i): """ Visualize example tool motion. """ i = min(i, len(planes) - 1) # make sure i doesn't go beyond available number of planes passed_path = None assert planes[0], 'The planes you have provided are invalid.' origin = [ float(origin_coords[0]), float(origin_coords[1]), float(origin_coords[2]) ] o = rg.Point3d(origin[0], origin[1], origin[2]) x = rg.Vector3d(1, 0, 0) y = rg.Vector3d(0, -1, 0) # z = rg.Vector3d(0, 0, -1) ee_frame = rg.Plane(o, x, y) target_frame = planes[i] T = rg.Transform.PlaneToPlane(ee_frame, target_frame) mesh = rs.TransformObject(rs.CopyObject(mesh), T) passed_path = rs.AddPolyline([plane.Origin for plane in planes[:i + 1]]) return mesh, passed_path
def __init__(self, name, type, classification, shape, center, can_grow, key, occupied=None, target=None): self.name = name # (str) name of the object self.type = type # (str) type of the object self.classification = classification # (int) 1 or 0 self.shape = rs.coercebrep( rs.CopyObject(shape)) # (brep) shape of the object self.center = center # (list<float>) x,y,z coordinates of the center of the object self.can_grow = can_grow # (bool) true if object can grow self.face_dict = self.set_faces( ) # (dictionary) shows status of the faces of the object self.set_occupied_face(occupied) self.func = None # (string) func of the object in the playground self.target_face = 0 # (int) self.key = key self.selected = False self.create_growing = False
def offsetext(): def RepresentsInt(s): try: int(s) return True except ValueError: return False viste = rs.ViewNames() for viewport in viste: rs.ViewDisplayMode(viewport,"Shaded") diametro = rs.StringBox("dimensione della punta","10","scontornatura") if RepresentsInt(diametro): diametro = int(diametro) else: diametro = 10 brep = rs.GetObjects("dammi un solido",16) brepexp = rs.ExplodePolysurfaces(brep) get_val = rs.GetEdgeCurves("dammi le curve") surf_edge = [] for i in get_val: surf_edge.append(i[0]) surf_edge = rs.coerceguidlist(surf_edge) if len(surf_edge)>1: surf_edge = rs.JoinCurves(surf_edge,True) surface = rs.GetObjects("conferma la selezione",8,False,True,1,1) print surf_edge uv= [] temp_edge = rs.ExplodeCurves(surf_edge,False) new_surface = rs.CopyObject(surface,(0,0,0)) list_evpt =[] for i in temp_edge: evpt =rs.CurveMidPoint(i) print evpt list_evpt.append(evpt) for i in list_evpt: bord= rs.SurfaceClosestPoint(new_surface,i) uv.append(bord) for i in uv: rs.ExtendSurface(new_surface,i,diametro*10) edge = rs.OffsetCurveOnSurface(surf_edge,new_surface,-diametro) print edge if rs.CurveLength(edge)<rs.CurveLength(surf_edge): rs.DeleteObject(edge) edge = rs.OffsetCurveOnSurface(surf_edge,new_surface,diametro) surf_edge = rs.ExplodeCurves(surf_edge,True) print edge rs.ObjectColor(edge,(0,0,255)) for i in brepexp: rs.DeleteObject(i) for i in temp_edge: rs.DeleteObject(i) for i in surf_edge: rs.DeleteObject(i) rs.DeleteObjects([new_surface,surface])
def deflect(self, deflectPoint): """ Takes a Point as an input. Point creates a force field. The turtle deflects around the point """ defPtPos = rs.PointCoordinates(deflectPoint) prevPos = rs.PointCoordinates(self.point) deflectVector1 = rs.VectorScale(rs.VectorCreate(prevPos, defPtPos), 0.33) deflectVector2 = -deflectVector1 deflectVector90_1 = rs.VectorScale( rs.VectorRotate(deflectVector1, 90, [0, 0, 1]), 0.33) deflectVector90_2 = -deflectVector90_1 deflectVectorList = [ deflectVector1, deflectVector2, deflectVector90_1, deflectVector90_2 ] forcePts = [] for i in deflectVectorList: newPt = rs.CopyObject(deflectPoint) rs.MoveObject(newPt, i) forcePts.append(newPt) gotoPt = rs.PointCoordinates(forcePts[0]) self.goto(gotoPt[0], gotoPt[1]) rs.AddArc3Pt(forcePts[0], forcePts[1], forcePts[2]) rs.AddArc3Pt(forcePts[1], forcePts[0], forcePts[3]) rs.DeleteObjects(forcePts)
def PlacePolygon(points, layer): if (layer != 1) and (layer != 16): return None path = PathXY() first = True for point in points: if first: first = False path.MoveTo(point[0], point[1]) if len(point) >= 9: path.ArcTo(point[3], point[4], point[6], point[7]) else: if len(point) >= 9: path.LineTo(point[0], point[1]) path.ArcTo(point[3], point[4], point[6], point[7]) else: path.LineTo(point[0], point[1]) path.ClosePath() path.Join() curve = path.curves[0] # curve = rs.AddPolyline(points) extrusion = rs.ExtrudeCurveStraight(curve, (0, 0, 0), (0, 0, 0.1)) top = rs.AddPlanarSrf([curve]) bot = rs.CopyObject(top, (0, 0, 0.1)) object = rs.JoinSurfaces([top, extrusion, bot], True) rs.DeleteObject(curve) ColorAndMove(object, layer) return object
def main(): counts = [0, 0, 0] spacings = [10, 10, 10] rotations = [0, 0, 0] counts[0] = rs.GetInteger("number in x direction", minimum=1) # counts[1] = rs.GetInteger("number in y direction", minimum=1) # counts[2] = rs.GetInteger("number in z direction", minimum=1) spacings[0] = rs.GetReal("x spacing") # spacings[1] = rs.GetReal("y spacing") # spacings[2] = rs.GetReal("z spacing") rotations[0] = rs.GetReal("rotation of each object along x axis") # rotations[1] = rs.GetReal("y spacing") # rotations[2] = rs.GetReal("z spacing") print "count", counts print "spacing", spacings print "rotation", rotations for ix in range(counts[0]): newobj = rs.CopyObject(obj, [spacings[0] * ix, 0, 0]) bbox = rs.BoundingBox(newobj) if bbox: centroid = rs.PointSubtract(bbox[0], bbox[6]) print bbox[6], bbox[0] print centroid rs.AddPoint(centroid) else: print "no bbox"
def make_jigs(b, diam, bdiam): jig_base_height = 4. / 12 jig_clearance = .25 / 12 # for s in [b.tof[i] for i in [0,2,5,7]]: for s in b.tof: r = 90 width = 5 * b.deckString.thickness height = s.keel_hab + 2 * b.deckString.width + jig_base_height p = [s.section, 0, 0] rect = x_rectangle_cut_out( p, width, height, b.deckString.thickness + 2 * jig_clearance, height - jig_base_height + jig_clearance + b.deckString.width) rect = [rs.MoveObject(rect, [0, 0, -jig_base_height])] plane = rs.PlaneFromNormal([s.section, 0, 0], [1, 0, 0]) holes = [ rs.MoveObject(rs.AddCircle(plane, diam / 2), [ 0, 1.5 * b.deckString.thickness, s.keel_hab + b.deckString.width ]) ] holes.extend(rs.MirrorObjects(holes, p, ss(p, [1, 0, 0]), copy=True)) bhole = rs.MoveObject(rs.AddCircle(plane, bdiam / 2), [0, 0, 47. / 64 / 12 - jig_base_height]) holes.extend([bhole, rs.CopyObject(bhole, [0, 0, 1.5 / 12])]) rs.RotateObjects(rect + holes, p, 90, [0, 1, 0])
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 meshSwipPolyAlongPoly(profile, rail): profile = rs.CopyObject(profile) pts = rs.CurveEditPoints(rail) baseVect = Rhino.Geometry.Point3d(0, 1, 0) meshes = [] for i in range(0, len(pts) - 2): p0 = pts[i] p1 = pts[i + 1] p2 = pts[i + 2] v1 = rs.VectorUnitize(p1 - p0) v2 = rs.VectorUnitize(p2 - p1) rv1 = rs.VectorUnitize(p0 - p1) vect = p1 - p0 mid = rs.VectorUnitize((rv1 + v2) / 2) np = p1 + mid up = p1 + Rhino.Geometry.Point3d(0, 0, 1) pln = rs.PlaneFromPoints(p1, np, up) mesh, pjpts = meshExtrudePolyToByVectPlane(profile, vect, pln) meshes.append(mesh) rs.DeleteObject(profile) profile = rs.AddPolyline(pjpts) mesh = rs.JoinMeshes(meshes, True) rs.DeleteObject(profile) return mesh
def ellipse(self, xheight, yheight, direction): if direction == center: centerPoint = self.point else if direction == right: centerPoint = rs.CopyObject(self.point, rs.VectorScale(rs.VectorCreate([1,0,0],[0,0,0]), xheight/2)) else if direction == left: centerPoint = rs.CopyObject(self.point, rs.VectorScale(rs.VectorCreate([-1,0,0],[0,0,0]), xheight/2)) else if direction == top: centerPoint = rs.CopyObject(self.point, rs.VectorScale(rs.VectorCreate([0,1,0],[0,0,0]), yheight/2)) else if direction == bottom: centerPoint = rs.CopyObject(self.point, rs.VectorScale(rs.VectorCreate([0,-1,0],[0,0,0]), yheight/2)) else: print('invalid direction') continue newEllipse = rs.AddCircle(centerPoint, xheight/2) yScaleFactor = yheight/xheight rs.ScaleObject(newEllipse, self.point, [1,yScaleFactor,0])
def right(): r_curve = rs.CopyObject(curve, [0, 0, b_lst[1]]) rs.AddPipe(r_curve, 0, b_lst[2], cap=1) rs.DeleteObjects(r_curve) pts = [rs.EvaluateCurve(curve, t) for t in ref_pts] for i in range(b_lst[3]): base = rs.PointAdd(pts[i], [0, 0, b_lst[1]]) rs.AddCylinder(pts[i], base, b_lst[4])
def make(self): self.segments = rs.ExplodeCurves(self.Rect) treadLength = rs.CurveLength(self.segments[1]) / self.numRisers riserHeight = self.deltaHeight / self.numRisers runVector = rs.VectorCreate( rs.CurveEndPoint(self.segments[1]), rs.CurveStartPoint(self.segments[1])) unitRunVec = rs.VectorUnitize(runVector) treadVec = rs.VectorScale(unitRunVec, treadLength) riseVec = rs.VectorCreate([0, 0, riserHeight], [0, 0, 0]) newPt = [ rs.CurveStartPoint(self.segments[0]).X, rs.CurveStartPoint(self.segments[0]).Y, rs.CurveStartPoint(self.segments[0]).Z - self.deltaHeight ] ptList = [] ptList.append(rs.AddPoint(newPt)) for i in range(self.numRisers): tempPt = rs.CopyObject(ptList[-1]) rs.MoveObject(tempPt, riseVec) ptList.append(tempPt) tempPt = rs.CopyObject(ptList[-1]) rs.MoveObject(tempPt, treadVec) ptList.append(tempPt) downLine = rs.VectorCreate([0, 0, 0], [0, 0, self.thickness]) newBtmPt = rs.MoveObject(rs.CopyObject(ptList[0]), downLine) ptList.insert(0, newBtmPt) newBtmPt2 = rs.MoveObject(rs.CopyObject(ptList[-1]), downLine) ptList.append(newBtmPt2) stringer = rs.AddPolyline(ptList) closeCrv = rs.AddLine(rs.CurveStartPoint(stringer), rs.CurveEndPoint(stringer)) newStringer = rs.JoinCurves([stringer, closeCrv], True) stair = rs.ExtrudeCurve(newStringer, self.segments[0]) rs.CapPlanarHoles(stair) rs.DeleteObject(stringer) rs.DeleteObject(newStringer) rs.DeleteObjects(ptList) rs.DeleteObjects(self.segments) return stair