def DisplaySurfaces(self):
for id in self.srfIDs:
sc.doc.Objects.Delete(id, True)
neighs = self.GetClosest2Neighbors()
closestObjs = neighs[:2]
if len(closestObjs) > 1:
m = rg.Mesh()
m.Vertices.Add(self.pos)
m.Vertices.Add(closestObjs[0].pos)
m.Vertices.Add(closestObjs[1].pos)
m.Faces.AddFace(0, 1, 2)
#m.Normal.ComputeNormals()
self.srfIDs.append(sc.doc.Objects.AddMesh(m, self.attr))
def Update(self):
self.ball0.Update()
self.ball1.Update()
line = rg.LineCurve(self.ball0.pos, self.ball1.pos)
vec = self.ball1.pos - self.ball0.pos
plane = rg.Plane(self.ball0.pos, vec)
circ = rg.Circle(plane, self.ball0.size)
circ.ToNurbsCurve()
cylinder = rg.Cylinder(circ, vec.Length)
cylinder = cylinder.ToBrep(True, True)
if self.id:
sc.doc.Objects.Delete(self.id, True)
results = rg.Brep.CreateBooleanUnion(
[self.ball0.brep, self.ball1.brep, cylinder],
sc.doc.ModelAbsoluteTolerance)
if results:
if len(results) > 0:
self.brep = results[0]
if self.brep:
self.id = sc.doc.Objects.AddBrep(self.brep,
self.system.attr)
def __init__(self, system):
self.system = system
self.val = None
#Movement
self.vel = rg.Vector3d(random.uniform(-1, 1), random.uniform(-1, 1),
random.uniform(-1, 1))
self.vel.Unitize()
self.speed = random.uniform(1, 2)
self.vel *= self.speed
self.acc = rg.Vector3d(0, 0, 0)
self.size = 2
self.cone = None
self.coneID = None
#Color and material
self.attr = rc.DocObjects.ObjectAttributes()
self.attr.ColorSource = rc.DocObjects.ObjectColorSource.ColorFromObject
self.attr.ObjectColor = color.ColorBetweenColors(
drawing.Color.DeepSkyBlue, drawing.Color.LimeGreen,
random.uniform(0, 1))
self.attr.MaterialSource = rc.DocObjects.ObjectMaterialSource.MaterialFromObject
index = sc.doc.Materials.Add()
self.mat = sc.doc.Materials[index]
self.mat.DiffuseColor = self.attr.ObjectColor
self.mat.CommitChanges()
self.attr.MaterialIndex = index
#Position
self.pos = rg.Point3d(random.uniform(5, 95), random.uniform(5, 95),
random.uniform(5, 95))
self.sphere = rg.Sphere(self.pos, 2)
#Bake
self.ids = []
self.ids.append(sc.doc.Objects.AddSphere(self.sphere, self.attr))
def AvoidNeighborPaths(self):
futureVel = self.vel.Clone()
futurePos = self.pos.Clone()
futureVel += self.acc
futurePos += futureVel
plane0 = rg.Plane(self.pos, futureVel)
plane1 = rg.Plane(futurePos, futureVel)
l = futurePos-self.pos
cone = rg.Cone(plane0,self.size*10, self.size*3)
cone = cone.ToBrep(False)
for neigh in self.system.particles:
if neigh is self: continue
if neigh.pipe:
results = rg.Intersect.Intersection.BrepBrep(cone, neigh.pipe, sc.doc.ModelAbsoluteTolerance)
if len(results[1]) > 0:
#bbox = rg.BoundingBox(results[1][0])
pt = geo.PointBetweenPoints(results[1][0].PointAtStart, results[1][0].PointAtEnd)
collisionVec = futurePos - pt
rg.Vector3d.PerpendicularTo(collisionVec, futureVel)
collisionVec.Unitize()
self.acc += collisionVec
def __init__(self):
self.particles = []
self.boundary = rg.Box(rg.Plane.WorldXY, rg.Interval(0,100), rg.Interval(0,100), rg.Interval(0,100))
self.boundary = self.boundary.ToBrep()
self.time = 0
self.attr = rc.DocObjects.ObjectAttributes()
self.attr.ColorSource = rc.DocObjects.ObjectColorSource.ColorFromObject
self.attr.MaterialSource = rc.DocObjects.ObjectMaterialSource.MaterialFromObject
grad = color.GetGradient(1)
self.attr.ObjectColor = color.GradientOfColors(grad, 0)
self.attr.ObjectColor = drawing.Color.White
index = sc.doc.Materials.Add()
self.mat = sc.doc.Materials[index]
self.mat.DiffuseColor = self.attr.ObjectColor
self.mat.CommitChanges()
self.attr.MaterialIndex = index
self.attr = rc.DocObjects.ObjectAttributes()
self.attr.ColorSource = rc.DocObjects.ObjectColorSource.ColorFromObject
self.attr.MaterialSource = rc.DocObjects.ObjectMaterialSource.MaterialFromObject
self.clays = []
#numClays = 1
#for i in range(numClays):
# self.clays.append(Clay(self, color.GradientOfColors(grad, i/numClays), rg.Interval(25+(i*10), 35+(i*10))))
numClays = 1
self.clays.append(Clay(self, color.GradientOfColors(grad, 0), rg.Interval(25, 75)))
self.balls = []
for i in range(4):
self.balls.append(Ball(self))
def isSizeAcceptableAtPoint(cone, point, bDebug=False):
mmPerModelUnit = 1.0 / Rhino.RhinoMath.UnitScale(
Rhino.UnitSystem.Millimeters, sc.doc.ModelUnitSystem)
if abs(cone.ApexPoint.MaximumCoordinate *
mmPerModelUnit) >= MAX_ACCEPTED_SIZE:
if bDebug:
print "Cone with ApexPoint of {} skipped.".format(
cone.ApexPoint)
return False
else:
apexToPtOnCone = cone.ApexPoint.DistanceTo(point)
if apexToPtOnCone <= sc.doc.ModelAbsoluteTolerance:
# Point must be at apex.
return
line_Axis = rg.Line(cone.ApexPoint, cone.BasePoint)
pt_onAxis = line_Axis.ClosestPoint(point,
limitToFiniteSegment=False)
apexToPtOnAxis = cone.ApexPoint.DistanceTo(pt_onAxis)
if apexToPtOnAxis <= sc.doc.ModelAbsoluteTolerance:
# Point must be at apex.
return
radiusAtPt = point.DistanceTo(pt_onAxis)
if radiusAtPt >= MAX_ACCEPTED_SIZE:
if bDebug:
print "Cone with {} Radius skipped.".format(
cone_radius_at_srf)
return False
if radiusAtPt < sc.doc.ModelAbsoluteTolerance:
if bDebug:
print "Cone with {} Radius skipped.".format(
cone_radius_at_srf)
return False
# Older method.
# cone_radius_at_srf = (apexToPtOnCone**2.0 - apexToPtOnAxis**2.0)**0.5
# if (cone_radius_at_srf * mmPerModelUnit) >= MAX_ACCEPTED_SIZE:
# if bDebug:
# print "Cone with {} Radius skipped.".format(
# cone_radius_at_srf)
# return False
return True
def Update(self):
#for id in self.ids:
# if id:
# sc.doc.Objects.Delete(id, True)
self.age += 1
#Previous positions
self.prevPos = rg.Point3d(self.pos)
#######################################################
self.size = util.Remap(self.age, 0, 150, 4, 10)
futureXform = rg.Transform.Translation(self.vel)
futureObj = self.brep.Duplicate()
futureObj.Transform(futureXform)
closestD = None
for particle in self.system.particles:
if particle is self: continue
pt0, pt1 = BrepProximity(self.brep, particle.brep)
d = (pt0 - pt1).Length
if d < closestD or closestD is None:
closestD = d
pt0, pt1 = BrepProximity(self.brep, self.system.boundary)
d = (pt0 - pt1).Length
if d < closestD or closestD is None:
closestD = d
if closestD < self.size * 2:
# self.vel.Unitize()
#self.vel *= closestD
self.vel *= 0
else:
self.vel += self.acc
self.pos += self.vel
#if self.pos.Z < 5:
# hit = True
#######################################################
xform = rg.Transform.Translation(self.vel)
self.brep.Transform(xform)
xform = rg.Transform.Scale(self.pos, 1.01)
self.brep.Transform(xform)
self.ids.append(sc.doc.Objects.AddBrep(self.brep, self.attr))
def get_center_of_points(self, points):
sum_x = 0
sum_y = 0
for p in points:
sum_x += p.X
sum_y += p.Y
avrg_x = sum_x / len(points)
avrg_y = sum_y / len(points)
avrg_p = rg.Point3d(avrg_x, avrg_y, points[0].Z)
return avrg_p
def get_avrg_center(self, point_list):
sum_x = 0
sum_y = 0
for p in point_list:
sum_x += p.X
sum_y += p.Y
avrg_x = sum_x / len(point_list)
avrg_y = sum_y / len(point_list)
avrg_p = rg.Point3d(avrg_x, avrg_y, point_list[0].Z)
return avrg_p
def anglesCheck(self):
vect1 = rs.VectorCreate(self.points[-2], self.points[-3])
vect2 = rs.VectorCreate(self.points[-1], self.points[-2])
norm = self.mesh.NormalAt(self.mpos)
alpha = g.Vector3d.VectorAngle(vect1, vect2)
# check the tolerance angle
if alpha > angleTol and norm.Z < 0: # if the angle between 2 moves larger than tolerance
self.state = 'off' # the waterflow is off the facade
edgePoints.append(self.pos)
# check the drop angle
alpha = g.Vector3d.VectorAngle(vect2, g.Vector3d(0., 0., -1.))
if alpha > (math.pi / 2 -
angleDrop) and norm.Z < 0: # if the geometry is too steep
self.state = 'off' # the waterflow is off the facade
def __init__(self, rows, columns, step):
self.rows = rows
self.columns = columns
self.step = step
# make grid, which is a 2d-array
# [[p00], [p10], etc
# [p01], [p11],
# etc, etc ]]
self._grid = []
for u in range(columns):
self._grid.append([])
for v in range(rows):
currentPos = rg.Point3d(u * self.step, 0, v * self.step)
self._grid[u].append(Particle(currentPos, (u, v)))
def apply(self, v):
loc, direction = self.dot_map.position_based(v.vec_version)
l = (loc.X**2. + (loc.Y * self.y_scale)**2.)**.5
if not (isinstance(self.ee, type(None))):
amp = self.a * self.ee.scale_val(v.vec_version.X)
else:
amp = self.a
if l > self.r:
return v.v
else:
scale_val = direction * amp * (1. - l / self.r)
return rg.Point3d(v.o + v.n * scale_val)
def CreateAngle(self):
pt = rg.Point3d(self.length, 0, self.length)
self.planeEnd = rg.Plane.WorldYZ
self.planeEnd.Origin = pt
centerPt = rg.Point3d(self.length, 0, 0)
origin = rg.Point3d(0, 0, 0)
centerPlane = rg.Plane(centerPt, origin, pt)
circ = rg.Circle(centerPlane, self.length)
arc = rg.Arc(circ, math.pi * .5)
arc = arc.ToNurbsCurve()
sweep = rg.SweepOneRail()
self.geo = sweep.PerformSweep(arc, self.sec)[0]
def __init__(self, system):
self.system = system
self.radius = 2
self.size = 4
self.vel = rg.Vector3d(random.uniform(-1, 1), random.uniform(-1, 1),
random.uniform(-.3, .3))
self.vel.Unitize()
self.speed = random.uniform(1, 2)
self.vel *= self.speed
self.acc = rg.Vector3d(0, 0, 0)
self.attr = rc.DocObjects.ObjectAttributes()
self.attr.ColorSource = rc.DocObjects.ObjectColorSource.ColorFromObject
self.attr.ObjectColor = color.ColorBetweenColors(
drawing.Color.DeepSkyBlue, drawing.Color.LimeGreen,
random.uniform(0, 1))
self.attr.MaterialSource = rc.DocObjects.ObjectMaterialSource.MaterialFromObject
index = sc.doc.Materials.Add()
self.mat = sc.doc.Materials[index]
self.mat.DiffuseColor = self.attr.ObjectColor
self.mat.CommitChanges()
self.attr.MaterialIndex = index
self.pos = geo.RandomPoint(self.size * 2, 100 - self.size * 2,
self.size * 2, 100 - self.size * 2,
self.size * 2, 100 - self.size * 2)
self.xSize = rg.Interval(-self.size * .25, self.size * .25)
self.ySize = rg.Interval(-self.size * .125, self.size * .125)
self.zSize = rg.Interval(-self.size, self.size)
up = rg.Vector3d(0, 0, 1)
xvec = rg.Vector3d.CrossProduct(self.vel, rg.Vector3d(0, 0, 1))
yvec = rg.Vector3d.CrossProduct(self.vel, xvec)
self.plane = rg.Plane(self.pos, yvec, xvec)
self.box = rg.Box(self.plane, self.xSize, self.ySize, self.zSize)
self.boxID = sc.doc.Objects.AddBox(self.box, self.attr)
def nextStepOn(self):
newPlane = rs.PlaneFromNormal(self.pos, self.mesh.NormalAt(self.mpos))
# figure out how much to rotate it to put it in the slope
deltaAngle = g.Vector3d.VectorAngle( newPlane.XAxis, g.Vector3d(0., 0., -1.), newPlane )
# rotate it in the plane
newPlane.Rotate( deltaAngle, newPlane.ZAxis, newPlane.Origin)
# set the movement vector
downVect = newPlane.XAxis
downVect.Unitize()
downVect = rs.VectorScale(downVect, self.stepsize)
spacePoint = g.Point3d.Add(self.pos, downVect)
# find next point
newPoint = self.mesh.ClosestPoint(spacePoint)
newPoint = self.randomDir(newPoint, newPlane)
self.updatePos(newPoint)
def cgvector_to_rgvector(
v,
): # type: (compas.geometry.Vector) -> Rhino.Geometry.Vector3d
"""Convert :class:`compas.geometry.Vector` to :class:`Rhino.Geometry.Vector3d`.
Parameters
----------
v : :class:`compas.geometry.Vector`
Vector object to convert.
Returns
-------
:class:`Rhino.Geometry.Vector3d`
Resulting Vector3d object.
"""
return rg.Vector3d(*v.data)
def UpdatePosition(self):
self.acc = self.pos - rg.Point3d(50, 50, 50)
if self.acc.Length > 10:
self.acc.Reverse()
self.acc.Unitize()
self.acc *= 2.5
rand = geo.RandomVector3d(1)
self.acc += rand
self.vel += self.acc
self.pos += self.vel
xform = rg.Transform.Translation(self.vel)
self.box.Transform(xform)
self.boxBrep.Transform(xform)
def UpdateDisplay(self):
#if self.id: sc.doc.Objects.Delete(self.id, True)
if self.plineId: sc.doc.Objects.Delete(self.plineId, True)
if self.meshID: sc.doc.Objects.Delete(self.meshID, True)
mesh = rg.Mesh()
for neighbor in self.neighbors:
for neighborNeighbor in neighbor.neighbors:
if neighborNeighbor in self.neighbors:
id0 = mesh.Vertices.Add(self.pos)
id1 = mesh.Vertices.Add(neighbor.pos)
id2 = mesh.Vertices.Add(neighborNeighbor.pos)
face = mesh.Faces.AddFace(id0, id1, id2)
self.meshID = sc.doc.Objects.AddMesh(mesh)
def main(field):
check_data = True
##check inputs
if field is None:
check_data = False
msg = "No field provided"
ghenv.Component.AddRuntimeMessage(
gh.Kernel.GH_RuntimeMessageLevel.Warning, msg)
if check_data:
return field.name, field.resolution, field.boundaries, field.pts, field.return_values_list(
), rg.Vector3d(field.x_count, field.y_count, field.z_count)
else:
return -1
def cgplane_to_rgplane(
cgplane, ): # type: (compas.geometry.Plane) -> Rhino.Geometry.Plane
"""Convert :class:`compas.geometry.Plane` to :class:`Rhino.Geometry.Plane`.
Parameters
----------
cgplane : :class:`compas.geometry.Plane`
Plane to convert.
Returns
-------
:class:`Rhino.Geometry.Plane`
Resulting plane.
"""
return rg.Plane(cgpoint_to_rgpoint(cgplane.point),
cgvector_to_rgvector(cgplane.normal))
def cgline_to_rgline(
line): # type: (compas.geometry.Line) -> Rhino.Geometry.Line
"""Convert :class:`compas.geometry.Line` to :class:`Rhino.Geometry.Line`.
Parameters
----------
line : :class:`compas.geometry.Line`
Point object to convert.
Returns
-------
:class:`Rhino.Geometry.Line`
Resulting Line object.
"""
return rg.Line(cgpoint_to_rgpoint(line.start),
cgpoint_to_rgpoint(line.end))
def test_get_mapped_point(self):
from_frame = trans.Frame.create_frame_from_normal_and_x(
origin=geom.Point3d(1, -2, 1),
normal=geom.Vector3d(0, 0, 1),
x=geom.Vector3d(1, 0, 0))
from_frame.show()
to_frame = trans.Frame.create_frame_from_normal_and_x(
origin=geom.Point3d(3, 3, 0),
normal=geom.Vector3d(0, 0, 1),
x=geom.Vector3d(-1, 0, 0))
to_frame.show()
pnt = geom.Point3d(2, -1, 1)
correct_point = geom.Point3d(2, 2, 0)
new_point = trans.get_mapped_point(pnt, from_frame, to_frame)
self.assertTrue(correct_point.Equals(new_point))
rs.AddPoint(pnt)
rs.AddPoint(new_point)
rs.AddPoint(correct_point)
def __init__(self, targets, iv):
self.numVoxels = 25
self.voxelSize = 4
self.grad = color.GetGradient(10)
self.targets = []
self.isoValue = iv
self.mesh = rg.Mesh()
self.id = None
self.pts = []
self.ptsCollection = rc.Collections.Point3dList()
self.targets = targets
self.attr = rc.DocObjects.ObjectAttributes()
self.attr.ColorSource = rc.DocObjects.ObjectColorSource.ColorFromObject
grad = color.GetGradient(5)
self.attr.ObjectColor = color.GradientOfColors(
grad, util.Remap(self.isoValue, .3, .5, 0, 1), 3)
self.attr.MaterialSource = rc.DocObjects.ObjectMaterialSource.MaterialFromObject
index = sc.doc.Materials.Add()
mat = sc.doc.Materials[index]
mat.DiffuseColor = self.attr.ObjectColor
mat.CommitChanges()
self.attr.MaterialIndex = index
#Setup Vertices
self.vertices = []
for x in range(self.numVoxels + 1):
yRow = []
for y in range(self.numVoxels + 1):
zRow = []
for z in range(self.numVoxels + 1):
zRow.append(
Vertex(self, x * self.voxelSize, y * self.voxelSize,
z * self.voxelSize, x, y, z))
yRow.append(zRow)
self.vertices.append(yRow)
#Setup Voxels
self.voxels = []
index = 0
for x in range(self.numVoxels):
for y in range(self.numVoxels):
for z in range(self.numVoxels):
self.voxels.append(
Voxel(self, x * self.voxelSize, y * self.voxelSize,
z * self.voxelSize, x, y, z))
def create_box(self, size_):
w = float(size_)
h = float(size_)
d = float(size_)
p0 = rg.Point3d(0, 0, 0)
p1 = rg.Point3d(w, 0, 0)
p2 = rg.Point3d(w, d, 0)
p3 = rg.Point3d(0, d, 0)
p4 = rg.Point3d(0, 0, h)
p5 = rg.Point3d(w, 0, h)
p6 = rg.Point3d(w, d, h)
p7 = rg.Point3d(0, d, h)
box_ = rg.Brep.CreateFromBox([p0, p1, p2, p3, p4, p5, p6, p7])
return box_
def nextStep(self):
newPlane = rs.PlaneFromNormal(self.pos, self.mesh.NormalAt(self.mpos))
# create a vector from newFrame XAxis
downVect = newPlane.XAxis
downVect.Unitize()
# figure out how much to rotate it.
deltaAngle = g.Vector3d.VectorAngle(downVect,
g.Vector3d(0.0, 0.0,
-1.0), newPlane)
# rotate it in the plane
downVect.Rotate(deltaAngle, newPlane.ZAxis)
# set the length
downVect = rs.VectorScale(downVect, self.stepsize)
spacePoint = g.Point3d.Add(self.pos, downVect)
# find next point
newPoint = self.mesh.ClosestPoint(spacePoint)
self.updatePos(newPoint)
def AvoidNeighborPaths(self):
futureVel = self.vel.Clone()
futurePos = self.pos.Clone()
futureVel += self.acc
futurePos += futureVel
self.plane.Origin = self.pos
self.plane.ZAxis = futureVel
self.plane.UpdateEquation()
#self.plane = rg.Plane(self.pos, futureVel)
rect = rg.Rectangle3d(self.plane, self.size, self.size)
rect = rect.ToNurbsCurve()
#sc.doc.Objects.AddCurve(rect)
self.history.append(rect)
self.historyPos.append(self.pos)
def makeCurves(self):
self.pts_set = []
crv_set = []
for layer_i, layer_set in enumerate(self.pattern_set):
pt_set = [vertex.v for vertex in layer_set]
pt_set = pt_set + self.normal_set[layer_i] + [pt_set[0]]
self.pts_set.append(pt_set)
crv = rg.Polyline(pt_set)
crv_set.append(crv)
return crv_set
def __init__(self):
self.particles = []
self.m = rg.Mesh()
self.mID = None
self.pn = perlin.SimplexNoise()
for i in range(30):
self.particles.append(Particle(self))
for item in self.particles:
item.AssignNeighbors()
#self.m = rg.Mesh()
#for item in self.particles:
# item.CreateMesh()
self.mID = sc.doc.Objects.AddMesh(self.m)
def intersect_point_normal_check(i):
"""Intersect all of the vectors of a given point with a normal check."""
pt, normal_vec = points[i], normals[i]
int_list = []
angle_list = []
for vec in vectors:
vec_angle = rg.Vector3d.VectorAngle(normal_vec, vec)
angle_list.append(vec_angle)
if vec_angle <= cutoff_angle:
ray = rg.Ray3d(pt, vec)
is_clear = 0 if rg.Intersect.Intersection.MeshRay(
mesh, ray) >= 0 else 1
int_list.append(is_clear)
else: # the vector is pointing behind the surface
int_list.append(0)
intersection_matrix[i] = int_list
angle_matrix[i] = angle_list
def matrix_to_rgtransform(M):
"""Create :class:`Rhino.Geometry.Transform` from a transformation matrix.
Parameters
----------
M : :class:`list` of :class:`list` of :class:`float`
Transformation matrix.
Returns
-------
:class:`Rhino.Geometry.Transform`
"""
rgM = rg.Transform()
for i, row in enumerate(M):
for j, val in enumerate(row):
rgM[i, j] = val
return rgM
