Merge remote-tracking branch 'compas-dev/main' into main

Author: juney-lee

.bumpversion.cfg

@@ -1,5 +1,5 @@
 [bumpversion]
-current_version = 1.15.0
+current_version = 1.15.1
 message = Bump version to {new_version}
 commit = True
 tag = True

CHANGELOG.md

@@ -7,11 +7,43 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## Unreleased
 
+
 ### Added
 
+* Added `Polyline.extend`, `Polyline.extended`, `Polyline.shorten`,  `Polyline.shortened`.
+* Added `Data.sha256` for computing a hash value of data objects, for example for comparisons during version control.
+* Added optional `path` parameter to `compas.rpc.Proxy` to allow for non-package calls.
+* Added Grasshopper component to call RPC functions.
+
+### Changed
+
+* Set `jinja >= 3.0` to dev dependencies to fix docs build error.
+
+### Removed
+
+* Removed unused `compas_rhino.objects` (moved to `compas_ui`).
+* Removed unused `compas_rhino.ui` (moved to `compas_ui`).
+
+
+## [1.15.1] 2022-03-28
+
+### Added
+
+* Added optional `triangulated` flag to `Mesh.to_vertices_and_faces`.
+* Added geometry information of active meshes to the serialization/deserialization of robot model's `MeshDescriptor`.
+* Added Grasshopper component to draw any COMPAS object.
+* Added new icons to Grasshopper components and default to icon style.
+
 ### Changed
 
+<<<<<<< HEAD
 * Fixed bug in `normal_polygon` in `compas.geometry`.
+=======
+* Fixed bug in Blender mesh conversion.
+* Changed Rhino plugin installer to check for and install required plugin packages.
+* Refactor robot model artists to use the same `Mesh.to_vertices_and_faces` everywhere.
+* Fix debug print on Blender artist.
+>>>>>>> main
 
 ### Removed
 

docs/conf.py

@@ -40,7 +40,7 @@ def patched_m2r2_setup(app):
 copyright = "Block Research Group - ETH Zurich"
 author = "Tom Van Mele"
 
-release = "1.15.0"
+release = "1.15.1"
 version = ".".join(release.split(".")[0:2])
 
 master_doc = "index"

docs/tutorial/rpc.rst

@@ -2,28 +2,11 @@
 Remote Procedure Calls
 ********************************************************************************
 
-* :mod:`compas.rpc`
-
 Remote Procedure Calls (``RPC``) is a mechanism to transparently execute code in
 a remote process or computer. This is especially useful in scenarios where COMPAS
 runs inside an IronPython host (eg. Rhino) and needs to execute code that only
 runs on CPython (eg. code that requires ``numpy``).
 
-COMPAS provides **two ways to achieve** this: ``rcp`` and ``XFunc``.
-
-Through ``Xfunc``, COMPAS provides a mechanism for calling Python functions through
-a separately launched sub-process.
-
-A drawback of the ``Xfunc`` mechanism is that every call launches a new Python
-(sub)process with all the overhead that that entails. For infrequent calls to
-long-running processes this is not an issue. However, for frequent calls to functions
-that are expected to run quickly, this is not ideal.
-
-The second mechanism is the ``rpc`` module. The principle of RPC is to start a server
-that handles all requests. The advantage is that once the server is started,
-no additional processes have to be launched and the server can handle the requests
-without any overhead. Therefore, the response time is much faster than with ``XFunc``.
-
 
 Basic Usage
 ===========
@@ -64,6 +47,70 @@ The use of :mod:`compas.rpc` is not restricted to COMPAS packages only. ::
 Note that Numpy arrays are automatically converted to lists.
 
 
