Fix RGB/BGR color converter and legacy dataset detection (#1972)

Fix the RGB color converter. It did not properly handle the images
returned from the polars data frame which are stored as a flattened
list. Also added support for BGR to RGB conversion.

Make the legacy converter more robust by adding explicit arguments to
determine which dataset is being dealt with. It is not always possible
to determine a hierarchical dataset just by looking at the dataset.
<!--
Please add a summary of changes. You may use Copilot to auto-generate
the PR description but please consider including any other relevant
facts which Copilot may be unaware of (such as design choices and
testing procedure).

Add references to the relevant issues and pull requests if any like so:

Resolves #111 and #222.
Depends on #1000 (for series of dependent commits).
-->

### Checklist
<!-- Put an 'x' in all the boxes that apply -->
- [ ] I have added tests to cover my changes or documented any manual
tests.
- [ ] I have updated the
[documentation](https://github.com/open-edge-platform/datumaro/tree/develop/docs)
accordingly

---------

Signed-off-by: Albert van Houten <[email protected]>
Co-authored-by: Copilot <[email protected]>

Author: AlbertvanHouten

src/datumaro/experimental/converters/__init__.py

@@ -16,7 +16,7 @@
     ImageCallableToImageConverter,
     ImagePathToImageConverter,
     ImageToImageInfo,
-    RGBToBGRConverter,
+    RedBlueColorConverter,
     UInt8ToFloat32Converter,
 )
 from datumaro.experimental.converters.mask_converters import (
@@ -67,7 +67,7 @@
     # Mask converters
     "PolygonToMaskConverter",
     # Image converters
-    "RGBToBGRConverter",
+    "RedBlueColorConverter",
     "RotatedBBoxToPolygonConverter",
     "UInt8ToFloat32Converter",
     "_can_lazy_converter_handle_conversion",

src/datumaro/experimental/converters/image_converters.py

@@ -16,68 +16,58 @@
 
 
 @converter
-class RGBToBGRConverter(Converter):
+class RedBlueColorConverter(Converter):
     """
-    Converter that transforms RGB image format to BGR format.
-
-    This converter swaps the red and blue channels of RGB images to produce
-    BGR format images, commonly used for OpenCV compatibility.
+    Converter that transforms RGB image format to BGR format and vice-versa.
     """
 
     input_image: AttributeSpec[ImageField]
     output_image: AttributeSpec[ImageField]
 
     def filter_output_spec(self) -> bool:
         """
-        Check if input is RGB and configure output for BGR conversion.
+        Check if input is RGB/BGR and configure output for BGR/RGB conversion.
 
         Returns:
-            True if the converter should be applied (RGB to BGR), False otherwise
+            True if the converter should be applied (RGB to BGR/BGR to RGB), False otherwise
         """
         input_format = self.input_image.field.format
         output_format = self.output_image.field.format
 
-        # Configure output specification for BGR format
         self.output_image = AttributeSpec(
             name=self.output_image.name,
             field=ImageField(
                 semantic=self.input_image.field.semantic,
                 dtype=self.input_image.field.dtype,
                 channels_first=self.output_image.field.channels_first,
-                format="BGR",  # Set output format to BGR
+                format=self.output_image.field.format,
             ),
         )
 
-        # Only apply if input is RGB and output should be BGR
-        return input_format == "RGB" and output_format == "BGR"
+        return (input_format == "RGB" and output_format == "BGR") or (input_format == "BGR" and output_format == "RGB")
 
     def convert(self, df: pl.DataFrame) -> pl.DataFrame:
-        """
-        Convert RGB image format to BGR using numpy channel swapping.
-
-        Args:
-            df: Input DataFrame containing RGB image data
-
-        Returns:
-            DataFrame with BGR image data in the output column
-        """
         input_column_name = self.input_image.name
         output_column_name = self.output_image.name
 
         input_shape_column_name = self.input_image.name + "_shape"
         output_shape_column_name = self.output_image.name + "_shape"
 
-        def rgb_to_bgr(tensor_data: pl.Series) -> Any:
-            """Convert RGB tensor data to BGR by reversing the channel order."""
-            data = tensor_data.to_numpy().copy()
-            data = data.reshape(-1, 3)
-            data = np.flip(data, 1)  # Flip along channel axis
-            return data.reshape(-1)
+        expected_dtype = polars_to_numpy_dtype(self.input_image.field.dtype)
+
+        def red_blue_swap(row: dict[str, Any]) -> Any:
+            """Swaps the first and third channels in the image. Images are stored as a flattened list in polars"""
+            flat_data = np.array(row[input_column_name], dtype=expected_dtype, copy=True)
+            shape = tuple(row[input_shape_column_name])
+            reshaped = flat_data.reshape(shape)
+            swapped = reshaped[..., ::-1]
+            return np.asarray(swapped.reshape(-1), dtype=expected_dtype)
 
-        dtype = df.schema[input_column_name]
         # Apply the conversion using map_elements for efficient processing
         return df.with_columns(
-            pl.col(input_column_name).map_elements(rgb_to_bgr, return_dtype=dtype).alias(output_column_name),
+            pl.struct([pl.col(input_column_name), pl.col(input_shape_column_name)])
+            .map_elements(red_blue_swap, return_dtype=pl.List(self.input_image.field.dtype))
+            .alias(output_column_name),
             pl.col(input_shape_column_name).alias(output_shape_column_name),
         )
 

src/datumaro/experimental/legacy/dataset_converters.py

@@ -44,12 +44,21 @@ class AnalysisResult:
     is_hierarchical: bool
 
 
-def analyze_legacy_dataset(legacy_dataset: LegacyDataset, semantic: Semantic = Semantic.Default) -> AnalysisResult:
+def analyze_legacy_dataset(
+    legacy_dataset: LegacyDataset,
+    semantic: Semantic = Semantic.Default,
+    hierarchical: bool = False,
+    multi_label: bool = False,
+    anomaly: bool = False,
+) -> AnalysisResult:
     """Analyze legacy dataset and generate schema using registered converters.
 
     Args:
         legacy_dataset: The legacy Datumaro dataset to analyze
         semantic: The semantic type for the converted fields
+        hierarchical: Boolean indicating if the dataset should be treated as hierarchical
+        multi_label: Boolean indicating if the dataset should be treated as multi-label
+        anomaly: Boolean indicating if the dataset should be treated as anomaly
 
     Returns:
         AnalysisResult containing the inferred schema and converters
@@ -70,11 +79,11 @@ def analyze_legacy_dataset(legacy_dataset: LegacyDataset, semantic: Semantic = S
 
         # Check if project has a hierarchical structure
         label_names = [item.name for item in legacy_dataset.categories()[AnnotationType.label].items]
-        is_hierarchical = _has_derived_labels(label_group_names) or _has_derived_labels(label_names)
+        is_hierarchical = (_has_derived_labels(label_group_names) or _has_derived_labels(label_names)) or hierarchical
 
         # Look for multi label classification groups
         multi_label_group_names = [name for name in label_group_names if name.startswith("Classification labels__")]
-        is_multi_label = len(multi_label_group_names) > 1 and not is_hierarchical
+        is_multi_label = (len(multi_label_group_names) > 1 and not is_hierarchical) or multi_label
     else:
         is_hierarchical = False
         is_multi_label = False
@@ -89,7 +98,7 @@ def analyze_legacy_dataset(legacy_dataset: LegacyDataset, semantic: Semantic = S
 
     # If we have a label converter plus other converters, assume that this is an anomaly task.
     # To avoid conflicts between the label attribute and the other ones, use semantic to distinguish them.
-    is_anomaly = AnnotationType.label in ann_types and len(ann_types) > 1
+    is_anomaly = (AnnotationType.label in ann_types and len(ann_types) > 1) or anomaly
 
     for ann_type in ann_types:
         ann_semantic = Semantic.Anomaly if is_anomaly and ann_type != AnnotationType.label else semantic
@@ -177,11 +186,16 @@ def _convert_legacy_item(item: DatasetItem, analysis_result: AnalysisResult) ->
     return attributes
 
 
-def convert_from_legacy(legacy_dataset: LegacyDataset) -> Dataset[Sample]:
+def convert_from_legacy(
+    legacy_dataset: LegacyDataset, hierarchical: bool = False, multi_label: bool = False, anomaly: bool = False
+) -> Dataset[Sample]:
     """Convert legacy dataset to new dataset format with automatic schema inference.
 
     Args:
         legacy_dataset: The legacy Datumaro dataset to convert
+        hierarchical: If True, forces hierarchical classification; otherwise, uses automatic detection.
+        multi_label: If True, forces multi-label classification; otherwise, uses automatic detection.
+        anomaly: If True, forces anomaly detection; otherwise, uses automatic detection.
     Returns:
         A new Dataset with inferred schema and converted data
 
@@ -194,7 +208,9 @@ def convert_from_legacy(legacy_dataset: LegacyDataset) -> Dataset[Sample]:
     """
 
     # Step 1: Analyze dataset to infer schema
-    analysis_result = analyze_legacy_dataset(legacy_dataset)
+    analysis_result = analyze_legacy_dataset(
+        legacy_dataset, hierarchical=hierarchical, multi_label=multi_label, anomaly=anomaly
+    )
 
     # Step 2: Create new dataset with inferred schema
     experimental_dataset = Dataset(analysis_result.schema)

src/datumaro/experimental/legacy/media_converters.py

@@ -10,7 +10,7 @@
 
 from datumaro import Dataset as LegacyDataset
 from datumaro import DatasetItem, Image, MediaElement
-from datumaro.components.media import FromDataMixin, FromFileMixin
+from datumaro.components.media import FromDataMixin, FromFileMixin, ImageFromBytes
 from datumaro.experimental import AttributeInfo, Sample, Schema, Semantic
 from datumaro.experimental.fields import (
     ImageInfo,
@@ -172,7 +172,7 @@ def get_schema_attributes(self) -> dict[str, AttributeInfo]:
     def convert_item_media(self, item: DatasetItem) -> dict[str, Any]:
         result: dict[str, Any] = {}
 
-        if isinstance(item.media, Image):  # pyright: ignore[reportUnknownMemberType]
+        if isinstance(item.media, (Image, ImageFromBytes)):
             if self.media_mixin == FromDataMixin:
                 if self.has_callable_data:
                     # Use a top-level callable to ensure picklability across workers

tests/unit/experimental/test_converters.py

@@ -26,7 +26,7 @@
     PolygonToBBoxConverter,
     PolygonToInstanceMaskConverter,
     PolygonToMaskConverter,
-    RGBToBGRConverter,
+    RedBlueColorConverter,
     RotatedBBoxToPolygonConverter,
     UInt8ToFloat32Converter,
     converter,
@@ -82,12 +82,12 @@ def convert(self, df: pl.DataFrame) -> pl.DataFrame:
 
 def test_rgb_to_bgr_converter():
     """Test RGB to BGR format conversion."""
-    converter_instance = RGBToBGRConverter()  # type: ignore[call-arg]
+    converter_instance = RedBlueColorConverter()  # type: ignore[call-arg]
 
     # Create test data
-    rgb_data = np.array([[[255, 0, 0], [0, 255, 0]], [[0, 0, 255], [128, 128, 128]]])
+    rgb_data = np.array([255, 0, 0, 0, 255, 0, 0, 0, 255, 128, 128, 128])
     df = pl.DataFrame(
-        {"image": [rgb_data.reshape(-1)], "image_shape": [[2, 2, 3]]},
+        {"image": [rgb_data], "image_shape": [[2, 2, 3]]},
         schema=pl.Schema({"image": pl.List(pl.UInt8()), "image_shape": pl.List(pl.Int64)}),
     )
 
@@ -443,7 +443,7 @@ def test_multiple_converter_chaining():
     # If successful, should have multiple steps
     assert len(path.converters["image"]) == 2
     assert type(path.converters["image"][0]) is UInt8ToFloat32Converter
-    assert type(path.converters["image"][1]) is RGBToBGRConverter
+    assert type(path.converters["image"][1]) is RedBlueColorConverter
 
     # FIXME(gdlg): the BBoxCoordinateConverter needs an image
     # and it does not matter if the image is 8 bits or 32 bits,