supervisely 6.73.438__py3-none-any.whl → 6.73.513__py3-none-any.whl

supervisely/convert/video/sly/sly_video_converter.py

@@ -1,20 +1,29 @@
 import os
-from typing import List
+from typing import Dict, List, Optional
 
 import supervisely.convert.video.sly.sly_video_helper as sly_video_helper
-from supervisely import KeyIdMap, ProjectMeta, VideoAnnotation, logger
+from supervisely import ProjectMeta, VideoAnnotation, logger
+from supervisely.api.api import Api, ApiContext
 from supervisely.convert.base_converter import AvailableVideoConverters
 from supervisely.convert.video.video_converter import VideoConverter
-from supervisely.io.fs import JUNK_FILES, get_file_ext
+from supervisely.io.fs import JUNK_FILES, file_exists, get_file_ext
 from supervisely.io.json import load_json_file
+from supervisely.project.project import OpenMode, find_project_dirs
+from supervisely.project.project_settings import LabelingInterface
+from supervisely.project.video_project import VideoProject
 from supervisely.video.video import validate_ext as validate_video_ext
 
+DATASET_ITEMS = "items"
+NESTED_DATASETS = "datasets"
+
 
 class SLYVideoConverter(VideoConverter):
 
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
         self._supports_links = True
+        self._project_structure = None
+        self._multi_view_setting_enabled = False
 
     def __str__(self) -> str:
         return AvailableVideoConverters.SLY
@@ -48,9 +57,34 @@ class SLYVideoConverter(VideoConverter):
         except Exception:
             return False
 
+    @staticmethod
+    def _create_project_node() -> Dict[str, dict]:
+        return {DATASET_ITEMS: [], NESTED_DATASETS: {}}
+
+    @classmethod
+    def _append_to_project_structure(
+        cls, project_structure: Dict[str, dict], dataset_name: str, items: List
+    ):
+        normalized_name = (dataset_name or "").replace("\\", "/").strip("/")
+        if not normalized_name:
+            normalized_name = dataset_name or "dataset"
+        parts = [part for part in normalized_name.split("/") if part]
+        if not parts:
+            parts = ["dataset"]
+
+        curr_ds = project_structure.setdefault(parts[0], cls._create_project_node())
+        for part in parts[1:]:
+            curr_ds = curr_ds[NESTED_DATASETS].setdefault(part, cls._create_project_node())
+        curr_ds[DATASET_ITEMS].extend(items)
+
     def validate_format(self) -> bool:
         if self.upload_as_links and self._supports_links:
             self._download_remote_ann_files()
+        if self.read_project_structure(self._input_data):
+            return True
+
+        if self.read_dataset_structure(self._input_data):
+            return True
         detected_ann_cnt = 0
         videos_list, ann_dict = [], {}
         for root, _, files in os.walk(self._input_data):
@@ -123,3 +157,325 @@ class SLYVideoConverter(VideoConverter):
         except Exception as e:
             logger.warning(f"Failed to convert annotation: {repr(e)}")
             return item.create_empty_annotation()
