small tweaks and rename groups

Author: tomvanmele

src/compas_rv/datastructures/diagram.py

@@ -7,15 +7,15 @@ class Diagram(Mesh):
     Base data structure for form, force and thrust diagrams.
     """
 
-    def edge_loop(self, uv):
+    def edge_loop(self, edge):
         """
         Identify all edges on the same loop as a given edge.
         This implementation is different than the base implmentation in the mesh data structure,
         because of the "unloaded" faces in form, force, and thrust diagrams.
 
         Parameters
         ----------
-        uv : tuple[int, int]
+        edge : tuple[int, int]
             The identifier of the edge.
 
         Returns
@@ -24,8 +24,8 @@ def edge_loop(self, uv):
             A list of edge identifiers.
 
         """
-        u, v = uv
-        f1, f2 = self.edge_faces(uv)
+        u, v = edge
+        f1, f2 = self.edge_faces(edge)
 
         if f1 is not None and not self.face_attribute(f1, "_is_loaded"):
             loop = []
@@ -91,7 +91,7 @@ def smooth(self, fixed, kmax=10):
         None
 
         """
-        self.smooth_area(self, fixed=fixed, kmax=kmax)
+        self.smooth_area(fixed=fixed, kmax=kmax)
 
     def corner_vertices(self, tol=160):
         """
@@ -116,10 +116,10 @@ def corner_vertices(self, tol=160):
             else:
                 nbrs = []
                 for nkey in self.vertex_neighbors(key):
-                    if self.is_edge_on_boundary(key, nkey):
+                    if self.is_edge_on_boundary((key, nkey)):
                         nbrs.append(nkey)
-                u = self.edge_vector(key, nbrs[0])
-                v = self.edge_vector(key, nbrs[1])
+                u = self.edge_vector((key, nbrs[0]))
+                v = self.edge_vector((key, nbrs[1]))
                 if angle_vectors(u, v, deg=True) < tol:
                     vkeys.append(key)
         return vkeys

src/compas_rv/datastructures/formdiagram.py

@@ -1,13 +1,13 @@
 from compas.geometry import scale_vector
 from compas.geometry import sum_vectors
 from compas_fd.solvers import fd_numpy
-from compas_tna.diagrams import FormDiagram
+from compas_tna.diagrams import FormDiagram as BaseFormDiagram
 
 from .diagram import Diagram
 from .pattern import Pattern
 
 
-class FormDiagram(Diagram, FormDiagram):
+class FormDiagram(Diagram, BaseFormDiagram):
     """
     Data structure for form diagrams.
     """
@@ -77,17 +77,18 @@ def solve_fd(self) -> None:
 
         """
         vertex_index = self.vertex_index()
-        xyz = self.vertices_attributes("xyz")
+        xyz: list[list[float]] = self.vertices_attributes("xyz")  # type: ignore
         loads = [[0.0, 0.0, 0.0] for _ in xyz]
         fixed = [vertex_index[key] for key in self.vertices_where(is_support=True)]
         fixed += [vertex_index[key] for key in self.vertices_where(is_fixed=True)]
         edges = list(self.edges_where(_is_edge=True))
-        q = self.edges_attribute("q", keys=edges)
+        q: list[float] = self.edges_attribute("q", keys=edges)  # type: ignore
         edges = [(vertex_index[u], vertex_index[v]) for u, v in edges]
         result = fd_numpy(vertices=xyz, fixed=fixed, edges=edges, forcedensities=q, loads=loads)
-        for key in self.vertices():
-            index = vertex_index[key]
-            self.vertex_attributes(key, "xyz", result.vertices[index])
+        for vertex in self.vertices():
+            index = vertex_index[vertex]
+            self.vertex_attributes(vertex, "xyz", result.vertices[index])
+            self.vertex_attributes(vertex, ["_rx", "_ry", "_rz"], result.residuals[index])
 
     def flip_cycles_if_normal_down(self):
         """Flip the cycles of the diagram if the average normal points downward."""

src/compas_rv/scene/diagramobject.py

@@ -1,3 +1,5 @@
+from typing import Optional
+
 import Rhino  # type: ignore
 import rhinoscriptsyntax as rs  # type: ignore
 import scriptcontext as sc  # type: ignore
@@ -51,39 +53,37 @@ def settings(self):
 
     @property
     def diagram(self) -> Diagram:
-        return self.mesh
+        return self.mesh  # type: ignore
 
     @diagram.setter
     def diagram(self, diagram: Diagram) -> None:
         self.mesh = diagram
 
