Geometry#

geometry_bounding_volume.py#

 1# ----------------------------------------------------------------------------
 2# -                        CloudViewer: www.cloudViewer.org                  -
 3# ----------------------------------------------------------------------------
 4# Copyright (c) 2018-2024 www.cloudViewer.org
 5# SPDX-License-Identifier: MIT
 6# ----------------------------------------------------------------------------
 7
 8import cloudViewer as cv3d
 9
10
11def mesh_generator():
12    mesh = cv3d.geometry.ccMesh.create_arrow()
13    mesh.compute_vertex_normals()
14    mesh.rotate(mesh.get_rotation_matrix_from_xyz((0.3, 0.5, 0.1)))
15
16    yield "rotated box mesh", mesh
17    yield "rotated box pcd", mesh.sample_points_uniformly(500)
18
19    armadillo = cv3d.data.ArmadilloMesh()
20    mesh_armadillo = cv3d.io.read_triangle_mesh(armadillo.path)
21    mesh_armadillo.compute_vertex_normals()
22    yield "armadillo mesh", mesh_armadillo
23    yield "armadillo pcd", mesh_armadillo.sample_points_uniformly(500)
24
25
26if __name__ == "__main__":
27    for name, geom in mesh_generator():
28        aabox = geom.get_axis_aligned_bounding_box()
29        print("%s has an axis aligned box volume of %f" %
30              (name, aabox.volume()))
31        obox = geom.get_oriented_bounding_box()
32        print("%s has an oriented box volume of %f" % (name, obox.volume()))
33        aabox.set_color([1, 0, 0])
34        obox.set_color([0, 1, 0])
35        cv3d.visualization.draw_geometries([geom, aabox, obox])
36
37    armadillo = cv3d.data.ArmadilloMesh()
38    mesh = cv3d.io.read_triangle_mesh(armadillo.path)
39    mesh.compute_vertex_normals()
40    bbox = cv3d.geometry.ccBBox(min_bound=(-30, 0, -10), max_bound=(10, 20, 10))
41    cv3d.visualization.draw_geometries([mesh, bbox])
42    cv3d.visualization.draw_geometries([mesh.crop(bbox), bbox])
43
44    bbox = cv3d.geometry.ecvOrientedBBox(
45        center=(-10, 10, 0),
46        R=bbox.get_rotation_matrix_from_xyz((2, 1, 0)),
47        extent=(40, 20, 20),
48    )
49    cv3d.visualization.draw_geometries([mesh, bbox])
50    cv3d.visualization.draw_geometries([mesh.crop(bbox), bbox])
51
52    pcd = mesh.sample_points_uniformly(500000)
53
54    bbox = cv3d.geometry.ccBBox(min_bound=(-30, 0, -10), max_bound=(10, 20, 10))
55    cv3d.visualization.draw_geometries([pcd, bbox])
56    cv3d.visualization.draw_geometries([pcd.crop(bbox), bbox])
57
58    obbox = cv3d.geometry.ecvOrientedBBox(
59        center=(-10, 10, 0),
60        R=bbox.get_rotation_matrix_from_xyz((2, 1, 0)),
61        extent=(40, 20, 20),
62    )
63    cv3d.visualization.draw_geometries([pcd, obbox])
64    cv3d.visualization.draw_geometries([pcd.crop(obbox), obbox])

geometry_facets.py#

 1# ----------------------------------------------------------------------------
 2# -                        CloudViewer: www.cloudViewer.org                  -
 3# ----------------------------------------------------------------------------
 4# Copyright (c) 2018-2024 www.cloudViewer.org
 5# SPDX-License-Identifier: MIT
 6# ----------------------------------------------------------------------------
 7
 8import cloudViewer as cv3d
 9
