def RunCommand(is_interactive):
global params
center = rs.GetPoint(message="Select center point")
n = rs.GetInteger(message="Number of teeth", number=params["n"], minimum=4)
r = rs.GetReal(message="Outside Diameter", number=params["r"])
m = rs.GetReal(message="Gear module", number=params["m"])
pa = rs.GetReal(message="Pressure angle",
number=params["pa"],
minimum=0,
maximum=45)
bool_opts = rs.GetBoolean(message="Output options",
items=(("PitchCircle", "No", "Yes"), ),
defaults=(params["pc"], ))
if None in [center, n, m, pa, bool_opts]:
return 1 # Cancel
pc = bool_opts[0]
params["n"] = n
params["m"] = m
params["r"] = r
params["pa"] = pa
params["pc"] = pc
cplane = rs.ViewCPlane() # Get current CPlane
cplane = rs.MovePlane(cplane, center)
xform = rs.XformChangeBasis(cplane, rs.WorldXYPlane())
rs.EnableRedraw(False)
old_plane = rs.ViewCPlane(plane=rs.WorldXYPlane())
gear = generate_gear_crv_with_outside(teeth=params["n"],
module=params["m"],
outside_diam=params["r"],
pressure_angle=params["pa"])
rs.ViewCPlane(plane=old_plane)
rs.TransformObjects(gear, xform)
rs.EnableRedraw(True)
if pc:
circle = generate_pitch_circle_crv(teeth=params["n"],
module=params["m"])
rs.TransformObjects(circle, xform)
rs.SelectObjects([gear, circle])
else:
rs.SelectObjects(gear)
return 0 # Success
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 drawDivisionLine(emblem, color=True):
objs = []
# line
r = 24
for i in range(int(emblem.division)):
p = [r, 0, 0]
if (emblem.division % 4 == 0):
angle = i * 360.0 / emblem.division + 360.0 / emblem.division / 2.0
else:
angle = i * 360.0 / emblem.division
p = rs.VectorRotate(p, angle, [0, 0, 1])
obj = rs.AddLine([0, 0, 0], p)
if (color):
layer = "line%s" % (i % int(emblem.division / 2.0))
else:
layer = "lineGray"
rs.ObjectLayer(obj, layer)
objs.append(obj)
# circle
obj = rs.AddCircle([0, 0, 0], r)
if (color):
layer = "lineBlack"
else:
layer = "lineGray"
rs.ObjectLayer(obj, layer)
objs.append(obj)
# text
planeOri = rs.ViewCPlane()
for i in range(int(emblem.division / 2.0)):
if (emblem.division % 4 == 0):
angle = i * 360.0 / emblem.division + 360.0 / emblem.division / 2.0
else:
angle = i * 360.0 / emblem.division
p = [r, 0, 0]
txt = "%d" % (angle)
height = 1.2
pt = [0, height / 2.0, 0]
font_style = 0
justification = 2 + 65536
obj = rs.AddText(txt, pt, height, font, font_style, justification)
rs.RotateObject(obj, [0, 0, 0], -90.0, [0, 0, 1], False)
rs.MoveObject(obj, [r, 0, 0])
rs.RotateObject(obj, [0, 0, 0], angle, [0, 0, 1], False)
rs.ObjectLayer(obj, "textLine")
objs.append(obj)
rs.ViewCPlane(None, planeOri)
#return
return objs
def makeEngraves(m, obj):
tool_id = m.group(1)
operation = m.group(2)
z_pos = m.group(3)
#restore view cplane
p1 = rs.WorldXYPlane()
rs.ViewCPlane(None, p1)
subtracts = []
if operation == 'Engrave':
# return sweepVolume(obj, tool_id, z_pos)
subcurves = rs.ExplodeCurves(obj, True)
if subcurves:
for crv in subcurves:
vol = sweepVolume(crv, tool_id, z_pos)
if vol:
subtracts += vol
result = rs.BooleanUnion(subtracts)
return result
def main():
print 'test'
objs = rs.GetObjects()
vec_x = [10,0,0]
# restore viewport Cplane
p1 = rs.WorldXYPlane()
rs.ViewCPlane(None, p1)
for obj in objs:
if rs.IsBlockInstance(obj) and rs.BlockInstanceName(strObject):
xform1 = rs.BlockInstanceXform(obj)
crv = rs.AddCurve([ [0,0,0], [0,300,0] ])
xfrom1_inv = rs.TransformObject( crv, (xform1) )
rs.SelectObject(crv)
vec1 = rs.CurveEndPoint(crv) - rs.CurveStartPoint(crv)
print vec1, math.degrees(calcAngle(vec1, vec_x))
if __name__ == "__main__":
main();
def makeEngraves(tool_id, operation, z_pos, obj):
#restore view cplane
p1 = rs.WorldXYPlane()
rs.ViewCPlane(None, p1)
subtracts = []
# return [sweepVolume(obj, tool_id, z_pos)]
subcurves = rs.ExplodeCurves(obj, False)
if subcurves:
rs.DeleteObject(obj)
for crv in subcurves:
volumes = sweepVolume(crv, tool_id, z_pos)
if not volumes or len(volumes) < 1:
rs.MessageBox('Error with %s, %s, %s' % (tool_id, operation, z_pos))
for vol in volumes:
subtracts.append( vol )
else:
volumes = sweepVolume(obj, tool_id, z_pos)
if not volumes or len(volumes) < 1:
rs.MessageBox('Error with %s, %s, %s' % (tool_id, operation, z_pos))
for vol in volumes:
subtracts.append( vol )
return subtracts
def profile2(plane, vec):
rs.ViewCPlane(None, plane)
sec = rs.AddLine((0, 0, 0), (louverW, 0, 0))
sec = rs.RotateObject(sec, plane.Origin, 45.0, plane.ZAxis, copy=True)
# if sec: rs.DeleteObjects(sec)
return sec
def transformMatrix():
obj_ids = rs.GetObjects("Select object(s) from which to create matrix", 0,
True, True)
if obj_ids is None: return
box = rs.BoundingBox(obj_ids)
if not isinstance(box, list): return
origin = rs.PointDivide(rs.PointAdd(box[0], box[6]), 2)
endpt = rs.GetPoint("To point")
newpt = [1, 1, 1]
translation1 = rs.VectorCreate(endpt, newpt)
translation2 = rs.VectorCreate(translation1, origin)
copied_obj_ids = rs.CopyObjects(obj_ids, translation2)
for obj in copied_obj_ids:
matrix = []
degrees = 90.0 # Some angle
radians = math.radians(degrees)
c = math.cos(radians)
s = math.sin(radians)
matrix.append([c, -s, 0, 0])
matrix.append([s, c, 0, 0])
matrix.append([0, 0, 1, 0])
matrix.append([0, 0, 0, 1])
pprint.pprint(matrix)
rs.ScaleObject(obj, newpt, [3, 1, -9])
plane = rs.ViewCPlane()
pprint.pprint(plane)
rs.RotateObject(obj, newpt, uniform(0, 360), plane.XAxis)
rs.RotateObject(obj, newpt, uniform(0, 360), plane.YAxis)
rs.RotateObject(obj, newpt, uniform(0, 360), plane.ZAxis)
def RunCommand(is_interactive):
ringSize = rs.GetReal("Ring size", 8.5, 0, 16)
center = rs.GetPoint("Location")
plane = rs.MovePlane(rs.ViewCPlane(), center)
radius = (11.63 + 0.8128 * ringSize) * 0.5
objId = rs.AddCircle(plane, radius)
rs.SelectObject(objId)
def cPlaneLvl():
userstr = rs.GetDocumentUserText("levels")
objdict = ast.literal_eval(userstr)
for i in objdict:
lvlname = i["level"]
elevation = float(i["elevation"])
newplane = rs.CreatePlane((0, 0, elevation))
rs.ViewCPlane(None, newplane)
rs.AddNamedCPlane(lvlname)
def Orthographic_Cplane():
cpln_current = rs.ViewCPlane()
Bool_Osnap = rs.Osnap()
point = cpln_current.Origin
if Bool_Osnap:
rs.Osnap(False)
rs.Command("_Circle 0,0,0 ")
#
rs.EnableRedraw(False)
#
Circle = rs.LastCreatedObjects()
if Bool_Osnap:
rs.Osnap(True)
if Circle is None:
#
rs.EnableRedraw(True)
#
return
if not rs.IsObject(Circle):
rs.EnableRedraw(True)
return
rs.Command("_Point 0,0,1 ")
pt_pos = rs.LastCreatedObjects()
rs.Command("_Point 0,0,-1 ")
pt_neg = rs.LastCreatedObjects()
pt_cam = rs.ViewCamera()
dist_pos = rs.Distance(pt_cam,pt_pos)
dist_neg = rs.Distance(pt_cam,pt_neg)
print pt_cam
Disk = rs.AddPlanarSrf(Circle)
rs.UnselectAllObjects()
rs.SelectObjects(Disk)
if dist_pos>dist_neg:
rs.Command("OrientCameraToSrf _f 0,0,0 _pause")
else:
rs.Command("OrientCameraToSrf 0,0,0 _pause")
rs.DeleteObjects((pt_pos,pt_neg,Circle,Disk))
rs.ViewProjection(None,1)
def Func(crvID):
if rs.IsLine(crvID): plane = rs.ViewCPlane()
else: plane = rs.CurvePlane(crvID)
crv = sc.doc.Objects.Find(crvID).Geometry
# if t_style==1: trans=Rhino.Geometry.CurveOffsetCornerStyle.Sharp
# elif t_style==2: trans=Rhino.Geometry.CurveOffsetCornerStyle.Round
# elif t_style==3: trans=Rhino.Geometry.CurveOffsetCornerStyle.Smooth
# elif t_style==4: trans=Rhino.Geometry.CurveOffsetCornerStyle.Chamfer
offset1 = crv.Offset(plane, dist, tol, trans)
offset1ID = sc.doc.Objects.AddCurve(offset1[0])
def CreateCircle(circumference=None):
center = rs.GetPoint("Center point of circle")
if center:
plane = rs.MovePlane(rs.ViewCPlane(), center)
length = circumference
if length is None: length = rs.GetReal("Circle circumference")
if length and length > 0:
radius = length / (2 * math.pi)
objectId = rs.AddCircle(plane, radius)
rs.SelectObject(objectId)
return length
return None
def main():
rs.AddLayer("laydown")
while True:
panel, face = getsubsurface.GetSubSurface("select down face")
if panel is None or face is None:
break
# compute the plane
normal = rs.VectorUnitize(rs.SurfaceNormal(face, (0.5,0.5)))
plane = rs.PlaneFromNormal(rs.EvaluateSurface(face, 0.5, 0.5), normal)
rs.ViewCPlane(plane=plane)
box = rs.BoundingBox(face, rs.ViewCPlane(), in_world_coords=True)
proj_coords = [rs.SurfaceClosestPoint(face, coord) + (0,) for coord in box]
laydown = rs.OrientObject(panel, box[0:3], proj_coords[0:3], flags=1)
rs.ObjectLayer(laydown, "laydown")
rs.DeleteObject(face)
rs.HideObject(panel)
def main():
to_delete = []
rs.ProjectOsnaps(False)
positive_object = rs.GetObject("select positive object", 16)
negative_object = rs.GetObject("select negative object", 16)
rs.HideObject(negative_object)
polysurface, face = GetSubSurface("select tenon surface")
to_delete.append(face)
normal = rs.VectorUnitize(rs.SurfaceNormal(face, (0.5, 0.5)))
plane = rs.PlaneFromNormal(rs.EvaluateSurface(face, 0.5, 0.5), normal)
rs.ViewCPlane(plane=plane)
rs.ProjectOsnaps(True)
tenon_rects = rs.GetObjects(message="select tenon curves", filter=4)
tenon_faces = []
for rect in tenon_rects:
tenon_faces.append(rs.AddPlanarSrf(rect)[0])
rs.ShowObject(negative_object)
rs.ProjectOsnaps(False)
height_pt = rs.GetPoint("enter height point")
# compule a vector normal to plane of the desired height
extrude_vec_a = rs.EvaluateSurface(face, 0.5, 0.5)
dist = rs.DistanceToPlane(plane, height_pt)
extrude_vec_b = [dist * el for el in normal]
extrude_vec_b = rs.VectorAdd(extrude_vec_a, extrude_vec_b)
extrude_curve = rs.AddCurve((extrude_vec_a, extrude_vec_b))
to_delete.append(extrude_curve)
tenons = []
for tenon_face in tenon_faces:
tenon = rs.ExtrudeSurface(tenon_face, extrude_curve)
tenons.append(tenon)
rs.BooleanUnion([positive_object] + tenons, delete_input=False)
rs.BooleanDifference([negative_object], tenons, delete_input=False)
to_delete.append(positive_object)
to_delete.append(negative_object)
rs.DeleteObjects(to_delete)
rs.DeleteObjects(tenon_faces)
rs.DeleteObjects(tenons)
def convertTextToPolylines2(obj):
# get object properties
text = rs.TextObjectText(obj)
pt = rs.TextObjectPoint(obj)
origin = rs.coerce3dpoint([0, 0, 0])
ht = rs.TextObjectHeight(obj)
object_layer = rs.ObjectLayer(obj)
plane = rs.TextObjectPlane(obj)
diff = rs.coerce3dpoint([pt.X, pt.Y, pt.Z])
p1 = rs.WorldXYPlane()
#restore view cplane
rs.ViewCPlane(None, p1)
matrix = rs.XformRotation4(p1.XAxis, p1.YAxis, p1.ZAxis, plane.XAxis,
plane.YAxis, plane.ZAxis)
rs.DeleteObject(obj)
# split text at enters
text = text.split('\r\n')
opts = 'GroupOutput=No FontName="' + EXPORT_FONT + '" Italic=No Bold=No Height=' + str(
ht)
opts += " Output=Curves AllowOpenCurves=Yes LowerCaseAsSmallCaps=No AddSpacing=No "
n_lines = len(text)
origin.Y += 1.6 * ht * (len(text) - 1)
polylines = []
for item in text:
rs.Command(
"_-TextObject " + opts + '"' + item + '"' + " " + str(origin),
False)
polylines += rs.LastCreatedObjects()
origin.Y -= ht * 1.6
rs.ObjectLayer(polylines, object_layer)
polylines = rs.ScaleObjects(polylines, (0, 0, 0), (0.7, 1, 1), True)
# transform to old position
rs.TransformObjects(polylines, matrix, copy=False)
rs.MoveObjects(polylines, diff)
return polylines
def OffsetCurve2Sides(crvID, dist, t_style, conn, tol):
if rs.IsLine(crvID): plane = rs.ViewCPlane()
else: plane = rs.CurvePlane(crvID)
crv = sc.doc.Objects.Find(crvID).Geometry
if t_style == 1: trans = Rhino.Geometry.CurveOffsetCornerStyle.Sharp
elif t_style == 2: trans = Rhino.Geometry.CurveOffsetCornerStyle.Round
elif t_style == 3: trans = Rhino.Geometry.CurveOffsetCornerStyle.Smooth
elif t_style == 4: trans = Rhino.Geometry.CurveOffsetCornerStyle.Chamfer
offset1 = crv.Offset(plane, dist, tol, trans)
if offset1:
offset2 = crv.Offset(plane, -dist, tol, trans)
if offset2:
if len(offset1) == 1 and len(offset2) == 1:
offset1ID = sc.doc.Objects.AddCurve(offset1[0])
offset2ID = sc.doc.Objects.AddCurve(offset2[0])
if conn >= 0 and not rs.IsCurveClosed(crvID):
AddEndsToOffset(offset1ID, offset2ID, conn, dist)
#don't care if ends get made or not, exit afterward
return True
def ProjectPlan(objs, plane):
print "Projecting Plan"
try:
rs.SelectObjects(objs)
except:
rs.SelectObject(objs)
rs.AddNamedCPlane('c_prev')
rs.AddNamedCPlane('c_temp')
rs.ViewCPlane(plane=plane)
rs.Command('-_Make2d l c p f _Enter', False)
projLines = rs.SelectedObjects()
rs.DeleteNamedCPlane('c_temp')
rs.RestoreNamedCPlane('c_prev')
rs.DeleteNamedCPlane('c_prev')
for line in projLines:
rs.ObjectColor(line, (200, 200, 200))
return projLines
def main():
# get objects to export
objs = rs.GetObjects("select objects to move to worldXY", 0, True, True)
if not objs:
print "moveToXY aborted"
return
rs.EnableRedraw(False)
# reset world xy
rs.ViewCPlane(None, rs.WorldXYPlane())
for obj in objs:
# get lowest point
point = getLowestPoint(obj)
# move object to xy plane
rs.MoveObject(obj, (0, 0, -point.Z))
rs.EnableRedraw(True)
def SampleArrayCrv():
obj_ids = rs.GetObjects("Select objects to array")
if not obj_ids: return
base_pt = rs.GetPoint("Base point")
if not base_pt: return
plane = rs.ViewCPlane()
plane.Origin = base_pt
crv_id = rs.GetObject("Select path curve")
if not crv_id: return
count = rs.GetInteger("Number of items", 2, 2)
if not count: return
if rs.IsCurveClosed(crv_id): count -= 1
crv_t = rs.DivideCurve(crv_id, count, False, False)
for t in crv_t:
frame = rs.CurveFrame(crv_id, t)
xform = rs.XformRotation1(plane, frame)
rs.TransformObjects(obj_ids, xform, True)
def __reset_view(self):
rs.ViewCPlane(None, rs.WorldXYPlane() )
rs.Command("_Zoom _A _E _Enter")
rs.Command("_SelAll")
rs.Command("_Shade _d=r _Enter")
rs.Command("_SelNone")
def main():
global inner_curves, outer_curves, curve_coords
# save for later
orig_hidden_objects = rs.HiddenObjects()
# we put reference points in the dogbone-ref layer, so create it if it doesn't exist
rs.AddLayer("dogbone-ref")
panel, face = getsubsurface.GetSubSurface("select dogbone face")
diameter = rs.GetReal("enter cutter diameter", number=0.25)
diameter = diameter * 1.1
rs.EnableRedraw(False)
# compute the plane
normal = rs.VectorUnitize(rs.SurfaceNormal(face, (0.5, 0.5)))
plane = rs.PlaneFromNormal(rs.EvaluateSurface(face, 0.5, 0.5), normal)
rs.ViewCPlane(plane=plane)
rs.ProjectOsnaps(True)
outer_curves = rs.DuplicateSurfaceBorder(face, 1)
inner_curves = rs.DuplicateSurfaceBorder(face, 2)
# make a dict mapping each curve to the coords in that curve
curve_coords = dict()
for curve in outer_curves + inner_curves:
coords = rs.CurvePoints(curve)[:-1]
curve_coords[curve] = coords
# make a dict mapping each curve to the z component of its cross product at each index
curve_cross_zs = dict()
for curve, coords in curve_coords.items():
proj_coords = [rs.SurfaceClosestPoint(face, coord) for coord in coords]
cross_zs = []
for idx in range(len(proj_coords)):
triplet = [
proj_coords[(idx + 1) % len(proj_coords)], proj_coords[idx],
proj_coords[(idx - 1) % len(proj_coords)]
]
v0 = (triplet[1][0] - triplet[0][0], triplet[1][1] - triplet[0][1],
0)
v1 = (triplet[2][0] - triplet[1][0], triplet[2][1] - triplet[1][1],
0)
cross_z = rs.VectorCrossProduct(v0, v1)[2]
cross_zs.append(cross_z)
curve_cross_zs[curve] = cross_zs
points = []
bones = []
temp_points = []
rs.EnableRedraw(True)
while True:
coord = rs.GetPoint("select corner")
if coord is None:
break
try:
curve, idx = get_curve_and_idx_for_coord(coord)
point = rs.AddPoint(coord)
rs.ObjectColor(point, (255, 0, 0))
temp_points.append(point)
bones.append((curve, idx))
except ValueError:
print "invalid curve point"
continue
rs.EnableRedraw(False)
rs.DeleteObjects(temp_points)
# try to automatically identify dogbone points if user selected none
if len(bones) == 0:
for curve, coords in curve_coords.items():
proj_coords = [
rs.SurfaceClosestPoint(face, coord) for coord in coords
]
for idx in range(len(proj_coords)):
triplet = [
proj_coords[(idx + 1) % len(proj_coords)],
proj_coords[idx], proj_coords[(idx - 1) % len(proj_coords)]
]
if curve_cross_zs[curve][idx] > 0:
bones.append((curve, idx))
# make the bones
extrusions = []
for bone in bones:
curve, idx = bone
coords = curve_coords[curve]
point = rs.AddPoint(coords[idx])
rs.ObjectLayer(point, "dogbone-ref")
triplet = [
coords[(idx + 1) % len(coords)],
coords[idx],
coords[(idx - 1) % len(coords)],
]
angle = rs.Angle2(
(triplet[1], triplet[0]),
(triplet[1], triplet[2]),
)
angle = angle[0]
# This is a hacky method to determine the handedness of the curve
# the cross product SHOULD have worked here, but for some reason
# it did not.
v0 = triplet[2][0] - triplet[1][0], triplet[2][1] - triplet[1][1], 0
v1 = triplet[1][0] - triplet[0][0], triplet[1][1] - triplet[0][1], 0
_angle = math.degrees(
math.atan2(v0[1], v0[0]) - math.atan2(v1[1], v1[0]))
while _angle > 180:
_angle -= 360
while _angle < -180:
_angle += 360
if math.copysign(1, angle) != math.copysign(1, _angle):
angle -= 180
point = rs.VectorAdd(
triplet[1],
rs.VectorRotate(
0.5 * diameter *
rs.VectorUnitize(rs.VectorSubtract(triplet[2], triplet[1])),
angle / 2, (0, 0, 1)))
circle = rs.AddCircle((point.X, point.Y, -10), diameter / 2.0)
circle_srf = rs.AddPlanarSrf(circle)
p0 = (point.X, point.Y, -10)
p1 = (point.X, point.Y, 10)
line = rs.AddLine(p0, p1)
extrusion = rs.ExtrudeSurface(circle_srf, line)
extrusions.append(extrusion)
rs.DeleteObjects([circle, circle_srf, line])
rs.BooleanDifference([panel], extrusions, delete_input=True)
rs.DeleteObject(panel)
rs.DeleteObjects(extrusions)
rs.DeleteObjects(points)
rs.DeleteObjects(inner_curves)
rs.DeleteObjects(outer_curves)
rs.DeleteObject(face)
rs.ShowObject(rs.AllObjects())
rs.HideObjects(orig_hidden_objects)
rs.EnableRedraw(True)
def optimization_rotate(_origin_point, _x_point, _y_point, _unused_srf,
_unused_line, _unused_polyline, _unused_mark_line,
_used_srf1, unused_timber, tolerance):
start_time = time.time()
# 初期変数
origin_point = _origin_point
x_point = _x_point
y_point = _y_point
unused_srf = _unused_srf
unused_line = _unused_line
unused_polyline = _unused_polyline
unused_mark_line = _unused_mark_line
used_srf1 = _used_srf1
angle1 = 0.1
angle2 = -0.03
curve_length = []
count1 = 0
angle2_flag = False
end_joint_count = 0
# 回転平面を定義する
new_plane = rs.PlaneFromPoints(origin_point, x_point, y_point)
rs.ViewCPlane(None, new_plane)
rotate_p = origin_point
vec1 = rs.VectorCreate(x_point, rotate_p)
vec2 = rs.VectorCreate(y_point, rotate_p)
cross = rs.VectorCrossProduct(vec1, vec2)
cross_unit = rs.VectorUnitize(cross)
rotate_vec = rs.VectorScale(cross_unit, 100)
# 描画
# rotate_axis = AddVector(rotate_p, rotate_vec)
# print("-------------------------------------------------------")
# 衝突判定
for i in range(200):
curve = rs.IntersectBreps(unused_srf, used_srf1)
# もし接触しなかった場合
if curve is None:
curve_length = []
if i == 0:
angle2_flag = True
angle2 = -1.0
if i == 1:
angle = (angle1 * -1.1)
rs.RotateObject(unused_srf, rotate_p, angle, rotate_vec)
rs.RotateObject(unused_line, rotate_p, angle, rotate_vec)
rs.RotateObject(unused_polyline, rotate_p, angle, rotate_vec)
rs.RotateObject(unused_mark_line[0], rotate_p, angle,
rotate_vec)
rs.RotateObject(unused_mark_line[1], rotate_p, angle,
rotate_vec)
if i == 199:
print("tan2: Can not optimize")
# input("Can not optimize")
# object削除
if curve:
for k in range(0, len(curve)):
rs.DeleteObject(curve[k])
# 平面をもとのxy平面に戻す
origin_point = (0, 0, 0)
x_point = (100, 0, 0)
y_point = (0, 100, 0)
new_plane = rs.PlaneFromPoints(origin_point, x_point, y_point)
rs.ViewCPlane(None, new_plane)
# run time console
end_time = time.time()
optimization_rotate_run_time = end_time - start_time
# print("---------------------------------------------------")
# print("optimization_rotate Run time: %s" % optimization_rotate_run_time)
return False
# console
# print("There is not curve[%s] angle2: %s" % (i, angle2))
rs.RotateObject(unused_srf, rotate_p, angle2, rotate_vec)
rs.RotateObject(unused_line, rotate_p, angle2, rotate_vec)
rs.RotateObject(unused_polyline, rotate_p, angle2, rotate_vec)
rs.RotateObject(unused_mark_line[0], rotate_p, angle2, rotate_vec)
rs.RotateObject(unused_mark_line[1], rotate_p, angle2, rotate_vec)
count1 = count1 + 1
# もし20回連続で接触しない場合、回転方向を逆転する
if count1 == 10 and angle2_flag:
angle2 = angle2 * -1.0
angle = 10 * angle2
rs.RotateObject(unused_srf, rotate_p, angle, rotate_vec)
rs.RotateObject(unused_line, rotate_p, angle, rotate_vec)
rs.RotateObject(unused_polyline, rotate_p, angle, rotate_vec)
rs.RotateObject(unused_mark_line[0], rotate_p, angle,
rotate_vec)
rs.RotateObject(unused_mark_line[1], rotate_p, angle,
rotate_vec)
angle2_flag = False
continue
# もし接触した場合
else:
length = 0
for j in range(0, len(curve)):
if rs.IsCurve(curve[j]):
length = length + rs.CurveLength(curve[j])
else:
rs.RotateObject(unused_srf, rotate_p, angle1, rotate_vec)
rs.RotateObject(unused_line, rotate_p, angle1, rotate_vec)
rs.RotateObject(unused_polyline, rotate_p, angle1,
rotate_vec)
rs.RotateObject(unused_mark_line[0], rotate_p, angle1,
rotate_vec)
rs.RotateObject(unused_mark_line[1], rotate_p, angle1,
rotate_vec)
continue
# 接点2の接触部の長さを格納する
curve_length.append(length)
# もし衝突交線の値が大きくなる場合、回転の方向を逆転する
if len(curve_length) == 5:
if curve_length[0] < curve_length[1] < curve_length[
2] < curve_length[3] < curve_length[4]:
angle1 = angle1 * -1.0
# print("update angle1")
# print("angle1: %s" % angle1)
angle = 3.0 * angle1
rs.RotateObject(unused_srf, rotate_p, angle, rotate_vec)
rs.RotateObject(unused_line, rotate_p, angle, rotate_vec)
rs.RotateObject(unused_polyline, rotate_p, angle,
rotate_vec)
rs.RotateObject(unused_mark_line[0], rotate_p, angle,
rotate_vec)
rs.RotateObject(unused_mark_line[1], rotate_p, angle,
rotate_vec)
curve_length = []
# 接合条件を満たした場合
if length < tolerance:
select_curve = curve[0]
reference_point = createMidPointFromCurve(select_curve)
check_domain = unused_timber.judgeSurfaceDomain(
reference_point)
# もし接触部が端部(domainが0か8の時)
if check_domain == 0 or check_domain == 8:
rs.RotateObject(unused_srf, rotate_p, angle1, rotate_vec)
rs.RotateObject(unused_line, rotate_p, angle1, rotate_vec)
rs.RotateObject(unused_polyline, rotate_p, angle1,
rotate_vec)
rs.RotateObject(unused_mark_line[0], rotate_p, angle1,
rotate_vec)
rs.RotateObject(unused_mark_line[1], rotate_p, angle1,
rotate_vec)
end_joint_count = end_joint_count + 1
if end_joint_count == 2:
# print("tan2: Can not optimize(joint is ends)")
# run time console
end_time = time.time()
optimization_rotate_run_time = end_time - start_time
# print("---------------------------------------------------")
# print("optimization_rotate Run time: %s" % optimization_rotate_run_time)
return False
continue
else:
# print("tan2 <count: %s | curve_length = %s>" % (i, length))
# 平面をもとのxy平面に戻す
origin_point = (0, 0, 0)
x_point = (100, 0, 0)
y_point = (0, 100, 0)
new_plane = rs.PlaneFromPoints(origin_point, x_point,
y_point)
rs.ViewCPlane(None, new_plane)
# run time console
end_time = time.time()
optimization_rotate_run_time = end_time - start_time
# print("optimization_rotate Run time: %s" % optimization_rotate_run_time)
return curve
# 接合条件を満たさなかった場合
else:
# angleを更新
if length < 45:
if angle1 > 0:
angle1 = 0.05
else:
angle1 = -0.05
elif length < 60:
if angle1 > 0:
angle1 = 0.25
else:
angle1 = -0.25
elif length < 70:
if angle1 > 0:
angle1 = 0.35
else:
angle1 = -0.35
elif length < 100:
if angle1 > 0:
angle1 = 0.65
else:
angle1 = -0.65
elif length < 120:
if angle1 > 0:
angle1 = 1.75
else:
angle1 = -1.75
else:
if angle1 > 0:
angle1 = 2.0
else:
angle1 = -2.0
rs.RotateObject(unused_srf, rotate_p, angle1, rotate_vec)
rs.RotateObject(unused_line, rotate_p, angle1, rotate_vec)
rs.RotateObject(unused_polyline, rotate_p, angle1, rotate_vec)
rs.RotateObject(unused_mark_line[0], rotate_p, angle1,
rotate_vec)
rs.RotateObject(unused_mark_line[1], rotate_p, angle1,
rotate_vec)
# print("curve length[%s]: %s | angle1: %s" % (i, length, angle1))
# object削除
for k in range(0, len(curve)):
rs.DeleteObject(curve[k])
if i == 199:
# print("tan2: Can not optimize")
if curve:
for k in range(0, len(curve)):
rs.DeleteObject(curve[k])
# 平面をもとのxy平面に戻す
origin_point = (0, 0, 0)
x_point = (100, 0, 0)
y_point = (0, 100, 0)
new_plane = rs.PlaneFromPoints(origin_point, x_point,
y_point)
rs.ViewCPlane(None, new_plane)
# run time console
end_time = time.time()
optimization_rotate_run_time = end_time - start_time
# print("---------------------------------------------------")
# print("optimization_rotate Run time: %s" % optimization_rotate_run_time)
return False
def RunCommand(is_interactive):
global params
center = rs.GetPoint(message="Select center point")
n = rs.GetInteger(message="Number of teeth",
number=params["n"], minimum=4)
m = rs.GetReal(message="Gear module",
number=params["m"])
pa = rs.GetReal(message="Pressure angle",
number=params["pa"], minimum=0, maximum=45)
ca = rs.GetReal(message="Cone angle",
number=params["ca"], minimum=0, maximum=180)
bool_opts = rs.GetBoolean(message="Output options",
items=(("PitchCone", "No", "Yes"),),
defaults=(params["pc"],))
if None in [center, n, m, pa, ca, bool_opts]:
return 1 # Cancel
pc = bool_opts[0]
params["n"] = n
params["m"] = m
params["pa"] = pa
params["ca"] = ca
params["pc"] = pc
cplane = rs.ViewCPlane() # Get current CPlane
cplane = rs.MovePlane(cplane, center)
xform = rs.XformChangeBasis(cplane, rs.WorldXYPlane())
rs.EnableRedraw(False)
old_plane = rs.ViewCPlane(plane=rs.WorldXYPlane())
gear = generate_gear_crv(teeth=params["n"],
module=params["m"],
pressure_angle=params["pa"],
cone_angle=params["ca"])
# Calculate pitch cone tip
cone_tip = [0, 0, (m * n / 2) / tan(radians(ca/2))]
bevel_gear_srf = rs.ExtrudeCurvePoint(gear, cone_tip)
rs.ViewCPlane(plane=old_plane)
rs.TransformObjects(bevel_gear_srf, xform)
if pc:
circle = generate_pitch_circle_crv(teeth=params["n"],
module=params["m"])
pitch_cone_srf = rs.ExtrudeCurvePoint(circle, cone_tip)
rs.TransformObjects(pitch_cone_srf, xform)
rs.DeleteObjects([gear, circle])
rs.SelectObjects([bevel_gear_srf, pitch_cone_srf])
else:
rs.DeleteObject(gear)
rs.SelectObjects(bevel_gear_srf)
rs.EnableRedraw(True)
return 0 # Success
def testDuplicationsAndSpaceAndScaleAndRotate():
print("\n testDuplicationsAndSpaceAndScaleAndRotate commands \n")
obj_ids = rs.GetObjects(
"Select object(s) from which to create the rectangular matrix", 0,
True, True)
if obj_ids is None: return
box = rs.BoundingBox(obj_ids)
if not isinstance(box, list): return
origin = rs.PointDivide(rs.PointAdd(box[0], box[6]), 2)
nXdups = rs.GetInteger("Max Duplications X", 1, 1)
nYdups = rs.GetInteger("Max Duplications Y", 1, 1)
nZdups = rs.GetInteger("Max Duplications Z", 1, 1)
nXspace = rs.GetReal("Spacing X", 1, 0)
rXspace = rs.GetReal("Spacing X rand", 0, 0, 100) / 100
nYspace = rs.GetReal("Spacing Y", 1, 0)
rYspace = rs.GetReal("Spacing Y rand", 0, 0, 100) / 100
nZspace = rs.GetReal("Spacing Z", 1, 0)
rZspace = rs.GetReal("Spacing Z rand", 0, 0, 100) / 100
nXscale = rs.GetReal("Scale X", 1, 0)
rXscale = rs.GetReal("Scale X rand", 0, 0, 100) / 100
nYscale = rs.GetReal("Scale Y", 1, 0)
rYscale = rs.GetReal("Scale Y rand", 0, 0, 100) / 100
nZscale = rs.GetReal("Scale Z", 1, 0)
rZscale = rs.GetReal("Scale Z rand", 0, 0, 100) / 100
nXrotate = rs.GetReal("Rotate X", 0, 0, 360)
rXrotate = rs.GetReal("Rotate X rand", 0, 0, 100) / 100
nYrotate = rs.GetReal("Rotate Y", 0, 0, 360)
rYrotate = rs.GetReal("Rotate Y rand", 0, 0, 100) / 100
nZrotate = rs.GetReal("Rotate Z", 0, 0, 360)
rZrotate = rs.GetReal("Rotate Z rand", 0, 0, 100) / 100
rKeep = 1 - rs.GetReal("Percent to erase", 0, 0, 100) / 100
endpt = rs.GetPoint("To point")
sample_near_val = lambda val, rand: random.uniform(-rand * val, rand * val)
translations = []
# Copy Points with Spacing
for k in range(nZdups):
for j in range(nYdups):
for i in range(nXdups):
newpt = [
origin[0] + i * nXspace +
sample_near_val(nXspace, rXspace), origin[1] +
j * nYspace + sample_near_val(nYspace, rYspace),
origin[2] + k * nZspace +
sample_near_val(nZspace, rZspace)
]
translations = translations + [rs.VectorCreate(endpt, newpt)]
nObjs = len(translations)
objs_to_keep = random.sample(range(nObjs), int(round(nObjs * rKeep)))
translations = [translations[i] for i in objs_to_keep]
copied_objs = []
for tr in translations:
copied_objs = copied_objs + rs.CopyObjects(obj_ids, tr)
for obj in copied_objs:
bb = rs.BoundingBox(obj)
if bb:
center_point = rs.PointDivide(rs.PointAdd(bb[0], bb[6]), 2)
# pt = rs.SurfaceVolumeCentroid(obj)
rs.ScaleObject(obj, center_point, [
nXscale + sample_near_val(nXscale, rXscale),
nYscale + sample_near_val(nYscale, rYscale),
nZscale + sample_near_val(nZscale, rZscale)
])
plane = rs.ViewCPlane()
rs.RotateObject(obj, center_point,
nXrotate + sample_near_val(nXrotate, rXrotate),
plane.XAxis)
rs.RotateObject(obj, center_point,
nYrotate + sample_near_val(nYrotate, rYrotate),
plane.YAxis)
rs.RotateObject(obj, center_point,
nZrotate + sample_near_val(nZrotate, rZrotate),
plane.ZAxis)
def SetPlaneOrigin():
plane_origin = rs.PlaneFromPoints((0, 0, 0), (100, 0, 0), (0, 100, 0))
rs.ViewCPlane(None, plane_origin)
import rhinoscriptsyntax as rs
# !-RunPythonScript "wallsFromCrvs.py"
objs = rs.GetObjects("Pick curves to loft", rs.filter.curve, preselect=True)
width = rs.GetReal("width", 0.4)
height = rs.GetReal("height", 3)
plane = rs.ViewCPlane()
def wallBaseSrf(crv, width):
rs.SimplifyCurve(crv)
if rs.IsCurveClosed(crv):
domain = rs.CurveDomain(crv)
parameter = (domain[0] + domain[1]) / 2.0
rs.CurveSeam(crv, parameter)
offsets = map(lambda x: rs.OffsetCurve(crv, [0, 0, 0], x),
[width / 2, -width / 2])
section = rs.AddLoftSrf(offsets, loft_type=2)
if offsets: rs.DeleteObjects(offsets)
if rs.IsPolysurface(section):
return rs.ExplodePolysurfaces(section, delete_input=True)
return section
def makeBrep(srf):
point1 = rs.EvaluateSurface(srf, 0, 0)
vec = rs.CreateVector(0, 0, height)
point2 = rs.CopyObject(point1, vec)
line = rs.AddLine(point1, point2)
brep = rs.ExtrudeSurface(srf, line)
def MultiNestedBoundaryTrimCurves():
msg="Select closed boundary curves for trimming"
TCrvs = rs.GetObjects(msg, 4, preselect=False)
if not TCrvs: return
cCrvs=[crv for crv in TCrvs if rs.IsCurveClosed(crv)]
if len(cCrvs)==0:
print "No closed trim curves found"
return
rs.LockObjects(cCrvs)
origCrvs = rs.GetObjects("Select curves to trim", 4)
rs.UnlockObjects(cCrvs)
if not origCrvs : return
#plane which is active when trim curve is chosen
refPlane = rs.ViewCPlane()
if sc.sticky.has_key("TrimSideChoice"):
oldTSChoice = sc.sticky["TrimSideChoice"]
else:
oldTSChoice=True
choice = [["Trim", "Outside", "Inside"]]
res = rs.GetBoolean("Side to trim away?", choice, [oldTSChoice])
if not res: return
trimIns = res[0] #False=Outside
tol=sc.doc.ModelAbsoluteTolerance
bb=rs.BoundingBox(origCrvs,refPlane) #CPlane box, world coords
if not bb: return
zVec=refPlane.ZAxis
rs.EnableRedraw(False)
botPlane=Rhino.Geometry.Plane(bb[0]-zVec,zVec) #check
xform=rs.XformPlanarProjection(botPlane)
cutCrvs=rs.TransformObjects(cCrvs,xform,True)
ccc=CheckPlanarCurvesForCollision(cutCrvs)
if ccc:
msg="Boundary curves overlap, results may be unpredictable, continue?"
res=rs.MessageBox(msg,1+32)
if res!= 1: return
bSrfs=rs.AddPlanarSrf(cutCrvs)
rs.DeleteObjects(cutCrvs)
if bSrfs == None: return
line=rs.AddLine(bb[0]-zVec,bb[4]+zVec)
vols=[]
for srf in bSrfs:
ext=rs.ExtrudeSurface(srf,line,True)
if ext != None: vols.append(ext)
rs.DeleteObjects(bSrfs)
rs.DeleteObject(line)
if len(vols)==0: return
exGroup=rs.AddGroup()
rs.AddObjectsToGroup(vols,exGroup)
rs.Prompt("Splitting curves...")
rs.SelectObjects(origCrvs)
rs.Command("_Split _-SelGroup " + exGroup + " _Enter", False)
splitRes=rs.LastCreatedObjects()
rs.DeleteGroup(exGroup)
rs.Prompt("Classifying trims...")
noSplit=[]
for crv in origCrvs:
#add curve to list if it has not been split (still exists in doc)
id=sc.doc.Objects.Find(crv)
if id != None: noSplit.append(crv)
errors=0
if splitRes:
if len(noSplit)>0: splitRes.extend(noSplit)
for crv in splitRes:
inside=MultiTestInOrOut(crv,vols)
if inside != None:
if (inside and trimIns) or (not inside and not trimIns):
rs.DeleteObject(crv)
else:
errors+=1
rs.DeleteObjects(vols)
if errors>0: print "Problems with {} curves".format(errors)
sc.sticky["TrimSideChoice"] = trimIns
# Draw object based on input emotion
switch_on_new_emotion(object_id)
else:
exit_script()
if __name__ == "__main__":
# Fixes data reload problem in Rhino
construction_functions = reload(construction_functions)
emotion_class = reload(emotion_class)
config = reload(config)
# clear_all()
# reset_view()
rs.Command("_SelAll")
rs.Command("Delete")
rs.ViewCPlane(None, rs.WorldXYPlane() )
rs.Command("_Zoom _A _E _Enter")
rs.Command("_SelAll")
rs.Command("_Shade _d=r _Enter")
rs.Command("_SelNone")
next_action = ""
while next_action != "n" and next_action not in config.exit_commands:
next_action = rs.GetString('Enter (n) for new object')
if next_action == "n":
switch_on_new_object()
else:
exit_script()
def __generate_individual_levels(self, crosssectionplane, loft_height):
cplane = rs.ViewCPlane(None, crosssectionplane)
level_points = []
spikiness = self.emotion_properties["spikiness"] # max spikiness = 1
scaling_factor_aid = 0.2 * spikiness
#draws profile curves on each spine level
for i in xrange(self.emotion_properties["horizontal_AR"][loft_height]
["points_in_curve"]):
scaling_factor = 1 - scaling_factor_aid if i % 2 == 0 else 1 #ranges from a difference in 0.8 and 1 (no difference)
angle = 2 * math.pi * i / self.emotion_properties["horizontal_AR"][
loft_height]["points_in_curve"]
x_point = scaling_factor * self.dimensions[
"actual_height"] * self.dimensions[
"vertical_AR"] * self.emotion_properties["vertical_AR"][
loft_height] * self.emotion_properties[
"horizontal_AR"][loft_height][
"level_horizontal_AR_x"] * math.cos(angle) / 2
y_point = scaling_factor * self.dimensions[
"actual_height"] * self.dimensions[
"vertical_AR"] * self.emotion_properties["vertical_AR"][
loft_height] * self.emotion_properties[
"horizontal_AR"][loft_height][
"level_horizontal_AR_y"] * math.sin(angle) / 2
z_point = 0
point = rs.XformCPlaneToWorld([x_point, y_point, z_point], cplane)
level_points.append(rs.AddPoint(point))
connecting_point = level_points[0]
level_points.append(rs.AddPoint(connecting_point))
level_curve = rs.AddCurve(
level_points, self.emotion_properties["horizontal_AR"][str(
loft_height)]["horizontal_smoothness"])
#twists curve start point 180deg if it is below the spine_x point (to make sure loft doesn't twist)
crvStart = rs.CurveStartPoint(level_curve)
if crvStart[0] <= self.x_points[int(loft_height) - 1]:
crvDomain = rs.CurveDomain(level_curve)
rs.CurveSeam(level_curve, (crvDomain[0] + crvDomain[1]) / 2)
# add planar surface to top and bottom of bottle
if loft_height == "5" or loft_height == "1":
rs.AddPlanarSrf(level_curve)
# hide curves and points on level profiles
rs.HideObjects(level_curve)
rs.HideObjects(level_points)
# object finishing features
if (self.object_id == "Bottle"):
if loft_height == "5":
rs.AddCylinder(cplane, 14.5, 7.4, cap=True)
if (self.object_id == "Chair"):
if loft_height == "5":
rs.AddCylinder(cplane, 14.5, 7.4, cap=True)
if (self.object_id == "Jewelry"):
if loft_height == "5":
major_radius = 5.0
minor_radius = major_radius - 1.5
# rotated_cplane = rs.RotatePlane(cplane, 45.0, cplane.XAxis)
direction = rs.AddPoint((0, 0, 1))
rs.AddTorus(cplane.Origin, major_radius, minor_radius,
direction)
if (self.object_id == "Totem"):
if loft_height == "1":
base_width = 80
base_length = 60
base_depth = -10
base_points = [(-base_width / 2, -base_length / 2, 0),
(base_width / 2, -base_length / 2, 0),
(base_width / 2, base_length / 2, 0),
(-base_width / 2, base_length / 2, 0),
(-base_width / 2, -base_length / 2, base_depth),
(base_width / 2, -base_length / 2, base_depth),
(base_width / 2, base_length / 2, base_depth),
(-base_width / 2, base_length / 2, base_depth)]
rs.AddBox(base_points)
return level_curve