-    def edges(self, **kwargs):
-        return self.diagram.edges(**kwargs)
+    def edges(self, **kwargs) -> list[tuple[int, int]]:
+        return self.diagram.edges(**kwargs)  # type: ignore
 
-    def faces(self, **kwargs):
-        return self.diagram.faces(**kwargs)
+    def faces(self, **kwargs) -> list[int]:
+        return self.diagram.faces(**kwargs)  # type: ignore
 
-    def forces(self):
-        return self.diagram.edges_attribute("_f", keys=self.edges())
+    def forces(self) -> list[float]:
+        return self.diagram.edges_attribute("_f", keys=self.edges())  # type: ignore
 
-    def compute_edge_colors(self, tol=1e-3) -> None:
+    def compute_edge_colors(self, tol=1e-3) -> list[Color]:
         forces = self.forces()
         magnitudes = [abs(f) for f in forces]
         fmin = min(magnitudes)
         fmax = max(magnitudes)
 
-        if fmax - fmin < tol:
-            # size of the range of forces is already checked here
-            # no need to check again in the loop
-            return
-
         colors = []
 
-        for force, magnitude in zip(forces, magnitudes):
-            # this will need to be updated once we allow for tension forces
-            # or we have to exclude tension forces from the calculation
-            # and give tension edges their own style
-            colors.append(Color.from_i((magnitude - fmin) / (fmax - fmin)))
+        if fmax - fmin >= tol:
+            # size of the range of forces is already checked here
+            # no need to check again in the loop
+            for magnitude in magnitudes:
+                # this will need to be updated once we allow for tension forces
+                # or we have to exclude tension forces from the calculation
+                # and give tension edges their own style
+                colors.append(Color.from_i((magnitude - fmin) / (fmax - fmin)))
 
         return colors
 

src/compas_rv/scene/forceobject.py

@@ -9,17 +9,17 @@
 
 class RhinoForceObject(RhinoDiagramObject):
     session = RVSession()