+
+    def read_project_structure(self, input_data: str) -> bool:
+        """Read video project with multiple datasets."""
+        try:
+            self._items = []
+            project = {}
+            ds_cnt = 0
+            self._meta = None
+
+            logger.debug("Trying to find Supervisely video project format in the input data")
+            project_dirs = [d for d in find_project_dirs(input_data, project_class=VideoProject)]
+            if len(project_dirs) > 1:
+                logger.info("Found multiple possible Supervisely video projects in the input data")
+            elif len(project_dirs) == 1:
+                logger.info("Possible Supervisely video project found in the input data")
+            else:
+                return False
+
+            meta = None
+            for project_dir in project_dirs:
+                project_fs = VideoProject(project_dir, mode=OpenMode.READ)
+                if meta is None:
+                    meta = project_fs.meta
+                else:
+                    meta = meta.merge(project_fs.meta)
+
+                for dataset in project_fs.datasets:
+                    ds_items = []
+                    for name in dataset.get_items_names():
+                        video_path, ann_path = dataset.get_item_paths(name)
+                        item = self.Item(video_path)
+                        if file_exists(ann_path):
+                            if self.validate_ann_file(ann_path, meta):
+                                item.ann_data = ann_path
+                        ds_items.append(item)
+
+                    if len(ds_items) > 0:
+                        self._append_to_project_structure(project, dataset.name, ds_items)
+                        ds_cnt += 1
+                        self._items.extend(ds_items)
+
+            if self.items_count > 0:
+                self._meta = meta
+                meta: ProjectMeta
+                if meta.labeling_interface == LabelingInterface.MULTIVIEW:
+                    self._multi_view_setting_enabled = True
+                if ds_cnt > 1:
+                    self._project_structure = project
+                return True
+            else:
+                return False
+        except Exception as e:
+            logger.debug(f"Not a video project: {repr(e)}")
+            return False
+
+    def read_dataset_structure(self, input_data: str) -> bool:
+        """Read video datasets without project meta.json."""
+        try:
+            from supervisely import VideoDataset
+            from supervisely.io.fs import dirs_filter
+
+            self._items = []
+            project = {}
+            ds_cnt = 0
+            self._meta = None
+            logger.debug("Trying to read Supervisely video datasets")
+
+            def _check_function(path):
+                try:
+                    dataset_ds = VideoDataset(path, OpenMode.READ)
+                    return len(dataset_ds.get_items_names()) > 0
+                except Exception:
+                    return False
+
+            meta = ProjectMeta()
+            dataset_dirs = [d for d in dirs_filter(input_data, _check_function)]
+            for dataset_dir in dataset_dirs:
+                dataset_fs = VideoDataset(dataset_dir, OpenMode.READ)
+                ds_items = []
+                for name in dataset_fs.get_items_names():
+                    video_path, ann_path = dataset_fs.get_item_paths(name)
+                    item = self.Item(video_path)
+                    if file_exists(ann_path):
+                        meta = self.generate_meta_from_annotation(ann_path, meta)
+                        if self.validate_ann_file(ann_path, meta):
+                            item.ann_data = ann_path
+                    ds_items.append(item)
+
+                if len(ds_items) > 0:
+                    self._append_to_project_structure(project, dataset_fs.name, ds_items)
+                    ds_cnt += 1
+                    self._items.extend(ds_items)
+
+            if self.items_count > 0:
+                self._meta = meta
+                if ds_cnt > 1:  # multiple datasets
+                    self._project_structure = project
+                return True
+            else:
+                return False
+        except Exception as e:
+            logger.debug(f"Failed to read Supervisely video datasets: {repr(e)}")
+            return False
+
+    def upload_dataset(
+        self, api: Api, dataset_id: int, batch_size: int = 10, log_progress=True
+    ) -> Optional[int]:
+        """Upload converted data to Supervisely."""
+        if self._project_structure:
+            return self._upload_project(api, dataset_id, batch_size, log_progress)
+        else:
+            self._upload_single_dataset(api, dataset_id, self._items, batch_size, log_progress)
+
+    def _upload_project(
+        self, api: Api, dataset_id: int, batch_size: int = 10, log_progress=True
+    ) -> Optional[int]:
+        """Upload video project with multiple datasets."""
+        from supervisely import generate_free_name, is_development
+
+        dataset_info = api.dataset.get_info_by_id(dataset_id, raise_error=True)
+        project_id = dataset_info.project_id
+        new_project_created = False
+
+        if self._multi_view_setting_enabled:
+            src_meta_json = api.project.get_meta(project_id, with_settings=True)
+            src_meta = ProjectMeta.from_json(src_meta_json)
+
+            if src_meta.labeling_interface == LabelingInterface.DEFAULT:
+                project_id, dataset_id = self._handle_multi_view_labeling_interface(
+                    api, project_id, dataset_info
+                )
+                new_project_created = True
+
+        existing_datasets = api.dataset.get_list(project_id, recursive=True)
+        existing_datasets = {ds.name for ds in existing_datasets}
+
+        if log_progress:
+            progress, progress_cb = self.get_progress(self.items_count, "Uploading project")
+        else:
+            progress, progress_cb = None, None
+
+        logger.info("Uploading video project structure")
+
+        def _upload_datasets_recursive(
+            project_structure: dict,
+            project_id: int,
+            dataset_id: int,
+            parent_id=None,
+            first_dataset=False,
+        ):
+            for ds_name, value in project_structure.items():
+                ds_name = generate_free_name(existing_datasets, ds_name, extend_used_names=True)
+                if first_dataset:
+                    first_dataset = False
+                    api.dataset.update(dataset_id, ds_name)  # rename first dataset
+                else:
+                    dataset_id = api.dataset.create(project_id, ds_name, parent_id=parent_id).id
+
+                items = value.get(DATASET_ITEMS, [])
+                nested_datasets = value.get(NESTED_DATASETS, {})
+                logger.info(
+                    f"Dataset: {ds_name}, items: {len(items)}, nested datasets: {len(nested_datasets)}"
+                )
+                if items:
+                    self._upload_single_dataset(
+                        api,
+                        dataset_id,
+                        items,
+                        batch_size,
+                        log_progress=False,
+                        progress_cb=progress_cb,
+                    )
+
+                if nested_datasets:
+                    _upload_datasets_recursive(nested_datasets, project_id, dataset_id, dataset_id)
+
+        _upload_datasets_recursive(
+            self._project_structure, project_id, dataset_id, first_dataset=True
+        )
+
+        if is_development() and progress is not None:
+            progress.close()
+
+        if new_project_created:
+            logger.info(
+                "Data was uploaded to a new project with 'Multi-View' labeling interface setting."
+            )
+            return dataset_id
+
+    def _upload_single_dataset(
+        self,
+        api: Api,
+        dataset_id: int,
+        items: List,
+        batch_size: int = 10,
+        log_progress=True,
+        progress_cb=None,
+    ):
+        """Upload videos from a single dataset."""
+        from supervisely import batched, generate_free_name, is_development
+        from supervisely.io.fs import get_file_size
+
+        meta, renamed_classes, renamed_tags = self.merge_metas_with_conflicts(api, dataset_id)
+        videos_in_dataset = api.video.get_list(dataset_id, force_metadata_for_links=False)
+        existing_names = {video_info.name for video_info in videos_in_dataset}
+        items_count = len(items)
+        convert_progress, convert_progress_cb = self.get_progress(
+            items_count, "Preparing videos..."
+        )
+        for item in items:
+            item_name, item_path = self.convert_to_mp4_if_needed(item.path)
+            item.name = item_name
+            item.path = item_path
+            convert_progress_cb(1)
+        if is_development():
+            convert_progress.close()
+
+        has_large_files = False
+        size_progress_cb = None
+        _progress_cb, progress, ann_progress, ann_progress_cb = None, None, None, None
+        if log_progress:
+            if progress_cb is None:
+                progress, _progress_cb = self.get_progress(items_count, "Uploading videos...")
+            else:
+                _progress_cb = progress_cb
+            if not self.upload_as_links:
+                file_sizes = [get_file_size(item.path) for item in items]
+                has_large_files = any(
+                    [self._check_video_file_size(file_size) for file_size in file_sizes]
+                )
+                if has_large_files:
+                    upload_progress = []
+                    size_progress_cb = self._get_video_upload_progress(upload_progress)
+
+        with ApiContext(api=api, project_meta=meta):
+            batch_size = 1 if has_large_files and not self.upload_as_links else batch_size
+            for batch in batched(items, batch_size=batch_size):
+                item_names = []
+                item_paths = []
+                anns = []
+                figures_cnt = 0
+                for item in batch:
+                    item.name = generate_free_name(
+                        existing_names, item.name, with_ext=True, extend_used_names=True
+                    )
+                    item_paths.append(item.path)
+                    item_names.append(item.name)
+
+                    ann = None
+                    if not self.upload_as_links or self.supports_links:
+                        ann = self.to_supervisely(item, meta, renamed_classes, renamed_tags)
+                        if ann is not None:
+                            figures_cnt += len(ann.figures)
+                    anns.append(ann)
+
+                if self.upload_as_links:
+                    vid_infos = api.video.upload_links(
+                        dataset_id,
+                        item_paths,
+                        item_names,
+                        skip_download=True,
+                        progress_cb=_progress_cb if log_progress else None,
+                        force_metadata_for_links=False,
+                    )
+                else:
+                    vid_infos = api.video.upload_paths(
+                        dataset_id,
+                        item_names,
+                        item_paths,
+                        progress_cb=_progress_cb if log_progress else None,
+                        item_progress=(
+                            size_progress_cb if log_progress and has_large_files else None
+                        ),
+                    )
+
+                vid_ids = [vid_info.id for vid_info in vid_infos]
+                if log_progress and has_large_files and figures_cnt > 0:
+                    ann_progress, ann_progress_cb = self.get_progress(
+                        figures_cnt, "Uploading annotations..."
+                    )
+
+                if meta.labeling_interface == LabelingInterface.MULTIVIEW:
+                    for idx, (ann, info) in enumerate(zip(anns, vid_infos)):
+                        if ann is None:
+                            anns[idx] = VideoAnnotation(
+                                (info.frame_height, info.frame_width), info.frames_count
+                            )
+                    api.video.annotation.upload_anns_multiview(vid_ids, anns, ann_progress_cb)
+                else:
+                    for vid, ann, info in zip(vid_ids, anns, vid_infos):
+                        if ann is None:
+                            ann = VideoAnnotation(
+                                (info.frame_height, info.frame_width), info.frames_count
+                            )
+                        api.video.annotation.append(vid, ann, progress_cb=ann_progress_cb)
+
+        if log_progress and is_development():
+            if progress is not None:
+                progress.close()
+            if ann_progress is not None:
+                ann_progress.close()
+        logger.info(f"Dataset ID:{dataset_id} has been successfully uploaded.")
+
+    def _handle_multi_view_labeling_interface(self, api: Api, project_id: int, dataset_info):
+        project_info = api.project.get_info_by_id(project_id)
+        if project_info.items_count == 0:
+            return project_id, dataset_info.id
+        logger.warning(
+            "The uploaded project has 'Multi-View' labeling interface setting enabled, "
+            "but the target project has 'Default' labeling interface. "
+        )
+        logger.warning("New project with 'Multi-View' labeling interface will be created.")
+        new_project = api.project.create(
+            workspace_id=project_info.workspace_id,
+            name=f"{project_info.name}_multi_view",
+            type=project_info.type,
+            change_name_if_conflict=True,
+        )
+        new_dataset = api.dataset.create(
+            new_project.id, dataset_info.name, change_name_if_conflict=True
+        )
+        return new_project.id, new_dataset.id

