nxtomomill 2.1.0.dev3__tar.gz → 2.1.0.dev4__tar.gz

{nxtomomill-2.1.0.dev3/nxtomomill.egg-info → nxtomomill-2.1.0.dev4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nxtomomill
-Version: 2.1.0.dev3
+Version: 2.1.0.dev4
 Summary: applications and library to convert raw format to NXtomo format
 Author-email: Henri Payno <henri.payno@esrf.fr>, Pierre Paleo <pierre.paleo@esrf.fr>, Pierre-Olivier Autran <pierre-olivier.autran@esrf.fr>, Jérôme Lesaint <jerome.lesaint@esrf.fr>, Alessandro Mirone <mirone@esrf.fr>
 License: 
@@ -55,7 +55,7 @@ License-File: LICENSE
 Requires-Dist: numpy
 Requires-Dist: h5py>=3.0
 Requires-Dist: silx>=2.0
-Requires-Dist: nxtomo>=3.1.0dev0
+Requires-Dist: nxtomo>=3.1.0dev1
 Requires-Dist: pint
 Requires-Dist: packaging
 Requires-Dist: tomoscan[full]>=2.2.0a4

{nxtomomill-2.1.0.dev3 → nxtomomill-2.1.0.dev4}/nxtomomill/app/dxfile2nx.py

@@ -103,9 +103,16 @@ def main(argv):
         "--fov",
         "--field-of-view",
         default=None,
-        help="field of view. Can be Full or Half",
+        help="DEPRECATED: field of view as string. Use --half-acquisition instead.",
         dest="field_of_view",
     )
+    parser.add_argument(
+        "--half-acquisition",
+        help="Use half acquisition instead of full acquisition.",
+        action="store_true",
+        dest="half_acquisition",
+        default=None,
+    )
     # as distance is not stored in the dxfile and requested for paganin
     # we provide some default value
     parser.add_argument(
@@ -139,6 +146,12 @@ def main(argv):
     )
     options = parser.parse_args(argv[1:])
 
+    if options.field_of_view is not None and options.half_acquisition is not None:
+        raise ValueError(
+            "Cannot use --field-of-view and --half-acquisition together. "
+            "Please use --half-acquisition."
+        )
+
     distance = options.distance
     if distance is not None:
         distance = float(options.distance)
@@ -163,6 +176,7 @@ def main(argv):
         scan_range=convert_2elmts__tuple_to_float(options.scan_range),
         pixel_size=_get_pixel_size(options.pixel_size),
         field_of_view=options.field_of_view,
+        half_acquisition=options.half_acquisition,
         distance=distance,
         overwrite=options.overwrite,
         duplicate_data=options.duplicate_data,

{nxtomomill-2.1.0.dev3 → nxtomomill-2.1.0.dev4}/nxtomomill/app/h52nx.py

@@ -125,6 +125,11 @@ def main(argv):
         "parse raw data to find this information.",
         default=None,
     )
