ncca-ngl 0.3.5__py3-none-any.whl → 0.5.0__py3-none-any.whl

ncca/ngl/PrimData/pack_arrays.py

@@ -1,15 +1,14 @@
 #!/usr/bin/env python3
 
-import numpy as np
 import pathlib
 
+import numpy as np
+
 files = pathlib.Path(".").glob("*.npy")
 
 data = {}
 for f in files:
     data[str(f.stem)] = np.load(f)
-    # arrays.append(np.load(f))
-    # names.append(str(f.stem))
 print(data.keys())
 
 

ncca/ngl/__init__.py

@@ -2,10 +2,9 @@
 from importlib.metadata import PackageNotFoundError, version
 
 try:
-    __version__ = version("ncca-ngl")
-except PackageNotFoundError:
+    __version__ = version("ncca-ngl")  # pragma: no cover
+except PackageNotFoundError:  # pragma: no cover
     __version__ = "0.0.0"
-
 __author__ = "Jon Macey jmacey@bournemouth.ac.uk"
 __license__ = "MIT"
 
@@ -16,7 +15,7 @@ from .bezier_curve import BezierCurve
 from .first_person_camera import FirstPersonCamera
 from .image import Image, ImageModes
 from .log import logger
-from .mat2 import Mat2
+from .mat2 import Mat2, Mat2Error, Mat2NotSquare
 from .mat3 import Mat3, Mat3Error, Mat3NotSquare
 from .mat4 import Mat4, Mat4Error, Mat4NotSquare
 from .multi_buffer_vao import MultiBufferVAO

ncca/ngl/base_mesh.py

@@ -54,6 +54,24 @@ class BaseMesh:
         """
         return all(len(f.vertex) == 3 for f in self.faces)
 
+    def _should_skip_vao_creation(self, reset_vao: bool) -> bool:
+        """Check if VAO creation should be skipped."""
+        if self.vao is None:
+            return False
+
+        if reset_vao:
+            logger.warning("VAO exist so returning")
+            return True
+
+        logger.warning("Creating new VAO")
+        return False
+
+    def _validate_triangular_mesh(self) -> None:
+        """Validate that the mesh is composed of triangles."""
+        if not self.is_triangular():
+            logger.error("Can only create VBO from all Triangle data at present")
+            raise RuntimeError("Can only create VBO from all Triangle data at present")
+
     def create_vao(self, reset_vao: bool = False) -> None:
         """
         Create a Vertex Array Object (VAO) for the mesh.
@@ -64,20 +82,14 @@ class BaseMesh:
         Raises:
             RuntimeError: If the mesh is not composed entirely of triangles.
         """
-        if reset_vao:
-            if self.vao is not None:
-                logger.warning("VAO exist so returning")
-                return
-        else:
-            if self.vao is not None:
-                logger.warning("Creating new VAO")
-
-        data_pack_type = 0
-        if self.is_triangular():
-            data_pack_type = gl.GL_TRIANGLES
-        if data_pack_type == 0:
-            logger.error("Can only create VBO from all Triangle data at present")
-            raise RuntimeError("Can only create VBO from all Triangle data at present")
+
+        # Handle existing VAO based on reset_vao flag
+        if self._should_skip_vao_creation(reset_vao):
+            return
+        # Validate mesh is triangular
+        self._validate_triangular_mesh()
+
+        data_pack_type = gl.GL_TRIANGLES
 
         @dataclass
         class VertData:
@@ -123,9 +135,7 @@ class BaseMesh:
                 vbo_mesh.append(d)
 
         mesh_data = np.concatenate([v.as_array() for v in vbo_mesh]).astype(np.float32)
-        self.vao = vao_factory.VAOFactory.create_vao(
-            vao_factory.VAOType.SIMPLE, data_pack_type
-        )
+        self.vao = vao_factory.VAOFactory.create_vao(vao_factory.VAOType.SIMPLE, data_pack_type)
         with self.vao as vao:
             mesh_size = len(mesh_data) // 8
             vao.set_data(VertexData(mesh_data, mesh_size))
@@ -137,9 +147,7 @@ class BaseMesh:
             vao.set_vertex_attribute_pointer(2, 2, gl.GL_FLOAT, 8 * 4, 6 * 4)
             vao.set_num_indices(mesh_size)
         self.calc_dimensions()
-        self.bbox = BBox.from_extents(
-            self.min_x, self.max_x, self.min_y, self.max_y, self.min_z, self.max_z
-        )
+        self.bbox = BBox.from_extents(self.min_x, self.max_x, self.min_y, self.max_y, self.min_z, self.max_z)
 
     def calc_dimensions(self) -> None:
         """