supervisely/convert/video/video_converter.py

@@ -40,10 +40,12 @@ class VideoConverter(BaseConverter):
             shape=None,
             custom_data=None,
             frame_count=None,
+            metadata=None,
         ):
             self._path = item_path
             self._name: str = None
             self._ann_data = ann_data
+            self._metadata = metadata
             self._type = "video"
             if shape is None:
                 vcap = cv2.VideoCapture(item_path)
@@ -83,6 +85,14 @@ class VideoConverter(BaseConverter):
         def name(self, name: str):
             self._name = name
 
+        @property
+        def metadata(self) -> Optional[str]:
+            return self._metadata
+
+        @metadata.setter
+        def metadata(self, metadata: Optional[str]):
+            self._metadata = metadata
+
         def create_empty_annotation(self) -> VideoAnnotation:
             return VideoAnnotation(self._shape, self._frame_count)
 
@@ -120,9 +130,7 @@ class VideoConverter(BaseConverter):
         log_progress=True,
     ):
         """Upload converted data to Supervisely"""
-
         meta, renamed_classes, renamed_tags = self.merge_metas_with_conflicts(api, dataset_id)
-
         videos_in_dataset = api.video.get_list(dataset_id, force_metadata_for_links=False)
         existing_names = {video_info.name for video_info in videos_in_dataset}
 