+    parser.add_argument(
+        "--half-acquisition",
+        help="If the scan is an half-acquisition (CoR at the borders of projections).",
+        default=None,
+    )
     parser.add_argument(
         "--no-input",
         "--no-input-for-missing-information",

{nxtomomill-2.1.0.dev3 → nxtomomill-2.1.0.dev4}/nxtomomill/converter/dxfile/dxfileconverter.py

@@ -49,6 +49,7 @@ def from_dx_to_nx(
     scan_range: tuple = (0.0, 180.0),
     pixel_size=(None, None),
     field_of_view: FieldOfView | str | None = None,
+    half_acquisition: bool | None = None,
     distance: float | None = None,
     overwrite: bool = True,
     energy: float | None = None,
@@ -84,6 +85,7 @@ def from_dx_to_nx(
     configuration.scan_range = scan_range
     configuration.pixel_size = pixel_size
     configuration.field_of_view = field_of_view
+    configuration.half_acquisition = half_acquisition
     configuration.sample_detector_distance = distance
     configuration.overwrite = overwrite
     configuration.energy = energy
@@ -200,6 +202,10 @@ class _DxFileToNxConverter(BaseConverter):
     def field_of_view(self) -> FieldOfView | None:
         return self._configuration.field_of_view
 
+    @property
+    def half_acquisition(self) -> bool | None:
+        return self._configuration.half_acquisition
+
     @property
     def energy(self) -> float | None:
         return self._configuration.energy
@@ -281,12 +287,15 @@ class _DxFileToNxConverter(BaseConverter):
             detector_grp["y_pixel_size"] = y_pixel_size
             detector_grp["y_pixel_size"].attrs["units"] = "m"
         #  field of view
-        if self.field_of_view is not None:
+        if self.field_of_view is not None or self.half_acquisition is not None:
             with HDF5File(self.output_file, mode="a") as h5f:
                 root_grp = h5f.require_group(self.output_entry)
                 instrument_grp = root_grp.require_group("instrument")
                 detector_grp = instrument_grp.require_group("detector")
-                detector_grp["field_of_view"] = self.field_of_view.value
+                if self.field_of_view is not None:
+                    detector_grp["field_of_view"] = self.field_of_view.value
+                if self.half_acquisition is not None:
+                    detector_grp["half_acquisition"] = self.half_acquisition
         #  distance
         if self._configuration.sample_detector_distance is None:
             # if value not set by the user let read it

{nxtomomill-2.1.0.dev3 → nxtomomill-2.1.0.dev4}/nxtomomill/converter/dxfile/tests/test_dxfile.py

@@ -1,16 +1,18 @@
 # coding: utf-8
 
 import os
+import h5py
 import pytest
 import numpy
 
-from nxtomomill import converter
+from nxtomomill.converter.dxfile.dxfileconverter import from_dx_config_to_nx
+from nxtomomill.models.dx2nx import DX2nxModel
 from nxtomomill.tests.utils.dxfile import MockDxFile
 
 from tomoscan.esrf.scan.nxtomoscan import NXtomoScan
 from tomoscan.validator import is_valid_for_reconstruction
 
-from silx.io.utils import get_data
+from silx.io.utils import get_data, h5py_read_dataset
 
 
 @pytest.mark.parametrize("duplicate_data", (True, False))
@@ -32,11 +34,13 @@ def test_dx_file_conversion(tmp_path, duplicate_data):
 
     output_file = os.path.join(folder, "dxfile.nx")
 
-    results = converter.from_dx_to_nx(
+    config = DX2nxModel(
         input_file=dxfile_path,
         output_file=output_file,
         duplicate_data=duplicate_data,
     )
+
+    results = from_dx_config_to_nx(config)
     assert len(results) == 1
     assert os.path.exists(output_file)
     _, entry = results[0]
@@ -62,17 +66,58 @@ def test_dx_file_conversion(tmp_path, duplicate_data):
 
     # if overwrite not requested should fail on reprocessing
     with pytest.raises(OSError):
-        converter.from_dx_to_nx(
+        from_dx_config_to_nx(
+            DX2nxModel(
+                input_file=dxfile_path,
+                output_file=output_file,
+                duplicate_data=duplicate_data,
+                overwrite=False,
+            )
+        )
+
+    # if overwrite requested should succeed
+    from_dx_config_to_nx(
+        DX2nxModel(
             input_file=dxfile_path,
             output_file=output_file,
             duplicate_data=duplicate_data,
-            overwrite=False,
+            overwrite=True,
         )
+    )
 
-    # if overwrite requested should succeed
-    converter.from_dx_to_nx(
-        input_file=dxfile_path,
-        output_file=output_file,
-        overwrite=True,
-        duplicate_data=duplicate_data,
+
+def test_dx_file_conversion_half_acquisition(tmp_path):
+    folder = tmp_path / "test_dx_file_conversion_half_acquisition"
+    folder.mkdir()
+    dxfile_path = os.path.join(folder, "dxfile.h5")
+
+    n_projections = 10
+    n_darks = 1
+    n_flats = 1
+    MockDxFile(
+        file_path=dxfile_path,
+        n_projection=n_projections,
+        n_darks=n_darks,
+        n_flats=n_flats,
     )
+
+    output_file = os.path.join(folder, "dxfile_half.nx")
+
+    results = from_dx_config_to_nx(
+        DX2nxModel(
+            input_file=dxfile_path,
+            output_file=output_file,
+            half_acquisition=True,
+        )
+    )
+    assert len(results) == 1
+    assert os.path.exists(output_file)
+
+    with h5py.File(output_file, "r") as h5f:
+        assert h5py_read_dataset(
+            h5f["entry0000/instrument/detector/half_acquisition"]
+        ) is numpy.bool(True)
+        assert (
+            h5py_read_dataset(h5f["entry0000/instrument/detector/field_of_view"])
+            == "Half"
+        )

{nxtomomill-2.1.0.dev3 → nxtomomill-2.1.0.dev4}/nxtomomill/converter/edf/edfconverter.py

@@ -1000,16 +1000,24 @@ def __process(
         output_grp["/entry/instrument"].attrs["NX_class"] = "NXinstrument"
         output_grp["/entry/instrument/detector"].attrs["NX_class"] = "NXdetector"
         output_grp["/entry/instrument/detector/data"].attrs["interpretation"] = "image"
-        if configuration.field_of_view is not None:
+        if configuration.half_acquisition is not None:
+            half_acquisition = configuration.half_acquisition
+            field_of_view = "Half" if half_acquisition else "Full"
+        elif configuration.field_of_view is not None:
             field_of_view = configuration.field_of_view
+            half_acquisition = field_of_view is FieldOfView.HALF
         elif abs(scan.scan_range) == 180:
             field_of_view = "Full"
+            half_acquisition = False
         elif abs(scan.scan_range) == 360:
             field_of_view = "Half"
+            half_acquisition = True
 
         if field_of_view is not None:
             field_of_view = FieldOfView(field_of_view)
             output_grp["/entry/instrument/detector/field_of_view"] = field_of_view.value
+        if half_acquisition is not None:
+            output_grp["/entry/instrument/detector/half_acquisition"] = half_acquisition
 
         output_grp["/entry/sample"].attrs["NX_class"] = "NXsample"
         output_grp["/entry/definition"] = "NXtomo"

{nxtomomill-2.1.0.dev3 → nxtomomill-2.1.0.dev4}/nxtomomill/converter/fscan/fscanconverter.py

@@ -125,9 +125,7 @@ def from_fscan_to_nx(
             )
         my_nxtomo.sample.rotation_angle = np.concatenate(rotation_angles) * _ureg.degree
 
-    my_nxtomo.instrument.detector.field_of_view = (
-        "Half" if (halftomo and do_360) else "Full"
-    )
+    my_nxtomo.instrument.detector.half_acquisition = halftomo and do_360
     my_nxtomo.instrument.detector.x_pixel_size = (
         my_nxtomo.instrument.detector.y_pixel_size
     ) = (6.5 * 1e-6)

{nxtomomill-2.1.0.dev3 → nxtomomill-2.1.0.dev4}/nxtomomill/converter/hdf5/acquisition/baseacquisition.py

@@ -71,6 +71,8 @@ class BaseAcquisition:
 
     _FOV_PATH = "technique/scan/field_of_view"
 
+    _HALF_ACQUISITION = "technique/scan/half_acquisition"
+
     _NB_LOOP_PATH = ("technique/scan/nb_loop", "technique/proj/nb_loop")
 
     _NB_TOMO_PATH = ("technique/scan/nb_tomo", "technique/proj/nb_tomo")

{nxtomomill-2.1.0.dev3 → nxtomomill-2.1.0.dev4}/nxtomomill/converter/hdf5/acquisition/standardacquisition.py

@@ -1126,7 +1126,7 @@ class StandardAcquisition(BaseAcquisition):
                 _logger.warning(mess)
                 return 10e-6 * _ureg.meter
 
-    def _get_field_of_view(self) -> str:
+    def _get_field_of_view(self) -> str | None:
         if self.configuration.field_of_view is not None:
             return self.configuration.field_of_view.value
         url = self.parent_root_url() or self.root_url
@@ -1138,11 +1138,27 @@ class StandardAcquisition(BaseAcquisition):
             if self._FOV_PATH in entry:
                 return h5py_read_dataset(entry[self._FOV_PATH])
             else:
-                # FOV is optional: don't raise an error
                 _logger.warning(
-                    f"unable to find information regarding field of view for entry {entry}. set it to default value (Full)"
+                    f"Unable to find information regarding field of view for entry {entry}. Set it to default value (Full)"
                 )
-                return "Full"
+                return None
+
+    def _get_half_acquisition(self) -> bool | None:
+        if self.configuration.half_acquisition is not None:
+            return self.configuration.half_acquisition
+        url = self.parent_root_url() or self.root_url
+        if url is None:
+            return None
+        with EntryReader(
+            url, open_mode_for_reading=self.configuration.open_mode_for_reading
+        ) as entry:
+            if self._HALF_ACQUISITION in entry:
+                return bool(h5py_read_dataset(entry[self._HALF_ACQUISITION]))
+            else:
+                _logger.warning(
+                    f"Unable to find information regarding 'half_acquisition' for entry {entry}."
+                )
+                return None
 
     def _update_configuration_from_tomo_config(self):
         """
@@ -1213,9 +1229,21 @@ class StandardAcquisition(BaseAcquisition):
                 active_tomo_config_dataset_name = h5py_read_dataset(
                     dataset_name, decode_ascii=True
                 )[0]
+
+                active_tomo_config_path = (
+                    f"instrument/{active_tomo_config_dataset_name}"
+                )
+                if active_tomo_config_path not in entry:
+                    _logger.error(
+                        f"Cannot find the active tomo config in {active_tomo_config_path!r}"
+                    )
+                    self._active_config_tomo_detector = None
+                    return
+
                 active_tomo_config = BlissActiveConfig.from_hdf5_group(
-                    entry[f"instrument/{active_tomo_config_dataset_name}"]
+                    entry[active_tomo_config_path]
                 )
+
                 if active_tomo_config.tomo_detector:
                     # tomo_detector is given as a tuple of 1 element
                     self._active_config_tomo_detector = (
@@ -1353,7 +1381,14 @@ class StandardAcquisition(BaseAcquisition):
             DetXFlipTransformation(flip=self.ud_flipped)
         )
 
-        # fov
+        # half-acquisition
+        half_acquisition = self._get_half_acquisition()
+        assert isinstance(
+            half_acquisition, (bool, type(None))
+        ), f"half acquisition has to be a boolean or None. Got {half_acquisition}"
+        # Note: default value is False and not None. So if the half_acquisition is not found in the metadata we will set it to False
+        nx_tomo.instrument.detector.half_acquisition = half_acquisition
+        # fov (deprecated. half-acquisition is preferred)
         fov = self._get_field_of_view()
         if fov is not None:
             nx_tomo.instrument.detector.field_of_view = fov

{nxtomomill-2.1.0.dev3 → nxtomomill-2.1.0.dev4}/nxtomomill/converter/hdf5/acquisition/tests/test_legacy.py

@@ -61,6 +61,7 @@ def test_S59_68p41b_16mm_6p5mm_F8_0001_dataset(
     assert len(nxtomo.instrument.detector.image_key) == n_frames
     assert len(nxtomo.instrument.detector.image_key_control) == n_frames
     assert nxtomo.instrument.detector.field_of_view.value == "Full"
+    assert nxtomo.instrument.detector.half_acquisition is None
 
     N_PROJ = 10000
 

{nxtomomill-2.1.0.dev3 → nxtomomill-2.1.0.dev4}/nxtomomill/converter/hdf5/tests/test_hdf5converter.py

@@ -1496,3 +1496,23 @@ def test_keys_operations(tmp_path):
         first_scan.z_translation,
         (numpy.array([150.49] * n_frames) * _ureg.millimeter).to_base_units().magnitude,
     )
+
+
+def test_invalid_active_tomo_config(tmp_path):
+    config = TomoHDF5Config()
+    config.input_file = GitlabDataset.get_dataset(
+        os.sep.join(
+            (
+                "h5_datasets",
+                "failling",
+                "SPL_WG_WG_K_03_Zseries_LR_167_P_239_7479_D_2477_0000_0000.h5",
+            )
+        )
+    )
+    config.output_file = str(tmp_path / "test.nx")
+    result = converter.from_h5_to_nx(configuration=config)
+    assert len(result) == 1
+    output_file, output_entry = result[0]
+    assert os.path.exists(output_file)
+    scan = NXtomo().load(file_path=output_file, data_path=output_entry)
+    assert len(scan.sample.rotation_angle) == 2542

{nxtomomill-2.1.0.dev3 → nxtomomill-2.1.0.dev4}/nxtomomill/io/config/confighandler.py

@@ -131,6 +131,7 @@ class TomoHDF5ConfigHandler:
             "sub_entries_to_ignore",
             "raises_error",
             "field_of_view",
+            "half_acquisition",
             "request_input",
             "default_data_copy",
             "sample_x_keys",

{nxtomomill-2.1.0.dev3 → nxtomomill-2.1.0.dev4}/nxtomomill/io/config/tests/test_confighandler.py

@@ -41,6 +41,7 @@ class _ARParseMock(object):
         self.no_master_file = False
         self.file_extension = None
         self.field_of_view = None
+        self.half_acquisition = None
         self.sample_detector_distance_keys = None
         self.use_abs_path_for_vds = None
         self.open_mode_for_reading = "robust"

{nxtomomill-2.1.0.dev3 → nxtomomill-2.1.0.dev4}/nxtomomill/models/dx2nx.py

@@ -4,7 +4,13 @@ from __future__ import annotations
 
 from nxtomo.nxobject.nxdetector import FieldOfView
 from .base.general_section import GeneralSection
-from pydantic import Field, ConfigDict, field_serializer, field_validator
+from pydantic import (
+    Field,
+    ConfigDict,
+    field_serializer,
+    field_validator,
+    model_validator,
+)
 
 __all__ = [
     "DX2nxModel",
@@ -38,8 +44,13 @@ class DX2nxModel(GeneralSection):
         default=(None, None),
         description="Pixel size can be provided - in meter - as (x_pizel_size, y_pixel_size)",
     )
+    half_acquisition: bool | None = Field(
+        default=None,
+        description="If True, run a half acquisition. This replaces the string-based field_of_view setting.",
+    )
     field_of_view: FieldOfView | None = Field(
-        default=None, description="Detector field of view"
+        default=None,
+        description="DEPRECATED: Detector field of view. Use half_acquisition instead.",
     )
     sample_detector_distance: float | None = Field(
         default=1.0, description="sample / detector distance in meter"
@@ -55,6 +66,16 @@ class DX2nxModel(GeneralSection):
             return None
         return FieldOfView(value)
 
+    @model_validator(mode="after")
+    def normalize_half_acquisition(self):
+        if self.half_acquisition is not None and self.field_of_view is None:
+            self.field_of_view = (
+                FieldOfView.HALF if self.half_acquisition else FieldOfView.FULL
+            )
+        elif self.field_of_view is not None and self.half_acquisition is None:
+            self.half_acquisition = self.field_of_view == FieldOfView.HALF
+        return self
+
     @field_serializer(
         "field_of_view",
         when_used="always",

{nxtomomill-2.1.0.dev3 → nxtomomill-2.1.0.dev4}/nxtomomill/models/edf2nx/detector_section.py

@@ -9,10 +9,13 @@ from pydantic import BaseModel, Field, field_validator, ConfigDict, field_serial
 class DetectorSection(BaseModel):
 
     model_config = ConfigDict(validate_assignment=True, validate_by_name=True)
-
+    half_acquisition: bool | None = Field(
+        default=None,
+        description="Is the acquisition an full acquisition of an half acquisition (CoR in at borders of projections)",
+    )
     field_of_view: FieldOfView | None = Field(
         default=None,
-        description="Detector field of view. If set must be in `Half` or `Full`",
+        description="Deprecated to the benefit of 'half_acquisition'. Detector field of view. If set must be in `Half` or `Full`",
     )
 
     @field_validator(

{nxtomomill-2.1.0.dev3 → nxtomomill-2.1.0.dev4}/nxtomomill/models/edf2nx/edf2nx.py

@@ -80,6 +80,7 @@ class EDF2nxModel(
             ),
             detector_section=DetectorSection(
                 field_of_view=self.field_of_view,
+                half_acquisition=self.half_acquisition,
             ),
             unit_section=UnitSection(
                 pixel_size_unit=self.pixel_size_unit,

{nxtomomill-2.1.0.dev3 → nxtomomill-2.1.0.dev4}/nxtomomill/models/h52nx/general_section.py

@@ -38,6 +38,10 @@ class GeneralSection(_GeneralSectionBase):
         default=None,
         description="Force output to be a 'Full' or 'Half' acquisition. Else determine from existing metadata",
     )
+    half_acquisition: bool | None = Field(
+        default=None,
+        description="Is is a full acquisition or an half-acquisition (CoR at bordrs of projections)",
+    )
     create_control_data: bool = Field(
         default=True, description="Generate control/data - filled with machine current."
     )
@@ -77,6 +81,7 @@ class GeneralSection(_GeneralSectionBase):
     @field_validator(
         "check_tomo_n",
         "rotation_is_clockwise",
+        "half_acquisition",
         mode="before",
     )
     @classmethod

{nxtomomill-2.1.0.dev3 → nxtomomill-2.1.0.dev4}/nxtomomill/models/h52nx/h52nx.py

@@ -49,6 +49,7 @@ class H52nxModel(
                 single_file=self.single_file,
                 no_master_file=self.no_master_file,
                 field_of_view=self.field_of_view,
+                half_acquisition=self.half_acquisition,
                 rotation_is_clockwise=self.rotation_is_clockwise,
                 create_control_data=self.create_control_data,
                 check_tomo_n=self.check_tomo_n,

{nxtomomill-2.1.0.dev3 → nxtomomill-2.1.0.dev4}/nxtomomill/version.py

@@ -57,7 +57,7 @@ MAJOR = 2
 MINOR = 1
 MICRO = 0
 RELEV = "dev"  # <16
-SERIAL = 3  # <16
+SERIAL = 4  # <16
 
 date = __date__
 

{nxtomomill-2.1.0.dev3 → nxtomomill-2.1.0.dev4/nxtomomill.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nxtomomill
-Version: 2.1.0.dev3
+Version: 2.1.0.dev4
 Summary: applications and library to convert raw format to NXtomo format
 Author-email: Henri Payno <henri.payno@esrf.fr>, Pierre Paleo <pierre.paleo@esrf.fr>, Pierre-Olivier Autran <pierre-olivier.autran@esrf.fr>, Jérôme Lesaint <jerome.lesaint@esrf.fr>, Alessandro Mirone <mirone@esrf.fr>
 License: 
@@ -55,7 +55,7 @@ License-File: LICENSE
 Requires-Dist: numpy
 Requires-Dist: h5py>=3.0
 Requires-Dist: silx>=2.0
-Requires-Dist: nxtomo>=3.1.0dev0
+Requires-Dist: nxtomo>=3.1.0dev1
 Requires-Dist: pint
 Requires-Dist: packaging
 Requires-Dist: tomoscan[full]>=2.2.0a4

{nxtomomill-2.1.0.dev3 → nxtomomill-2.1.0.dev4}/nxtomomill.egg-info/SOURCES.txt

@@ -46,7 +46,6 @@ nxtomomill/converter/version.py
 nxtomomill/converter/dxfile/__init__.py
 nxtomomill/converter/dxfile/dxfileconverter.py
 nxtomomill/converter/dxfile/tests/test_dxfile.py
-nxtomomill/converter/edf/_Blosc2Jp2kWrapper.py
 nxtomomill/converter/edf/__init__.py
 nxtomomill/converter/edf/checks.py
 nxtomomill/converter/edf/edfconverter.py

{nxtomomill-2.1.0.dev3 → nxtomomill-2.1.0.dev4}/nxtomomill.egg-info/requires.txt

@@ -1,7 +1,7 @@
 numpy
 h5py>=3.0
 silx>=2.0
-nxtomo>=3.1.0dev0
+nxtomo>=3.1.0dev1
 pint
 packaging
 tomoscan[full]>=2.2.0a4

{nxtomomill-2.1.0.dev3 → nxtomomill-2.1.0.dev4}/nxtomomill.egg-info/top_level.txt

@@ -1,4 +1,3 @@
-build
 dist
 doc
 html

{nxtomomill-2.1.0.dev3 → nxtomomill-2.1.0.dev4}/pyproject.toml

@@ -36,7 +36,7 @@ dependencies = [
     "numpy",
     "h5py>=3.0",
     "silx>=2.0",
-    "nxtomo>=3.1.0dev0",
+    "nxtomo>=3.1.0dev1",
     "pint",
     "packaging",
     "tomoscan[full] >=2.2.0a4",

nxtomomill-2.1.0.dev3/nxtomomill/converter/edf/_Blosc2Jp2kWrapper.py

@@ -1,63 +0,0 @@
-from __future__ import annotations
-import numpy
-from h5py import Dataset
-
-try:
-    import blosc2
-    import blosc2_grok
-except ImportError:
-    _has_blosc2 = False
-else:
-    _has_blosc2 = True
-
-
-class Blosc2Jp2kWrapper:
-    """Wrapper to apply JP2K conversion to a dataset"""
-
-    def __init__(self, dataset: Dataset, compression_params: dict):
-        self.dataset: Dataset = dataset
-        self.compression_params: dict = self.get_default_compression_params()
-        self.compression_params.update(compression_params)
-
-        blosc2_grok.set_params_defaults(
-            # codec=blosc2.Codec.GROK,
-            cod_format=blosc2_grok.GrkFileFmt.GRK_FMT_JP2,
-            num_threads=self.compression_params["nthreads"],
-            quality_mode="rates",
-            quality_layers=numpy.array(
-                [self.compression_params["cratio"]],
-                dtype=numpy.float64,
-            ),
-            verbose=True,
-        )
-
-    def __setitem__(self, name, value):
-        z, _, _ = name
-        Z, Y, X = self.dataset.shape
-
-        # Verify data type compatibility
-        if value.dtype not in [numpy.float32, numpy.float64, numpy.uint16]:
-            raise ValueError(f"Unsupported dtype: {value.dtype}")
-
-        b2im = blosc2.asarray(
-            value.reshape(1, Y, X),
-            chunks=(1, Y, X),
-            blocks=(1, Y, X),
-            cparams=self.compression_params,
-        )
-        cframe = b2im.schunk.to_cframe()
-        self.dataset.id.write_direct_chunk((z, 0, 0), cframe, filter_mask=0)
-
-    @classmethod
-    def get_default_compression_params(cls) -> dict:
-        if _has_blosc2:
-            return {
-                "codec": blosc2.Codec.GROK,
-                "filters": [],
-                "splitmode": blosc2.SplitMode.NEVER_SPLIT,
-                "nthreads": 4,
-                "cratio": 10,
-                "verbose": True,
-            }
-        else:
-            return {}