def ConvertToUVW(srf_id, xyz_points):
uvw_points = []
for point in xyz_points:
Suv = rs.SurfaceClosestPoint(srf_id, point)
Sxyz = rs.EvaluateSurface(srf_id, Suv)
Snormal = rs.SurfaceNormal(srf_id, Suv)
dirPos = rs.PointAdd(Sxyz, Snormal)
dirNeg = rs.PointSubtract(Sxyz, Snormal)
Sdist = rs.Distance(Sxyz, point)
if rs.Distance(point, dirPos) > rs.Distance(point, dirNeg):
Sdist = -Sdist
uvw_points.append((Suv(0), Suv(1), Sdist))
return uvw_points
def get_derivation_cell_position_triples(cls, n_shapes):## 09-21 17:52
"""Receives:
n_shapes int >= 2. The number of labeled shapes in the
derivation
Calculates the positions of labeled shapes, arrows, and rule names
arranged in an array. Returns:
derivation_cell_position_triples
[(triple)]. A list of n triples, n = n_shapes,
each of the form:
( labeled_shape_position,
arrow_position,
rule_name_position)
where each position is a triple of the form:
(num, num, num)
"""
labeled_shape_offset = cls.derivation_labeled_shape_offset
arrow_offset = cls.derivation_arrow_offset
rule_name_offset = cls.derivation_rule_name_offset
cell_positions = (cls._get_derivation_array_cell_positions(n_shapes))
derivation_cell_position_triples = []
for i in range(n_shapes):
derivation_array_cell_position = (
cell_positions[i])
labeled_shape_position = rs.PointAdd(
derivation_array_cell_position,
labeled_shape_offset)
arrow_position = rs.PointAdd(
derivation_array_cell_position,
arrow_offset)
rule_name_position = rs.PointAdd(
derivation_array_cell_position,
rule_name_offset)
position_triple = (
labeled_shape_position,
arrow_position,
rule_name_position)
derivation_cell_position_triples.append(position_triple)
return derivation_cell_position_triples
def _add_3_frame_layer(cls, layer_name, rule_spec, left_frame_position):
"""Receives:
layer_name str
left_frame_position
Point3d. The location of the leftmost frame
instance
Draws 3 frame instances on the specified layer
"""
cls._add_subsequent_rule(layer_name, rule_spec, left_frame_position)
frame_name = s.Settings.frame_name
right_frame_offset = (100, 0, 0)
right_frame_position = rs.PointAdd(left_frame_position,
right_frame_offset)
f.Frame.new_instance(frame_name, layer_name, right_frame_position)
def add_tickmarks(rect, len, offset):
c, _ = rs.CurveAreaCentroid(rect)
mirror_v = [c, rs.PointAdd(c, [0, 10, 0])]
mirror_h = [c, rs.PointAdd(c, [10, 0, 0])]
pts = rs.CurvePoints(rect)
if not pts:
return "ERROR"
pts = rs.SortPoints(pts)
# print pts
t_0 = rs.CopyObject(pts[0], [offset, offset, 0])
t_1 = rs.CopyObject(t_0, [len, 0, 0])
t_2 = rs.CopyObject(t_0, [0, len, 0])
tick = rs.AddPolyline([t_1, t_0, t_2])
rs.DeleteObjects([t_0, t_1, t_2])
tick_2 = rs.MirrorObject(tick, mirror_v[0], mirror_v[1], True)
ticks_3 = rs.MirrorObjects([tick, tick_2], mirror_h[0], mirror_h[1], True)
rs.ObjectLayer([tick, tick_2] + ticks_3, LCUT_NAMES[3])
tick_list = [tick, tick_2] + ticks_3
return tick_list
def XYZ_To_UVW(srf_id, pXYZ):
pUVW = []
for pt in pXYZ:
uvClosest = rs.SurfaceClosestPoint(srf_id, pt)
ptClosest = rs.EvaluateSurface(srf_id, uvClosest)
srfNormal = rs.SurfaceNormal(srf_id, uvClosest)
pPositive = rs.PointAdd(ptClosest, srfNormal)
pNegative = rs.PointSubtract(ptClosest, srfNormal)
fDistance = rs.Distance(ptClosest, pt)
if rs.Distance(pt, pPositive) > rs.Distance(pt, pNegative):
fDistance = -fDistance
pUVW.append((uvClosest[0], uvClosest[1], fDistance))
return pUVW
def spiral_stairs(curve, center, start_pt, end_pt, stair_width, steps,
plinth_lst, bannister_lst):
height = end_pt[2] - start_pt[2]
cen = rs.AddLine(center, rs.PointAdd(center, [0, 0, height]))
cen_e = rs.CurveEndPoint(cen)
ref_pts = [n * 1 / steps for n in range(steps + 1)]
outer_pts = [rs.EvaluateCurve(curve, t) for t in ref_pts]
inner_pts = [[cen_e[0], cen_e[1], cen_e[2] * t] for t in ref_pts]
print(inner_pts)
rise = [0, 0, height / steps]
for i in range(steps):
#draw rise
v_ver = [
outer_pts[i], inner_pts[i],
rs.PointAdd(inner_pts[i], rise),
rs.PointAdd(outer_pts[i], rise)
]
rs.AddSrfPt(v_ver)
#draw run
v_hori = [v_ver[3], v_ver[2], outer_pts[i + 1]]
rs.AddSrfPt(v_hori)
#draw sides
s1 = rs.AddLine(outer_pts[i], rs.PointAdd(outer_pts[i], rise))
s2 = rs.AddLine(rs.PointAdd(outer_pts[i], rise), outer_pts[i + 1])
s3 = rs.AddSubCrv(curve, rs.CurveClosestPoint(curve, outer_pts[i]),
rs.CurveClosestPoint(curve, outer_pts[i + 1]))
rs.AddEdgeSrf([s1, s2, s3])
rs.DeleteObjects([s1, s2, s3])
if plinth_lst[0]:
curvy_plinth(curve, None, stair_width, plinth_lst)
if bannister_lst[0]:
curvy_bannister(curve, None, stair_width, bannister_lst)
def meshLoftSections(sections, closed=True):
faces = []
v = []
for i in range(len(sections)):
v.extend(sections[i])
for i in range(len(sections) - 1):
for j in range(len(sections[0]) - 1):
index0 = i * len(sections[0]) + j
index1 = i * len(sections[0]) + (j + 1) % len(sections)
index2 = (i + 1) * len(sections[0]) + (j + 1) % len(sections)
index3 = (i + 1) * len(sections[0]) + j
faces.append([index0, index1, index2, index3])
if closed:
st_cnt, en_cnt = [0, 0, 0], [0, 0, 0]
for i in range(len(sections[0])):
st_cnt = rs.PointAdd(st_cnt, sections[0][i])
en_cnt = rs.PointAdd(en_cnt, sections[-1][i])
st_cnt = rs.VectorScale(st_cnt, 1 / len(sections[0]))
en_cnt = rs.VectorScale(en_cnt, 1 / len(sections[0]))
init = 0
v.append(st_cnt)
for j in range(len(sections[0]) - 1):
index0 = init + j
index1 = len(v) - 1
index2 = init + (j + 1) % (len(sections[0]) - 1)
index3 = init + j
faces.append([index0, index1, index2])
#init = len(sections)*(len(sections[0])-1) + 1
init = len(v) - 1 - len(sections[0])
v.append(en_cnt)
for j in range(len(sections[0]) - 1):
index0 = init + j
index1 = len(v) - 1
index2 = init + j + 1
index3 = init + j
faces.append([index0, index1, index2])
mesh = rs.AddMesh(v, faces)
def offsetPoints(pList, startPt, endPt):
pointList = []
sideVector = rs.VectorCreate(endPt, startPt)
pointSpacing = (rs.VectorLength(sideVector) / len(pList))
gapVector = rs.VectorUnitize(sideVector)
gapVector = rs.VectorScale(gapVector, pointSpacing)
for i in range(0, len(pList)):
scaledVector = rs.VectorScale(gapVector, i)
pointMove = rs.VectorAdd(startPt, scaledVector)
offsetPoint = rs.VectorAdd(pointMove,
pList[i] * rs.VectorLength(sideVector))
point = (0, 0, 0)
movedPoint = rs.PointAdd(point, offsetPoint)
pointList.append(movedPoint)
return pointList
def get_arrow_position(cls, left_frame_position): ## rule arrow
"""Receives:
left_frame_position
Point3d or (num, num, num). The position of the
left frame instance
Returns:
arrow_position Point3d. The center point of the arrow
"""
frame_gap_factor_x = (cls.right_frame_offset_factor - 1) / 2
arrow_offset_x = cls.frame_size[0] * (frame_gap_factor_x + 1)
arrow_offset_y = cls.frame_size[1] / 2
arrow_offset_z = 0
arrow_offset = (arrow_offset_x, arrow_offset_y, arrow_offset_z)
arrow_position = rs.PointAdd(left_frame_position, arrow_offset)
return arrow_position
def smoothcurve(curve_id, s):
curve_points = rs.CurvePoints(curve_id)
new_curve_points = []
for i in range(len(curve_points) - 1):
vm = smoothingvector(curve_points[i], curve_points[i - 1],
curve_points[i + 1], s)
new_curve_points.append(rs.PointAdd(curve_points[i], vm))
knots = rs.CurveKnots(curve_id)
degree = rs.CurveDegree(curve_id)
weights = rs.CurveWeights(curve_id, 0)
newcurve_id = rs.AddNurbsCurve(new_curve_points, knots, degree, weights)
if newcurve_id: rs.DeleteObject(curve_id)
return newcurve_id
def get_right_frame_position(cls, left_frame_position):
"""Receives:
left_frame_position
Point3d or (num, num, num). The origin of the left
frame block
Returns:
right_frame_position
Point3d. The origin of the right frame block
"""
frame_side_x = cls.frame_size[0]
right_frame_offset_x = (
frame_side_x * cls.right_frame_offset_factor)
right_frame_offset = (right_frame_offset_x, 0, 0)
right_frame_position = rs.PointAdd(
left_frame_position, right_frame_offset)
return right_frame_position
def nameTag(obj):
roomName = rs.ObjectName(obj)
try:
text = str(roomName)
pt0 = rs.BoundingBox(obj)[0]
pt2 = rs.BoundingBox(obj)[2]
pt = rs.PointDivide(rs.PointAdd(pt0, pt2), 2)
areaTag = rs.AddText(text, pt, 1, justification=131074)
except:
print "Object has no name"
return
parentLayer = rs.ParentLayer(rs.ObjectLayer(obj))
hostLayer = rs.AddLayer("ANNO_NAME", (128, 128, 128), parent=parentLayer)
rs.ObjectLayer(areaTag, hostLayer)
return None
def addArc(startPt, endPt, vecDir):
vecBase = rs.PointSubtract(endPt, startPt)
if rs.VectorLength(vecBase) == 0.0:
return
if rs.IsVectorParallelTo(vecBase, vecDir):
return
vecBase = rs.VectorUnitize(vecBase)
vecDir = rs.VectorUnitize(vecDir)
vecBisector = rs.VectorAdd(vecDir, vecBase)
vecBisector = rs.VectorUnitize(vecBisector)
midlength = (0.5*rs.Distance(startPt, endPt)) / (rs.VectorDotProduct(vecBisector, vecDir))
vecBisector = rs.VectorScale(vecBisector, midlength)
return rs.AddArc3Pt(startPt, endPt, rs.PointAdd(startPt, vecBisector))
def isometricflow(polyline=None, t=0.1):
polyline = polyline or rs.GetObject("Select a polyline", rs.filter.curve,
True, True)
if polyline is None: return
vertices = rs.PolylineVertices(polyline)
n = len(vertices) - 1
lengths = []
angles = []
if vertices:
for i in range(n):
if i > 0: prev = i - 1
else: prev = n - 1
next = i + 1
l_i = subtract(vertices[next], vertices[i])
l_j = subtract(vertices[i], vertices[prev])
lengths.append(length(l_i))
# TODO: Is this working only for convex polygons? Does rs.VectorAngle return negative values when it's not convex?
angles.append(angle(l_i, l_j))
angles_sum = sum(angles)
for a in angles:
a = a - t * (a - angles_sum / n)
# TODO(mikhaildubov): This is a dead piece of code
prev_edge = subtract(vertices[1], vertices[0])
newvertices = [vertices[0]]
for i in range(1, n):
newvertices.append(rs.PointAdd(newvertices[-1], prev_edge))
next_edge = scale(unit(rotate(prev_edge, angles[i], [0, 0, 1])),
lengths[i])
prev_edge = next_edge
newvertices.append(newvertices[0]) # first point closes the polyline
# new_polyline = rs.AddPolyline(newvertices, polyline) # replaces previous polyline
new_polyline = rs.AddPolyline(newvertices) # keeps previous polyline
return new_polyline
def DrawFrameBySize(size,location, rightMargin, leftMargin ):
width, height = GetFrameSize(size)
# draw layout frame
width = width*config.DRAWINGSCALE
height = height*config.DRAWINGSCALE
rightMargin = rightMargin*config.DRAWINGSCALE
leftMargin = leftMargin*config.DRAWINGSCALE
p0 = rs.PointAdd((0,0,0),location)
p1 = rs.PointAdd((width,0,0),location)
p2 = rs.PointAdd((width,height,0),location)
p3 = rs.PointAdd((0,height,0),location)
outPolyline = rs.AddPolyline([p0,p1,p2,p3,p0])
p0 = rs.PointAdd((leftMargin,rightMargin,0),location)
p1 = rs.PointAdd((width-rightMargin,rightMargin,0),location)
p2 = rs.PointAdd((width-rightMargin,height-rightMargin,0),location)
p3 = rs.PointAdd((leftMargin,height-rightMargin,0),location)
inPolyline = rs.AddPolyline([p0,p1,p2,p3,p0])
return ( outPolyline, inPolyline)
def SurfacePoints3(self):
ptMTX = {}
srfNORM = {}
rndNORM = {}
#rndptlist3 = []
Udomain = rs.SurfaceDomain(self.strsrf, 0)
Vdomain = rs.SurfaceDomain(self.strsrf, 1)
stepU = (Udomain[1] - Udomain[0]) / self.intu
stepV = (Vdomain[1] - Vdomain[0]) / self.intv
#PLOT POINTS ON SURFACE
count = 0
self.rndvectorlist = self.rndvector()
for i in range(self.intu + 1):
for j in range(self.intv + 1):
#define u and v in terms of step values and i and j
u = Udomain[0] + stepU * i
v = Vdomain[0] + stepV * j
point = rs.EvaluateSurface(self.strsrf, u, v)
ptMTX[(i, j)] = point
#find normals at u,v parameters
srfNORM[(i, j)] = rs.SurfaceNormal(self.strsrf, (u, v))
#CREATE GRID OF OFFSET POINTS DEFINED BY SURFACE NORMALS
self.Dis = self.distance()
for i in range(self.intu + 1):
for j in range(self.intv + 1):
srfNORM[(i, j)] = rs.VectorScale(srfNORM[(i, j)],
120000 / self.Dis[(i, j)])
srfNORM[(i, j)] = rs.PointAdd(ptMTX[(i, j)], srfNORM[(i, j)])
rndNORM[(i, j)] = rs.VectorAdd(
srfNORM[(i, j)],
self.rndvectorlist[count] * (800 / self.Dis[(i, j)]))
count = count + 1
#rs.AddPoint(rndNORM[(i,j)])
#rs.AddPoint(ptMTX[(i,j)])
self.rndptlist3.append(rndNORM[(i, j)])
#rs.DeleteObject(rndptlist3)
return self.rndptlist3
def addArcDiv(ptStart, ptEnd, vecDir):
vecBase = rs.PointSubtract(ptEnd, ptStart)
# error handling
if rs.VectorLength(vecBase) == 0.0: return
if rs.IsVectorParallelTo(vecBase, vecDir): return
vecBase = rs.VectorUnitize(
vecBase
) # normalize vector == force magnitude to 1 to just compare direction
vecDir = rs.VectorUnitize(vecDir)
vecBisector = rs.VectorAdd(vecDir, vecBase)
vecBisector = rs.VectorUnitize(vecBisector)
dotProd = rs.VectorDotProduct(vecBisector, vecDir)
midLength = (0.5 * rs.Distance(ptStart, ptEnd)) / dotProd
vecBisector = rs.VectorScale(vecBisector, midLength)
return rs.AddArc3Pt(ptStart, rs.PointAdd(pt.Start, vecBisector), ptEnd)
def _point_is_in_box(cls, point, position, size):
"""Receives:
point Point3d or (num, num, num)
position Point3d or (num, num, num). The position of the
box
size Point3d or (num, num, num). The diagonal size of
the box
Returns:
value boolean. True, if the point is inside or on the
surface of the box
"""
p1 = position
p2 = rs.PointAdd(p1, size)
x0, y0, z0 = point
x1, y1, z1 = p1
x2, y2, z2 = p2
value = (x1 <= x0 <= x2 and y1 <= y0 <= y2 and z1 <= z0 <= z2)
return value
def grow(self):
x1 = self.node[0][0] - (self.size[1] / 2)
x2 = self.node[0][0] + (self.size[1] / 2)
y1 = self.node[0][1] - (self.size[1] / 2)
y2 = self.node[0][1] + (self.size[1] / 2)
z1 = self.node[0][2]
z2 = self.node[0][2] + self.size[0]
i = 0
while i < self.twigCount:
randPt = placePt(x1, x2, y1, y2, z1, z2)
joinPt = self.node[rs.PointArrayClosestPoint(self.node, randPt)]
vec = rs.VectorScale(
rs.VectorUnitize(rs.VectorSubtract(randPt, joinPt)),
self.segLength)
newPt = rs.PointAdd(joinPt, vec)
self.addTwig(joinPt, newPt)
i += 1
def AddArcDir(ptStart, ptEnd, vecDir):
vecBase = rs.PointSubtract(ptEnd, ptStart)
if rs.VectorLength(vecBase) == 0.0: return
if rs.IsVectorParallelTo(vecBase, vecDir):
return rs.AddLine(ptStart, ptEnd)
vecBase = rs.VectorUnitize(vecBase)
vecDir = rs.VectorUnitize(vecDir)
vecBisector = rs.VectorAdd(vecDir, vecBase)
vecBisector = rs.VectorUnitize(vecBisector)
dotProd = rs.VectorDotProduct(vecBisector, vecDir)
midLength = (0.5 * rs.Distance(ptStart, ptEnd)) / dotProd
vecBisector = rs.VectorScale(vecBisector, midLength)
return rs.AddArc3Pt(ptStart, ptEnd, rs.PointAdd(ptStart, vecBisector))
def Polygon_C(Center, R, N):
import rhinoscriptsyntax as rs
from math import tan, pi
#List Definition
vertex = []
Erase = []
#####################################################################
######## Geometric Operations
#####################################################################
pt = rs.AddPoint([Center[0], Center[1] + R, Center[2]])
#angle in degrees divided by the number of sides
Alf = 2. * pi / N
#angle in degrees divided by the number of sides
Alfa = 360. / N
#you have to add a vector in the x direction which is the radius
#multiplied by tangent of the angle divided by 2
pt2 = rs.PointAdd(pt, (R * tan(Alfa / 2), 0, 0))
#Draw point on rhinospace
pt2 = rs.AddPoint(pt2)
#Loop for the rest of the vertex
for i in range(N + 1):
p = rs.RotateObject(pt2, Center, i * Alfa, axis=None, copy=True)
vertex.append(p)
#Define Polyline
rs.AddPolyline(vertex)
#Finish
Erase = [pt, pt2]
#We extended our existing list, is equivalent to add a list to another list
vertex.extend(Erase)
#Delete points at vertexes
rs.DeleteObjects(vertex)
print("Operation complete")
def curvy_stairs(curve, start_pt, end_pt, stair_width, steps, plinth_lst,
bannister_lst):
ref = rs.OffsetCurve(
curve, [1, 0, 0],
stair_width) # create the second curve to guide the stair
ref_pts = [n * 1 / steps for n in range(steps + 1)
] # guide points to divide up the curve
left_pts = [rs.EvaluateCurve(curve, t)
for t in ref_pts] # guide points on input curve
right_pts = [rs.EvaluateCurve(ref, t)
for t in ref_pts] #guide points on the offset curve
height = end_pt[2] - start_pt[2] #stair height
rise = [0, 0, height / steps] # a vector
for i in range(steps):
#draw rise
v_ver = [
left_pts[i], right_pts[i],
rs.PointAdd(right_pts[i], rise),
rs.PointAdd(left_pts[i], rise)
]
rs.AddSrfPt(v_ver)
#draw run
v_hori = [v_ver[3], v_ver[2], right_pts[i + 1], left_pts[i + 1]]
rs.AddSrfPt(v_hori)
#draw sides
s1 = rs.AddLine(left_pts[i], rs.PointAdd(left_pts[i], rise))
s2 = rs.AddLine(rs.PointAdd(left_pts[i], rise), left_pts[i + 1])
s3 = rs.AddSubCrv(curve, rs.CurveClosestPoint(curve, left_pts[i]),
rs.CurveClosestPoint(curve, left_pts[i + 1]))
rs.AddEdgeSrf([s1, s2, s3])
rs.DeleteObjects([s1, s2, s3])
s1 = rs.AddLine(right_pts[i], rs.PointAdd(right_pts[i], rise))
s2 = rs.AddLine(rs.PointAdd(right_pts[i], rise), right_pts[i + 1])
s3 = rs.AddSubCrv(ref, rs.CurveClosestPoint(ref, right_pts[i]),
rs.CurveClosestPoint(ref, right_pts[i + 1]))
rs.AddEdgeSrf([s1, s2, s3])
rs.DeleteObjects([s1, s2, s3])
s1 = rs.AddLine(left_pts[0], right_pts[0])
s2 = rs.AddLine(left_pts[-1], right_pts[-1])
rs.AddEdgeSrf([s1, curve, s2, ref])
rs.DeleteObjects([s1, s2])
if plinth_lst[0]:
curvy_plinth(curve, ref, stair_width, plinth_lst)
if bannister_lst[0]:
curvy_bannister(curve, ref, stair_width, bannister_lst)
def genIntPoly(self, poly):
cen=rs.CurveAreaCentroid(poly)[0]
pts=rs.CurvePoints(poly)
a=[(pts[0][0]+pts[1][0])/2,(pts[0][1]+pts[1][1])/2,0]
b=[(pts[0][0]+pts[3][0])/2,(pts[0][1]+pts[3][1])/2,0]
vec1=rs.VectorScale(rs.VectorUnitize(rs.VectorCreate(cen,a)),self.d0/2)
vec2=rs.VectorScale(rs.VectorUnitize(rs.VectorCreate(cen,b)),self.d1/2)
p=rs.PointAdd(cen,vec1)
q=rs.PointAdd(cen,-vec1)
r=rs.PointAdd(p,vec2)
u=rs.PointAdd(p,-vec2)
t=rs.PointAdd(q,vec2)
s=rs.PointAdd(q,-vec2)
poly=rs.AddPolyline([r,u,s,t,r])
self.req_poly.append(poly)
def duplicateN():
obj = rs.GetObject("Select object to duplicate", 16, True)
if obj is None: return
box = rs.BoundingBox(obj)
if not isinstance(box, list): return
origin = rs.PointDivide(rs.PointAdd(box[0], box[6]), 2)
endpt = rs.GetPoint("To point")
ndups = rs.GetInteger("Number of duplications")
maxd = rs.GetReal("Max Distance")
translation = rs.VectorCreate(endpt, origin)
for i in range(0, ndups, 1):
xr = random() if random() < 0.5 else -1*random()
yr = random() if random() < 0.5 else -1*random()
zr = random() if random() < 0.5 else -1*random()
newpt = [xr*maxd, yr*maxd, zr*maxd]
translation1 = rs.VectorCreate(endpt, newpt)
translation2 = rs.VectorCreate(translation1, origin)
rs.CopyObject(obj, translation2)
def FitSurface(srf_id, samples):
ptSurface = rs.SurfacePoints(srf_id)
grSurface = rs.SurfaceEditPoints(idSrf, True, True)
nrSurface = GrevilleNormals(srf_id)
uvSamples = XYZ_To_UVW(srf_id, samples)
#Create null vectors for all control-point forces
vecForce = [(0,0,0) for pt in ptSurface]
for i in range(len(uvSamples)):
LocalCP = NearestUV(uvSamples[i], grSurface)
LocalForce = nrSurface[LocalCP]
LocalForce = rs.VectorScale(LocalForce, uvSamples[i][2])
vecForce[LocalCP] = rs.VectorAdd(vecForce[LocalCP], LocalForce)
ptSurface = [rs.PointAdd(ptSurface[i], vecForce[i]) for i in range(len(ptSurface))]
srf_CP_Count = rs.SurfacePointCount(srf_id)
srf_Knots = rs.SurfaceKnots(srf_id)
srf_Weights = rs.SurfaceWeights(srf_id)
srf_Degree = (rs.SurfaceDegree(srf_id, 0), rs.SurfaceDegree(srf_id, 1))
return rs.AddNurbsSurface(srf_CP_Count, ptSurface, srf_Knots[0], srf_Knots[1], srf_Degree, srf_Weights)
def create_square(self, start_point, end_point, start_vector):
across = rs.VectorUnitize(end_point - start_point)
up = rs.VectorScale(start_vector, 0.5)
over_unit = rs.VectorUnitize(rs.VectorCrossProduct(up, across))
over = rs.VectorScale((over_unit), 0.5)
points_inner = []
points_inner.append(rs.PointAdd(start_point, rs.VectorAdd(up, over)))
points_inner.append(
rs.PointAdd(points_inner[0], rs.VectorReverse(over_unit)))
points_inner.append(
rs.PointAdd(points_inner[1], rs.VectorReverse(start_vector)))
points_inner.append(rs.PointAdd(points_inner[2], over_unit))
points_outer = []
points_outer.append(
rs.PointAdd(start_point, rs.VectorAdd(start_vector, over_unit)))
points_outer.append(
rs.PointAdd(points_outer[0],
rs.VectorScale(rs.VectorReverse(over_unit), 2)))
points_outer.append(
rs.PointAdd(points_outer[1],
rs.VectorScale(rs.VectorReverse(start_vector), 2)))
points_outer.append(
rs.PointAdd(points_outer[2], rs.VectorScale(over_unit, 2)))
return [points_outer, points_inner, across]
def RunCommand( is_interactive ):
margin = 5
L, W = 810, 455
basept = Rhino.Geometry.Point3d(0,0,0)
L = unit_convert(L)
W = unit_convert(W)
margin = unit_convert(margin)
go = Rhino.Input.Custom.GetPoint()
opt_L = Rhino.Input.Custom.OptionDouble(L,0.2,10000)
opt_W = Rhino.Input.Custom.OptionDouble(W,0.2,10000)
go.SetCommandPrompt("Pick lower left corner of lasercut area or Enter to place at origin. Default sheet size is L=%.2f, W=%.2f" % (L,W))
go.AddOptionDouble("Length", opt_L)
go.AddOptionDouble("Width", opt_W)
go.AcceptNothing(True)
while True:
res = go.Get()
if res == Rhino.Input.GetResult.Option:
continue
elif res == Rhino.Input.GetResult.Cancel:
return
elif res == Rhino.Input.GetResult.Nothing:
pass
elif res == Rhino.Input.GetResult.Point:
basept = go.Point()
break
layer_dict = wla.get_lcut_layers()
plane = rs.WorldXYPlane()
plane = rs.MovePlane(plane,basept)
inner_rect = rs.AddRectangle(plane,L-margin*2,W-margin*2)
plane = rs.MovePlane(plane, rs.PointAdd(basept, [-margin,-margin,0]))
outer_rect = rs.AddRectangle(plane, L, W)
rs.ObjectLayer([inner_rect, outer_rect],"XXX_LCUT_00-GUIDES")
rs.SelectObjects([inner_rect,outer_rect])
return True
def contour (crvOffset):
# get geometry
surfaceId = rs.GetObject("pick surface to contour", 0, True, True)
startPt = rs.GetPoint("base point of contours")
endPt = rs.GetPoint("end point of contours")
count = 0
reference = []
target = []
# make contours & store in newCrvs
newCrvs = rs.AddSrfContourCrvs(surfaceId, (startPt, endPt), crvOffset) # output is a list of GUIDs. can't access raw points
# divide the target surface
printBed = rs.GetObject("pick surface for layout", 8, True, True)
intCount = len(newCrvs)
uDomain = rs.SurfaceDomain(printBed, 0)
vDomain = rs.SurfaceDomain(printBed, 1)
uStep = (uDomain[1] - uDomain[0]) / intCount
for u in rs.frange(uDomain[0], uDomain[1], uStep):
layout = rs.SurfaceFrame(printBed, [u,1])
target1 = layout[0] # set target to point inside of object - note this is a single point
target2 = rs.PointAdd(target1,(0,10,0)) # this could be more parametric
target.extend([target1, target2])
#print target
# add text, reference and orient!
# for orient, we need a list 3 points to reference and 3 points to target!
# maybe reference should be curve origin crvPl[0] and midpoint? or else polyline verticies -- need to convert curve to polyline first?
for crv in newCrvs:
count += 1 # for label
crvPl = rs.CurvePlane(crv) # plane for text
rs.AddText(count, crvPl, 0.25) # should you label on the ground?
#crvPl = rs.PointAdd(crvPl[0], (0,0,-1)) # if you wanted to offset text
ref1 = rs.CurveMidPoint(crv)
ref2 = crvPl[0]
reference.extend([ref1, ref2])
def createSupPt(origin, nCores, nFloors, rad1, rad2, hP, ang):
for i in range((nCores * nFloors) + 1):
ptO = rs.PointAdd(origin, (0, 0, hP * i / nCores))
pt1 = rs.Polar(ptO, (360 * i / nCores), rad1)
pt1AuxA = rs.Polar(ptO, (360 * i / nCores) + ang, rad1)
pt1AuxB = rs.Polar(ptO, (360 * i / nCores) - ang, rad1)
pt2 = rs.Polar(ptO, (360 * i / nCores), rad2)
pt2AuxA = rs.Polar(ptO, (360 * i / nCores) + ang, rad2)
pt2AuxB = rs.Polar(ptO, (360 * i / nCores) - ang, rad2)
#pExt.append(pt1)
pExt.Add(pt1, g.Kernel.Data.GH_Path(i // nCores))
auxExtPts.extend([pt1AuxA, pt1AuxB])
arc1 = rs.AddArc3Pt(pt1AuxA, pt1AuxB, pt1)
#arc drawing pedestrian path in core area
arcPed.Add(
rs.OffsetCurve(arc1, origin, pedOff)[0],
g.Kernel.Data.GH_Path(i // nCores))
arcPark.Add(
rs.OffsetCurve(arc1, origin, pedOff + parkOff)[0],
g.Kernel.Data.GH_Path(i // nCores))
#extArcs.append(arc1)
extArcs.Add(arc1, g.Kernel.Data.GH_Path(i // nCores))
#pInt.append(pt2)
pInt.Add(pt2, g.Kernel.Data.GH_Path(i // nCores))
auxIntPts.extend([pt2AuxA, pt2AuxB])
arc2 = rs.AddArc3Pt(pt2AuxA, pt2AuxB, pt2)
#intArcs.append(arc2)
intArcs.Add(arc2, g.Kernel.Data.GH_Path(i // nCores))
pSupExt.AddRange([pt1AuxA, pt1AuxB, pt2AuxA, pt2AuxB],
g.Kernel.Data.GH_Path(i // nCores))
def layerTag(obj):
roomName = rs.LayerName(rs.ObjectLayer(obj), False)
#add text tag
try:
text = str(roomName)
pt0 = rs.BoundingBox(obj)[0]
pt2 = rs.BoundingBox(obj)[2]
pt = rs.AddPoint(rs.PointDivide(rs.PointAdd(pt0, pt2), 2))
rs.MoveObject(pt, [0, 1.5, 0])
areaTag = rs.AddText(text, pt, 1, justification=131074)
except:
print "Object has no name"
return
rs.DeleteObject(pt)
parentLayer = rs.ParentLayer(rs.ObjectLayer(obj))
hostLayer = rs.AddLayer("ANNO_LAYER", (128, 128, 128), parent=parentLayer)
rs.ObjectLayer(areaTag, hostLayer)
#te = rs.coercerhinoobject(id, True, True)
#te.Geometry.TextFormula = text
#te.CommitChanges()
#sc.doc.Views.Redraw()
return None
