refactor: remove adjust/adjusted functions

robgee86 · robgee86 · commit 50d781a140ab · 2025-11-04T16:51:17.000+01:00
diff --git a/src/arduino/app_utils/image/__init__.py b/src/arduino/app_utils/image/__init__.py
@@ -11,7 +11,6 @@
     "PipeableFunction",
     "letterboxed",
     "resized",
-    "adjusted",
     "greyscaled",
     "compressed_to_jpeg",
     "compressed_to_png",
diff --git a/src/arduino/app_utils/image/image_editor.py b/src/arduino/app_utils/image/image_editor.py
@@ -27,7 +27,7 @@ class ImageEditor:
         result = frame | letterboxed(target_size=(640, 640))
         
         Chained operations:
-        result = frame | letterboxed(target_size=(640, 640)) | adjusted(brightness=10)
+        result = frame | letterboxed(target_size=(640, 640)) | greyscaled()
     """
 
     @staticmethod
@@ -101,54 +101,6 @@ def resize(frame: np.ndarray,
         else:
             return cv2.resize(frame, (target_size[1], target_size[0]), interpolation=interpolation)
 
-    @staticmethod
-    def adjust(frame: np.ndarray, 
-               brightness: float = 0.0, 
-               contrast: float = 1.0,
-               saturation: float = 1.0) -> np.ndarray:
-        """
-        Apply basic image filters.
-        
-        Args:
-            frame (np.ndarray): Input frame
-            brightness (float): Brightness adjustment (-100 to 100)
-            contrast (float): Contrast multiplier (0.0 to 3.0)
-            saturation (float): Saturation multiplier (0.0 to 3.0)
-            
-        Returns:
-            np.ndarray: adjusted frame
-        """
-        original_dtype = frame.dtype
-        
-        # Convert to float for calculations to avoid overflow/underflow
-        result = frame.astype(np.float32)
-
-        # Apply contrast and brightness
-        result = result * contrast + brightness
-        
-        # Clamp to valid range based on original dtype
-        try:
-            if np.issubdtype(original_dtype, np.integer):
-                info = np.iinfo(original_dtype)
-                result = np.clip(result, info.min, info.max)
-            else:
-                info = np.finfo(original_dtype)
-                result = np.clip(result, info.min, info.max)
-        except ValueError:
-            # If we fail, just ensure a non-negative output
-            result = np.clip(result, 0.0, np.inf)
-        
-        result = result.astype(original_dtype)
-        
-        # Apply saturation
-        if saturation != 1.0:
-            hsv = cv2.cvtColor(result, cv2.COLOR_BGR2HSV).astype(np.float32)
-            hsv[:, :, 1] *= saturation
-            hsv[:, :, 1] = np.clip(hsv[:, :, 1], 0, 255)
-            result = cv2.cvtColor(hsv.astype(np.uint8), cv2.COLOR_HSV2BGR)
-        
-        return result
-
     @staticmethod
     def greyscale(frame: np.ndarray) -> np.ndarray:
         """
@@ -244,26 +196,6 @@ def pil_to_numpy(image: Image.Image) -> np.ndarray:
         rgb_array = np.array(image)
         return cv2.cvtColor(rgb_array, cv2.COLOR_RGB2BGR)
 
-    @staticmethod
-    def get_frame_info(frame: np.ndarray) -> dict:
-        """
-        Get information about a frame.
-        
-        Args:
-            frame (np.ndarray): Input frame
-            
-        Returns:
-            dict: Frame information including dimensions, channels, dtype, size
-        """
-        return {
-            'height': frame.shape[0],
-            'width': frame.shape[1],
-            'channels': frame.shape[2] if len(frame.shape) > 2 else 1,
-            'dtype': str(frame.dtype),
-            'size_bytes': frame.nbytes,
-            'shape': frame.shape
-        }
-
 
 # =============================================================================
 # Functional API - Standalone pipeable functions
