updated to fix various issued

Author: jmacey

src/ngl/first_person_camera.py

@@ -58,9 +58,7 @@ def __init__(self, eye: Vec3, look: Vec3, up: Vec3, fov: float) -> None:
         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
-        )
+        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)
@@ -71,9 +69,7 @@ def __str__(self) -> str:
     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:
+    def process_mouse_movement(self, diffx: float, diffy: float, _constrain_pitch: bool = True) -> None:
         """
         Process mouse movement to update the camera's direction vectors.
 
@@ -117,9 +113,7 @@ def _update_camera_vectors(self) -> None:
 
         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:
+    def set_projection(self, fov: float, aspect: float, near: float, far: float) -> Mat4:
         """
         Set the projection matrix for the camera.
 
@@ -157,3 +151,18 @@ def get_vp(self) -> Mat4:
             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)

src/ngl/image.py

@@ -12,6 +12,7 @@
 class ImageModes(Enum):
     RGB = "RGB"
     RGBA = "RGBA"
+    GRAY = "L"
 
 
 class Image:
@@ -22,15 +23,18 @@ def __init__(
         height: int = 0,
         mode: ImageModes = None,
     ):
-        logger.debug(f"Creating Image from file {filename} or {width}x{height}")
         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:
-                self._data = np.zeros((height, width, len(mode.value)), dtype=np.uint8)
+                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
 
@@ -47,7 +51,16 @@ def load(self, filename: str) -> bool:
             with PILImage.open(filename) as img:
                 self._width = img.width
                 self._height = img.height
-                self._mode = ImageModes(img.mode)
+                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:

src/ngl/mat2.py

@@ -28,6 +28,16 @@ def __init__(self, m=None):
         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.

src/ngl/pyside_event_handling_mixin.py

@@ -298,17 +298,15 @@ def set_camera_state(self, state: dict) -> None:
         self.spin_y_face = state.get("spin_y_face", 0)
 
         pos = state.get("model_position", [0, 0, 0])
-        self.model_position.set(pos[0], pos[1], pos[2])
-
-        self.rotation_sensitivity = state.get(
-            "rotation_sensitivity", self.DEFAULT_ROTATION_SENSITIVITY
-        )
-        self.translation_sensitivity = state.get(
-            "translation_sensitivity", self.DEFAULT_TRANSLATION_SENSITIVITY
-        )
-        self.zoom_sensitivity = state.get(
-            "zoom_sensitivity", self.DEFAULT_ZOOM_SENSITIVITY
-        )
+        # Handle cases where pos might have fewer than 3 elements
+        x = pos[0] if len(pos) > 0 else 0
+        y = pos[1] if len(pos) > 1 else 0
+        z = pos[2] if len(pos) > 2 else 0
+        self.model_position.set(x, y, z)
+
+        self.rotation_sensitivity = state.get("rotation_sensitivity", self.DEFAULT_ROTATION_SENSITIVITY)
+        self.translation_sensitivity = state.get("translation_sensitivity", self.DEFAULT_TRANSLATION_SENSITIVITY)
+        self.zoom_sensitivity = state.get("zoom_sensitivity", self.DEFAULT_ZOOM_SENSITIVITY)
 
         # # Sync legacy attributes
         # self.sync_legacy_attributes()

src/ngl/random.py

@@ -128,9 +128,7 @@ def get_random_normalized_vec2() -> Vec2:
         return v
 
     @staticmethod
