def xdraw_frame(frame): """Draw frame. """ pt = Point3d(*iter(frame.point)) xaxis = Vector3d(*iter(frame.xaxis)) yaxis = Vector3d(*iter(frame.yaxis)) return Plane(pt, xaxis, yaxis)
def __init__(self): self.position = Point3d(random.randint(box.x[0], b_x), random.randint(box.y[0], b_y), random.randint(box.z[0], b_z)) self.velocity = Vector3d(random.random(), random.random(), random.random()) self.acceleration = Vector3d(0, 0, 0) self.max_speed = 3 self.max_force = 0.3 self.trail = []
def rhino_volmesh_vertex_lift(volmesh): """Rhino wrapper for the vertex lift operation. """ vertex = VolMeshSelector.select_vertex(volmesh) vertex_hfkeys = [] for hfkey in volmesh.vertex_halffaces(vertex): if volmesh.is_halfface_on_boundary(hfkey): vertex_hfkeys.append(hfkey) xyz = volmesh.vertex_coordinates(vertex) normal = volmesh.vertex_normal(vertex) def OnDynamicDraw(sender, e): cp = e.CurrentPoint for hfkey in vertex_hfkeys: for vertex in volmesh.halfface_vertices(hfkey): sp = volmesh.vertex_coordinates(vertex) e.Display.DrawLine(Point3d(*sp), cp, black, 2) ip = Point3d(*xyz) axis = Rhino.Geometry.Line(ip, ip + Vector3d(*normal)) gp = get_target_point(axis, OnDynamicDraw) volmesh_vertex_lift(volmesh, vertex, gp, vertex_hfkeys) volmesh.draw()
def draw_circles(circles, **kwargs): guids = [] for data in iter(circles): point, normal = data['plane'] radius = data['radius'] name = data.get('name', '') color = data.get('color') layer = data.get('layer') circle = Circle(Plane(Point3d(*point), Vector3d(*normal)), radius) guid = add_circle(circle) if not guid: continue obj = find_object(guid) if not obj: continue attr = obj.Attributes if color: attr.ObjectColor = FromArgb(*color) attr.ColorSource = ColorFromObject else: attr.ColorSource = ColorFromLayer if layer and find_layer_by_fullpath: index = find_layer_by_fullpath(layer, True) if index >= 0: attr.LayerIndex = index attr.Name = name attr.WireDensity = -1 obj.CommitChanges() guids.append(guid) return guids
def draw_circles(circles): """Draw circles in Grasshopper. Parameters ---------- circles : list of dict The circle definitions. Returns ------- list of :class:`Rhino.Geometry.Circle` Notes ----- .. code-block:: python Schema({ 'plane': lambda x: len(x[0]) == 3 and len(x[1]) == 3, 'radius': And(Or(int, float), lambda x: x > 0) }) """ rg_circles = [] for c in iter(circles): point, normal = c['plane'] radius = c['radius'] rg_circles.append( Circle(Plane(Point3d(*point), Vector3d(*normal)), radius)) return rg_circles
def alignment(self, boids, radius=5, angle=10): neighbors = self.get_neighbors(boids, radius, angle) if len(neighbors) > 0: n_neighbors = len(neighbors) pox = 0 poy = 0 poz = 0 for i in neighbors: pox += i.velocity.X poy += i.velocity.Y poz += i.velocity.Z center = Vector3d(pox / n_neighbors, poy / n_neighbors, poz / n_neighbors) return center - self.velocity else: return Vector3d(0, 0, 0)
def set_values(self, values, boundaries=[]): try: v = values[0][2] self.is_tensor_field = True except: self.is_tensor_field = False pts_count = 0 if len(values) > 0: for z in range(0, self.z_count): self.vals.append([]) for y in range(0, self.y_count): self.vals[z].append([]) for x in range(0, self.x_count): if len(boundaries) > 0: inside = False for bou in boundaries: if bou.IsPointInside(self.pts[pts_count], global_tolerance, True) == True: self.vals[z][y].append(values[pts_count]) inside = True break if inside == False: if self.is_tensor_field: self.vals[z][y].append(Vector3d(0, 0, 0)) else: self.vals[z][y].append(0.0) else: self.vals[z][y].append(values[pts_count]) pts_count += 1
def draw_circles(circles): """Draw circles in Grasshopper. """ rg_circles = [] for c in iter(circles): point, normal = c['plane'] radius = c['radius'] rg_circles.append(Circle(Plane(Point3d(*point), Vector3d(*normal)), radius)) return rg_circles
def draw_circles(circles, **kwargs): """Draw circles and optionally set individual name, color, and layer properties. Parameters ---------- circles : list[dict] A list of circle dictionaries. See Notes, for more information about the structure of the dict. Returns ------- list[System.Guid] Notes ----- A circle dict has the following schema: .. code-block:: python Schema({ 'plane': lambda x: len(x[0]) == 3 and len(x[1]) == 3, 'radius': And(Or(int, float), lambda x: x > 0), Optional('name', default=''): str, Optional('color', default=None): And(lambda x: len(x) == 3, all(0 <= y <= 255 for y in x)), Optional('layer', default=None): str }) """ guids = [] for data in iter(circles): point, normal = data['plane'] radius = data['radius'] name = data.get('name', '') color = data.get('color') layer = data.get('layer') circle = Circle(Plane(Point3d(*point), Vector3d(*normal)), radius) guid = add_circle(circle) if not guid: continue obj = find_object(guid) if not obj: continue attr = obj.Attributes if color: attr.ObjectColor = FromArgb(*color) attr.ColorSource = ColorFromObject else: attr.ColorSource = ColorFromLayer if layer and find_layer_by_fullpath: index = find_layer_by_fullpath(layer, True) if index >= 0: attr.LayerIndex = index attr.Name = name attr.WireDensity = -1 obj.CommitChanges() guids.append(guid) return guids
def smartPointProject(smartPoints, brep, vector=Vector3d(0.0,0.0,1.0), tolerance=0.001): resultSet = [] # project everything for smartPt in smartPoints: result = Rhino.Geometry.Intersect.Intersection.ProjectPointsToBreps([brep], [smartPt.geom], vector, tolerance) if len(result) > 0: smartPt.geom = result[0] resultSet.append(smartPt) return resultSet
def vector_to_rhino(vector): """Convert a COMPAS vector to a Rhino vector. Parameters ---------- vector : :class:`compas.geometry.Vector` Returns ------- :class:`Rhino.Geometry.Vector3d` """ return Vector3d(vector[0], vector[1], vector[2])
def align(self, others): #generate list of other Boid headings headings = [other.heading for other in others] #empty vector creation uberVector = Vector3d(0.0, 0.0, 0.0) #add up all headings for heading in headings: uberVector = Vector3d.Add(uberVector, heading) #remove magnitude from sum of all headings uberVector = Vector3d.Divide(uberVector, uberVector.Length) #set Boids heading to aligned vector self.heading = uberVector
def __init__(self, name, boundaries, pts, count_vec, resolution, values=[]): self.name = name self.resolution = resolution self.boundaries = boundaries self.pts = pts self.bbox = BoundingBox(pts) self.x_count = int(count_vec.X) self.y_count = int(count_vec.Y) self.z_count = int(count_vec.Z) self.vals = [] pts_count = 0 self.is_tensor_field = False try: v = values[0][2] self.is_tensor_field = True except: pass if len(values) > 0: for z in range(0, self.z_count): self.vals.append([]) for y in range(0, self.y_count): self.vals[z].append([]) for x in range(0, self.x_count): if len(self.boundaries) > 0: inside = False for bou in self.boundaries: if bou.IsPointInside(self.pts[pts_count], global_tolerance, True) == True: self.vals[z][y].append(values[pts_count]) inside = True break if inside == False: if self.is_tensor_field: self.vals[z][y].append(Vector3d(0, 0, 0)) else: self.vals[z][y].append(0.0) else: self.vals[z][y].append(values[pts_count]) pts_count += 1
def trimesh_slice(mesh, planes): """Slice a mesh by a list of planes. Parameters ---------- mesh : tuple of vertices and faces The mesh to slice. planes : list of (point, normal) tuples or compas.geometry.Plane The slicing planes. Returns ------- list of arrays The points defining the slice polylines. Examples -------- >>> from compas.geometry import Sphere, Plane, Point, Vector >>> sphere = Sphere([1, 1, 1], 1) >>> sphere = sphere.to_vertices_and_faces(u=30, v=30) >>> P1 = Plane(Point(0, 0, 0), Vector(0, -1, 0)) >>> P2 = Plane(Point(0, 0, 0), Vector(0.87, -0.5, 0)) >>> planes = [P1, P2] >>> points = trimesh_slice(sphere, planes) """ # (0) see if input is already Rhino.Geometry.Mesh M = Rhino.Geometry.Mesh() if not isinstance(mesh, Rhino.Geometry.Mesh): for x, y, z in mesh[0]: M.Vertices.Add(x, y, z) for face in mesh[1]: M.Faces.AddFace(*face) else: M = mesh # (1) parse to Rhino.Geometry.Plane P = [] for plane in planes: point = Point3d(plane[0][0], plane[0][1], plane[0][2]) normal = Vector3d(plane[1][0], plane[1][1], plane[1][2]) P.append(Plane(point, normal)) # (2) Slice polylines = MeshPlane(M, P) # (3) Return points in a list of arrays polyline_pts = [] for polyline in polylines: pts = [] for i in range(polyline.Count): pts.append([polyline.X[i], polyline.Y[i], polyline.Z[i]]) polyline_pts.append(pts) return polyline_pts
def contourBrepInZ(brep, stepSize): # get the upper and lower limits bbox = brep.GetBoundingBox(True) zMin, zMax = bbox.Min.Z, bbox.Max.Z zRange = zMax-zMin vect = Vector3d(0.0,0.0,1.0) # the next line is dense planes = [Plane(Point3d(0.0, 0.0, z), vect) for z in RangeTools.drange(zMin,zMax, 0.5)] resultList = [] for plane in planes: curves = brep.CreateContourCurves(brep, plane) resultList.append(curves) return resultList
def __init__(self, _plane, _type, _part, _id): self.pln = _plane flip_pln_Y = Vector3d(self.pln.YAxis) flip_pln_Y.Reverse() self.flip_pln = Plane(self.pln.Origin, self.pln.XAxis, flip_pln_Y) self.type = _type self.part = _part self.id = _id self.rules_table = [] self.active_rules = []
def fromJSON(cls, filePath): with open(filePath, 'r') as file: parsed = json.load(file) system = cls(Point3d(0, 0, 0)) for data in parsed['bodies']: body = Body(data['name'], data['mass'], data['radius']) body.position = Point3d(*data['position']) body.velocity = Vector3d(*data['velocity']) body.color = Color.FromArgb(*data['color']) body.pendown() system.add(body) return system
def _egi_sort_v_nbrs(egi): """ By default, the sorting should be ccw, since the circle is typically drawn ccw around the local plane's z-axis... """ xyz = dict((key, [attr[_] for _ in 'xyz']) for key, attr in egi.vertices(True)) for vkey in egi.vertex: nbrs = egi.vertex[vkey]['nbrs'] plane = Plane(Point3d(*xyz[vkey]), Vector3d(*[axis for axis in egi.vertex[vkey]['normal']])) circle = Circle(plane, 1) p_list = [] for nbr_vkey in nbrs: boolean, parameter = ArcCurve(circle).ClosestPoint(Point3d(*xyz[nbr_vkey])) p_list.append(parameter) sorted_nbrs = [key for (param, key) in sorted(zip(p_list, nbrs))] egi.vertex[vkey]['sorted_nbrs'] = sorted_nbrs
def separation(self, boids, radius=3, angle=10): neighbors = self.get_neighbors(boids, radius, angle) pox = 0 poy = 0 poz = 0 if len(neighbors) > 0: n_neighbors = len(neighbors) for i in neighbors: pox += i.position.X poy += i.position.Y poz += i.position.Z center = Point3d(pox / n_neighbors, poy / n_neighbors, poz / n_neighbors) return (center - self.position) * -1 else: return Vector3d(0, 0, 0)
def interpolatePointsToTerrainMesh(points, terrainMesh): out = [] for pt in points: pts = [pt] meshes = [terrainMesh] vect = Vector3d(0.0,0.0, 1.0) tol = 0.001 intResult = Rhino.Geometry.Intersect.Intersection.ProjectPointsToMeshes(meshes, pts, vect, tol) if len(intResult) == 1: # it hit, and just once out.append(intResult[0]) # add the result elif len(intResult) < 1: # it missed # approximate the z value line = Rhino.Geometry.Line(pt, vect) closPt = terrainMesh.ClosestPoint(pt) roughPt = line.ClosestPoint(closPt, False) closestTerrain = terrainMesh.ClosestPoint(roughPt) roughPt.Z = closestTerrain.Z out.append(roughPt) else: # it hit twice??!! # this appears to happen often. out.append(intResult[0]) # use the first intersection anyway return out
def smartCurveLayerProject(curveLayerName, surfaceLayerName, objectAttributes=None, vector=Vector3d(0.0,0.0,1.0), tolerance=0.001): '''Project a layer contining only curves onto a layer containing a surface, and maintain UserString associations between the original and projected curves. ObjectAttributes can be passed in to predetermine a layer or other data. Returns a list of (Geometry, ObjAttributes) pairs, with user keys set. If anything fails, should print an error message and return an empty set.''' # get the curves objs = scriptcontext.doc.Objects.FindByLayer(curveLayerName) if len(objs) == 0: print 'No Curves found on that layer' return [] # get the surface(s) srfObjs = scriptcontext.doc.Objects.FindByLayer(surfaceLayerName) if len(srfObjs) == 0: print 'no surfaces found on that layer' return [] else: srf = srfObjs[0].Geometry # deal with ObjectAttributes if objectAttributes: att = objectAttributes else: att = Rhino.DocObjects.ObjectAttributes() resultSet = [] # project everything for crvObj in objs: smartCurve = SmartFeature(crvObj) smartAtt = smartCurve.objAttributes(att) projCurves = smartCurve.geom.ProjectToBrep(smartCurve.geom, srf, vector, tolerance) for crv in projCurves: smartPair = (crv, smartAtt) resultSet.append(smartPair) return resultSet
def RunCommand(): # select a surface srfid = rs.GetObject("select serface", rs.filter.surface | rs.filter.polysurface) if not srfid: return # get the brep brep = rs.coercebrep(srfid) if not brep: return x = rs.GetReal("value of x", 0) y = rs.GetReal("value of y", 0) pts = [(abs(point.Z), point.Z) for point in Intersect.Intersection.ProjectPointsToBreps( [brep], [Point3d(x, y, 0)], Vector3d( 0, 0, 1), doc.ModelAbsoluteTolerance)] pts.sort(reverse=True) if pts == []: print "no Z for given X, Y" else: rs.AddPoint(Point3d(x, y, pts[0][1]))
def smartPointLayerProject(pointLayerName, surfaceLayerName, objectAttributes=None, vector=Vector3d(0.0,0.0,1.0), tolerance=0.001): '''Project a layer contining only points onto a layer containing a surface, and maintain UserString associations between the original and projected points. ObjectAttributes can be passed in to predetermine a layer or other data. Returns a list of (Geometry, ObjAttributes) pairs, with user keys set. If anything fails, should print an error message and return an empty set.''' objs = scriptcontext.doc.Objects.FindByLayer(pointLayerName) if len(objs) == 0: print 'No Curves found on %s' % pointLayerName return [] # get the surface(s) srfObjs = scriptcontext.doc.Objects.FindByLayer(surfaceLayerName) if len(srfObjs) == 0: print 'No Surfaces found on %s' % surfaceLayerName return [] else: srf = srfObjs[0].Geometry # deal with ObjectAttributes if objectAttributes: att = objectAttributes else: att = Rhino.DocObjects.ObjectAttributes() resultSet = [] # project everything for ptObj in objs: smartPt = SmartFeature(ptObj) smartAtt = smartPt.objAttributes(att) projPoints = Rhino.Geometry.Intersect.Intersection.ProjectPointsToBreps([srf], [smartPt.geom], vector, tolerance) for pt in projPoints: smartPair = (pt, smartAtt) resultSet.append(smartPair) return resultSet
def __init__(self): self.position = Point3d(random.randint(box.x[0], b_x),random.randint(box.y[0], b_y),random.randint(box.z[0], b_z)) self.velocity = Vector3d(random.random(),random.random(),random.random()) self.trail = []
def rhino_volmesh_pull_halffaces(volmesh, hfkey, uniform=False): # # -------------------------------------------------------------------------- # # 1. display boundary halffaces # # -------------------------------------------------------------------------- # boundary_halffaces = volmesh.halffaces_on_boundaries() # volmesh.clear() # volmesh.draw_edges() # volmesh.draw_faces(faces=boundary_halffaces) # rs.EnableRedraw(True) # # -------------------------------------------------------------------------- # # 2. select halfface and its dependents # # -------------------------------------------------------------------------- # hf_inspector = VolmeshHalffaceInspector(volmesh, # hfkeys=boundary_halffaces, # dependents=True) # hf_inspector.enable() # hfkey = mesh_select_face(volmesh) # hf_inspector.disable() # del hf_inspector # hf dependent hfs dep_hfkeys = volmesh.halfface_manifold_neighborhood(hfkey, ring=50) # -------------------------------------------------------------------------- # 3. move face # -------------------------------------------------------------------------- ckey = volmesh.halfface_cell(hfkey) cell_vkeys = volmesh.cell_vertices(ckey) hf_vkeys = volmesh.halfface_vertices(hfkey) hf_normal = volmesh.halfface_normal(hfkey) hf_center = volmesh.halfface_center(hfkey) edges = {} for u in hf_vkeys: u_nbrs = volmesh.vertex_neighbors(u) for v in u_nbrs: if v in cell_vkeys: if v not in hf_vkeys: edges[u] = v xyz_dict = {} for vkey in cell_vkeys: xyz_dict[vkey] = volmesh.vertex_coordinates(vkey) if uniform: hfkeys = dep_hfkeys + [hfkey] target_normal = _halffaces_avg_normals(volmesh, hfkeys) else: target_normal = None # dynamic draw ------------------------------------------------------------- def OnDynamicDraw(sender, e): cp = e.CurrentPoint xyz = _volmesh_compute_dependent_face_intersections( volmesh, hfkey, cp, target_normal) seen = set() for fkey in dep_hfkeys + [hfkey]: hf_edges = volmesh.halfface_halfedges(fkey) for edge in hf_edges: u = edge[0] v = edge[1] pair = frozenset([u, v]) if pair not in seen: init_u = volmesh.vertex_coordinates(u) init_u_xyz = Point3d(*init_u) u_xyz = Point3d(*xyz[u]) v_xyz = Point3d(*xyz[v]) e.Display.DrawLine(Line(u_xyz, v_xyz), black, 4) e.Display.DrawArrow(Line(init_u_xyz, u_xyz), arrow_color, 12, 0) # e.Display.DrawDottedLine(init_u_xyz, u_xyz, feedback_color) seen.add(pair) for u, v in volmesh.edges_iter(): if frozenset([u, v]) not in seen: sp = volmesh.vertex_coordinates(u) ep = volmesh.vertex_coordinates(v) if u in xyz: sp = xyz[u] if v in xyz: ep = xyz[v] e.Display.DrawLine(Line(Point3d(*sp), Point3d(*ep)), black, 2) # -------------------------------------------------------------------------- # 4. new face location # -------------------------------------------------------------------------- ip = Point3d(*hf_center) line = Rhino.Geometry.Line(ip, ip + Vector3d(*hf_normal)) gp = get_target_point(line, OnDynamicDraw) # -------------------------------------------------------------------------- # 5. update halfface and its dependents # -------------------------------------------------------------------------- new_xyz = _volmesh_compute_dependent_face_intersections( volmesh, hfkey, gp, target_normal) for key in new_xyz: coordinates = new_xyz[key] volmesh.vertex_update_xyz(key, coordinates, constrained=False)
from __future__ import absolute_import
def alingBlock(block_a, block_b, model_inside): """ Scale box to the correct dimentions Align box a and what is inside to box b The dimention of the box is expected to be equal lenght :param block_a: :param block_b: block to align block_a to :param model_inside: models inside block_a """ # Find center of box_a exp_a = rs.ExplodePolysurfaces(block_a) cen_a = Vector3d(0, 0, 0) for exp in exp_a: cen_a += rs.SurfaceAreaCentroid(exp)[0] cen_a /= 6.0 # Find center of box_b exp_b = rs.ExplodePolysurfaces(block_b) cen_b = Vector3d(0, 0, 0) for exp in exp_b: cen_b += rs.SurfaceAreaCentroid(exp)[0] cen_b /= 6.0 # Find side Lenght c = rs.DuplicateEdgeCurves(exp_a[0]) L = float(rs.CurveLength(c[0])) def sqrt_length(a, b, c): return math.sqrt(a * a + b * b + c * c) def create_matrix(a, b, c, d): M = [[a[0], a[1], a[2], d[0]], [b[0], b[1], b[2], d[1]], [c[0], c[1], c[2], d[2]], [0, 0, 0, 1]] return M # find basic function of box_a basic_0 = cen_a - rs.SurfaceAreaCentroid(exp_a[0])[0] basic_0 /= sqrt_length(basic_0[0], basic_0[1], basic_0[2]) basic_1 = rs.SurfaceAreaCentroid(exp_a[1])[0] - cen_a basic_1 /= sqrt_length(basic_1[0], basic_1[1], basic_1[2]) basic_2 = cen_a - rs.SurfaceAreaCentroid(exp_a[4])[0] basic_2 /= sqrt_length(basic_2[0], basic_2[1], basic_2[2]) # create tranformation matrix M = create_matrix(basic_0, basic_1, basic_2, [0, 0, 0]) # scale rs.ScaleObjects([block_a] + model_inside, cen_a, [200 / L, 200 / L, 200 / L]) # move to [0,0,0] rs.MoveObjects([block_a] + model_inside, -cen_a) # rotate rs.TransformObjects([block_a] + model_inside, M) # move to object rs.MoveObjects([block_a] + model_inside, cen_b) rs.DeleteObjects(exp_a) rs.DeleteObjects(exp_b) rs.DeleteObjects(c)
def rhino_cell_face_pull(cell): # -------------------------------------------------------------------------- # 1. pick face # -------------------------------------------------------------------------- cell.draw() face = mesh_select_face(cell) cell_split_indet_face_vertices(cell, face) cell.clear() # -------------------------------------------------------------------------- # 2. face data # -------------------------------------------------------------------------- f_normal = cell.face_normal(face) f_center = cell.face_center(face) f_area = cell.face_area(face) f_vkeys = cell.face_vertices(face) # -------------------------------------------------------------------------- # 3. get neighbor edges and vertex coordinates # -------------------------------------------------------------------------- edges = {} for u in f_vkeys: u_nbrs = cell.vertex_neighbors(u) for v in u_nbrs: if v not in f_vkeys: edges[u] = v xyz_dict = {} for vkey in cell.vertex: if vkey not in f_vkeys: xyz_dict[vkey] = cell.vertex_coordinates(vkey) # -------------------------------------------------------------------------- # 4. dynamic draw # -------------------------------------------------------------------------- rs.EnableRedraw(True) def OnDynamicDraw(sender, e): cp = e.CurrentPoint plane = (cp, f_normal) new_pt_list = [] for u in f_vkeys: v = edges[u] u_xyz = cell.vertex_coordinates(u) v_xyz = cell.vertex_coordinates(v) line = (u_xyz, v_xyz) it = intersection_line_plane(line, plane) xyz_dict[u] = it new_pt_list.append(it) e.Display.DrawDottedLine(Point3d(*u_xyz), Point3d(*it), black) for vkey in cell.vertex: xyz = cell.vertex_coordinates(vkey) e.Display.DrawPoint(Point3d(*xyz), 0, 5, black) # old normal and area -------------------------------------------------- e.Display.DrawDot(Point3d(*f_center), str(round(f_area, 3)), gray, white) # draw original face --------------------------------------------------- for i in range(-1, len(f_vkeys) - 1): vkey1 = f_vkeys[i] vkey2 = f_vkeys[i + 1] sp = Point3d(*cell.vertex_coordinates(vkey1)) np = Point3d(*cell.vertex_coordinates(vkey2)) e.Display.DrawDottedLine(sp, np, black) # get current face info ------------------------------------------------ areas = {} normals = {} for fkey in cell.faces(): face_coordinates = [ xyz_dict[vkey] for vkey in cell.face_vertices(fkey) ] areas[fkey] = polygon_area_oriented(face_coordinates) normals[fkey] = polygon_normal_oriented(face_coordinates) # draw new face areas / vectors ---------------------------------------- for fkey in cell.faces(): area = areas[fkey] normal = normals[fkey] value = area / max(areas.values()) color = i_to_rgb(value) color = FromArgb(*color) # draw vectors ----------------------------------------------------- scale = 0.25 center = datastructure_centroid(cell) sp = Point3d(*center) vector = scale_vector(normal, area * scale) ep = Point3d(*add_vectors(center, vector)) e.Display.DrawArrow(Line(sp, ep), color, 20, 0) # draw face -------------------------------------------------------- face_coordinates = [ xyz_dict[vkey] for vkey in cell.face_vertices(fkey) ] face_coordinates.append(face_coordinates[0]) polygon_xyz = [Point3d(*xyz) for xyz in face_coordinates] e.Display.DrawPolyline(polygon_xyz, black, 2) if fkey == face: e.Display.DrawPolyline(polygon_xyz, black, 4) e.Display.DrawPolygon(polygon_xyz, color, filled=True) # display force magnitudes ----------------------------------------- vector = add_vectors(vector, scale_vector(normalize_vector(normal), 0.75)) xyz = add_vectors(center, vector) if fkey == face: color = black e.Display.DrawDot(Point3d(*xyz), str(round(area, 2)), color, white) # -------------------------------------------------------------------------- # 5. input point # -------------------------------------------------------------------------- ip = Point3d(*f_center) line = Rhino.Geometry.Line(ip, ip + Vector3d(*f_normal)) gp = get_target_point(line, OnDynamicDraw) # -------------------------------------------------------------------------- # 6. update cell coordinates # -------------------------------------------------------------------------- cell_relocate_face(cell, face, gp, f_normal) cell.draw()
def aggregate_field(self, num): added = 0 loops = 0 while added < num: ## avoid endless loops loops += 1 if loops > num * 100: break ## if no part is present in the aggregation, add first random part if len(self.aggregated_parts) == 0 and self.prev_num == 0: first_part = self.parts[random.choice(self.parts.keys())] start_point = None if self.multiple_fields: f_name = first_part.field if (self.mode == 2 or self.mode == 3) and len(self.global_constraints) > 0: start_point = self.field[f_name].return_highest_pt( constraints=self.global_constraints) else: start_point = self.field[f_name].return_highest_pt() else: if (self.mode == 2 or self.mode == 3) and len(self.global_constraints) > 0: start_point = self.field.return_highest_pt( constraints=self.global_constraints) else: start_point = self.field.return_highest_pt() mov_vec = Vector3d.Subtract(Vector3d(start_point), Vector3d(first_part.center)) move_transform = Transform.Translation(mov_vec.X, mov_vec.Y, mov_vec.Z) first_part_trans = first_part.transform(move_transform) for conn in first_part_trans.connections: conn.generate_rules_table(self.rules) first_part_trans.id = 0 self.aggregated_parts.append(first_part_trans) ## compute all possible next parts and append to list self.compute_next_w_field(first_part_trans) added += 1 else: ## if no part is available, exit the aggregation routine and return an error message if self.queue_count == 0: msg = "Could not place " + str(num - added) + " parts" return msg next_data = self.aggregation_queue[self.queue_count - 1] next_part = self.parts[next_data[0]] next_center = Point3d(next_part.center) orientTransform = next_data[2] global_check, coll_check, add_coll_check, missing_sup_check, global_const_check = self.check_all_constraints( next_part, orientTransform) if not global_check: next_part_trans = next_part.transform(orientTransform) next_part_trans.reset_part(self.rules) for conn in next_part_trans.connections: conn.generate_rules_table(self.rules) next_part_trans.id = len(self.aggregated_parts) self.aggregated_parts[next_data[1]].children.append( next_part_trans.id) next_part_trans.parent = self.aggregated_parts[ next_data[1]].id self.aggregated_parts.append(next_part_trans) ## compute all possible next parts and append to list self.compute_next_w_field(next_part_trans) added += 1 ## TO FIX --> do not remove rules when only caused by missing supports self.aggregation_queue.pop() self.queue_values.pop() self.queue_count -= 1
def rhino_volmesh_halfface_pinch(volmesh): hfkeys = _select_boundary_halffaces(volmesh) key = hfkeys[0] center = volmesh.halfface_center(key) normal = volmesh.halfface_oriented_normal(key) line = (center, add_vectors(center, normal)) # -------------------------------------------------------------------------- # dynamic draw # -------------------------------------------------------------------------- rs.EnableRedraw(True) def OnDynamicDraw(sender, e): cp = e.CurrentPoint plane = (cp, normal) line = (center, add_vectors(center, normal)) it = intersection_line_plane(line, plane) translation = subtract_vectors(it, center) dot = dot_vectors(normal, translation) dot = dot / abs(dot) dist = distance_point_point(center, it) * dot for hfkey in hfkeys: hf_center = volmesh.halfface_center(hfkey) hf_normal = volmesh.halfface_oriented_normal(hfkey) ep = add_vectors(hf_center, scale_vector(hf_normal, dist)) e.Display.DrawDottedLine(Point3d(*hf_center), Point3d(*ep), feedback_color) e.Display.DrawPoint(Point3d(*ep), 0, 4, black) for vkey in volmesh.halfface_vertices(hfkey): sp = volmesh.vertex_coordinates(vkey) e.Display.DrawLine(Point3d(*sp), Point3d(*ep), black, 2) # -------------------------------------------------------------------------- # input point # -------------------------------------------------------------------------- ip = Point3d(*center) axis = Rhino.Geometry.Line(ip, ip + Vector3d(*normal)) gp = get_target_point(axis, OnDynamicDraw) plane = (gp, normal) it = intersection_line_plane(line, plane) translation = subtract_vectors(it, center) dot = dot_vectors(normal, translation) dot = dot / abs(dot) rise = distance_point_point(center, it) * dot for hfkey in hfkeys: hf_center = volmesh.halfface_center(hfkey) hf_normal = volmesh.halfface_oriented_normal(hfkey) ep = add_vectors(hf_center, scale_vector(hf_normal, rise)) volmesh_halfface_pinch(volmesh, hfkey, ep) volmesh.draw() return volmesh