ncca-ngl 0.1.1__py3-none-any.whl → 0.1.4__py3-none-any.whl

ncca/ngl/bezier_curve.py

@@ -0,0 +1,75 @@
+from .vec3 import Vec3
+
+
+class BezierCurve:
+    """A Bezier curve class."""
+
+    def __init__(
+        self, control_points: list[Vec3] = None, knots: list[float] = None
+    ) -> None:
+        self._cp = control_points if control_points is not None else []
+        self._knots = knots if knots is not None else []
+        self._degree = 0
+        self._order = 0
+        self._num_cp = 0
+        self._num_knots = 0
+        if self._cp:
+            self._num_cp = len(self._cp)
+            self._degree = self._num_cp
+            self._order = self._degree + 1
+            if not self._knots:
+                self.create_knots()
+            self._num_knots = len(self._knots)
+
+    @property
+    def control_points(self) -> list[Vec3]:
+        return self._cp
+
+    @property
+    def knots(self) -> list[float]:
+        return self._knots
+
+    def add_point(self, x: float | Vec3, y: float = None, z: float = None) -> None:
+        if isinstance(x, Vec3):
+            self._cp.append(x)
+        else:
+            self._cp.append(Vec3(x, y, z))
+        self._num_cp += 1
+        self._degree = self._num_cp
+        self._order = self._degree + 1
+        self.create_knots()
+
+    def add_knot(self, k: float) -> None:
+        self._knots.append(k)
+        self._num_knots = len(self._knots)
+
+    def create_knots(self) -> None:
+        self._num_knots = self._num_cp + self._order
+        self._knots = [0.0] * (self._num_knots // 2) + [1.0] * (
+            self._num_knots - (self._num_knots // 2)
+        )
+
+    def get_point_on_curve(self, u: float) -> Vec3:
+        p = Vec3()
+        for i in range(self._num_cp):
+            val = self.cox_de_boor(u, i, self._degree, self._knots)
+            if val > 0.001:
+                p += self._cp[i] * val
+        return p
+
+    def cox_de_boor(self, u: float, i: int, k: int, knots: list[float]) -> float:
+        if k == 1:
+            return 1.0 if knots[i] <= u <= knots[i + 1] else 0.0
+
+        den1 = knots[i + k - 1] - knots[i]
+        den2 = knots[i + k] - knots[i + 1]
+
+        eq1 = 0.0
+        if den1 > 0:
+            eq1 = ((u - knots[i]) / den1) * self.cox_de_boor(u, i, k - 1, knots)
+
+        eq2 = 0.0
+        if den2 > 0:
+            eq2 = ((knots[i + k] - u) / den2) * self.cox_de_boor(u, i + 1, k - 1, knots)
+
+        return eq1 + eq2

ncca/ngl/first_person_camera.py

@@ -0,0 +1,174 @@
+import math
+
+from .mat4 import Mat4
+from .util import perspective
+from .vec3 import Vec3
+
+
+class FirstPersonCamera:
+    """
+    A class representing a first-person camera.
+
+    This class provides functionality for a first-person camera, including movement,
+    rotation, and projection matrix calculation.
+
+    Attributes:
+        eye (Vec3): The position of the camera.
+        look (Vec3): The point the camera is looking at.
+        world_up (Vec3): The world's up vector.
+        front (Vec3): The front direction vector of the camera.
+        up (Vec3): The up direction vector of the camera.
+        right (Vec3): The right direction vector of the camera.
+        yaw (float): The yaw angle of the camera.
+        pitch (float): The pitch angle of the camera.
+        speed (float): The movement speed of the camera.
+        sensitivity (float): The mouse sensitivity.
+        zoom (float): The zoom level of the camera.
+        near (float): The near clipping plane.
+        far (float): The far clipping plane.
+        aspect (float): The aspect ratio.
+        fov (float): The field of view.
+        projection (Mat4): The projection matrix.
+        view (Mat4): The view matrix.
+    """
+
+    def __init__(self, eye: Vec3, look: Vec3, up: Vec3, fov: float) -> None:
+        """
+        Initialize the FirstPersonCamera.
+
+        Args:
+            eye (Vec3): The position of the camera.
+            look (Vec3): The point the camera is looking at.
+            up (Vec3): The world's up vector.
+            fov (float): The field of view.
+        """
+        self.eye: Vec3 = eye
+        self.look: Vec3 = look
+        self.world_up: Vec3 = up
+        self.front: Vec3 = Vec3()
+        self.up: Vec3 = Vec3()
+        self.right: Vec3 = Vec3()
+        self.yaw: float = -90.0
+        self.pitch: float = 0.0
+        self.speed: float = 2.5
+        self.sensitivity: float = 0.1
+        self.zoom: float = 45.0
+        self.near: float = 0.1
+        self.far: float = 100.0
+        self.aspect: float = 1.2
+        self.fov: float = fov
+        self._update_camera_vectors()
+        self.projection: Mat4 = self.set_projection(
+            self.fov, self.aspect, self.near, self.far
+        )
+        from .util import look_at
+
+        self.view: Mat4 = look_at(self.eye, self.eye + self.front, self.up)
+
+    def __str__(self) -> str:
+        return f"Camera {self.eye} {self.look} {self.world_up} {self.fov}"
+
+    def __repr__(self) -> str:
+        return f"Camera {self.eye} {self.look} {self.world_up} {self.fov}"
+
+    def process_mouse_movement(
+        self, diffx: float, diffy: float, _constrain_pitch: bool = True
+    ) -> None:
+        """
+        Process mouse movement to update the camera's direction vectors.
+
+        Args:
+            diffx (float): The difference in the x-coordinate of the mouse movement.
+            diffy (float): The difference in the y-coordinate of the mouse movement.
+            _constrain_pitch (bool, optional): Whether to constrain the pitch angle. Defaults to True.
+        """
+        diffx *= self.sensitivity
+        diffy *= self.sensitivity
+
+        self.yaw += diffx
+        self.pitch += diffy
+
+        # Make sure that when pitch is out of bounds, screen doesn't get flipped
+        if _constrain_pitch:
+            if self.pitch > 89.0:
+                self.pitch = 89.0
+            if self.pitch < -89.0:
+                self.pitch = -89.0
+
+        self._update_camera_vectors()
+
+    def _update_camera_vectors(self) -> None:
+        """
+        Update the camera's direction vectors based on the current yaw and pitch angles.
+        """
+        pitch = math.radians(self.pitch)
+        yaw = math.radians(self.yaw)
+        self.front.x = math.cos(yaw) * math.cos(pitch)
+        self.front.y = math.sin(pitch)
+        self.front.z = math.sin(yaw) * math.cos(pitch)
+        self.front.normalize()
+        # Also re-calculate the Right and Up vector
+        self.right = self.front.cross(self.world_up)
+        self.up = self.right.cross(self.front)
+        # normalize as fast movement can cause issues
+        self.right.normalize()
+        self.front.normalize()
+        from .util import look_at
+
+        self.view = look_at(self.eye, self.eye + self.front, self.up)
+
+    def set_projection(
+        self, fov: float, aspect: float, near: float, far: float
+    ) -> Mat4:
+        """
+        Set the projection matrix for the camera.
+
+        Args:
+            fov (float): The field of view.
+            aspect (float): The aspect ratio.
+            near (float): The near clipping plane.
+            far (float): The far clipping plane.
+
+        Returns:
+            Mat4: The projection matrix.
+        """
+
+        return perspective(fov, aspect, near, far)
+
+    def move(self, x: float, y: float, delta: float) -> None:
+        """
+        Move the camera based on input directions.
+
+        Args:
+            x (float): The movement in the x-direction.
+            y (float): The movement in the y-direction.
+            delta (float): The amount to move the camera.
+        """
+        velocity = self.speed * delta
+        self.eye += self.front * velocity * x
+        self.eye += self.right * velocity * y
+        self._update_camera_vectors()
+
+    def get_vp(self) -> Mat4:
+        """
+        Get the view-projection matrix.
+
+        Returns:
+            Mat4: The view-projection matrix.
+        """
+        return self.projection @ self.view
+
+    def process_mouse_scroll(self, y_offset: float) -> None:
+        """
+        Process mouse scroll events.
+
+        Args:
+            _yoffset (float): The scroll offset.
+        """
+        if self.zoom >= 1.0 and self.zoom <= 45.0:
+            self.zoom -= y_offset
+        if self.zoom <= 1.0:
+            self.zoom = 1.0
+        if self.zoom >= 45.0:
+            self.zoom = 45.0
+        self.projection = perspective(self.zoom, self.aspect, self.near, self.far)

ncca/ngl/image.py

@@ -0,0 +1,94 @@
+from __future__ import annotations
+
+import logging
+from enum import Enum
+
+import numpy as np
+from PIL import Image as PILImage
+
+logger = logging.getLogger(__name__)
+
+
+class ImageModes(Enum):
+    RGB = "RGB"
+    RGBA = "RGBA"
+    GRAY = "L"
+
+
+class Image:
+    def __init__(
+        self,
+        filename: str = None,
+        width: int = 0,
+        height: int = 0,
+        mode: ImageModes = None,
+    ):
+        if filename:
+            self.load(filename)
+            logger.debug(f"Creating Image from file {filename} ")
+        else:
+            self._width = width
+            self._height = height
+            self._mode = mode
+            if mode:
+                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
+                    )
+            else:
+                self._data = None
+
+    def set_pixel(self, x, y, r, g, b, a=255):
+        if x < 0 or x >= self._width or y < 0 or y >= self._height:
+            raise ValueError("Pixel coordinates out of bounds")
+        if self._mode == ImageModes.RGBA:
+            self._data[y, x] = [r, g, b, a]
+        else:
+            self._data[y, x] = [r, g, b]
+
+    def load(self, filename: str) -> bool:
+        try:
+            with PILImage.open(filename) as img:
+                self._width = img.width
+                self._height = img.height
+                try:
+                    self._mode = ImageModes(img.mode)
+                except ValueError:
+                    logger.warning(f"Image mode {img.mode} not supported, converting")
+                    if img.mode == "I;16":
+                        img = img.convert("L")
+                    else:
+                        img = img.convert("RGB")
+                    self._mode = ImageModes(img.mode)
+
+                self._data = np.array(img)
+            return True
+        except Exception as e:
+            logger.error(f"Error loading image {filename}: {e}")
+            return False
+
+    def save(self, filename: str) -> bool:
+        try:
+            img = PILImage.fromarray(self._data).convert(self._mode.value)
+            img.save(filename)
+            return True
+        except Exception as e:
+            logger.error(f"Error saving image {filename}: {e}")
+            return False
+
+    @property
+    def width(self) -> int:
+        return self._width
+
+    @property
+    def height(self) -> int:
+        return self._height
+
+    @property
+    def mode(self) -> ImageModes:
+        return self._mode
+
+    def get_pixels(self) -> np.ndarray:
+        return self._data

