pfc-geometry 0.2.16__tar.gz → 0.2.19__tar.gz

{pfc_geometry-0.2.16 → pfc_geometry-0.2.19}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pfc-geometry
-Version: 0.2.16
+Version: 0.2.19
 Summary: A library for working with 3D geometry.
 License-File: LICENSE
 Requires-Python: >=3.12

{pfc_geometry-0.2.16 → pfc_geometry-0.2.19}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "pfc-geometry"
-version="0.2.16"
+version="0.2.19"
 description = "A library for working with 3D geometry."
 readme = "README.md"
 requires-python = ">=3.12"

{pfc_geometry-0.2.16 → pfc_geometry-0.2.19}/src/geometry/__init__.py

@@ -11,6 +11,7 @@ this program. If not, see <http://www.gnu.org/licenses/>.
 """
 from .base import Base
 from .time import Time
+from . import angles as angles
 from .point import *
 from .quaternion import *
 from .gps import GPS
@@ -27,13 +28,3 @@ def Euldeg(*args, **kwargs) -> Quaternion:
     return Quaternion.from_euler(Point(*args, **kwargs).radians())
 
 
-def angle_diff(a, b): 
-    d1 = a - b
-    d2 = d1 - 2 * np.pi
-    bd=np.abs(d2) < np.abs(d1)
-    d1[bd] = d2[bd]
-    d3 = d1 + 2 * np.pi
-    bd=np.abs(d3) < np.abs(d1)
-    d1[bd] = d3[bd]
-
-    return d1

pfc_geometry-0.2.19/src/geometry/angles.py

@@ -0,0 +1,19 @@
+import numpy as np
+import numpy.typing as npt
+
+def unwind(angles: npt.NDArray, center: float = 0.0):
+    """given an angle, unwind it to the range [-pi, pi] around a center point."""
+    turns = np.round((angles - center) / (2 * np.pi)) 
+    return angles - turns * 2 * np.pi
+
+
+def difference(a, b): 
+    d1 = a - b
+    d2 = d1 - 2 * np.pi
+    bd=np.abs(d2) < np.abs(d1)
+    d1[bd] = d2[bd]
+    d3 = d1 + 2 * np.pi
+    bd=np.abs(d3) < np.abs(d1)
+    d1[bd] = d3[bd]
+
+    return d1

{pfc_geometry-0.2.16 → pfc_geometry-0.2.19}/src/geometry/base.py

@@ -252,6 +252,9 @@ class Base:
     def __neg__(self) -> Self:
         return self.__class__(-self.data)
 
+    def __pow__(self, power: Number) -> Self:
+        return self.__class__(self.data ** power)
+
     @dprep
     def dot(self, other: Self) -> Self:
         return np.einsum("ij,ij->i", self.data, other)

{pfc_geometry-0.2.16 → pfc_geometry-0.2.19}/src/geometry/coordinate_frame.py

@@ -87,3 +87,36 @@ class Coord(Base):
 
     def axes(self):
         return Point.concatenate([self.x_axis, self.y_axis, self.z_axis])
+
+    def plot(self, fig=None, scale=1, label: str = None):
+        import plotly.graph_objects as go
+        if fig is None:
+            fig = go.Figure(layout=dict(scene=dict(aspectmode="data")))
+
+        if len(self) > 1:
+            for c in self:
+                fig = c.plot(fig)
+            return fig
+        fig.add_trace(
+            go.Scatter3d(
+                x=self.origin.x,
+                y=self.origin.y,
+                z=self.origin.z,
+                mode="markers",
+                name="Origin",
+                marker=dict(size=5, color="black"),
+            )
+        )
+        colors = ["red", "green", "blue"]
+        for i, axis in enumerate([self.x_axis, self.y_axis, self.z_axis]):
+            fig.add_trace(
+                go.Scatter3d(
+                    x=[self.origin.x[0], (self.origin.x + axis.x * scale)[0]],
+                    y=[self.origin.y[0], (self.origin.y + axis.y * scale)[0]],
+                    z=[self.origin.z[0], (self.origin.z + axis.z * scale)[0]],
+                    mode="lines",
+                    name=f"{label or 'Axis'} {Point.cols[i]}",
+                    line=dict(width=2, color=colors.pop(0))
+                )
+            )
+        return fig

{pfc_geometry-0.2.16 → pfc_geometry-0.2.19}/src/geometry/point.py

@@ -12,6 +12,8 @@ this program. If not, see <http://www.gnu.org/licenses/>.
 
 from __future__ import annotations
 from typing import Literal
+
+from sqlalchemy import literal
 from .base import Base
 import numpy as np
 import pandas as pd
@@ -150,18 +152,45 @@ class Point(Base):
     def zeros(count=1):
         return Point(np.zeros((count, 3)))
 
+    @staticmethod
+    def circle_xy(radius: float, n: int) -> Point:
+        """
+        Generate points on a circle in the specified plane.
+        
+        :param radius: Radius of the circle.
+        :param n: Number of points to generate.
+        :return: Points on the circle as a Point object.
+        """
+        
+        angles = np.linspace(0, 2 * np.pi, n, endpoint=False)
+        return Point(radius * np.cos(angles), radius * np.sin(angles), np.zeros(n))
+
+    @staticmethod
+    def ellipse_xy(a: float, b: float, n: int) -> Point:
+        """
+        Generate points on an ellipse in the specified plane.
+        
+        :param a: Semi-major axis length.
+        :param b: Semi-minor axis length.
+        :param n: Number of points to generate.
+        :return: Points on the ellipse as a Point object.
+        """
+        
+        angles = np.linspace(0, 2 * np.pi, n, endpoint=False)
+        return Point(a * np.cos(angles), b * np.sin(angles), np.zeros(n))
+
     def bearing(self):
         return np.arctan2(self.y, self.x)
 
-    def plot3d(self, **kwargs):
+    def plot3d(self, fig=None, **kwargs):
         import plotly.graph_objects as go
-        fig = go.Figure()
 
-        fig.add_trace(go.Scatter3d(x=self.x, y=self.y, z=self.z, **kwargs))
-        fig.update_layout(
-            scene=dict(aspectmode="data"),
-        )
-        return fig
+        _fig = go.Figure() if fig is None else fig
+
+        _fig.add_trace(go.Scatter3d(x=self.x, y=self.y, z=self.z, **kwargs))
+        if fig is None:
+            _fig.update_layout(scene=dict(aspectmode="data"))
+        return _fig
 
     def plotxy(self):
         import plotly.express as px
@@ -183,6 +212,18 @@ class Point(Base):
         return px.line(self.df, x="z", y="x").update_layout(
             yaxis=dict(scaleanchor="x", scaleratio=1, title="x"), xaxis=dict(title="z")
         )
+    def plotxz(self):
+        import plotly.express as px
+
+        return px.line(self.df, x="x", y="z").update_layout(
+            yaxis=dict(scaleanchor="x", scaleratio=1, title="x"), xaxis=dict(title="z")
+        )
+    def arbitrary_perpendicular(self) -> Point:
+        min_axes = np.argmin(np.abs(self.data), axis=1)
+        cvecs = Point.concatenate(
+            [Point(*[1 if axis == i else 0 for i in np.arange(3)]) for axis in min_axes]
+        )
+        return cross(self, cvecs)
 
 
 def Points(*args, **kwargs):
@@ -262,10 +303,6 @@ def min_angle_between(p1: Point, p2: Point):
     return np.minimum(angle, np.pi - angle)
 
 
-def arbitrary_perpendicular(v: Point) -> Point:
-    return Point(-v.y, v.x, 0).unit()
-
-
 def vector_norm(point: Point):
     return abs(point)
 

{pfc_geometry-0.2.16 → pfc_geometry-0.2.19}/src/geometry/quaternion.py

@@ -12,7 +12,7 @@ this program. If not, see <http://www.gnu.org/licenses/>.
 from __future__ import annotations
 from .point import Point
 from .base import Base
-from geometry import PZ
+from geometry.point import PZ
 import numpy as np
 import numpy.typing as npt
 import pandas as pd

{pfc_geometry-0.2.16 → pfc_geometry-0.2.19}/src/geometry/transformation.py

@@ -40,9 +40,6 @@ class Transformation(Base):
     @property
     def q(self):    
         return Quaternion(self.data[:,3:])
-    
-    def offset(self, p: Point):
-        return Transformation(self.p + p, self.q)
 
     def __getattr__(self, name):
         if name in list("xyz"):
@@ -94,7 +91,6 @@ class Transformation(Base):
             coord_b.origin - coord_a.origin,
             -q1 * q2
         )
-
     
     def apply(self, oin: Point | Quaternion | Self | Coord):
         if isinstance(oin, Point):
@@ -115,6 +111,14 @@ class Transformation(Base):
         else:
             raise TypeError(f"expected a Point or a Quaternion, got a {oin.__class__.__name__}")
 
+    def offset(self, p: Point | Self):
+        if isinstance(p, Point):
+            return Transformation(self.p + p, self.q)
+        elif isinstance(p, self.__class__):
+            return Transformation(self.p + p.p, self.q * p.q)
+        else:
+            raise TypeError(f"expected a Point or a Transformation, got a {p.__class__.__name__}")
+
     def translate(self, point: Point):
         return point + self.p
 
@@ -134,11 +138,12 @@ class Transformation(Base):
         return outarr
         
 
-    def plot_3d(self, size: float=3, vis:Literal["coord", "plane"]="coord"):
+    def plot(self, fig=None, size: float=3, vis:Literal["coord", "plane"]="coord"):
         import plotly.graph_objects as go
         from plotting.traces import axestrace, meshes
-        import plotting.templates
-        fig = go.Figure(layout=dict(template="generic3d+clean_paper"))
+        if fig is None:
+            import plotting.templates
+            fig = go.Figure(layout=dict(template="generic3d+clean_paper"))
         if vis=="coord":
             fig.add_traces(axestrace(self, length=size))
         elif vis=="plane":

{pfc_geometry-0.2.16 → pfc_geometry-0.2.19}/src/geometry/utils.py

@@ -36,12 +36,15 @@ def get_index(
     value: Number,
     missing: float | Literal["throw"] = "throw",
     direction: Literal["forward", "backward"] = "forward",
+    increasing: bool = None
 ):
     """given a value, find the index of the first location in the aray,
     if no exact match, linearly interpolate in the index
     assumes arr is monotonic increasing
-    raise value error outside of bounds and missing == "throw", else return missing"""
-    increasing = np.sign(np.diff(arr).mean())
+    raise value error outside of bounds and missing == "throw", else return missing
+    increasing, is the array going up or down, if not given it will be inferred from the data
+    """
+    increasing = np.sign(np.diff(arr).mean()) if increasing is None else increasing
     res = np.argwhere(arr == value)
     if len(res):
         return res[0 if direction == "forward" else -1, 0]

pfc_geometry-0.2.19/tests/test_angles.py

@@ -0,0 +1,18 @@
+import numpy as np
+import geometry as g
+
+
+def test_unwind():
+    assert g.angles.unwind(0) == 0
+    assert g.angles.unwind(2*np.pi) == 0
+    assert g.angles.unwind(3*np.pi) == -np.pi
+    assert g.angles.unwind(-2*np.pi) == 0
+    assert g.angles.unwind(-3*np.pi) == np.pi
+    assert g.angles.unwind(3*np.pi, np.pi) == np.pi
+    assert g.angles.unwind(-np.pi, np.pi) == np.pi
+
+def test_unwind_array():
+    np.testing.assert_array_almost_equal(
+        g.angles.unwind(np.zeros(10)),
+        np.zeros(10)
+    )