+Configuration Options
+=====================
+
+The :class:`compas.rpc.Proxy` object has several configuration options.
+We will discuss only a few of those here.
+For a complete overview, please refer to the API docs (:mod:`compas.rpc`).
+
+``python``
+----------
+
+The :class:`compas.rpc.Proxy` object will automatically try to reconnect to an
+active instance of the command server, or start a new one if no active server can be found.
+By default, a newly started server will run an instance of the default Python interpreter
+of the active environment, for example, when running RPC from the command line;
+or of the Python interpreter specified in `compas_bootstrapper`, for example, when running RPC from Rhino.
+
+In some cases, this might not be what you want, or might not result in the expected behaviour,
+for example when `compas_bootstrapper` does not exist.
+
+To use a specific Python iterpreter, you can specify the path to an executable through the ``python`` parameter.
+
+.. code-block:: python
+
+    >>> from compas.rpc import Proxy
+    >>> proxy = Proxy(python=r"C:\\Users\\<username>\\anaconda3\\envs\\research\\python.exe")
+
+
+``path``
+--------
+
+Sometimes you will want the server to run custom functions that are not (yet) part of a specific package.
+To allow the server to find such functions, you can specify an additional search path.
+
+For example, if you have a Python script on your desktop,
+defining a wrapper for the k-means clustering algorithm of ``scikit-learn``,
+you can tell the command server where to find it using the ``path`` parameter.
+
+.. code-block:: python
+
+    # C:\Users\<username>\Desktop\clustering.py
+
+    from sklearn.cluster import KMeans
+    from numpy import array
+
+
+    def cluster(points, n_clusters):
+        kmeans = KMeans(n_clusters=n_clusters, n_init=2000, max_iter=1000).fit(array(cloud, dtype=float))
+        clusters = {}
+        for label, point in zip(kmeans.labels_, cloud):
+            if label not in clusters:
+                clusters[label] = []
+            clusters[label].append(point)
+        return clusters
+
+
+.. code-block:: python
+
+    >>> from compas.geometry import Pointcloud
+    >>> from compas.rpc import Proxy
+    >>> cloud = Pointcloud.from_bounds(10, 5, 3, 100)
+    >>> proxy = Proxy(package='clustering', path=r'C:\\Users\\<username>\\Desktop')
+    >>> clusters = proxy.cluster(cloud, 10)
+
+
 Supported data types
 ====================
 

requirements-dev.txt

@@ -17,4 +17,5 @@ sphinx_compas_theme >=0.15.18
 sphinx >=3.4
 twine
 wheel
+jinja2 >= 3.0
 -e .

setup.py

