def fillet_lines(self): self.lines = [] for i in range(0, len(self.line_lists)): fillets = [] new_line = [] for j in range(0, len(self.line_lists[i]) - 1): fillets.append( rs.AddFilletCurve(self.line_lists[i][j], self.line_lists[i][j + 1], 1)) for k in range(0, len(self.line_lists[i])): line = self.line_lists[i][k] if (k < len(self.line_lists[i]) - 1): line_domain = rs.CurveDomain(line) line_intersect = rs.CurveCurveIntersection( line, fillets[k])[0][5] line = rs.TrimCurve(self.line_lists[i][k], (line_domain[0], line_intersect), True) if (k > 0): line_domain = rs.CurveDomain(line) line_intersect = rs.CurveCurveIntersection( line, fillets[k - 1]) line = rs.TrimCurve(line, (line_intersect[0][5], line_domain[1]), True) new_line.append(line) if (k < len(self.line_lists[i]) - 1): new_line.append(fillets[k]) self.lines.append(rs.JoinCurves(new_line))
def GetPointsOnSecondCurve(self, trailingEdgeCurve, pointsOnFirstCurve): TrailingEdgePoints = [] for i in range(0, len(pointsOnFirstCurve)): # draw a line from the point on the first curve startingPoint = pointsOnFirstCurve[i] endPoint = (100, startingPoint[1], startingPoint[2]) tmpLine = rs.AddLine(startingPoint, endPoint) # get the point where the new line and the traling edge curve is intersection_list = rs.CurveCurveIntersection( trailingEdgeCurve, tmpLine) if intersection_list is None: print "Selected curves do not intersect." return for intersection in intersection_list: if intersection[0] == 1: print intersection[1] #rs.AddPoint(intersection[1]) TrailingEdgePoints.append(intersection[1]) rs.DeleteObject(tmpLine) return TrailingEdgePoints
def cxc(crv, pt, r, onlyNext=True): trash = [] xc = rs.AddCircle(pt, r) xx = rs.CurveCurveIntersection(crv, xc) xpts = [] if xx is None: return None #print('xx len:',len(xx)) for xxe in xx: if xxe[0] == 1: xpts.append(xxe[1]) rs.DeleteObject(xc) dom = rs.CurveDomain(crv) # endT=rs.CurveClosestPoint(crv,rs.CurveEndPoint(crv)) # print('endT :'endT) if onlyNext: centerT = rs.CurveClosestPoint(crv, pt) maxT = dom[0] maxI = 0 for i in range(0, len(xpts)): p = xpts[i] t = rs.CurveClosestPoint(crv, p) if t > maxT: maxT = t maxI = i # print(dom[1],centerT,t) if maxT > dom[1] or maxT < centerT: return None return xpts[maxI] return xpts
def rampIntersection(route1, route2, width): edges = [] offSeg1 = offsetLine(route1, width / 2) offSeg2 = offsetLine(route2, width / 2) test1 = rs.CurveCurveIntersection(offSeg1, offSeg2) if (test1 == None): side1 = False else: side1 = True offSeg3 = offsetLine(route1, -width / 2) offSeg4 = offsetLine(route2, -width / 2) rs.ObjectColor(offSeg3, [255, 0, 0]) rs.ObjectColor(offSeg4, [255, 0, 0]) test2 = rs.CurveCurveIntersection(offSeg3, offSeg4) if (test2 == None): side2 = False else: side2 = True if (side1): pivotPt = rs.LineLineIntersection(offSeg1, offSeg2)[0] perpPt1 = rs.EvaluateCurve(offSeg3, rs.CurveClosestPoint(offSeg3, pivotPt)) perpPt2 = rs.EvaluateCurve(offSeg4, rs.CurveClosestPoint(offSeg4, pivotPt)) edges.append(rs.AddLine(pivotPt, perpPt1)) edges.append(rs.AddLine(pivotPt, perpPt2)) elbowPt = rs.LineLineIntersection(offSeg3, offSeg4)[0] else: pivotPt = rs.LineLineIntersection(offSeg3, offSeg4)[0] perpPt1 = rs.EvaluateCurve(offSeg1, rs.CurveClosestPoint(offSeg1, pivotPt)) perpPt2 = rs.EvaluateCurve(offSeg2, rs.CurveClosestPoint(offSeg2, pivotPt)) edges.append(rs.AddLine(pivotPt, perpPt1)) edges.append(rs.AddLine(pivotPt, perpPt2)) elbowPt = rs.LineLineIntersection(offSeg1, offSeg2)[0] rs.DeleteObject(offSeg1) rs.DeleteObject(offSeg2) rs.DeleteObject(offSeg3) rs.DeleteObject(offSeg4) landing = rs.AddPolyline([pivotPt, perpPt1, elbowPt, perpPt2, pivotPt]) return edges, landing
def findIntersection(curve1, curve2): pAttempt = rs.CurveCurveIntersection(curve1,curve2) #if intersection exists if len(pAttempt) != 0: pOut = list() for i in range(len(pAttempt)): pInt = pAttempt[i] pOut.append(pInt[1]) return pOut else: return None
def unfilletCurve(curve): rs.EnableRedraw(False) curLay = rs.CurrentLayer() childrenLay = rs.LayerChildren(curLay) cutCrvs = [] contours = [] finalLines = [] finalLineSegs = [] tempCrv = curve if tempCrv is not None: cutCrvs.append(tempCrv) for crv in cutCrvs: contours.append(ghcomp.Explode(crv, True)[0]) for contour in contours: for i in range(0, len(contour)): if rs.IsLine(contour[i]): finalLines.append(sc.doc.Objects.AddCurve(contour[i])) finalPts = [] for line in finalLines: rs.ExtendCurveLength(line, 0, 2, 300) for i in range(0, len(finalLines) - 1): tempPt = rs.CurveCurveIntersection(finalLines[i], finalLines[i + 1]) finalPts.append(rs.AddPoint(rs.coerce3dpoint(tempPt[0][1]))) tempPt = rs.CurveCurveIntersection(finalLines[-1], finalLines[0]) finalPts.append(rs.AddPoint(rs.coerce3dpoint(tempPt[0][1]))) for i in range(0, len(finalPts) - 1): finalLineSegs.append(rs.AddLine(finalPts[i], finalPts[i + 1])) finalLineSegs.append(rs.AddLine(finalPts[-1], finalPts[0])) lastCrv = rs.JoinCurves(finalLineSegs, True) sc.doc.Views.Redraw() rs.DeleteObjects(finalPts) rs.DeleteObjects(finalLines) rs.DeleteObject(tempCrv) rs.DeleteObjects(cutCrvs) rs.EnableRedraw(True) rs.SelectObject(lastCrv)
def test_is_curve_not_selfintersected(options): layer_name = options['layer'] intersects = [] geom = get_geometry_by_layer(layer_name) if len(geom) == 0: return None, intersects for x in geom: xs = rs.CurveCurveIntersection(x) if xs: intersects.append(x.Name) return len(intersects) == 0, intersects
def CreateEdgeSupport(self, edge, circle): edgeParameters = [] circleParameters = [] intersections = rs.CurveCurveIntersection(edge, circle) for intersection in intersections: edgeParameters.append(intersection[5]) circleParameters.append(intersection[7]) edgeCurves = rs.SplitCurve(edge, edgeParameters, True) edge = self.Keep(edgeCurves, 1, 0) circleCurves = rs.SplitCurve(circle, circleParameters, True) arc = self.Keep(circleCurves, 2) return rs.JoinCurves([edge, arc], True)
def curveDivByDiameter(): curve = rs.GetObject("sel curve") point = rs.GetPoint("sel point") num = rs.GetReal("radius") cBool = True # ptDir = rs.GetPoint("set Direction:") numA= num if(cBool): numA = num/2 else: numA = num circle = rs.AddCircle(point,numA) ix = rs.CurveCurveIntersection(curve,circle) rs.AddPoint(ix[0][1]) # or alternatively: # rs.AddPoint(ix[0][1]) # this should get the first intersection curve # rs.AddPoint(ix[1][1]) # this should get the second intersection curve arrPt = [] count = 20 countConst = count #create a check for point by point(x,y,z) value while(True != (ix[0][1] in arrPt) and count > 0): circle = rs.AddCircle(ix[0][1],num) ix = rs.CurveCurveIntersection(curve,circle) arrPt.append(rs.AddPoint(ix[0][1])) count -= 1 rs.Prompt(str(countConst-count)); count = 20 circle = rs.AddCircle(point,numA) ix = rs.CurveCurveIntersection(curve,circle) while(True != (ix[1][1] in arrPt) and count > 0): circle = rs.AddCircle(ix[1][1],num) ix = rs.CurveCurveIntersection(curve,circle) arrPt.append(rs.AddPoint(ix[1][1])) count -= 1 rs.Prompt(str(countConst-count));
def recursivePanel(startPoint, lengthPanel): """it works only with this rules: circle just cut crv in two points, this means crv is more or less strait and do not have flowers on int""" #building the core circleAux = rs.AddCircle(startPoint, lengthPanel) pEnd = rs.CurveCurveIntersection(crvIterative, circleAux) if len(pEnd) == 2: #first middle curve panelA = rs.AddLine(startPoint, pEnd[0][1]) recursivePanel(pEnd[0][1], lengthPanel)
def trim(self, curve, cutter, filter=1): resultLines = [] intersectedPoints = rs.CurveCurveIntersection(curve, cutter) if intersectedPoints == None: return None tmpSurface = rs.AddPlanarSrf(cutter) intersectedPoints = [n[1] for n in intersectedPoints] intersectedPoints.insert(0, rs.CurveStartPoint(curve)) intersectedPoints.insert(len(intersectedPoints), rs.CurveEndPoint(curve)) for i in range(len(intersectedPoints) - 1): x = intersectedPoints[i][0] + intersectedPoints[i + 1][0] y = intersectedPoints[i][1] + intersectedPoints[i + 1][1] z = intersectedPoints[i][2] + intersectedPoints[i + 1][2] mid = (x / 2.0, y / 2.0, z / 2.0) if tmpSurface is None: continue if rs.IsPointOnSurface(tmpSurface, mid): if filter == 1: resultLines.append( rs.AddLine(intersectedPoints[i], intersectedPoints[i + 1])) elif filter == 2: continue else: if filter == 1: continue elif filter == 2: resultLines.append( rs.AddLine(intersectedPoints[i], intersectedPoints[i + 1])) rs.DeleteObject(curve) if tmpSurface is not None: rs.DeleteObject(tmpSurface) return resultLines
def ccx(): curve1 = rs.GetObject("Select first curve", 4) curve2 = rs.GetObject("Select second curve", 4) intersection_list = rs.CurveCurveIntersection(curve1, curve2) if intersection_list is None: print "Selected curves do not intersect." return for intersection in intersection_list: print("Point") print("Intersection point on first curve:") print(intersection[1]) print("Intersection point on second curve:") print(intersection[3]) print("First curve parameter:") print(intersection[5]) print("Second curve parameter:") print(intersection[7])
def checkPoly(self, pts, poly): sum = 0 for i in pts: m = rs.PointInPlanarClosedCurve(i, poly) if (m != 0): sum += 1 poly2 = rs.AddPolyline(pts) pts2 = rs.CurvePoints(poly) for i in pts2: m = rs.PointInPlanarClosedCurve(i, poly2) if (m != 0): sum += 1 intx = rs.CurveCurveIntersection(poly, poly2) rs.DeleteObject(poly2) if (sum > 0 or intx): return False else: return True
def checkSelfIntersection(obj): segments = rs.ExplodeCurves(obj, False) list = segments for seg in segments: segA = seg segments.remove(segA) for segB in segments: intersection_list = rs.CurveCurveIntersection(segA, segB, tolerance=-1) if intersection_list: for intersection in intersection_list: if (intersection[0] == 2): rs.AddPoint(intersection[1]) rs.AddPoint(intersection[2]) rs.DeleteObjects(list)
def create_slots(array, partIndex): """ Creates half-lap slots for a given part with its intersecting neighbors. Returns a list of tuples with part index and slot curve.""" numItems = len(array) if partIndex >= numItems: return "part index outside of array" part = array[partIndex] intersections = find_neighbor_intersections(array, partIndex) boundary = rs.DuplicateSurfaceBorder(part) slots = [] ## check intersections with the part's boundary to determine joint case ## rs.CurveCurveIntersection returns case specific lists see F1 help. for line in intersections: if len(line) == 1: return intersectTest = rs.CurveCurveIntersection(line[1], boundary) ## Case 1: slot is floating in part boundary (Only works in some cases) if intersectTest == None: slots.append((partIndex, line[1])) ## Case 2: intersection coincedent along an edge and can't be slotted elif intersectTest[0][0] == 2: print "no slot needed" ## Case 3: part and neighbor have a valid connection and slot is drawn else: ## create Current Part slot startPoint = intersectTest[0][1] endPoint = evaluateCrv(line[1], .5) slot = rs.AddLine(startPoint, endPoint) slots.append((partIndex, slot)) ## create neighbor slot testPoint = rs.CurveEndPoint(line[1]) distance = rs.Distance(startPoint, testPoint) if distance != 0: startPoint = testPoint else: startPoint = rs.CurveStartPoint(line[1]) slot = rs.AddLine(startPoint, endPoint) slots.append((line[0], slot)) return slots
def offsetRow(self, edge, vec, width): """ Offset a row depending on the type of width and direction. need to use self.edges :return: """ # print("edge", rs.CurveLength(edge)) # print("vec", vec) # print("width", width) newRow = rs.OffsetCurve(edge, vec, width) # Magic number # print("newRow", newRow) # print("newRowCurve", rs.CurveLength(newRow)) rs.ScaleObject(newRow, rs.CurveMidPoint(newRow), [20, 20, 0]) # print("ScaleNewRowCurve", rs.CurveLength(newRow)) # Problem Below!! param = [] for e in self.edges: intersect = rs.CurveCurveIntersection(newRow, e) # Follows the Rhino api if intersect is not None: param.append(intersect[0][5]) # print("param", param) if param[0] < param[1]: newRow = rs.TrimCurve(newRow, [param[0], param[1]]) elif param[0] > param[1]: newRow = rs.TrimCurve(newRow, [param[1], param[0]]) else: # only one intersection, it's time to stop newRow = None # newRow = rs.TrimCurve(newRow, [param[0], param[1]]) # print("TrimNewRowCurve", rs.CurveLength(newRow)) return newRow
def GetPoints(self, curve): curveDomain = rs.CurveDomain(curve) # Get the minimim point minDomainValue = curveDomain[0] minPoint = rs.EvaluateCurve(curve, minDomainValue) # get the maximum point maxDomainValue = curveDomain[1] maxPoint = rs.EvaluateCurve(curve, maxDomainValue) yLength = abs(minPoint[1] - maxPoint[1]) points = [] for i in range(0, self.numberOfDivisions + 1): print minPoint startingPoint = (minPoint[0], (yLength / self.numberOfDivisions) * i, minPoint[2]) print startingPoint endPoint = (100, startingPoint[1], startingPoint[2]) tmpLine = rs.AddLine(startingPoint, endPoint) # get the point where the new line and the traling edge curve is intersection_list = rs.CurveCurveIntersection(curve, tmpLine) if intersection_list is None: print "Selected curves do not intersect." return for intersection in intersection_list: if intersection[0] == 1: print intersection[1] #rs.AddPoint(intersection[1]) points.append(intersection[1]) rs.DeleteObject(tmpLine) return points
def trim(self, curve, cutter): resultLines = [] #when arguments are shit, return empty list try: rs.IsCurve(curve) except: ##Debug needs print('IsCurve failed') print(curve) return resultLines try: rs.IsCurve(cutter) except: ##Debug needs print('IsCurve failed') print(cutter) return resultLines if rs.IsCurve(curve) is False or rs.IsCurve(cutter) is False: return resultLines intersectedPoints = rs.CurveCurveIntersection(curve, cutter) if intersectedPoints == None: return resultLines #when cutter is not planar, tmpSurface will be non intersectedPoints = [n[1] for n in intersectedPoints] if len(intersectedPoints) % 2 == 1: #print("In trim(), there is weird") return resultLines #convert point to curve parameter curveParas = [] for i in intersectedPoints: curveParas.append(rs.CurveClosestPoint(curve, i)) for i in range(int(len(curveParas) / 2)): tmp = [] tmp.append(curveParas[i * 2]) tmp.append(curveParas[i * 2 + 1]) try: resultLines.append(rs.TrimCurve(curve, tmp)) except: return [] ##debug needs """ print('trim failed\ncurve,tmp,domain') print(curve) print(tmp) print(rs.IsCurve(curve)) ##debug needs ##why this 'curve' isn't curve? if rs.IsCurve(curve): print(rs.CurveDomain(curve)) """ return resultLines
pts = P polylines = [] for pt in P: polylines.append(chebyshev_circle(pt, r)) for i in range(len(polylines)): for j in range(i): if i == j: continue if rs.CurveBooleanUnion([polylines[i], polylines[j]]): MN = chebyshev_midnormal(pts[i], pts[j], l) ccx = rs.CurveCurveIntersection(polylines[i], MN, 0.0001) if ccx is None: continue if ccx[0][0] == 2: continue para_a = [ccx[0][5], ccx[1][5]] para_b = [ccx[0][7], ccx[1][7]] if para_b[0] > para_b[1]: para_b.reverse() probable_dash = rs.SplitCurve(polylines[i], para_a) edge = rs.TrimCurve(MN, para_b, False) edgepts = rs.CurvePoints(edge) for crv in probable_dash:
coordinates1_list = [] for (x, y) in list1: coordinates1 = (x, y, 0) rs.AddPoint(coordinates1) coordinates1_list.append(coordinates1) coordinates2_list = [] for (x, y) in list2: coordinates2 = (x, y, 0) rs.AddPoint(coordinates2) coordinates2_list.append(coordinates2) curve1 = rs.AddInterpCurve(coordinates1_list) curve2 = rs.AddInterpCurve(coordinates2_list) intersection_list = rs.CurveCurveIntersection(curve1, curve2) #print(intersection_list) points_intersection_list = [] for intersection in intersection_list: if intersection[0] == 1: print "Intersection point on first curve: ", intersection[1] points_intersection_list.append(intersection[1]) #print(points_intersection_list) distances = [] for point in points_intersection_list: distances.append(rs.Distance((0, 0, 0), point)) print(distances) distanceAndPointsPaired = zip(distances, points_intersection_list) distanceAndPointsPaired.sort() #need to take the second velue, because the first one is the beginning of the coordinates where the curves start closestPoint = distanceAndPointsPaired[1][1]
def getpEnd(self): circle = rs.AddCircle(self.pStart, 1) self.pEnd = rs.CurveCurveIntersection(self.Crv, circle) return self.pEnd
def IntersectionMatrix(self, boundary_list, intersected_fractures): """ Function to perform fracture-fractrure intersection and fracture-boundary intersection, then form an intersection matrix. Parameters --------- boundary_list: list list of GUIDs of the plane's boundaries intersected_fractures: list list of GUIDs of the intersecting fractures Raises ------ TypeError if the arguments are not lists """ try: if type(boundary_list) != list or type( intersected_fractures) != list: raise TypeError except TypeError: print("IntersectionMatrix(): The two arguments should\ be of type list") else: # initialize Matrix mat = [] # number of fractures num_frac = len(intersected_fractures) # number of rows and cols for matrix n_row = num_frac + 4 n_col = num_frac + 4 # initialize matrix for i in range(n_row): mat.append([]) for j in range(n_col): mat[i].append(j) mat[i][j] = 0 # boundary to bounday taken care by the matrix initialization # fractures to fractures for i in range(num_frac): for j in range(num_frac): if i != j: intersection = rs.CurveCurveIntersection( intersected_fractures[i], intersected_fractures[j]) if intersection is not None: # set the matrix elements to be 1 # since it is a symmetric matrix # mat[i][j] == mat[j][i] mat[i][j] = 1 mat[j][i] = 1 # boundary-fractures for i in range(num_frac): # 0 to number of fractures - 1 # number of fractures to end of row/col for j in range(num_frac, n_col): intersection = rs.CurveCurveIntersection( intersected_fractures[i], boundary_list[j - num_frac]) if intersection is not None: # set the matrix elements to be 1 # since it is a symmetric matrix mat[i][j] == mat[j][i] mat[i][j] = 1 mat[j][i] = 1 # return the matrix return mat
def drilling(curve_list, surface1, used_line2, unused_line, closest_p): split_num = 4 point_list = [] if not curve_list: # print("tan2: There is not curve") return if len(curve_list) != 1: cur_length = [] length = 0 # Message: unable to convert 0530c598-26e0-4ff5-a15a-389bd334aeff into Curve geometry for i in range(0, len(curve_list)): if rs.IsCurve(curve_list[i]): length = rs.CurveLength(curve_list[i]) cur_length.append(length) curve_index = cur_length.index(max(cur_length)) curve = curve_list[curve_index] else: curve = curve_list domain = rs.CurveDomain(curve) t = (domain[1] - domain[0]) / split_num for i in range(0, 4): dt = t * i point = rs.EvaluateCurve(curve, dt) point_list.append(point) # 直線の交点を求める line1 = rs.AddLine(point_list[0], point_list[2]) line2 = rs.AddLine(point_list[1], point_list[3]) vec1 = rs.VectorCreate(point_list[2], point_list[0]) vec2 = rs.VectorCreate(point_list[3], point_list[1]) cross = rs.VectorCrossProduct(vec1, vec2) normal = rs.VectorUnitize(cross) curveOnsurface1 = rs.ProjectCurveToSurface(line1, surface1, normal) curveOnsurface2 = rs.ProjectCurveToSurface(line2, surface1, normal) if len(curveOnsurface1) == 0: # ttm add プロジェクションされていない可能性があるため new_vec1 = rs.VectorReverse(normal) curveOnsurface1 = rs.ProjectCurveToSurface(line1, surface1, new_vec1) if len(curveOnsurface2) == 0: # ttm add プロジェクションされていない可能性があるため new_vec2 = rs.VectorReverse(normal) curveOnsurface2 = rs.ProjectCurveToSurface(line2, surface1, new_vec2) if len(curveOnsurface1) == 2 and len(curveOnsurface2) == 2: intersection1 = rs.CurveCurveIntersection(curveOnsurface1[0], curveOnsurface2[0]) intersection2 = rs.CurveCurveIntersection(curveOnsurface1[1], curveOnsurface2[1]) # 条件分岐 if intersection1 is None: intersection1 = rs.CurveCurveIntersection(curveOnsurface1[0], line2) if intersection1 is None: intersection1 = rs.CurveCurveIntersection( curveOnsurface2[0], line1) if intersection1 is None: intersection1 = rs.CurveCurveIntersection( curveOnsurface1[1], line2) if intersection1 is None: intersection1 = rs.CurveCurveIntersection( curveOnsurface2[1], line1) if intersection1 is None: intersection1 = rs.CurveCurveIntersection( curveOnsurface1[0], curveOnsurface2[1]) intersection2 = rs.CurveCurveIntersection( curveOnsurface1[1], curveOnsurface2[0]) else: # normal_reverce = rs.VectorReverse(normal) # curveOnsurface1 = rs.ProjectCurveToSurface(line1, surface1, normal) # curveOnsurface2 = rs.ProjectCurveToSurface(line2, surface1, normal) intersection1 = rs.CurveCurveIntersection( curveOnsurface1[0], curveOnsurface2[0]) #index out of range: 0 intersection2 = None # console # print("intersection1: %s" % (intersection1)) # print("intersection2: %s" % (intersection2)) if intersection1 is None and intersection2 is None: center_point = rs.CurveMidPoint(curveOnsurface1[0]) elif intersection2 is None: center_point = intersection1[0][1] else: center_point1 = intersection1[0][1] center_point2 = intersection2[0][1] dis1 = rs.Distance(center_point1, closest_p) dis2 = rs.Distance(center_point2, closest_p) if dis1 > dis2: center_point = center_point2 else: center_point = center_point1 parameter1 = rs.CurveClosestPoint(unused_line, center_point) parameter2 = rs.CurveClosestPoint(used_line2, center_point) point1 = rs.EvaluateCurve(unused_line, parameter1) # base point point2 = rs.EvaluateCurve(used_line2, parameter2) # base point # ドリル穴のベクトルを生成 drill_line = rs.AddLine(point1, point2) rs.CurveArrows(drill_line, 2) rs.ExtendCurveLength(drill_line, 0, 2, 100) drill_vec = rs.VectorCreate(point2, point1) # 外積計算より回転軸を生成 start_point = rs.CurveStartPoint(unused_line) end_point = rs.CurveEndPoint(unused_line) distance1 = rs.Distance(start_point, center_point) distance2 = rs.Distance(end_point, center_point) if distance1 > distance2: select_point = end_point else: select_point = start_point # 回転平面を定義する origin_point = center_point x_point = point1 y_point = select_point new_plane = rs.PlaneFromPoints(origin_point, x_point, y_point) rs.ViewCPlane(None, new_plane) rotate_p = origin_point vec1 = rs.VectorCreate(x_point, rotate_p) vec2 = rs.VectorCreate(y_point, rotate_p) cross = rs.VectorCrossProduct(vec1, vec2) cross_unit = rs.VectorUnitize(cross) rotate_vec = rs.VectorScale( cross_unit, 100) # Message: Could not convert None to a Vector3d # 描画 # new_rotate_axis = AddVector(center_point, rotate_vector) # rotate_axis = AddVector(rotate_p, rotate_vec) # rs.AddPoint(point1) # rs.AddPoint(point2) # rs.AddPoint(center_point) # object削除 rs.DeleteObject(line1) rs.DeleteObject(line2) for i in range(0, len(curveOnsurface1)): rs.DeleteObject(curveOnsurface1[i]) for i in range(0, len(curveOnsurface2)): rs.DeleteObject(curveOnsurface2[i]) # 平面をもとのxy平面に戻す origin_point = (0, 0, 0) x_point = (100, 0, 0) y_point = (0, 100, 0) new_plane = rs.PlaneFromPoints(origin_point, x_point, y_point) rs.ViewCPlane(None, new_plane) # 戻り値(ドリルライン、ドリルベクトル、回転軸、回転軸点) return drill_line, drill_vec, rotate_vec, center_point
pts = P polylines = [] for pt in P: polylines.append(taxicab_circle(pt, r)) for i in range(len(polylines)): for j in range(i): if i == j: continue if rs.CurveBooleanUnion([polylines[i], polylines[j]]): MN = taxicab_midnormal(pts[i], pts[j], l) ccx = rs.CurveCurveIntersection(polylines[i], MN) if ccx is None: continue if ccx[0][0] == 2: continue para_a = [ccx[0][5], ccx[1][5]] para_b = [ccx[0][7], ccx[1][7]] if para_b[0] > para_b[1]: para_b = [para_b[1], para_b[0]] probable_dash = rs.SplitCurve(polylines[i], para_a) edge = rs.TrimCurve(MN, para_b, False) edgepts = rs.CurvePoints(edge) for crv in probable_dash:
def setLayerFill(self, vec, intersectCurve, index): #set baseline, baseVec, dist newSliceSurface = rs.CopyObject(self.sliceSurface, vec) editPoints = rs.SurfaceEditPoints(newSliceSurface) #vertical if index % 2 == 0: baseLine = rs.AddLine(editPoints[0], editPoints[1]) baseVec = (editPoints[2][0] - editPoints[0][0], editPoints[2][1] - editPoints[0][1], editPoints[2][2] - editPoints[0][2]) dist = rs.Distance(editPoints[0], editPoints[2]) #horizontal elif index % 2 == 1: baseLine = rs.AddLine(editPoints[0], editPoints[2]) baseVec = (editPoints[1][0] - editPoints[0][0], editPoints[1][1] - editPoints[0][1], editPoints[1][2] - editPoints[0][2]) dist = rs.Distance(editPoints[0], editPoints[1]) #normalize baseVec forNormal = math.sqrt(baseVec[0]**2 + baseVec[1]**2 + baseVec[2]**2) baseVec = [i / forNormal for i in baseVec] #end set baseLine, baseVec, dist self.gcoder.addGcode("; layer filling\n") for i in range(int(dist / self.gcoder.getLayerHeight()) + 1): lines = [] nextVec = [v * self.gcoder.getLayerHeight() * i for v in baseVec] #vertical if index % 2 == 0: nextStartPoint = (editPoints[0][0] + nextVec[0], editPoints[0][1] + nextVec[1], editPoints[0][2] + nextVec[2]) nextEndPoint = (editPoints[1][0] + nextVec[0], editPoints[1][1] + nextVec[1], editPoints[1][2] + nextVec[2]) if index % 2 == 1: nextStartPoint = (editPoints[0][0] + nextVec[0], editPoints[0][1] + nextVec[1], editPoints[0][2] + nextVec[2]) nextEndPoint = (editPoints[2][0] + nextVec[0], editPoints[2][1] + nextVec[1], editPoints[2][2] + nextVec[2]) #nextLine = (nextStartPoint), (nextEndPoint) nextLine = rs.AddLine(nextStartPoint, nextEndPoint) try: intersectedPoint = rs.CurveCurveIntersection( nextLine, intersectCurve[0]) except: print("intersect failur") print('nextLine') print(nextLine) print('intersectCurve') print(intersectCurve) print(intersectCurve[0]) if intersectedPoint == None: #print('intersectedPoint is none') rs.DeleteObject(nextLine) rs.DeleteObject(newSliceSurface) continue intersectedPoint = [n[1] for n in intersectedPoint] if len(intersectedPoint) % 2 == 0: for j in range(int(len(intersectedPoint) / 2)): if i % 2 == 0: lines.append( rs.AddLine(intersectedPoint[2 * j], intersectedPoint[(2 * j) + 1])) else: lines.append( rs.AddLine( intersectedPoint[ 2 * int(len(intersectedPoint) / 2 - j) - 1], intersectedPoint[ 2 * int(len(intersectedPoint) / 2 - j) - 2])) elif len(intersectedPoint) % 2 == 1: #check there is no duplicate point with intersectCurve #DEBUG needs intersectedPoint = self.deleteAlonePoint( intersectedPoint, intersectCurve) rs.DeleteObject(nextLine) for j in lines: startPoint = rs.CurveStartPoint(j) endPoint = rs.CurveEndPoint(j) #self.gcoder.calcEValue(startPoint, endPoint) self.gcoder.calcEValue(rs.Distance(startPoint, endPoint)) tmpText = "G1 X" + str(startPoint[0]) + " Y" + str( startPoint[1]) + " Z" + str(startPoint[2]) + " F3600\n" tmpText += "G1 X" + str(endPoint[0]) + " Y" + str( endPoint[1]) + " Z" + str(endPoint[2]) + " E" + str( self.gcoder.getEValue()) + " F1800\n" self.gcoder.addGcode(tmpText) rs.DeleteObjects(lines) rs.DeleteObject(newSliceSurface)
def setInfill(self, vec, intersectCurve): if self.gcoder.getInfillRatio() == 0: return newSliceSurface = rs.CopyObject(self.sliceSurface, vec) editPoints = rs.SurfaceEditPoints(newSliceSurface) rs.DeleteObject(newSliceSurface) #horizontal baseLine = rs.AddLine(editPoints[0], editPoints[1]) baseVec = (editPoints[2][0] - editPoints[0][0], editPoints[2][1] - editPoints[0][1], editPoints[2][2] - editPoints[0][2]) forNormalize = math.sqrt(baseVec[0]**2 + baseVec[1]**2 + baseVec[2]**2) baseVec = [i / forNormalize for i in baseVec] dist = rs.Distance(editPoints[0], editPoints[2]) lines = [] #interval = self.gcoder.getLayerHeight() * (1.0 / self.gcoder.getInfillRatio()) interval = self.gcoder.getLayerHeight() * 30 #prepare horizontal lines for i in range(int(dist / interval + 1)): nextVec = [j * (interval * i) for j in baseVec] nextStartPoint = (editPoints[0][0] + nextVec[0], editPoints[0][1] + nextVec[1], editPoints[0][2] + nextVec[2]) nextEndPoint = (editPoints[1][0] + nextVec[0], editPoints[1][1] + nextVec[1], editPoints[1][2] + nextVec[2]) nextLine = rs.AddLine(nextStartPoint, nextEndPoint) if nextLine == None or intersectCurve == None: ''' print("hogehoge") print('nextLine') print(nextLine) print('intersectCurve') print(intersectCurve) ''' continue try: intersectedPoint = rs.CurveCurveIntersection( nextLine, intersectCurve) except: print('failed') print('nextLine') print(nextLine) print('intersectCurve') print(intersectCurve) if intersectedPoint == None: rs.DeleteObject(nextLine) continue intersectedPoint = [n[1] for n in intersectedPoint] if intersectedPoint == None: print('there is no intersectedPoint') rs.DeleteObject(nextLine) rs.DeleteObject(intersectedPoint) continue if len(intersectedPoint) % 2 == 0: for j in range(int(len(intersectedPoint) / 2)): if i % 2 == 0: lines.append( rs.AddLine(intersectedPoint[2 * j], intersectedPoint[(2 * j) + 1])) else: lines.append( rs.AddLine( intersectedPoint[ 2 * int(len(intersectedPoint) / 2 - j) - 1], intersectedPoint[ 2 * int(len(intersectedPoint) / 2 - j) - 2])) elif len(intersectedPoint) % 2 == 1: #check there is no duplicate point with intersectCurve #DEBUG needs intersectedPoint = self.deleteAlonePoint( intersectedPoint, intersectCurve) rs.DeleteObject(nextLine) self.gcoder.addGcode("; layer infill\n") for i in range(len(lines)): startPoint = rs.CurveStartPoint(lines[i]) endPoint = rs.CurveEndPoint(lines[i]) #self.gcoder.calcEValue(startPoint, endPoint) self.gcoder.calcEValue(rs.Distance(startPoint, endPoint)) #if i%2 == 0: tmpText = "G1 X" + str(startPoint[0]) + " Y" + str( startPoint[1]) + " Z" + str(startPoint[2]) + " F3600\n" tmpText += "G1 X" + str(endPoint[0]) + " Y" + str( endPoint[1]) + " Z" + str(endPoint[2]) + " E" + str( self.gcoder.getEValue()) + " F1800\n" self.gcoder.addGcode(tmpText) rs.DeleteObjects(lines) #rs.DeleteObject(baseLine) #vertical baseLine = rs.AddLine(editPoints[0], editPoints[2]) baseVec = (editPoints[1][0] - editPoints[0][0], editPoints[1][1] - editPoints[0][1], editPoints[1][2] - editPoints[0][2]) forNormalize = math.sqrt(baseVec[0]**2 + baseVec[1]**2 + baseVec[2]**2) baseVec = [i / forNormalize for i in baseVec] dist = rs.Distance(editPoints[0], editPoints[1]) lines = [] #interval = self.gcoder.getLayerHeight() * (1.0 / self.gcoder.getInfillRatio()) #prepare horizontal lines for i in range(int(dist / interval + 1)): nextVec = [j * (interval * i) for j in baseVec] nextStartPoint = (editPoints[0][0] + nextVec[0], editPoints[0][1] + nextVec[1], editPoints[0][2] + nextVec[2]) nextEndPoint = (editPoints[2][0] + nextVec[0], editPoints[2][1] + nextVec[1], editPoints[2][2] + nextVec[2]) nextLine = rs.AddLine(nextStartPoint, nextEndPoint) if nextLine == None or intersectCurve == None: #print("hogehoge") continue intersectedPoint = rs.CurveCurveIntersection( nextLine, intersectCurve) if intersectedPoint == None: #print('intersectedPoint is none') rs.DeleteObject(nextLine) continue intersectedPoint = [n[1] for n in intersectedPoint] if intersectedPoint == None: print('there is no intersectedPoint') rs.DeleteObject(nextLine) rs.DeleteObject(intersectedPoint) continue if len(intersectedPoint) % 2 == 0: for j in range(int(len(intersectedPoint) / 2)): if i % 2 == 0: lines.append( rs.AddLine(intersectedPoint[2 * j], intersectedPoint[(2 * j) + 1])) else: lines.append( rs.AddLine( intersectedPoint[ 2 * int(len(intersectedPoint) / 2 - j) - 1], intersectedPoint[ 2 * int(len(intersectedPoint) / 2 - j) - 2])) elif len(intersectedPoint) % 2 == 1: #check there is no duplicate point with intersectCurve #DEBUG needs intersectedPoint = self.deleteAlonePoint( intersectedPoint, intersectCurve) rs.DeleteObject(nextLine) self.gcoder.addGcode("; layer infill\n") for i in range(len(lines)): startPoint = rs.CurveStartPoint(lines[i]) endPoint = rs.CurveEndPoint(lines[i]) #self.gcoder.calcEValue(startPoint, endPoint) self.gcoder.calcEValue(rs.Distance(startPoint, endPoint)) #if i%2 == 0: tmpText = "G1 X" + str(startPoint[0]) + " Y" + str( startPoint[1]) + " Z" + str(startPoint[2]) + " F3600\n" tmpText += "G1 X" + str(endPoint[0]) + " Y" + str( endPoint[1]) + " Z" + str(endPoint[2]) + " E" + str( self.gcoder.getEValue()) + " F1800\n" ''' else: tmpText += "G1 X" + str(endPoint[0]) + " Y" + str(endPoint[1]) + " Z" + str(endPoint[2]) + " F3600\n" tmpText = "G1 X" + str(startPoint[0]) + " Y" + str(startPoint[1]) + " Z" + str(startPoint[2]) +" E" + str(self.gcoder.getEValue()) + " F1800\n" ''' self.gcoder.addGcode(tmpText) rs.DeleteObjects(lines) #rs.DeleteObject(baseLine) return
def Generation(): #SETTING UP THE FILE ACCESS TO READ ALL THERE IS TO BE READ #THE SCRIPT FROM NOW ON LOOKS for FILE AND if IT CANNOT FIND ONE IT WILL HAVE TO MAKE ONE #SOOO WE START BY LOOKING for AND READING THE FILE if WE FIND IT ## ######################################################################## #READ INFO IN THE FILE ######################################################################## #ReadFile returns an array of [isAlive,startPoint,jointNos] content = History.ReadPolies(folder, file) rhUnitInches = 8 rs.UnitSystem(rhUnitInches, False, True) zero = [0, 0, 0] zaxis = [0, 0, 1] vrt = [] #Decimal display and decimal places #rs.UnitDistanceDisplayMode(0) #rs.UnitDistanceDisplayPrecision(7) #sth to control that we have an [0,0,0] to check endcheck = 1 size = 1 living = [] startpts = [] sequences = [] #if we read nothing we should save 1 starting point - namely [0,0,0] if content is None: living = [1] startpts = [[0, 0, 0]] sequences = [[0]] npolies = 0 content = [[living[0], startpts[0], sequences[0]]] endcheck = 0 else: for rib in content: living.append(rib[0]) startpts.append(rib[1]) sequences.append(rib[2]) #checking if new rib has actualy been started #[0,0,0] will always be there to be grown if rs.Distance(content[-1][1], [0, 0, 0]) < tiny: endcheck = 0 # if not and we have less than 4 legs start a new leg at [0,0,0] if (endcheck != 0 and len(content) < 4): ribs = content ribs.append([1, [0, 0, 0], [0]]) content = ribs endcheck = 0 living.append(1) startpts.append([0, 0, 0]) sequences.append([0]) npolies = len(content) narm = [] setforbool = [] content2 = [] crack = [] numb = 0 # P R O C E S S I N G #CASE 1. NOTHING HAS BEEN MADE. WE HAVE ONE EXISTING RIB. IT IS BUDDING (IT THINKS IT STARTS AT [0,0,0]) #NO CHECKS, NO INTERSECTIONS, THE B A S I C STUFF if npolies == 1: for i in range(noribs): rs.Command( "_-Import C:\R3\OffCenter\Walk\Temp\protoslant_walk.igs ENTER") rs.Command("_SelAll") rs.Command("_Join") rs.Command("_SelNone") rs.Command("_SelAll") defject = rs.SelectedObjects(False, False) box2 = rs.AddPolyline([[-5.25, -5.25, 0], [5.25, -5.25, 0], [5.25, 5.25, 0], [-5.25, 5.25, 0], [-5.25, -5.25, 0]]) rs.MoveObject(box2, move_it) line1 = [1, 0, 0] line1 = rs.VectorRotate(line1, i * 360 / (noribs), zaxis) sequence = [1, line1, [0]] polypoints = JointAccess.Outline(sequence[1], sequence[1], sequence[2]) verte = rs.AddPolyline(polypoints) intersection = rs.CurveCurveIntersection(verte, box2) if not intersection is None: sequence[0] = 0 rs.DeleteObject(verte) setforbool = [] setforbool.append(defject) setforbool.append( JointAccess.Arm(sequence[1], sequence[1], sequence[2], fc)) container = rs.BooleanUnion(setforbool) if not container is None: defject = container(0) SaveNClean(defject, polypoints, numb, content2) numb = numb + 1 #CASE 2 ONE RIB HAS STARTED GROWING AND ONE RIB IS BUDDING (THINKS THE ENDPOINT IS (0,0,0)) #THE EXISTING RIB NEEDS TO CHECK FOR INTERECTIONS WITH ITSELF ALONE [MAYBE WITH THE BASE AS WELL????] #THE NEW RIB MUST MAKE SURE IT IS STARTING FROM A DIFFERENT POINT A N D THAT IT DOES NOT INTERSECT WITH EXISTING RIB elif npolies == 2 and rs.Distance(startpts[-1], [0, 0, 0]) <= tiny: #ADDING TO THE EXISTING RIB #THE LOOP BELOW IS INFRASTRUCTURE FOR CASE 3. RIGHT NOW IT ONLY HAS ONE ITERATION for i in range(npolies - 1): insequence = content[i] #do sth only if this particular rib is NOT DEAD if insequence[0] != 0: for i in range(noribs)[1:]: #i is going through 1 to 15 for different endings #in [s,e,q,u,e,n,c,e,0] we will get [s,e,q,u,e,n,c,e,i,0] rs.Command( "_-Import C:\R3\OffCenter\Walk\Temp\protoslant_walk.igs ENTER" ) rs.Command("_SelAll") rs.Command("_Join") rs.Command("_SelNone") rs.Command("_SelAll") defject = rs.SelectedObjects(False, False) box2 = rs.AddPolyline([[-5.25, -5.25, 0], [5.25, -5.25, 0], [5.25, 5.25, 0], [-5.25, 5.25, 0], [-5.25, -5.25, 0]]) rs.MoveObject(box2, move_it) joints = insequence[2][:-1] joints.append(i) joints.append(0) sequence = [1, insequence[1], joints] polypoints = JointAccess.Outline(sequence[1], sequence[1], sequence[2]) verte = rs.AddPolyline(polypoints) #CHECKING FOR SELF INTERSECTION #continue continues with the loop without reading the stuff below int = rs.CurveCurveIntersection(verte, None, 0.000001) if len(int) != 0: everything = rs.AllObjects() rs.DeleteObjects(everything) continue intersection = rs.CurveCurveIntersection(verte, box2) #NEED A SELF INTERSECTIOn CHECK if not intersection is None: sequence[0] = 0 rs.DeleteObject(verte) setforbool = [] setforbool.append(defject) setforbool.append( JointAccess.Arm(sequence[1], sequence[1], sequence[2], fc)) container = rs.BooleanUnion(setforbool) if not container is None: defject = container(0) else: #print error message message = str(datetime.datetime.now() ) + "\n" + "BOOLEAN UNION FAIL" History.WriteFile( "C:\R3\OffCenter\Walk\ErrorMessage.dat", message) SaveNClean(defject, polypoints, numb, content2) numb = numb + 1 #MAKING OF THE NEW RIB other_ribs = [] for i in range(len(content) - 1): other_ribs.append(content[i]) for i in range(noribs): rs.Command( "_-Import C:\R3\OffCenter\Walk\Temp\protoslant_walk.igs ENTER") rs.Command("_SelAll") rs.Command("_Join") rs.Command("_SelNone") rs.Command("_SelAll") defject = rs.SelectedObjects(False, False) box2 = rs.AddPolyline([[-5.25, -5.25, 0], [5.25, -5.25, 0], [5.25, 5.25, 0], [-5.25, 5.25, 0], [-5.25, -5.25, 0]]) rs.MoveObject(box2, move_it) line1 = [1, 0, 0] line1 = rs.VectorRotate(line1, i * 360 / (noribs), zaxis) sequence = [1, line1, [0]] polypoints = JointAccess.Outline(sequence[1], sequence[1], sequence[2]) verte = rs.AddPolyline(polypoints) #CHECKING FOR INTERSECTION with any of the already existent ribs #continue continues with the loop without reading the stuff below chck = False for i in range(len(content) - 1): chckpts = JointAccess.Outline(content[i][1], content[i][1], content[i][2]) chckcrv = rs.AddPolyline(chckpts) int = rs.CurveCurveIntersection(verte, chckcrv, 0.000001) if len(int) != 0: chck = True if chck: everything = rs.AllObjects() rs.DeleteObjects(everything) continue intersection = rs.CurveCurveIntersection(verte, box2) if not intersection is None: sequence[0] = 0 rs.DeleteObject(verte) setforbool = [] setforbool.append(defject) setforbool.append( JointAccess.Arm(sequence[1], sequence[1], sequence[2], fc)) for i in range(len(content) - 1): setforbool.append( JointAccess.Arm(content[i][1], content[i][1], content[i][2], fc)) container = rs.BooleanUnion(setforbool) if not container is None: defject = container(0) else: #print error message message = str( datetime.datetime.now()) + "\n" + "BOOLEAN UNION FAIL" History.WriteFile("C:\R3\OffCenter\Walk\ErrorMessage.dat", message) SaveNClean(defject, polypoints, numb, content2) numb = numb + 1 elif npolies > 2 and rs.Distance(startpts[-1], [0, 0, 0]) <= tiny: print "case npolies>2 and one budding not coded yet" else: print "case npolies>2 and none budding" #THE OUTERMOST POINT ROTATES THROUGH THE END POINTS - whatever that means:P """ for k in range(len(content)): #OOOOOOO #OOOOOOO #OOOOOOO #OOOOOOO #G O I N G T H R O U G H L I V I N G R I B S #if RIB IS ALIVE THEN DO WHAT FOLLOWS OTHERWISE THERE IS NOTHING TO LOOK AT #WHAT if ALL DIES??? I WILL WORRY ABOUT IT LATER for i in range(len(noribs)): rs.Command("_-Import C:\R3\OffCenter\Walk\Temp\protoslant_walk.igs ENTER") rs.Command("_SelAll") rs.Command("_Join") rs.Command("_SelNone") rs.Command("_SelAll") defject = rs.SelectedObjects(False,False) box2 = rs.AddPolyline([[-5.25,-5.25,0],[5.25,-5.25,0],[5.25,5.25,0],[-5.25,5.25,0],[-5.25,-5.25,0]]) rs.MoveObject(box2, move_it) pas = 1 con2 = -1 if rs.Distance(endpts[k],[0,0,0]) < tiny: #If we are working with a new rib then we need to set a new beginning. line1 = [1,0,0] line1 = rs.VectorRotate(line1,i*360/(noribs),zaxis) sequence = [1,line1,[0]] #TEST1 - CHECK for LEAVING OFF IN THE SAME DIRECTION pas = 1 for pt in startpts: if rs.Distance(pt,line1)<tiny: pas = 0 #TEST2 - CHECK for OVERLAP WITH OTHER CURVES if pas = 1: for j = 0 To npolies #CAN#T DO INTERSECTION WITH CURVE THAT HASN#T GROWN YET - OUTLINE PRODUCTION if rs.Distance(content(0](j](1],[0,0,0]] > tiny And j<>k Then carrier = content(0](j] con2 = con2 + 1 ReDim Preserve content2(con2] content2(con2] = Outline(carrier(1],carrier(1],carrier(2]] ReDim Preserve vrt(con2] vrt(con2] = rs.PolylineVertices(content2(j]] elif rs.Distance(content(0](j](1],[0,0,0]] < tiny And j=k Then carrier = sequence con2 = con2 + 1 ReDim Preserve content2(con2] content2(con2] = Outline(carrier(1],carrier(1],carrier(2]] ReDim Preserve vrt(con2] vrt(con2] = rs.PolylineVertices(content2(j]] verte = content2 #TEST3 - CHECK for OVERLAP WITH THE BORDER - OVERLAP = KILL intersection = rs.CurveCurveIntersection(verte(k],box2] if intersection not is None: sequence(0] = 0 for j = 0 To npolies if j <> k Then intersection = rs.CurveCurveIntersection(verte(k],verte(j]] if Not isNull(intersection] Then rs.DeleteObjects(verte] pass = 0 Exit for rs.DeleteObjects(verte] #STEP 4 - PRINT THE ARMS AND BOOLEAN THE HELL OUT OF THEM SAVE THEM ETC if pass = 1 Then for j = 0 To npolies if j <> k Then content2(j] = content(0](j] Else content2(k] = sequence End if Next ReDim setforbool(npolies+1] setforbool(0] = defject for j = 0 To npolies setforbool(j+1] = Arm(content2(j](1],content2(j](1],content2(j](2]] Next #BOOLEAN THINGS UP container = rs.BooleanUnion(setforbool] if Not IsNull(container] Then defject = container(0] End if SaveNClean(defject,vrt,numb,k,content2] numb = numb + 1 Else objects = rs.AllObjects(] rs.DeleteObjects(objects] End if Else if i <> 0 Then #STEP0 - MAKE A NEW RIB line1 = i size2 = UBound(content(0](k](2]] ReDim crack(size2+1] for j = 0 To size2-1 crack(j] = content(0](k](2](j] Next crack(size2] = line1 crack(size2+1] = 0 sequence = [content(0](k](0],content(0](k](1],crack] #TEST1 - CHECK for LEAVING OFF IN THE SAME DIRECTION #DROPPED if pass = 1 Then for j = 0 To npolies #CAN#T DO INTERSECTION WITH CURVE THAT HASN#T GROWN YET - OUTLINE PRODUCTION if rs.Distance(content(0](j](1],[0,0,0]] > tiny Then carrier = sequence con2 = con2 + 1 ReDim Preserve content2(con2] content2(con2] = Outline(carrier(1],carrier(1],carrier(2]] ReDim Preserve vrt(con2] vrt(con2] = rs.PolylineVertices(content2(j]] End if Next verte = content2 #TEST3 - CHECK for OVERLAP WITH THE BORDER - OVERLAP = KILL intersection = rs.CurveCurveIntersection(verte(k],box2] if Not isNull(intersection] Then sequence(0] = 0 End if #TEST2 - CHECK for OVERLAP WITH OTHER CURVES for j = 0 To con2 if j <> k Then intersection = rs.CurveCurveIntersection(verte(k],verte(j]] if Not isNull(intersection] Then pas = 0 Exit for End if End if Next rs.DeleteObjects(verte] End if #STEP 4 - PRINT THE ARMS AND BOOLEAN THE HELL OUT OF THEM SAVE THEM ETC if pass = 1 Then for j = 0 To con2 #[0,0,0] can only happen in the last poly if j <> k Then content2(j] = content(0](j] Else content2(k] = sequence End if Next ReDim setforbool(con2+1] setforbool[0] = defject for j = 0 To con2 setforbool[j+1] = Arm(content2[j][1],content2[j][1],content2[j][2]) container = rs.BooleanUnion(setforbool) if container not is None: defject = container(0) SaveNClean(defject,vrt,numb,k,content2) numb = numb + 1 else: objects = rs.AllObjects(] rs.DeleteObjects(objects] """ ## ######################################################################## #making a text file that will be read by python to decide how many iterations to run on testing ######################################################################## History.WriteFile(tempfolder, str(numb)) ######################################################################## ## #DONE History.WriteFile(tempfolder + "OutputNo.txt", str(numb)) #SET UP A CLEAN EXIT rs.Command("-saveas C:\\R3\OffCenter\Walk\Temp\rubbish.3dm")
def trim_boundary(e_crvs, cb_crvs, tol, inside=True): """input: e_crvs: etch curves to be trimmed cb_crvs: closed boundary curves tol: tolerance. document tolerance recommended inside=True: trim the inside if true, trim outside if false returns the trimmed curves. NOTE: assumes redraw is turned off. assumes curves are planar. future versions to use projection method to avoid these assumptions.""" #remove non-crv inputs e_crvs = [x for x in e_crvs if rs.ObjectType(x) == 4] cb_crvs = [x for x in cb_crvs if rs.ObjectType(x) == 4] #split curves split_crvs = [] for e in e_crvs: intersection_list = [] for c in cb_crvs: ccx_out = rs.CurveCurveIntersection(e, c, tol) if ccx_out is None: continue params = [x[5] for x in ccx_out if x[0] == 1 ] #if pt intersection type; get param on etch crv intersection_list.extend(params) if intersection_list: split_crvs.extend(rs.SplitCurve(e, intersection_list)) #append non-split curves no_split = [] for e in e_crvs: id = sc.doc.Objects.Find(e) if id != None: no_split.append(e) split_crvs.extend(no_split) #rs.ObjectLayer(split_crvs,"XXX_LCUT_02-SCORE") #build regions for boundary test srfs = rs.AddPlanarSrf(cb_crvs) line = rs.AddLine([0, 0, -5], [0, 0, 5]) rs.MoveObjects(srfs, [0, 0, -5]) vols = [] for srf in srfs: ext = rs.ExtrudeSurface(srf, line, True) if ext != None: vols.append(ext) rs.DeleteObjects(srfs) rs.DeleteObject(line) #categorize inside/outside curves keep_crvs = [] delete_crvs = [] for c in split_crvs: if inside == True: keep_crvs.append(c) if not multi_test_in_or_out( c, vols) else delete_crvs.append(c) else: keep_crvs.append(c) if multi_test_in_or_out( c, vols) else delete_crvs.append(c) #rs.ObjectLayer(keep_crvs,"XXX_LCUT_04-ENGRAVE") rs.DeleteObjects(vols) rs.DeleteObjects(delete_crvs) return keep_crvs