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