@@ -156,6 +164,7 @@ class VideoConverter(BaseConverter):
         for batch in batched(self._items, batch_size=batch_size):
             item_names = []
             item_paths = []
+            item_metas = []
             anns = []
             figures_cnt = 0
             for item in batch:
@@ -165,6 +174,15 @@ class VideoConverter(BaseConverter):
                 item_paths.append(item.path)
                 item_names.append(item.name)
 
+                if isinstance(item.metadata, str):  # path to file
+                    from supervisely.io.json import load_json_file
+
+                    item_metas.append(load_json_file(item.metadata))
+                elif isinstance(item.metadata, dict):
+                    item_metas.append(item.metadata)
+                else:
+                    item_metas.append({})
+
                 ann = None
                 if not self.upload_as_links or self.supports_links:
                     ann = self.to_supervisely(item, meta, renamed_classes, renamed_tags)
@@ -177,6 +195,7 @@ class VideoConverter(BaseConverter):
                     dataset_id,
                     item_paths,
                     item_names,
+                    metas=item_metas,
                     skip_download=True,
                     progress_cb=progress_cb if log_progress else None,
                     force_metadata_for_links=False,
@@ -188,6 +207,7 @@ class VideoConverter(BaseConverter):
                     item_paths,
                     progress_cb=progress_cb if log_progress else None,
                     item_progress=(size_progress_cb if log_progress and has_large_files else None),
