pfc-geometry 0.1.1__tar.gz → 0.1.2__tar.gz

pfc_geometry-0.1.2/PKG-INFO

@@ -0,0 +1,24 @@
+Metadata-Version: 2.1
+Name: pfc_geometry
+Version: 0.1.2
+Summary: A package for handling 3D geometry with a nice interface
+Home-page: https://github.com/PyFlightCoach/geometry
+Author: Thomas David
+Author-email: thomasdavid0@gmail.com
+Description-Content-Type: text/markdown
+License-File: LICENSE
+
+# geometry #
+
+Tools for handling 3D geometry, mostly just adds a nice interface to various geometric enterties. Each geometric entity can also be a vector of geometric entities. Each entity wraps a numpy array with the relevant number of columns labelled according to the cols class property and rows equal to the number of elements in the vector. Attribute access to each column is available and returns a numpy array. 
+
+Where operations are supported between geometric types the size of the output is inferred based on the length of the inputs. Where the two vectors of entities are of the same length, elementwise operations are performed. Where one vector is length one and the other is greater than one then the operation will be performed on every element of the longer vector. 
+
+Magic methods are used extensively and the function of operators are logical for each type. If unsure what the logical option is then check the code where it should be pretty clear. 
+
+Many convenience methods and constructors are available. Documentation is limited but if you need something it has probably already been written so check the code first. 
+
+
+now available on pypi:
+
+pip install pfc-geometry

pfc_geometry-0.1.2/README.md

@@ -0,0 +1,14 @@
+# geometry #
+
+Tools for handling 3D geometry, mostly just adds a nice interface to various geometric enterties. Each geometric entity can also be a vector of geometric entities. Each entity wraps a numpy array with the relevant number of columns labelled according to the cols class property and rows equal to the number of elements in the vector. Attribute access to each column is available and returns a numpy array. 
+
+Where operations are supported between geometric types the size of the output is inferred based on the length of the inputs. Where the two vectors of entities are of the same length, elementwise operations are performed. Where one vector is length one and the other is greater than one then the operation will be performed on every element of the longer vector. 
+
+Magic methods are used extensively and the function of operators are logical for each type. If unsure what the logical option is then check the code where it should be pretty clear. 
+
+Many convenience methods and constructors are available. Documentation is limited but if you need something it has probably already been written so check the code first. 
+
+
+now available on pypi:
+
+pip install pfc-geometry

{pfc_geometry-0.1.1 → pfc_geometry-0.1.2}/geometry/__init__.py

@@ -17,11 +17,11 @@ from .transformation import Transformation
 from .mass import Mass
 
 
-def Euler(*args, **kwargs):
+def Euler(*args, **kwargs) -> Quaternion:
     return Quaternion.from_euler(Point(*args, **kwargs))
     
 
-def Euldeg(*args, **kwargs):
+def Euldeg(*args, **kwargs) -> Quaternion:
     return Quaternion.from_euler(Point(*args, **kwargs).radians())
 
 

{pfc_geometry-0.1.1 → pfc_geometry-0.1.2}/geometry/base.py

@@ -47,11 +47,11 @@ class Base:
             elif "data" in kwargs:
                 args = [kwargs["data"]]
             else:
-                raise TypeError("unknown kwargs passed")
+                raise TypeError(f"unknown kwargs passed to {self.__class__.__name__}: {args}")
 
         if len(args)==1: 
-            if isinstance(args[0], np.ndarray): #data was passed directly
-                self.data = self.__class__._clean_data(args[0])
+            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
@@ -60,7 +60,7 @@ class Base:
             elif isinstance(args[0], pd.DataFrame):
                 self.data = self.__class__._clean_data(np.array(args[0]))
             else:
-                raise TypeError("unknown data passed")
+                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
@@ -80,7 +80,7 @@ class Base:
     def _clean_data(cls, data) -> np.ndarray:
         assert isinstance(data, np.ndarray)
         if data.dtype == 'O': 
-            raise TypeError('data must have homogeneous shape')
+            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))
         
