def GridCornerSmall(treeIn):
listIn = TreeToList(treeIn)
cor_x = []
cor_y = []
cor_z = []
for i in listIn:
cX = i.X
cY = i.Y
cZ = i.Z
cor_x.append(cX)
cor_y.append(cY)
cor_z.append(cZ)
cor_x.sort()
cor_y.sort()
cor_z.sort()
corx_min = (cor_x[0])
cory_min = (cor_y[0])
corz_min = (cor_z[0])
cor_x.reverse()
cor_y.reverse()
cor_z.reverse()
corx_max = (cor_x[0])
cory_max = (cor_y[0])
corz_max = (cor_z[0])
SmallCorner = rs.AddPoint(corx_min, cory_min, corz_min)
SmallCorner = rs.coerce3dpoint(SmallCorner)
BigCorner = rs.AddPoint(corx_max, cory_max, corz_max)
BigCorner = rs.coerce3dpoint(BigCorner)
return (SmallCorner)
def draw_rectangle_2(p, theta):
t = 1
p0 = rs.AddPoint(p)
p1 = rs.CopyObject(p0, polar(t, theta + 11, 0))
p2 = rs.CopyObject(p0, polar(t, theta + 169, 0))
p3 = rs.CopyObject(p0, polar(t, theta - 169, 0))
p4 = rs.CopyObject(p0, polar(t, theta - 11, 0))
rec = [
rs.AddLine(p1, p2),
rs.AddLine(p2, p3),
rs.AddLine(p3, p4),
rs.AddLine(p4, p1)
]
return rec
def CSVlist():
#prompt the user for a file to import
filter = "CSV file (*.csv)|*.csv|*.txt|All Files (*.*)|*.*||"
filename = rs.OpenFileName("Open Point File", filter)
if not filename: return
with open(filename) as csvfile:
reader = csv.reader(csvfile)
for row in reader:
x = float(row[0])
y = float(row[1])
z = float(row[2])
print x, y, z
rs.AddPoint(x,y,z)
def branchingDLA_MAIN():
#nodes = [ ]
#create root node
nodes = [node([0,0,0],0,1)]
rNodes = [rs.AddPoint(nodes[0].posVec)]
speed = .5 #rhino units per iteration
stickRange = 1.5
nThrows = 300
boundRadius = 10.0
rs.AddCircle([0,0,0],boundRadius)
for i in range(nThrows):
throwNode(nodes,speed,stickRange,rNodes,boundRadius)
def AnnotateCurveEndPoints():
print "annotateCurveEndPoints"
#Annotates the endpoints of curve objects. If the curve is closed then only the starting point is annotated.
# get the curve object
objectId = rs.GetObject("Select curve", rs.filter.curve)
if objectId is None: return
# Add the first annotation
point = rs.CurveStartPoint(objectId)
rs.AddPoint(point)
#textDot is out of scale
#rs.AddTextDot(point, point)
txtString = meters(point)
rs.AddText(txtString, point, 1000 )
print (point.X + point.Y + point.Z)
# Add the second annotation
if not rs.IsCurveClosed(objectId):
point = rs.CurveEndPoint(objectId)
rs.AddPoint(point)
txtString = meters(point)
rs.AddText(txtString, point, 1000 )
def intersect_surfaces(guids):
"""Intersects all surfaces in model. Uses python cmd line, not api."""
sc.doc.Views.Redraw()
rs.UnselectAllObjects()
layer('INTS_BOX')
rs.SelectObjects(guids.boxes)
rs.Command('_Intersect', echo=False)
rs.UnselectAllObjects()
layer('INTS')
rs.SelectObjects(guids.fractures)
rs.Command('_Intersect', echo=False)
frac_isect_ids = rs.LastCreatedObjects()
rs.UnselectAllObjects()
if frac_isect_ids:
for intid in frac_isect_ids:
if rs.IsCurve(intid):
rs.AddPoint(rs.CurveStartPoint(intid))
rs.AddPoint(rs.CurveEndPoint(intid))
if len(frac_isect_ids) > 1:
rs.SelectObjects(frac_isect_ids)
rs.Command('_Intersect', echo=False)
if rs.IsLayer('INTS_BOX_INT'):
layer('INTS_BOX_INT')
rs.UnselectAllObjects()
rs.SelectObjects(guids.boxes_int)
rs.SelectObjects(guids.fractures)
rs.Command('_Intersect', echo=False)
frac_isect_ids = rs.LastCreatedObjects()
rs.UnselectAllObjects()
if frac_isect_ids:
for intid in frac_isect_ids:
if rs.IsCurve(intid):
rs.AddPoint(rs.CurveStartPoint(intid))
rs.AddPoint(rs.CurveEndPoint(intid))
if len(frac_isect_ids) > 1:
rs.SelectObjects(frac_isect_ids)
rs.Command('_Intersect', echo=False)
def _CreateConstructionGeometry(self):
self.PCG1 = rs.AddPoint([-100,-100,0])
self.PCG2 = rs.AddPoint([-100,100,0])
self.PCG3 = rs.AddPoint([100,100,0])
self.PCG4 = rs.AddPoint([100,-100,0])
self.XoY_Plane = rs.AddSrfPt([self.PCG1, self.PCG2, self.PCG3, self.PCG4])
self.PCG5 = rs.AddPoint([3,3,0])
self.PCG6 = rs.AddPoint([3,3,100])
self.ProjVectorZ = rs.VectorCreate(self.PCG5, self.PCG6)
def vert3_to_points(self, vert3):
# print(vert3)
points = []
for i in xrange(len(vert3)):
vert = vert3[i]
# print(vert)
p = rs.AddPoint(vert)
points.append(p)
points_geo = rs.coerce3dpointlist(points)
return points_geo
def Main():
n = 50
radius = 3
for i in range(0, n): # notice how range() accepts variables
# a little trick here: as i goes from 0 to n-1, k will go from 0 to 1
k = i / (n - 1)
# traverse the full circle
angle = k * 2 * math.pi
# and now, work that trigonometry
rs.AddPoint([radius * math.cos(angle), radius * math.sin(angle), 0])
def draw(self):
for i in range(self.uNum + 1):
for j in range(self.vNum + 1):
pt = self.getPt(i, j)
rs.AddPoint(pt)
rs.AddText(str(i) + ',' + str(j), pt, height=0.2)
#
#
return self
#eof
#eoc
def param(self):
#print " check "
dome = rs.CurveDomain(self.c1)
#print dome
#domain remaping
domemin = dome[0]
domemax = dome[1]
pointList1 = []
pointList2 = []
#iterations of i
for i in range(0, self.numberD + 1):
#parameter defined to evaluate the tangent of curve
parameter = (domemax - domemin) / self.numberD * i
pt = rs.EvaluateCurve(self.c1, parameter)
tn = rs.CurveTangent(self.c1, parameter)
tn = rs.VectorUnitize(tn)
tn = rs.VectorScale(tn, self.scale)
point1 = rs.AddPoint(pt)
rs.AddPoint(tn)
point2 = rs.VectorAdd(pt, tn)
rs.AddLine(pt, point2)
pointList1.append(point1)
pointList2.append(point2)
return [pointList1, pointList2]
def equilateralPolygon(sides, size):
cornerpoints = []
cornerpoint = rs.AddPoint(0, size, 0)
cornerpoints.append(cornerpoint)
for points in range(1, sides, 1):
anothercorner = rs.RotateObject(cornerpoint, (0, 0, 0),
points * 360 / sides,
None,
copy=True)
cornerpoints.append(anothercorner)
print(cornerpoints)
rs.AddLine(cornerpoints[0], cornerpoints[1])
rs.AddLine(cornerpoints[1], cornerpoints[2])
def _clear_objects(cls):
"""Deletes all drawn objects, including locked objects, if any.
Returns:
n_objects int. The number of objects deleted, if successful
"""
dummy_point = rs.AddPoint(0, 0, 0)
value = rs.DeleteObject(dummy_point)
include_lights = True
include_grips = True
objects = rs.AllObjects(include_lights, include_grips)
n_objects = rs.DeleteObjects(objects)
remaining_objects = rs.AllObjects(include_lights, include_grips)
rs.UnlockObjects(remaining_objects)
m_objects = rs.DeleteObjects(remaining_objects)
return n_objects + m_objects
def MakeEllipsoidalCoordinates(treeIn, treeOut):
# U1, U2, U3 meghatarozasa
MaxCoord = GridCornerBig(treeIn)
x_max = MaxCoord.X
y_max = MaxCoord.Y
z_max = MaxCoord.Z
for i in range(treeIn.BranchCount):
treeBranch = treeIn.Branch(i)
treePath = treeIn.Path(i)
for j in range(treeBranch.Count):
elem = treeBranch[j]
x = elem.X
y = elem.Y
z = elem.Z
a = alpha / x_max
b = beta / y_max
y = y_max - y
# a logikus vetites miatt
U2 = x * a
U3 = y * b + gap
deltaZ = z_max
if deltaZ != 0:
deltaV = thick
v = (1 - (z / deltaZ)) * deltaV
else:
v = 0
U2rad = math.radians(U2)
U3rad = math.radians(U3)
a = math.sin(U3rad) * math.sin(U3rad)
b = (rad - v) * (rad - v)
c = math.cos(U3rad) * math.cos(U3rad)
d = (height - v) * (height - v)
U1 = math.sqrt(1 / (a / b + c / d))
EllPoint = rs.AddPoint(U1, U2, U3)
EllPoint = rs.coerce3dpoint(EllPoint)
treeOut.Add(EllPoint, treePath)
def ptsOnSrf ():
surfaceId = rs.GetObject("pick surface", 8, True, True)
uVal = rs.GetInteger("pick u/row count",4, 1, 20)
vVal = rs.GetInteger("pick v/col count",4, 1, 20)
uDomain = rs.SurfaceDomain(surfaceId, 0)
vDomain = rs.SurfaceDomain(surfaceId, 1)
uStep = (uDomain[1] - uDomain[0])/ uVal
vStep = (vDomain[1] - vDomain[0])/ vVal
count = 0
for i in rs.frange(uDomain[0], uDomain[1], uStep):
for j in rs.frange(vDomain[0], vDomain[1], vStep):
point = rs.EvaluateSurface(surfaceId, i, j)
newPt = rs.AddPoint(point)
count += 1
rs.AddText(count,newPt, .25)
def manypoints():
pt = []
imax = rs.GetInteger("number of spheres in X-axis", 5, 1, 10)
jmax = rs.GetInteger("number of spheres in Y-axis", 5, 1, 10)
kmax = rs.GetInteger("number of spheres in Z-axis", 5, 1, 10)
for i in rs.frange(0, imax, 1):
for j in rs.frange(0, jmax, 1):
for k in rs.frange(0, kmax, 1):
#set up coordinate
arrPointCoord = rs.AddPoint([i, j, k])
pt.append(arrPointCoord)
r = 0 + (255 - 0) / (imax) * i
g = 255 - (0 + (255 - 0) / (jmax) * j)
b = (255 / kmax * k)
rs.ObjectColor(pt, [r, g, b])
def main():
ptStart = rs.AddPoint(0,0,0)
vecDir = [0,0,1]
minTwigCount = 1
maxTwigCount = 5
maxGen = 5
maxTwigLength = 1
lengthMutation = .5
maxTwigAngle = 90
angleMutation = .5
newProps = minTwigCount, maxTwigCount, maxGen, maxTwigLength, lengthMutation, maxTwigAngle, angleMutation
RecursiveGrowth (ptStart, vecDir, props, 0)
def createSegments():
for i in range(levels):
points = []
origin = [0+random.random()*depth,0+random.random()*depth,i*levelres]
point1 = rs.AddPoint(radius,0,i*levelres)
points.append(point1)
for i in range(1, segements):
tempPoint = points[-1]
tempOrgin = [origin[0] + random.random()*depth, origin[1] + random.random()*depth, origin[2]+1]
newPt = rs.RotateObject(tempPoint,tempOrgin,degrees,None,True)
points.append(newPt)
points.append(point1)
lastCircle.append(tempOrgin)
polygon = rs.AddPolyline(points)
lofts.append(polygon)
return lofts
def plotGaussKernel():
stepSize = .01
nIter = 120
maxGrowLen = 2
minGrowLen = .001
cutoffDist = 3
s = 1.0 / (maxGrowLen * math.sqrt(2.0 * math.pi)
) # calculate s so that gauss(x=0)=maxGrowLen
u = 0
gaussKernel = createGaussKernel(stepSize, maxGrowLen, minGrowLen,
cutoffDist)
for i in range(len(gaussKernel)):
x = i * stepSize
y = gaussKernel[i]
rs.AddPoint(x, y, 0)
def ellipse(self, xheight, yheight, placement='center', angle=0):
"""xheight: the x dimension of the ellipse before rotation \n
yheight: the y dimension of the ellipse before rotation \n
placement: (optional) 'center' places ellipse centered around the turtle, 'edge' places ellipse to the side of the turtle \n
angle: (optional) rotates ellipse around the turtle's"""
centerPoint = rs.AddPoint(self.point)
if placement == 'edge':
centerPoint = rs.MoveObject(
centerPoint,
rs.VectorScale(rs.VectorCreate([1, 0, 0], [0, 0, 0]),
xheight / 2))
newEllipse = rs.AddCircle(centerPoint, xheight / 2)
ScaleFactor = yheight / xheight
rs.ScaleObject(newEllipse, self.point, [1, ScaleFactor, 0])
newEllipse = rs.RotateObject(newEllipse, self.point, angle)
rs.DeleteObject(centerPoint)
def cubecenter(self, m1, m2, m3):
# a = rs.AddPoint(self.point)
p = rs.GetPoint("Enter center point")
a = rs.AddPoint(p)
l = m1 / 2
w = m2 / 2
h = m3 / 2
b = rs.CopyObject(a, [l, w, -h])
c = rs.CopyObject(a, [l, -w, -h])
d = rs.CopyObject(a, [-l, -w, -h])
e = rs.CopyObject(a, [-l, w, -h])
f = rs.CopyObject(a, [l, w, h])
g = rs.CopyObject(a, [l, -w, h])
h = rs.CopyObject(a, [-l, -w, h])
j = rs.CopyObject(a, [-l, w, (m3 / 2)])
box = rs.AddBox([b, c, d, e, f, g, h, j])
def xyz2pts(self, FN):
filepath = self._mainDIR + self._session + "\\" + FN + ".xyz"
if (os.path.exists(filepath)):
result = []
with open(filepath) as fp:
line = fp.readline()
while line:
curLine = line.strip()
coord = curLine.split(' ')
for i in range(len(coord)):
coord[i] = float(coord[i])
result.append(rs.AddPoint(coord))
line = fp.readline()
return result
else:
raise Exception('File doesn\'t exist!')
def splitlines(lines, count):
#temp list and clear input list
templines = lines
lines = []
pts = []
#make sure we have a way to break the recursion
if count == 0:
return 1
else:
for line in templines:
#get properties of the line (endpts, length, direction, domain)
stpt = rs.CurveStartPoint(line)
endpt = rs.CurveEndPoint(line)
length = rs.Distance(stpt, endpt)
dir1 = rs.VectorCreate(endpt, stpt)
crvdomain = rs.CurveDomain(line)
#parameters for midpt and pts 1/3 and 2/3 along the line
t0 = crvdomain[1] / 2.0
t1 = crvdomain[1] / 3.0
t2 = t1 * 2
midpt = rs.EvaluateCurve(line, t0)
ptatonethird = rs.EvaluateCurve(line, t1)
ptattwothird = rs.EvaluateCurve(line, t2)
midpt = rs.AddPoint(midpt)
#call get normal function
normal = getnormal(stpt, endpt)
#move midpt perpendicular to line at 1/3 the length of the line
scaled = rs.VectorScale(normal, 0.3333)
rs.MoveObject(midpt, scaled)
#create the 4 newlines and add them to the list
newline1 = rs.AddLine(stpt, ptatonethird)
newline2 = rs.AddLine(ptatonethird, midpt)
newline3 = rs.AddLine(midpt, ptattwothird)
newline4 = rs.AddLine(ptattwothird, endpt)
lines.append(newline1)
lines.append(newline2)
lines.append(newline3)
lines.append(newline4)
#create a list of objects to delete
cleanup = []
cleanup.append(line)
cleanup.append(midpt)
rs.DeleteObjects(cleanup)
#don't forget to decrement the count otherwise infinite loop
count = count - 1
return splitlines(lines, count)
def automated_smoothing_surface_constraints(mesh, surface):
"""Apply automatically surface-related constraints to the vertices of a mesh to smooth: kinks, boundaries and surface.
Parameters
----------
mesh : Mesh
The mesh to apply the constraints to for smoothing.
surface : RhinoSurface
A RhinoSurface object on which to constrain mesh vertices.
Returns
-------
constraints : dict
A dictionary of mesh constraints for smoothing as vertex keys pointing to point, curve or surface objects.
"""
constraints = {}
points = [rs.AddPoint(point) for point in surface.kinks()]
curves = surface.borders(type=0)
constraints.update({vkey: surface.guid for vkey in mesh.vertices()})
for vkey in mesh.vertices_on_boundary():
xyz = mesh.vertex_coordinates(vkey)
projections = {
curve: distance_point_point(
xyz,
RhinoCurve.from_guid(curve).closest_point(xyz))
for curve in curves
}
constraints.update({vkey: min(projections, key=projections.get)})
key_to_index = {
i: vkey
for i, vkey in enumerate(mesh.vertices_on_boundary())
}
vertex_coordinates = tuple(
mesh.vertex_coordinates(vkey) for vkey in mesh.vertices_on_boundary())
constraints.update({
key_to_index[closest_point_in_cloud(rs.PointCoordinates(point),
vertex_coordinates)[2]]: point
for point in points
})
return constraints
def faces():
surfaces = rs.GetObjects("select surfaces", filter=rs.filter.surface)
points = [
rs.EvaluateSurface(surface, *rs.SurfaceParameter(surface, (0.5, 0.5)))
for surface in surfaces
]
x = reduce(lambda s, point: s + point.X, points, 0) / len(points)
y = reduce(lambda s, point: s + point.Y, points, 0) / len(points)
z = reduce(lambda s, point: s + point.Z, points, 0) / len(points)
# find the center of the object
mass_center = rs.AddPoint(x, y, z)
extrude_curves = {}
# find the appropriate extrusion curve with the lowest dot product
for surface in surfaces:
surface_center = rs.EvaluateSurface(
surface, *rs.SurfaceParameter(surface, (0.5, 0.5)))
center_vector = rs.VectorCreate(surface_center, mass_center)
normals = []
normals.append(
rs.SurfaceNormal(surface, rs.SurfaceParameter(surface,
(0.5, 0.5))))
normals.append(-rs.SurfaceNormal(
surface, rs.SurfaceParameter(surface, (0.5, 0.5))))
if (rs.VectorDotProduct(normals[0], center_vector) <
rs.VectorDotProduct(normals[1], center_vector)):
extrude_curve = normals[0]
else:
extrude_curve = normals[1]
extrude_curve = rs.VectorUnitize(extrude_curve)
extrude_curve = rs.VectorScale(extrude_curve, 0.25)
extrude_curve = [
surface_center,
rs.VectorAdd(surface_center, extrude_curve)
]
extrude_curve = rs.AddCurve(extrude_curve)
rs.ExtrudeSurface(surface, extrude_curve)
rs.DeleteObject(extrude_curve)
rs.DeleteObject(surface)
rs.DeleteObject(mass_center)
def create_connection_tangram(self, target_tangram):
if self.can_grow:
vector = self.get_connection_vector(self, target_tangram)
ref_type = self.get_connection_type(vector)
ref_tangram = self.get_growing_tangram(ref_type)
face_index = self.get_connection_face(vector)
can_grow = get_distance(self.center,
target_tangram.get_center()) > 2
angle = self.get_connection_angle(ref_type, ref_tangram,
face_index, vector)
tangram_shape = create_shape(self, ref_tangram, face_index, angle)
center = find_center(
Brep.Vertices.GetValue(rs.coercebrep(tangram_shape)))
shape_list.append(rs.AddPoint(center))
self.create_tangram(ref_type, self.classification, tangram_shape,
center, can_grow,
(self.target_face, self.name), face_index)
def __init__(self,radius,sides):
self.radius = radius
self.sides = sides
theta = (2*math.pi)/self.sides
print theta
pt01 = rs.AddPoint(self.radius,0,0);
pts = []
pts.append(pt01)
self.origin = [0,0,0]
degrees = theta*(180/math.pi)
print degrees
for i in range(1,self.sides):
tempPt = pts[-1]
newPt = rs.RotateObject(tempPt,self.origin,degrees,None,True)
pts.append(newPt)
pts.append(pt01)
self.polygon = rs.AddPolyline(pts);
def define_mesh_points_triangle(self, num):
pts = []
for i in xrange(num):
for j in xrange(num):
yy = j * (math.sin((1.0 / 3.0) * math.pi))
if j % 2 == 0:
xx = i
else:
xx = i + (math.cos((1.0 / 3.0) * math.pi))
pts.append(rs.AddPoint(xx, yy, 0))
return pts
def make(self):
self.segments = rs.ExplodeCurves(self.Rect)
treadLength = rs.CurveLength(self.segments[1]) / self.numRisers
riserHeight = self.deltaHeight / self.numRisers
runVector = rs.VectorCreate(
rs.CurveEndPoint(self.segments[1]),
rs.CurveStartPoint(self.segments[1]))
unitRunVec = rs.VectorUnitize(runVector)
treadVec = rs.VectorScale(unitRunVec, treadLength)
riseVec = rs.VectorCreate([0, 0, riserHeight], [0, 0, 0])
newPt = [
rs.CurveStartPoint(self.segments[0]).X,
rs.CurveStartPoint(self.segments[0]).Y,
rs.CurveStartPoint(self.segments[0]).Z - self.deltaHeight
]
ptList = []
ptList.append(rs.AddPoint(newPt))
for i in range(self.numRisers):
tempPt = rs.CopyObject(ptList[-1])
rs.MoveObject(tempPt, riseVec)
ptList.append(tempPt)
tempPt = rs.CopyObject(ptList[-1])
rs.MoveObject(tempPt, treadVec)
ptList.append(tempPt)
downLine = rs.VectorCreate([0, 0, 0], [0, 0, self.thickness])
newBtmPt = rs.MoveObject(rs.CopyObject(ptList[0]), downLine)
ptList.insert(0, newBtmPt)
newBtmPt2 = rs.MoveObject(rs.CopyObject(ptList[-1]), downLine)
ptList.append(newBtmPt2)
stringer = rs.AddPolyline(ptList)
closeCrv = rs.AddLine(rs.CurveStartPoint(stringer),
rs.CurveEndPoint(stringer))
newStringer = rs.JoinCurves([stringer, closeCrv], True)
stair = rs.ExtrudeCurve(newStringer, self.segments[0])
rs.CapPlanarHoles(stair)
rs.DeleteObject(stringer)
rs.DeleteObject(newStringer)
rs.DeleteObjects(ptList)
rs.DeleteObjects(self.segments)
return stair
def AddPoint(ptcordTmpPointInter, ptcordTmpPoint, ltTmpCordNum,
intWhich): #to add the point into the dict
ltTmpCordNumInter = [ltTmpCordNum[0], ltTmpCordNum[1]]
if ptcordTmpPointInter[intWhich] < ptcordTmpPoint[intWhich]:
ltTmpCordNumInter[intWhich] -= 1
if intWhich == 1:
ltTmpCordNumInter[0] += 1
else:
ltTmpCordNumInter[intWhich] += 1
if ((ltTmpCordNumInter[0] % 5 == 0)):
rs.AddTextDot(
str(ltTmpCordNumInter[0]) + "," + str(ltTmpCordNumInter[1]),
ptcordTmpPointInter)
dictPointByCord[ptcordTmpPointInter] = ltTmpCordNumInter
dictPointByNum[tuple(ltTmpCordNumInter)] = ptcordTmpPointInter
ptTmpPoint = rs.AddPoint(ptcordTmpPointInter)
ltObjectPoint.append(ptTmpPoint)