ncca/ngl/log.py

@@ -0,0 +1,44 @@
+import logging
+import sys
+
+
+class ColoredFormatter(logging.Formatter):
+    COLORS = {
+        logging.DEBUG: "\033[37m",  # White
+        logging.INFO: "\033[36m",  # Cyan
+        logging.WARNING: "\033[33m",  # Yellow
+        logging.ERROR: "\033[31m",  # Red
+        logging.CRITICAL: "\033[41m",  # Red background
+    }
+    RESET = "\033[0m"
+
+    def format(self, record):
+        log_message = super().format(record)
+        return f"{self.COLORS.get(record.levelno, '')}{log_message}{self.RESET}"
+
+
+def setup_logger():
+    logger = logging.getLogger("ngl")
+    if not logger.handlers:
+        logger.setLevel(logging.DEBUG)
+        file_handler = logging.FileHandler("NGLDebug.log", mode="w")
+        console_handler = logging.StreamHandler(sys.stdout)
+
+        file_formatter = logging.Formatter(
+            "%(asctime)s - %(levelname)s - %(message)s",
+            datefmt="%H:%M:%S",
+        )
+        console_formatter = ColoredFormatter(
+            "%(asctime)s - %(levelname)s - %(message)s",
+            datefmt="%H:%M:%S",
+        )
+
+        file_handler.setFormatter(file_formatter)
+        console_handler.setFormatter(console_formatter)
+
+        logger.addHandler(file_handler)
+        logger.addHandler(console_handler)
+    return logger
+
+
+logger = setup_logger()

