Cleanup of inconsistencies

processing/utils/image_processing_utils.py

@@ -426,4 +426,90 @@ def save_image(
         return True
     except Exception: # as e:
         # print(f"Error saving image {path_obj}: {e}") # Optional: for debugging utils
-        return False
+        return False
+
+# --- Common Map Transformations ---
+
+import re
+import logging
+
+ipu_log = logging.getLogger(__name__)
+
+def apply_common_map_transformations(
+    image_data: np.ndarray,
+    processing_map_type: str, # The potentially suffixed internal type
+    invert_normal_green: bool,
+    file_type_definitions: Dict[str, Dict],
+    log_prefix: str
+) -> Tuple[np.ndarray, str, List[str]]:
+    """
+    Applies common in-memory transformations (Gloss-to-Rough, Normal Green Invert).
+    Returns potentially transformed image data, potentially updated map type, and notes.
+    """
+    transformation_notes = []
+    current_image_data = image_data # Start with original data
+    updated_processing_map_type = processing_map_type # Start with original type
+
+    # Gloss-to-Rough
+    # Check if the base type is Gloss (before suffix)
+    base_map_type_match = re.match(r"(MAP_GLOSS)", processing_map_type)
+    if base_map_type_match:
+        ipu_log.info(f"{log_prefix}: Applying Gloss-to-Rough conversion.")
+        inversion_succeeded = False
+        if np.issubdtype(current_image_data.dtype, np.floating):
+            current_image_data = 1.0 - current_image_data
+            current_image_data = np.clip(current_image_data, 0.0, 1.0)
+            ipu_log.debug(f"{log_prefix}: Inverted float image data for Gloss->Rough.")
+            inversion_succeeded = True
+        elif np.issubdtype(current_image_data.dtype, np.integer):
+            max_val = np.iinfo(current_image_data.dtype).max
+            current_image_data = max_val - current_image_data
+            ipu_log.debug(f"{log_prefix}: Inverted integer image data (max_val: {max_val}) for Gloss->Rough.")
+            inversion_succeeded = True
+        else:
+             ipu_log.error(f"{log_prefix}: Unsupported image data type {current_image_data.dtype} for GLOSS map. Cannot invert.")
+             transformation_notes.append("Gloss-to-Rough FAILED (unsupported dtype)")
+
+        if inversion_succeeded:
+            # Update the type string itself (e.g., MAP_GLOSS-1 -> MAP_ROUGH-1)
+            updated_processing_map_type = processing_map_type.replace("GLOSS", "ROUGH")
+            ipu_log.info(f"{log_prefix}: Map type updated: '{processing_map_type}' -> '{updated_processing_map_type}'")
+            transformation_notes.append("Gloss-to-Rough applied")
+
+    # Normal Green Invert
+    # Check if the base type is Normal (before suffix)
+    base_map_type_match_nrm = re.match(r"(MAP_NRM)", processing_map_type)
+    if base_map_type_match_nrm and invert_normal_green:
+        ipu_log.info(f"{log_prefix}: Applying Normal Map Green Channel Inversion (Global Setting).")
+        current_image_data = invert_normal_map_green_channel(current_image_data)
+        transformation_notes.append("Normal Green Inverted (Global)")
+
+    return current_image_data, updated_processing_map_type, transformation_notes
+
+# --- Normal Map Utilities ---
+
+def invert_normal_map_green_channel(normal_map: np.ndarray) -> np.ndarray:
+    """
+    Inverts the green channel of a normal map.
+    Assumes the normal map is in RGB or RGBA format (channel order R, G, B, A).
+    """
+    if normal_map is None or len(normal_map.shape) < 3 or normal_map.shape[2] < 3:
+        # Not a valid color image with at least 3 channels
+        return normal_map
+
+    # Ensure data is mutable
+    inverted_map = normal_map.copy()
+
+    # Invert the green channel (index 1)
+    # Handle different data types
+    if np.issubdtype(inverted_map.dtype, np.floating):
+        inverted_map[:, :, 1] = 1.0 - inverted_map[:, :, 1]
+    elif np.issubdtype(inverted_map.dtype, np.integer):
+        max_val = np.iinfo(inverted_map.dtype).max
+        inverted_map[:, :, 1] = max_val - inverted_map[:, :, 1]
+    else:
+        # Unsupported dtype, return original
+        print(f"Warning: Unsupported dtype {inverted_map.dtype} for normal map green channel inversion.")
+        return normal_map
+
+    return inverted_map