pfc-geometry 0.2.9__tar.gz → 0.2.11__tar.gz

{pfc_geometry-0.2.9/pfc_geometry.egg-info → pfc_geometry-0.2.11}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pfc-geometry
-Version: 0.2.9
+Version: 0.2.11
 Summary: A package for handling 3D geometry with a nice interface
 Author-email: Thomas David <thomasdavid0@gmail.com>
 License: GNU GPL v3

{pfc_geometry-0.2.9 → pfc_geometry-0.2.11}/geometry/base.py

@@ -18,26 +18,31 @@ from numbers import Number
 
 
 def dprep(func):
-    """this decorates a method that works on numpy arrays of shape equal to self.data. 
-        you can pass a nupy array or an instance of self.__class__. As long as the length
-        is the same as self, 1, or len(self) == 1 it should construct the arguments for the decorated function.
+    """this decorates a method that works on numpy arrays of shape equal to self.data.
+    you can pass a nupy array or an instance of self.__class__. As long as the length
+    is the same as self, 1, or len(self) == 1 it should construct the arguments for the decorated function.
     """
+
     def wrapper(self, b):
         bdat = self._dprep(b)
-        
+
         if len(bdat) > 1 and len(self) == 1:
             a = self.tile(len(bdat))
         else:
             a = self
         return func(a, bdat)
-    
+
     return wrapper
 
+
 class Base:
-    __array_priority__ = 15.0   # this is a quirk of numpy so the __r*__ methods here take priority
-    cols=[]
+    __array_priority__ = (
+        15.0  # this is a quirk of numpy so the __r*__ methods here take priority
+    )
+    cols = []
     from_np_base = []
     from_np = []
+
     def __init__(self, *args, **kwargs):
         if len(kwargs) > 0:
             if len(args) > 0:
@@ -47,23 +52,31 @@ class Base:
             elif "data" in kwargs:
                 args = [kwargs["data"]]
             else:
-                raise TypeError(f"unknown kwargs passed to {self.__class__.__name__}: {args}")
-
-        if len(args)==1: 
-            if isinstance(args[0], np.ndarray) or isinstance(args[0], list): #data was passed directly
+                raise TypeError(
+                    f"unknown kwargs passed to {self.__class__.__name__}: {args}"
+                )
+
+        if len(args) == 1:
+            if isinstance(args[0], np.ndarray) or isinstance(
+                args[0], list
+            ):  # data was passed directly
                 self.data = self.__class__._clean_data(np.array(args[0]))
 
             elif all([isinstance(a, self.__class__) for a in args[0]]):
-                #a list of self.__class__ is passed, concatenate into one
-                self.data = self.__class__._clean_data(np.concatenate([a.data for a in args[0]]))
-            
+                # a list of self.__class__ is passed, concatenate into one
+                self.data = self.__class__._clean_data(
+                    np.concatenate([a.data for a in args[0]])
+                )
+
             elif isinstance(args[0], pd.DataFrame):
                 self.data = self.__class__._clean_data(np.array(args[0]))
             else:
-                raise TypeError(f"unknown args passed to {self.__class__.__name__}: {args[0]}")
-            
+                raise TypeError(
+                    f"unknown args passed to {self.__class__.__name__}: {args[0]}"
+                )
+
         elif len(args) == len(self.__class__.cols):
-            #three args passed, each represents a col
+            # three args passed, each represents a col
             if all(isinstance(arg, Number) for arg in args):
                 self.data = self.__class__._clean_data(np.array(args))
             elif all(isinstance(arg, np.ndarray) for arg in args):
@@ -71,7 +84,9 @@ class Base:
             elif all(isinstance(arg, list) for arg in args):
                 self.data = self.__class__._clean_data(np.array(args).T)
             elif all(isinstance(arg, pd.Series) for arg in args):
-                self.data = self.__class__._clean_data(np.array(pd.concat(args, axis=1)))
+                self.data = self.__class__._clean_data(
+                    np.array(pd.concat(args, axis=1))
+                )
             else:
                 raise TypeError
         else:
@@ -80,16 +95,18 @@ class Base:
     @classmethod
     def _clean_data(cls, data) -> npt.NDArray[np.float64]:
         assert isinstance(data, np.ndarray)
-        if data.dtype == 'O': 
-            raise TypeError(f'data must have homogeneous shape for {cls.__name__}, given {data.shape}')
+        if data.dtype == "O":
+            raise TypeError(
+                f"data must have homogeneous shape for {cls.__name__}, given {data.shape}"
+            )
         if len(data.shape) == 1:
             data = data.reshape(1, len(data))
-        
+
         assert data.shape[1] == len(cls.cols)
         return data
 
     @classmethod
-    def type_check(cls,a):
+    def type_check(cls, a):
         return a if isinstance(a, cls) else cls(a)
 
     @classmethod
@@ -99,7 +116,9 @@ class Base:
         elif len(b) == 1 and len(a) > 1:
             b = b.tile(len(a))
         elif len(a) > 1 and len(b) > 1 and not len(a) == len(b):
-            raise TypeError(f"lengths of passed arguments must be equal or 1, got {len(a)}, {len(b)}")
+            raise TypeError(
+                f"lengths of passed arguments must be equal or 1, got {len(a)}, {len(b)}"
+            )
         return a, b
 
     @classmethod
@@ -108,16 +127,16 @@ class Base:
 
     def __getattr__(self, name) -> npt.NDArray[np.float64]:
         if name in self.__class__.cols:
-            return self.data[:,self.__class__.cols.index(name)]
-            #return res[0] if len(res) == 1 else res
+            return self.data[:, self.__class__.cols.index(name)]
+            # return res[0] if len(res) == 1 else res
         elif name in self.__class__.from_np + self.__class__.from_np_base:
             return self.__class__(getattr(np, name)(self.data))
         else:
             for col in self.__class__.cols:
                 if len(name) > len(col):
-                    if name[:len(col)] == col:
+                    if name[: len(col)] == col:
                         try:
-                            id = int(name[len(col):])
+                            id = int(name[len(col) :])
                         except ValueError:
                             break
                         return getattr(self, col)[id]
@@ -128,31 +147,31 @@ class Base:
         return self.__class__.cols
 
     def __getitem__(self, sli) -> Self:
-        return self.__class__(self.data[sli,:])
+        return self.__class__(self.data[sli, :])
 
-    def _dprep(self, other):        
-        l , w = len(self), len(self.cols)
+    def _dprep(self, other):
+        l, w = len(self), len(self.cols)
 
         if isinstance(other, np.ndarray):
-            if other.shape == (l,w):
+            if other.shape == (l, w):
                 return other
             elif other.shape == (l, 1) or other.shape == (l,):
-                return np.tile(other, (w,1)).T
+                return np.tile(other, (w, 1)).T
             elif other.shape == (1,):
-                return np.full((l,w), other[0])
-            elif l==1:
+                return np.full((l, w), other[0])
+            elif l == 1:
                 if len(other.shape) == 1:
-                    return np.tile(other, (w,1)).T
+                    return np.tile(other, (w, 1)).T
                 elif other.shape[1] == w:
                     return other
                 else:
-                    raise ValueError(f"array shape {other.shape} not handled")    
+                    raise ValueError(f"array shape {other.shape} not handled")
             else:
                 raise ValueError(f"array shape {other.shape} not handled")
         elif isinstance(other, float) or isinstance(other, int):
-            return np.full((l,w), other)
+            return np.full((l, w), other)
         elif isinstance(other, Base):
-            a,b = self.__class__.length_check(self, other)
+            a, b = self.__class__.length_check(self, other)
             return self._dprep(b.data)
         else:
             raise ValueError(f"unhandled datatype ({other.__class__.name})")
@@ -163,7 +182,7 @@ class Base:
     def degrees(self) -> Self:
         return self.__class__(np.degrees(self.data))
 
-    def count(self) ->  int:
+    def count(self) -> int:
         return len(self)
 
     def __len__(self) -> int:
@@ -171,7 +190,7 @@ class Base:
 
     @property
     def ends(self) -> Self:
-        return self.__class__(self.data[[0,-1], :])
+        return self.__class__(self.data[[0, -1], :])
 
     @dprep
     def __eq__(self, other):
@@ -180,7 +199,7 @@ class Base:
     @dprep
     def __add__(self, other) -> Self:
         return self.__class__(self.data + other)
-    
+
     @dprep
     def __radd__(self, other) -> Self:
         return self.__class__(other + self.data)
@@ -188,7 +207,7 @@ class Base:
     @dprep
     def __sub__(self, other) -> Self:
         return self.__class__(self.data - other)
-    
+
     @dprep
     def __rsub__(self, other) -> Self:
         return self.__class__(other - self.data)
@@ -210,12 +229,14 @@ class Base:
         return self.__class__(self.data / other)
 
     def __str__(self):
-        means = ' '.join(f'{c}_={v}' for c, v in zip(self.cols, np.mean(self.data, axis=0).round(2)))
-        return f'{self.__class__.__name__}({means}, len={len(self)})'
+        means = " ".join(
+            f"{c}_={v}" for c, v in zip(self.cols, np.mean(self.data, axis=0).round(2))
+        )
+        return f"{self.__class__.__name__}({means}, len={len(self)})"
 
     def __abs__(self):
         return np.linalg.norm(self.data, axis=1)
-    
+
     def abs(self) -> Self:
         return self.__class__(np.abs(self.data))
 
@@ -224,27 +245,23 @@ class Base:
 
     @dprep
     def dot(self, other: Self) -> Self:
-        return np.einsum('ij,ij->i', self.data, other)   
+        return np.einsum("ij,ij->i", self.data, other)
 
-    def diff(self, dt:np.array) -> Self:
+    def diff(self, dt: np.array) -> Self:
         if not pd.api.types.is_list_like(dt):
             dt = np.full(len(self), dt)
         assert len(dt) == len(self)
         return self.__class__(
-            np.gradient(self.data,axis=0) \
-                / \
-                np.tile(dt, (len(self.__class__.cols),1)).T)
+            np.gradient(self.data, axis=0)
+            / np.tile(dt, (len(self.__class__.cols), 1)).T
+        )
 
-    def to_pandas(self, prefix='', suffix='', columns=None, index=None):
+    def to_pandas(self, prefix="", suffix="", columns=None, index=None):
         if columns is not None:
             cols = columns
         else:
             cols = [prefix + col + suffix for col in self.__class__.cols]
-        return pd.DataFrame(
-            self.data, 
-            columns=cols,
-            index=index
-        )
+        return pd.DataFrame(self.data, columns=cols, index=index)
 
     def tile(self, count) -> Self:
         return self.__class__(np.tile(self.data, (count, 1)))
@@ -254,14 +271,14 @@ class Base:
             return {key: getattr(self, key)[0] for key in self.cols}
         else:
             return {key: getattr(self, key) for key in self.cols}
-    
+
     @classmethod
     def from_dict(Cls, data):
         return Cls(**data)
 
     def to_dicts(self):
-        return self.to_pandas().to_dict('records')
-    
+        return self.to_pandas().to_dict("records")
+
     @classmethod
     def from_dicts(Cls, data: dict):
         return Cls(pd.DataFrame.from_dict(data))
@@ -282,53 +299,63 @@ class Base:
     def maxloc(self):
         return self.__class__(self.data.argmax(axis=0))
 
-
     def cumsum(self):
-        return self.__class__(np.cumsum(self.data,axis=0))
+        return self.__class__(np.cumsum(self.data, axis=0))
 
     def round(self, decimals=0):
         return self.__class__(self.data.round(decimals))
-    
+
     def __repr__(self):
         return str(self)
-    
+
     def copy(self):
         return self.__class__(self.data.copy())
-    
 
     def unwrap(self, discont=np.pi):
         return self.__class__(np.unwrap(self.data, discont=discont, axis=0))
-    
-    def filter(self, order, cutoff, ts: np.ndarray=None):
+
+    def filter(self, order, cutoff, ts: np.ndarray = None):
         from scipy.signal import butter, freqz, filtfilt
+
         if ts is None:
             ts = np.array(range(len(self)))
         N = len(self)
         T = (ts[-1] - ts[0]) / N
 
-        fs = 1/T
-        b, a = butter(
-            order,
-            cutoff,
-            fs=fs,
-            btype='low', analog=False
-        )
+        fs = 1 / T
+        b, a = butter(order, cutoff, fs=fs, btype="low", analog=False)
 
         return self.__class__(filtfilt(b, a, self.data, axis=0))
-    
-    def fft(self, ts: np.ndarray=None):
+
+    def fft(self, ts: np.ndarray = None):
         from scipy.fft import fft, fftfreq
+
         if ts is None:
             ts = np.array(range(len(self)))
-        N = len(self)*2
+        N = len(self) * 2
         T = (ts[-1] - ts[0]) / len(self)
 
         yf = fft(self.data, axis=0, n=N)
-        xf = fftfreq(N, T)[:N//2]
+        xf = fftfreq(N, T)[: N // 2]
 
-        
-        y=2.0/N * np.abs(yf[0:N//2, :])
+        y = 2.0 / N * np.abs(yf[0 : N // 2, :])
+
+        return pd.DataFrame(
+            np.column_stack([xf, y]), columns=["freq"] + self.cols
+        ).set_index("freq")
+
+    def fill_zeros(self):
+        """fills zero length rows with the previous or next non-zero value"""
+        return self.__class__(
+            pd.DataFrame(np.where(
+                np.tile(abs(self) == 0, (3, 1)).T,
+                np.full(self.data.shape, np.nan),
+                self.data,
+            )).ffill().bfill().to_numpy()
+        )
 
-        return pd.DataFrame(np.column_stack([xf, y]), columns=['freq'] + self.cols).set_index('freq')
+    def ffill(self):
+        return self.__class__(pd.DataFrame(self.data).ffill().to_numpy())
 
-    
+    def bfill(self):
+        return self.__class__(pd.DataFrame(self.data).bfill().to_numpy())

{pfc_geometry-0.2.9 → pfc_geometry-0.2.11}/geometry/coordinate_frame.py

@@ -9,7 +9,7 @@ FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
 You should have received a copy of the GNU General Public License along with
 this program. If not, see <http://www.gnu.org/licenses/>.
 """