+                    metas=item_metas,
                 )
             vid_ids = [vid_info.id for vid_info in vid_infos]
 
@@ -266,8 +286,8 @@ class VideoConverter(BaseConverter):
             if codec_type not in ["video", "audio"]:
                 continue
             codec_name = stream["codecName"]
-            if codec_type == "video" and codec_name != "h264":
-                logger.info(f"Video codec is not h264, transcoding is required: {codec_name}")
+            if codec_type == "video" and codec_name not in ["h264", "h265", "hevc", "av1"]:
+                logger.info(f"Video codec is not h264/h265/hevc/av1, transcoding is required: {codec_name}")
                 need_video_transc = True
             elif codec_type == "audio" and codec_name != "aac":
                 logger.info(f"Audio codec is not aac, transcoding is required: {codec_name}")

supervisely/convert/volume/dicom/dicom_converter.py

@@ -1,15 +1,21 @@
 from typing import List
 
+from supervisely import ProjectMeta, generate_free_name, logger
 from supervisely.api.api import Api
-from supervisely import generate_free_name, logger, ProjectMeta
 from supervisely.convert.base_converter import AvailableVolumeConverters
-from supervisely.convert.volume.volume_converter import VolumeConverter
 from supervisely.convert.volume.dicom import dicom_helper as h
-from supervisely.volume.volume import inspect_dicom_series, get_extension, read_dicom_serie_volume
+from supervisely.convert.volume.volume_converter import VolumeConverter
+from supervisely.volume.volume import (
+    get_extension,
+    inspect_dicom_series,
+    read_dicom_serie_volume,
+)
+
 
 class DICOMConverter(VolumeConverter):
     class Item(VolumeConverter.Item):
         """Item class for DICOM series."""
+
         def __init__(self, serie_id: str, item_paths: List[str], volume_meta: dict):
             item_path = item_paths[0] if len(item_paths) > 0 else None
             super().__init__(item_path, volume_meta=volume_meta)
@@ -62,9 +68,11 @@ class DICOMConverter(VolumeConverter):
                 continue
 
             for dicom_path in dicom_paths:
-                h.convert_to_monochrome2(dicom_path)
+                h.read_and_convert_to_monochrome2(dicom_path)
             _, meta = read_dicom_serie_volume(dicom_paths, anonymize=True)
-            item = self.Item(serie_id=dicom_id, item_paths=dicom_paths, volume_meta=meta)
+            item = self.Item(
+                serie_id=dicom_id, item_paths=dicom_paths, volume_meta=meta
+            )
             self._items.append(item)
         self._meta = ProjectMeta()
 

supervisely/convert/volume/dicom/dicom_helper.py

@@ -3,7 +3,7 @@ from typing import List
 
 import nrrd
 import numpy as np
-
+from pydicom import FileDataset
 from supervisely import logger
 from supervisely.io.fs import file_exists
 from supervisely.volume.volume import read_dicom_serie_volume_np
@@ -38,31 +38,43 @@ def dcm_to_nrrd(id: str, paths: List[str]) -> str:
 
     return nrrd_path, volume_meta
 
-def convert_to_monochrome2(dcm_path: str):
-    import pydicom
 
-    is_modified = False
+def read_and_convert_to_monochrome2(dcm_path: str):
+    import pydicom
 
     try:
         dcm = pydicom.dcmread(dcm_path)
     except Exception as e:
-        logger.warn("Failed to read DICOM file: " + str(e))
+        logger.warning("Failed to read DICOM file: " + str(e))
         return
 
     try:
         if dcm.file_meta.TransferSyntaxUID.is_compressed:
             dcm.decompress()
-            is_modified = True
     except Exception as e:
-        logger.warn("Failed to decompress DICOM file: " + str(e))
+        logger.warning("Failed to decompress DICOM file: " + str(e))
         return
 
+    convert_to_monochrome2(dcm_path, dcm)
+
+
+def convert_to_monochrome2(dcm_path: str, dcm: FileDataset) -> FileDataset:
     if getattr(dcm, "PhotometricInterpretation", None) == "YBR_FULL_422":
         # * Convert dicom to monochrome
-        if len(dcm.pixel_array.shape) == 4 and dcm.pixel_array.shape[-1] == 3:
-            monochrome = dcm.pixel_array[..., 0].astype(np.uint8)
+        monochrome = None
+        pixel_array = dcm.pixel_array
+
+        if len(pixel_array.shape) == 4 and pixel_array.shape[-1] == 3:
+            monochrome = pixel_array[..., 0].astype(np.uint8)
+        elif len(pixel_array.shape) == 3 and pixel_array.shape[-1] == 3:
+            monochrome = pixel_array[..., 0].astype(np.uint8)
         else:
