Merge branch 'main' into blender-install-windows

Author: tomvanmele

CHANGELOG.md

@@ -15,10 +15,12 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 * Added optional `path` parameter to `compas.rpc.Proxy` to allow for non-package calls.
 * Added Grasshopper component to call RPC functions.
 * Added alternative installation procedure for Blender on Windows.
+* Added `Mesh.to_lines` method and tests.
 
 ### Changed
 
 * Set `jinja >= 3.0` to dev dependencies to fix docs build error.
+* Fixed removing of collections for `compas_plotters`.
 
 ### Removed
 
@@ -37,6 +39,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Changed
 
+* 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.

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
 ====================
 

src/compas/artists/colordict.py

@@ -1,5 +1,6 @@
 import compas
 from collections import defaultdict
+
 if compas.PY2:
     from collections import Mapping
 else:
@@ -12,7 +13,7 @@ class DescriptorProtocol(type):
 
     def __init__(cls, name, bases, attrs):
         for k, v in iter(attrs.items()):
-            if hasattr(v, '__set_name__'):
+            if hasattr(v, "__set_name__"):
                 v.__set_name__(cls, k)
 
 
@@ -58,8 +59,8 @@ def __set_name__(self, owner, name):
 
         """
         self.public_name = name
-        self.private_name = '_' + name
-        self.default_name = 'default_' + ''.join(name.split('_'))
+        self.private_name = "_" + name
+        self.default_name = "default_" + "".join(name.split("_"))
 
     def __get__(self, obj, otype=None):
         """Get the color dict stored in the private attribute corresponding to the public attribute name of the descriptor.

src/compas/datastructures/mesh/mesh.py

@@ -377,15 +377,15 @@ def from_lines(cls, lines, delete_boundary_face=False, precision=None):
         return mesh
 
     def to_lines(self):
-        """Convert the mesh to a collection of lines.
+        """Return the lines of the mesh as pairs of start and end point coordinates.
 
         Returns
         -------
         list[tuple[list[float], list[float]]]
-            A list of lines each defined by a pair of points.
+            A list of lines each defined by a pair of point coordinates.
 
         """
-        raise NotImplementedError
+        return [self.edge_coordinates(u, v) for u, v in self.edges()]
 
     @classmethod
     def from_polylines(cls, boundary_polylines, other_polylines):

src/compas/datastructures/network/network.py

@@ -221,6 +221,7 @@ def from_pointcloud(cls, cloud, degree=3):
         Returns
         -------
         :class:`~compas.datastructures.Network`
+            A network object.
 
         """
         network = cls()
@@ -256,6 +257,7 @@ def to_points(self):
         Returns
         -------
         list[list[float]]
+            A list with the coordinates of the vertices of the network.
 
         """
         return [self.node_coordinates(key) for key in self.nodes()]
@@ -266,6 +268,7 @@ def to_lines(self):
         Returns
         -------
         list[tuple[list[float], list[float]]]
+            A list of lines each defined by a pair of point coordinates.
 
         """
         return [self.edge_coordinates(u, v) for u, v in self.edges()]

src/compas/geometry/_core/normals.py

@@ -63,9 +63,9 @@ def normal_polygon(polygon, unitized=True):
         n = cross_vectors(oa, ob)
         oa = ob
 
-        nx += n[0]
-        ny += n[1]
-        nz += n[2]
+        nx += n[0] * 0.5
+        ny += n[1] * 0.5
+        nz += n[2] * 0.5
 
     if not unitized:
         return [nx, ny, nz]