ncca/ngl/image.py

@@ -34,9 +34,7 @@ class Image:
                 if mode == ImageModes.GRAY:
                     self._data = np.zeros((height, width), dtype=np.uint8)
                 else:
-                    self._data = np.zeros(
-                        (height, width, len(mode.value)), dtype=np.uint8
-                    )
+                    self._data = np.zeros((height, width, len(mode.value)), dtype=np.uint8)
             else:
                 self._data = None
 

ncca/ngl/mat2.py

@@ -1,4 +1,8 @@
-import copy
+"""
+Mat2 class with NumPy implementation
+"""
+
+import numpy as np
 
 from .vec2 import Vec2
 
@@ -7,36 +11,40 @@ class Mat2Error(Exception):
     pass
 
 
-_identity = [[1.0, 0.0], [0.0, 1.0]]
+class Mat2NotSquare(Exception):
+    """If we try to construct from a non square (2x2) value or 4 elements this exception will be thrown"""
+
+    pass
 
 
 class Mat2:
     __slots__ = ["m"]
 
-    def __init__(self, m=None):
+    def __init__(self):
         """
         Initialize a 2x2 matrix.
 
-        Args:
-            m (list): A 2D list representing the matrix.
-                        If not provided, an identity matrix is created.
-        """
-        if m is None:
-            self.m = copy.deepcopy(_identity)
-        elif isinstance(m, list) and len(m) == 4 and not isinstance(m[0], list):
-            self.m = [m[0:2], m[2:4]]
-        else:
-            self.m = m
 
-    @classmethod
-    def from_list(cls, m: list[float]):
         """
-        Initialize a 2x2 matrix from a flat list.
+        self.m = np.eye(2, dtype=np.float64)
 
-        Args:
-            m (list[float]): A flat list representing the matrix.
-        """
-        return cls([m[0:2], m[2:4]])
+    @classmethod
+    def from_list(cls, lst):
+        "class method to create mat2 from list"
+        v = Mat2()
+        if isinstance(lst, list) and len(lst) == 2 and all(isinstance(row, list) for row in lst):
+            # 2D list
+            if all(len(row) == 2 for row in lst):
+                v.m = np.array(lst, dtype=np.float64)
+                return v
+            elif any(len(row) != 2 for row in lst):
+                raise Mat2NotSquare
+        elif isinstance(lst, list) and len(lst) == 4:
+            # flat list - reshape to 2x2 in row-major order
+            v.m = np.array(lst, dtype=np.float64).reshape(2, 2, order="C")
+            return v
+        else:
+            raise Mat2NotSquare
 
     def get_matrix(self) -> list[float]:
         """
@@ -45,7 +53,7 @@ class Mat2:
         Returns:
             list[float]: A flat list of floats.
         """
-        return [item for sublist in zip(*self.m, strict=False) for item in sublist]
+        return self.m.flatten("C").tolist()
 
     def to_numpy(self):
         """
@@ -54,9 +62,7 @@ class Mat2:
         Returns:
             np.ndarray: The matrix as a NumPy array.
         """
-        import numpy as np
-
-        return np.array(self.get_matrix()).reshape([2, 2])
+        return self.m.astype(np.float32)
 
     @classmethod
     def identity(cls) -> "Mat2":