-    def get_random_point(
-        x_range: float = 1.0, y_range: float = 1.0, z_range: float = 1.0
-    ) -> Vec3:
+    def get_random_point(x_range: float = 1.0, y_range: float = 1.0, z_range: float = 1.0) -> Vec3:
         """get a random point in 3D space defaults to +/- 1 else user defined range
         Args:
             x_range (float): the +/-x range

src/ngl/texture.py

@@ -28,6 +28,19 @@ def format(self) -> int:
                 return gl.GL_RGB
             elif self._image.mode.value == "RGBA":
                 return gl.GL_RGBA
+            elif self._image.mode.value == "L":
+                return gl.GL_RED
+        return 0
+
+    @property
+    def internal_format(self) -> int:
+        if self._image.mode:
+            if self._image.mode.value == "RGB":
+                return gl.GL_RGB8
+            elif self._image.mode.value == "RGBA":
+                return gl.GL_RGBA8
+            elif self._image.mode.value == "L":
+                return gl.GL_R8
         return 0
 
     def load_image(self, filename: str) -> bool:
@@ -46,7 +59,7 @@ def set_texture_gl(self) -> int:
             gl.glTexImage2D(
                 gl.GL_TEXTURE_2D,
                 0,
-                self.format,
+                self.internal_format,
                 self.width,
                 self.height,
                 0,

tests/test_pyside_event_handling_mixin.py

@@ -10,8 +10,7 @@
 import pytest
 from PySide6.QtCore import QPointF, Qt
 
-from ngl import Vec3
-from ngl.pyside_event_handling_mixin import PySideEventHandlingMixin
+from ngl import PySideEventHandlingMixin, Vec3
 
 
 class MockEventHandlingWindow(PySideEventHandlingMixin):
@@ -350,10 +349,10 @@ def test_get_camera_state(event_window):
     expected = {
         "spin_x_face": 45,
         "spin_y_face": 90,
-        "model_position": [1, 2, 3],
+        "model_position": [pytest.approx(1), pytest.approx(2), pytest.approx(3)],
         "rotation_sensitivity": pytest.approx(0.8),
         "translation_sensitivity": pytest.approx(0.02),
-        "zoom_sensitivity": pytest.approx(0.15) ,
+        "zoom_sensitivity": pytest.approx(0.15),
     }
 
     assert state == expected
@@ -374,9 +373,9 @@ def test_set_camera_state(event_window):
 
     assert event_window.spin_x_face == 30
     assert event_window.spin_y_face == 60
-    assert event_window.model_position.x == 5
-    assert event_window.model_position.y == 10
-    assert event_window.model_position.z == 15
+    assert event_window.model_position.x == pytest.approx(5)
+    assert event_window.model_position.y == pytest.approx(10)
+    assert event_window.model_position.z == pytest.approx(15)
     assert event_window.rotation_sensitivity == pytest.approx(0.75)
     assert event_window.translation_sensitivity == pytest.approx(0.05)
     assert event_window.zoom_sensitivity == pytest.approx(0.25)
@@ -393,9 +392,9 @@ def test_set_camera_state_partial(event_window):
 
     assert event_window.spin_x_face == 15
     assert event_window.spin_y_face == 0  # Default
-    assert event_window.model_position.x == 2
-    assert event_window.model_position.y == 4
-    assert event_window.model_position.z == 6
+    assert event_window.model_position.x == pytest.approx(2)
+    assert event_window.model_position.y == pytest.approx(4)
+    assert event_window.model_position.z == pytest.approx(6)
     assert event_window.rotation_sensitivity == PySideEventHandlingMixin.DEFAULT_ROTATION_SENSITIVITY
     assert event_window.translation_sensitivity == PySideEventHandlingMixin.DEFAULT_TRANSLATION_SENSITIVITY
     assert event_window.zoom_sensitivity == PySideEventHandlingMixin.DEFAULT_ZOOM_SENSITIVITY
@@ -408,9 +407,9 @@ def test_set_camera_state_empty_dict(event_window):
     # Should use all defaults
     assert event_window.spin_x_face == 0
     assert event_window.spin_y_face == 0
-    assert event_window.model_position.x == 0
-    assert event_window.model_position.y == 0
-    assert event_window.model_position.z == 0
+    assert event_window.model_position.x == pytest.approx(0)
+    assert event_window.model_position.y == pytest.approx(0)
+    assert event_window.model_position.z == pytest.approx(0)
     assert event_window.rotation_sensitivity == PySideEventHandlingMixin.DEFAULT_ROTATION_SENSITIVITY
     assert event_window.translation_sensitivity == PySideEventHandlingMixin.DEFAULT_TRANSLATION_SENSITIVITY
     assert event_window.zoom_sensitivity == PySideEventHandlingMixin.DEFAULT_ZOOM_SENSITIVITY
@@ -439,9 +438,9 @@ def test_camera_state_round_trip(event_window):
     # Check values are restored
     assert event_window.spin_x_face == 25
     assert event_window.spin_y_face == 50
-    assert event_window.model_position.x == 3
-    assert event_window.model_position.y == 6
-    assert event_window.model_position.z == 9
+    assert event_window.model_position.x == pytest.approx(3)
+    assert event_window.model_position.y == pytest.approx(6)
+    assert event_window.model_position.z == pytest.approx(9)
     assert event_window.rotation_sensitivity == pytest.approx(0.6)
     assert event_window.translation_sensitivity == pytest.approx(0.03)
     assert event_window.zoom_sensitivity == pytest.approx(0.12)
@@ -509,3 +508,134 @@ def test_event_handling_target_protocol():
     assert hasattr(window, "close")
     assert callable(window.update)
     assert callable(window.close)
+
+
+def test_mouseMoveEvent_rotation_without_left_button(event_window):
+    """Test mouse movement during rotation mode but without left button pressed"""
+    # Setup rotation state
+    event_window.rotate = True
+    event_window.original_x_rotation = 100
+    event_window.original_y_rotation = 200
+
+    event = Mock()
+    event.buttons.return_value = Qt.NoButton  # No button pressed
+    event.position.return_value = QPointF(120, 180)
+
+    event_window.mouseMoveEvent(event)
+
+    # Should not update rotation values
+    assert event_window.spin_x_face == 0
+    assert event_window.spin_y_face == 0
+    assert event_window.update_called is False
+
+
+def test_mouseMoveEvent_translation_without_right_button(event_window):
+    """Test mouse movement during translation mode but without right button pressed"""
+    # Setup translation state
+    event_window.translate = True
+    event_window.original_x_pos = 100
+    event_window.original_y_pos = 200
+
+    event = Mock()
+    event.buttons.return_value = Qt.NoButton  # No button pressed
+    event.position.return_value = QPointF(110, 190)
+
+    event_window.mouseMoveEvent(event)
+
+    # Should not update position
+    assert event_window.model_position.x == 0
+    assert event_window.model_position.y == 0
+    assert event_window.update_called is False
+
+
+def test_mousePressEvent_middle_button(event_window):
+    """Test middle mouse button press (should be ignored)"""
+    event = Mock()
+    event.button.return_value = Qt.MiddleButton
+    event.position.return_value = QPointF(100, 200)
+
+    event_window.mousePressEvent(event)
+
+    # Should not change any state
+    assert event_window.rotate is False
+    assert event_window.translate is False
+
+
+def test_mouseReleaseEvent_middle_button(event_window):
+    """Test middle mouse button release (should be ignored)"""
+    event_window.rotate = True
+    event_window.translate = True
+
+    event = Mock()
+    event.button.return_value = Qt.MiddleButton
+
+    event_window.mouseReleaseEvent(event)
+
+    # Should not change state
+    assert event_window.rotate is True
+    assert event_window.translate is True
+
+
+def test_setup_event_handling_with_none_position():
+    """Test setup_event_handling with None initial position"""
+    window = MockEventHandlingWindow()
+    window.setup_event_handling(initial_position=None)
+
+    assert window.model_position.x == 0
+    assert window.model_position.y == 0
+    assert window.model_position.z == 0
+
+
+def test_wheelEvent_priority_y_over_x(event_window):
+    """Test that y delta takes priority over x delta when both are non-zero"""
+    event_window.zoom_sensitivity = 0.5
+    initial_z = event_window.model_position.z
+
+    event = Mock()
+    angle_delta = Mock()
+    angle_delta.y.return_value = 120  # Positive y delta
+    angle_delta.x.return_value = -120  # Negative x delta
+    event.angleDelta.return_value = angle_delta
+
+    event_window.wheelEvent(event)
+
+    # Should use y delta (120), not x delta (-120)
+    assert event_window.model_position.z == initial_z + 0.5
+    assert event_window.update_called is True
+
+
+def test_set_camera_state_partial_model_position():
+    """Test set_camera_state with partial model position data"""
+    window = MockEventHandlingWindow()
+    window.setup_event_handling()
+
+    state = {
+        "spin_x_face": 25,
+        "model_position": [7, 8],  # Only 2 values instead of 3
+    }
+
+    # This should handle the IndexError gracefully
+    window.set_camera_state(state)
+
+    assert window.spin_x_face == 25
+    assert window.model_position.x == pytest.approx(7)
+    assert window.model_position.y == pytest.approx(8)
+    # z should remain default
+    assert window.model_position.z == pytest.approx(0)
+
+
+def test_set_camera_state_empty_model_position():
+    """Test set_camera_state with empty model position list"""
+    window = MockEventHandlingWindow()
+    window.setup_event_handling()
+
+    state = {
+        "model_position": [],  # Empty list
+    }
+
+    # This should handle gracefully and use defaults
+    window.set_camera_state(state)
+
+    assert window.model_position.x == pytest.approx(0)
+    assert window.model_position.y == pytest.approx(0)
+    assert window.model_position.z == pytest.approx(0)