pfc-geometry 0.2.9__py3-none-any.whl → 0.2.10__py3-none-any.whl

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,57 @@ 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')
+        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()
+        )

{pfc_geometry-0.2.9.dist-info → pfc_geometry-0.2.10.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pfc-geometry
-Version: 0.2.9
+Version: 0.2.10
 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.dist-info → pfc_geometry-0.2.10.dist-info}/RECORD

@@ -1,5 +1,5 @@
 geometry/__init__.py,sha256=HNhMyemIJzDq1nDjrr09eX5PS7q9ULscSbYsXss3JRM,1253
-geometry/base.py,sha256=jaufGQb6fxGAUWyKMYnilKbfaJtd6FkDKy7pBM4rv7w,11280
+geometry/base.py,sha256=rJSDViQlW6zHwP6n2VT7uulfargKIDEmUCV5sPhghOM,11735
 geometry/coordinate_frame.py,sha256=qO3jqUWF4PW4BOkw5rBMTXfOzBjlA1HYwGYmPtu2M8M,3039
 geometry/gps.py,sha256=Fs3hakSQ754HUqRsA7NWg_MSEdYxNqyiu4gu6EDrFqI,3381
 geometry/mass.py,sha256=BUWBSITwpdRfpJR5-oJTd16BI7FLZt8rhxdzr0cx1HY,1675
@@ -8,8 +8,8 @@ geometry/quaternion.py,sha256=PH7YKAVnQ8vZ8RZdtnrIaqx3FmHHwQ2aTEEdofrng_U,9392
 geometry/testing.py,sha256=o8yMBAdU5Vy0EspBYaof4fPGgRSFZhRDhzBjRPsLd0M,375
 geometry/time.py,sha256=ZWO6yThXesHkNsROJfUruF-G4Lpcx149x0H__0HPLvw,1206
 geometry/transformation.py,sha256=eunEC924zPBLhaVSEWE-IClrRfitvUKjSdOTaa2tdDQ,4705
-pfc_geometry-0.2.9.dist-info/LICENSE,sha256=z72U6pv-bQgJ_Svr4uCXnMjemsp38aSerhHEdEAOMJ4,7632
-pfc_geometry-0.2.9.dist-info/METADATA,sha256=8mWZo2S4C_o4fPrO8mZP11xd6w0na5lg7ebzZnpj8Qc,1978
-pfc_geometry-0.2.9.dist-info/WHEEL,sha256=nCVcAvsfA9TDtwGwhYaRrlPhTLV9m-Ga6mdyDtuwK18,91
-pfc_geometry-0.2.9.dist-info/top_level.txt,sha256=RWbWhWYclEM-OFtXLCB4eLv-jxNnlJB-NPC2YM587Fo,9
-pfc_geometry-0.2.9.dist-info/RECORD,,
+pfc_geometry-0.2.10.dist-info/LICENSE,sha256=z72U6pv-bQgJ_Svr4uCXnMjemsp38aSerhHEdEAOMJ4,7632
+pfc_geometry-0.2.10.dist-info/METADATA,sha256=aIrRdNxRV07oKLdlKXzsjcano6Y_q36vR2ONr-XRrew,1979
+pfc_geometry-0.2.10.dist-info/WHEEL,sha256=Mdi9PDNwEZptOjTlUcAth7XJDFtKrHYaQMPulZeBCiQ,91
+pfc_geometry-0.2.10.dist-info/top_level.txt,sha256=RWbWhWYclEM-OFtXLCB4eLv-jxNnlJB-NPC2YM587Fo,9
+pfc_geometry-0.2.10.dist-info/RECORD,,

{pfc_geometry-0.2.9.dist-info → pfc_geometry-0.2.10.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (73.0.0)
+Generator: setuptools (73.0.1)
 Root-Is-Purelib: true
 Tag: py3-none-any