10
11def generate_from_point_cloud():
12    print("Load a ply point cloud, print it, and render it")
13    ply_data = cv3d.data.PLYPointCloud()
14    pc = cv3d.io.read_point_cloud(ply_data.path)
15    facet = cv3d.geometry.ccFacet.Create(cloud=pc, max_edge_length=0)
16    print(facet)
17    facet.get_polygon().set_temp_color([0, 0, 0.5])
18    facet.get_polygon().set_opacity(0.5)
19    facet.get_polygon().clear_triangle_normals()
20    facet.get_polygon().compute_vertex_normals()
21    facet.get_contour().set_color([1, 0, 1])
22    facet.get_contour().set_width(9)
23    facet.show_normal_vector(True)
24    return [facet]
25
26
27def generate_from_file():
28    print("Load a facets data, print it, and render it")
29    cv3d.data.set_custom_downloads_prefix(
30        "https://github.com/Asher-1/cloudViewer_downloads/releases/download/")
31    facets_data = cv3d.data.FacetsModel()
32    entity = cv3d.io.read_entity(facets_data.path)
33    facets = entity.filter_children(recursive=False,
34                                    filter=cv3d.geometry.ccHObject.FACET)
35    print(facets)
36    for facet in facets:
37        facet.get_polygon().set_temp_color([0.5, 0, 0])
38        facet.get_polygon().set_opacity(0.5)
39        facet.get_polygon().clear_triangle_normals()
40        facet.get_polygon().compute_vertex_normals()
41        facet.get_contour().set_color([0, 1, 0])
42        facet.get_contour().set_width(9)
43        facet.show_normal_vector(True)
44    return facets
45
46
47def facets_generator():
48    yield "facet1", generate_from_file()
49    yield "facet2", generate_from_point_cloud()
50
51
52if __name__ == "__main__":
53    cv3d.utility.set_verbosity_level(cv3d.utility.Debug)
54    for name, facets in facets_generator():
55        print("{}: RMS {}, Area {}, normal {}".format(name, facets[0].get_rms(),
56                                                      facets[0].get_area(),
57                                                      facets[0].get_normal()))
58        cv3d.visualization.draw_geometries(facets, mesh_show_back_face=True)

geometry_polyline.py#

  1# ----------------------------------------------------------------------------
  2# -                        CloudViewer: www.cloudViewer.org                  -
  3# ----------------------------------------------------------------------------
  4# Copyright (c) 2018-2024 www.cloudViewer.org
  5# SPDX-License-Identifier: MIT
  6# ----------------------------------------------------------------------------
  7
  8import numpy as np
  9import cloudViewer as cv3d
 10
 11
 12def get_circle(cx=0., cy=0., r=2., plane="xy"):
 13    theta = np.arange(0, 2 * np.pi, 0.01)
 14    x = cx + r * np.cos(theta)
 15    y = cy + r * np.sin(theta)
 16    z = np.zeros(y.shape[0])
 17    x = x.reshape((-1, 1))
 18    y = y.reshape((-1, 1))
 19    z = z.reshape((-1, 1))
 20    if plane.lower() in ["xy", "yx"]:
 21        cloud = np.concatenate((x, y, z), axis=1)
 22    elif plane.lower() in ["xz", "zx"]:
 23        cloud = np.concatenate((x, z, y), axis=1)
 24    elif plane.lower() in ["yz", "zy"]:
 25        cloud = np.concatenate((z, x, y), axis=1)
 26    else:
 27        assert False, "invalid plane parameters!"
 28    return cloud
 29
 30
 31def generate_pivots():
 32    circle1 = get_circle(cx=0., cy=0., r=2., plane="xy")
 33    cloud1 = cv3d.geometry.ccPointCloud(cv3d.utility.Vector3dVector(circle1))
 34    circle2 = get_circle(cx=0., cy=0., r=2., plane="xz")
 35    cloud2 = cv3d.geometry.ccPointCloud(cv3d.utility.Vector3dVector(circle2))
 36    circle3 = get_circle(cx=0., cy=0., r=2., plane="yz")
 37    cloud3 = cv3d.geometry.ccPointCloud(cv3d.utility.Vector3dVector(circle3))
 38    polyline1 = cv3d.geometry.ccPolyline(cloud1)
 39    polyline2 = cv3d.geometry.ccPolyline(cloud2)
 40    polyline3 = cv3d.geometry.ccPolyline(cloud3)
 41    polyline1.set_color([1, 0, 0])
 42    polyline2.set_color([0, 1, 0])
 43    polyline3.set_color([0, 0, 1])
 44    return polyline1, polyline2, polyline3
 45
 46
 47def generate_spring():
 48    z = np.arange(-50, 50, 0.01)  # z -50~50
 49    x = 50 * np.cos(z)
 50    y = 50 * np.sin(z)
 51    x = x.reshape((-1, 1))
 52    y = y.reshape((-1, 1))
 53    z = z.reshape((-1, 1))
 54    points = np.concatenate((x, y, z), axis=1)
 55    return [wrap_polyline(points, color=(0, 1, 0))]
 56
 57
 58def generate_funnel(start, end, steps=0.1):
 59    z = np.arange(start, end, steps)
 60    x = z * np.cos(z)
 61    y = z * np.sin(z)
 62    x = x.reshape((-1, 1))
 63    y = y.reshape((-1, 1))
 64    z = z.reshape((-1, 1))
 65    points = np.concatenate((x, y, z), axis=1)
 66    return points
 67
 68
 69def wrap_polyline(points, color):
 70    cloud = cv3d.geometry.ccPointCloud(cv3d.utility.Vector3dVector(points))
 71    polyline = cv3d.geometry.ccPolyline(cloud=cloud)
 72    polyline.set_color(color)
 73    return polyline
 74
 75
 76def generate_from_file():
 77    print("Load a polylines data, print it, and render it")
 78    cv3d.data.set_custom_downloads_prefix(
 79        "https://github.com/Asher-1/cloudViewer_downloads/releases/download/")
 80    polylines_data = cv3d.data.PolylinesModel()
 81    entity = cv3d.io.read_entity(polylines_data.path)
 82    polylines = entity.filter_children(recursive=False,
 83                                       filter=cv3d.geometry.ccHObject.POLY_LINE)
 84    print(polylines)
 85    for poly in polylines:
 86        poly.set_color([0, 0, 1])
 87        poly.set_width(10)
 88    return polylines
 89
 90
 91def polylines_generator():
 92    yield "polylines", generate_from_file()
 93    polyline = wrap_polyline(generate_funnel(-50, 0, 0.1), color=(1, 0, 0)) + \
 94               wrap_polyline(generate_funnel(0, 50, 0.1), color=(0, 1, 0))
 95    polyline.set_closed(False)
 96    polyline.set_2d_mode(True)
 97    yield "Spline", [polyline]
 98    yield "Spring", generate_spring()
 99    yield "Pivots", generate_pivots()