@@ -257,4 +257,8 @@ class Base:
         return self.__class__(np.cumsum(self.data,axis=0))
 
     def round(self, decimals=0):
-        return self.__class__(self.data.round(decimals))
+        return self.__class__(self.data.round(decimals))
+    
+    def __repr__(self):
+        return f"{self.__class__.__name__}\n{self.to_pandas()}"
+    

pfc_geometry-0.1.2/pfc_geometry.egg-info/PKG-INFO

@@ -0,0 +1,24 @@
+Metadata-Version: 2.1
+Name: pfc-geometry
+Version: 0.1.2
+Summary: A package for handling 3D geometry with a nice interface
+Home-page: https://github.com/PyFlightCoach/geometry
+Author: Thomas David
+Author-email: thomasdavid0@gmail.com
+Description-Content-Type: text/markdown
+License-File: LICENSE
+
+# geometry #
+
+Tools for handling 3D geometry, mostly just adds a nice interface to various geometric enterties. Each geometric entity can also be a vector of geometric entities. Each entity wraps a numpy array with the relevant number of columns labelled according to the cols class property and rows equal to the number of elements in the vector. Attribute access to each column is available and returns a numpy array. 
+
+Where operations are supported between geometric types the size of the output is inferred based on the length of the inputs. Where the two vectors of entities are of the same length, elementwise operations are performed. Where one vector is length one and the other is greater than one then the operation will be performed on every element of the longer vector. 
+
+Magic methods are used extensively and the function of operators are logical for each type. If unsure what the logical option is then check the code where it should be pretty clear. 
+
+Many convenience methods and constructors are available. Documentation is limited but if you need something it has probably already been written so check the code first. 
+
+
+now available on pypi:
+
+pip install pfc-geometry

{pfc_geometry-0.1.1 → pfc_geometry-0.1.2}/pfc_geometry.egg-info/SOURCES.txt

@@ -1,11 +1,9 @@
-COPYING
 LICENSE
 README.md
 setup.cfg
 setup.py
 geometry/__init__.py
 geometry/base.py
-geometry/circle.py
 geometry/coordinate_frame.py
 geometry/gps.py
 geometry/mass.py
@@ -17,4 +15,11 @@ pfc_geometry.egg-info/PKG-INFO
 pfc_geometry.egg-info/SOURCES.txt
 pfc_geometry.egg-info/dependency_links.txt
 pfc_geometry.egg-info/requires.txt
-pfc_geometry.egg-info/top_level.txt
+pfc_geometry.egg-info/top_level.txt
+tests/test_base.py
+tests/test_coord.py
+tests/test_gps.py
+tests/test_mass.py
+tests/test_point.py
+tests/test_quaternion.py
+tests/test_transform.py

{pfc_geometry-0.1.1 → pfc_geometry-0.1.2}/setup.cfg

@@ -5,7 +5,7 @@ author_email = thomasdavid0@gmail.com
 description = A package for handling 3D geometry with a nice interface
 long_description = file: README.md
 long_description_content_type = text/markdown
-version = 0.1.1
+version = 0.1.2
 url = https://github.com/PyFlightCoach/geometry
 
 [options]
@@ -13,8 +13,6 @@ install_requires =
 	setuptools
 	numpy
 	pandas
-packages = 
-	geometry
 
 [egg_info]
 tag_build = 

pfc_geometry-0.1.2/tests/test_base.py

