points1.append(Point(-7, 2, 2))
points1.append(Point(-6, 3, 1))
points1.append(Point(-4, 3, -1))
points1.append(Point(-3, 5, -2))
spline1 = BSplineCurve.from_points(points1)
points2 = []
points2.append(Point(-4, 0, 2))
points2.append(Point(-2, 2, 0))
points2.append(Point(2, 3, -1))
points2.append(Point(3, 7, -2))
points2.append(Point(4, 9, -1))
spline2 = BSplineCurve.from_points(points2)
surface = BSplineSurface.from_fill(spline1, spline2)
points = Collection(surface.xyz(nu=100, nv=100))
# ==============================================================================
# Viz
# ==============================================================================
mesh = surface.to_vizmesh()
boundary = Polyline(
mesh.vertices_attributes('xyz', keys=mesh.vertices_on_boundary()))
view = App()
view.add(boundary, linewidth=2)
view.add(points, color=(1, 0, 0), size=30)
view.run()
from math import radians from compas.geometry import Pointcloud, Box from compas.geometry import Rotation from compas.geometry import oriented_bounding_box_numpy from compas_view2.app import App cloud = Pointcloud.from_bounds(10, 5, 3, 100) Rz = Rotation.from_axis_and_angle([0.0, 0.0, 1.0], radians(60)) Ry = Rotation.from_axis_and_angle([0.0, 1.0, 0.0], radians(20)) Rx = Rotation.from_axis_and_angle([1.0, 0.0, 0.0], radians(10)) cloud.transform(Rz * Ry * Rx) bbox = oriented_bounding_box_numpy(cloud) box = Box.from_bounding_box(bbox) viewer = App() viewer.add(cloud) viewer.add(box, show_faces=False, linecolor=(1, 0, 0), linewidth=3) viewer.run()
front = Plane([0, -1, 0], [0, -1, 0])
back = Plane([0, +1, 0], [0, +1, 0])
halfspaces = array(
[left.abcd, right.abcd, top.abcd, bottom.abcd, front.abcd, back.abcd],
dtype=float)
interior = array([0, 0, 0], dtype=float)
hsi = HalfspaceIntersection(halfspaces, interior)
hull = ConvexHull(hsi.intersections)
mesh = Mesh.from_vertices_and_faces(
[hsi.intersections[i] for i in hull.vertices], hull.simplices)
mesh.unify_cycles()
to_merge = []
for a, b in combinations(mesh.faces(), 2):
na = Vector(*mesh.face_normal(a))
nb = Vector(*mesh.face_normal(b))
if na.dot(nb) >= 1:
if na.cross(nb).length < 1e-6:
to_merge.append([a, b])
for faces in to_merge:
mesh.merge_faces(faces)
viewer = App()
viewer.add(mesh, show_vertices=True, pointsize=10)
viewer.run()
# ==============================================================================
# Tesselation
# ==============================================================================
tess = ShapeTesselator(shell)
tess.Compute()
vertices = []
triangles = []
for i in range(tess.ObjGetVertexCount()):
xyz = tess.GetVertex(i)
vertices.append(xyz)
for i in range(tess.ObjGetTriangleCount()):
a, b, c = tess.GetTriangleIndex(i)
triangles.append([a, b, c])
mesh = Mesh.from_vertices_and_faces(vertices, triangles)
# ==============================================================================
# Viz
# ==============================================================================
print(mesh.number_of_vertices())
print(mesh.number_of_faces())
viewer = App()
viewer.add(mesh)
viewer.run()
T = Translation.from_vector([0, -1.5, 0])
R = Rotation.from_axis_and_angle([0, 0, 1], radians(45))
surface.transform(R * T)
# ==============================================================================
# AABB
# ==============================================================================
box = surface.aabb()
# ==============================================================================
# Visualisation
# ==============================================================================
view = App()
for row in surface.points:
view.add(Polyline(row),
show_points=True,
pointsize=20,
pointcolor=(1, 0, 0),
linewidth=2,
linecolor=(1.0, 0, 0))
for col in zip(*surface.points):
view.add(Polyline(col), linewidth=2, linecolor=(0, 1.0, 0))
view.add(surface.to_mesh(), show_edges=False)
view.add(box, show_faces=False)
c3.edges_attribute('crease', 3, keys=list(cage.face_halfedges(bottom)))
c4.edges_attribute('crease', 4, keys=list(cage.face_halfedges(top)))
c4.edges_attribute('crease', 4, keys=list(cage.face_halfedges(bottom)))
c5.edges_attribute('crease', 5, keys=list(cage.face_halfedges(top)))
c5.edges_attribute('crease', 5, keys=list(cage.face_halfedges(bottom)))
s0 = c0.subdivide(k=5)
s1 = c1.subdivide(k=5)
s2 = c2.subdivide(k=5)
s3 = c3.subdivide(k=5)
s4 = c4.subdivide(k=5)
s5 = c5.subdivide(k=5)
viewer = App()
viewer.add(c0, show_faces=False, show_edges=True)
viewer.add(s0)
viewer.add(c1, show_faces=False, show_edges=True)
viewer.add(s1)
viewer.add(c2, show_faces=False, show_edges=True)
viewer.add(s2)
viewer.add(c3, show_faces=False, show_edges=True)
viewer.add(s3)
viewer.add(c4, show_faces=False, show_edges=True)
viewer.add(s4)
from compas.geometry import Point from compas.geometry import Polyline, Bezier from compas_occ.geometry import OCCNurbsCurve from compas_view2.app import App from compas_view2.objects import Collection points = [Point(0, 0, 0), Point(3, 6, 0), Point(6, -3, 3), Point(10, 0, 0)] bezier = Bezier(points) points = bezier.locus(10) curve = OCCNurbsCurve.from_interpolation(points) # ============================================================================== # Visualisation # ============================================================================== view = App() view.add(Polyline(curve.locus()), linewidth=3) view.add(Collection(points)) view.run()
from math import pi, cos, sin
from compas.utilities import pairwise
from compas.datastructures import Mesh
from compas_kagome.kagome import Kagome
from compas_view2.app import App
from compas.geometry import Point
# Kagome pattern for a simple patch with one singularity...
n = 5
vertices = [[cos(i / n * 2 * pi),
sin(i / n * 2 * pi), 0.0] for i in range(n)] + [[0.0, 0.0, 0.0]]
faces = [[i, j, n] for i, j in pairwise(list(range(n)) + [0])]
coarse_tri_mesh = Mesh.from_vertices_and_faces(
vertices, faces) # hard-coded coarse triangulated mesh
# ...or Kagome pattern from a polyhedron
# coarse_tri_mesh = Mesh.from_polyhedron(20) # 4 or 20 for tetrahedron (4 faces) and icosahedron (20 faces)
kagome_mesh = Kagome.from_mesh(coarse_tri_mesh,
k=3) # play with density value k
viewer = App()
for fkey in kagome_mesh.singularities():
viewer.add(Point(*kagome_mesh.face_centroid(fkey)))
mesh = Mesh.from_vertices_and_faces(*kagome_mesh.to_vertices_and_faces())
viewer.add(mesh, show_edges=True)
viewer.run()
index1, index2, index3 = trian.Get()
# for j in range(1, 4):
# if j == 1:
# m = index1
# n = index2
# elif j == 2:
# n = index3
# elif j == 3:
# m = index2
# me = BRepBuilderAPI_MakeEdge(tab.Value(m), tab.Value(n))
# if me.IsDone():
# builder.Add(comp, me.Edge())
ex.Next()
# ==============================================================================
# Viz
# ==============================================================================
viewer = App()
# viewer.add(surface.to_mesh())
viewer.add(mesh)
for edge in edges:
curve = OCCNurbsCurve.from_edge(edge)
viewer.add(Polyline(curve.locus(resolution=16)),
linecolor=(1, 0, 0),
linewidth=5)
viewer.run()
from compas.geometry import Point from compas.geometry import Polyline from compas_occ.geometry import OCCNurbsCurve from compas_view2.app import App points1 = [Point(0, 0, 0), Point(1, 1, 0), Point(3, 0, 0)] points2 = [Point(3, 0, 0), Point(4, -2, 0), Point(5, 0, 0)] curve1 = OCCNurbsCurve.from_interpolation(points1) curve2 = OCCNurbsCurve.from_interpolation(points2) joined = curve1.joined(curve2) curve1.join(curve2) # ============================================================================== # Visualisation # ============================================================================== view = App() view.add(Polyline(curve1.locus()), linewidth=3, linecolor=(1, 0, 0)) view.add(Polyline(curve2.locus()), linewidth=3, linecolor=(0, 1, 0)) view.add(Polyline(joined.locus()), linewidth=3, linecolor=(0, 0, 1)) view.run()
# ==============================================================================
# JSON Data
# ==============================================================================
string = surface.to_jsonstring(pretty=True)
print(string)
other = OCCNurbsSurface.from_jsonstring(string)
print(surface == other)
# ==============================================================================
# Visualisation
# ==============================================================================
view = App()
u = surface.u_isocurve(0.5 * sum(surface.u_domain))
v = surface.v_isocurve(0.5 * sum(surface.v_domain))
view.add(Polyline(u.locus()), linewidth=1, linecolor=(0.3, 0.3, 0.3))
view.add(Polyline(v.locus()), linewidth=1, linecolor=(0.3, 0.3, 0.3))
for curve in surface.boundary():
view.add(Polyline(curve.locus()), linewidth=2, linecolor=(0, 0, 0))
view.add(other.to_mesh(), show_edges=False)
view.run()
gyro = mesh_conway_gyro(mesh) join = mesh_conway_join(mesh) kis = mesh_conway_kis(mesh) meta = mesh_conway_meta(mesh) needle = mesh_conway_needle(mesh) ortho = mesh_conway_ortho(mesh) snub = mesh_conway_snub(mesh) truncate = mesh_conway_truncate(mesh) # ============================================================================== # Viz # ============================================================================== T = Translation.from_vector viewer = App() viewer.add(ambo) viewer.add(bevel.transformed(T([3, 0, 0]))) viewer.add(dual.transformed(T([6, 0, 0]))) viewer.add(expand.transformed(T([9, 0, 0]))) viewer.add(gyro.transformed(T([0, 4, 0]))) viewer.add(join.transformed(T([3, 4, 0]))) viewer.add(kis.transformed(T([6, 4, 0]))) viewer.add(meta.transformed(T([9, 4, 0]))) viewer.add(needle.transformed(T([0, 8, 0]))) viewer.add(ortho.transformed(T([3, 8, 0]))) viewer.add(snub.transformed(T([6, 8, 0]))) viewer.add(truncate.transformed(T([9, 8, 0])))
mesh = model.mesh_to_compas() lengths = [mesh.edge_length(*edge) for edge in mesh.edges()] print(mesh.is_valid()) print(min(lengths)) print(max(lengths)) # omesh = model.mesh_to_openmesh() # print(omesh) # ============================================================================== # Viz # ============================================================================== viewer = App(width=1600, height=900) viewer.view.camera.rz = 0 viewer.view.camera.rx = -55 viewer.view.camera.tx = -5 viewer.view.camera.ty = -2 viewer.view.camera.distance = 10 viewer.add(mesh) poa = Point(*plate.vertex_coordinates(poa)) start = poa + Vector(0, 0, 1) vector = Vector(0, 0, -1) load = Arrow(start, vector, body_width=0.03) viewer.add(poa, size=20)
Rz = Rotation.from_axis_and_angle(Vector.Zaxis(),
radians(i * 360 / 30),
point=base)
lines.append(line.transformed(Rz))
intersections = []
for line in lines:
x = surface.intersections_with_line(line)
if x:
intersections.append(x[0])
# ==============================================================================
# Visualisation
# ==============================================================================
view = App(viewmode='ghosted')
for row in surface.points:
view.add(Polyline(row),
show_points=True,
pointsize=20,
pointcolor=(1, 0, 0),
linewidth=2,
linecolor=(0.3, 0.3, 0.3))
for col in zip(*surface.points):
view.add(Polyline(col),
show_points=True,
pointsize=20,
pointcolor=(1, 0, 0),
linewidth=2,
points2 = []
points2.append(Point(-4, 0, 2))
points2.append(Point(-2, 2, 0))
points2.append(Point(2, 3, -1))
points2.append(Point(3, 7, -2))
points2.append(Point(4, 9, -1))
spline2 = BSplineCurve.from_points(points2)
surface = BSplineSurface.from_fill(spline1, spline2)
U, V = meshgrid(surface.uspace(30), surface.vspace(20), 'ij')
frames = [surface.frame_at(u, v) for u, v in zip(flatten(U[1:]), flatten(V))]
# ==============================================================================
# Viz
# ==============================================================================
mesh = surface.to_vizmesh()
boundary = Polyline(
mesh.vertices_attributes('xyz', keys=mesh.vertices_on_boundary()))
view = App()
view.add(mesh)
view.add(boundary, linewidth=2)
for frame in frames:
view.add(frame, size=0.1)
view.run()
points2.append(Point(2, 3, -1))
points2.append(Point(3, 7, -2))
points2.append(Point(4, 9, -1))
spline2 = BSplineCurve.from_points(points2)
surface = BSplineSurface.from_fill(spline1, spline2)
line = Geom_Line(gp_Pnt(0, 4, 0), gp_Dir(0, 0, 1))
# ==============================================================================
# Intersection
# ==============================================================================
intersection = GeomAPI_IntCS(line, surface.occ_surface)
pnt = intersection.Point(1)
point = Point.from_occ(pnt)
# ==============================================================================
# Viz
# ==============================================================================
mesh = surface.to_vizmesh()
boundary = Polyline(
mesh.vertices_attributes('xyz', keys=mesh.vertices_on_boundary()))
view = App()
view.add(mesh)
view.add(boundary, linewidth=2)
view.add(point, size=10, color=(1, 0, 0))
view.run()
# Import
# ==============================================================================
meshes = compas.json_load(FILE_I)
# ==============================================================================
# Construct assembly
# ==============================================================================
assembly = Assembly()
for mesh in meshes:
block = mesh.copy(cls=Block)
assembly.add_block(block)
# ==============================================================================
# Export
# ==============================================================================
compas.json_dump(assembly, FILE_O)
# ==============================================================================
# Viz
# ==============================================================================
viewer = App()
for mesh in meshes:
viewer.add(mesh, show_faces=False, show_edges=True)
viewer.run()
nurbscurve3 = NurbsCurve.from_interpolation(points3)
nurbscurve4 = NurbsCurve.from_interpolation(points4)
nurbscurve5 = NurbsCurve.from_interpolation(points5)
nurbscurve6 = NurbsCurve.from_interpolation(points6)
nurbssurface_4curves = NurbsSurface.from_fill(nurbscurve3,
nurbscurve4,
nurbscurve5,
nurbscurve6,
style='curved')
# ==============================================================================
# Visualisation
# ==============================================================================
view = App()
view.add(Polyline(nurbscurve1.locus()), linewidth=3, linecolor=(1, 0, 0))
view.add(Polyline(nurbscurve2.locus()), linewidth=3, linecolor=(0, 1, 0))
view.add(Polyline(nurbscurve3.locus()), linewidth=3, linecolor=(1, 0, 0))
view.add(Polyline(nurbscurve4.locus()), linewidth=3, linecolor=(0, 1, 0))
view.add(Polyline(nurbscurve5.locus()), linewidth=3, linecolor=(1, 0, 1))
view.add(Polyline(nurbscurve6.locus()), linewidth=3, linecolor=(0, 0, 1))
view.add(nurbssurface_2curves.to_mesh(nu=10))
view.add(nurbssurface_4curves.to_mesh(nu=10))
view.run()
sphere = Sphere(Point(1, 1, 1), 1) sphere = Mesh.from_shape(sphere, u=30, v=30) sphere.quads_to_triangles() B = sphere.to_vertices_and_faces() # ============================================================================== # Remesh the sphere # ============================================================================== B = remesh(B, 0.3, 10) # ============================================================================== # Compute the boolean mesh # ============================================================================== V, F = boolean_union(A, B) mesh = Mesh.from_vertices_and_faces(V, F) # ============================================================================== # Visualize # ============================================================================== viewer = App() viewer.add(mesh, show_edges=True) viewer.run()
planes.append(plane)
# ==============================================================================
# Slice
# ==============================================================================
M = benchy.to_vertices_and_faces()
pointsets = slice_mesh(M, planes)
# ==============================================================================
# Process output
# ==============================================================================
polylines = []
for points in pointsets:
points = [Point(*point) for point in points]
polyline = Polyline(points)
polylines.append(polyline)
# ==============================================================================
# Visualize
# ==============================================================================
viewer = App()
for polyline in polylines:
viewer.add(polyline, linecolor=(1, 0, 0))
viewer.run()
s = 1 / (p - o).length
S = Scale.from_factors([s, s, s])
dodeca.transform(T * T * T * S)
p = Point(*icosa.vertex_coordinates(icosa.get_any_vertex()))
s = 1 / (p - o).length
S = Scale.from_factors([s, s, s])
icosa.transform(T * T * T * T * S)
# ==============================================================================
# Viz
# ==============================================================================
viewer = App()
primal = {
'show_faces': False,
'show_edges': True,
'show_vertices': False,
'linecolor': (0, 0, 0),
'linewidth': 2,
}
dual = {
'show_faces': True,
'show_edges': True,
'show_vertices': True,
'facecolor': (0, 0, 1),
'linecolor': (0, 1, 1),
pointsets = intersection_mesh_mesh(A, B)
# ==============================================================================
# Process output
# ==============================================================================
polylines = []
for points in pointsets:
points = [Point(*point) for point in points]
polyline = Polyline(points)
polylines.append(polyline)
# ==============================================================================
# Visualize
# ==============================================================================
viewer = App()
viewer.add(Mesh.from_vertices_and_faces(*A), facecolor=(1, 0, 0), opacity=0.7)
viewer.add(Mesh.from_vertices_and_faces(*B), facecolor=(0, 1, 0), opacity=0.7)
for polyline in polylines:
viewer.add(polyline,
linecolor=(0, 0, 1),
linewidth=3,
pointcolor=(1, 0, 0),
pointsize=10,
show_points=True)
viewer.run()
# ==============================================================================
T = Translation.from_vector(Point(0, 0, 0) - Point(*before.centroid()))
S = Scale.from_factors([100, 100, 100])
R = Rotation.from_axis_and_angle([1, 0, 0], radians(90))
before.transform(R * S * T)
# ==============================================================================
# Remesh
# ==============================================================================
L = sum(before.edge_length(*edge)
for edge in before.edges()) / before.number_of_edges()
V, F = trimesh_remesh(before.to_vertices_and_faces(), 3 * L)
after = Mesh.from_vertices_and_faces(V, F)
# ==============================================================================
# Viz
# ==============================================================================
viewer = App()
box = Box.from_bounding_box(before.bounding_box())
dx = 1.5 * box.xsize
viewer.add(before)
viewer.add(after.transformed(Translation.from_vector([dx, 0, 0])))
viewer.run()
line = Line(* box.diagonal)
# ==============================================================================
# Slices
# ==============================================================================
N = 9
slices = []
a = line.start
for i in range(1, N + 1):
b = a + line.direction * i * 0.1 * line.length
plane = Plane(b, line.direction)
mesh, B = mesh.slice_plane(plane)
slices.append(B)
slices.append(mesh)
# ==============================================================================
# Exploded viz
# ==============================================================================
viewer = App()
for i, mesh in enumerate(slices):
T = Translation.from_vector(line.direction * i * 0.05 * line.length)
viewer.add(mesh.transformed(T), facecolor=i_to_rgb(i / N, normalize=True))
viewer.run()
from compas_occ.geometry import OCCNurbsCurve from compas_view2.app import App pointsA = [Point(0, 0, 0), Point(3, 6, 0), Point(6, -3, 3), Point(10, 0, 0)] curveA = OCCNurbsCurve.from_points(pointsA) curveA.segment(u=0.2, v=0.5) print(curveA.domain) pointsB = [Point(0, -1, 0), Point(3, 5, 0), Point(6, -4, 3), Point(10, -1, 0)] curveB = OCCNurbsCurve.from_points(pointsB) segment = curveB.segmented(u=0.2, v=0.5) print(curveB.domain) print(segment.domain) # ============================================================================== # Visualisation # ============================================================================== view = App() view.add(Polyline(curveA.locus()), linewidth=4, linecolor=(1, 0, 0)) view.add(Polyline(curveB.locus()), linewidth=1, linecolor=(0, 0, 0)) view.add(Polyline(segment.locus()), linewidth=4, linecolor=(0, 1, 0)) view.run()
# ==============================================================================
assembly = Assembly()
for mesh in meshes:
block = mesh.copy(cls=Block)
assembly.add_block(block)
# ==============================================================================
# Export
# ==============================================================================
compas.json_dump(assembly, FILE_O)
# ==============================================================================
# Viz
# ==============================================================================
viewer = App()
nodes = []
blocks = []
for node in assembly.nodes():
nodes.append(Point(* assembly.node_coordinates(node)))
blocks.append(assembly.node_attribute(node, 'block'))
viewer.add(Collection(nodes))
viewer.add(Collection(blocks), show_faces=True, show_edges=True, facecolor=(0.8, 0.8, 0.8), linecolor=(0, 0, 0))
viewer.run()
# ============================================================================== # Compute the boolean difference # ============================================================================== V, F = boolean_difference(A, B) difference = Mesh.from_vertices_and_faces(V, F) # ============================================================================== # Compute the boolean intersection # ============================================================================== V, F = boolean_intersection(A, B) intersection = Mesh.from_vertices_and_faces(V, F) # ============================================================================== # Visualize # ============================================================================== viewer = App() viewer.add(box, facecolor=(1, 0, 0), opacity=0.5) viewer.add(sphere, facecolor=(0, 0, 1), opacity=0.5) viewer.add(union.transformed(Translation.from_vector([1 * 1.5 * width, 0, 0])), facecolor=(1, 0, 1)) viewer.add(difference.transformed(Translation.from_vector([2 * 1.5 * width, 0, 0])), show_faces=False, show_edges=True, linecolor=(1, 0, 0)) viewer.add(intersection.transformed(Translation.from_vector([2 * 1.5 * width, 0, 0])), facecolor=(0, 1, 0)) viewer.run()
spline1 = BSplineCurve.from_points(points1)
points2 = []
points2.append(Point(-4, 0, 2))
points2.append(Point(-2, 2, 0))
points2.append(Point(2, 3, -1))
points2.append(Point(3, 7, -2))
points2.append(Point(4, 9, -1))
spline2 = BSplineCurve.from_points(points2)
surface = BSplineSurface.from_fill(spline1, spline2)
points = surface.xyz(nu=30, nv=20)
n = len(points)
colors = [i_to_rgb(i / n, normalize=True) for i in range(n)]
# ==============================================================================
# Viz
# ==============================================================================
mesh = surface.to_vizmesh()
boundary = Polyline(
mesh.vertices_attributes('xyz', keys=mesh.vertices_on_boundary()))
view = App()
view.add(mesh)
view.add(boundary, linewidth=2)
view.add(Collection(points), colors=colors, size=10)
view.run()
from compas.geometry import Vector, Point, Plane
from compas.geometry import Polyline
from compas.geometry import Circle
from compas_occ.geometry import OCCNurbsCurve
from compas_view2.app import App
circle = Circle(Plane(Point(0, 0, 0), Vector(0, 0, 1)), 1.0)
curve = OCCNurbsCurve.from_circle(circle)
# ==============================================================================
# Visualisation
# ==============================================================================
view = App()
view.add(Polyline(curve.locus()), linewidth=3)
view.add(Polyline(curve.points),
show_points=True,
pointsize=20,
pointcolor=(1, 0, 0),
linewidth=1,
linecolor=(0.3, 0.3, 0.3))
view.run()
model.generate_mesh() model.optimize_mesh() # ============================================================================== # COMPAS mesh # ============================================================================== mesh = model.mesh_to_compas() mesh.transform(Translation.from_vector([4 * R, 0, 0])) # ============================================================================== # Visualization with viewer # ============================================================================== viewer = App(width=1600, height=900) viewer.view.camera.rz = -35 viewer.view.camera.rx = -75 viewer.view.camera.tx = -2 * R viewer.view.camera.ty = 1 viewer.view.camera.distance = 12 viewer.add(sphere, u=32, v=32, opacity=0.5, color=(1, 0, 0)) viewer.add(box, opacity=0.5, color=(0, 1, 0)) viewer.add(cylx, u=32, opacity=0.5, color=(0, 0, 1)) viewer.add(cyly, u=32, opacity=0.5, color=(0, 0, 1)) viewer.add(cylz, u=32, opacity=0.5, color=(0, 0, 1)) viewer.add(mesh) viewer.run()