100
101
102if __name__ == "__main__":
103    cv3d.utility.set_verbosity_level(cv3d.utility.Debug)
104    for name, polys in polylines_generator():
105        print("{}: line width {}, color {}".format(name, polys[0].get_width(),
106                                                   polys[0].get_color()))
107        print("{}: isClosed {}, 2D_mode {}".format(name, polys[0].is_closed(),
108                                                   polys[0].is_2d_mode()))
109        cv3d.visualization.draw_geometries(polys)
110
111        vertex_list = []
112        for poly in polys:
113            vertex = poly.sample_points(True, 10., True)
114            vertex.paint_uniform_color(poly.get_color())
115            vertex_list.append(vertex)
116        cv3d.visualization.draw_geometries(vertex_list)

geometry_primitives.py#

 1# ----------------------------------------------------------------------------
 2# -                        CloudViewer: www.cloudViewer.org                  -
 3# ----------------------------------------------------------------------------
 4# Copyright (c) 2018-2024 www.cloudViewer.org
 5# SPDX-License-Identifier: MIT
 6# ----------------------------------------------------------------------------
 7
 8# examples/Python/Basic/polyline.py
 9
10import numpy as np
11import cloudViewer as cv3d
12
13
14def primitives_generator(only_show_union=True):
15    plane = cv3d.geometry.ccPlane(width=2, height=4)
16    plane.paint_uniform_color((0.5, 1, 0))
17    plane.compute_vertex_normals()
18    if not only_show_union:
19        yield "Plane", [plane]
20
21    box = cv3d.geometry.ccBox(dims=[2, 2, 2])
22    box.set_color([0, 0, 1])
23    box.compute_vertex_normals()
24    if not only_show_union:
25        yield "Box", [box]
26
27    sphere = cv3d.geometry.ccSphere(radius=2, precision=96)
28    sphere.set_color((1, 0, 0))
29    sphere.compute_vertex_normals()
30    if not only_show_union:
31        yield "Sphere", [sphere]
32
33    torus = cv3d.geometry.ccTorus(inside_radius=1,
34                                  outside_radius=1.5,
35                                  rectangular_section=False,
36                                  angle_rad=2 * np.pi,
37                                  rect_section_height=0,
38                                  precision=96)
39    torus.set_color([0.5, 0, 1])
40    torus.compute_vertex_normals()
41    if not only_show_union:
42        yield "Torus", [torus]
43
44    quadric = cv3d.geometry.ccQuadric(min_corner=(-1, -1),
45                                      max_corner=(1, 1),
46                                      equation=(1, 1, 1, 1, 1, 1))
47    quadric.paint_uniform_color((0, 1, 0.5))
48    quadric.compute_vertex_normals()
49    if not only_show_union:
50        yield "Quadric", [quadric]
51
52    truncated_cone = cv3d.geometry.ccCone(bottom_radius=2,
53                                          top_radius=1,
54                                          height=4,
55                                          x_off=0,
56                                          y_off=0,
57                                          precision=64)
58    truncated_cone.set_color([1, 0, 1])
59    truncated_cone.compute_vertex_normals()
60    if not only_show_union:
61        yield "TruncatedCone", [truncated_cone]
62
63    cone = cv3d.geometry.ccCone(bottom_radius=2,
64                                top_radius=0,
65                                height=4,
66                                x_off=0,
67                                y_off=0,
68                                precision=64)
69    cone.set_color([1, 0, 1])
70    cone.compute_vertex_normals()
71    if not only_show_union:
72        yield "Cone", [cone]
73
74    cylinder = cv3d.geometry.ccCylinder(radius=2, height=4, precision=128)
75    cylinder.paint_uniform_color((0, 1, 0))
76    cylinder.compute_vertex_normals()
77    if not only_show_union:
78        yield "Cylinder", [cylinder]
79
80    d = 4
81    union = cv3d.geometry.ccMesh()
82    union.create_internal_cloud()
83    union += plane.translate((-d, 0, 0))
84    union += box.translate((0, 0, 0))
85    union += sphere.translate((0, -d, 0))
86    union += torus.translate((-d, -d, 0))
87    union += quadric.translate((d, 0, 0))
88    union += truncated_cone.translate((d, -d, 0))
89    union += cone.translate((-d, d, 0))
90    union += cylinder.translate((d, d, 0))
91    yield "Unions", [union]
92
93
94if __name__ == "__main__":
95    cv3d.utility.set_verbosity_level(cv3d.utility.Debug)
96    for name, primitives in primitives_generator(only_show_union=True):
97        print(primitives)
98        cv3d.visualization.draw(primitives)
99        # cv3d.visualization.draw_geometries()

