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