synapse-sdk 1.0.0a79__py3-none-any.whl → 1.0.0a81__py3-none-any.whl

synapse_sdk/shared/enums.py

@@ -7,3 +7,63 @@ class Context(str, Enum):
     WARNING = 'warning'
     DANGER = 'danger'
     ERROR = 'error'
+
+
+class SupportedTools(Enum):
+    """Enum for supported annotation tools.
+
+    * TODO: Need dynamic configuration by referencing apps/annotation/categories/{file_type}/settings.py.
+        * Currently difficult to configure due to non-standardized prompt file types.
+    """
+
+    BOUNDING_BOX = 'bounding_box', 'bounding_box'
+    NAMED_ENTITY = 'named_entity', 'named_entity'
+    CLASSIFICATION = 'classification', 'classification'
+    POLYLINE = 'polyline', 'polyline'
+    KEYPOINT = 'keypoint', 'keypoint'
+    BOUNDING_BOX_3D = '3d_bounding_box', '3d_bounding_box'
+    IMAGE_SEGMENTATION = 'segmentation', 'image_segmentation'
+    VIDEO_SEGMENTATION = 'segmentation', 'video_segmentation'
+    SEGMENTATION_3D = '3d_segmentation', '3d_segmentation'
+    POLYGON = 'polygon', 'polygon'
+    RELATION = 'relation', 'relation'
+    GROUP = 'group', 'group'
+    PROMPT = 'prompt', 'prompt'
+    ANSWER = 'answer', 'answer'
+
+    def __init__(self, annotation_tool, method_name):
+        self.annotation_tool = annotation_tool
+        self.method_name = method_name
+
+    @classmethod
+    def get_all_values(cls):
+        """Get all tool values as a list."""
+        return [tool.value for tool in cls]
+
+    @classmethod
+    def get_tools_for_file_type(cls, file_type):
+        """Get tools supported for a specific file type."""
+        basic_tools = [cls.RELATION, cls.GROUP, cls.CLASSIFICATION]
+
+        if file_type == 'image':
+            basic_tools.extend([
+                cls.BOUNDING_BOX,
+                cls.POLYLINE,
+                cls.KEYPOINT,
+                cls.IMAGE_SEGMENTATION,
+                cls.POLYGON,
+            ])
+        elif file_type == 'video':
+            basic_tools.extend([
+                cls.BOUNDING_BOX,
+                cls.POLYLINE,
+                cls.KEYPOINT,
+                cls.VIDEO_SEGMENTATION,
+                cls.POLYGON,
+            ])
+        elif file_type == 'pcd':
+            basic_tools.extend([cls.BOUNDING_BOX_3D, cls.SEGMENTATION_3D])
+        elif file_type == 'text':
+            basic_tools.extend([cls.PROMPT, cls.ANSWER, cls.NAMED_ENTITY])
+
+        return basic_tools

synapse_sdk/utils/converters/coco/from_dm.py

@@ -3,7 +3,7 @@ import json
 import os
 import shutil
 from glob import glob
-from typing import Any, Dict
+from typing import Any, Dict, IO
 
 from PIL import Image
 from tqdm import tqdm
@@ -22,14 +22,23 @@ class FromDMToCOCOConverter(FromDMConverter):
         # 'audio': ['.wav', '.mp3', ...]
     }
 
-    def __init__(self, root_dir, info_dict=None, licenses_list=None, data_type='img', is_categorized_dataset=False):
+    def __init__(
+        self,
+        root_dir=None,
+        info_dict=None,
+        licenses_list=None,
+        data_type='img',
+        is_categorized_dataset=False,
+        is_single_conversion=False,
+    ):
         """Args:
         root_dir (str): Root directory containing data.
         info_dict, licenses_list: COCO metadata.
         data_type (str): Which data type to use (default: 'img').
         is_categorized_dataset (bool): Whether to handle train, test, valid splits.
+        is_single_conversion (bool): Whether to use single file conversion mode.
         """
-        super().__init__(root_dir, is_categorized_dataset)
+        super().__init__(root_dir, is_categorized_dataset, is_single_conversion)
         self.data_type = data_type
         self.info_dict = info_dict or self._default_info()
         self.licenses_list = licenses_list or self._default_licenses()
@@ -267,3 +276,47 @@ class FromDMToCOCOConverter(FromDMConverter):
                 shutil.copy(src_path, dst_path)
             else:
                 print(f'[WARNING] Image not found: {src_path}')
