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 Cremona2(no, nomes, Linhas, countPF, dicPF):
ptos1 = []
dicUp = {}
for i in range(countPF):
if i == 0:
Spt = dicPF[nomes[i]].PointAt(0)
Ept = dicPF[nomes[i]].PointAt(1)
else:
if i == 1:
cond1 = rs.PointCompare(dicPF[nomes[i - 1]].PointAt(0),
dicPF[nomes[i]].PointAt(1), Tol)
cond2 = rs.PointCompare(dicPF[nomes[i - 1]].PointAt(0),
dicPF[nomes[i]].PointAt(0), Tol)
if cond1 or cond2:
pAux3 = Spt
Spt = Ept
Ept = pAux3
if rs.PointCompare(Ept, dicPF[nomes[i]].PointAt(1), Tol):
ptAux1 = dicPF[nomes[i]].PointAt(1)
ptAux2 = dicPF[nomes[i]].PointAt(0)
else:
ptAux1 = dicPF[nomes[i]].PointAt(0)
ptAux2 = dicPF[nomes[i]].PointAt(1)
Ept += (ptAux2 - ptAux1)
vAux1 = Line(rs.CurveStartPoint(Linhas[-2]), Ept)
vAux2 = Line(rs.CurveStartPoint(Linhas[-1]), Spt)
F1 = gh.Move(rs.coerceline(Linhas[-2]), vAux1)[0]
F2 = gh.Move(rs.coerceline(Linhas[-1]), vAux2)[0]
inter = gh.LineXLine(F1, F2)[2]
F1 = rs.AddLine(Ept, inter)
F2 = rs.AddLine(inter, Spt)
dicUp[nomes[-2]] = rs.coerceline(F1)
dicUp[nomes[-1]] = rs.coerceline(F2)
#-cargas e nomenclatura
#teste de tração e compressão
sin1 = TraComp(no, F1, rs.coerceline(Linhas[-2]), nomes[-2])
sin2 = TraComp(no, F2, rs.coerceline(Linhas[-1]), nomes[-1])
#valores das cargas
carga1 = rs.CurveLength(F1) * sin1 / Escala
carga2 = rs.CurveLength(F2) * sin2 / Escala
#teste de tensão admissivel
cor1 = teste_elemento(nomes[-2], carga1, Linhas[-2])
cor2 = teste_elemento(nomes[-1], carga2, Linhas[-1])
#nomenclatura do FG
txt1 = nomes[-2] + ' = ' + str('%.2f' % carga1)
txt2 = nomes[-1] + ' = ' + str('%.2f' % carga2)
pt1 = rs.coerceline(Linhas[-2]).PointAt(.5)
pt2 = rs.coerceline(Linhas[-1]).PointAt(.5)
ptos1 += [pt1, txt1, cor1]
ptos1 += [pt2, txt2, cor2]
#nimenclatura do PF
pt1 = rs.coerceline(F1).PointAt(.5)
pt2 = rs.coerceline(F2).PointAt(.5)
txt1 = nomes[-2]
txt2 = nomes[-1]
ptos1 += [pt1, txt1, cor1]
ptos1 += [pt2, txt2, cor2]
return dicUp, ptos1
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 dimension_boundingBox(part):
"""returns a tuple with the height and width of bounding box"""
boundingBox = set_partAligned_boundingBox(part)
lineHeight = rs.AddLine(boundingBox[0], boundingBox[1])
lineWidth = rs.AddLine(boundingBox[0], boundingBox[3])
partHeight = rs.CurveLength(lineHeight)
partWidth = rs.CurveLength(lineWidth)
dimensions = (partHeight, partWidth)
return dimensions
def mergeLR(self, Llist, Rlist):
assert (len(Llist) == len(Rlist))
mergedList = []
for i in range(len(Llist)):
if rs.CurveLength(Llist[i]) >= rs.CurveLength(Rlist[i]):
mergedList.append(rs.CopyObject(Llist[i]))
else:
mergedList.append(rs.CopyObject(Rlist[i]))
return mergedList
def 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 get_adjust(self):# 曲線の長さ調整の仕方を返却 if self.mode == "extend":# 長い方に揃える if rs.CurveLength(self.crvs[self.ind_o]) >= rs.CurveLength(self.crvs[self.ind_x]): pattern = 1 else: pattern = 2 else:# 短い方に揃える if rs.CurveLength(self.crvs[self.ind_o]) >= rs.CurveLength(self.crvs[self.ind_x]): pattern = 3 else: pattern = 4 return pattern
def iterativeshortencurve():
curve_id = rs.GetObject("Open curve to smooth", 4, True)
if curve_id is None or rs.IsCurveClosed(curve_id): return
min = rs.Distance(rs.CurveStartPoint(curve_id), rs.CurveEndPoint(curve_id))
max = rs.CurveLength(curve_id)
goal = rs.GetReal("Goal length", 0.5 * (min + max), min, max)
if goal is None: return
while rs.CurveLength(curve_id) > goal:
rs.EnableRedraw(False)
curve_id = smoothcurve(curve_id, 0.1)
rs.EnableRedraw(True)
if curve_id is None: break
def weave(self, firstcurve, secondcurve, pointcount):
e = rs.CurveLength(firstcurve)
f = rs.CurveLength(secondcurve)
p1 = rs.DivideCurveEquidistant(firstcurve, e / pointcount, True, True)
p2 = rs.DivideCurveEquidistant(secondcurve, f / pointcount, True, True)
points = []
for i in range(len(p1)):
points.append(p1[i])
points.append(p2[i])
for p in points:
self.goto(p[0], p[1], p[2])
def BSearchCurve(idCrv, Length, Tolerance):
Lcrv = rs.CurveLength(idCrv)
if Lcrv < Length: return
tmin = rs.CurveDomain(idCrv)[0]
tmax = rs.CurveDomain(idCrv)[1]
t0 = tmin
t1 = tmax
while True:
t = 0.5 * (t1 + t0)
Ltmp = rs.CurveLength(idCrv, 0, [tmin, t])
if abs(Ltmp - Length) < Tolerance: return t
if Ltmp < Length: t0 = t
else: t1 = t
def TotalLengthOfFractures(self, fracture_guid_list, cut_plane):
"""
Function to intersect fractures and return the total length of
fractures in the cut plane
Parameters
----------
fracture_guid_list: list
list containing domain fractures' guids
cut_plane: guid
guid of the cut plane
"""
# initialise length as 0
length = 0
# convert plane to a surface
plane_surf = rs.AddPlanarSrf(cut_plane)
# loop through the fractures' GUIDs
for i in range(len(fracture_guid_list)):
# perform intersection test
intersection = rs.IntersectBreps(fracture_guid_list[i], plane_surf)
# if there is intersection
if intersection is not None:
# go through the list
for x in intersection:
# check it's a line!
if rs.IsLine(intersection[0]):
# add the GUID to class attribute
# 'intersecting_fractures'
self.intersecting_fractures.append(intersection[0])
# increment the length of intersecting fractures
length += rs.CurveLength(intersection[0])
# delete the plane surface we added to Rhino interface
rs.DeleteObject(plane_surf)
# return the lotal lengths of intersection
return length
def teste_elemento(nome, carga, fglin):
#banzo ou diagonal
if nome[0] == 'b':
bd = 0
else:
bd = 1
# se tracionado
if carga >= 0:
if abs(carga) < F_adm[bd]:
#print nome + 'compressão ok'
return corpass
else:
print nome + ' Falhou na tração'
return corfail
#se comprimido
elif carga < 0:
len1 = rs.CurveLength(fglin)
rGira = (Areas[1][bd] / Areas[0][bd])**0.5
esbelt = len1 / rGira
if esbelt >= esb_min:
T_comp = (3.14**2 * Mod_E) / (esbelt**2 * coe_Comp)
#print nome + ' Formula de Euler'
else:
T_comp = (17000 - 0.485 * (esbelt**2)) * 6894.745
#print nome + ' Formula do A.I.S.C.'
if (abs(carga) / Areas[0][bd] < T_comp) and (abs(carga) < F_adm[bd]):
return corpass
else:
print nome + ' Falhou na compressão'
return corfail
def Sierpinsky_triangle(triangle):
if rs.CurveLength(triangle[0]) < smallestCurve:
return
else:
#make left triangle
line1 = rs.AddLine(rs.CurveStartPoint(triangle[0]),
rs.CurveMidPoint(triangle[0]))
line2 = rs.AddLine(rs.CurveMidPoint(triangle[0]),
rs.CurveMidPoint(triangle[2]))
line3 = rs.AddLine(rs.CurveMidPoint(triangle[2]),
rs.CurveStartPoint(triangle[0]))
#make right triangle
line4 = rs.AddLine(rs.CurveMidPoint(triangle[0]),
rs.CurveEndPoint(triangle[0]))
line5 = rs.AddLine(rs.CurveEndPoint(triangle[0]),
rs.CurveMidPoint(triangle[1]))
line6 = rs.AddLine(rs.CurveMidPoint(triangle[1]),
rs.CurveMidPoint(triangle[0]))
#make top triangle
line7 = rs.AddLine(rs.CurveMidPoint(triangle[2]),
rs.CurveMidPoint(triangle[1]))
line8 = rs.AddLine(rs.CurveMidPoint(triangle[1]),
rs.CurveEndPoint(triangle[1]))
line9 = rs.AddLine(rs.CurveStartPoint(triangle[2]),
rs.CurveMidPoint(triangle[2]))
#recurse
Sierpinsky_triangle([line1, line2, line3])
Sierpinsky_triangle([line4, line5, line6])
Sierpinsky_triangle([line7, line8, line9])
def Rectify_AngleFirst(obj, angleMultiple, lengthMultiple):
"""
Rebuilds a polyline with exact angles and lengths. Angles have priority
input:
obj (polyline)
angleMultiple (float): Multiple to round to
lengthMultiple (float): Length to round to (0 == no rounding)
returns:
polyline (guid)
"""
angles = GetCornerAngles(obj)
if angleMultiple != 0:
fixedAngles = ForceToMultipleOf(angles, angleMultiple)
else:
fixedAngles = angles
if rs.IsLine(obj):
lengths = [rs.CurveLength(obj)]
fixedAngles = 0
else:
lengths = GetSegmentLengths(obj)
if lengthMultiple != 0:
fixedLengths = ForceToMultipleOf(lengths, lengthMultiple)
else:
fixedLengths = lengths
if rs.IsLine(obj):
line = ChangeLineLength(obj, fixedLengths)
id = sc.doc.Objects.AddLine(line)
else:
newPline = ChangeVertexAngles(obj, fixedAngles, fixedLengths)
id = sc.doc.Objects.AddPolyline(newPline)
sc.doc.Views.Redraw()
return id
def vector_sum(lines, preview=False):
vector_list = []
total_time = 0
total_length = 0
last_feed = 0
for i in range(len(lines)):
point_a = lines[i][:3]
if i == len(lines) - 1: break
point_b = lines[i + 1][:3]
vector = rs.AddLine(point_a, point_b) if preview else rs.VectorCreate(
point_a, point_b)
if preview:
rs.ObjectLayer(vector, LAYER_NAME)
rs.ObjectColor(vector, color_palette["cut"])
vector_list.append(vector)
if len(lines[i]) == 4:
feed = lines[i][-1]
last_feed = feed
vector_length = rs.CurveLength(vector) if preview else rs.VectorLength(
vector)
total_length += vector_length
total_time += (vector_length) / last_feed
return vector_list, round(total_time, 2), round(total_length, 2)
def getRoadCurve(key1, key2, trans_path, road_dict, insert_road_dict):
# 根据路径结点序号得到一条路径线段
curve_lst = []
direction = False # 合并后线的方向, true代表和第一段线同向
#trans_path = ([9, 0, 70, 79, 91, 77, 8, 60, 56, 58, 47, 43, 29, 61, 50, 54, 78, 81, 80], 3660.0)
if trans_path[1] == 0:
return curve_lst
curve_lst.append(insert_road_dict[key1])
n = len(trans_path[0])
for i in range(n - 1):
node, next = trans_path[0][i], trans_path[0][i + 1]
s1, s2 = str(node) + ',' + str(next), str(next) + ',' + str(node)
cur = road_dict[s1] if s1 in road_dict else road_dict[
s2] # 0->9 or 9->0
#print(cur)
curve_lst.append(cur)
curve_lst.append(insert_road_dict[key2])
num = len(curve_lst)
if num:
if num == 1:
return curve_lst[0]
join_curve = rs.JoinCurves(curve_lst)
length = rs.CurveLength(join_curve)
if rs.CurveTangent(join_curve, 0) == rs.CurveTangent(curve_lst[0], 0):
direction = True
return join_curve, direction
#print(length)
#t = 0.5
#pt = rs.CurveArcLengthPoint(join_curve, t*length)
else:
return
def howManyBricksCanWeMake(index):
#don't like the name of this method? deal with it
curvelen = rs.CurveLength(ContourCurves[index])
return [
math.ceil(curvelen / (BrickWidth + GapDomain[0])),
math.floor(curvelen / (BrickWidth + GapDomain[1]))
]
def Intersect(self, other):
"""
function to check if a fracture intersects another
Parameter
-------
other: guid
guid of the second fracture
"""
# inputs are frcature instances in fracture list
curveA = self.fracture_GUID
# check for intersection
intersection = rs.IntersectBreps(curveA, other.fracture_GUID)
# if no intersection
if intersection is None:
print('The fractures do not intersect')
else:
# go through the list of intersection
for x in intersection:
# check it's a line!
if rs.IsLine(intersection[0]):
# get intersection length
length = rs.CurveLength(intersection[0])
# print a statement
print(
'Fracture intersect, the length of intersection\
is:', length)
def getExtendedCrv(self, crvList, dist=50, layer_height=2.5, vecMul=.66):
segmentCount = int(math.floor(dist / layer_height)) - 1
tmpList = []
fullHeight = []
for i in range(len(crvList)):
extendedCrv = rs.ExtendCurveLength(crvList[i], 2, 0, dist)
fullHeight.append(extendedCrv)
domStart, domEnd = rs.CurveDomain(extendedCrv)
trimmedCrv = rs.TrimCurve(extendedCrv, (domStart, 0))
tmpList.append(trimmedCrv)
tmp = []
###Smooth Curves###
for i in range(len(tmpList)):
bottomPt = rs.CurveEndPoint(tmpList[i])
zVec = rs.VectorAdd((0, 0, 0), (0, 0, dist))
topPt = rs.CopyObject(bottomPt, zVec)
line = rs.AddLine(bottomPt, topPt)
crvPts = rs.DivideCurve(tmpList[i], segmentCount)
LinePts = rs.DivideCurve(line, segmentCount)
for i in range(segmentCount):
tmpVec = rs.VectorCreate(LinePts[segmentCount - i - 1],
crvPts[i])
tmpVec = rs.VectorScale(tmpVec, vecMul)
rs.MoveObject(crvPts[i], tmpVec)
tmp.append(rs.AddInterpCurve(crvPts))
result = []
for crv in tmp:
crvLen = rs.CurveLength(crv)
if crvLen < dist:
tmpExt = dist - crvLen
result.append(rs.ExtendCurveLength(crv, 2, 0, tmpExt))
else:
result.append(rs.CopyObject(crv))
return result
def fitcurvetolength():
curve_id = rs.GetObject("Select a curve to fit to Length", rs.filter.curve, True, True)
if curve_id is None:return
length = rs.CurveLength(curve_id)
length_limit = rs.GetReal("Length limit", 0.5*length, 0.01*length, length)
if length_limit is None:return
while True:
if rs.CurveLength(curve_id)<=length_limit:break
curve_id = rs.ScaleObject(curve_id, (0,0,0), (0.95,0.95,0.95))
if curve_id is None:
print "Something went wrong"
return
print "New curve length: ", rs.CurveLength(curve_id)
def _left_over_space(self, curve_id):
'''
compute the remaning space that will result
from segmenting the given curve with self.spacing chunks.
'''
length = rs.CurveLength(curve_id)
extra = length - int(length / self.spacing) * self.spacing
return extra
def getDiv(srf, dist, uv, eq):
domaincrv = rs.ExtractIsoCurve(srf, [0, 0], uv)
crvLen = rs.CurveLength(domaincrv)
newdist = setDist(crvLen, dist, eq)
pts = rs.DivideCurveLength(domaincrv, newdist)
pts.pop(0)
pts.pop(-1)
rs.DeleteObject(domaincrv)
return pts
def __init__(self, Rect, deltaHeight, numRisers, thickness, runNum,
maxTread):
self.Rect = Rect
self.segments = rs.ExplodeCurves(self.Rect)
self.deltaHeight = deltaHeight
self.numRisers = int(numRisers)
self.thickness = thickness
self.riserHeight = self.deltaHeight / self.numRisers
self.firstRiserEdge = self.segments[0]
self.runLongEdge = self.segments[1]
self.treadLength = rs.CurveLength(self.runLongEdge) / self.numRisers
self.maxTread = maxTread
if self.treadLength > self.maxTread:
self.treadLength = self.maxTread
self.runNum = runNum + 1
self.stairWidth = rs.CurveLength(self.segments[0])
self.extenionLength = rs.CurveLength(
self.runLongEdge) - (self.treadLength * self.numRisers)
def length(self): """Return the length of the curve. Returns ------- float The curve's length. """ return rs.CurveLength(self.guid)
def divEQCrvToPolyAD(crv,w=900,adjacentCrvs=None):
outpoly=PolyAD()
crvLen=rs.CurveLength(crv)
numDiv=crvLen/w
width=crvLen/round(numDiv)
pts=rs.DivideCurve(crv,numDiv,False,True)
#add to output
outpoly.points=pts
sharedNormals=[None,None]
if adjacentCrvs is not None:
sharedNormals=findSharedbisecNormals(crv,adjacentCrvs)
for i in range(0,len(pts)-2):
up=(0,0,1)
# direct direct_end
# (p0)-v1->(p1)-v2->(p2)
# |n_start |n |n_end
# V V V
p0=pts[i]
p1=pts[i+1]
p2=pts[i+2]
v1=rs.VectorUnitize(p1-p0)
v2=rs.VectorUnitize(p2-p1)
n1=rs.VectorCrossProduct(v1,up)
n2=rs.VectorCrossProduct(v2,up)
mid=rs.VectorAdd(n1,n2)
n=rs.VectorUnitize(mid)
direct=p1-p0
#add to output
outpoly.directions.append(direct)
if i==0:
if sharedNormals[0] is not None: n_start=sharedNormals[0]
else: n_start=rs.VectorCrossProduct(v1,up)
outpoly.normals.append(n_start)
#add to output
outpoly.normals.append(n)
if i==len(pts)-3:
if sharedNormals[1] is not None: n_end=sharedNormals[1]
else: n_end=rs.VectorCrossProduct(v2,up)
outpoly.normals.append(n_end)
direct_end=p2-p1
outpoly.directions.append(direct_end)
return outpoly
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 ColorBySize():
try:
objs = rs.GetObjects("Select objects to color",
1073815613,
preselect=True)
if objs is None: return
print "Select First Color"
firstColor = rs.GetColor()
if firstColor is None: return
print "Select Second Color"
secondColor = rs.GetColor(firstColor)
if secondColor is None: return
rs.EnableRedraw(False)
colorLine = rs.AddLine(firstColor, secondColor)
areas = []
for obj in objs:
if rs.IsCurve(obj):
if rs.IsCurveClosed(obj):
areas.append(rs.CurveArea(obj)[0])
else:
areas.append(rs.CurveLength(obj))
elif rs.IsSurface(obj):
areas.append(rs.SurfaceArea(obj)[0])
elif rs.IsPolysurface(obj):
if rs.IsPolysurfaceClosed(obj):
areas.append(rs.SurfaceVolume(obj)[0])
elif rs.IsHatch(obj):
areas.append(rs.Area(obj))
else:
print "Only curves, hatches, and surfaces supported"
return
newAreas = list(areas)
objAreas = zip(newAreas, objs)
objAreas.sort()
objSorted = [objs for newAreas, objs in objAreas]
areas.sort()
normalParams = utils.RemapList(areas, 0, 1)
colors = []
for t in normalParams:
param = rs.CurveParameter(colorLine, t)
colors.append(rs.EvaluateCurve(colorLine, param))
for i, obj in enumerate(objSorted):
rs.ObjectColor(obj, (colors[i].X, colors[i].Y, colors[i].Z))
rs.DeleteObject(colorLine)
rs.EnableRedraw(True)
return True
except:
return False
def weaverandom(self, firstcurve, secondcurve, pointcount):
e = rs.CurveLength(firstcurve)
f = rs.CurveLength(secondcurve)
p1 = rs.DivideCurveEquidistant(firstcurve, e / pointcount, True, True)
p2 = rs.DivideCurveEquidistant(secondcurve, f / pointcount, True, True)
points = []
for i in range(len(p1)):
a = random.randint(0, pointcount - 1)
b = random.randint(0, pointcount - 1)
points.append(p1[a])
points.append(p2[b])
for p in points:
l = self.goto(p[0], p[1], p[2])
clength = rs.CurveLength(l)
if clength > e / 2:
rs.DeleteObject(l)
def scalecurve():
curve_id = rs.GetObject("pick curve", 4)
# provide breakout bc idk
if curve_id is None:
return
length = rs.CurveLength(curve_id)
print "current length: %g " % length
length_max = rs.GetReal("max length? ", .5 * length, .1 * length,
10 * length) # you can set ranges!
if length_max is None:
return
while length < length_max:
curve_id = rs.ScaleObject(curve_id, (0, 0, 0), (1.5, 1.5, 1.5), True)
length = rs.CurveLength(curve_id)
print "new curve length: %g" % rs.CurveLength(curve_id)
def get_curve_from_segments(self, lines):
curves = rs.JoinCurves(lines)
index = 0
length = 0
for i in range(0, len(curves)):
new_length = rs.CurveLength(curves[i])
if (new_length > length):
index = i
length = new_length
return curves[index]
