tomwer 1.2.1__py3-none-any.whl → 1.3.12__py3-none-any.whl

tomwer/core/process/reconstruction/nabu/helical.py

@@ -6,7 +6,7 @@ from nabu.io.reader import load_images_from_dataurl_dict
 from nabu.app.prepare_weights_double import create_heli_maps
 
 from tomwer.core.process.task import TaskWithProgress
-from tomwer.core.scan.hdf5scan import HDF5TomoScan
+from tomwer.core.scan.nxtomoscan import NXtomoScan
 from tomwer.core.utils.scanutils import format_output_location
 
 
@@ -17,8 +17,10 @@ class NabuHelicalPrepareWeightsDouble(
     TaskWithProgress,
     input_names=(
         "data",
-        "transition_width",
+        "transition_width_vertical",
+        "transition_width_horizontal",
         "processes_file",
+        "rotation_axis_position",
     ),
     optional_input_names=("progress",),
     output_names=("data",),
@@ -26,8 +28,8 @@ class NabuHelicalPrepareWeightsDouble(
     def run(self):
         # TODO: handle future /cluster config ???
         scan = self.inputs.data
-        if not isinstance(scan, HDF5TomoScan):
-            raise TypeError(f"data is expected to be an instance of {HDF5TomoScan}")
+        if not isinstance(scan, NXtomoScan):
+            raise TypeError(f"data is expected to be an instance of {NXtomoScan}")
         dataset_info = HDF5DatasetAnalyzer(
             scan.master_file,
             extra_options={"h5_entry": scan.entry},
@@ -48,7 +50,9 @@ class NabuHelicalPrepareWeightsDouble(
             profile=mappe,
             process_file_name=scan.helical.processes_files,
             entry_name=scan.entry,
-            transition_width=self.inputs.transition_width,
+            transition_width_vertical=self.inputs.transition_width_vertical,
+            transition_width_horizontal=self.inputs.transition_width_horizontal,
+            rotation_axis_position=self.inputs.rotation_axis_position,
         )
 
         self.outputs.data = scan

tomwer/core/process/reconstruction/nabu/nabucommon.py

@@ -39,29 +39,37 @@ import uuid
 from typing import Iterable, Optional, Union
 import signal
 import psutil
+import sys
 
 import numpy
 from silx.io.url import DataUrl
-from silx.utils.enum import Enum as _Enum
+from silx.io.utils import open as open_hdf5
 from sluurp.executor import submit as submit_to_slurm_cluster
 from sluurp.job import SBatchScriptJob
 from tomoscan.io import HDF5File
 from tomoscan.normalization import Method as INormMethod
+from tomoscan.identifier import VolumeIdentifier
 
+from tomwer.core.process.reconstruction.nabu.plane import NabuPlane
 from tomwer.core.cluster.cluster import SlurmClusterConfiguration
 from tomwer.core.process.reconstruction.nabu.target import Target
 from tomwer.core.process.reconstruction.nabu.utils import (
     _NabuPhaseMethod,
     nabu_std_err_has_error,
 )
+from tomwer.core.process.reconstruction.output import (
+    ProcessDataOutputDirMode,
+    get_output_folder_from_scan,
+    NabuOutputFileFormat,
+)
 from tomwer.core.process.reconstruction.normalization.params import (
     _ValueSource as INormSource,
 )
 from tomwer.core.scan.edfscan import EDFTomoScan
-from tomwer.core.scan.hdf5scan import HDF5TomoScan
+from tomwer.core.scan.nxtomoscan import NXtomoScan
 from tomwer.core.scan.scanbase import TomwerScanBase
-from tomwer.core.utils.scanutils import format_output_location
 from tomwer.core.utils.slurm import get_slurm_script_name, is_slurm_available
+from tomwer.core.volume.volumefactory import VolumeFactory
 
 from . import settings, utils
 
@@ -85,37 +93,6 @@ else:
     has_nabu = True
 
 
-class NabuOutputFileFormat(_Enum):
-    TIFF = "tiff"
-    HDF5 = "hdf5"
-    JP2K = "jp2"
-    EDF = "edf"
-    RAW = "vol"
-
-    @classmethod
-    def from_value(cls, value):
-        if isinstance(value, str):
-            value = value.lstrip(".")
-        return super().from_value(value)
-
-
-def get_file_format(file_str):
-    extension = os.path.splitext(file_str.lower())[-1]
-    extension = extension.lstrip(".")
-    if extension in ("tiff", "tif"):
-        return NabuOutputFileFormat.TIFF
-    elif extension in ("hdf5", "hdf", "h5"):
-        return NabuOutputFileFormat.HDF5
-    elif extension in ("jp2", "jp2k", "jpg2k"):
-        return NabuOutputFileFormat.JP2K
-    elif extension in ("edf",):
-        return NabuOutputFileFormat.EDF
-    elif extension in ("vol", "raw"):
-        return NabuOutputFileFormat.RAW
-    else:
-        raise ValueError(f"Unrecognized file extension {extension} from {file_str}")
-
-
 class ResultsRun:
     """
     Base class of results for nabu
@@ -165,24 +142,44 @@ class ResultsLocalRun(ResultsWithStd):
 
     def __init__(
         self,
-        results_urls: tuple,
+        results_identifiers: tuple,
         *args,
         **kwargs,
     ) -> None:
         super().__init__(*args, **kwargs)
-        if not isinstance(results_urls, Iterable):
+        if not isinstance(results_identifiers, Iterable):
             raise TypeError(
-                f"results_urls is expected to be an Iterable not {type(results_urls)}"
+                f"results_urls is expected to be an Iterable not {type(results_identifiers)}"
             )
-        self.__results_urls = results_urls
+
+        # check all identifiers
+        def check_identifier(identifier):
+            if isinstance(identifier, str):
+                vol = VolumeFactory.create_tomo_object_from_identifier(
+                    identifier=identifier
+                )
+                return vol.get_identifier()
+            elif not isinstance(identifier, VolumeIdentifier):
+                raise TypeError(
+                    f"identifiers are expected to be VolumeIdentifier. Get {type(identifier)} instead."
+                )
+            else:
+                return identifier
+
+        self.__results_identifiers = tuple(
+            [
+                check_identifier(identifier=identifier)
+                for identifier in results_identifiers
+            ]
+        )
 
     @property
-    def results_urls(self) -> tuple:
-        return self.__results_urls
+    def results_identifiers(self) -> tuple:
+        return self.__results_identifiers
 
     def __str__(self) -> str:
         res = super().__str__()
-        res += f"\n - result urls: {self.results_urls}"
+        res += f"\n - result urls: {self.results_identifiers}"
         return res
 
 
@@ -231,6 +228,7 @@ class _NabuBaseReconstructor:
         target: Target,
         cluster_config: Optional[Union[dict, SlurmClusterConfiguration]],
         process_name: str,
+        axis: NabuPlane = NabuPlane.XY,
     ) -> None:
         self._scan = scan
         self._target = Target.from_value(target)
@@ -238,6 +236,7 @@ class _NabuBaseReconstructor:
         self._process_name = process_name
         self._process = None
         self._cancelled = False
+        self._axis = NabuPlane.from_value(axis)
         # nabu subprocess if run locally
         if isinstance(cluster_config, SlurmClusterConfiguration):
             self._cluster_config = cluster_config
@@ -270,6 +269,10 @@ class _NabuBaseReconstructor:
     def process_name(self):
         return self._process_name
 
+    @property
+    def axis(self) -> NabuPlane:
+        return self._axis
+
     def only_create_config_file(self):
         """Should we run the reconstruction or only create the configuration file"""
         return False
@@ -287,8 +290,6 @@ class _NabuBaseReconstructor:
         config_to_dump: dict,
         config_file: str,
         file_format: str,
-        start_z: Optional[int],
-        end_z: Optional[int],
         info: Optional[str],
         process_name: str,
     ):
@@ -308,8 +309,7 @@ class _NabuBaseReconstructor:
                 conf_file=config_file,
                 file_format=file_format,
                 config_to_dump=config_to_dump,
-                start_z=start_z,
-                end_z=end_z,
+                axis=config_to_dump["reconstruction"].get("slice_plane", "XY"),
             )
         elif self.target is Target.SLURM:
             _logger.info(
@@ -319,8 +319,6 @@ class _NabuBaseReconstructor:
                 conf_file=config_file,
                 config_to_dump=config_to_dump,
                 cluster_config=self.cluster_config.to_dict(),
-                start_z=start_z,
-                end_z=end_z,
                 process_name=process_name,
                 info=info,
             )
@@ -341,11 +339,10 @@ class _NabuBaseReconstructor:
 
     def _run_nabu_locally(
         self,
+        axis: NabuPlane,
         conf_file: str,
         file_format: str,
         config_to_dump: dict,
-        start_z: int,
-        end_z: int,
     ) -> ResultsLocalRun:
         """
         run locally nabu for a single configuration file.
@@ -365,7 +362,7 @@ class _NabuBaseReconstructor:
 
         command = " ".join(
             (
-                "python3",
+                sys.executable,
                 "-m",
                 settings.NABU_FULL_FIELD_APP_PATH,
                 conf_file,
@@ -396,13 +393,11 @@ class _NabuBaseReconstructor:
             slice_index=None,
             scan=self.scan,
             file_format=file_format,
-            start_z=start_z,
-            end_z=end_z,
-            expects_single_slice=self.EXPECTS_SINGLE_SLICE,
+            axis=axis,
         )
         return ResultsLocalRun(
             success=not nabu_std_err_has_error(errs),
-            results_urls=recons_urls,
+            results_identifiers=recons_urls,
             std_out=outs,
             std_err=errs,
             config=config_to_dump,  # config_slices,
@@ -413,8 +408,6 @@ class _NabuBaseReconstructor:
         conf_file: str,
         config_to_dump: dict,
         cluster_config: dict,
-        start_z: int,
-        end_z: int,
         process_name: str,
         info: str,
     ) -> ResultSlurmRun:
@@ -521,26 +514,28 @@ class _NabuBaseReconstructor:
                                 "delta_beta"
                             ][0]
                     db = round(float(config["phase"]["delta_beta"]))
+        # retrieve axis used
+        axis = config.get("reconstruction", {}).get("slice_plane", "XY")
+
         # handle output
         if "output" in config:
-            _file_name = self._get_file_basename_reconstruction(pag=pag, db=db, ctf=ctf)
+            _file_name = self._get_file_basename_reconstruction(
+                pag=pag, db=db, ctf=ctf, axis=axis
+            )
             config["output"]["file_prefix"] = _file_name
-            location = config["output"].get("location", None)
-            if location not in ("", None):
-                location = format_output_location(location, scan=self.scan)
-                location_cfg_files = location
-            else:
-                # otherwise default location will be the data root level
-                location = self.scan.path
-                location_cfg_files = location
-                # TODO: if is a single file - append prefix
-                if config["output"].get("file_format") in (
-                    NabuOutputFileFormat.EDF.value,
-                    NabuOutputFileFormat.TIFF.value,
-                    NabuOutputFileFormat.JP2K.value,
-                ):  # if user specify the location
-                    location = "/".join([location, _file_name])
-
+            location, location_cfg_files = get_output_folder_from_scan(
+                mode=ProcessDataOutputDirMode.from_value(
+                    config["output"].get(
+                        "output_dir_mode", ProcessDataOutputDirMode.OTHER
+                    )
+                ),
+                nabu_location=config["output"].get("location", None),
+                scan=self.scan,
+                file_basename=_file_name,
+                file_format=config["output"].get(
+                    "file_format", NabuOutputFileFormat.HDF5
+                ),
+            )
             # add reconstruction path to the list. scan `reconstruction_paths` register all the existing path where
             # reconstruction are saved in order to be able to browse them all
             self.scan.add_reconstruction_path(location)
@@ -587,9 +582,7 @@ class _NabuBaseReconstructor:
                     # if an url exists insure we can access it
                     dataset_url = DataUrl(path=dataset_url)
                     if os.path.exists(dataset_url.file_path()):
-                        with HDF5File(
-                            dataset_url.file_path(), mode="r", swmr="True"
-                        ) as h5f:
+                        with open_hdf5(dataset_url.file_path()) as h5f:
                             if dataset_url.data_path() not in h5f:
                                 dataset_url = None
                     else:
@@ -624,7 +617,7 @@ class _NabuBaseReconstructor:
             raise NotImplementedError(f"source type {source.value} is not handled")
         return config, nabu_cfg_folder
 
-    def _get_file_basename_reconstruction(self, pag, db, ctf):
+    def _get_file_basename_reconstruction(self, pag, db, ctf, axis):
         """return created file base name"""
         raise NotImplementedError("Base class")
 
@@ -661,7 +654,7 @@ def dump_normalization_array_for_nabu(
             f"array is expected to be a numpy array or a scalar and not {type(array)}"
         )
     # save the value to a dedicated path in "nabu_tomwer_serving_hatch"
-    if isinstance(scan, HDF5TomoScan):
+    if isinstance(scan, NXtomoScan):
         entry_path = scan.entry
     elif isinstance(scan, EDFTomoScan):
         entry_path = "entry"