-    diagram: ForceDiagram
+    diagram: ForceDiagram  # type: ignore
 
     vertexcolor = ColorDictAttribute(default=Color.blue())
     edgecolor = ColorDictAttribute(default=Color.blue().darkened(50))
     facecolor = ColorDictAttribute(default=Color.blue().lightened(25))
 
     def __init__(
         self,
-        vertexgroup="RV::ForceDiagram::Vertices",
-        edgegroup="RV::ForceDiagram::Edges",
-        facegroup="RV::ForceDiagram::Faces",
+        vertexgroup="RhinoVAULT::ForceDiagram::Vertices",
+        edgegroup="RhinoVAULT::ForceDiagram::Edges",
+        facegroup="RhinoVAULT::ForceDiagram::Faces",
         **kwargs,
     ):
         super().__init__(

src/compas_rv/scene/formobject.py

@@ -8,31 +8,33 @@
 
 class RhinoFormObject(RhinoDiagramObject):
     session = RVSession()
-    diagram: FormDiagram
+    diagram: FormDiagram  # type: ignore
 
     vertexcolor = ColorDictAttribute(default=Color.green())
     edgecolor = ColorDictAttribute(default=Color.green().darkened(50))
     facecolor = ColorDictAttribute(default=Color.green().lightened(25))
 
     def __init__(
         self,
-        vertexgroup="RV::FormDiagram::Vertices",
-        edgegroup="RV::FormDiagram::Edges",
-        facegroup="RV::FormDiagram::Faces",
+        vertexgroup="RhinoVAULT::FormDiagram::Vertices",
+        edgegroup="RhinoVAULT::FormDiagram::Edges",
+        facegroup="RhinoVAULT::FormDiagram::Faces",
+        layer="RhinoVAULT::FormDiagram",
         **kwargs,
     ):
         super().__init__(
             vertexgroup=vertexgroup,
             edgegroup=edgegroup,
             facegroup=facegroup,
+            layer=layer,
             **kwargs,
         )
 
     # =============================================================================
     # Properties
     # =============================================================================
 
-    def edges(self):
+    def edges(self, **kwargs):
         return self.diagram.edges_where(_is_edge=True)
 
     def faces(self, **kwargs):

src/compas_rv/scene/patternobject.py

@@ -18,9 +18,9 @@ class RhinoPatternObject(RUIMeshObject):
     def __init__(
         self,
         disjoint=True,
-        vertexgroup="RV::FormDiagram::Vertices",
-        edgegroup="RV::FormDiagram::Edges",
-        facegroup="RV::FormDiagram::Faces",
+        vertexgroup="RhinoVAULT::FormDiagram::Vertices",
+        edgegroup="RhinoVAULT::FormDiagram::Edges",
+        facegroup="RhinoVAULT::FormDiagram::Faces",
         **kwargs,
     ):
         super().__init__(

src/compas_rv/scene/thrustobject.py

@@ -36,14 +36,14 @@ def __init__(
         show_supports=True,
         show_fixed=True,
         show_free=False,
-        vertexgroup="RV::ThrustDiagram::Vertices",
-        edgegroup="RV::ThrustDiagram::Edges",
-        facegroup="RV::ThrustDiagram::Faces",
-        loadgroup="RV::ThrustDiagram::Loads",
-        selfweightgroup="RV::ThrustDiagram::Selfweight",
-        forcegroup="RV::ThrustDiagram::Forces",
-        reactiongroup="RV::ThrustDiagram::Reactions",
-        residualgroup="RV::ThrustDiagram::Residuals",
+        vertexgroup="RhinoVAULT::ThrustDiagram::Vertices",
+        edgegroup="RhinoVAULT::ThrustDiagram::Edges",
+        facegroup="RhinoVAULT::ThrustDiagram::Faces",
+        loadgroup="RhinoVAULT::ThrustDiagram::Loads",
+        selfweightgroup="RhinoVAULT::ThrustDiagram::Selfweight",
+        forcegroup="RhinoVAULT::ThrustDiagram::Forces",
+        reactiongroup="RhinoVAULT::ThrustDiagram::Reactions",
+        residualgroup="RhinoVAULT::ThrustDiagram::Residuals",
         **kwargs,
     ):
         super().__init__(

src/compas_rv/solvers/forcefromform.py

@@ -14,7 +14,7 @@ def update_force_from_form(force: ForceDiagram, form: FormDiagram):
     xy = np.array(form.vertices_attributes("xy"), dtype=np.float64)
     edges = [[vertex_index[u], vertex_index[v]] for u, v in form.edges_where(_is_edge=True)]
     C: sps.csr_matrix = connectivity_matrix(edges, "csr")
-    Q = sps.diags([form.edges_attribute("q", keys=list(form.edges_where(_is_edge=True)))], [0])
+    Q = sps.diags([form.edges_attribute("q", keys=list(form.edges_where(_is_edge=True)))], [0])  # type: ignore
     uv = C.dot(xy)
 
     _vertex_index = force.vertex_index()
@@ -35,5 +35,5 @@ def update_force_from_form(force: ForceDiagram, form: FormDiagram):
 
     for vertex, attr in force.vertices(True):
         index = _vertex_index[vertex]
-        attr["x"] = _xy[index, 0]
-        attr["y"] = _xy[index, 1]
+        attr["x"] = _xy[index, 0]  # type: ignore
+        attr["y"] = _xy[index, 1]  # type: ignore

src/compas_rv/solvers/scalehorizonal.py

@@ -43,11 +43,11 @@ def conduit_edges(self) -> EdgesConduit:
     def numdata(self) -> FDNumericalData:
         if self._numdata is None:
             vertex_index = self.thrust.vertex_index()
-            vertices = self.thrust.vertices_attributes("xyz")
-            loads = [self.thrust.vertex_attributes(vertex, ["px", "py", "pz"]) or [0, 0, 0] for vertex in self.thrust.vertices()]
+            vertices: list[list[float]] = self.thrust.vertices_attributes("xyz")  # type: ignore
+            loads: list[list[float]] = [self.thrust.vertex_attributes(vertex, ["px", "py", "pz"]) or [0, 0, 0] for vertex in self.thrust.vertices()]  # type: ignore
             fixed = [vertex_index[vertex] for vertex in self.thrust.vertices_where(is_support=True)]
             edges = list(self.thrust.edges_where(_is_edge=True))
-            forcedensities = list(self.thrust.edges_attribute(name="q", keys=edges))
+            forcedensities: list[float] = list(self.thrust.edges_attribute(name="q", keys=edges))  # type: ignore
             edges = [(vertex_index[u], vertex_index[v]) for u, v in edges]
             self._numdata = FDNumericalData.from_params(vertices, fixed, edges, forcedensities, loads)
         return self._numdata
@@ -59,7 +59,7 @@ def loadupdater(self) -> LoadUpdater:
             self._loadupdater = LoadUpdater(
                 self.thrust,
                 array(self.numdata.p, copy=True),
-                array(self.thrust.vertices_attribute("t"), dtype=float64).reshape((-1, 1)),
+                array(self.thrust.vertices_attribute("t"), dtype=float64).reshape((-1, 1)),  # type: ignore
                 1.0,
             )
         return self._loadupdater