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