@@ -66,9 +72,28 @@ class Mat2:
         Returns:
             Mat2: A new identity Mat2 object.
         """
-        ret = cls()
-        ret.m = copy.deepcopy(_identity)
-        return ret
+        return cls()
+
+    @classmethod
+    def zero(cls):
+        """class method to return a new zero matrix
+
+        Returns
+        -------
+        Mat2
+            new Mat2 matrix as all zeros
+
+        """
+        v = Mat2()
+        v.m = np.zeros((2, 2), dtype=np.float64)
+        return v
+
+    def _mat_mul(self, rhs):
+        "matrix mult for 3D OpenGL style graphics"
+        result = Mat2()
+        # Use numpy's @ operator which does standard matrix multiplication
+        result.m = rhs.m @ self.m
+        return result
 
     def __matmul__(self, rhs):
         """
@@ -77,8 +102,7 @@ class Mat2:
         Args:
             rhs (Mat2 | Vec2): The right-hand side operand.
                                 If Mat2, perform matrix multiplication.
-                                If Vec2, transform the vec
-                                r by the matrix.
+                                If Vec2, transform the vector by the matrix.
 
         Returns:
             Mat2: Resulting matrix from matrix multiplication.
@@ -90,29 +114,12 @@ class Mat2:
         if isinstance(rhs, Mat2):
             return self._mat_mul(rhs)
         elif isinstance(rhs, Vec2):
-            return Vec2(
-                rhs.x * self.m[0][0] + rhs.y * self.m[0][1],
-                rhs.x * self.m[1][0] + rhs.y * self.m[1][1],
-            )
+            vec = np.array([rhs.x, rhs.y], dtype=np.float64)
+            res = self.m @ vec
+            return Vec2(res[0], res[1])
         else:
             raise ValueError(f"Can only multiply by Mat2 or Vec2, not {type(rhs)}")
 
-    def _mat_mul(self, other):
-        """
-        Internal method to perform matrix multiplication.
-
-        Args:
-            other (Mat2): The right-hand side matrix.
-
-        Returns:
-            Mat2: Result of matrix multiplication.
-        """
-        ret = Mat2()
-        for i in range(2):
-            for j in range(2):
-                ret.m[i][j] = sum(self.m[i][k] * other.m[k][j] for k in range(2))
-        return ret
-
     def __str__(self) -> str:
         """
         String representation of the matrix.
@@ -120,12 +127,11 @@ class Mat2:
         Returns:
             str: The string representation.
         """
-        return f"Mat2({self.m[0]}, {self.m[1]})"
+        return f"Mat2({self.m[0].tolist()}, {self.m[1].tolist()})"
 
     def to_list(self):
         "convert matrix to list in column-major order"
-        # flatten to single array
-        return [item for sublist in zip(*self.m, strict=False) for item in sublist]
+        return self.m.flatten("C").tolist()
 
     def copy(self) -> "Mat2":
         """Create a copy of the matrix.
@@ -134,5 +140,25 @@ class Mat2:
             A new Mat2 instance with the same values.
         """
         new_mat = Mat2()
-        new_mat.m = copy.deepcopy(self.m)
+        new_mat.m = self.m.copy()
         return new_mat
+
+    def __eq__(self, rhs):
+        """Value-based equality for Mat2: compare underlying matrices numerically.
+        Returns NotImplemented for non-Mat2 types so Python can try reflected comparisons
+        or handle it appropriately.
+        """
+        if not isinstance(rhs, Mat2):
+            return NotImplemented
+        # self.m and other.m should be numpy arrays; compare with tolerance
+        return bool(np.allclose(self.m, rhs.m, rtol=1e-8, atol=1e-12))
+
+    def __ne__(self, rhs):
+        """Value-based equality for Mat2: compare underlying matrices numerically.
+        Returns NotImplemented for non-Mat2 types so Python can try reflected comparisons
+        or handle it appropriately.
+        """
+        if not isinstance(rhs, Mat2):
+            return NotImplemented
+        # self.m and other.m should be numpy arrays; compare with tolerance
+        return not bool(np.allclose(self.m, rhs.m, rtol=1e-8, atol=1e-12))