-
+from __future__ import annotations
 from geometry import Point, Quaternion, PX, PY, PZ, P0
 from typing import List
 import numpy as np
@@ -33,7 +33,7 @@ class Coord(Base):
         self.z_axis=Point(self.data[:,9:12])
     
     @staticmethod
-    def from_axes(o:Point, x:Point, y:Point, z:Point):
+    def from_axes(o:Point, x:Point, y:Point, z:Point) -> Coord:
         assert len(o) == len(x) == len(y) == len(z)
         return Coord(np.concatenate([
             o.data,
@@ -43,25 +43,25 @@ class Coord(Base):
         ],axis=1))
 
     @staticmethod
-    def zero(count=1):
+    def zero(count=1) -> Coord:
         return Coord.from_nothing(count)
 
     @staticmethod
-    def from_nothing(count=1):
+    def from_nothing(count=1) -> Coord:
         return Coord.from_axes(P0(count), PX(1,count), PY(1,count), PZ(1,count))
 
     @staticmethod
-    def from_xy(origin: Point, x_axis: Point, y_axis: Point):
+    def from_xy(origin: Point, x_axis: Point, y_axis: Point) -> Coord:
         z_axis = x_axis.cross(y_axis)
         return Coord.from_axes(origin, x_axis, z_axis.cross(x_axis), z_axis)
 
     @staticmethod
