add group object

Author: tomvanmele

CHANGELOG.md

@@ -9,6 +9,10 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Added
 
+* Added `compas_notebook.conversions.shapes_to_edgesbuffer`.
+* Added `compas_notebook.conversions.shapes_to_facesbuffer`.
+* Added `compas_notebook.scene.ThreeGroupObject`.
+
 ### Changed
 
 ### Removed

notebooks/80_groups.ipynb

@@ -0,0 +1,94 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# %%capture\n",
+    "# %pip install compas_notebook"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import random\n",
+    "from compas.geometry import Box, Frame, Pointcloud\n",
+    "from compas.colors import Color\n",
+    "from compas_notebook import Viewer"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "cloud = Pointcloud.from_bounds(10, 10, 10, 1000)\n",
+    "shapes = []\n",
+    "for point in cloud:\n",
+    "    shape = Box(random.random(), random.random(), random.random(), frame=Frame(point))\n",
+    "    shapes.append(shape)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "4a9300cce349439abca62bb8ebae76ce",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "VBox(children=(HBox(children=(Button(icon='search-plus', layout=Layout(height='32px', width='48px'), style=But…"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "viewer = Viewer()\n",
+    "viewer.scene.clear()\n",
+    "viewer.scene.add(shapes, color=Color.grey().lightened(50))\n",
+    "viewer.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "compas2",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.12.1"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

src/compas_notebook/conversions/__init__.py

@@ -17,6 +17,9 @@
 from .meshes import vertices_and_faces_to_threejs
 from .meshes import vertices_to_threejs
 
+from .buffers import shapes_to_edgesbuffer
+from .buffers import shapes_to_facesbuffer
+
 
 __all__ = [
     "box_to_threejs",
@@ -29,6 +32,8 @@
     "point_to_threejs",
     "pointcloud_to_threejs",
     "polyline_to_threejs",
+    "shapes_to_edgesbuffer",
+    "shapes_to_facesbuffer",
     "sphere_to_threejs",
     "torus_to_threejs",
     "vertices_and_edges_to_threejs",

src/compas_notebook/conversions/buffers.py

@@ -0,0 +1,181 @@
+from typing import Union
+
+import numpy as np
+import pythreejs as three
+from compas.colors import Color
+from compas.datastructures import Mesh
+from compas.geometry import Polygon
+from compas.geometry import Shape
+from compas.geometry import earclip_polygon
+
+
+class MeshShape:
+
+    def __init__(self, mesh: Mesh):
+        self.mesh = mesh
+        self._vertices = None
+        self._edges = None
+        self._faces = None
+
+    @property
+    def vertices(self):
+        if not self._vertices:
+            self._vertices = self.mesh.vertices_attributes("xyz")
+        return self._vertices
+
+    @property
+    def edges(self):
+        if not self._edges:
+            self._edges = list(self.mesh.edges())
+        return self._edges
+
+    @property
+    def faces(self):
+        if not self._faces:
+            self._faces = [self.mesh.face_vertices(face) for face in self.mesh.faces()]
+        return self._faces
+
+
+def shapes_to_edgesbuffer(
+    shapes: list[Mesh, Shape],
+    color: Color,
+) -> three.LineSegments:
+    """Convert the combined edges of a collection of shapes to one line segment buffer.
+
+    Parameters
+    ----------
+    shapes : list[:class:`compas.datastructures.Mesh`, :class:`compas.geometry.Shape`]
+        The shape collection.
+    color : :class:`compas.colors.Color`
+        The color of the edges.
+
+    Returns
+    -------
+    pythreejs.LineSegments
+
+    """
+    positions = []
+    colors = []
+
+    for shape in shapes:
+        buffer = shape_to_edgesbuffer(shape, color)
+        positions += buffer[0]
+        colors += buffer[1]
+
+    positions = np.array(positions, dtype=np.float32)
+    colors = np.array(colors, dtype=np.float32)
+
+    geometry = three.BufferGeometry(
+        attributes={
+            "position": three.BufferAttribute(positions, normalized=False),
+            "color": three.BufferAttribute(colors, normalized=False, itemSize=3),
+        }
+    )
+
+    material = three.LineBasicMaterial(vertexColors="VertexColors")
+
+    return three.LineSegments(geometry, material)
+
+
+def shapes_to_facesbuffer(
+    shapes: list[Mesh],
+    color: Color,
+) -> three.Mesh:
+    """Convert the combined faces of a collection of shapes to one mesh buffer.
+
+    Parameters
+    ----------
+    shapes : list[:class:`compas.datastructures.Mesh`, :class:`compas.geometry.Shape`]
+        The shape collection.
+    color : :class:`compas.colors.Color`
+        The color of the faces.
+
+    Returns
+    -------
+    pythreejs.Mesh
+
+    """
+    positions = []
+    colors = []
+
+    for shape in shapes:
+        buffer = shape_to_facesbuffer(shape, color)
+        positions += buffer[0]
+        colors += buffer[1]
+
+    positions = np.array(positions, dtype=np.float32)
+    colors = np.array(colors, dtype=np.float32)
+
+    geometry = three.BufferGeometry(
+        attributes={
+            "position": three.BufferAttribute(positions, normalized=False),
+            "color": three.BufferAttribute(colors, normalized=False, itemSize=3),
+        }
+    )
+
+    material = three.MeshBasicMaterial(
+        side="DoubleSide",
+        vertexColors="VertexColors",
+    )
+
+    return three.Mesh(geometry, material)
+
+
+def shape_to_edgesbuffer(shape: Union[Mesh, Shape], color: Color) -> tuple[list[list[float]], list[Color]]:
+    positions = []
+    colors = []
+
+    if isinstance(shape, Mesh):
+        shape = MeshShape(shape)
+
+    for u, v in shape.edges:
+        positions.append(shape.vertices[u])
+        positions.append(shape.vertices[v])
+        colors.append(color)
+        colors.append(color)
+
+    return positions, colors
+
+
+def shape_to_facesbuffer(shape: Union[Mesh, Shape], color: Color) -> tuple[list[list[float]], list[Color]]:
+    positions = []
+    colors = []
+
+    if isinstance(shape, Mesh):
+        shape = MeshShape(shape)
+
+    for face in shape.faces:
+
+        if len(face) == 3:
+            positions.append(shape.vertices[face[0]])
+            positions.append(shape.vertices[face[1]])
+            positions.append(shape.vertices[face[2]])
+            colors.append(color)
+            colors.append(color)
+            colors.append(color)
+
+        elif len(face) == 4:
+            positions.append(shape.vertices[face[0]])
+            positions.append(shape.vertices[face[1]])
+            positions.append(shape.vertices[face[2]])
+            colors.append(color)
+            colors.append(color)
+            colors.append(color)
+            positions.append(shape.vertices[face[0]])
+            positions.append(shape.vertices[face[2]])
+            positions.append(shape.vertices[face[3]])
+            colors.append(color)
+            colors.append(color)
+            colors.append(color)
+
+        else:
+            ears = earclip_polygon(Polygon([shape.vertices[v] for v in face]))
+            for ear in ears:
+                positions.append(shape.vertices[ear[0]])
+                positions.append(shape.vertices[ear[1]])
+                positions.append(shape.vertices[ear[2]])
+                colors.append(color)
+                colors.append(color)
+                colors.append(color)
+
+    return positions, colors

src/compas_notebook/scene/__init__.py

@@ -45,6 +45,8 @@
 from .graphobject import ThreeGraphObject
 from .meshobject import ThreeMeshObject
 
+from .groupobject import ThreeGroupObject
+
 
 @plugin(category="drawing-utils", pluggable_name="clear", requires=["pythreejs"])
 def clear_pythreejs(guids=None):
@@ -82,8 +84,7 @@ def register_scene_objects():
     register(Sphere, ThreeSphereObject, context="Notebook")
     register(Torus, ThreeTorusObject, context="Notebook")
     register(Mesh, ThreeMeshObject, context="Notebook")
-
-    # print("PyThreeJS SceneObjects registered.")
+    register(list, ThreeGroupObject, context="Notebook")
 
 
 __all__ = [

src/compas_notebook/scene/groupobject.py

@@ -0,0 +1,50 @@
+from compas.colors import Color
+from compas.data import Data
+
+from compas_notebook.conversions import shapes_to_edgesbuffer
+from compas_notebook.conversions import shapes_to_facesbuffer
+
+from .sceneobject import SceneObject
+
+
+class Group(Data):
+    """A group of compas.data.Data items."""
+
+    def __init__(self, items: list[Data] = None):
+        super().__init__()
+        self.items = items or []
+
+    @property
+    def __data__(self):
+        return {"items": self.items}
+
+
+class ThreeGroupObject(SceneObject):
+    """A group of scene objects."""
+
+    item: Group
+
+    def __init__(self, item=None, **kwargs):
+        super().__init__(item=Group(item), **kwargs)
+        self.show = True
+        self.is_selected = False
+        self.opacity = 1.0
+        self.bounding_box = None
+
+    @property
+    def items(self) -> list:
+        return self.item.items
+
+    def init(self, *args, **kwargs):
+        pass
+
+    def draw(self, *args, **kwargs):
+        self._guids = []
+        edgesbuffer = shapes_to_edgesbuffer(self.items, Color(0.2, 0.2, 0.2))
+        facesbuffer = shapes_to_facesbuffer(self.items, self.color)
+        self._guids.append(edgesbuffer)
+        self._guids.append(facesbuffer)
+        return self._guids
+
+    def draw_instance(self, *args, **kwargs):
+        pass