geometry_transformation.py#

 1# ----------------------------------------------------------------------------
 2# -                        CloudViewer: www.cloudViewer.org                  -
 3# ----------------------------------------------------------------------------
 4# Copyright (c) 2018-2024 www.cloudViewer.org
 5# SPDX-License-Identifier: MIT
 6# ----------------------------------------------------------------------------
 7
 8# examples/Python/Utility/transformation.py
 9
10import numpy as np
11import cloudViewer as cv3d
12import time
13
14
15def geometry_generator():
16    mesh = cv3d.geometry.ccMesh.create_sphere()
17    verts = np.asarray(mesh.get_vertices())
18    colors = np.random.uniform(0, 1, size=verts.shape)
19    mesh.set_vertex_colors(cv3d.utility.Vector3dVector(colors))
20    mesh.compute_vertex_normals()
21
22    pcl = cv3d.geometry.ccPointCloud()
23    pcl.set_points(mesh.get_vertices())
24    pcl.set_colors(mesh.get_vertex_colors())
25    pcl.set_normals(mesh.get_vertex_normals())
26    yield pcl
27
28    yield cv3d.geometry.LineSet.create_from_triangle_mesh(mesh)
29
30    yield mesh
31
32
33def animate(geom):
34    vis = cv3d.visualization.Visualizer()
35    vis.create_window()
36
37    geom.rotate(geom.get_rotation_matrix_from_xyz((0.75, 0.5, 0)))
38    vis.add_geometry(geom)
39
40    scales = [0.9 for _ in range(30)] + [1 / 0.9 for _ in range(30)]
41    axisangles = [(0.2 / np.sqrt(2), 0.2 / np.sqrt(2), 0) for _ in range(60)]
42    ts = [(0.1, 0.1, -0.1) for _ in range(30)
43         ] + [(-0.1, -0.1, 0.1) for _ in range(30)]
44
45    for scale, aa in zip(scales, axisangles):
46        R = geom.get_rotation_matrix_from_axis_angle(aa)
47        geometry = geom.scale(scale)
48        geometry.rotate(R, geometry.get_center())
49        vis.update_geometry(geom)
50        vis.poll_events()
51        vis.update_renderer()
52        time.sleep(0.05)
53
54    for t in ts:
55        geom.translate(t)
56        vis.update_geometry(geom)
57        vis.poll_events()
58        vis.update_renderer()
59        time.sleep(0.05)
60
61    for scale, aa, t in zip(scales, axisangles, ts):
62        R = geom.get_rotation_matrix_from_axis_angle(aa)
63        geom.scale(scale).translate(t).rotate(R)
64        vis.update_geometry(geom)
65        vis.poll_events()
66        vis.update_renderer()
67        time.sleep(0.05)
68
69
70if __name__ == "__main__":
71    for geom in geometry_generator():
72        animate(geom)