DOCS cleanup examples.

Author: petrasvestartas

docs/examples/example_meshing.py

@@ -1,11 +1,11 @@
 from compas.datastructures import Mesh
 
-# from compas_cgal import remesh
 from compas.geometry import scale_vector
 from compas.geometry import Translation
 from compas.geometry import Rotation
 from compas.geometry import Scale
 from compas.geometry import Vector
+from compas.geometry import transform_points_numpy
 from pathlib import Path
 import math
 from line_profiler import profile
@@ -18,19 +18,9 @@ def main():
     """Remesh a bunny mesh that is loaded from .ply file."""
 
     FILE = Path(__file__).parent.parent.parent / "data" / "Bunny.ply"
-
-    # ==============================================================================
-    # Get the bunny and construct a mesh
-    # ==============================================================================
-
     bunny = Mesh.from_ply(FILE)
-
     bunny.remove_unused_vertices()
 
-    # ==============================================================================
-    # Move the bunny to the origin and rotate it upright.
-    # ==============================================================================
-
     centroid = bunny.vertex_point(0)
 
     vector = scale_vector(centroid, -1)
@@ -40,13 +30,12 @@ def main():
     R = Rotation.from_axis_and_angle(Vector(1, 0, 0), math.radians(90))
 
     bunny.transform(R * S * T)
+    V0, F0 = bunny.to_vertices_and_faces()
+    V1 = transform_points_numpy(V0, R * S * T)
 
-    # ==============================================================================
-    # Remesh
-    # ==============================================================================
-
-    V, F = mesh_remesh(bunny.to_vertices_and_faces(), 0.3, 10)
-    mesh = Mesh.from_vertices_and_faces(V, F)
+    V1, F1 = mesh_remesh((V0, F0), 0.3, 10)
+    V1 = transform_points_numpy(V1, Translation.from_vector([20, 0, 0]))
+    mesh = Mesh.from_vertices_and_faces(V1, F1)
 
     return bunny, mesh
 
@@ -63,7 +52,7 @@ def main():
 viewer.renderer.camera.target = [0, 0, 0]
 viewer.renderer.camera.position = [0, -25, 10]
 
-viewer.scene.add(bunny.transformed(Translation.from_vector([-10, 0, 0])), show_points=False)
-viewer.scene.add(mesh.transformed(Translation.from_vector([+10, 0, 0])), show_points=False)
+viewer.scene.add(bunny, show_points=False)
+viewer.scene.add(mesh, show_points=False)
 
 viewer.show()

docs/examples/example_reconstruction_pointset_outlier_removal.py

@@ -25,8 +25,6 @@ def reconstruction_pointset_outlier_removal():
     points = pointset_outlier_removal(c1, 30, 2.0)
     c2 = Pointcloud(points)
     c3 = c1.difference(c2)
-    c2.name = "pointset_outlier_removal"
-    c3.name = "pointset_outlier_removal"
 
     return c2, c3
 

docs/examples/example_reconstruction_pointset_reduction.py

@@ -2,6 +2,7 @@
 
 from compas.geometry import Pointcloud
 from compas.geometry import Translation
+from compas.geometry import transform_points_numpy
 from compas_cgal.reconstruction import pointset_reduction
 from compas_viewer import Viewer
 from compas_viewer.config import Config
@@ -12,29 +13,19 @@
 def reconstruction_pointset_reduction():
     """Reduce the number of points in a point set."""
 
-    # ==============================================================================
-    # Input geometry
-    # ==============================================================================
-
     FILE = Path(__file__).parent.parent.parent / "data" / "forked_branch_1.ply"
     c = Pointcloud.from_ply(FILE)
 
-    # ==============================================================================
-    # Compute
-    # ==============================================================================
-
     points = Pointcloud(pointset_reduction(c, 50))
+    transform_points_numpy(points, Translation.from_vector([-1000, 0, 0]))
+
     c.transform(Translation.from_vector([-1000, 0, 0]))
 
     return c, points
 
 
 c_reduction_0, c_reduction_1 = reconstruction_pointset_reduction()
 
-# ==============================================================================
-# Visualize
-# ==============================================================================
-
 config = Config()
 config.camera.target = [100, 500, 200]
 config.camera.position = [100, -1500, 2000]

docs/examples/example_reconstruction_pointset_smoothing.py

@@ -3,6 +3,7 @@
 from compas.geometry import Pointcloud
 from compas.geometry import Translation
 from compas_cgal.reconstruction import pointset_smoothing
+from compas.geometry import transform_points_numpy
 from compas_viewer import Viewer
 from compas_viewer.config import Config
 from line_profiler import profile
@@ -12,29 +13,12 @@
 def reconstruction_pointset_smoothing():
     """Smooth a point set."""
 
-    # ==============================================================================
-    # Input geometry
-    # ==============================================================================
-
     ply_file_path = Path(__file__).parent.parent.parent / "data" / "box.ply"
     original_points = Pointcloud.from_ply(ply_file_path)
-    original_points.transform(Translation.from_vector([-10000, 0, 0]))
-    transformed_points = Pointcloud.from_ply(ply_file_path)
-    transformed_points.transform(Translation.from_vector([10000, 0, 0]))
-
-    # ==============================================================================
-    # Compute
-    # ==============================================================================
-
-    smoothed_points = pointset_smoothing(transformed_points, 1000, 3)
 
-    # ==============================================================================
-    # Visualize
-    # ==============================================================================
+    smoothed_points = pointset_smoothing(original_points, 1000, 3)
 