@@ -0,0 +1,216 @@
+from geometry.base import Base
+from pytest import mark, approx, raises
+import numpy as np
+import pandas as pd
+
+a_b_c = ["a", "b", "c"]
+class ABC(Base):
+    cols=list("abc")
+
+
+def test_init_nparray():
+    abc = ABC(np.ones((5,3)))
+    np.testing.assert_array_equal(abc.data, np.ones((5,3)))
+
+    abc = ABC(np.ones(3))
+    np.testing.assert_array_equal(abc.data, np.ones(3).reshape((1,3)))
+
+
+
+def test__dprep():
+    np.testing.assert_array_equal(
+        ABC(np.ones((10,3)))._dprep(np.ones(10)), 
+        np.ones((10,3))
+    )
+
+    np.testing.assert_array_equal(
+        ABC(np.ones((10,3)))._dprep(np.ones((10,3))), 
+        np.ones((10,3))
+    )
+
+    with raises(ValueError):
+        ABC(np.ones((10,3)))._dprep(np.ones((5,3)))
+
+    with raises(ValueError):
+        np.testing.assert_array_equal(
+            ABC(np.ones((10,3)))._dprep(np.ones(3)), 
+            np.ones((10,3))
+        )
+
+    np.testing.assert_array_equal(
+        ABC(np.ones((10,3)))._dprep(np.array([1])), 
+        np.ones((10,3))
+    )
+
+    np.testing.assert_array_equal(
+        ABC(np.ones((10,3)))._dprep(1), 
+        np.ones((10,3))
+    )
+
+
+def test_dot():
+    a = ABC(np.random.random((10, 3)))
+    b = ABC(np.random.random((10, 3)))
+
+    c = a.dot(b)
+
+    c_check = np.array([np.dot(_a.data[0], _b.data[0]) for _a, _b in zip(a,b)])
+
+    np.testing.assert_array_almost_equal(c, c_check)
+
+
+def test_init_values():
+    abc = ABC(1,2,3)
+    np.testing.assert_array_equal(abc.data, np.array([[1,2,3]]))
+
+    abc = ABC(*[np.ones(10) for _ in range(3)])
+    np.testing.assert_array_equal(abc.data, np.ones((10,3)))
+
+    with raises(TypeError):
+        abc = ABC([1,2,3], [1,2], [1,2,3,4])
+
+    abc = ABC([1,2], [1,2], [1,2])
+
+    np.testing.assert_array_equal(abc.data, np.array([[1,2], [1,2], [1,2]]).T)
+
+def test_init_kwargs():
+    with raises(TypeError):
+        abc = ABC(1,b=2,c=3)
+
+    abc = ABC(a=1,b=2,c=3)
+    np.testing.assert_array_equal(abc.data, np.array([[1,2,3]]))
+
+    abc = ABC(a=[1,1],b=[1,1],c=[1,1])
+    np.testing.assert_array_equal(abc.data, np.ones((2,3)))
+
+    abc = ABC(data=np.ones((10,3)))
+    np.testing.assert_array_equal(abc.data, np.ones((10,3)))
+
+    with raises(TypeError):
+        ABC(ggg=234342)
+
+def test_init_list_of_self():
+    abc = ABC([ABC(1,2,3), ABC(np.ones((4,3)))])
+    np.testing.assert_array_equal(abc.b, np.array([2,1,1,1,1]))
+
+def test_init_empty():
+    with raises(TypeError):
+        ABC()
+
+def test_init_df():
+    abc = ABC(pd.DataFrame(np.tile([1,2,3], (20,1)), columns=list("abc")))
+    assert all(abc.c == 3)
+
+def test_attr():
+    abc = ABC(np.ones((5,3)))
+    
+    np.testing.assert_array_equal(abc.a, np.ones(5))
+    np.testing.assert_array_equal(abc.b, np.ones(5))
+    np.testing.assert_array_equal(abc.c, np.ones(5))
+        
+    assert dir(abc) == a_b_c
+
+    with raises(AttributeError):
+        d = abc.d
+
+
+def test_getitem():
+    abc = ABC(np.tile(np.linspace(0,4,5), (3,1)).T)
+
+    assert abc[0] == ABC(np.array([[0,0,0]]))
+    assert abc[0][0] == ABC(np.array([[0,0,0]]))
+
+    assert abc[2:][0] == ABC(np.array([[2,2,2]]))
+
+
+
+def test_eq():
+    assert ABC(np.ones((5,3))) == ABC(np.ones((5,3)))
+
+    assert not ABC(np.zeros((5,3))) == ABC(np.ones((5,3)))
+    with raises(TypeError):
+        ABC(np.zeros((5,3))) == ABC(np.zeros((6,3)))
+
+    assert ABC(1,2,4) == ABC(1.0, 2.0, 4.0)
+    
+    assert ABC(np.ones((5,3))) == 1
+
+def test_add():
+    assert ABC(1,2,3) + 1 == ABC(2,3,4)
+    assert 1 + ABC(1,2,3) == ABC(2,3,4)
+    assert ABC(1,2,3) + ABC(1,2,3) == ABC(2,4,6)
+    assert ABC(1,1,1) + np.ones(10) == ABC(np.full((10,3), 2))
+
+def test_mul():
+    assert ABC(1,2,3) * 2 == ABC(2,4,6)
+    assert 2 * ABC(1,2,3) == ABC(2,4,6)
+    assert ABC(1,2,3) * ABC(1,2,3) == ABC(1,4,9)
+    assert ABC(2,2,2) * np.ones(10) == ABC(np.full((10,3), 2))
+
+    a = ABC(1,1,1) * np.array([2])
+    b = np.array([2]) * ABC(1,1,1)
+    assert a.data.shape == b.data.shape
+
+    assert ABC(1,1,1).tile(10) * np.ones(10) == ABC(np.ones((10,3)))
+
+    assert ABC(1,2,3) * np.full(5, 2) == ABC(2,4,6).tile(5)
+
+    assert ABC(1,2,3) * ABC(2,2,2).tile(10) == ABC(2,4, 6).tile(10)
+
+
+def test_div():
+    assert ABC(1,2,3) / 2 == ABC(0.5,1,1.5)
+    assert 6 / ABC(1,2,3) == ABC(6,3,2)
+
+    assert (6 / ABC(1,2,3)).data.shape == (1,3)
+
+
+def test_abs():
+    assert abs(ABC(1,1,1)) == np.sqrt(3)
+    assert abs(ABC(2,2,2)) == np.sqrt(12)
+    np.testing.assert_array_equal(abs(ABC(np.ones((5,3)))), np.full(5, np.sqrt(3)))
+
+
+def test_diff():
+    testarr = ABC(np.tile(np.linspace(0,100,20), (3,1)).T)
+    np.testing.assert_array_almost_equal(
+        testarr.diff(np.full(20,1)).data, 
+        np.tile(np.full(20, 100/19), (3,1)).T
+    ) 
+
+
+def test_full():
+    full =ABC(1,2,3).tile(100)
+
+    assert len(full) == 100
+    assert full[50] == ABC(1,2,3)
+
+
+
+@mark.skip("not expected to work yet")
+def test_single_col():
+    class A(Base):
+        cols = ["a"]
+
+    assert A(1).data == np.array([[1]])
+
+
+    np.testing.assert_array_equal(A([1,2,3]).data, np.array([[1],[2],[3]]))
+
+
+def test_concatenate():
+    a = ABC.full(ABC(1,2,3), 10)
+    b = ABC.full(ABC(4,5,6), 10)
+    c=ABC.concatenate([a,b])
+
+    assert len(c) == len(a) + len(b) 
+    np.testing.assert_array_equal(c.a, np.concatenate([a.a, b.a], axis=0))
+
+
+
+def test_repr__():
+    p = ABC(1,2,3)
+    rpr = p.__repr__().split("\n")
+    assert rpr[0] == "ABC"
+    assert np.all(rpr[1:] == str(p.to_pandas()).split("\n"))
+    