+
+    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 COCO format.
+
+        Args:
+            data: DM format data dictionary (JSON content)
+            original_file: File object for the corresponding original image
+
+        Returns:
+            Dictionary containing COCO 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')
+
+        self.reset_state()
+        self.coco_dict = {
+            'info': self.info_dict,
+            'licenses': self.licenses_list,
+            'images': [],
+            'annotations': [],
+            'categories': [],
+        }
+
+        # Process the image file
+        with Image.open(original_file) as im:
+            width, height = im.size
+
+        image_info = {
+            'id': self.img_id,
+            'file_name': getattr(original_file, 'name', 'image.jpg'),
+            'width': width,
+            'height': height,
+            'license': self.license_id,
+        }
+        self.coco_dict['images'].append(image_info)
+
+        # Process annotations from the first (and only) image in data
+        if 'images' in data and len(data['images']) > 0:
+            anns = data['images'][0]
+            self._process_polylines(anns)
+            self._process_bboxes(anns)
+            self._process_keypoints(anns)
+
+        return self.coco_dict

synapse_sdk/utils/converters/coco/to_dm.py

@@ -1,5 +1,6 @@
 import json
 import os
+from typing import IO, Any, Dict
 
 from synapse_sdk.utils.converters import ToDMConverter
 
@@ -7,6 +8,9 @@ from synapse_sdk.utils.converters import ToDMConverter
 class COCOToDMConverter(ToDMConverter):
     """Convert COCO format annotations to DM (Data Manager) format."""
 
+    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)
+
     def convert(self):
         if self.is_categorized_dataset:
             splits = self._validate_splits(['train', 'valid'], ['test'])
@@ -111,3 +115,101 @@ class COCOToDMConverter(ToDMConverter):
             dm_json = {'images': [dm_img]}
             result[img_filename] = (dm_json, img_path)
         return result
+
+    def convert_single_file(self, data: Dict[str, Any], original_file: IO) -> Dict[str, Any]:
+        """Convert a single COCO annotation data and corresponding image to DM format.
+
+        Args:
+            data: COCO format data dictionary (JSON content)
+            original_file: File object for the corresponding original image
+
+        Returns:
+            Dictionary containing DM 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')
+
+        images = data.get('images', [])
+        annotations = data.get('annotations', [])
+        categories = data.get('categories', [])
+
+        if not images:
+            raise ValueError('No images found in COCO data')
+
+        # Get file name from original_file
+        img_path = getattr(original_file, 'name', None)
+        if not img_path:
+            raise ValueError('original_file must have a "name" attribute representing its path or filename.')
+        img_basename = os.path.basename(img_path)
+
+        # Find the matching image info in COCO 'images' section by comparing file name
+        # COCO image dicts might use 'file_name', 'filename', or similar
+        matched_img = None
+        for img in images:
+            for key in ['file_name', 'filename', 'name']:
+                if key in img and os.path.basename(img[key]) == img_basename:
+                    matched_img = img
+                    break
+            if matched_img:
+                break
+
+        if not matched_img:
+            raise ValueError(f'No matching image found in COCO data for file: {img_basename}')
+
+        img_id = matched_img['id']
+        print('img_id : ', img_id)
+        cat_map = {cat['id']: cat for cat in categories}
+        anns = [ann for ann in annotations if ann['image_id'] == img_id]
+
+        dm_img = {
+            'bounding_box': [],
+            'keypoint': [],
+            'relation': [],
+            'group': [],
+        }
+
+        bbox_ids = []
+        for ann in anns:
+            cat = cat_map.get(ann['category_id'], {})
+            if 'bbox' in ann and ann['bbox']:
+                bbox_id = self._generate_unique_id()
+                bbox_ids.append(bbox_id)
+                dm_img['bounding_box'].append({
+                    'id': bbox_id,
+                    'classification': cat.get('name', str(ann['category_id'])),
+                    'attrs': ann.get('attrs', []),
+                    'data': list(ann['bbox']),
+                })
+
+        for ann in anns:
+            cat = cat_map.get(ann['category_id'], {})
+            attrs = ann.get('attrs', [])
+            if 'keypoints' in ann and ann['keypoints']:
+                kp_names = cat.get('keypoints', [])
+                kps = ann['keypoints']
+                keypoint_ids = []
+                for idx in range(min(len(kps) // 3, len(kp_names))):
+                    x, y, _ = kps[idx * 3 : idx * 3 + 3]
+                    kp_id = self._generate_unique_id()
+                    keypoint_ids.append(kp_id)
+                    dm_img['keypoint'].append({
+                        'id': kp_id,
+                        'classification': kp_names[idx] if idx < len(kp_names) else f'keypoint_{idx}',
+                        'attrs': attrs,
+                        'data': [x, y],
+                    })
+                group_ids = bbox_ids + keypoint_ids
+                if group_ids:
+                    dm_img['group'].append({
+                        'id': self._generate_unique_id(),
+                        'classification': cat.get('name', str(ann['category_id'])),
+                        'attrs': attrs,
+                        'data': group_ids,
+                    })
+
+        dm_json = {'images': [dm_img]}
+        return {
+            'dm_json': dm_json,
+            'image_path': img_path,
+            'image_name': img_basename,
+        }

synapse_sdk/utils/converters/dm/__init__.py

@@ -1,95 +1,43 @@
 from abc import ABC, abstractmethod
+from enum import Enum
+
+from synapse_sdk.shared.enums import SupportedTools
 
 
 class BaseDMConverter(ABC):
     """Base class for DM format converters."""
 
-    SUPPORTED_TOOLS = [
-        'bounding_box',
-        'named_entity',
-        'classification',
-        'polyline',
-        'keypoint',
-        '3d_bounding_box',
-        'segmentation',
-        'polygon',
-        'relation',
-        'group',
-    ]
+    SUPPORTED_TOOLS = SupportedTools.get_all_values()
+
+    def __init__(self, file_type=None):
+        """Initialize the base converter.
 