-    c_original = Pointcloud(original_points)
-    c_transformed = Pointcloud(smoothed_points)
-    return c_original, c_transformed
+    return Pointcloud(original_points), Pointcloud(smoothed_points)
 
 
 c_smoothing_0, c_smoothing_1 = reconstruction_pointset_smoothing()

docs/examples/example_reconstruction_poisson_surface_reconstruction.py

@@ -12,10 +12,6 @@
 
 @profile
 def reconstruction_poisson_surface_reconstruction():
-    # ==============================================================================
-    # Input geometry
-    # ==============================================================================
-
     FILE = Path(__file__).parent.parent.parent / "data" / "oni.xyz"
 
     points = []
@@ -26,23 +22,12 @@ def reconstruction_poisson_surface_reconstruction():
             points.append([float(x), float(y), float(z)])
             normals.append([float(nx), float(ny), float(nz)])
 
-    # ==============================================================================
-    # Compute
-    # ==============================================================================
-
     V, F = poisson_surface_reconstruction(points, normals)
     mesh = Mesh.from_vertices_and_faces(V, F)
 
-    R = Rotation.from_axis_and_angle([1, 0, 0], math.radians(90))
-    S = Scale.from_factors([10, 10, 10])
-    T = R * S
-
     c = Pointcloud(V)
-    c.transform(T)
-    mesh.transform(T)
-    points, mesh.name = (c, mesh)
 
-    return points, mesh
+    return c, mesh
 
 
 points, mesh = reconstruction_poisson_surface_reconstruction()
@@ -52,6 +37,11 @@ def reconstruction_poisson_surface_reconstruction():
 # ==============================================================================
 
 viewer = Viewer()
+
+viewer.renderer.camera.target = [0, 0, 0]
+viewer.renderer.camera.position = [0, -0.2, 2.0]
+
 viewer.scene.add(points, pointsize=10, pointcolor=(255, 0, 0))
 viewer.scene.add(mesh, show_points=False)
+
 viewer.show()

docs/examples/example_skeletonization.py

@@ -14,39 +14,23 @@
 
 @profile
 def main():
-    # ==============================================================================
-    # Load and transform mesh
-    # ==============================================================================
+    """Skeletonize a mesh."""
 
     input_file = Path(__file__).parent.parent.parent / "data" / "elephant.off"
 
-    # Create transformation sequence
     rotation_x = Rotation.from_axis_and_angle([1, 0, 0], math.radians(60))
     rotation_y = Rotation.from_axis_and_angle([0, 1, 0], math.radians(5))
     rotation = rotation_y * rotation_x
     scale = Scale.from_factors([5, 5, 5])
     translation = Translation.from_vector([0, 0, 2])
 
-    # Apply transformations to mesh
     mesh = Mesh.from_off(input_file).transformed(translation * rotation * scale)
     mesh = mesh.subdivided("loop")
 
-    # ==============================================================================
-    # Convert mesh to vertices and faces
-    # ==============================================================================
-
     vertices, faces = mesh.to_vertices_and_faces()
 
-    # ==============================================================================
-    # Generate skeleton edges
-    # ==============================================================================
-
     skeleton_edges = mesh_skeleton((vertices, faces))
 
-    # ==============================================================================
-    # Convert skeleton edges to polylines
-    # ==============================================================================
-
     polylines = []
     for start_point, end_point in skeleton_edges:
         polyline = Polyline([start_point, end_point])

docs/examples/example_slicer.py

@@ -13,20 +13,12 @@
 
 @profile
 def main():
-    # ==============================================================================
-    # Input geometry
-    # ==============================================================================
-
     # Get Mesh from STL
     FILE = Path(__file__).parent.parent.parent / "data" / "3DBenchy.stl"
     benchy = Mesh.from_stl(FILE)
 
     V, F = benchy.to_vertices_and_faces()
 
-    # ==============================================================================
-    # Create slicing planes
-    # ==============================================================================
-
     # Get Slice planes from the bounding box
     bbox = benchy.aabb()
     normal = Vector(0, 0, 1)
@@ -35,10 +27,6 @@ def main():
         plane = Plane(Point(0, 0, i), normal)
         planes.append(plane)
 
-    # ==============================================================================
-    # Compute
-    # ==============================================================================
-
     # Slice
     slicer_polylines = slice_mesh((V, F), planes)
 

docs/examples/example_straight_skeleton_2_interior_straight_skeleton.py

@@ -9,10 +9,6 @@
 def main():
     """Compute the interior straight skeleton of a polygon."""
 
-    # ==============================================================================
-    # Input geometry
-    # ==============================================================================
-
     points = [
         Point(-1.91, 3.59, 0.0),
         Point(-5.53, -5.22, 0.0),
@@ -27,10 +23,6 @@ def main():
     ]
     polygon = Polygon(points)
 
-    # ==============================================================================
-    # Compute
-    # ==============================================================================
-
     graph = interior_straight_skeleton(polygon)
 
     return graph

docs/examples/example_straight_skeleton_2_interior_straight_skeleton_offset_polygon.py

@@ -7,6 +7,8 @@
 
 @profile
 def main():
+    """Create offset polygons."""
+
     points = [
         (-1.91, 3.59, 0.0),
         (-5.53, -5.22, 0.0),

docs/examples/example_straight_skeleton_2_interior_straight_skeleton_weighted_offset_polygon.py

@@ -7,6 +7,8 @@
 
 @profile
 def main():
+    """Create weighted offset polygons."""
+
     points = [
         (-1.91, 3.59, 0.0),
         (-5.53, -5.22, 0.0),