-            logger.warn("Unexpected shape for YBR_FULL_422 data: " + str(dcm.pixel_array.shape))
+            logger.warning(
+                "Unexpected shape for YBR_FULL_422 data: " + str(pixel_array.shape)
+            )
+            return dcm
+
+        logger.debug("Monochrome shape: " + str(monochrome.shape))
 
         try:
             dcm.SamplesPerPixel = 1
@@ -71,15 +83,15 @@ def convert_to_monochrome2(dcm_path: str):
             if len(monochrome.shape) == 3:
                 dcm.NumberOfFrames = str(monochrome.shape[0])
                 dcm.Rows, dcm.Columns = monochrome.shape[1:3]
+            elif len(monochrome.shape) == 2:
+                dcm.Rows, dcm.Columns = monochrome.shape[0:2]
+                if hasattr(dcm, "NumberOfFrames"):
+                    delattr(dcm, "NumberOfFrames")
             dcm.PixelData = monochrome.tobytes()
         except AttributeError as ae:
             logger.error(f"Error occurred while converting dicom to monochrome: {ae}")
+            return dcm
 
-        logger.info("Rewriting DICOM file with MONOCHROME2 photometric interpretation.")
-        is_modified = True
-
-    try:
-        if is_modified:
-            dcm.save_as(dcm_path)
-    except Exception as e:
-        logger.warn("Failed to save DICOM file: " + str(e))
+        logger.info("Rewriting DICOM file with monochrome2 format")
+        dcm.save_as(dcm_path)
+    return dcm

supervisely/geometry/constants.py

@@ -15,6 +15,7 @@ SPACE_ORIGIN = "space_origin"
 SPACE = "space"
 SPACE_DIRECTIONS = "space_directions"
 POINTS = "points"
+ANGLE = "angle"
 ROWS = "rows"
 TYPE = "type"
 GEOMETRY_SHAPE = "shape"

supervisely/geometry/geometry.py

@@ -272,6 +272,7 @@ class Geometry(JsonSerializable):
         )
         from supervisely.geometry.polygon import Polygon
         from supervisely.geometry.rectangle import Rectangle
+        from supervisely.geometry.oriented_bbox import OrientedBBox
 
         res = []
         if new_geometry == Bitmap:
@@ -282,6 +283,9 @@ class Geometry(JsonSerializable):
             res = [self.to_bbox()]
         elif new_geometry == Polygon:
             res = geometry_to_polygon(self, approx_epsilon=approx_epsilon)
+        elif new_geometry == OrientedBBox:
+            bbox = self.to_bbox()
+            res = [OrientedBBox.from_bbox(bbox)]
 
         if len(res) == 0:
             logger.warn(

supervisely/geometry/helpers.py

@@ -13,6 +13,7 @@ from supervisely.geometry.point_location import PointLocation
 from supervisely.geometry.polygon import Polygon
 from supervisely.geometry.polyline import Polyline
 from supervisely.geometry.rectangle import Rectangle
+from supervisely.geometry.oriented_bbox import OrientedBBox
 
 
 def _geometry_to_mask_base(
@@ -122,7 +123,7 @@ def deserialize_geometry(geometry_type_str: str, geometry_json: Dict) -> Geometr
 
 
 def geometry_to_polygon(geometry: Geometry, approx_epsilon: Optional[int] = None) -> List[Geometry]:
-    if type(geometry) not in (Rectangle, Polyline, Polygon, Bitmap, AlphaMask):
+    if type(geometry) not in (Rectangle, Polyline, Polygon, Bitmap, AlphaMask, OrientedBBox):
         raise KeyError(
             "Can not convert {} to {}".format(geometry.geometry_name(), Polygon.__name__)
         )
@@ -135,6 +136,9 @@ def geometry_to_polygon(geometry: Geometry, approx_epsilon: Optional[int] = None
 
     if type(geometry) == Polygon:
         return [geometry]
+    
+    if type(geometry) == OrientedBBox:
+        return [Polygon(geometry.calculate_rotated_corners(), [])]
 
     if type(geometry) in [AlphaMask, Bitmap]:
         new_geometries = geometry.to_contours()