pfc_geometry-0.1.2/tests/test_coord.py

@@ -0,0 +1,32 @@
+from pytest import approx, mark
+from geometry import Coord, Point, Quaternion, P0, PX, PY, PZ
+import numpy as np
+
+
+
+def test_axes():
+    coord = Coord(np.ones((20, 12)))
+    assert coord.origin == Point(np.ones((20,3)))
+
+def test_from_axes():
+    coord = Coord.from_axes(P0(2), PX(1,2), PY(1,2), PZ(1,2))
+    assert coord.data[:,:3] == P0(2)
+
+
+def test_rotation_matrix():
+    np.testing.assert_array_equal(
+        Coord.from_nothing(10).rotation_matrix(),
+        np.tile(np.identity(3).reshape(1,3,3), (10,1,1))
+    )
+
+
+def test_rotate():
+    q = Quaternion.from_euler(Point(0, 0, np.pi/2))
+
+    c = Coord.from_nothing(10)
+
+    rc = c.rotate(q)
+    assert rc.origin == P0()
+    np.testing.assert_almost_equal(rc.x_axis.data, PY(1,10).data)
+    np.testing.assert_almost_equal(rc.y_axis.data, PX(-1,10).data)
+    np.testing.assert_almost_equal(rc.z_axis.data, PZ(1,10).data)

