def isShareEdge(srf1, srf2): border1 = rs.DuplicateSurfaceBorder(srf1) border2 = rs.DuplicateSurfaceBorder(srf2) edges1 = rs.ExplodeCurves(border1, True) edges2 = rs.ExplodeCurves(border2, True) shareMid = [] threshold = 0.001 flag = False for e1 in edges1: for e2 in edges2: mid1 = rs.CurveMidPoint(e1) mid2 = rs.CurveMidPoint(e2) if rs.Distance(mid1, mid2) < threshold: s1 = rs.CurveStartPoint(e1) s2 = rs.CurveStartPoint(e2) e1 = rs.CurveEndPoint(e1) e2 = rs.CurveEndPoint(e2) if rs.Distance(s1, s1) < threshold: flag = True break if rs.Distance(s1, e1) < threshold: flag = True break rs.DeleteObjects(edges1) rs.DeleteObjects(edges2) return flag
def getTotalRun(landingEdges): run = 0.0 for i in range(0, len(landingEdges), 2): a = rs.CurveMidPoint(landingEdges[i]) b = rs.CurveMidPoint(landingEdges[i + 1]) run = run + rs.Distance(a, b) return run
def visualize_rays(room, keys=None, ref_order=None, layer='Default', dot=None): rs.CurrentLayer(layer) if not keys: keys = room.ray_lines.keys() for rk in keys: if ref_order: ref_k = ref_order if ref_k in room.ray_lines[rk]: u, v = room.ray_lines[rk][ref_k] line = rs.AddLine(u, v) else: lkeys = room.ray_lines[rk] for lk in lkeys: u, v = room.ray_lines[rk][lk] line = rs.AddLine(u, v) if dot == 'w': w = room.ray_powers[rk][lk][ 100] # this needs to be better, user given rs.AddTextDot(str(w), rs.CurveMidPoint(line)) if dot == 't': t = room.ray_times[rk][lk] rs.AddTextDot(str(t), rs.CurveMidPoint(line)) if dot == 'key': rs.AddTextDot(str(lk), rs.CurveMidPoint(line))
def write_strip_data(layer, point_ind): # get all surfaces on layer strips = rs.ObjectsByLayer(layer) strip_ind = 1 strip_dict = {} for strip in strips: # get only surfaces if rs.IsSurface(strip): if rs.IsSurfacePlanar(strip): strip_dict['Strip=' + layer + str(strip_ind)] = [] strip_brep = rs.coercebrep(strip) edges = Rhino.Geometry.Brep.DuplicateEdgeCurves(strip_brep) edge_ids = [] ind = 0 for edge in edges: edge_id = sc.doc.Objects.AddCurve(edge) if edge_id: rs.ObjectName(edge_id, 'active' + str(ind)) edge_ids.append(edge_id) ind += 1 # Get strip geometry # change color to help find strip rs.ObjectColor(strip, color=(255, 0, 255)) start_edge = rs.GetObject('Select start edge.', 4, False, False, active_strip_filter) start_length = rs.CurveLength(start_edge) sp = rs.CurveMidPoint(start_edge) rs.ObjectName(rs.AddPoint(sp), name='SP_' + str(point_ind)) end_edge = rs.GetObject('Select end edge.', 4, False, False, active_strip_filter) end_length = rs.CurveLength(end_edge) ep = rs.CurveMidPoint(end_edge) rs.ObjectName(rs.AddPoint(ep), name='SP_' + str(point_ind)) # Clean up rs.DeleteObjects(edge_ids) rs.ObjectColor(strip, color=(128, 0, 128)) # write to json start = { 'Point': point_ind, 'GlobalX': round(sp.X, 4), 'GlobalY': round(sp.Y, 4), 'WALeft': round(start_length * 0.5, 4), 'WARight': round(start_length * 0.5, 4), 'Autowiden': 'No' } point_ind += 1 end = { 'Point': point_ind, 'GlobalX': round(ep.X, 4), 'GlobalY': round(ep.Y, 4), 'WBLeft': round(end_length * 0.5, 4), 'WBRight': round(end_length * 0.5, 4), } strip_dict['Strip=' + layer + str(strip_ind)].append(start) strip_dict['Strip=' + layer + str(strip_ind)].append(end) point_ind += 1 strip_ind += 1 return strip_dict
def CrvSegmentMidPt(crv, n): if rs.IsPolyline(crv): verts = rs.PolylineVertices(crv) midPt = (verts[n] + verts[n + 1]) / 2 elif rs.IsPolyCurve(crv): midPt = rs.CurveMidPoint(crv, n) else: midPt = rs.CurveMidPoint(crv) return midPt
def Extend_trim_crv(A, B, thickness): if mode == "extend": if rs.CurveLength(A) > rs.CurveLength(B): B = rs.OffsetCurve(A, rs.CurveMidPoint(B), thickness) else: A = rs.OffsetCurve(B, rs.CurveMidPoint(A), thickness) elif mode == "trim": if rs.CurveLength(A) > rs.CurveLength(B): A = rs.OffsetCurve(B, rs.CurveMidPoint(A), thickness) else: B = rs.OffsetCurve(A, rs.CurveMidPoint(B), thickness) return (A, B)
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 WindowLeftDistance(): # Find midpoint of window left line midpoint_windowLeft = rs.CurveMidPoint(window_leftLine[1]) # Find closest point in curve window left parameterLeftLine = rs.CurveClosestPoint(window_leftLine[1], midpoint_windowLeft) # Find curve window left Tangent windowLeft_Tangent = rs.CurveTangent(window_leftLine[1], parameterLeftLine) # find window left normal plane windowLeft_plane = rs.PlaneFromNormal(midpoint_windowLeft, windowLeft_Tangent) # find start and end points of ground line points_ll = [] start_ll = bbox[0] end_ll = bbox[3] points_ll.append(start_ll) points_ll.append(end_ll) #find point on Surface Left line point_SurfLeftLine = rs.LinePlaneIntersection(points_ll, windowLeft_plane) #point_SurfLeftLine = rs.AddPoint(point_SurfLeftLine) Window_leftDistance = rs.Distance(midpoint_windowLeft, point_SurfLeftLine) return Window_leftDistance
def SillHeight(): # Find mid point of sill line midpointSill = rs.CurveMidPoint(window_sillLine[1]) #midpointSill = rs.AddPoint(midpointSill) # Find closest point in curve parameterSill = rs.CurveClosestPoint(window_sillLine[1], midpointSill) # Find curve Tangent sill_Tangent = rs.CurveTangent(window_sillLine[1], parameterSill) # find normal plane sill_plane = rs.PlaneFromNormal(midpointSill, sill_Tangent) # find start and end points of ground line points_gl = [] start_gl = rs.CurveStartPoint(groundLine[1]) end_gl = rs.CurveEndPoint(groundLine[1]) points_gl.append(start_gl) points_gl.append(end_gl) #find point on ground line pointGroundLine = rs.LinePlaneIntersection(points_gl, sill_plane) #pointGroundLine = rs.AddPoint(pointGroundLine) sill_Height = rs.Distance(midpointSill, pointGroundLine) return sill_Height
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 squareSect(crv,width,height): sections=[] divPts=rs.DivideCurve(crv,10) keep=True for i in range(len(divPts)): param=rs.CurveClosestPoint(crv,divPts[i]) tan=rs.CurveTangent(crv,param) plane=rs.PlaneFromNormal(divPts[i],tan) sect=rs.AddRectangle(plane,width,height) cpt=rs.CurveAreaCentroid(sect)[0] vec=rs.VectorCreate(divPts[i],cpt) sect=rs.MoveObject(sect,vec) if i>0: if testAlign(sect,oldSect)==False: sect=align(sect,oldSect,divPts[i],tan) oldSect=sect sections.append(sect) branch=rs.AddLoftSrf(sections,None,None,2,0,0,False) edges=rs.DuplicateEdgeCurves(branch) if width>height: testVal=height else: testVal=width for i in range(len(edges)): testPt=rs.CurveMidPoint(edges[i]) for j in range(len(edges)): param=rs.CurveClosestPoint(edges[j],testPt) pt=rs.EvaluateCurve(edges[j],param) if rs.Distance(pt,testPt)<testVal/6: keep=False rs.DeleteObjects(sections) rs.DeleteObjects(edges) return branch
def construct_mesh_center(points): meshes = [] ### calc center point bbox = rs.BoundingBox(points) line = rs.AddLine(bbox[0], bbox[6]) c = rs.CurveMidPoint(line) ### set new point list points.append(c) ### c_index = len(points) - 1 # print(c_index) 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
def main(): crv = rs.GetObject("Select Curve to offset repeatedly:", 4) ptCrvMid = rs.CurveMidPoint(crv) #### Use the following lines to offset by count #dir = rs.GetPoint("Direction of Offset:"); #count = rs.GetInteger("Number of Offsets:"); tupCount = getCount(ptCrvMid) recursiveOffset(crv, tupCount[1], tupCount[2], tupCount[0], 0)
def Keep(self, curves, index, axis=1): meta = [(i, rs.CurveMidPoint(curves[i])[axis]) for i in range(len(curves))] meta.sort(key=lambda iy: iy[1]) for i in range(len(meta)): if i != index: rs.DeleteObject(curves[meta[i][0]]) return curves[meta[index][0]]
def DropBlockToSurface(): try: obj = rs.GetObjects('Select Objects', rs.filter.curve | rs.filter.instance | rs.filter.mesh | rs.filter.surface | rs.filter.subd | rs.filter.light | rs.filter.polysurface, preselect=True) srf = rs.GetObject('Select Surface') if obj: if srf: rs.EnableRedraw(False) # Check if srf is a mesh, if so convert to Nurb isMesh = rs.IsMesh(srf) if isMesh == True: srf = rs.MeshToNurb(srf) # For each object send test rays up and down in Z coord # Move each object to the ray test that hits a srf for i in obj: bndBox = rs.BoundingBox(i) pt1 = bndBox[0] pt2 = bndBox[2] crv = rs.AddLine(pt1, pt2) if crv: midcrv = rs.CurveMidPoint(crv) rs.DeleteObject(crv) ray_pt_up = rs.ShootRay(srf, midcrv, (0, 0, 1), reflections=1) ray_pt_down = rs.ShootRay(srf, midcrv, (0, 0, -1), reflections=1) if ray_pt_up: vector = rs.VectorCreate(ray_pt_up[1], midcrv) rs.MoveObject(i, vector) if ray_pt_down: vector = rs.VectorCreate(ray_pt_down[1], midcrv) rs.MoveObject(i, vector) # deleate any created srf if isMesh == True: rs.DeleteObject(srf) rs.EnableRedraw(True) except: print("Failed to execute") rs.EnableRedraw(True) return
def Findclosestpt(crvs): dict_dist = {} list_midpt = [rs.CurveMidPoint(crv) for crv in crvs] count = 0 while count != len(crvs): list_distance = [int(rs.Distance(list_midpt[count], i)) for i in list_midpt] dict_dist[count] = sorted(range(len(list_distance)), key=lambda k: list_distance[k]) count += 1 return dict_dist
def RunCommand(is_interactive): global params pitch_line = rs.GetObject(message="Select pitch line", filter=rs.filter.curve, preselect=True) if pitch_line is None: return 1 # Cancel if not rs.IsLine(pitch_line): print "Selected curve is not a line!" return 1 # Cancel rs.SelectObjects(pitch_line) m = rs.GetReal(message="Rack module", number=params["m"]) pa = rs.GetReal(message="Pressure angle", number=params["pa"], minimum=0, maximum=45) if m is None or pa is None: return 1 # Cancel params["m"] = m params["pa"] = pa pitch_line_center = rs.CurveMidPoint(pitch_line) pitch_line_start = rs.CurveStartPoint(pitch_line) pitch_line_end = rs.CurveEndPoint(pitch_line) angle, reflex_angle = rs.Angle2(line1=((0, 0, 0), (1, 0, 0)), line2=(pitch_line_start, pitch_line_end)) x_vector = rs.VectorCreate(pitch_line_end, pitch_line_start) y_vector = rs.VectorRotate(x_vector, 90.0, [0, 0, 1]) cplane = rs.PlaneFromFrame(origin=pitch_line_center, x_axis=x_vector, y_axis=y_vector) xform = rs.XformChangeBasis(cplane, rs.WorldXYPlane()) rs.EnableRedraw(False) old_plane = rs.ViewCPlane(plane=rs.WorldXYPlane()) rack = draw_rack(length=rs.CurveLength(pitch_line), module=params["m"], pressure_angle=params["pa"]) rs.ViewCPlane(plane=old_plane) rs.TransformObjects(rack, xform) rs.EnableRedraw(True) rs.UnselectAllObjects() rs.SelectObjects(rack) return 0 # Success
def plotPoint(pOne, pTwo): line = rs.AddLine(pOne, pTwo) coordinates = rs.CurveMidPoint(line) point = rs.AddPoint(coordinates) rs.DeleteObject(line) translation = rs.Distance(pOne, pTwo) rs.MoveObject(point, (0, 0, translation)) result = rs.PointCoordinates(point) rs.DeleteObject(point) return result
def addVertLineAtMid(): objs = rs.GetObjects("select lines you want to add a vertical line at mid", rs.filter.curve) vector1 = rs.VectorCreate((0, 0, 0), (0, 0, 200)) if objs: for obj in objs: midPoint = rs.CurveMidPoint(obj) midPointMoved = midPoint rs.MoveObject(midPointMoved, vector1) rs.AddLine(midPoint, midPointMoved)
def Getendpoints(Curve): x = rs.CurveStartPoint(Curve) y = rs.CurveEndPoint(Curve) z = rs.CurveMidPoint(Curve) startP = x.X, x.Y, x.Z MidP = z.X, z.Y, z.Z EndP = y.X, y.Y, y.Z if rs.CurveDegree(Curve) == 2: return str(startP) + "," + str(MidP) + "," + str(EndP) elif rs.CurveDegree(Curve) == 1: return str(startP) + "," + str(EndP) else: return "Invalid Curve"
def Findclosestpt(crvs): dict_dist = {} list_midpt = [rs.CurveMidPoint(crv) for crv in crvs] count = 0 while count != len(crvs): list_distance = [ int(rs.Distance(list_midpt[count], i)) for i in list_midpt ] list_sorted = zip(list_distance, range(len(crvs))) list_sorted.sort() list_distance, list_sortindex = zip(*list_sorted) dict_dist[count] = list_sortindex count += 1 return dict_dist
def Previewwall(dict, index, crvs, zoommode):# 壁を作る # get_adjustの中身で処理を決める if dict[index][2] == 1: A = crvs[dict[index][0]] B = rs.OffsetCurve(crvs[dict[index][0]], rs.CurveMidPoint(crvs[dict[index][1]]), dict[index][3]) elif dict[index][2] == 2: A = rs.OffsetCurve(crvs[dict[index][1]], rs.CurveMidPoint(crvs[dict[index][0]]), dict[index][3]) B = crvs[dict[index][1]] elif dict[index][2] == 3: A = rs.OffsetCurve(crvs[dict[index][1]], rs.CurveMidPoint(crvs[dict[index][0]]), dict[index][3]) B = crvs[dict[index][1]] elif dict[index][2] == 4: A = crvs[dict[index][0]] B = rs.OffsetCurve(crvs[dict[index][0]], rs.CurveMidPoint(crvs[dict[index][1]]), dict[index][3]) obj_srf = rs.AddLoftSrf([A, B]) obj_height = rs.AddLine((0,0,0), (0,0,dict[index][4])) obj_wall = rs.ExtrudeSurface(obj_srf, obj_height) if zoommode:# 壁と曲線で箱を作り、箱をズーム obj_zoom = rs.BoundingBox([obj_wall, crvs[dict[index][0]], crvs[dict[index][1]]]) rs.ZoomBoundingBox(obj_zoom) return obj_wall
def createMidPointFromCurve(curve): split_num = 2 point_list = [] domain = rs.CurveDomain(curve) t = (domain[1] - domain[0]) / split_num for int in range(split_num): dt = t * int point = rs.EvaluateCurve(curve, dt) point_list.append(point) # 直線の中心点を求める line = rs.AddLine(point_list[0], point_list[1]) mid_point = rs.CurveMidPoint(line) return mid_point
def label_and_len_lines(self): # f = open('{0}/{1}.txt'.format(dir_path, self.outFile), 'w') # dists = [] for i in range(0, len(self.all_lines)): curr_len = rs.CurveLength(self.all_lines[i]) # rs.AddPipe(self.all_lines[i], 0, 0.09375, 0, 1) if math.fabs(curr_len - self.FLAT_LENGTH) > 0.000001: # dists.append('%.3f' % curr_len) mp = rs.CurveMidPoint(self.all_lines[i]) text = 'line{0}'.format(i) rs.AddText(text, mp, 0.3) start = rs.AddLine(rs.CurveStartPoint(self.all_lines[i - 1]), rs.CurveEndPoint(self.all_lines[i - 1])) mid = rs.AddLine(rs.CurveStartPoint(self.all_lines[i]), rs.CurveEndPoint(self.all_lines[i])) end = rs.AddLine(rs.CurveStartPoint(self.all_lines[i + 1]), rs.CurveEndPoint(self.all_lines[i + 1])) self.createPipe(start, mid, end, text)
def appendEdgeDirection(self): """ Calculate the unit vector of offset directions for self.edges and append in list: self.offsetDirection. :rtype: None (result in self.offsetDirection) """ for edge in self.edges: # make vertical vector curveVector = rs.VectorCreate(rs.CurveStartPoint(edge), rs.CurveEndPoint(edge)) midPoint = rs.CurveMidPoint(edge) vec1 = rs.VectorRotate(curveVector, 90.0, [0, 0, 1]) vec2 = rs.VectorRotate(curveVector, -90.0, [0, 0, 1]) midToCenterVec = rs.VectorCreate(midPoint, self.center) offsetVec = "" if rs.VectorDotProduct(vec1, midToCenterVec) > 0: offsetVec = vec1 else: offsetVec = vec2 offsetVec = rs.VectorUnitize(offsetVec) # result self.offsetDirection.append(offsetVec)
def CreatingNodeFun(Pt, Lines, BeamRad, BeamLength): Beams = [] for i in Lines: MidPt = rs.CurveMidPoint(i) DirVe = MidPt - Pt DirVecUni = rs.VectorUnitize(DirVe) TrVec = rs.VectorScale(DirVecUni, BeamLength) PtToMove = rs.AddPoint(pt) EndPt = rs.MoveObject(PtToMove, TrVec) Plane01 = rs.PlaneFromNormal(pt, DirVe) Plane02 = rs.PlaneFromNormal(PtToMove, DirVe) Ids = [] Cir01 = rs.AddCircle(Plane01, BeamRad) Cir02 = rs.AddCircle(Plane02, BeamRad) Ids.append(Cir01) Ids.append(Cir02) Beam = rs.AddLoftSrf(Ids) Beams.append(Beam) return Beams
def dogbone(curves, diam, diam_barrenos, tol): for curve in curves: if rs.CloseCurve(curve): centroid = rs.CurveAreaCentroid(curve)[0] else: centroid = rs.CurveMidPoint(curve) if diam_barrenos == -1: rs.AddPoint(centroid) elif diam_barrenos == 0: pass else: rs.AddCircle(centroid, diam_barrenos * .5) curve = rs.ConvertCurveToPolyline(curve, delete_input=True) tol_curve = rs.OffsetCurve(curve, centroid, -tol) if tol else curve ocurve = rs.OffsetCurve(tol_curve, rs.CurveAreaCentroid(curve)[0], diam * .3) circles = [rs.AddCircle(i, diam / 2) for i in rs.CurvePoints(ocurve)] rs.CurveBooleanUnion(circles + [tol_curve]) rs.DeleteObjects([ocurve, tol_curve] + circles) if curve: rs.DeleteObject(curve)
def Section2D(): #"Create cross-section and rotate to 2D plane" # Select objects to draw section from objects = rs.GetObjects("Select objects to rotate", rs.filter.curve) # Select cross section plane sectionplane = rs.GetObject("Select cross-section line", rs.filter.curve) # Calculate orientation of cross-section plane startpt = rs.CurveStartPoint(sectionplane) midpt = rs.CurveMidPoint(sectionplane) endpt = rs.CurveEndPoint(sectionplane) x1, y1 = startpt[0], startpt[1] x2, y2 = endpt[0], endpt[1] rad2deg = 180 / math.pi angle = math.atan((y2 - y1) / (x2 - x1)) * rad2deg # rotate cross-section objects to 2D plane rs.RotateObjects(objects, midpt, -angle) rs.RotateObjects(objects, midpt, -90, [1, 0, 0])
def addConstructionLine(point_a): # Color to use when drawing dynamic lines line_color_1 = System.Drawing.Color.FromArgb(200, 200, 200) line_color_2 = System.Drawing.Color.FromArgb(255, 0, 0) # This is a function that is called whenever the GetPoint's # DynamicDraw event occurs def GetPointDynamicDrawFunc(sender, args): point_b = args.CurrentPoint point_C = Rhino.Geometry.Point3d((point_a.X + point_b.X) / 2, (point_a.Y + point_b.Y) / 2, (point_a.Z + point_b.Z) / 2) #Rhino.Geometry.Transform.Translation( vec = rs.VectorCreate(point_b, point_a) rs.VectorUnitize(vec) vec2 = rs.VectorScale(vec, 500) vec3 = rs.coerce3dpoint(rs.VectorAdd(point_b, vec2)) rs.VectorReverse(vec2) vec4 = rs.coerce3dpoint(rs.VectorSubtract(point_b, vec2)) args.Display.DrawLine(point_a, vec3, line_color_1, 1) args.Display.DrawLine(point_a, vec4, line_color_1, 1) args.Display.DrawPoint(point_a, Rhino.Display.PointStyle.ControlPoint, 3, line_color_1) args.Display.DrawPoint(point_b, Rhino.Display.PointStyle.ControlPoint, 3, line_color_2) # Create an instance of a GetPoint class and add a delegate # for the DynamicDraw event gp = Rhino.Input.Custom.GetPoint() gp.DynamicDraw += GetPointDynamicDrawFunc gp.Get() if (gp.CommandResult() == Rhino.Commands.Result.Success): pt = gp.Point() line = rs.AddLine(point_a, pt) c = rs.CurveMidPoint(line) scaled = rs.ScaleObject(line, c, [500, 500, 500]) rs.ObjectColor(scaled, [199, 199, 199])
def resample_polyline(self, length): try: rs_poly = rs.AddPolyline(self.polyline.points) if length <= self.polyline.length: a = rs.DivideCurveLength(rs_poly, length, False) num_div = len( rs.DivideCurveLength(rs_poly, length, False, False)) new_pts = rs.DivideCurve(rs_poly, num_div, False, True) new_rs_poly = rs.AddPolyline(new_pts) segs = rs.ExplodeCurves(new_rs_poly) else: print('it is a line!') segs = [ rs.AddLine(rs.CurveStartPoint(rs_poly), rs.CurveEndPoint(rs_poly)) ] print(segs) out_pts = [] out_vec = [] for seg in segs: new_pt = rs.CurveMidPoint(seg) v = rs.VectorCreate(rs.CurveEndPoint(seg), rs.CurveStartPoint(seg)) new_pt = [new_pt.X, new_pt.Y, new_pt.Z] new_vec = [v.X, v.Y, v.Z] new_vec = compas.geometry.normalize_vector(new_vec) out_pts.append(new_pt) out_vec.append(new_vec) # print('succesfully resampled') return out_pts, out_vec except Exception: print('Polyline could not be resampled.') return None, None