-    def from_yz(origin: Point, y_axis: Point, z_axis: Point):
+    def from_yz(origin: Point, y_axis: Point, z_axis: Point) -> Coord:
         x_axis = y_axis.cross(z_axis)
         return Coord.from_axes(origin, x_axis, y_axis, x_axis.cross(y_axis))
 
     @staticmethod
-    def from_zx(origin: Point, z_axis: Point, x_axis: Point):
+    def from_zx(origin: Point, z_axis: Point, x_axis: Point) -> Coord:
         y_axis = z_axis.cross(x_axis)
         return Coord.from_axes(origin, y_axis.cross(z_axis), y_axis, z_axis)
 
@@ -71,7 +71,7 @@ class Coord(Base):
     def inverse_rotation_matrix(self):
         return Quaternion.from_rotation_matrix(self.rotation_matrix()).inverse().to_rotation_matrix()
 
-    def rotate(self, rotation=Quaternion):
+    def rotate(self, rotation=Quaternion) -> Coord:
         return Coord.from_axes(
             self.origin,
             rotation.transform_point(self.x_axis),
@@ -82,7 +82,7 @@ class Coord(Base):
     def __eq__(self, other):
         return self.data == other.data
 
-    def translate(self, point):
+    def translate(self, point) -> Coord:
         return Coord.from_axes(self.origin + point, self.x_axis, self.y_axis, self.z_axis)
 
     def axes(self):

{pfc_geometry-0.2.9 → pfc_geometry-0.2.11}/geometry/point.py

@@ -14,6 +14,8 @@ from .base import Base
 import numpy as np
 import pandas as pd
 from warnings import warn
+from numbers import Number
+import numpy.typing as npt
 
 
 class Point(Base):
@@ -62,16 +64,16 @@ class Point(Base):
         return abs(Point.angles(self, p2))
     
     @staticmethod
-    def X(value=1, count=1):
-        return Point(np.tile([value,0,0], (count, 1)))
+    def X(value: Number | npt.NDArray=1, count=1):
+        return np.tile(value, count) * Point(1,0,0)
 
     @staticmethod
     def Y(value=1, count=1):
-        return Point(np.tile([0,value,0], (count, 1)))
+        return np.tile(value, count) * Point(0,1,0)
 
     @staticmethod
     def Z(value=1, count=1):
-        return Point(np.tile([0,0,value], (count, 1)))
+        return np.tile(value, count) * Point(0,0,1)
 
     def rotate(self, rmat=np.ndarray):
         if len(rmat.shape) == 3:
@@ -108,6 +110,9 @@ class Point(Base):
     def zeros(count=1):
         return Point(np.zeros((count,3)))
 
+    def bearing(self):
+        return np.arctan2(self.y, self.x)
+
 def Points(*args, **kwargs):
     warn("Points is deprecated, you can now just use Point", DeprecationWarning)
     return Point(*args, **kwargs)
@@ -136,7 +141,7 @@ def ppmeth(func):
 
 
 @ppmeth
-def cross(a, b) -> Point:
+def cross(a: Point, b: Point) -> Point:
     return Point(np.cross(a.data, b.data))
  
 

{pfc_geometry-0.2.9 → pfc_geometry-0.2.11}/geometry/quaternion.py

@@ -253,7 +253,10 @@ class Quaternion(Base):
         # does the rotation reverse the Z axis?
         return np.sign(self.transform_point(PZ()).z) > 0
 
-    
+    def bearing(self, p: Point=None):
+        if p is None:
+            p = Point.X()
+        return self.transform_point(p).bearing()
     
         
 

{pfc_geometry-0.2.9 → pfc_geometry-0.2.11/pfc_geometry.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pfc-geometry
-Version: 0.2.9
+Version: 0.2.11
 Summary: A package for handling 3D geometry with a nice interface
 Author-email: Thomas David <thomasdavid0@gmail.com>
 License: GNU GPL v3