ncca-ngl 0.3.4__tar.gz → 0.5.0__tar.gz

{ncca_ngl-0.3.4 → ncca_ngl-0.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: ncca-ngl
-Version: 0.3.4
+Version: 0.5.0
 Summary: A Python version of the NGL graphics library.
 Author: Jon Macey
 Author-email: Jon Macey <jmacey@bournemouth.ac.uk>
@@ -17,6 +17,7 @@ Requires-Dist: pillow
 Requires-Dist: glfw>=2.9.0
 Requires-Dist: freetype-py>=2.5.1
 Requires-Dist: pyside6>=6.9.2
-Requires-Python: >=3.13
+Requires-Dist: wgpu>=0.29.0
+Requires-Python: >=3.11
 Project-URL: Homepage, https://github.com/NCCA/PyNGL
 Project-URL: Issues, https://github.com/NCCA/PyNGL/issues

{ncca_ngl-0.3.4 → ncca_ngl-0.5.0}/pyproject.toml

@@ -1,9 +1,9 @@
 [project]
 name = "ncca-ngl"
-version = "0.3.4"
+version = "0.5.0"
 description = "A Python version of the NGL graphics library."
 authors = [{ name = "Jon Macey", email = "jmacey@bournemouth.ac.uk" }]
-requires-python = ">=3.13"
+requires-python = ">=3.11"
 license = { file = "LICENSE.txt" }
 
 dependencies = [
@@ -13,6 +13,7 @@ dependencies = [
     "glfw>=2.9.0",
     "freetype-py>=2.5.1",
     "pyside6>=6.9.2",
+    "wgpu>=0.29.0",
 ]
 
 [project.urls]
@@ -42,4 +43,26 @@ dev = [
     "mkdocs>=1.6.1",
     "mkdocstrings[python]>=0.30.1",
     "mkdocs-material>=9.7.0",
+    "pytest-qt>=4.5.0",
+]
+
+[tool.coverage.run]
+source = ["src/ncca/ngl"]
+omit = [
+    "*/tests/*",
+    "*/test_*",
+    "*/__pycache__/*",
+    "*/site-packages/*",
+    "__main__.py",
+    "__init__.py",
+]
+
+[tool.coverage.report]
+exclude_lines = [
+    "pragma: no cover",
+    "def __repr__",
+    "raise AssertionError",
+    "raise NotImplementedError",
+    "if __name__ == .__main__.:",
+    "if TYPE_CHECKING:",
 ]

{ncca_ngl-0.3.4 → ncca_ngl-0.5.0}/src/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-0.3.4 → ncca_ngl-0.5.0}/src/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-0.3.4 → ncca_ngl-0.5.0}/src/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-0.3.4 → ncca_ngl-0.5.0}/src/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-0.5.0/src/ncca/ngl/mat2.py

@@ -0,0 +1,164 @@
+"""
+Mat2 class with NumPy implementation
+"""
+
+import numpy as np
+
+from .vec2 import Vec2
+
+
+class Mat2Error(Exception):
+    pass
+
+
+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):
+        """
+        Initialize a 2x2 matrix.
+
+
+        """
+        self.m = np.eye(2, dtype=np.float64)
+
+    @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]:
+        """
+        Get the current matrix representation as a flat list in column-major order.
+
+        Returns:
+            list[float]: A flat list of floats.
+        """
+        return self.m.flatten("C").tolist()
+
+    def to_numpy(self):
+        """
+        Convert the current matrix to a NumPy array.
+
+        Returns:
+            np.ndarray: The matrix as a NumPy array.
+        """
+        return self.m.astype(np.float32)
+
+    @classmethod
+    def identity(cls) -> "Mat2":
+        """
+        Create an identity matrix.
+
+        Returns:
+            Mat2: A new identity Mat2 object.
+        """
+        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):
+        """
+        Matrix multiplication or vector transformation with a 2D matrix.
+
+        Args:
+            rhs (Mat2 | Vec2): The right-hand side operand.
+                                If Mat2, perform matrix multiplication.
+                                If Vec2, transform the vector by the matrix.
+
+        Returns:
+            Mat2: Resulting matrix from matrix multiplication.
+            Vec2: Transformed vector.
+
+        Raises:
+            ValueError: If rhs is neither a Mat2 nor Vec2 object.
+        """
+        if isinstance(rhs, Mat2):
+            return self._mat_mul(rhs)
+        elif isinstance(rhs, Vec2):
+            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 __str__(self) -> str:
+        """
+        String representation of the matrix.
+
+        Returns:
+            str: The string representation.
+        """
+        return f"Mat2({self.m[0].tolist()}, {self.m[1].tolist()})"
+
+    def to_list(self):
+        "convert matrix to list in column-major order"
+        return self.m.flatten("C").tolist()
+
+    def copy(self) -> "Mat2":
+        """Create a copy of the matrix.
+
+        Returns:
+            A new Mat2 instance with the same values.
+        """
+        new_mat = Mat2()
+        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))