def get_polyline_coordinates(guids):
"""Get the point coordinates of polylines.
Parameters
----------
guids : list[System.Guid]
Polyline curve identifiers.
Returns
-------
list[list[[float, float, float]]]
A list of point coordinates per polyline.
"""
if isinstance(guids, System.Guid):
points = rs.PolylineVertices(guids)
coords = []
if points:
coords = [map(float, point) for point in points]
return coords
polylines = []
for guid in guids:
points = rs.PolylineVertices(guid)
coords = []
if points:
coords = [map(float, point) for point in points]
polylines.append(coords)
return polylines
def Elementos_vigas(viga):
#banzo superior v3 -- barras
bs = rs.ExplodeCurves(viga[0])
#banzo superior v3 -- nos
nbs = rs.PolylineVertices(viga[0])
#diagonais v3 -- barras
dg = rs.ExplodeCurves(viga[1])
#diagonais v3 -- nos3
ndg = rs.PolylineVertices(viga[1])
#banzo inferior v3 -- barras
bi = rs.ExplodeCurves(viga[2])
#banzo inferior v3 -- nos
nbi = rs.PolylineVertices(viga[2])
return bs, nbs, dg, ndg, bi, nbi
def get_polyline_coordinates(guids):
if isinstance(guids, System.Guid):
points = rs.PolylineVertices(guids)
coords = []
if points:
coords = [map(float, point) for point in points]
return coords
polylines = []
for guid in guids:
points = rs.PolylineVertices(guid)
coords = []
if points:
coords = [map(float, point) for point in points]
polylines.append(coords)
return polylines
def decompose(polyline=None):
# Returns a pair (lengths, angles). Angles are in radians.
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)
lengths = []
angles = []
if vertices:
for i in range(n - 1): # n-1 to avoid the last extra point
if i > 0: prev = i - 1
else: prev = n - 2
next = i + 1
l_i = subtract(vertices[next], vertices[i])
l_j = subtract(vertices[i], vertices[prev])
lengths.append(length(l_i))
# TODO: assumes that we have always a left turn.
# what if the polyline is not convex?
angles.append(pi - angle(rev(l_i), l_j))
return lengths, angles
def blendcorners():
polyline_id = rs.GetObject("Polyline to blend", 4, True, True)
if not polyline_id: return
vertices = rs.PolylineVertices(polyline_id)
if not vertices: return
radius = rs.GetReal("Blend radius", 1.0, 0.0)
if radius is None: return
between = lambda a, b: (a + b) / 2.0
newverts = []
for i in range(len(vertices) - 1):
a = vertices[i]
b = vertices[i + 1]
segmentlength = rs.Distance(a, b)
vec_segment = rs.PointSubtract(b, a)
vec_segment = rs.VectorUnitize(vec_segment)
if radius < (0.5 * segmentlength):
vec_segment = rs.VectorScale(vec_segment, radius)
else:
vec_segment = rs.VectorScale(vec_segment, 0.5 * segmentlength)
w1 = rs.PointAdd(a, vec_segment)
w2 = rs.PointSubtract(b, vec_segment)
newverts.append(a)
newverts.append(between(a, w1))
newverts.append(w1)
newverts.append(between(w1, w2))
newverts.append(w2)
newverts.append(between(w2, b))
newverts.append(vertices[len(vertices) - 1])
rs.AddCurve(newverts, 5)
rs.DeleteObject(polyline_id)
def align(crv1,crv2,origin,axis):
count=0
vert=rs.PolylineVertices(crv1)
while testAlign(crv1,crv2)==False or count>len(vert):
count=count+1
crv1=rs.RotateObject(crv1,origin,360/len(vert),axis)
return crv1
def blendcorners(polyline_id, radius):
# Fillets the corners of a polyline (from the McNeel website)
if not polyline_id: return
vertices = rs.PolylineVertices(polyline_id)
if not vertices: return
if radius is None: return
between = lambda a, b: (a + b) / 2.0
newverts = []
for i in range(len(vertices) - 1):
a = vertices[i]
b = vertices[i + 1]
segmentlength = rs.Distance(a, b)
vec_segment = rs.PointSubtract(b, a)
vec_segment = rs.VectorUnitize(vec_segment)
if radius < (0.5 * segmentlength):
vec_segment = rs.VectorScale(vec_segment, radius)
else:
vec_segment = rs.VectorScale(vec_segment, 0.5 * segmentlength)
w1 = rs.PointAdd(a, vec_segment)
w2 = rs.PointSubtract(b, vec_segment)
newverts.append(a)
newverts.append(between(a, w1))
newverts.append(w1)
newverts.append(between(w1, w2))
newverts.append(w2)
newverts.append(between(w2, b))
newverts.append(vertices[len(vertices) - 1])
CrvId = rs.AddCurve(newverts, 5)
rs.DeleteObject(polyline_id)
return CrvId
def createAirplane():
#CREATE FUSELAGE
rectangleFuselage = rs.AddRectangle(rs.WorldXYPlane(), Fw, Fh)
endPointsF = rs.PolylineVertices(rectangleFuselage)
fPtsB = offsetPoints(Fpb, endPointsF[0], endPointsF[1])
fPtsR = offsetPoints(Fpr, endPointsF[1], endPointsF[2])
fPtsT = offsetPoints(Fpt, endPointsF[2], endPointsF[3])
fPtsL = offsetPoints(Fpl, endPointsF[3], endPointsF[0])
fPtsL.append(fPtsB[0])
fCurveOpen = rs.AddCurve(fPtsB + fPtsR + fPtsT + fPtsL, 2)
#CREATE WING SLOT
wingSlotStart = rs.VectorAdd(endPointsF[0], (Fwx, Fwy, 0))
wingSlotEnd = rs.VectorAdd(wingSlotStart,
(Fw - Fwx + maxPointOffset * 2, 0, 0))
wingSlot = rs.AddLine(wingSlotStart, wingSlotEnd)
wingSlotOffset = rs.OffsetCurve(wingSlot, (0, 1, 0), 1 / 32)
rs.AddLine(rs.CurveStartPoint(wingSlot),
rs.CurveStartPoint(wingSlotOffset))
#CREATE WING
wPlaneOffY = Wh + 1
wPlaneOffX = Fw / 2
wingPlane = rs.MovePlane(rs.WorldXYPlane(), (wPlaneOffX, -wPlaneOffY, 0))
rectangleWing = rs.AddRectangle(wingPlane, Ww, Wh)
endPointsW = rs.PolylineVertices(rectangleWing)
wPtsB = offsetPoints(Wpb, endPointsW[0], endPointsW[1])
wPtsR = offsetPoints(Wps, endPointsW[1], endPointsW[2])
wPtsT = offsetPoints(Wpt, endPointsW[2], endPointsW[3])
wPtsT.append(endPointsW[3])
wPtsB.insert(0, endPointsW[0])
wingCurve = rs.AddCurve(wPtsB + wPtsR + wPtsT)
#wingLine = rs.AddLine(endPointsW[3],endPointsW[0])
rs.MirrorObject(wingCurve, endPointsW[3], endPointsW[0], True)
#CREATE WING GROOVE
wingGrooveStart = rs.VectorAdd(endPointsW[3], (-1 / 64, maxPointOffset, 0))
wingGrooveEnd = rs.VectorAdd(wingGrooveStart,
(0, -(maxPointOffset + Wh * Wsd), 0))
wingGroove = rs.AddLine(wingGrooveStart, wingGrooveEnd)
wingGrooveOffset = rs.OffsetCurve(wingGroove, (1, 0, 0), -1 / 32)
rs.AddLine(rs.CurveEndPoint(wingGroove),
rs.CurveEndPoint(wingGrooveOffset))
#DELETE RECTANGLES
rs.DeleteObject(rectangleFuselage)
rs.DeleteObject(rectangleWing)
def CrvSegmentMidPt(crv, n):
if rs.IsPolyline(crv):
verts = rs.PolylineVertices(crv)
midPt = (verts[n] + verts[n + 1]) / 2
elif rs.IsPolyCurve(crv):
midPt = rs.CurveMidPoint(crv, n)
else:
midPt = rs.CurveMidPoint(crv)
return midPt
def testAlign(crv1,crv2):
start=rs.CurveStartPoint(crv2)
crv1Start=rs.CurveStartPoint(crv1)
pts=rs.PolylineVertices(crv1)
index=rs.PointArrayClosestPoint(pts,start)
crv1Pt=pts[index]
if index!=0:
return False
else:
return True
def ExportLighthouseSensorsToJSON(filename):
print "Writing", filename
#objectIds = rs.GetObjects("Select Sensors",rs.filter.curves,True,True)
#if( objectIds==None ): return3
# Find all circle and all lines in scene
circles = []
lines = []
for obj in rs.AllObjects():
# Skip hidden objects, and invisible layers
# TODO: Recuse up layet hierarchy?
if rs.IsObjectHidden(obj):
continue
layer = rs.ObjectLayer(obj)
if layer and not rs.IsLayerVisible(layer):
continue
if rs.IsCurve(obj):
if rs.IsCircle(obj):
circles.append((obj, rs.CircleCenterPoint(obj)))
elif rs.IsLine(obj):
verts = rs.PolylineVertices(obj)
if len(verts) == 2:
lines.append((obj, verts))
print 'found', len(circles), 'sensor candidates (circles) in scene'
print 'found', len(lines), 'sensor candidates (normals) in scene'
modelJSON = {'modelNormals': [], 'modelPoints': []}
# TODO: Better sort order? Perhaps based on winding around origin?
for circleObj, circleCenter in reversed(circles):
for line, lineVerts in lines:
pos, normal = GetSensorPosAndNormal(circleCenter, lineVerts)
if pos is None:
continue
else:
modelJSON['modelNormals'].append([float(x) for x in normal])
modelJSON['modelPoints'].append(
[float(x) / 1000.0 for x in pos])
break
modelJSON['channelMap'] = range(len(modelJSON['modelNormals']))
print "Extracted", len(modelJSON['channelMap']), "sensors"
if len(modelJSON['modelNormals']) > 0:
outputFile = file(filename, 'w')
jsonText = json.dumps(modelJSON, indent=4, sort_keys=True)
outputFile.write(jsonText)
outputFile.close()
print "Wrote", filename
else:
print "Error: No sensors found in scene"
def mapping(discretization_spacing, surface_guid, curve_features_guids = [], point_features_guids = []):
"""Creates planar polylines from the boundaries of a NURBS surface, NURBS curves and point on the NURBS surface
by using the UV parameterisation with a user-input discretisation spacing.
Parameters
----------
discretization_spacing: real
Spacing value for discretisation of NURBS surface borders and curves into polylines.
surface: Rhino surface guid
Untrimmed or trimmed Rhino NURBS surface.
curve_features: Rhino curve guid
Rhino NURBS curve on the surface.
point_features: Rhino point guid
Rhino point on the surface.
Returns
-------
output: list
Planar parameterised geometrical output: boundary, holes, polyline features and point features.
Raises
------
-
"""
boundaries = surface_borders(surface_guid, border_type = 1)
boundary_polylines = [curve_discretisation(boundary, discretization_spacing) for boundary in boundaries]
uv_boundary_polylines = [[rs.SurfaceClosestPoint(surface_guid, vertex) for vertex in rs.PolylineVertices(boundary_polyline)] for boundary_polyline in boundary_polylines]
planar_boundary_polylines = [[[u, v, 0] for u, v in uv_boundary_polyline] for uv_boundary_polyline in uv_boundary_polylines]
planar_boundary_polyline = []
for polyline in planar_boundary_polylines:
planar_boundary_polyline += polyline[: -1]
planar_boundary_polyline.append(planar_boundary_polyline[0])
rs.DeleteObjects(boundaries)
rs.DeleteObjects(boundary_polylines)
holes = surface_borders(surface_guid, border_type = 2)
if len(holes) > 1:
holes = rs.JoinCurves(holes, delete_input = True)
hole_polylines = [curve_discretisation(hole, discretization_spacing) for hole in holes]
uv_hole_polylines = [[rs.SurfaceClosestPoint(surface_guid, vertex) for vertex in rs.PolylineVertices(hole_polyline)] for hole_polyline in hole_polylines]
planar_hole_polylines = [[[u, v, 0] for u, v in hole] for hole in uv_hole_polylines]
rs.DeleteObjects(holes)
rs.DeleteObjects(hole_polylines)
polyline_features = [curve_discretisation(curve_features_guid, discretization_spacing) for curve_features_guid in curve_features_guids]
uv_polyline_features = [[rs.SurfaceClosestPoint(surface_guid, vertex) for vertex in rs.PolylineVertices(polyline_feature)] for polyline_feature in polyline_features]
planar_polyline_features = [[[u, v, 0] for u, v in feature] for feature in uv_polyline_features]
rs.DeleteObjects(polyline_features)
uv_point_features = [rs.SurfaceClosestPoint(surface_guid, point) for point in point_features_guids]
planar_point_features = [[u, v, 0] for u, v in uv_point_features]
return planar_boundary_polyline, planar_hole_polylines, planar_polyline_features, planar_point_features
def get_polyline_points(polylines):
polys = {}
for key, id in enumerate(polylines):
polys[key] = {}
if not rs.IsCurveClosed(id):
print str(id) + " is an open curve"
rs.MessageBox(str(id) + " is an open curve")
return None
polys[key]['points'] = rs.PolylineVertices(id)[:-1]
polys[key]['id'] = id
return polys
def GetMaxLength(rect):
# find long side
rs.ObjectColor(rect, Color.Blue)
tempPt = rs.PolylineVertices(rect)
tempPt = PointsReorder(tempPt, 1)
if rs.Distance(tempPt[0], tempPt[1]) > rs.Distance(tempPt[1], tempPt[2]):
rs.ObjectColor(rect, Color.Orange)
return rs.Distance(tempPt[0], tempPt[1])
else:
rs.ObjectColor(rect, Color.Orange)
return rs.Distance(tempPt[1], tempPt[2])
def ptsFromPolyline(poly=None):
if poly == None: return
pts = rs.PolylineVertices(poly)
if len(pts) != 3:
return
newPts = []
newPts.append(pts[1])
newPts.append(pts[0])
newPts.append(pts[2])
return newPts
def creatrec(rec1):
#输入一个gh里的矩形,输出矩形类
rec1 = rs.PolylineVertices(rec1)
origin_point1 = Point2D([rec1[0][0],rec1[0][1]])
point1 = rec1[1]
point_end = rec1[-2]
vecx1 = Vector(point1[0]-origin_point1.x,point1[1]-origin_point1.y)
vecy1 = Vector(point_end[0]-origin_point1.x,point_end[1]-origin_point1.y)
vecx1_na = vecx1.reverse()
vecy1_na = vecy1.reverse()
now_rec1 = Rectangle(origin_point1,[vecx1,vecy1,vecx1_na,vecy1_na])
return now_rec1
def subd(pol, ratio):
pts = rs.PolylineVertices(pol)
vec = rs.VectorCreate(pts[2], pts[1])
vec = rs.VectorScale(vec, ratio)
midPt = rs.VectorAdd(pts[1], vec)
pts1 = [pts[0], pts[1], midPt, pts[0]]
pts2 = [pts[0], midPt, pts[2], pts[0]]
triangle1 = rs.AddPolyline(pts1)
triangle2 = rs.AddPolyline(pts2)
def save(obj, x=0, y=0, filename=None):
if filename is None:
filename = rs.SaveFileName("Save", "CarbideMotion (*.nc)|*.nc||")
print('saving to ' + filename)
with open(filename, 'w') as f:
program_start(f.write, x, y)
points = rs.PolylineVertices(obj)
for point in points:
f.write("X{:.3f}Y{:.3f}Z{:.3f}\n".format(point.X, point.Y,
point.Z))
program_end(f.write)
print('file sucessfully saved')
def GroupMove(rectOutlineList, objects, objCenter, rotatedAngle, movingCenter):
for objs, rect, center, rotAngle, centerStart in zip(
objects, rectOutlineList, objCenter, rotatedAngle, movingCenter):
# rotate everything by center with rotatedAngle
rs.RotateObjects(objs, center, rotAngle)
# find vector to move from obj location to rectangle(obj center to rect center)
boxCenter = rs.CurveAreaCentroid(rect)[0]
moveVector = rs.VectorCreate(boxCenter, center)
# check if object is in box
rectPt = rs.PolylineVertices(rect)
rectPt = PointsReorder(rectPt, 1)
if rs.Distance(rectPt[0], rectPt[1]) > rs.Distance(
rectPt[1], rectPt[2]):
rs.RotateObjects(objs, center, 90)
rs.MoveObjects(objs, moveVector)
def Linhas_de_Cargas(viga, cargas, nome):
Cargasvigas = []
ptos1 = []
nos = rs.PolylineVertices(viga[0])
for i in range(len(cargas)):
lincarg = Linha_force_extena(nos[i], cargas[i], Escala)
linCoe = rs.coerceline(lincarg)
pt1 = linCoe.PointAt(.5)
pt2 = linCoe.PointAt(0)
texto1 = str('%.2f' % cargas[i])
texto2 = 'P' + str(i) + '_' + nome
Cargasvigas.append(lincarg)
ptos1 += [pt1, texto1, corcargas]
ptos1 += [pt2, texto2, corcargas]
return Cargasvigas, ptos1
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
__version__ = "2021.03.17"
import rhinoscriptsyntax as rs
import Rhino as rh
import scriptcontext as sc
sc.doc = rh.RhinoDoc.ActiveDoc
all_objs = rs.AllObjects()
#obj_crv = rs.coercecurve(all_objs[0])
#print(obj_crv)
#pnt = rs.CreatePoint(float(-22), float(-1), float(0))
pnt = rs.CreatePoint(float(42), float(-3), float(0))
counter = 0
for obj in all_objs:
crv = rs.coercecurve(obj)
in_curve = rs.PointInPlanarClosedCurve(pnt, crv)
counter += 1
if (in_curve):
print(counter, "Tada")
points = rs.PolylineVertices(curve)
pnt = rs.CreatePoint(float(235), float(240), float(0))
rs.SetUserText(curve, "PartNo", "KM40-4960")
print(counter, crv)
def Outline(refpt,dir,arrlist):
data = ReadJoints(di,fil)
O = -1
trim = 1
left = []
upl = []
right = []
upr = []
res = Start(refpt,dir,data[0])
dir = res[0]
for j in range(len(res[1])):
upl.append(rs.VectorAdd(res[1][j],[0,0,-1*trim]))
left.append(res[1][j])
for j in range(len(res[2])):
upr.append(rs.VectorAdd(res[2][j],[0,0,-1*trim]))
right.append(res[2][j])
store = [[left,right],[upl,upr]]
info2 = data[0]
for i in range(len(arrlist)):
trim = trim*fc
refpt = rs.VectorAdd(refpt,dir)
info = data[arrlist[i]]
if i < len(arrlist):
res = Elt(refpt,dir,info)
res1 = Shift(res,trim)
dir = res[0]
for j in range(len(res[1])):
upl.append(rs.VectorAdd(res[1][j],[0,0,-1*trim]))
left.append(res[1][j])
for j in range(len(res[2])):
upr.append(rs.VectorAdd(res[2][j],[0,0,-1*trim]))
right.append(res[2][j])
store2 = [[res[1],res[2]],[res1[1],res1[2]]]
store = store2
else:
res = Ending(refpt,dir,info)
res1 = Shift(res,trim)
dir = res[0]
for j in range(len(res[1])):
upl.append(rs.VectorAdd(res[1][j],[0,0,-1*trim]))
left.append(res[1][j])
for j in range(len(res[2])):
upr.append(rs.VectorAdd(res[2][j],[0,0,-1*trim]))
right.append(res[2][j])
store2 = [[res[1],res[2]],[res1[1],res1[2]]]
store = store2
info2 = info
l1 = rs.AddPolyline(left)
r1 = rs.AddPolyline(right)
#l2 = rs.AddPolyline(upl)
#r2 = rs.AddPolyline(upr)
output = rs.JoinCurves([l1,r1],True)
return rs.PolylineVertices(output[0])
import rhinoscriptsyntax as rs
fp = "gcode_out.txt"
inCrv = rs.GetObjects("Select curves to draw", filter=4)
print inCrv
if len(inCrv) > 0:
inCrv = sorted(inCrv, key=lambda k:rs.CurveStartPoint(k).Y)
#subD = rs.GetReal("Input segment length", number=1.0)
with open(fp, mode='w') as outfile:
if len(inCrv) >= 1:
for crv in inCrv:
pts = rs.PolylineVertices(crv)
for i, pt in enumerate(pts):
if i == 0:
#raise pen
outfile.write("M03 S0 \n")
#go to first position
outfile.write("G00 X%.3f Y%.3f \n" %(pt.X,pt.Y) )
#drop pen
outfile.write("M03 S1024 \n")
continue
#go to next position (with pen down)
outfile.write("G00 X%.3f Y%.3f \n" %(pt.X,pt.Y) )
#lift pen
outfile.write("M03 S0 \n")
outfile.write("G00 X0 Y0 \n")
def createAirplane(self):
#CREATE FUSELAGE
rectangleFuselage = rs.AddRectangle(self.location,
self.genes.values['Fw'],
self.genes.values['Fh'])
endPointsF = rs.PolylineVertices(rectangleFuselage)
fPtsB = offsetPoints(self.genes.values['Fpb'], endPointsF[0],
endPointsF[1])
fPtsR = offsetPoints(self.genes.values['Fpr'], endPointsF[1],
endPointsF[2])
fPtsT = offsetPoints(self.genes.values['Fpt'], endPointsF[2],
endPointsF[3])
fPtsL = offsetPoints(self.genes.values['Fpl'], endPointsF[3],
endPointsF[0])
fPtsL.append(fPtsB[0])
fCurveOpen = rs.AddCurve(fPtsB + fPtsR + fPtsT + fPtsL, 2)
#CREATE WING SLOT
wingSlotStart = rs.VectorAdd(
endPointsF[0],
(self.genes.values['Fwx'], self.genes.values['Fwy'], 0))
wingSlotEnd = rs.VectorAdd(
wingSlotStart,
(self.genes.values['Fw'] - self.genes.values['Fwx'] +
maxPointOffset * 2, 0, 0))
wingSlot = rs.AddLine(wingSlotStart, wingSlotEnd)
#guideLine = rs.AddLine(wingSlotStart,rs.VectorAdd(wingSlotStart,(0,0.2,0)))
#rs.ObjectColor(guideLine,(0,0,200))
#wingSlotOffset = rs.OffsetCurve(wingSlot,(0,1,0),1/32)
#rs.AddLine(rs.CurveStartPoint(wingSlot),rs.CurveStartPoint(wingSlotOffset))
#CREATE WING
wPlaneOffY = self.genes.values['Wh'] + 1
wPlaneOffX = self.genes.values['Fw'] / 2
wingPlane = rs.MovePlane(self.location,
(wPlaneOffX + self.location[0].X,
-wPlaneOffY + self.location[0].Y, 0))
rectangleWing = rs.AddRectangle(wingPlane, self.genes.values['Ww'],
self.genes.values['Wh'])
endPointsW = rs.PolylineVertices(rectangleWing)
wPtsB = offsetPoints(self.genes.values['Wpb'], endPointsW[0],
endPointsW[1])
wPtsR = offsetPoints(self.genes.values['Wps'], endPointsW[1],
endPointsW[2])
wPtsT = offsetPoints(self.genes.values['Wpt'], endPointsW[2],
endPointsW[3])
wPtsT.append(endPointsW[3])
wPtsB.insert(0, endPointsW[0])
wingCurve = rs.AddCurve(wPtsB + wPtsR + wPtsT)
#wingLine = rs.AddLine(endPointsW[3],endPointsW[0])
wingCurveM = rs.MirrorObject(wingCurve, endPointsW[3], endPointsW[0],
True)
#CREATE WING GROOVE
wingGrooveStart = rs.VectorAdd(endPointsW[3], (0, maxPointOffset, 0))
wingGrooveEnd = rs.VectorAdd(
wingGrooveStart,
(0, -(maxPointOffset +
self.genes.values['Wh'] * self.genes.values['Wsd']), 0))
wingGroove = rs.AddLine(wingGrooveStart, wingGrooveEnd)
#wingGrooveOffset = rs.OffsetCurve(wingGroove,(1,0,0),-1/32)
#rs.AddLine(rs.CurveEndPoint(wingGroove),rs.CurveEndPoint(wingGrooveOffset))
#DELETE RECTANGLES
rs.DeleteObject(rectangleFuselage)
rs.DeleteObject(rectangleWing)
textPlane = rs.MovePlane(
self.location,
(self.location[0].X + .25, self.location[0].Y + .25, 0))
text = rs.AddText(self.number, textPlane, 0.25)
textCurves = rs.ExplodeText(text, True)
rs.ObjectColor(textCurves, (0, 0, 200))
planeGroup = rs.AddGroup()
rs.AddObjectsToGroup(
[fCurveOpen, wingCurveM, wingSlot, wingCurve, wingGroove, text],
planeGroup)
#atualizando dicionário
dic_2.update(dicUp)
#Atualizando elementos na saida PF2
for i in dicUp.keys():
PF2.append(dicUp[i])
print '####--------------------V2-----------------------####'
dicUp, ptos = Grafo_Viga(v2, carreg_v2, Plano, dic_2, cirDir, Conector[1],
fgR_v2, 'v2')
txt_pontos += ptos
#atualizando dicionário
dic_2.update(dicUp)
#Atualizando elementos na saida PF2
for i in dicUp.keys():
PF2.append(dicUp[i])
print '####--------------Eixo do Conector---------------####'
nos = rs.PolylineVertices(Conector[1])
no = nos[0]
conector = rs.ExplodeCurves(Conector[1])
conector.append(rs.AddLine(no, nos[2]))
#elementos do conector
elementos, nomesNo = elemntos_node(no, conector, 'bc', 'c')
#Força externa
fgF0 = (rs.AddLine(F0.PointAt(0), F0.PointAt(1)))
nomesNo, elementos, countPF, countCalcular = OrdenaLinhasDeAcao(
no, cirDir, elementos, nomesNo, dic_2, Plano)
nomesNo.insert(1, 'F0')
elementos.insert(1, fgF0)
dicUp, ptos1 = Cremona1(no, nomesNo, elementos, countPF + 1, dic_2)
txt_pontos += ptos1
dic_2.update(dicUp)
#Atualizando elementos na saida PF2
def RectNestingOperation(boards, rectOutlineList):
onBoard = [] # store the rectngles placed that are currently on this board
rectInOrder = [] # store the rectangles that are in order
curBoardIndex = 0 # number of board used
nestingOrient = 1 # 1: current (big), 2: cur. turn 90 degrees, 3: reversed (small), 4: reversed and teuned 90 degrees
intersectWithRect = False
# order rectangle by length (UPDATED)
for i in rectOutlineList:
# check if list is empty so far
if len(rectInOrder) == 0:
rectInOrder.append(i)
continue
lastIndex = len(rectInOrder) - 1
index = 1
rs.ObjectColor(i, Color.Orange)
maxLength = GetMaxLength(i)
# compare first and last
if GetMaxLength(rectInOrder[0]) >= maxLength:
rectInOrder.insert(0, i)
continue
elif GetMaxLength(rectInOrder[lastIndex]) <= maxLength:
rectInOrder.append(i)
continue
# check within the ordered list
while GetMaxLength(rectInOrder[index]) < maxLength:
index += 1
rectInOrder.insert(index, i)
# reverse rectangle order to descending order
rectInOrder.reverse()
while curBoardIndex <= len(boards):
# check if ascend of descend placement (adjust curRect also)
if len(rectInOrder) == 0:
# done nesting, no more in list
return True
# update board if previous board is full
curBoard = boards[curBoardIndex]
curBoardPt = rs.PolylineVertices(curBoard)
# nesting Orient checking
if nestingOrient == 1 or nestingOrient == 2:
if nestingOrient == 1:
curRectIndex = 0
curRect = rectInOrder[curRectIndex]
curRectPt = rs.PolylineVertices(curRect)
else:
rs.RotateObject(curRect, (curRectPt[0] + curRectPt[2]) / 2, 90)
elif nestingOrient == 3 or nestingOrient == 4:
if nestingOrient == 3:
curRectIndex = len(rectInOrder) - 1
curRect = rectInOrder[curRectIndex]
curRectPt = rs.PolylineVertices(curRect)
else:
rs.RotateObject(curRect, (curRectPt[0] + curRectPt[2]) / 2, 90)
rs.ObjectColor(curRect, Color.LightBlue)
curRectPt = rs.PolylineVertices(curRect)
curRectPt = PointsReorder(curRectPt, 1)
"""
*******************************************************************************************************************
# arrange all rect with long side in lateral (MOVE THIS TO GETRECT CLASS)-> THIS IS MOVED TO GETALLRECTOUTLINE CLASS
# SO WE CAN SUPPOSE ALL RECT PASSING IN IS MAX LENGTH AT LATERAL DIRECTION
*******************************************************************************************************************
if nestingOrient == 1 or nestingOrient == 3:
if rs.Distance(curRectPt[0], curRectPt[1]) > rs.Distance(curRectPt[1], curRectPt[2]):
rs.RotateObject(curRect,(curRectPt[0] + curRectPt[2]) / 2, 90)
"""
# remake points for curRectPt and move to board start
curRectPt = rs.PolylineVertices(curRect)
curRectPt = PointsReorder(curRectPt, 1)
moveInBoard = rs.VectorCreate(curBoardPt[0], curRectPt[0])
rs.MoveObject(curRect, moveInBoard)
curRectPt = rs.PolylineVertices(curRect)
curRectPt = PointsReorder(curRectPt, 1)
# nesting movement
if len(onBoard) == 0:
onBoard.append(curRect)
rectInOrder.pop(curRectIndex)
else:
while True:
# check intersection with other rect.
for check in onBoard:
# True means intersect, false means good to place if other condition pass
intersectWithRect = (rs.IsObjectInBox(
curRect, rs.PolylineVertices(check), False))
if intersectWithRect == True:
break
# in board status
overBoard = curRectPt[1][0] > curBoardPt[1][0]
changeBoard = curRectPt[2][1] > curBoardPt[2][1]
if (changeBoard and nestingOrient == 4):
# change board
curBoardIndex += 1
curBoard = boards[curBoardIndex]
del onBoard[:] # clearing onBoard for next board
nestingOrient = 1
# move back to original location
rs.MoveObject(curRect, -moveInBoard)
break
elif (changeBoard):
# first change orientation and see if it can still fit
if (nestingOrient == 1):
nestingOrient = 2
break
elif (nestingOrient == 2):
nestingOrient = 3
# move back to original location (not super ideal but can't think of anything else at this point Lol)
moveTemp = [0, -2000000, 0]
rs.MoveObject(curRect, moveTemp)
rs.RotateObject(curRect,
(curRectPt[0] + curRectPt[2]) / 2, -90)
break
elif (nestingOrient == 3):
nestingOrient = 4
break
elif (overBoard):
# switch to new y (up 1 interval)
lateralMove = [(curBoardPt[0][0] - curRectPt[0][0]), 20, 0]
rs.MoveObject(curRect, lateralMove)
curRectPt = rs.PolylineVertices(curRect)
curRectPt = PointsReorder(curRectPt, 1)
elif (intersectWithRect):
rs.MoveObject(curRect, [10, 0, 0])
curRectPt = rs.PolylineVertices(curRect)
curRectPt = PointsReorder(curRectPt, 1)
else:
onBoard.append(curRect)
rectInOrder.pop(curRectIndex)
# reset nesting orient to descending if location is found
if nestingOrient == 2:
nestingOrient = 1
elif nestingOrient == 4:
nestingOrient = 3
break
return False # meaning element is more than the board that can nest
def Cargas_Vigas(viga, plD, plB, plC, cob, borda1, borda2, conv):
#
cob = rs.coercecurve(cob)
forces = []
#separando entrada viga em seus elementos (polilinhas)
#bs = banzo superior, diag = diagonais, bi = banzo inferior
bs, diag, bi = viga
#extraindo os nós do banzo superior
nos = rs.PolylineVertices(bs)
# explodindo polilinhas
bs = rs.ExplodeCurves(bs)
diag = rs.ExplodeCurves(diag)
bi = rs.ExplodeCurves(bi)
for i in range(len(nos)):
P = 0
if 0 < i < (len(nos) - 1):
#banzo inferior
P = rs.CurveLength(bi[i]) * plB
#banzo superior
P += (rs.CurveLength(bs[i - 1]) + rs.CurveLength(bs[i])) / 2 * plB
#diagonais
P += (rs.CurveLength(diag[i * 2]) +
rs.CurveLength(diag[(i * 2) + 1])) * plD
#cobertura
bs1 = bs[i - 1]
bs1 = rs.coerceline(bs1)
ptAux1 = bs1.PointAt(.5)
bs2 = bs[i]
bs2 = rs.coerceline(bs2)
ptAux2 = bs2.PointAt(.5)
param1 = rs.CurveClosestPoint(cob, ptAux1)
param2 = rs.CurveClosestPoint(cob, ptAux2)
elif i == 0:
#banzo inferior
P = rs.CurveLength(bi[i]) * plB
#banzo superior
P += (rs.CurveLength(bs[i]) / 2) * plB
#diagonais
P += (rs.CurveLength(diag[i * 2]) +
rs.CurveLength(diag[(i * 2) + 1])) * plD
#cobertura
param1 = 0
bs1 = bs[i]
bs1 = rs.coerceline(bs1)
ptAux = bs1.PointAt(.5)
#teste.append(ptAux)
param2 = rs.CurveClosestPoint(cob, ptAux)
elif i == (len(nos) - 1):
#banzo superior e conector
P = (rs.CurveLength(bs[i - 1]) + rs.CurveLength(borda1)) / 2 * plB
#conector
P += rs.CurveLength(borda2) * plB
#cobertura
bs1 = bs[i - 1]
bs1 = rs.coerceline(bs1)
ptAux1 = bs1.PointAt(.5)
borda1 = rs.coerceline(borda1)
ptAux2 = borda1.PointAt(.5)
param1 = rs.CurveClosestPoint(cob, ptAux1)
param2 = rs.CurveClosestPoint(cob, ptAux2)
if not len(diag) % 2 == 0:
#banzo inferior
P += rs.CurveLength(bi[i]) * plB
#diagonal
P += (rs.CurveLength(diag[i * 2])) * plD
P_viga = P
if not param1 == param2:
cobAux = rs.TrimCurve(cob, [param1, param2], False)
P_cob = rs.CurveLength(cobAux) * plC
P += P_cob
P *= conv
forces.append(P)
return forces, P_viga, P_cob
import rhinoscriptsyntax as rs
iterationCount = 2
obj = rs.GetObject("Select a polyline")
if rs.IsPolyline(obj):
controlPoints = rs.PolylineVertices(obj)
# if points:
# for point in points: rs.AddPoint(point)
for j in range(iterationCount):
newControlPoints = []
for i in range(len(controlPoints) - 1):
oneQuarterPoint = rs.PointAdd(
rs.PointScale(controlPoints[i], 0.75),
rs.PointScale(controlPoints[i + 1], 0.25))
newControlPoints.append(rs.CreatePoint(oneQuarterPoint))
threeQuarterPoint = rs.PointAdd(
rs.PointScale(controlPoints[i], 0.25),
rs.PointScale(controlPoints[i + 1], 0.75))
newControlPoints.append(rs.CreatePoint(threeQuarterPoint))
controlPoints = newControlPoints
rs.AddPolyline(controlPoints)
def Laplacemotion():
pl_id = rs.GetObject("Select a polyline", rs.filter.curve, True, True)
if pl_id is None: return
step = 0.3
length = rs.CurveLength(pl_id)
#area = rs.CurveArea(pl_id)
newvertices = []
vertices = rs.PolylineVertices(pl_id)
n = len(vertices) # one more than the actual number of vertices
# calcul du centre de gravite
g = (0, 0, 0)
for i in range(n - 1):
g = rs.VectorAdd(g, vertices[i])
g = rs.VectorScale(g, 1 / (n - 1))
rs.AddPoint(g)
if vertices:
for i in range(n - 1): # n-1 to avoid the last extra point
if i > 0: prev = i - 1
else: prev = n - 2
next = i + 1
# 1. Computing the flow vector (H or V)
e_i = rs.VectorSubtract(vertices[next], vertices[i])
e_i_1 = rs.VectorSubtract(vertices[i], vertices[prev])
v_i = rs.VectorUnitize(e_i)
v_i_1 = rs.VectorUnitize(e_i_1)
#vector = rs.VectorSubtract(e_i, e_i_1) # V = e_i - e_i-1
vector = rs.VectorSubtract(v_i, v_i_1) # H = v_i - v_i-1
# 2. Scaling the vecor
# HOW TO CHOOSE THE NORMALIZATION COEFFICIENT FOR THE VECTOR?
# This doesn't work in all cases
# vector = rs.VectorUnitize(vector)
# This doesn't either
# vector = rs.VectorScale(vector, step)
# We can also square the length of the flow vector
# (makes sense if it is H, not V)
vector = rs.VectorScale(vector, rs.VectorLength(vector)**2)
AddVector(vector, vertices[i]) # draws change vectors
newvertices.append(rs.PointAdd(vertices[i], vector))
newvertices.append(newvertices[0]) # first point closes the polyline
# newpl_id = rs.AddPolyline(newvertices, pl_id) # replaces previous polyline
newpl_id = rs.AddPolyline(newvertices) # keeps previous polyline
# Scale to preserve the same length
# (otherwise the polyline converges to a point)
newlength = rs.CurveLength(newpl_id)
scaling = length / newlength
#rs.ScaleObject(newpl_id, g, (scaling, scaling, scaling))
# Alternatively, one cane scale it by area
#newarea = rs.CurveArea(newpl_id)
#scaling_area = area / newarea
# rs.ScaleObject(newpl_id, g, (scaling_area, scaling_area, scaling_area))
return (newpl_id)