@@ -25,7 +25,7 @@ def read(*names, **kwargs):
 
 setup(
     name='COMPAS',
-    version='1.15.0',
+    version='1.15.1',
     description='The COMPAS framework',
     long_description=long_description,
     long_description_content_type='text/markdown',

src/compas/__init__.py

@@ -41,7 +41,7 @@
 __license__ = 'MIT License'
 __email__ = '[email protected]'
 
-__version__ = '1.15.0'
+__version__ = '1.15.1'
 
 version = LooseVersion(compas.__version__)
 versionstring = version.vstring.split('-')[0]

src/compas/data/data.py

@@ -4,6 +4,7 @@
 
 import os
 import json
+import hashlib
 from uuid import uuid4
 from copy import deepcopy
 
@@ -112,12 +113,12 @@ def __init__(self, name=None):
 
     def __getstate__(self):
         """Return the object data for state serialization with older pickle protocols."""
-        return {'__dict__': self.__dict__, 'dtype': self.dtype, 'data': self.data}
+        return {"__dict__": self.__dict__, "dtype": self.dtype, "data": self.data}
 
     def __setstate__(self, state):
         """Assign a deserialized state to the object data to support older pickle protocols."""
-        self.__dict__.update(state['__dict__'])
-        self.data = state['data']
+        self.__dict__.update(state["__dict__"])
+        self.data = state["data"]
 
     @property
     def DATASCHEMA(self):
@@ -133,18 +134,22 @@ def JSONSCHEMANAME(self):
     def JSONSCHEMA(self):
         """dict : The schema of the JSON representation of the data of this object."""
         if not self._JSONSCHEMA:
-            schema_filename = '{}.json'.format(self.JSONSCHEMANAME.lower())
-            schema_path = os.path.join(os.path.dirname(__file__), 'schemas', schema_filename)
-            with open(schema_path, 'r') as fp:
+            schema_filename = "{}.json".format(self.JSONSCHEMANAME.lower())
+            schema_path = os.path.join(
+                os.path.dirname(__file__), "schemas", schema_filename
+            )
+            with open(schema_path, "r") as fp:
                 self._JSONSCHEMA = json.load(fp)
         return self._JSONSCHEMA
 
     @property
     def jsondefinitions(self):
         """dict : Reusable schema definitions."""
         if not self._jsondefinitions:
-            schema_path = os.path.join(os.path.dirname(__file__), 'schemas', 'compas.json')
-            with open(schema_path, 'r') as fp:
+            schema_path = os.path.join(
+                os.path.dirname(__file__), "schemas", "compas.json"
+            )
+            with open(schema_path, "r") as fp:
                 self._jsondefinitions = json.load(fp)
         return self._jsondefinitions
 
@@ -153,13 +158,16 @@ def jsonvalidator(self):
         """jsonschema.Draft7Validator : JSON schema validator for draft 7."""
         if not self._jsonvalidator:
             from jsonschema import RefResolver, Draft7Validator
+
             resolver = RefResolver.from_schema(self.jsondefinitions)
             self._jsonvalidator = Draft7Validator(self.JSONSCHEMA, resolver=resolver)
         return self._jsonvalidator
 
     @property
     def dtype(self):
-        return '{}/{}'.format('.'.join(self.__class__.__module__.split('.')[:2]), self.__class__.__name__)
+        return "{}/{}".format(
+            ".".join(self.__class__.__module__.split(".")[:2]), self.__class__.__name__
+        )
 
     @property
     def data(self):
@@ -321,6 +329,7 @@ def validate_data(self):
 
         """
         import schema
+
         try:
             data = self.DATASCHEMA.validate(self.data)
         except schema.SchemaError as e:
@@ -342,6 +351,7 @@ def validate_json(self):
 
         """
         import jsonschema
+
         jsonstring = json.dumps(self.data, cls=DataEncoder)
         jsondata = json.loads(jsonstring, cls=DataDecoder)
         try:
@@ -350,3 +360,35 @@ def validate_json(self):
             print("Validation against the JSON schema of this object failed.")
             raise e
         return jsonstring
+
+    def sha256(self, as_string=False):
+        """Compute a hash of the data for comparison during version control using the sha256 algorithm.
+
+        Parameters
+        ----------
+        as_string : bool, optional
+            If True, return the digest in hexadecimal format rather than as bytes.
+
+        Returns
+        -------
+        bytes | str
+
+        Examples
+        --------
+        >>> from compas.datastructures import Mesh
+        >>> mesh = Mesh.from_obj(compas.get('faces.obj'))
+        >>> v1 = mesh.sha256()
+        >>> v2 = mesh.sha256()
+        >>> mesh.vertex_attribute(mesh.vertex_sample(1)[0], 'z', 1)
+        >>> v3 = mesh.sha256()
+        >>> v1 == v2
+        True
+        >>> v2 == v3
+        False
+
+        """
+        h = hashlib.sha256()
+        h.update(self.jsonstring.encode())
+        if as_string:
+            return h.hexdigest()
+        return h.digest()

src/compas/datastructures/mesh/mesh.py

@@ -473,9 +473,14 @@ def from_vertices_and_faces(cls, vertices, faces):
 
         return mesh
 
-    def to_vertices_and_faces(self):
+    def to_vertices_and_faces(self, triangulated=False):
         """Return the vertices and faces of a mesh.
 
+        Parameters
+        ----------
+        triangulated: bool, optional
+            If True, triangulate the faces.
+
         Returns
         -------
         list[list[float]]
@@ -486,7 +491,31 @@ def to_vertices_and_faces(self):
         """
         key_index = self.key_index()
         vertices = [self.vertex_coordinates(key) for key in self.vertices()]
-        faces = [[key_index[key] for key in self.face_vertices(fkey)] for fkey in self.faces()]
+
+        if not triangulated:
+            faces = [[key_index[key] for key in self.face_vertices(fkey)] for fkey in self.faces()]
+            return vertices, faces
+
+        faces = []
+
+        for fkey in self.faces():
+            face_vertices = self.face_vertices(fkey)
+
+            if len(face_vertices) == 3:
+                a, b, c = face_vertices
+                faces.append([key_index[a], key_index[b], key_index[c]])
+            elif len(face_vertices) == 4:
+                a, b, c, d = face_vertices
+                faces.append([key_index[a], key_index[b], key_index[c]])
+                faces.append([key_index[a], key_index[c], key_index[d]])
+            else:
+                centroid = centroid_polygon([vertices[key_index[key]] for key in face_vertices])
+                ckey = len(vertices)
+                vertices.append(centroid)
+
+                for a, b in pairwise(face_vertices + face_vertices[:1]):
+                    faces.append([key_index[a], key_index[b], ckey])
+
         return vertices, faces
 
     @classmethod