pfc_geometry-0.1.2/tests/test_gps.py

@@ -0,0 +1,53 @@
+from pytest import approx
+from geometry.gps import GPS
+
+import numpy as np
+
+def test_offset():
+    c = GPS( 52.542375, -1.631038)
+    p = GPS( 52.542264, -1.631817)
+    diff = c - p
+    c2 = p.offset(diff)
+
+    diff2 = c2 - p
+
+    np.testing.assert_array_almost_equal(diff.data, diff2.data, 1e-4)
+
+def test_diff():
+    p0 = GPSPosition( 50.206, 4.1941755999999994)
+    p0n = GPSPosition( 50.201, 4.1941755999999994)
+    
+    diff= p0 - p0n # should be south vector
+    pytest.approx(diff.y, 0)
+    assert diff.x >  0
+    
+    p0e= GPSPosition( 50.206, 4.195)
+    diff= p0 - p0e # should be west vector
+    pytest.approx(diff.x, 0)
+    assert diff.y < 0
+
+def test_diff():
+    p0 = GPS( 50.201, 4.195)
+    p0n = GPS( 50.206, 4.195) #directly north of p0
+    
+    diff= p0 - p0n # should be south vector
+    assert diff.y == approx(0)
+    assert diff.x < 0
+    
+    p0e= GPS( 50.201, 4.196)
+    diff= p0 - p0e # should be west vector
+    assert diff.x == approx(0)
+    assert diff.y < 0
+
+
+
+
+def test_sub():
+    centre = GPS( 52.542375, -1.631038)
+    pilot = GPS( 52.542264, -1.631817)
+
+    vec = centre - pilot 
+
+    assert abs(vec)[0] == approx(54.167, 1e-3)
+    assert vec.x[0] == approx(12.3563, 1e-3)
+    assert vec.y[0] == approx(52.7393, 1e-3)

pfc_geometry-0.1.2/tests/test_mass.py

@@ -0,0 +1,57 @@
+from geometry.mass import Mass
+from geometry import PX
+import numpy as np
+
+
+
+
+def test_point():
+    p = Mass.point(1)
+    np.testing.assert_array_equal(
+        p.data, 
+        np.concatenate([[1], np.zeros(9)]).reshape(1,10)
+    )
+
+def test_sphere():
+    s = Mass.sphere(1, 1)
+
+    np.testing.assert_array_equal(
+        s.data, 
+        np.concatenate([[1], 2/5 * np.identity(3).reshape(9)]).reshape(1,10)
+    )
+
+
+def test_cuboid():
+    c = Mass.cuboid(1, 1, 2, 3)
+
+    np.testing.assert_array_almost_equal(
+        c.data, 
+        np.concatenate([[1], ([
+            (2**2 + 3**2) / 12,
+            (1**2 + 3**2) / 12,
+            (1**2 + 2**2) / 12
+        ] * np.identity(3)).reshape(9)]).reshape(1,10)
+    )
+
+def test_matrix():
+    m = Mass.sphere(1, 1)
+    np.testing.assert_array_almost_equal(
+        m.matrix()[0],
+        2/5 * np.identity(3)
+    )
+
+    mf = Mass.full(m, 10)
+    np.testing.assert_array_almost_equal(
+        mf.matrix(),
+        np.tile(2/5 * np.identity(3), (10,1,1))
+    )
+
+def test_offset():
+    m = Mass.point(1).offset(PX(1))
+
+    assert m.m[0] == 1
+    assert m.xx[0] == 0
+    assert m.yy[0] == 1
+    assert m.zz[0] == 1
+
+    

