synapse-sdk 1.0.0a23__py3-none-any.whl → 2025.12.3__py3-none-any.whl

synapse_sdk/utils/converters/dm_legacy/to_v1.py

@@ -0,0 +1,367 @@
+import random
+import string
+
+from . import BaseDMConverter
+
+
+class DMV2ToV1Converter(BaseDMConverter):
+    """DM v2 to v1 format converter class."""
+
+    def __init__(self, new_dm_data={}, file_type=None):
+        """Initialize the converter.
+
+        Args:
+            new_dm_data (dict): DM v2 format data to be converted
+            file_type (str, optional): Type of file being converted (image, video, pcd, text, audio)
+        """
+        # Auto-detect file type if not provided
+        if file_type is None:
+            file_type = self._detect_file_type(new_dm_data)
+
+        super().__init__(file_type=file_type)
+        self.new_dm_data = new_dm_data
+        self.annotations = {}
+        self.annotations_data = {}
+        self.extra = {}
+        self.relations = {}
+        self.annotation_groups = {}
+
+    def _detect_file_type(self, data):
+        """Auto-detect file type from the data structure.
+
+        Args:
+            data (dict): DM v2 format data
+
+        Returns:
+            str: Detected file type (image, video, pcd, text, audio)
+        """
+        if not data:
+            return None
+
+        # Check for media type keys (plural forms)
+        if 'images' in data:
+            return 'image'
+        elif 'videos' in data:
+            return 'video'
+        elif 'pcds' in data:
+            return 'pcd'
+        elif 'texts' in data:
+            return 'text'
+        elif 'audios' in data:
+            return 'audio'
+
+        return None
+
+    def convert(self):
+        """Convert DM v2 data to v1 format.
+
+        Returns:
+            dict: Converted data in DM v1 format
+        """
+        # Reset state
+        new_dm_data = self.new_dm_data
+        self.annotations = {}
+        self.annotations_data = {}
+        self.extra = {}
+        self.relations = {}
+        self.annotation_groups = {}
+
+        # Process each media type (images, videos, etc.)
+        for media_type_plural, media_items in new_dm_data.items():
+            if media_type_plural == 'classification':
+                continue
+
+            media_type = self._singularize_media_type(media_type_plural)
+
+            for index, media_item in enumerate(media_items, 1):
+                media_id = f'{media_type}_{index}'
+
+                # Initialize structures for this media
+                self.annotations[media_id] = []
+                self.annotations_data[media_id] = []
+                self.extra[media_id] = {}
+                self.relations[media_id] = []
+                self.annotation_groups[media_id] = []
+
+                # Process each tool type in the media item
+                for tool_type, tool_data in media_item.items():
+                    self._process_tool_data(media_id, tool_type, tool_data)
+
+        # Build final result
+        result = {
+            'extra': self.extra,
+            'relations': self.relations,
+            'annotations': self.annotations,
+            'annotationsData': self.annotations_data,
+            'annotationGroups': self.annotation_groups,
+        }
+
+        return result
+
+    def _process_tool_data(self, media_id, tool_type, tool_data):
+        """Process tool data for a specific media item.
+
+        Args:
+            media_id (str): ID of the media item
+            tool_type (str): Type of annotation tool
+            tool_data (list): List of annotation data for this tool
+        """
+        for annotation in tool_data:
+            annotation_id = annotation['id']
+            classification = annotation['classification']
+            attrs = annotation.get('attrs', [])
+            data = annotation.get('data', {})
+
+            # Create annotation entry
+            annotation_entry = {
+                'id': annotation_id,
+                'tool': tool_type,
+                'isLocked': False,
+                'isVisible': True,
+                'classification': {'class': classification},
+            }
+
+            # Add additional classification attributes from attrs
+            for attr in attrs:
+                attr_name = attr.get('name')
+                attr_value = attr.get('value')
+                if attr_name and attr_value is not None:
+                    annotation_entry['classification'][attr_name] = attr_value
+
+            # Add special attributes for specific tools
+            if tool_type == 'keypoint':
+                annotation_entry['shape'] = 'circle'
+
+            self.annotations[media_id].append(annotation_entry)
+
+            # Create annotations data entry using tool processor
+            processor = self.tool_processors.get(tool_type)
+            if processor:
+                processor(annotation_id, data, self.annotations_data[media_id])
+            else:
+                self._handle_unknown_tool(tool_type, annotation_id)
+
+    def _convert_bounding_box(self, annotation_id, data, annotations_data):
+        """Process bounding box annotation data.
+
+        Args:
+            annotation_id (str): ID of the annotation
+            data (list): Bounding box data [x1, y1, x2, y2]
+            annotations_data (list): List to append the processed data
+        """
+        if len(data) >= 4:
+            x1, y1, width, height = data[:4]
+            coordinate = {'x': x1, 'y': y1, 'width': width, 'height': height}
+
+            annotations_data.append({'id': annotation_id, 'coordinate': coordinate})
+
+    def _convert_named_entity(self, annotation_id, data, annotations_data):
+        """Process named entity annotation data.
+
+        Args:
+            annotation_id (str): ID of the annotation
+            data (dict): Named entity data with ranges and content
+            annotations_data (list): List to append the processed data
+        """
+        entity_data = {'id': annotation_id}
+
+        if 'ranges' in data:
+            entity_data['ranges'] = data['ranges']
+
+        if 'content' in data:
+            entity_data['content'] = data['content']
+
+        annotations_data.append(entity_data)
+
+    def _convert_classification(self, annotation_id, data, annotations_data):
+        """Process classification annotation data.
+
+        Args:
+            annotation_id (str): ID of the annotation
+            data (dict): Classification data (usually empty)
+            annotations_data (list): List to append the processed data
+        """
+        # Classification data is typically empty in v2, so we just add the ID
+        annotations_data.append({'id': annotation_id})
+
+    def _convert_polyline(self, annotation_id, data, annotations_data):
+        """Process polyline annotation data.
+
+        Args:
+            annotation_id (str): ID of the annotation
+            data (list): Polyline data - can be flat [x1, y1, x2, y2, ...] or nested [[x1, y1], [x2, y2], ...]
+            annotations_data (list): List to append the processed data
+        """
+        coordinates = []
+
+        if data and isinstance(data[0], list):
+            # Nested format: [[x1, y1], [x2, y2], ...]
+            for point in data:
+                if len(point) >= 2:
+                    coordinates.append({'x': point[0], 'y': point[1], 'id': self._generate_random_id()})
+        else:
+            # Flat format: [x1, y1, x2, y2, ...]
+            for i in range(0, len(data), 2):
+                if i + 1 < len(data):
+                    coordinates.append({'x': data[i], 'y': data[i + 1], 'id': self._generate_random_id()})
+
+        annotations_data.append({'id': annotation_id, 'coordinate': coordinates})
+
+    def _convert_keypoint(self, annotation_id, data, annotations_data):
+        """Process keypoint annotation data.
+
+        Args:
+            annotation_id (str): ID of the annotation
+            data (list): Keypoint data [x, y]
+            annotations_data (list): List to append the processed data
+        """
+        if len(data) >= 2:
+            coordinate = {'x': data[0], 'y': data[1]}
+
+            annotations_data.append({'id': annotation_id, 'coordinate': coordinate})
+
+    def _convert_3d_bounding_box(self, annotation_id, data, annotations_data):
+        """Process 3D bounding box annotation data.
+
+        Args:
+            annotation_id (str): ID of the annotation
+            data (dict): 3D bounding box PSR data
+            annotations_data (list): List to append the processed data
+        """
+        annotations_data.append({'id': annotation_id, 'psr': data})
+
+    def _convert_image_segmentation(self, annotation_id, data, annotations_data):
+        """Process segmentation annotation data.
+
+        Args:
+            annotation_id (str): ID of the annotation
+            data (list or dict): Segmentation data (pixel_indices or section)
+            annotations_data (list): List to append the processed data
+        """
+        annotation_data = {'id': annotation_id}
+
+        if isinstance(data, list):
+            # Pixel-based segmentation
+            annotation_data['pixel_indices'] = data
+        elif isinstance(data, dict):
+            # Section-based segmentation (video)
+            annotation_data['section'] = data
+
+        annotations_data.append(annotation_data)
+
+    def _convert_video_segmentation(self, annotation_id, data, annotations_data):
+        """Process video segmentation annotation data.
+
+        Args:
+            annotation_id (str): ID of the annotation
+            data (list or dict): Segmentation data (pixel_indices or section)
+            annotations_data (list): List to append the processed data
+        """
+        annotation_data = {'id': annotation_id}
+
+        if isinstance(data, list):
+            # Pixel-based segmentation
+            annotation_data['pixel_indices'] = data
+        elif isinstance(data, dict):
+            # Section-based segmentation (video)
+            annotation_data['section'] = data
+
+        annotations_data.append(annotation_data)
+
+    def _convert_3d_segmentation(self, annotation_id, data, annotations_data):
+        """Process 3D segmentation annotation data.
+
+        Args:
+            annotation_id (str): ID of the annotation
+            data (list or dict): 3D segmentation data
+            annotations_data (list): List to append the processed data
+        """
+        annotation_data = {'id': annotation_id}
+
+        if isinstance(data, list):
+            # Pixel-based segmentation
+            annotation_data['pixel_indices'] = data
+        elif isinstance(data, dict):
+            # Section-based segmentation
+            annotation_data['section'] = data
+
+        annotations_data.append(annotation_data)
+
+    def _convert_prompt(self, annotation_id, data, annotations_data):
+        """Process prompt annotation data.
+
+        Args:
+            annotation_id (str): ID of the annotation
+            data (dict): Prompt data
+            annotations_data (list): List to append the processed data
+        """
+        annotation_data = {'id': annotation_id}
+
+        if isinstance(data, dict):
+            annotation_data.update(data)
+
+        annotations_data.append(annotation_data)
+
+    def _convert_answer(self, annotation_id, data, annotations_data):
+        """Process answer annotation data.
+
+        Args:
+            annotation_id (str): ID of the annotation
+            data (dict): Answer data
+            annotations_data (list): List to append the processed data
+        """
+        annotation_data = {'id': annotation_id}
+
+        if isinstance(data, dict):
+            annotation_data.update(data)
+
+        annotations_data.append(annotation_data)
+
+    def _convert_polygon(self, annotation_id, data, annotations_data):
+        """Process polygon annotation data.
+
+        Args:
+            annotation_id (str): ID of the annotation
+            data (list): Polygon data - can be flat [x1, y1, x2, y2, ...] or nested [[x1, y1], [x2, y2], ...]
+            annotations_data (list): List to append the processed data
+        """
+        coordinates = []
+
+        if data and isinstance(data[0], list):
+            # Nested format: [[x1, y1], [x2, y2], ...]
+            for point in data:
+                if len(point) >= 2:
+                    coordinates.append({'x': point[0], 'y': point[1], 'id': self._generate_random_id()})
+        else:
+            # Flat format: [x1, y1, x2, y2, ...]
+            for i in range(0, len(data), 2):
+                if i + 1 < len(data):
+                    coordinates.append({'x': data[i], 'y': data[i + 1], 'id': self._generate_random_id()})
+
+        annotations_data.append({'id': annotation_id, 'coordinate': coordinates})
+
+    def _convert_relation(self, annotation_id, data, annotations_data):
+        """Process relation annotation data.
+
+        Args:
+            annotation_id (str): ID of the annotation
+            data (list): Relation data
+            annotations_data (list): List to append the processed data
+        """
+        annotations_data.append({'id': annotation_id, 'data': data})
+
+    def _convert_group(self, annotation_id, data, annotations_data):
+        """Process group annotation data.
+
+        Args:
+            annotation_id (str): ID of the annotation
+            data (list): Group data
+            annotations_data (list): List to append the processed data
+        """
+        annotations_data.append({'id': annotation_id, 'data': data})
+
+    def _generate_random_id(self):
+        """Generate a random ID similar to the original format."""
+        # Generate 10-character random string with letters, numbers, and symbols
+        chars = string.ascii_letters + string.digits + '-_'
+        return ''.join(random.choices(chars, k=10))