-    def __init__(self):
-        """Initialize the base converter."""
+        Args:
+            file_type (str, optional): Type of file being converted (image, video, pcd, text, audio)
+        """
+        self.file_type = file_type
         self.tool_processors = self._setup_tool_processors()
 
     def _setup_tool_processors(self):
-        """Setup tool processor mapping."""
-        return {
-            'bounding_box': self._process_bounding_box,
-            'named_entity': self._process_named_entity,
-            'classification': self._process_classification,
-            'polyline': self._process_polyline,
-            'keypoint': self._process_keypoint,
-            '3d_bounding_box': self._process_3d_bounding_box,
-            'segmentation': self._process_segmentation,
-            'polygon': self._process_polygon,
-            'relation': self._process_relation,
-            'group': self._process_group,
-        }
-
-    @abstractmethod
-    def convert(self):
-        """Convert data from one format to another."""
-        pass
-
-    @abstractmethod
-    def _process_bounding_box(self, *args, **kwargs):
-        """Process bounding box annotation."""
-        pass
-
-    @abstractmethod
-    def _process_named_entity(self, *args, **kwargs):
-        """Process named entity annotation."""
-        pass
-
-    @abstractmethod
-    def _process_classification(self, *args, **kwargs):
-        """Process classification annotation."""
-        pass
+        """Setup tool processor mapping dynamically based on file_type."""
+        if not self.file_type:
+            return {}
 
-    @abstractmethod
-    def _process_polyline(self, *args, **kwargs):
-        """Process polyline annotation."""
-        pass
+        processors = {}
+        tools = SupportedTools.get_tools_for_file_type(self.file_type)
 
-    @abstractmethod
-    def _process_keypoint(self, *args, **kwargs):
-        """Process keypoint annotation."""
-        pass
+        for tool in tools:
+            # For other tools, use generic method names
+            method_name = f'_convert_{tool.method_name}'
 
-    @abstractmethod
-    def _process_3d_bounding_box(self, *args, **kwargs):
-        """Process 3D bounding box annotation."""
-        pass
+            if hasattr(self, method_name):
+                processors[tool.annotation_tool] = getattr(self, method_name)
 
-    @abstractmethod
-    def _process_segmentation(self, *args, **kwargs):
-        """Process segmentation annotation."""
-        pass
+        return processors
 
     @abstractmethod
-    def _process_polygon(self, *args, **kwargs):
-        """Process polygon annotation."""
-        pass
-
-    @abstractmethod
-    def _process_relation(self, *args, **kwargs):
-        """Process relation annotation."""
-        pass
-
-    @abstractmethod
-    def _process_group(self, *args, **kwargs):
-        """Process group annotation."""
-        pass
+    def convert(self):
+        """Convert data from one format to another."""
 
     def _handle_unknown_tool(self, tool_type, item_id=None):
         """Handle unknown tool types with consistent warning message."""