pfc_geometry-0.1.2/tests/test_point.py

@@ -0,0 +1,92 @@
+from geometry.point import Point, cross, PX, PY, PZ, P0, is_perpendicular
+
+import unittest
+from math import pi
+from pytest import mark, approx, fixture, raises
+import numpy as np
+
+
+def test_init():
+    p = Point(1,2,3)
+    assert p.x == 1
+    assert p.y == 2
+
+def test_cross():
+    a = Point(1,2,3)
+    b = Point(1,2,3)
+
+    c = a.cross(b)
+
+    np.testing.assert_almost_equal(c.data[0,:], np.cross(a.data[0,:], b.data[0,:]))
+    assert a.cross(b) == cross(a, b)
+
+def test_cross2():
+    a = Point(np.random.random((10, 3)))
+    b = Point(np.random.random((10, 3)))
+
+    c = a.cross(b)
+
+    c_check = np.array([np.cross(_a.data[0], _b.data[0]) for _a, _b in zip(a,b)])
+
+    np.testing.assert_array_almost_equal(c.data, c_check)
+
+
+def test_scale():
+    assert Point(1,0,0).scale(5) == Point(5,0,0)
+    assert Point(1,0,0).scale(5).data.shape == Point(5,0,0).data.shape
+
+    assert P0().scale(5) == P0()
+
+def test_unit():
+    assert Point(5,0,0).unit() == Point(1,0,0)
+    assert Point(5,0,0).unit().data.shape == (1,3)
+
+def test_angle_between():
+    with raises(ValueError):
+        Point(1,2,3).cos_angle_between(Point.zeros())
+
+    assert PX().cos_angle_between(PY()) == 0
+
+    assert PX().angle_between(PY()) == np.pi / 2
+
+    
+    assert PX(-1).angle_between(Point(1,1,0)) == 3 * np.pi / 4
+
+
+def test_is_parallel():
+    assert not Point(1,0, 0).is_parallel(Point(-1,0, 0))
+    assert Point(1,0, 0).is_parallel(Point(1,0, 0))
+    assert not Point(1,0, 0).is_parallel(Point(0,1, 0))
+
+
+@mark.skip("this is going to be picked up later with coord and Quaternion stuff")
+def test_rotate():
+    assert PX().rotate(np.identity(3)) == PX()
+
+    assert PX().rotate(np.array([[0, -1, 0], [1, 0, 0], [0, 0, 1]])) == Point(0, 1, 0)
+
+def test_scalar_projection():
+    assert Point(1, 1, 0).scalar_projection(PX()) == 1
+    assert P0().scalar_projection(Point(1, 1, 0)) == 0
+    assert Point(1, 1, 0).scalar_projection(P0()) == 0
+
+def test_is_perpendicular():
+    assert is_perpendicular(Point(1, 0, 0), Point(0, 1, 0))
+    assert is_perpendicular(Point(1, 0, 0), Point(0, 0, 1))
+    assert is_perpendicular(Point(0, 1, 0), Point(1, 0, 0))
+    assert not is_perpendicular(Point(1, 0, 0), Point(1, 1, 0))
+
+
+def test_full():
+    points = Point.full(Point(1,2,3), 100)
+    assert len(points) == 100
+    assert isinstance(points, Point)
+    assert points[20] == Point(1, 2, 3)
+
+    
+def test_X():
+    assert Point.X(1,100) + Point.Y(1,100) + Point.Z(1,100) == Point(np.ones((100,3)))
+
+
+def test_to_rotation_matrix():
+    np.testing.assert_array_equal(P0().to_rotation_matrix()[0],np.identity(3))