def vrep_pose_from_plane(plane):
"""Creates a vrep-compatible transformation matrix from a Rhino/Grasshopper
plane.
This function might need rework as the source of the 90-deg Y rotation
need is not entirely clear to me (related to the RFL model mismatch).
"""
translation_matrix = rs.XformTranslation(((plane[0][0]), (plane[0][1]), plane[0][2]))
plane_start = rs.PlaneFromFrame(rs.AddPoint(0, 0, 0), rs.AddPoint(1, 0, 0), rs.AddPoint(0, 1, 0))
plane_end = rs.PlaneFromFrame(rs.AddPoint(0, 0, 0), rs.AddPoint(plane[1][0], (plane[1][1]), plane[1][2]), rs.AddPoint(plane[2][0], plane[2][1], plane[2][2]))
rotation_matrix = rs.XformRotation1(plane_start, plane_end)
matrix = rs.XformMultiply(translation_matrix, rotation_matrix)
return [matrix.M00, matrix.M01, matrix.M02, matrix.M03,
matrix.M10, matrix.M11, matrix.M12, matrix.M13,
matrix.M20, matrix.M21, matrix.M22, matrix.M23]
def load_printpoints(path, folder_name, json_name):
""" Loads a dict of compas_slicer printpoints. """
data = load_json_file(path, folder_name, json_name)
# geometry data
points = []
frames = []
layer_heights = []
up_vectors = []
mesh_normals = []
closest_support = []
# fabrication related data
velocities = []
wait_times = []
blend_radiuses = []
extruder_toggles = []
if data:
for i in range(len(data)):
data_point = data[str(i)]
# geometry related data
point = rg.Point3d(data_point["point"][0], data_point["point"][1],
data_point["point"][2])
points.append(point)
compas_frame = Frame.from_data(data_point["frame"])
pt, x_axis, y_axis = compas_frame.point, compas_frame.xaxis, compas_frame.yaxis
frame = rs.PlaneFromFrame(pt, x_axis, y_axis)
frames.append(frame)
layer_heights.append(data_point["layer_height"])
v = data_point["up_vector"]
up_vector = rg.Vector3d(v[0], v[1], v[2])
up_vectors.append(up_vector)
v = data_point["mesh_normal"]
mesh_normal = rg.Vector3d(v[0], v[1], v[2])
mesh_normals.append(mesh_normal)
cp = data_point["closest_support_pt"]
if cp:
cp_pt = rg.Point3d(cp[0], cp[1], cp[2])
closest_support.append(cp_pt)
else:
closest_support.append(
point
) # in order to have the same number of points everywhere
# fabrication related data
velocities.append(data_point["velocity"])
wait_times.append(data_point["wait_time"])
blend_radiuses.append(data_point["blend_radius"])
extruder_toggles.append(data_point["extruder_toggle"])
return points, frames, layer_heights, up_vectors, mesh_normals, closest_support, velocities, wait_times, \
blend_radiuses, extruder_toggles
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 create_cut_sht_targets(stockOutline, array, margin, partSpacing):
"""returns a list of target planes to evenly space parts on a given stock"""
numParts = len(array)
stockDimensions = dimension_boundingBox(stockOutline)
partDimensions = dimension_boundingBox(array[0])
stockHeight = stockDimensions[0]
stockWidth = stockDimensions[1]
partHeight = partDimensions[0]
partWidth = partDimensions[1]
yStartPt = partWidth / 2.0 + margin
xStartPt = partHeight / 2.0 + margin
ySpacing = partWidth + partSpacing
xSpacing = partHeight + partSpacing
rowWidth = stockWidth - (2 * margin)
columnHeight = stockHeight - (2 * margin)
currentX = xStartPt
currentY = yStartPt
locationPts = []
targetPlanes = []
for i in range(len(array)):
xLimit = currentX + (partWidth / 2.0)
yLimit = currentY + (partHeight / 2.0)
if yLimit > columnHeight:
print "parts do not fit on stock"
return None
elif xLimit > rowWidth:
currentY += ySpacing
currentX = xStartPt
partCenterPt = rs.AddPoint(currentX, currentY, 0)
locationPts.append(partCenterPt)
targetPlane = rs.PlaneFromFrame(partCenterPt, [1, 0, 0], [0, 1, 0])
targetPlanes.append(targetPlane)
currentX += xSpacing
else:
partCenterPt = rs.AddPoint(currentX, currentY, 0)
locationPts.append(partCenterPt)
targetPlane = rs.PlaneFromFrame(partCenterPt, [1, 0, 0], [0, 1, 0])
targetPlanes.append(targetPlane)
currentX += xSpacing
return targetPlanes
def cross_section_plane_curvature(self, curvature, prev_normal, prev_perp):
crvPoint = curvature[0]
crvTangent = curvature[1]
crvPerp = rs.VectorUnitize(curvature[4])
crvNormal = rs.VectorCrossProduct(crvTangent, crvPerp)
if prev_normal:
crvNormal = self.reverse_if_needed(crvNormal, prev_normal)
if prev_perp:
crvPerp = self.reverse_if_needed(crvPerp, prev_perp)
return rs.PlaneFromFrame(crvPoint, crvPerp, crvNormal)
def flatWorm():
curveObject = rs.GetObject("pick a backbone curve", 4, True, False)
samples = rs.GetInteger("# of crosssections", 100, 5)
bend_radius = rs.GetReal("bend radius", 0.5, 0.001) # r1
perp_radius = rs.GetReal("ribbon plan radius", 2.0, 0.001) #r2
crvDom = rs.CurveDomain(
curveObject
) # domain != length // why do we use domains? == "The domain is the set of all possible input values to the function that defines the curve or surface."
crossSections = [] # empty array to store sections
t_step = (crvDom[1] -
crvDom[0]) / samples # this is starting to be a pattern!
t = crvDom[0] # start pt for loop at the start of the line
for t in rs.frange(crvDom[0], crvDom[1],
t_step): # loop thru entire domain w/ floats
crvCurvature = rs.CurveCurvature(
curveObject, t
) # evaluate curve with a circle - gives 3d normals & gives radius info
crossSecPlane = None
if not crvCurvature:
crvPoint = rs.EvaluateCurve(curveObject, t)
crvTan = rs.CurveTangent(curveObject, t) # get tangent vector
crvPerp = (0, 0, 1)
crvNorm = rs.VectorCrossProduct(crvTan,
crvPerp) # = product of 2 vectors
crossSecPlane = rs.PlaneFromFrame(crvPoint, crvPerp, crvNorm)
else:
crvPoint = crvCurvature[0]
crvTan = crvCurvature[1]
crvPerp = rs.VectorUnitize(crvCurvature[4])
crvNorm = rs.VectorCrossProduct(crvTan, crvPerp) # look up
crossSecPlane = rs.PlaneFromFrame(crvPoint, crvPerp, crvNorm)
if crossSecPlane:
csec = rs.AddEllipse(
crossSecPlane, bend_radius, perp_radius
) # draw ellipse at tan/normal to point along curve with radii
crossSections.append(csec) # add ellipses to an array
t += t_step # step through domain
rs.AddLoftSrf(crossSections) # loft list of curves
rs.DeleteObjects(
crossSections) # delete original list of curves as cleanup
def FlatWorm():
curve_object = rs.GetObject("Pick a backbone curve", 4, True, False)
if not curve_object: return
samples = rs.GetInteger("Number of cross sections", 100, 5)
if not samples: return
bend_radius = rs.GetReal("Bend plane radius", 0.5, 0.001)
if not bend_radius: return
perp_radius = rs.GetReal("Ribbon plane radius", 2.0, 0.001)
if not perp_radius: return
crvdomain = rs.CurveDomain(curve_object)
crosssections = []
t_step = (crvdomain[1]-crvdomain[0])/samples
t = crvdomain[0]
while t<=crvdomain[1]:
crvcurvature = rs.CurveCurvature(curve_object, t)
crosssectionplane = None
if not crvcurvature:
crvPoint = rs.EvaluateCurve(curve_object, t)
crvTangent = rs.CurveTangent(curve_object, t)
crvPerp = (0,0,1)
crvNormal = rs.VectorCrossProduct(crvTangent, crvPerp)
crosssectionplane = rs.PlaneFromFrame(crvPoint, crvPerp, crvNormal)
else:
crvPoint = crvcurvature[0]
crvTangent = crvcurvature[1]
crvPerp = rs.VectorUnitize(crvcurvature[4])
crvNormal = rs.VectorCrossProduct(crvTangent, crvPerp)
crosssectionplane = rs.PlaneFromFrame(crvPoint, crvPerp, crvNormal)
if crosssectionplane:
csec = rs.AddEllipse(crosssectionplane, bend_radius, perp_radius)
crosssections.append(csec)
t += t_step
if not crosssections: return
rs.AddLoftSrf(crosssections)
rs.DeleteObjects(crosssections)
def cross_section_plane_no_curvature(self,
t,
prev_normal=None,
prev_perp=None):
crvPoint = rs.EvaluateCurve(self.curve_object, t)
crvTangent = rs.CurveTangent(self.curve_object, t)
crvPerp = (0, 0, 1)
crvNormal = rs.VectorCrossProduct(crvTangent, crvPerp)
if prev_normal:
crvNormal = self.reverse_if_needed(crvNormal, prev_normal)
if prev_perp:
crvPerp = self.reverse_if_needed(crvPerp, prev_perp)
return rs.PlaneFromFrame(crvPoint, crvPerp, crvNormal)
def offset_vector(self, point, cross_section_index, point_index):
modulo = len(self.point_lists[cross_section_index - 1])
prev_point_1 = self.point_lists[cross_section_index - 1][
(point_index - 2) %
modulo] if cross_section_index % 2 == 0 else self.point_lists[
cross_section_index - 1][(point_index - 1) % modulo]
prev_point_2 = self.point_lists[cross_section_index - 1][
(point_index - 1) %
modulo] if cross_section_index % 2 == 0 else self.point_lists[
cross_section_index - 1][point_index]
in_between_vector = rs.VectorAdd(rs.VectorCreate(prev_point_1, point),
rs.VectorCreate(prev_point_2, point))
normal_vector = rs.SurfaceNormal(
self.brep, rs.SurfaceClosestPoint(self.brep, point))
plane = rs.PlaneFromFrame(point, in_between_vector, normal_vector)
vector = rs.SurfaceNormal(rs.AddPlaneSurface(plane, 1, 1), [0, 0])
unit_vector = rs.VectorUnitize(vector)
return [rs.VectorScale(unit_vector, 2), in_between_vector]
x = r * ma.sin(beta) * ma.cos(theta) * (ma.e**(theta / ma.tan(alpha)))
y = r * ma.sin(beta) * ma.sin(theta) * (ma.e**(theta / ma.tan(alpha)))
return (x, y) #对数螺旋线基本方程。
crvdomain = rs.CurveDomain(curve_object)
sections = []
t_step = (crvdomain[1] - crvdomain[0]) / sample
t = crvdomain[0]
a_step = 20 * pi / sample
a = 0
for t in rs.frange(crvdomain[0], crvdomain[1], t_step):
a = a + a_step
curvecurvature = rs.CurveCurvature(curve_object, t)
sectionplane = None
curvept = curvecurvature[0]
curvetangent = curvecurvature[1]
curveperp = (0, 0, 1)
curvenormal = rs.VectorCrossProduct(curveperp, curvetangent)
sectionplane = rs.PlaneFromFrame(curvept, curveperp, curvenormal)
if sectionplane:
coor = coorxy(a, al, be, r)
x = coor[0]
y = coor[1]
x1 = rs.VectorUnitize(curveperp)
y1 = rs.VectorUnitize(curvenormal)
pt = rs.VectorAdd(x * x1, y * y1)
secptvec = pt + curvept
secpt = rs.AddPoint(secptvec)
sections.append(secpt)
curve = rs.AddInterpCurve(sections)
def makeFireStair(rect, landingLevels):
#HARD VARIABLES
minStairWidth = 1.118
minHeadroom = 2.032
maxRunRise = 3.658
minNumRisers = 3
minGapSize = .2
minTread = .280
maxTread = .400
minRiser = .100
maxRiser = .180
thickness = .25
maxRisersInRun = 16
maxWidth = 2.4
scissorStair = False
hdrlHeight = .900
#hdrlTopExtension = .305
#hdrlBtmExtension = 1*treadDepth
#hdrlMaxProjection = .114
#(1)Determine Run Direction
rs.SimplifyCurve(rect)
rectSegments = rs.ExplodeCurves(rect)
edge1 = rectSegments[0]
edge3 = rectSegments[1]
if rs.CurveLength(edge1) > rs.CurveLength(edge3):
longEdge = edge1
shortEdge = edge3
else:
longEdge = edge3
shortEdge = edge1
longVec = rs.VectorCreate(rs.CurveStartPoint(longEdge),
rs.CurveEndPoint(longEdge))
longVecRev = rs.VectorReverse(longVec)
shortVec = rs.VectorCreate(rs.CurveStartPoint(shortEdge),
rs.CurveEndPoint(shortEdge))
shortVecRev = rs.VectorReverse(shortVec)
#(2)Stair Width
stairWidth = (rs.CurveLength(shortEdge) - minGapSize) / 2
if stairWidth < .6:
print "ERROR: Stair is ridiculously too narrow."
return
#(3)Run Length
runLength = rs.CurveLength(longEdge) - (stairWidth * 2)
if runLength < 1:
print "ERROR: Stair is ridiculously too short."
return
#LandingRect
landing1Plane = rs.PlaneFromFrame(rs.CurveStartPoint(shortEdge),
shortVecRev, longVecRev)
landing1 = rs.AddRectangle(landing1Plane, rs.CurveLength(shortEdge),
stairWidth)
landing2Plane = rs.PlaneFromFrame(rs.CurveEndPoint(longEdge), shortVec,
longVec)
landing2 = rs.AddRectangle(landing2Plane, rs.CurveLength(shortEdge),
stairWidth)
#RunRects
run1Plane = rs.PlaneFromFrame(
rs.CurveEditPoints(landing1)[3], shortVecRev, longVecRev)
run1Rect = rs.AddRectangle(run1Plane, stairWidth, runLength)
run2Plane = rs.PlaneFromFrame(
rs.CurveEditPoints(landing2)[3], shortVec, longVec)
run2Rect = rs.AddRectangle(run2Plane, stairWidth, runLength)
#(4)Num Flights between Landings
numLevels = len(landingLevels)
deltaLevels = []
runsPerLevel = []
mostRisersInRun = math.floor(runLength / minTread)
if mostRisersInRun > maxRisersInRun:
mostRisersInRun = maxRisersInRun
numRuns = 0
for i in range(0, numLevels - 1):
deltaLevels.append(landingLevels[i + 1] - landingLevels[i])
minNumRisers = math.ceil(deltaLevels[i] / maxRiser)
runsPerLevel.append(math.ceil(minNumRisers / mostRisersInRun))
numRuns = numRuns + int(runsPerLevel[i])
#(5) Which flights
listOfRuns = []
for i in range(0, numRuns):
if i % 2: #if even
listOfRuns.append(rs.CopyObject(run1Rect))
else:
listOfRuns.append(rs.CopyObject(run2Rect))
#(6) Num Treads per run
runsDeltaHeight = []
for i in range(0, numLevels - 1):
for j in range(0, int(runsPerLevel[i])):
runsDeltaHeight.append(deltaLevels[i] / runsPerLevel[i])
numRisersPerRun = []
for i in range(0, numRuns):
numRisersPerRun.append(math.ceil(runsDeltaHeight[i] / maxRiser))
#(7) Move Runs
elevation = 0
landings = []
for i in range(0, numRuns):
elevation = elevation + runsDeltaHeight[i]
translation = rs.VectorCreate([0, 0, elevation], [0, 0, 0])
rs.MoveObject(listOfRuns[i], translation)
if i % 2:
landings.append(rs.MoveObject(rs.CopyObject(landing2),
translation))
else:
landings.append(rs.MoveObject(rs.CopyObject(landing1),
translation))
#(8) Make Landings
stairGeo = []
for i in range(0, numRuns):
dir = rs.VectorCreate([0, 0, 0], [0, 0, runsDeltaHeight[i]])
#rs.MoveObject(landings[i], dir)
path = rs.AddLine([0, 0, 0], [0, 0, -thickness])
geo = rs.ExtrudeCurve(landings[i], path)
rs.CapPlanarHoles(geo)
stairGeo.append(geo)
rs.DeleteObject(path)
rs.DeleteObjects(landings)
#(9) Draw Stairs
runs = []
for i in range(0, numRuns):
runs.append(
Run(listOfRuns[i], runsDeltaHeight[i], numRisersPerRun[i],
thickness, i, maxTread))
stairGeo.append(runs[i].make())
runs[i].makeHandrail(hdrlHeight, minGapSize)
runs[i].printStats()
runs[i].cleanup()
finalGeo = rs.BooleanUnion(stairGeo, delete_input=True)
#(10) Scissor Stairs
if scissorStair:
pt0 = rs.CurveMidPoint(rectSegments[0])
pt1 = rs.CurveMidPoint(rectSegments[1])
pt2 = rs.CurveMidPoint(rectSegments[2])
pt3 = rs.CurveMidPoint(rectSegments[3])
mir1 = rs.MirrorObject(finalGeo, pt0, pt2, copy=True)
mirroredStair = rs.MirrorObject(mir1, pt1, pt3, copy=False)
#(11)Label
rs.SetUserText(finalGeo, "Brew", "Hot Coffee")
if scissorStair:
rs.SetUserText(mirroredStair, "Brew", "Hot Coffee")
#Cleanup
rs.DeleteObjects(listOfRuns)
rs.DeleteObjects(rectSegments)
rs.DeleteObject(landing1)
rs.DeleteObject(landing2)
rs.DeleteObject(run1Rect)
rs.DeleteObject(run2Rect)
print "done"
return None
import rhinoscriptsyntax as rs all = rs.AllObjects() rs.DeleteObjects(all) plane1 = rs.PlaneFromFrame([0, 0, 0], [0, 1, 0], [0, 0, 1]) plane2 = rs.PlaneFromFrame([20, 10, 10], [0, 0, 1], [0, 1, 0]) plane3 = rs.PlaneFromFrame([20, -10, 10], [0, 0, 1], [0, 1, 0]) plane4 = rs.PlaneFromFrame([40, 0, 0], [0, 0, 1], [0, 1, 0]) plane5 = rs.PlaneFromFrame([-12, 15, 35], [1, 0, .50], [0, 1, -.4]) plane6 = rs.PlaneFromFrame([0, 5, 17], [1, 0, .50], [0, 1, -.4]) #plane2 = rs.AddPlaneSurface (plane1, 50, 50) x = rs.AddPoint(-11, 15, 35) y = rs.AddPoint(1, 0, .50) z = rs.AddPoint(0, 1, -.4) j = 0 plane11 = rs.RotatePlane(plane1, 0, [0, 1, 0]) #for i in range(50): #plane11 = rs.RotatePlane(plane1, j, [0,1,0]) #j=j+10 #rs.AddRectangle( plane11, 25.0, 25.0 ) #rs.AddCircle( plane11, 25.0 ) #rs.AddSphere ( plane11, 25.0 ) #plane11 = rs.RotatePlane(plane1, j, [0,0,1]) #j=j+10 #rs.AddRectangle( plane11, 25.0, 25.0 ) #rs.AddSphere ( plane11, 50.0 )\ head = rs.AddSphere(plane11, 25.0)
arrBoxPoints = [[offsetX, offsetY, offsetZ],[offsetX + panelData[i][0].GetPanelProperty("PanelWidth"), offsetY, offsetZ],\
[offsetX, offsetY, offsetZ+panelData[i][0].GetPanelProperty("PanelHeight")],\
[offsetX + panelData[i][0].GetPanelProperty("PanelWidth"), offsetY, offsetZ+panelData[i][0].GetPanelProperty("PanelHeight")]]
blockCount = len(
panelData[i][0].GetPanelProperty("BlockInstances"))
panelCounter += blockCount
#create text info
if drawGeometry:
panelName = panelName.replace(" ", "\n\r", 1)
prevLayer = rs.CurrentLayer()
if not rs.IsLayer("GEO::_Canvas"):
rs.AddLayer("GEO::_Canvas")
rs.CurrentLayer("GEO::_Canvas")
txtPlane = rs.PlaneFromFrame(
rs.PointSubtract(arrBoxPoints[0],
[0, 0, rowSeparation / 2]), (1, 0, 0),
(0, 0, 1))
textTypes.append(
rs.AddText(panelName + "\n\rCount: " + str(blockCount),
txtPlane,
fontHeight,
font_style=fontStyle))
rs.CurrentLayer(prevLayer)
#create panel copy
Mockup_Bay.append(SGLibPanel())
Mockup_Bay[len(Mockup_Bay) - 1].Copy(panelData[i][0])
panelPoints = Mockup_Bay[len(Mockup_Bay) - 1].GetPanelProperty(
"PanelCornerPoints")
alignXform = rc.Geometry.Transform.Translation(
-min(panelPoints[0].X, panelPoints[2].X), 0, 0)
tmpBoxPts = rs.PointArrayTransform(arrBoxPoints, alignXform)
def ImportNearMaps():
try:
def scale():
system = rs.UnitSystem()
if system == 2 or system == 3 or system == 4:
scaleFactorDict = {2: 1000, 3: 100, 4: 1}
scaleFactor = scaleFactorDict[system]
return scaleFactor
if system != 2 or system != 3 or system != 4:
return None
def get_image_size(fname):
'''Determine the image type of fhandle and return its size.
from draco'''
with open(fname, 'rb') as fhandle:
head = fhandle.read(24)
if len(head) != 24:
return
if imghdr.what(fname) == 'png':
check = struct.unpack('>i', head[4:8])[0]
if check != 0x0d0a1a0a:
return
width, height = struct.unpack('>ii', head[16:24])
elif imghdr.what(fname) == 'gif':
width, height = struct.unpack('<HH', head[6:10])
elif imghdr.what(fname) == 'jpeg':
try:
fhandle.seek(0) # Read 0xff next
size = 2
ftype = 0
while not 0xc0 <= ftype <= 0xcf:
fhandle.seek(size, 1)
byte = fhandle.read(1)
while ord(byte) == 0xff:
byte = fhandle.read(1)
ftype = ord(byte)
size = struct.unpack('>H', fhandle.read(2))[0] - 2
# We are at a SOFn block
fhandle.seek(1, 1) # Skip `precision' byte.
height, width = struct.unpack('>HH', fhandle.read(4))
except Exception: # IGNORE:W0703
return
else:
return
return width, height
if scale() == None:
rs.MessageBox(
"This tool is can only be used in mm, cm or m model units")
return None
factor = scale()
# Find and open jgw file, extract scalefactor and x and y coordinates
jgw = rs.OpenFileName(title='Select .JGW file',
filter="JGW Files (*.JGW)|*.JGW||")
with open(jgw, 'rt') as f:
numslist = f.read().splitlines()
scaleFactor01 = numslist[0]
worldx = float(numslist[4]) * int(factor)
worldy = float(numslist[5]) * int(factor)
# Find and open jpg file, extract pixel size
jpg = rs.OpenFileName(title='Select .JPG image File',
filter="JPG Files (*.JPG)|*.JPG||")
size = get_image_size(jpg)
scaleFactor02 = (float(size[0]) * int(factor))
scaleFactor03 = (float(size[1]) * int(factor))
# Calculate scale factor
scaleFactorWidth = (float(scaleFactor01)) * (float(scaleFactor02))
scaleFactorHeight = (float(scaleFactor01)) * (float(scaleFactor03))
origin = (float(worldx), (float(worldy) - float(scaleFactorHeight)), 0)
picturePlane = rs.PlaneFromFrame(origin, (1, 0, 0), (0, 1, 0))
rs.AddPictureFrame(picturePlane,
jpg,
width=(float(scaleFactorWidth)),
height=(float(scaleFactorHeight)))
except:
print("Failed to execute")
rs.EnableRedraw(True)
return
def RedrawNetwork(path):
# open text file
m = open(path, 'r')
# read first line of text file; length of the domain
l = m.readline()
# convert length to float
length = float(l)
# read the second line of the domain; shape of the fracture
shape = m.readline().split()
#corners = ([(0,0,0),(length,0,0),(length,length,0),(0,length,0),(0,0,length),(length,0,length),(length,length,length),(0,length,length)])
#rs.AddBox(corners)
# create the domain
dom = Domain.Domain(length)
# display the domain
dom.Show()
if shape[0] != 'polygon':
# a list to store GUIDs of regenerated fractures
frac_list = []
# list to store the x_axis of the fracture plane
x_axis = []
# list to store the y_axis of the fracture plane
y_axis = []
# list to store the origin of the fracture location
origin = []
# list to store the size of fracture
size = []
# read file line by line
for line in m:
# split line by comma
words = line.split(",")
#if words[0] != 'circle':
# append the origin, x_axis and y_axis values in each line
origin.append(float(words[0]))
origin.append(float(words[1]))
origin.append(float(words[2]))
x_axis.append(float(words[3]))
x_axis.append(float(words[4]))
x_axis.append(float(words[5]))
y_axis.append(float(words[6]))
y_axis.append(float(words[7]))
y_axis.append(float(words[8]))
size.append(float((words[9])))
# if the shape is ellipse, we have two radii, so append the second radius
if shape[0] == 'ellipse':
size.append(float((words[10])))
# close file
m.close()
# display fractures if they are circles/disks
if shape[0] == 'circle':
n = 0
# go through the lists of origin, x_axis and y_axis
# we divide by 3, because the list contains 3 consecutive values
# representing a single origin, x_axis or y_axis
for i in range(int(len(origin) / 3)):
# lists to store the origin, x_axis and y_axis of each fracture
o = []
x = []
y = []
# append the origin, x_axis and y_axis of each fracture
for j in range(3):
o.append(origin[n + j])
x.append(x_axis[n + j])
y.append(y_axis[n + j])
# convert the origin, x_axis and y_axis to a plane
plane = rs.PlaneFromFrame(o, x, y)
# name the current layer
# we are creating layers so that we can trim out of bounds fractures
# the function that does this makes use of the layer names
layer_name = "FRACTURE_" + str(i + 1)
# give the layer a color
rs.AddLayer(layer_name, rs.CreateColor(0, 255, 0))
# make layer the current layer
rs.CurrentLayer(layer_name)
# draw fracture
my_disk = rs.AddCircle(plane, size[i])
# convert to a surface
surf = rs.AddPlanarSrf(my_disk)
#delete initial fracture drawn which is a curve
rs.DeleteObject(my_disk)
# append fracture
frac_list.append(surf)
# increment n used for parsing
n += 3
# trim out of bounds fractures
# the function all creates new fractures at the locations of all
# exixting fractures
dom.RemoveSurfacesOutsideOfBox(length)
# delete all old fractures
for frac in frac_list:
rs.DeleteObject(frac)
dom_frac = dom.my_fractures #get the fractures in the domain
#print(dom_frac)
#swap old guids with new ones and put new guids in old frac layers
#new_frac_guids = Frac.NewFracturesGuids(dom_frac,frac_list)
# display fractures if they are ellipse
if shape[0] == 'ellipse':
# lists to store the origin, x_axis and y_axis of each fracture
n = 0
p = 0
q = 1
# go through the lists of origin, x_axis and y_axis
# we divide by 3, because the list contains 3 consecutive values
# representing a single origin, x_axis or y_axis
for i in range(int(len(origin) / 3)):
o = []
x = []
y = []
# append the origin, x_axis and y_axis of each fracture
for j in range(3):
o.append(origin[n + j])
x.append(x_axis[n + j])
y.append(y_axis[n + j])
# convert the origin, x_axis and y_axis to a plane
plane = rs.PlaneFromFrame(o, x, y)
# name the current layer
# we are creating layers so that we can trim out of bounds fractures
# the function that does this makes use of the layer names
layer_name = "FRACTURE_" + str(i + 1)
# give the layer a color
rs.AddLayer(layer_name, rs.CreateColor(0, 255, 0))
# make layer current layer
rs.CurrentLayer(layer_name)
# draw fracture
my_frac = rs.AddEllipse(plane, size[i + p], size[i + q])
# convert to a surface from curve
surf = rs.AddPlanarSrf(my_frac)
# delete initial fracture drawn which is a curve
rs.DeleteObject(my_frac)
# append fracture
frac_list.append(surf)
# increment varaiables used for parsing
n += 3
p += 1
q += 1
# trim out of bounds fractures
dom.RemoveSurfacesOutsideOfBox(length)
# delete old fractures
for frac in frac_list:
rs.DeleteObject(frac)
dom_frac = dom.my_fractures
if shape[0] == 'polygon':
# list to store origin
origin = []
# list to store number of sides of each polygon
size = []
# list to store number of angle of deviation of each polygon
angle = []
# list to store fractures
frac_list = []
# list to store points
points = []
for line in m:
# split each line by comma
words = line.split(",")
# store the number of sides of the polygon
size.append(float(words[-1]))
# store the angle of deviation
angle.append(float(words[-2]))
# stpre the origin
origin.extend(
(float(words[-5]), float(words[-4]), float(words[-3])))
# length of all points on the line
# this will ensure we capture lines with disparate points when
# generating polygon of different sides
ex = int(3 * (size[-1] + 1))
# store all points on the line
points.extend((words[:ex]))
# close file
m.close()
# variables to use for parsing
n = 0
m = 0
# iterate for the number of fractures generated
for i in range(len(size)):
# list to store points and origin
o = []
p = []
# get the origin of the fracture
for j in range(3):
o.append(origin[n + j])
# variable for parsing
r = 0
# get the points of fracture edges
for k in range(int(size[i]) + 1):
p.append([])
for l in range(3):
p[k].append(float(points[m + l + r]))
# increment r
r += 3
# increment parsing variables
m += ((int(size[i]) + 1) * 3)
n += 3
# name the current layer
# we are creating layers so that we can trim out of bounds fractures
# the function that does this makes use of the layer names
layer_name = "FRACTURE_" + str(i + 1)
# give the layer a color
rs.AddLayer(layer_name, rs.CreateColor(0, 255, 0))
# make layer the current layer
rs.CurrentLayer(layer_name)
# joing the points
poly = rs.AddPolyline(p)
# roatate the fracture
frac = rs.RotateObject(poly, o, angle[i], [0, 1, 0])
# convert to a surface
surf = rs.AddPlanarSrf(frac)
#delete initial fracture drawn which is a curve
rs.DeleteObject(frac)
frac_list.append(surf)
# trim out of bounds fractures
# the function all creates new fractures at the locations of all
# exixting fractures
dom.RemoveSurfacesOutsideOfBox(length)
# delete all old fractures
for fr in frac_list:
rs.DeleteObject(fr)
dom_frac = dom.my_fractures
return dom_frac
# Load the Optitrack CSV file parser module.
import optitrack.csv_reader as csv
from optitrack.geometry import *
# Find the path to the test data file located alongside the script.
filename = os.path.join( os.path.abspath(os.path.dirname(__file__)), "sample_optitrack_take.csv")
# Read the file.
take = csv.Take().readCSV(filename)
# Print out some statistics
print "Found rigid bodies:", take.rigid_bodies.keys()
# Process the first rigid body into a set of planes.
bodies = take.rigid_bodies.values()
# for now:
xaxis = [1,0,0]
yaxis = [0,1,0]
if len(bodies) > 0:
body = bodies[0]
for pos,rot in zip(body.positions, body.rotations):
if pos is not None and rot is not None:
xaxis, yaxis = quaternion_to_xaxis_yaxis(rot)
plane = rs.PlaneFromFrame(pos, xaxis, yaxis)
# create a visible plane, assuming units are in meters
rs.AddPlaneSurface( plane, 0.1, 0.1 )
depth = 2.133
currentl = rs.CurrentLayer("Heel_0")
copy0 = rs.CopyObject(hull)
rs.ObjectLayer(copy0, "Heel_0")
rs.LayerVisible("Default", False)
#####################################################
#### ####
#### Creating DWL and obtaining submerged volume ####
#### ####
#####################################################
aux_plane = rs.PlaneFromFrame( [-5,-50,draft], [1,0,0], [0,1,0] )
dwl = rs.AddPlaneSurface(aux_plane, 100, 100)
inter = rs.BooleanIntersection(copy0, dwl, False)
Nabla = rs.SurfaceVolumeCentroid(inter)
if Nabla:
cb = rs.AddPoint(Nabla[0])
Volume0 = rs.SurfaceVolume(inter)
Initial_Volume = Volume0[0]
####################################
#### ####
#### Heeled volume calculations ####
#### ####
def makeFireStair(rect, landingLevels):
#HARD VARIABLES
minGapSize = .2
minTread = .260
maxRiser = .180
thickness = .15
#(1)Determine Run Direction
rs.SimplifyCurve(rect)
rectSegments = rs.ExplodeCurves(rect)
edge1 = rectSegments[0]
edge3 = rectSegments[1]
rs.DeleteObject(rectSegments[2])
rs.DeleteObject(rectSegments[3])
if rs.CurveLength(edge1) > rs.CurveLength(edge3):
longEdge = edge1
shortEdge = edge3
else:
longEdge = edge3
shortEdge = edge1
longVec = rs.VectorCreate(rs.CurveStartPoint(longEdge),
rs.CurveEndPoint(longEdge))
longVecRev = rs.VectorReverse(longVec)
shortVec = rs.VectorCreate(rs.CurveStartPoint(shortEdge),
rs.CurveEndPoint(shortEdge))
shortVecRev = rs.VectorReverse(shortVec)
rs.CurveArrows(longEdge, 2)
rs.CurveArrows(shortEdge, 2)
#(2)Stair Width
stairWidth = (rs.CurveLength(shortEdge) - minGapSize) / 2
#LandingRect
landing1Plane = rs.PlaneFromFrame(rs.CurveStartPoint(shortEdge),
shortVecRev, longVecRev)
landing1 = rs.AddRectangle(landing1Plane,
rs.CurveLength(shortEdge), stairWidth)
landing2Plane = rs.PlaneFromFrame(rs.CurveEndPoint(longEdge),
shortVec, longVec)
landing2 = rs.AddRectangle(landing2Plane,
rs.CurveLength(shortEdge), stairWidth)
#(3)Run Length
runLength = rs.CurveLength(longEdge) - (stairWidth * 2)
#RunRects
run1Plane = rs.PlaneFromFrame(
rs.CurveEditPoints(landing1)[3], shortVecRev, longVecRev)
run1Rect = rs.AddRectangle(run1Plane, stairWidth, runLength)
run2Plane = rs.PlaneFromFrame(
rs.CurveEditPoints(landing2)[3], shortVec, longVec)
run2Rect = rs.AddRectangle(run2Plane, stairWidth, runLength)
#(4)Num Flights between Landings
numLevels = len(landingLevels)
deltaLevels = []
runsPerLevel = []
maxRisersPerRun = math.floor(runLength / minTread)
numRuns = 0
for i in range(0, numLevels - 1):
deltaLevels.append(landingLevels[i + 1] - landingLevels[i])
minNumRisers = math.ceil(deltaLevels[i] / maxRiser)
runsPerLevel.append(math.ceil(minNumRisers / maxRisersPerRun))
numRuns = numRuns + int(runsPerLevel[i])
#(5) Which flights
listOfRuns = []
for i in range(0, numRuns):
if i % 2: #if even
listOfRuns.append(rs.CopyObject(run1Rect))
else:
listOfRuns.append(rs.CopyObject(run2Rect))
#(6) Num Treads per run
runsDeltaHeight = []
for i in range(0, numLevels - 1):
for j in range(0, int(runsPerLevel[i])):
runsDeltaHeight.append(deltaLevels[i] / runsPerLevel[i])
numRisersPerRun = []
for i in range(0, numRuns):
numRisersPerRun.append(math.ceil(runsDeltaHeight[i] /
maxRiser))
#(7) Move Runs
elevation = 0
landings = []
for i in range(0, numRuns):
elevation = elevation + runsDeltaHeight[i]
translation = rs.VectorCreate([0, 0, elevation], [0, 0, 0])
rs.MoveObject(listOfRuns[i], translation)
if i % 2:
landings.append(
rs.MoveObject(rs.CopyObject(landing2), translation))
else:
landings.append(
rs.MoveObject(rs.CopyObject(landing1), translation))
#(8) Make Landings
stairGeo = []
for i in range(0, numRuns):
dir = rs.VectorCreate([0, 0, 0], [0, 0, runsDeltaHeight[i]])
#rs.MoveObject(landings[i], dir)
path = rs.AddLine([0, 0, 0], [0, 0, -thickness])
geo = rs.ExtrudeCurve(landings[i], path)
rs.CapPlanarHoles(geo)
stairGeo.append(geo)
rs.DeleteObject(path)
rs.DeleteObjects(landings)
#(9) Draw Stairs
runs = []
for i in range(0, numRuns):
runs.append(
Run(listOfRuns[i], runsDeltaHeight[i], numRisersPerRun[i]))
stairGeo.append(runs[i].make())
finalGeo = rs.BooleanUnion(stairGeo, delete_input=True)
#Cleanup
rs.DeleteObjects(listOfRuns)
rs.DeleteObjects(rectSegments)
rs.DeleteObject(landing1)
rs.DeleteObject(landing2)
rs.DeleteObject(run1Rect)
rs.DeleteObject(run2Rect)
print "done"
return finalGeo
def outbox(self, gap):
#DEFINE BASE SLICE------------>
rec_lr = rs.AddRectangle(rs.WorldYZPlane(), self.data[0], self.data[1])
srf_lr = rs.AddPlanarSrf(rec_lr)
rec_lr = rs.MoveObject(
rec_lr, rs.VectorCreate(ZERO,
rs.SurfaceAreaCentroid(srf_lr)[0]))
rs.DeleteObject(srf_lr)
rec_lr = cutrec(2, rec_lr, gap)
srf_lr = rs.AddPlanarSrf(rec_lr)
rs.DeleteObjects(rec_lr)
### CANNOT USE WORLDZX()---------->
xz = rs.PlaneFromFrame([0, 0, 0], [1, 0, 0], [0, 0, 1])
rec_fk = rs.AddRectangle(xz, self.data[2], self.data[3])
###<-------------
srf_fk = rs.AddPlanarSrf(rec_fk)
rec_fk = rs.MoveObject(
rec_fk, rs.VectorCreate(ZERO,
rs.SurfaceAreaCentroid(srf_fk)[0]))
rs.DeleteObject(srf_fk)
rec_fk = cutrec(2, rec_fk, gap)
srf_fk = rs.AddPlanarSrf(rec_fk)
rs.DeleteObjects(rec_fk)
rec_tb = rs.AddRectangle(rs.WorldXYPlane(), self.data[5], self.data[4])
srf_tb = rs.AddPlanarSrf(rec_tb)
rec_tb = rs.MoveObject(
rec_tb, rs.VectorCreate(ZERO,
rs.SurfaceAreaCentroid(srf_tb)[0]))
rs.DeleteObject(srf_tb)
rec_tb = cutrec(1, rec_tb, 0)
srf_tb = rs.AddPlanarSrf(rec_tb)
rs.DeleteObject(rec_tb)
#CONSTRUCT THE BOX-------------------->
srfs = []
srfs.append(rs.CopyObject(srf_tb, [0, 0, self.data[3] / 2.0]))
srfs.append(rs.CopyObject(srf_tb, [0, 0, self.data[3] / (-2.0)]))
srfs.append(rs.CopyObject(srf_fk, [0, self.data[0] / 2.0, 0]))
srfs.append(
rs.MirrorObject(
rs.CopyObject(srf_fk, [0, self.data[0] / (-2.0), 0]),
[0, 1, 0], [0, 0, 1]))
srfs.append(rs.CopyObject(srf_lr, [self.data[5] / (-2.0), 0, 0]))
srfs.append(
rs.MirrorObject(
rs.CopyObject(srf_lr, [self.data[5] / (2.0), 0, 0]), [1, 0, 0],
[0, 0, 1]))
bele = []
for srf in srfs:
extvec = rs.VectorCreate(ZERO, rs.SurfaceAreaCentroid(srf)[0])
max, sign, loc = 0, -1, 0
for i in range(len(extvec)):
if abs(extvec[i]) > max:
max = abs(extvec[i])
sign = extvec[i]
loc = i
if loc == 0:
line = rs.AddLine(
ZERO, rs.VectorScale(rs.VectorUnitize([sign, 0, 0]), cut2))
bele.append(rs.ExtrudeSurface(srf, line))
elif loc == 1:
line = rs.AddLine(
ZERO, rs.VectorScale(rs.VectorUnitize([0, sign, 0]), cut2))
bele.append(rs.ExtrudeSurface(srf, line))
elif loc == 2:
line = rs.AddLine(
ZERO, rs.VectorScale(rs.VectorUnitize([0, 0, sign]), cut2))
bele.append(rs.ExtrudeSurface(srf, line))
rs.DeleteObject(line)
rs.DeleteObjects(srfs)
rs.DeleteObjects([srf_lr, srf_fk, srf_tb])
return bele
import rhinoscriptsyntax as rs all = rs.AllObjects() rs.DeleteObjects(all) plane1 = rs.PlaneFromFrame([0, 0, 0], [0, 1, 0], [1, 0, 0]) plane2 = rs.PlaneFromFrame([0, 0, 6], [0, 1, 0], [1, 0, 0]) plane3 = rs.PlaneFromFrame([0, 0, 40], [0, 1, 0], [1, 0, 0]) nose = rs.AddCone(plane2, 6, 20, cap=True) nose2 = rs.AddCone(plane3, 24, 5, cap=True) hat1 = rs.AddCylinder(plane1, 110, 20, cap=True) hat2 = rs.AddCylinder(plane1, -6, 10, cap=True) hat3 = rs.AddCylinder(plane2, -10, 12, cap=True) ##neck=rs.AddCylinder ((0,0,-35), 10, 5, cap=True)