ncca/ngl/mat2.py

@@ -0,0 +1,128 @@
+import copy
+
+from .vec2 import Vec2
+
+
+class Mat2Error(Exception):
+    pass
+
+
+_identity = [[1.0, 0.0], [0.0, 1.0]]
+
+
+class Mat2:
+    __slots__ = ["m"]
+
+    def __init__(self, m=None):
+        """
+        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.
+
+        Args:
+            m (list[float]): A flat list representing the matrix.
+        """
+        return cls([m[0:2], m[2:4]])
+
+    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 [item for sublist in zip(*self.m) for item in sublist]
+
+    def to_numpy(self):
+        """
+        Convert the current matrix to a NumPy array.
+
+        Returns:
+            np.ndarray: The matrix as a NumPy array.
+        """
+        import numpy as np
+
+        return np.array(self.get_matrix()).reshape([2, 2])
+
+    @classmethod
+    def identity(cls) -> "Mat2":
+        """
+        Create an identity matrix.
+
+        Returns:
+            Mat2: A new identity Mat2 object.
+        """
+        ret = cls()
+        ret.m = copy.deepcopy(_identity)
+        return ret
+
+    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 vec
+                                r 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):
+            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],
+            )
+        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.
+
+        Returns:
+            str: The string representation.
+        """
+        return f"Mat2({self.m[0]}, {self.m[1]})"
+
+    def to_list(self):
+        "convert matrix to list in column-major order"
+        # flatten to single array
+        return [item for sublist in zip(*self.m) for item in sublist]