def test_is_curve_planar(options):
layer_name = options['layer']
objs = get_geometry_by_layer(layer_name)
for x in objs:
if not rs.IsCurvePlanar(x.Id):
return False, None
return True, None
def isCurveOnCPlane(obj):
if rs.IsCurvePlanar(obj):
data = rs.CurvePoints(obj)
for pt in data:
if (math.fabs(pt.Z) < 1e-8):
return True
return False
def FindMostDistantPointInCurve(obj, resolution = 20):
"""
Returns the approximately most distant point within a closed curve
inputs:
obj (curve): closed planar curves
resolution (int)[optional]: numbers of sample points in a resolutionXresolution grid
returns:
point (point): point furthest from curve
"""
if rs.IsCurve(obj) == False:
print "Curves supported only"
return None
if rs.IsCurvePlanar(obj) == False:
print "Curve not planar"
return None
if rs.IsCurveClosed(obj) == False:
print "Curve not closed"
return None
rhobj = rs.coercecurve(obj)
bbox = rhobj.GetBoundingBox(rs.WorldXYPlane())
minX = bbox.Min[0]
minY = bbox.Min[1]
minZ = bbox.Min[2]
maxX = bbox.Max[0]
maxY = bbox.Max[1]
maxZ = bbox.Max[2]
xVals = []
yVals = []
for i in range(resolution):
xVals.append(i)
yVals.append(i)
newXvals = RemapList(xVals, minX, maxX)
newYvals = RemapList(yVals, minY, maxY)
furthestPt = None
furthestDist = 0
maxDist = 99999
for xVal in newXvals:
for yVal in newYvals:
newPt = rc.Geometry.Point3d(xVal, yVal, minZ)
result = rhobj.Contains(newPt, rs.WorldXYPlane())
if result == rc.Geometry.PointContainment.Inside:
param = rhobj.ClosestPoint(newPt, maxDist)
crvPt = rhobj.PointAt(param[1])
dist = rs.Distance(crvPt, newPt)
if dist > furthestDist:
furthestPt = newPt
furthestDist = dist
if furthestDist == 0:
return None
return furthestPt
def test_is_curve_planar(options):
layer_name = options['layer']
# log('Test: curves on layer {} should be planar'.format(layer_name))
objs = get_geometry_by_layer(layer_name)
for x in objs:
if not rs.IsCurvePlanar(x.Id):
return False
return True
def test_get_boundary_polyline(self):
#deprivated, since now in general not drwaing lines
#However, if needed can easily specifically draw cut lines
island.make_five_by_five_square_island(self.island)
self.island.clear()
self.island.draw_edges()
boundary = self.island.get_boundary_polyline()
self.assertTrue(rs.IsPolyCurve(boundary))
self.assertTrue(rs.IsCurveClosed(boundary))
self.assertTrue(rs.IsCurvePlanar(boundary))
self.island.clear()
def isCurveOnCPlane(obj):
if not rs.IsCurvePlanar(obj):
return False
else:
data = rs.CurvePoints(obj)
for pt in data:
if (math.fabs(pt.Z) > 1e-6):
print "Point height: {}".format(pt.Z)
return False
return True
def is_overlapping(self, other_island):
this_perimeter = self.get_boundary_polyline()
other_perimeter = other_island.get_boundary_polyline()
assert rs.IsCurvePlanar(
this_perimeter), "curve of this island not planar"
assert rs.IsCurvePlanar(
other_perimeter), "curve of other island not planar"
assert rs.IsCurveInPlane(
this_perimeter,
island_plane), "this island not in {} plane".format(island_plane)
assert rs.IsCurveInPlane(
other_perimeter,
island_plane), "input island not in {} plane".format(island_plane)
relation = rs.PlanarClosedCurveContainment(this_perimeter,
other_perimeter)
rs.DeleteObjects([this_perimeter, other_perimeter])
assert relation != None, "PlanarClosedCurveContainment failed"
if relation != 0:
return True
else:
return False
def curveErrorCheck(curve):
if rs.IsCurveClosed(curve):
error = False
else:
print "Failed...Curve must be closed"
error = True
if rs.IsCurvePlanar(curve):
error = error
else:
print "Failed...Curve must be planar"
error = True
return error
def setCurveDir(objs):
count = 0
for obj in objs:
# if rs.IsCurve(obj) and rs.IsCurvePlanar(obj):
if rs.IsCurve(obj) and rs.IsCurvePlanar(obj):
normal = rs.CurveNormal(obj)
if normal and normal[2] < 0:
count += 1
rs.ReverseCurve(obj)
normal2 = rs.CurveNormal(obj)
print "Curve {} flipped {}{}".format(obj, normal, normal2)
print "reversed " + str(count) + " curves"
def setCurveDir(objs):
count = 0
for obj in objs:
if rs.IsCurve(obj) and rs.IsCurvePlanar(obj):
sp = rs.AddPoint(rs.CurveEndPoint(obj))
tangent = rs.CurveTangent(obj, rs.CurveDomain(obj)[0])
print tangent
p2 = rs.CopyObject(sp, tangent * -10)
rs.AddPoint(p2)
# rs.Command("Dir")
# for i in range(0,rs.PolyCurveCount(obj)):
# l = rs.CurveLength(obj,i)
# if l < 4:
# print l
# layer=rs.ObjectLayer(obj)
# segments = rs.ExplodeCurves(obj, True)
# obj = rs.JoinCurves(segments, True)
# rs.ObjectLayer(obj, layer)
# rs.ObjectLayer(obj, layer)
normal = rs.CurveNormal(obj)
result = rs.CurveAreaCentroid(obj)
if result:
print normal
start = result[0]
end = (result[0].X + 100 * normal[0],
result[0].Y + 100 * normal[1],
result[0].Z + 100 * normal[2])
rs.AddLine(result[0], end)
if normal and normal[2] < 0:
count += 1
rs.ReverseCurve(obj)
# print "Curve {} flipped {}{}".format(obj, normal, normal2)
# try to find discontinuities
print "reversed " + str(count) + " curves"
def IsRectangle(obj):
"""
Checks if a curve is a rectangle. Must be closed, planar, 4 line segments, all 90 degrees. Uses UnitAngleTolerance
inputs:
obj (curve): curve to evaluate
returns (list):
[0] (Boolean): If rectangle
[1] (String): explaination of why it failed
"""
explaination = ''
tol = rs.UnitAngleTolerance()
rhobj = rs.coercecurve(obj)
if rs.IsCurveClosed(obj):
if rs.IsCurvePlanar(obj):
segments = rhobj.DuplicateSegments()
if len(segments) == 4:
for segment in segments:
if segment.Degree != 1:
explaination = "Not all segments are lines"
return [False, explaination]
for i in range(3):
angle = rs.Angle2(segments[i], segments[i+1])
dist1 = abs(abs(180 - angle[0])-90)
dist2 = abs(abs(180 - angle[1])-90)
if dist1 > tol or dist2 > tol:
explaination = "Angle not 90"
return [False, explaination]
angle = rs.Angle2(segments[-1], segments[0])
dist1 = abs(abs(180 - angle[0])-90)
dist2 = abs(abs(180 - angle[1])-90)
if dist1 > tol or dist2 > tol:
explaination = "Final angle not 90"
return [False, explaination]
explaination = "ITS A RECTANGLE"
return [True, explaination]
else:
explaination = "Curve does not have 4 sides"
return [False, explaination]
else:
explaination = "Curve not planar"
return [False, explaination]
else:
explaination = "Curve not closed"
return [False, explaination]
def SetPlanarCurve(self, type="Any", guid=None):
if (type == "Any"): prompt = "Select a planar pitch curve"
elif (type == "Circle"): prompt = "Select the pitch circle"
newCurve = rs.GetCurveObject(prompt, True,
True) if guid is None else [guid]
if (newCurve is None):
Rhino.RhinoApp.WriteLine("Exit: No curve was selected")
return False
isPlanar = rs.IsCurvePlanar(newCurve[0])
if (isPlanar == False):
newCurve = None
Rhino.RhinoApp.WriteLine("Exit: Selected curve was not planar")
return False
self.curve = newCurve #Accept the curve into the object because the curve exists and it is planar
self.isClosed = rs.IsCurveClosed(self.curve[0])
self.normal = rs.CurveNormal(
self.curve[0]) #For non planar curves the script already exited.
self.isCircle = rs.IsCircle(self.curve[0])
if (type == "Circle" and self.isCircle != True):
Rhino.RhinoApp.WriteLine("Exit: Selected curve was not a circle")
return False
self.crvLen = rs.CurveLength(self.curve[0])
if (self.isCircle == True):
Rhino.RhinoApp.WriteLine("Selected: Circle")
self.origin = rs.CircleCenterPoint(self.curve[0])
self.plane = rs.PlaneFromNormal(
self.origin, self.normal,
rs.CurveStartPoint(self.curve[0]) -
self.origin) #PlaneFromNormal(origin, normal, xaxis=None)
self.SetPD() #Propagate the value updates
self.SetBC() #Propagate the value updates
return
if (self.isClosed == True):
Rhino.RhinoApp.WriteLine(
"Selected: Closed non-circular planar curve")
return
else:
Rhino.RhinoApp.WriteLine("Selected: Open planar curve")
def dimensionPline(pline, offsetDist):
try:
if rs.IsCurvePlanar(pline):
pass
else:
print "Curve must be planar"
return
segments = []
dimGroup = rs.AddGroup("Pline Dims")
dir = rs.ClosedCurveOrientation(pline)
if dir == -1:
rs.ReverseCurve(pline)
normal = rs.CurvePlane(pline).ZAxis
segments = rs.ExplodeCurves(pline)
if len(segments)<1:
segments = [rs.CopyObject(pline)]
for seg in segments:
if rs.IsLine(seg):
endPt = rs.CurveEndPoint(seg)
stPt = rs.CurveStartPoint(seg)
tanVec = rs.VectorCreate(stPt, endPt)
offsetVec = rs.VectorRotate(tanVec, 90, normal)
offsetVec = rs.VectorUnitize(offsetVec)
offsetVec = rs.VectorScale(offsetVec, offsetDist)
offsetPt = rs.VectorAdd(stPt, offsetVec)
dim = rs.AddAlignedDimension(stPt, endPt, rs.coerce3dpoint(offsetPt), 'PCPA_12')
rs.AddObjectToGroup(dim, dimGroup)
rs.DeleteObjects(segments)
result = True
except:
result = False
return [dimGroup, result]
def AreaTag(obj, decPlaces):
try:
rhsrf = rs.coercesurface(obj)
if rs.IsCurve(obj):
if rs.IsCurvePlanar(obj) == False:
return [0, False]
if rs.IsCurveClosed(obj) == False:
return [0, False]
#get area
if rs.UnitSystem() == 8:
if rs.IsCurve(obj):
area = rs.CurveArea(obj)[0]*0.0069444444444444
else:
area = rs.Area(obj)*0.0069444444444444
areaText = utils.RoundNumber(area, decPlaces) + " SF"
else:
print "WARNING: Your units are not in inches"
area = rs.CurveArea(obj)[0]
areaText = area + ' ' + rs.UnitSystemName(False, True, True)
#add annotation style
dimStyle = sc.doc.DimStyles.FindName('PCPA_12')
###########################################################################
#CURVES
if rs.IsCurve(obj):
if utils.IsRectangle(obj)[0]:
#RECTANGLES
srf = rs.AddPlanarSrf(obj)
plane = HorizPlaneFromSurface(srf)
rs.DeleteObject(srf)
else:
#OTHER CURVES
srf = rs.AddPlanarSrf(obj)
plane = HorizPlaneFromSurface(srf)
rs.DeleteObject(srf)
###########################################################################
#HATCHES
elif rs.IsHatch(obj):
rhobj = rs.coercegeometry(obj)
boundaryCrvs = []
crvs = rhobj.Get3dCurves(False)
for crv in crvs:
boundaryCrvs.append(crv)
for crv in rhobj.Get3dCurves(True):
boundaryCrvs.append(crv)
srf = sc.doc.Objects.AddBrep(rc.Geometry.Brep.CreatePlanarBreps(boundaryCrvs)[0])
plane = HorizPlaneFromSurface(srf)
rs.DeleteObject(srf)
###########################################################################
#SURFACES
elif rs.IsSurface(obj):
plane = HorizPlaneFromSurface(obj)
###########################################################################
#OTHER/ERROR
else:
pts = rs.BoundingBox(obj)
centerPoint = (pts[0] + pts[6]) / 2
if dimStyle is not None:
textHeight = dimStyle.TextHeight
areaTag = rs.AddText(areaText, plane, height = textHeight, justification = 131074)
else:
areaTag = rs.AddText(areaText, plane, height = 1, justification = 131074)
#Change layers
hostLayer = layers.AddLayerByNumber(8103, False)
rs.ObjectLayer(areaTag, layers.GetLayerNameByNumber(8103))
return [area, True, areaTag]
except:
return [0, False]
#This script creates a point grid and prompts the user to reference a planar curve.
#the curve is copied from its center point to the new center points as defined by the grid.
#This will be in an XY plane at the Z height of the input curve's center Z
#A vector derived from the grid points to the attractor point describes the translation
#for another copy of the curve at a specified Z height
#the new curve pairs are lofted and capped to create a polysurface.
import rhinoscriptsyntax as rs
#ask the user for a curve to reference
myCrv = rs.GetObject("Please select reference curve", 4)
#make sure we have a planar curve
while rs.IsCurvePlanar(myCrv) == False:
rs.MessageBox("Curve must be planar")
myCrv = rs.GetObject("Please select reference curve", 4)
#get the bounding box and check the max length of the box sides, we use this to set default spacing
bBox = rs.BoundingBox(myCrv)
#bounding boxes are rectangular so we only need to compare one set of adjacent sides
spacing = max(rs.Distance(bBox[0], bBox[1]), rs.Distance(bBox[1], bBox[2]))
#get the center of the referenced curve
myCtr = rs.CurveAreaCentroid(myCrv)
#Command Line prompt the user for an x and y range for the loops
xRange= rs.GetInteger("Please select number of Curves in X", 10)
yRange= rs.GetInteger("Please select number of Curves in Y", 10)
#prompt user to overide grid spacing
spacing = rs.GetReal("Please enter spacing", spacing)
def hatchedCurve():
"""
this script divides a curve by length and makes a hatch-dashed version of it'
works only in world top
version 1.1
www.studiogijs.nl
"""
projection = Rhino.Geometry.Vector3d(0, 0, 1)
viewprojection = sc.doc.Views.ActiveView.ActiveViewport.CameraZ
if not viewprojection == projection:
print " this script only works in top view"
return
getcurves = rs.GetObjects(
"select curves to change into hatch-dashed-style", 4, preselect=True)
rs.UnselectAllObjects()
if not getcurves:
return
s = sc.sticky['scale'] if sc.sticky.has_key('scale') else 1
scale = rs.GetReal("line-width of the hatch-dashed curve", s, .5, 5)
if not scale:
return
sc.sticky['scale'] = scale
f = sc.sticky['factor'] if sc.sticky.has_key('factor') else 5
factor = rs.GetReal("line-length factor of the hatch-dashed curve", f, 1,
10)
if not factor:
return
sc.sticky['factor'] = factor
#turn of the lights, magic should be done in darkness
rs.EnableRedraw(False)
style = Rhino.Geometry.CurveOffsetCornerStyle.Sharp
tol = sc.doc.ModelAbsoluteTolerance
plane = Rhino.Geometry.Plane.WorldXY
subcurvelist = []
offset_curves = []
for curve in getcurves:
# ------------------------------------------------------
# offset curves inward and outward to create the borders
# ------------------------------------------------------
c = rs.coercecurve(curve)
if not rs.IsCurvePlanar(curve):
continue
#else:
#rs.HideObject(curve)
offsets = c.Offset(plane, scale / 2, tol, style)
if offsets:
offset = sc.doc.Objects.Add(offsets[0])
offset_curves.append(offset)
offsets = c.Offset(plane, -scale / 2, tol, style)
if offsets:
offset = sc.doc.Objects.Add(offsets[0])
offset_curves.append(offset)
# -----------------------------------
# explode c into segments if possible
# -----------------------------------
exploded = rs.ExplodeCurves(c)
if exploded:
for segment in exploded:
subcurvelist.append(segment)
else:
#it appears this is for single lines only
subcurvelist.append(rs.CopyObject(curve))
segments = []
# -------------------------------------------------------
# divide subcurves into shorter segments (dashed pattern)
# -------------------------------------------------------
for curve in subcurvelist:
closed = False
if rs.coercecurve(curve).IsClosed:
closed = True
if rs.CurveLength(curve) > (scale * factor):
segment_count = int(rs.CurveLength(curve) / (scale * factor / 2))
while True:
#we need to start with 1/2 segment, then full space, then half segment
#so #of segments needs to be a multiple of 4
if segment_count % 4 == 0: break
else: segment_count += 1
pts = rs.DivideCurve(curve, segment_count)
if closed:
pts = pts[
1:] #remove only first point, since last point == first
pts = pts[1:-1] #remove first and last point
pts = pts[::2] #remove every other point
# --------------
# dash the curve
# --------------
for i, pt in enumerate(pts):
t = rs.CurveClosestPoint(curve, pt)
curves = rs.SplitCurve(curve, t)
curve = curves[1]
segment = curves[0]
if closed:
#delete every odd segment
if i % 2 == 0:
rs.DeleteObject(segment)
else:
segments.append(segment)
else:
#delete every even segment
if i % 2 == 1:
rs.DeleteObject(segment)
else:
segments.append(segment)
#append the remaining part
segments.append(curve)
def hatchthis(s):
#offset all segments
s = rs.coercecurve(s)
offsets = s.Offset(plane, scale / 2, tol, style)
if offsets:
p1, p2, curve1 = getPointsAndLines(offsets)
offsets = s.Offset(plane, -scale / 2, tol, style)
if offsets:
p3, p4, curve2 = getPointsAndLines(offsets)
if not (p1 and p2 and p3 and p4):
return
#create end lines between the two offset curves
line1 = rs.AddLine(p1, p3)
line2 = rs.AddLine(p2, p4)
polyline = rs.JoinCurves([line1, line2, curve1, curve2], True, tol)
# FINALLY: hatch the bloody thing
hatch = rs.AddHatch(polyline, 'Solid')
#clean up
rs.DeleteObject(polyline)
return hatch
if segments:
segments = rs.JoinCurves(segments, True)
layer = "hatched_curves"
if not rs.IsLayer(layer):
rs.AddLayer(layer)
hatches = []
#create the hatches
for s in segments:
rs.ObjectLayer(hatchthis(s), layer)
for offset in offset_curves:
rs.ObjectLayer(offset, layer)
#clean up
rs.DeleteObjects(segments)
rs.HideObjects(getcurves)
rs.DeleteObjects(curves)
#put on the lights, it's the result that counts
rs.EnableRedraw(True)
def Crv2ViewLoose():
curve1 = rs.GetObject("select first curve", rs.filter.curve)
if curve1 != None:
rs.LockObject(curve1)
curve2 = rs.GetObject("select second curve", rs.filter.curve)
if curve1 == None or curve2 == None:
return
degree1 = rs.CurveDegree(curve1)
degree2 = rs.CurveDegree(curve2)
pts1 = rs.CurvePoints(curve1)
pts2 = rs.CurvePoints(curve2)
error = False
errors = []
if rs.IsPolyCurve(curve1) or rs.IsPolyCurve(curve2):
errors.append("Error: This script only works for single open curves")
error = True
if not rs.IsCurvePlanar(curve1) or not rs.IsCurvePlanar(curve2):
errors.append("Error: One or more of the input curves is not planar.")
error = True
if rs.IsCurvePeriodic(curve1) or rs.IsCurvePeriodic(curve2):
errors.append("Error: This script only works with open curves")
error = True
if len(pts1) != len(pts2):
errors.append(
"Error: Input curves need to have same amount of control points")
error = True
if rs.CurveDegree(curve1) != rs.CurveDegree(curve2):
errors.append("Error: Input curves need to be of same degree")
error = True
if error:
for err in errors:
print err
rs.UnlockObject(curve1)
return
top = 0
right = 0
front = 0
if rs.CurvePlane(curve1).ZAxis[2] != 0: #top view curve
top = 1
if rs.CurvePlane(curve2).ZAxis[2] != 0: #top view curve
top = 2
if rs.CurvePlane(curve1).ZAxis[0] != 0: #right view curve
right = 1
if rs.CurvePlane(curve2).ZAxis[0] != 0: #right view curve
right = 2
if rs.CurvePlane(curve1).ZAxis[1] != 0: #front view curve
front = 1
if rs.CurvePlane(curve2).ZAxis[1] != 0: #front view curve
front = 2
pts3 = [] #array to store the points for the new curve
if top == 1 and right == 2:
for i in range(0, len(pts1)):
pts1[i][2] = pts2[i][2]
pts1[i][1] = (pts1[i][1] + pts2[i][1]
) / 2 #average out y-coordinate of each point
pts3.append(pts1[i])
if top == 2 and right == 1:
for i in range(0, len(pts1)):
pts2[i][2] = pts1[i][2]
pts2[i][1] = (pts1[i][1] + pts2[i][1]
) / 2 #average out y-coordinate of each point
pts3.append(pts2[i])
if top == 1 and front == 2:
for i in range(0, len(pts1)):
pts1[i][2] = pts2[i][2]
pts1[i][0] = (pts1[i][0] + pts2[i][0]
) / 2 #average out x-coordinate of each point
pts3.append(pts1[i])
if top == 2 and front == 1:
for i in range(0, len(pts1)):
pts2[i][2] = pts1[i][2]
pts2[i][0] = (pts1[i][0] + pts2[i][0]
) / 2 #average out x-coordinate of each point
pts3.append(pts2[i])
rs.UnlockObject(curve1)
if (right == 0 and front == 0) or (top == 0
and right == 0) or (top == 0
and front == 0):
print "Error: Curves need to be placed on orthogonal views"
return
else:
rs.AddCurve(pts3, degree1)
def Main():
rectangle = rs.GetObject(
"Select rectangle to create mortise and tenon from", rs.filter.curve,
True, True)
if rs.IsCurveClosed(rectangle):
x = 0
else:
print "Failed....Curve must be closed and rectangular"
return
if rs.IsCurvePlanar(rectangle):
x = 0
else:
print "Failed....Curve must be planar"
return
lines = rs.ExplodeCurves(rectangle)
count = 0
for line in lines:
count = count + 1
if count != 4:
print "Failed....To many line segments, redraw rectangle"
return
if rs.IsLine(lines[0]):
x = 0
else:
print "Failed....Curve must be rectangular"
return
if rs.IsLine(lines[1]):
x = 0
else:
print "Failed....Curve must be rectangular"
return
if rs.IsLine(lines[2]):
x = 0
else:
print "Failed....Curve must be rectangular"
return
if rs.IsLine(lines[3]):
x = 0
else:
print "Failed....Curve must be rectangular"
return
face = rs.GetObject("Select tenon surface", rs.filter.surface, False, True,
None, True)
length = rs.GetReal("Enter tenon length", number=None)
if length and length != 0:
x = 0
else:
print "Failed....No length was entered"
return
depth = rs.GetReal("Enter mortise depth", number=length + 0.05)
if depth and depth != 0:
x = 0
else:
print "Failed....No depth was entered"
return
fit = rs.GetReal("Enter mortise fit", number=0.01)
line1 = rs.AddLine(rs.CurveStartPoint(lines[0]),
rs.CurveEndPoint(lines[0]))
line2 = rs.AddLine(rs.CurveStartPoint(lines[1]),
rs.CurveEndPoint(lines[1]))
line3 = rs.AddLine(rs.CurveStartPoint(lines[2]),
rs.CurveEndPoint(lines[2]))
line4 = rs.AddLine(rs.CurveStartPoint(lines[3]),
rs.CurveEndPoint(lines[3]))
rs.DeleteObjects(lines)
lines = line1, line2, line3, line4
if rs.CurveLength(lines[0]) > rs.CurveLength(lines[1]):
smallside = rs.CurveLength(lines[1])
longside1 = lines[0]
longside2 = lines[2]
else:
smallside = rs.CurveLength(lines[0])
longside1 = lines[1]
longside2 = lines[3]
filletRadius = smallside / 2
fillet1 = rs.CurveFilletPoints(lines[0], lines[1])
fillet2 = rs.CurveFilletPoints(lines[1], lines[2])
fillet3 = rs.CurveFilletPoints(lines[2], lines[3])
fillet4 = rs.CurveFilletPoints(lines[3], lines[0])
arc1 = rs.AddFilletCurve(lines[0], lines[1], radius=filletRadius)
arc2 = rs.AddFilletCurve(lines[1], lines[2], radius=filletRadius)
arc3 = rs.AddFilletCurve(lines[2], lines[3], radius=filletRadius)
arc4 = rs.AddFilletCurve(lines[3], lines[0], radius=filletRadius)
arcs = arc1, arc2, arc3, arc4
arcs = rs.JoinCurves(arcs)
arcEnd1 = rs.CurveEndPoint(arcs[0])
arcStart1 = rs.CurveStartPoint(arcs[0])
arcEnd2 = rs.CurveEndPoint(arcs[1])
arcStart2 = rs.CurveStartPoint(arcs[1])
if rs.Distance(arcEnd1, arcEnd2) > rs.Distance(arcEnd1, arcStart2):
temp = arcEnd2
arcEnd2 = arcStart2
arcStart2 = temp
line1 = rs.AddLine(arcEnd1, arcEnd2)
line2 = rs.AddLine(arcStart1, arcStart2)
curves = line1, arcs[0], arcs[1], line2
tenonOut = rs.JoinCurves(curves)
tenonSurf = rs.AddPlanarSrf(tenonOut)
point = rs.SurfacePoints(face)
param = rs.SurfaceClosestPoint(face, point[0])
normal = rs.SurfaceNormal(face, param)
normal = normal * length
vect = rs.AddLine(arcEnd1, arcEnd1 + normal)
tenon = rs.ExtrudeSurface(tenonSurf, vect, cap=True)
rs.DeleteObjects(curves)
arcs = arc1, arc2, arc3, arc4
rs.DeleteObjects(arcs)
rs.DeleteObject(rectangle)
rs.ExtendCurveLength(longside1, 0, 0, fit)
rs.ExtendCurveLength(longside1, 0, 1, fit)
rs.ExtendCurveLength(longside2, 0, 0, fit)
rs.ExtendCurveLength(longside2, 0, 1, fit)
if rs.Distance(rs.CurveEndPoint(longside1),
rs.CurveEndPoint(longside2)) < rs.Distance(
rs.CurveStartPoint(longside1),
rs.CurveEndPoint(longside2)):
line1Start = rs.CurveEndPoint(longside1)
line1End = rs.CurveEndPoint(longside2)
line2Start = rs.CurveStartPoint(longside1)
line2End = rs.CurveStartPoint(longside2)
else:
line1Start = rs.CurveStartPoint(longside1)
line1End = rs.CurveEndPoint(longside2)
line2Start = rs.CurveEndPoint(longside1)
line2End = rs.CurveStartPoint(longside2)
shortside1 = rs.AddLine(line1Start, line1End)
shortside2 = rs.AddLine(line2Start, line2End)
arc1 = rs.AddFilletCurve(longside1, shortside1, radius=filletRadius)
arc2 = rs.AddFilletCurve(shortside1, longside2, radius=filletRadius)
arc3 = rs.AddFilletCurve(longside2, shortside2, radius=filletRadius)
arc4 = rs.AddFilletCurve(shortside2, longside1, radius=filletRadius)
arcs = arc1, arc2, arc3, arc4
arcs = rs.JoinCurves(arcs)
arcEnd1 = rs.CurveEndPoint(arcs[0])
arcStart1 = rs.CurveStartPoint(arcs[0])
arcEnd2 = rs.CurveEndPoint(arcs[1])
arcStart2 = rs.CurveStartPoint(arcs[1])
if rs.Distance(arcEnd1, arcEnd2) > rs.Distance(arcEnd1, arcStart2):
temp = arcEnd2
arcEnd2 = arcStart2
arcStart2 = temp
line1 = rs.AddLine(arcEnd1, arcEnd2)
line2 = rs.AddLine(arcStart1, arcStart2)
curves = line1, arcs[0], arcs[1], line2
mortiseOut = rs.JoinCurves(curves)
mortiseSurf = rs.AddPlanarSrf(mortiseOut)
param = rs.SurfaceClosestPoint(face, point[0])
normal = rs.SurfaceNormal(face, param)
normal = normal * depth
vect = rs.AddLine(arcEnd1, arcEnd1 + normal)
mortise = rs.ExtrudeSurface(mortiseSurf, vect, cap=True)
rs.DeleteObject(shortside1)
rs.DeleteObject(shortside2)
rs.DeleteObject(mortiseOut)
rs.DeleteObject(mortiseSurf)
rs.DeleteObjects(curves)
rs.DeleteObjects(lines)
arcs = arc1, arc2, arc3, arc4
rs.DeleteObjects(arcs)
rs.DeleteObject(rectangle)
rs.DeleteObject(tenonOut)
rs.DeleteObject(tenonSurf)
return
#Generate grid of points
base_points = []
for i in range(0,count_x):
i += i
for j in range (0, count_y):
j += j
x = distance_x * i
y = distance_y * j
p = rs.AddPoint(x, y, 0)
base_points.append(p)
# Cull points outside curve
culled_pts = []
if rs.IsCurveClosed(boundary_curve) and rs.IsCurvePlanar(boundary_curve): # Checking curve is ok
for i in base_points:
if i:
result = rs.PointInPlanarClosedCurve(i, boundary_curve)
if result==0:
pass
#print ('The point is outside of the closed curve.')
elif result==1:
#print('The point is inside of the closed curve.')
culled_pts.append(i)
else:
ghenv.Component.AddRuntimeMessage(e, 'The curve must be planar and closed')
def OffsetCrvLoose():
crv = rs.GetObject("select curve to offset loosely", rs.filter.curve, True)
if crv == None:
return
if not rs.IsCurvePlanar(crv):
print "Sorry, but that curve is not planar."
return
if rs.IsPolyCurve(crv):
print "This simple script works only for single open or closed curves"
return
offset = rs.GetReal("offset amount", 5)
if offset == None or offset == 0:
return
both_sides = rs.GetBoolean("Offset both sides?",
["both_sides", "off", "on"], False)[0]
bPeriodic = False
#rs.EnableRedraw(False)
pts = rs.CurvePoints(crv)
degree = rs.CurveDegree(crv)
if rs.IsCurvePeriodic(crv):
pts = rs.CullDuplicatePoints(pts, 0.01)
bPeriodic = True
offset_pts = []
offset_pts2 = [] #if both_sides=true
plane = rs.CurvePlane(crv)
axis = plane.ZAxis
for pt in pts:
cp = rs.CurveClosestPoint(crv, pt)
v = rs.CurveTangent(crv, cp)
v = rs.VectorUnitize(v)
v *= offset
v = rs.VectorRotate(v, 90, axis)
pt_ = rs.AddPoint(pt)
#create points for offset on one side of the curve
movedpt = rs.MoveObject(pt_, v)
newpt = rs.coerce3dpoint(movedpt)
offset_pts.append(newpt)
#create points for offset on other side of the curve
movedpt = rs.MoveObject(pt_, -2 * v)
newpt = rs.coerce3dpoint(movedpt)
offset_pts2.append(newpt)
rs.DeleteObject(pt_)
nc = Rhino.Geometry.NurbsCurve.Create(bPeriodic, degree, offset_pts)
nc2 = Rhino.Geometry.NurbsCurve.Create(bPeriodic, degree, offset_pts2)
if not both_sides:
if nc.GetLength(0.1) > nc2.GetLength(0.1): #get the longest curve...
if offset > 0: #...and add it to the document for positive offsets...
sc.doc.Objects.AddCurve(nc)
else: #...or the shortest for negative offsets.
sc.doc.Objects.AddCurve(nc2)
else:
if offset > 0:
sc.doc.Objects.AddCurve(nc2)
else:
sc.doc.Objects.AddCurve(nc)
else: #add both curves to the document
sc.doc.Objects.AddCurve(nc)
sc.doc.Objects.AddCurve(nc2)
rs.EnableRedraw(True)
sc.doc.Views.Redraw()
def SampleExportCurvesAsJSON():
# Select curves to export
ids = rs.GetObjects('Select curves to export', 4, True, True)
if not ids: return
# Name of filename to creat
fname = rs.SaveFileName('Save', 'JSON File (*.json)|*.json||')
if not fname: return
# The json data (dictionary)
data = {}
# The version of this data format
data['version'] = 1.0
# The Rhino version
data['rhino'] = rs.ExeVersion()
# The date
data['date'] = time.strftime('%d/%m/%Y')
# The number of curve records
data['curve_count'] = len(ids)
# The curve records (list)
data['curves'] = []
for id in ids:
# Create a curve record (dictionary)
rec = {}
# The id
rec['id'] = id.ToString()
# The dimension
rec['dim'] = rs.CurveDim(id)
# Is rational
rec['rational'] = rs.IsCurveRational(id)
# The degree
rec['degree'] = rs.CurveDegree(id)
# The control point count
rec['cv_count'] = rs.CurvePointCount(id)
# The control points
rec['cvs'] = []
pts = rs.CurvePoints(id)
wht = rs.CurveWeights(id)
for i in range(len(pts)):
pt = pts[i]
rec['cvs'].append([pt[0], pt[1], pt[2], wht[i]])
# The knot count
rec['knot_count'] = rs.CurveKnotCount(id)
# The knots
rec['knots'] = []
knots = rs.CurveKnots(id)
for i in range(len(knots)):
rec['knots'].append(knots[i])
# Some other (unnecessary) properties
rec['closed'] = rs.IsCurveClosed(id)
rec['periodic'] = rs.IsCurvePeriodic(id)
rec['planar'] = rs.IsCurvePlanar(id)
# Append the curve record
data['curves'].append(rec)
# Write the json data
with open('c:/users/dale/desktop/data.json', 'w') as outfile:
json.dump(data, outfile)
def plcrv_filt(rhino_object, geometry, component_index):
return rs.IsCurvePlanar(geometry)