synapse_sdk/utils/converters/pascal/from_dm.py

@@ -0,0 +1,244 @@
+import json
+import os
+import shutil
+import xml.etree.ElementTree as ET
+from glob import glob
+from typing import IO, Any, Dict, List, Optional
+
+from PIL import Image
+
+from synapse_sdk.utils.converters import FromDMConverter
+
+
+class FromDMToPascalConverter(FromDMConverter):
+    """Convert DM format to Pascal VOC format."""
+
+    IMG_EXTENSIONS = ['.jpg', '.jpeg', '.png', '.bmp']
+
+    def __init__(self, root_dir: str = None, is_categorized_dataset: bool = False, is_single_conversion: bool = False):
+        super().__init__(root_dir, is_categorized_dataset, is_single_conversion)
+        self.class_names = set()
+
+    def find_image_for_base(self, img_dir: str, base: str) -> Optional[str]:
+        """Find the image file for a given base name in the specified directory."""
+        for ext in self.IMG_EXTENSIONS:
+            img_path = os.path.join(img_dir, base + ext)
+            if os.path.exists(img_path):
+                return img_path
+        return None
+
+    def build_pascal_xml(
+        self, img_filename: str, img_size: tuple, objects: List[dict], has_segmentation: bool = None
+    ) -> ET.ElementTree:
+        """Build a Pascal VOC XML tree from image filename, size, and objects."""
+        folder = 'Images'
+        width, height, depth = img_size
+        annotation = ET.Element('annotation')
+        ET.SubElement(annotation, 'folder').text = folder
+        ET.SubElement(annotation, 'filename').text = img_filename
+        ET.SubElement(annotation, 'path').text = img_filename
+        source = ET.SubElement(annotation, 'source')
+        ET.SubElement(source, 'database').text = 'Unknown'
+        size = ET.SubElement(annotation, 'size')
+        ET.SubElement(size, 'width').text = str(width)
+        ET.SubElement(size, 'height').text = str(height)
+        ET.SubElement(size, 'depth').text = str(depth)
+
+        # Set segmented to 1 if there are any segmentation objects, 0 otherwise
+        if has_segmentation is None:
+            has_segmentation = any(obj.get('has_segmentation', False) for obj in objects)
+        ET.SubElement(annotation, 'segmented').text = '1' if has_segmentation else '0'
+
+        for obj in objects:
+            obj_elem = ET.SubElement(annotation, 'object')
+            ET.SubElement(obj_elem, 'name').text = obj['name']
+            ET.SubElement(obj_elem, 'pose').text = 'Unspecified'
+            ET.SubElement(obj_elem, 'truncated').text = '0'
+            ET.SubElement(obj_elem, 'difficult').text = '0'
+            bndbox = ET.SubElement(obj_elem, 'bndbox')
+            ET.SubElement(bndbox, 'xmin').text = str(obj['xmin'])
+            ET.SubElement(bndbox, 'ymin').text = str(obj['ymin'])
+            ET.SubElement(bndbox, 'xmax').text = str(obj['xmax'])
+            ET.SubElement(bndbox, 'ymax').text = str(obj['ymax'])
+        return ET.ElementTree(annotation)
+
+    def parse_dm_annotations(self, annotation: dict):
+        """Parse DM annotations and convert to Pascal VOC format."""
+        objects = []
+        has_segmentation = 'segmentation' in annotation
+
+        # Only include bounding_box (Pascal VOC does not support polyline/keypoint by default)
+        if 'bounding_box' in annotation:
+            for box in annotation['bounding_box']:
+                class_name = box['classification']
+                x, y, w, h = box['data']
+                xmin = int(round(x))
+                ymin = int(round(y))
+                xmax = int(round(x + w))
+                ymax = int(round(y + h))
+                objects.append({
+                    'name': class_name,
+                    'xmin': xmin,
+                    'ymin': ymin,
+                    'xmax': xmax,
+                    'ymax': ymax,
+                    'has_segmentation': has_segmentation,
+                })
+                self.class_names.add(class_name)
+
+        # polyline, keypoint 등은 무시
+        return objects, has_segmentation
+
+    def _convert_split_dir(self, split_dir: str, split_name: str):
+        """Convert a split dir (train/valid/test) to list of (xml_tree, xml_filename, img_src, img_name)."""
+        json_dir = os.path.join(split_dir, 'json')
+        img_dir = os.path.join(split_dir, 'original_files')
+        results = []
+        for jfile in glob(os.path.join(json_dir, '*.json')):
+            base = os.path.splitext(os.path.basename(jfile))[0]
+            img_path = self.find_image_for_base(img_dir, base)
+            if not img_path:
+                print(f'[{split_name}] Image for {base} not found, skipping.')
+                continue
+            with open(jfile, encoding='utf-8') as jf:
+                data = json.load(jf)
+            img_ann = data['images'][0]
+            with Image.open(img_path) as img:
+                width, height = img.size
+                depth = len(img.getbands())
+            objects, has_segmentation = self.parse_dm_annotations(img_ann)
+            xml_tree = self.build_pascal_xml(
+                os.path.basename(img_path), (width, height, depth), objects, has_segmentation
+            )
+            xml_filename = base + '.xml'
+            results.append((xml_tree, xml_filename, img_path, os.path.basename(img_path)))
+        return results
+
+    def _convert_root_dir(self):
+        """Convert non-categorized dataset to list of (xml_tree, xml_filename, img_src, img_name)."""
+        json_dir = os.path.join(self.root_dir, 'json')
+        img_dir = os.path.join(self.root_dir, 'original_files')
+        results = []
+        for jfile in glob(os.path.join(json_dir, '*.json')):
+            base = os.path.splitext(os.path.basename(jfile))[0]
+            img_path = self.find_image_for_base(img_dir, base)
+            if not img_path:
+                print(f'[Pascal] Image for {base} not found, skipping.')
+                continue
+            with open(jfile, encoding='utf-8') as jf:
+                data = json.load(jf)
+            img_ann = data['images'][0]
+            with Image.open(img_path) as img:
+                width, height = img.size
+                depth = len(img.getbands())
+            objects, has_segmentation = self.parse_dm_annotations(img_ann)
+            xml_tree = self.build_pascal_xml(
+                os.path.basename(img_path), (width, height, depth), objects, has_segmentation
+            )
+            xml_filename = base + '.xml'
+            results.append((xml_tree, xml_filename, img_path, os.path.basename(img_path)))
+        return results
+
+    def convert(self) -> Any:
+        """Converts DM format to Pascal VOC format.
+
+        Returns:
+            - If categorized: dict {split: list of (xml_tree, xml_filename, img_src, img_name)}
+            - If not: list of (xml_tree, xml_filename, img_src, img_name)
+        """
+        self.class_names = set()
+        if self.is_categorized_dataset:
+            splits = self._validate_splits(['train', 'valid'], ['test'])
+            result = {}
+            for split, split_dir in splits.items():
+                result[split] = self._convert_split_dir(split_dir, split)
+            self.converted_data = result
+            return result
+        else:
+            self._validate_splits([], [])
+            result = self._convert_root_dir()
+            self.converted_data = result
+            return result
+
+    def save_to_folder(self, output_dir: Optional[str] = None):
+        """Save all Pascal VOC XML/Images to output_dir (Annotations, Images).
+        - If categorized: per split under output_dir/{split}/{Annotations, Images}
+        - If not: directly under output_dir/{Annotations, Images}
+        """
+        outdir = output_dir or self.root_dir
+        self.ensure_dir(outdir)
+        if self.converted_data is None:
+            self.converted_data = self.convert()
+
+        if self.is_categorized_dataset:
+            for split, entries in self.converted_data.items():
+                ann_dir = os.path.join(outdir, split, 'Annotations')
+                img_dir = os.path.join(outdir, split, 'Images')
+                os.makedirs(ann_dir, exist_ok=True)
+                os.makedirs(img_dir, exist_ok=True)
+                for xml_tree, xml_filename, img_src, img_name in entries:
+                    xml_tree.write(os.path.join(ann_dir, xml_filename), encoding='utf-8', xml_declaration=True)
+                    dst_path = os.path.join(img_dir, img_name)
+                    if os.path.abspath(img_src) != os.path.abspath(dst_path):
+                        shutil.copy(img_src, dst_path)
+        else:
+            ann_dir = os.path.join(outdir, 'Annotations')
+            img_dir = os.path.join(outdir, 'Images')
+            os.makedirs(ann_dir, exist_ok=True)
+            os.makedirs(img_dir, exist_ok=True)
+            for xml_tree, xml_filename, img_src, img_name in self.converted_data:
+                xml_tree.write(os.path.join(ann_dir, xml_filename), encoding='utf-8', xml_declaration=True)
+                dst_path = os.path.join(img_dir, img_name)
+                if os.path.abspath(img_src) != os.path.abspath(dst_path):
+                    shutil.copy(img_src, dst_path)
+        # Save classes.txt
+        with open(os.path.join(outdir, 'classes.txt'), 'w', encoding='utf-8') as f:
+            for c in sorted(self.class_names):
+                f.write(f'{c}\n')
+        print(f'Pascal VOC data exported to {outdir}')
+
+    def convert_single_file(self, data: Dict[str, Any], original_file: IO) -> Dict[str, Any]:
+        """Convert a single DM data dict and corresponding image file object to Pascal VOC format.
+
+        Args:
+            data: DM format data dictionary (JSON content)
+            original_file: File object for the corresponding original image
+
+        Returns:
+            Dictionary containing Pascal VOC format data for the single file
+        """
+        if not self.is_single_conversion:
+            raise RuntimeError('convert_single_file is only available when is_single_conversion=True')
+
+        # Extract image info from file object
+        with Image.open(original_file) as img:
+            width, height = img.size
+            depth = len(img.getbands())
+
+        # Get filename from original_file
+        img_filename = getattr(original_file, 'name', 'image.jpg')
+        if img_filename:
+            img_filename = os.path.basename(img_filename)
+
+        # Process annotations from the first (and only) image in data
+        if 'images' in data and len(data['images']) > 0:
+            img_ann = data['images'][0]
+            objects, has_segmentation = self.parse_dm_annotations(img_ann)
+        else:
+            objects = []
+            has_segmentation = False
+
+        # Build Pascal VOC XML
+        xml_tree = self.build_pascal_xml(img_filename, (width, height, depth), objects, has_segmentation)
+        xml_filename = os.path.splitext(img_filename)[0] + '.xml'
+
+        # Convert XML tree to string for easy viewing
+        xml_string = ET.tostring(xml_tree.getroot(), encoding='unicode', xml_declaration=True)
+
+        return {
+            'xml_tree': xml_tree,
+            'xml_content': xml_string,
+            'xml_filename': xml_filename,
+            'image_filename': img_filename,
+            'class_names': sorted(list(self.class_names)),
+        }