@@ -283,7 +215,7 @@ def letterboxed(target_size: Optional[Tuple[int, int]] = None,
         
     Examples:
         pipe = letterboxed(target_size=(640, 640))
-        pipe = letterboxed() | adjusted(brightness=10)
+        pipe = letterboxed() | greyscaled()
     """
     return PipeableFunction(ImageEditor.letterbox, target_size=target_size, color=color)
 
@@ -309,27 +241,6 @@ def resized(target_size: Tuple[int, int],
     return PipeableFunction(ImageEditor.resize, target_size=target_size, maintain_ratio=maintain_ratio, interpolation=interpolation)
 
 
-def adjusted(brightness: float = 0.0, 
-             contrast: float = 1.0,
-             saturation: float = 1.0):
-    """
-    Pipeable filter function - apply filters with pipe operator support.
-    
-    Args:
-        brightness (float): Brightness adjustment (-100 to 100)
-        contrast (float): Contrast multiplier (0.0 to 3.0)
-        saturation (float): Saturation multiplier (0.0 to 3.0)
-        
-    Returns:
-        Partial function that takes a frame and returns the adjusted frame
-        
-    Examples:
-        pipe = adjusted(brightness=10, contrast=1.2)
-        pipe = letterboxed() | adjusted(brightness=5) | resized(target_size=(320, 240))
-    """
-    return PipeableFunction(ImageEditor.adjust, brightness=brightness, contrast=contrast, saturation=saturation)
-
-
 def greyscaled():
     """
     Pipeable greyscale function - convert frame to greyscale with pipe operator support.
@@ -339,7 +250,7 @@ def greyscaled():
         
     Examples:
         pipe = greyscaled()
-        pipe = letterboxed() | greyscaled() | adjusted(contrast=1.2)
+        pipe = letterboxed() | greyscaled() | greyscaled()
     """
     return PipeableFunction(ImageEditor.greyscale)
 
diff --git a/tests/arduino/app_utils/image/test_image_editor.py b/tests/arduino/app_utils/image/test_image_editor.py
@@ -10,7 +10,6 @@
     ImageEditor, 
     letterboxed, 
     resized, 
-    adjusted, 
     greyscaled, 
     compressed_to_jpeg, 
     compressed_to_png
@@ -87,53 +86,6 @@ def test_resize_interpolation_methods(self, sample_frame):
             result = ImageEditor.resize(sample_frame, target_size=target_size, interpolation=interpolation)
             assert result.shape[:2] == (50, 40)
     
-    def test_adjust_brightness(self, sample_frame):
-        """Test brightness adjustment."""
-        # Increase brightness
-        result = ImageEditor.adjust(sample_frame, brightness=50)
-        assert result.shape == sample_frame.shape
-        # Brightness should increase (but clipped at 255)
-        assert np.all(result >= sample_frame)
-        
-        # Decrease brightness - should clamp at 0, so all values <= original
-        result = ImageEditor.adjust(sample_frame, brightness=-50)
-        assert result.shape == sample_frame.shape
-        assert result.dtype == sample_frame.dtype
-        assert np.all(result <= sample_frame)
-        # Values should never go below 0
-        assert np.all(result >= 0)
-    
-    def test_adjust_contrast(self, sample_frame):
-        """Test contrast adjustment."""
-        # Increase contrast
-        result = ImageEditor.adjust(sample_frame, contrast=1.5)
-        assert result.shape == sample_frame.shape
-        
-        # Decrease contrast
-        result = ImageEditor.adjust(sample_frame, contrast=0.5)
-        assert result.shape == sample_frame.shape
-    
-    def test_adjust_saturation(self, sample_frame):
-        """Test saturation adjustment."""
-        # Increase saturation
-        result = ImageEditor.adjust(sample_frame, saturation=1.5)
-        assert result.shape == sample_frame.shape
-        
-        # Decrease saturation (towards grayscale)
-        result = ImageEditor.adjust(sample_frame, saturation=0.5)
-        assert result.shape == sample_frame.shape
-        
-        # Zero saturation should be grayscale
-        result = ImageEditor.adjust(sample_frame, saturation=0.0)
-        # All channels should be equal for grayscale
-        assert np.allclose(result[:, :, 0], result[:, :, 1], atol=1)
-        assert np.allclose(result[:, :, 1], result[:, :, 2], atol=1)
-    
-    def test_adjust_combined(self, sample_frame):
-        """Test combined brightness, contrast, and saturation adjustment."""
-        result = ImageEditor.adjust(sample_frame, brightness=10, contrast=1.2, saturation=0.8)
-        assert result.shape == sample_frame.shape
-    
     def test_greyscale_conversion(self, sample_frame):
         """Test grayscale conversion."""
         result = ImageEditor.greyscale(sample_frame)
@@ -250,17 +202,6 @@ def test_resized_pipe_operator(self, sample_frame):
         assert result.shape[:2] == (50, 40)
         assert result.shape[2] == 3
     
-    def test_adjusted_function_returns_pipeable(self):
-        """Test that adjusted function returns PipeableFunction."""
-        result = adjusted(brightness=10, contrast=1.2)
-        assert isinstance(result, PipeableFunction)
-    
-    def test_adjusted_pipe_operator(self, sample_frame):
-        """Test adjusted function with pipe operator."""
-        result = adjusted(brightness=10, contrast=1.2, saturation=0.8)(sample_frame)
-        
-        assert result.shape == sample_frame.shape
-    
     def test_greyscaled_function_returns_pipeable(self):
         """Test that greyscaled function returns PipeableFunction."""
         result = greyscaled()
@@ -329,9 +270,7 @@ def test_simple_pipeline(self, sample_frame):
     def test_complex_pipeline(self, sample_frame):
         """Test complex pipeline with multiple operations."""
         # Create pipeline using function-to-function composition
-        pipe = (letterboxed(target_size=(150, 150)) |
-                   adjusted(brightness=10, contrast=1.1, saturation=0.9) |
-                   resized(target_size=(75, 75)))
+        pipe = (letterboxed(target_size=(150, 150)) | resized(target_size=(75, 75)))
         result = pipe(sample_frame)
         
         assert result.shape[:2] == (75, 75)
@@ -344,19 +283,15 @@ def test_pipeline_with_compression(self, mock_imencode, sample_frame):
         mock_imencode.return_value = (True, mock_encoded)
         
         # Create pipeline using function-to-function composition
-        pipe = (letterboxed(target_size=(100, 100)) |
-                adjusted(brightness=5) |
-                compressed_to_jpeg(quality=90))
+        pipe = (letterboxed(target_size=(100, 100)) | compressed_to_jpeg(quality=90))
         result = pipe(sample_frame)
         
         assert np.array_equal(result, mock_encoded)
     
     def test_pipeline_with_greyscale(self, sample_frame):
         """Test pipeline with greyscale conversion."""
         # Create pipeline using function-to-function composition
-        pipe = (letterboxed(target_size=(100, 100)) |
-                greyscaled() |
-                adjusted(brightness=10, contrast=1.2))
+        pipe = (letterboxed(target_size=(100, 100)) | greyscaled())
         result = pipe(sample_frame)
         
         assert len(result.shape) == 3 and result.shape[2] == 3
@@ -411,25 +346,4 @@ def test_invalid_target_sizes(self):
             ImageEditor.resize(frame, target_size=(0, 100))
         
         with pytest.raises((ValueError, cv2.error)):
-            ImageEditor.resize(frame, target_size=(-10, 100))
-    
-    def test_extreme_adjustment_values(self, sample_frame=None):
-        """Test extreme adjustment values."""
-        if sample_frame is None:
-            sample_frame = np.random.randint(0, 256, (50, 50, 3), dtype=np.uint8)
-        
-        # Extreme brightness
-        result = ImageEditor.adjust(sample_frame, brightness=1000)
-        assert result.shape == sample_frame.shape
-        assert np.all(result <= 255)  # Should be clipped
-        
-        result = ImageEditor.adjust(sample_frame, brightness=-1000)
-        assert np.all(result >= 0)  # Should be clipped
-        
-        # Extreme contrast
-        result = ImageEditor.adjust(sample_frame, contrast=100)
-        assert result.shape == sample_frame.shape
-        
-        # Zero contrast
-        result = ImageEditor.adjust(sample_frame, contrast=0)
-        assert result.shape == sample_frame.shape
+            ImageEditor.resize(frame, target_size=(-10, 100))
