tomwer 1.3.26__py3-none-any.whl → 1.4.0__py3-none-any.whl

tomwer/core/process/reconstruction/axis/params.py

@@ -1,48 +1,16 @@
-# coding: utf-8
-# /*##########################################################################
-#
-# Copyright (c) 2016-2017 European Synchrotron Radiation Facility
-#
-# Permission is hereby granted, free of charge, to any person obtaining a copy
-# of this software and associated documentation files (the "Software"), to deal
-# in the Software without restriction, including without limitation the rights
-# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-# copies of the Software, and to permit persons to whom the Software is
-# furnished to do so, subject to the following conditions:
-#
-# The above copyright notice and this permission notice shall be included in
-# all copies or substantial portions of the Software.
-#
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-# THE SOFTWARE.
-#
-# ###########################################################################*/
-
-__authors__ = ["H. Payno"]
-__license__ = "MIT"
-__date__ = "04/03/2019"
-
+from __future__ import annotations
 
 import logging
-import os
 from collections import namedtuple
-from typing import Union
 
-import h5py
 import numpy
 from silx.io.url import DataUrl
-from silx.utils.deprecation import deprecated
 from silx.utils.enum import Enum as _Enum
 from tomoscan.esrf.scan.utils import get_data
 
-from tomwer.core.process.task import Task
+from tomwer.core.process.reconstruction.utils.cor import relative_pos_to_absolute
+from tomwer.core.process.reconstruction.axis.side import Side
 from tomwer.core.scan.scanbase import TomwerScanBase
-from tomwer.core.utils.spec import getParametersFromParOrInfo
 
 from .anglemode import CorAngleMode
 from .mode import AxisMode, AXIS_MODE_METADATAS
@@ -110,13 +78,14 @@ class AxisResource(object):
     """Paganin configuration for axis calculation. To simplify we have only one
     static configuration for now. Otherwise complicate stuff"""
 
-    def __init__(self, url):
+    def __init__(self, url: None | DataUrl, angle: float | None = None):
         assert url is None or isinstance(url, DataUrl)
         assert url is None or url.is_valid()
         self.__url = url
         self.__raw_data = None
         self.__norme_data = None
         self.__norm_paganin = None
+        self.__angle = angle
 
     def __str__(self):
         return f"{type(self)}, url: {self.__url.path() if self.__url else None}"
@@ -149,6 +118,10 @@ class AxisResource(object):
     def normalized_data(self, data):
         self.__norme_data = data
 
+    @property
+    def angle(self) -> float | None:
+        return self.__angle
+
     def normalize_data(self, scan, log_):
         """Normalize data for axis calculation"""
         if not isinstance(scan, TomwerScanBase):
@@ -183,8 +156,7 @@ class AxisResource(object):
     def normalized_data_paganin(self):
         """
 
-        :return: data processed by the pagagnin phase retrieval
-        :rtype: 2D numpy.array
+        :return: data processed by the Pagagin phase retrieval
         """
         if self.__url is None:
             return None
@@ -216,7 +188,7 @@ class AxisResource(object):
 
 class AxisRP:
     """
-    Configuration class for a tomwer :class:`AxisProcess`
+    Configuration class for a tomwer :class:`AxisTask`
 
     note: every modification on the parameters will process a call fo changed
     except `axis_url_1` and `axis_url_2` which will produce a call to the
@@ -240,11 +212,12 @@ class AxisRP:
         "FINE_STEP_X",
         "SCALE_IMG2_TO_IMG1",
         "NEAR_POSITION",
+        "MOTOR_OFFSET",
+        "X_ROTATION_AXIS_PIXEL_POSITION",
         "SINOGRAM_SUBSAMPLING",
         "PADDING_MODE",
         "FLIP_LR",
         "COMPOSITE_OPTS",
-        "SIDE",
         "COR_OPTIONS",
     )
 
@@ -259,17 +232,18 @@ class AxisRP:
         None is not processing"""
         self.__angle_mode = CorAngleMode.use_0_180
         """Angle to use for radios"""
+        self.__x_rotation_axis_pixel_position = None
+        """rotation axis position obtained from motor"""
+        self.__x_rotation_axis_pos_px_offset = 0.0
+        """motor offset to be used to compute the 'estimated_cor' from 'x_rotation_axis_pixel_position'"""
         self.__estimated_cor = 0.0
-        """Position to use for near calculation"""
+        """Estimated position of the center of rotation. Given by the user or computed from 'x_rotation_axis_pixel_position' and 'pixel_offset'"""
         self.__axis_url_1 = AxisResource(url=None)
         """first data url to use for axis cor calculation"""
         self.__axis_url_2 = AxisResource(url=None)
         """second data url to use for axis cor calculation"""
         self.__calculation_input_type = AxisCalculationInput.transmission
         """Type of input (emission, absorption, with or without paganin)"""
-        self.__use_sinogram = False
-        """Do we want to use the sinogram of the radios for computing center
-        of rotation"""
         self.__sinogram_line = "middle"
         """Line of the radios to use for getting the sinogram"""
         self.__sinogram_subsampling = 10
@@ -278,17 +252,14 @@ class AxisRP:
         self.__look_at_stdmax = False
         """do the near search at X position which as the max Y column standard
         deviation"""
-        self.__near_wx = 5
+        self.__composite_window_size = 5
         """do the near search in an X window of size +-near_wx"""
-        self.__fine_stepx = 0.1
+        self.__composite_fine_step = 0.1
         """shift step x for fine shifting image"""
         self.__scale_img2_to_img1 = False
         """do image scaling"""
         self.__padding_mode = None
         self.__frame_width = None
-        self.__side = "right"
-        """side of the cor. Requested by nabu cor algorithms growing-window
-        and sliding-window"""
         self.__flip_lr = True
         self.__composite_options = {
             "theta": DEFAULT_CMP_THETA,
@@ -308,41 +279,11 @@ class AxisRP:
 
     @mode.setter
     def mode(self, mode):
-        if isinstance(mode, str):
-            try:
-                name = mode
-                if name in ("global_", "global"):
-                    name = AxisMode.global_.name
-                elif name == "accurate":
-                    _logger.info(
-                        f"convert axis mode {name} to {AxisMode.centered.name} (renamed)"
-                    )
-                    name = AxisMode.centered.name
-                elif name == "growing-window":
-                    _logger.warning(
-                        f"growing-window mode has been removed. Replace it by {AxisMode.growing_window_radios.value}"
-                    )
-                    name = AxisMode.growing_window_radios.name
-                elif name == "sliding-window":
-                    _logger.warning(
-                        f"sliding-window mode has been removed. Replace it by {AxisMode.sliding_window_radios.value}"
-                    )
-                    name = AxisMode.sliding_window_radios.name
-                try:
-                    _mode = getattr(AxisMode, name)
-                except Exception:
-                    _mode = AxisMode.from_value(name)
-            except Exception:
-                raise ValueError(f"Fail to create axis mode from {mode}")
-        else:
-            if not isinstance(mode, AxisMode):
-                raise TypeError(f"mode is expected to be an instance of {AxisMode}")
-            _mode = mode
-        self.__mode = _mode
+        self.__mode = AxisMode.from_value(mode)
         self.changed()
 
     @property
-    def frame_width(self) -> Union[None, float]:
+    def frame_width(self) -> float | None:
         return self.__frame_width
 
     @frame_width.setter
@@ -369,11 +310,6 @@ class AxisRP:
             self.__angle_mode = mode
             self.changed()
 
-    @property
-    @deprecated(replacement="relative_cor_value", since_version="0.7")
-    def value_ref_tomwer(self):
-        return self.relative_cor_value
-
     @property
     def relative_cor_value(self):
         return self.__relative_value
@@ -385,7 +321,7 @@ class AxisRP:
     def set_relative_value(self, value):
         if not isinstance(value, (int, float, str, type(None))):
             raise TypeError(
-                f"value is expected to be an instance of {int} {float}, {str} or {None}. {type(value)} provided"
+                f"value is expected to be an instance of {int}, {float}, {str}, or {None}. {type(value)} provided"
             )
         if value is None:
             changed = self.__relative_value is not None
@@ -400,41 +336,46 @@ class AxisRP:
             else:
                 self.__relative_value = float(value)
                 if self.frame_width is not None:
-                    self.__absolute_value = (
-                        self.__relative_value + self.frame_width / 2.0
+                    self.__absolute_value = relative_pos_to_absolute(
+                        relative_pos=self.__relative_value, det_width=self.frame_width
                     )
             self.changed()
 
-    @deprecated(replacement="set_relative_value", since_version="0.7")
-    def set_value_ref_tomwer(self, value):
-        self.set_relative_value(value=value)
-
-    @property
-    @deprecated(replacement="absolute_cor_value", since_version="0.7")
-    def value_ref_nabu(self):
-        return self.__absolute_value
-
     @property
-    def estimated_cor(self):
+    def estimated_cor(self) -> Side | float | None:
         return self.__estimated_cor
 
     @estimated_cor.setter
-    def estimated_cor(self, value):
+    def estimated_cor(self, value: Side | float | None):
+        try:
+            value = Side.from_value(value)
+        except ValueError:
+            pass
         if self.__estimated_cor != value:
             self.__estimated_cor = value
             self.changed()
 
     @property
-    def side(self):
-        return self.__side
-
-    @side.setter
-    def side(self, side):
-        if side not in ("all", "left", "right", "center", "near"):
-            raise ValueError(f"side '{side}' is not managed")
-        if self.__side != side:
-            self.__side = side
-            self.changed()
+    def x_rotation_axis_pos_px_offset(self) -> float:
+        return self.__x_rotation_axis_pos_px_offset
+
+    @x_rotation_axis_pos_px_offset.setter
+    def x_rotation_axis_pos_px_offset(self, value: float):
+        assert isinstance(
+            value, float
+        ), f"x_rotation_axis_pos_px_offset should be a float. Got {type(value)}"
+        self.__x_rotation_axis_pos_px_offset = value
+
+    @property
+    def x_rotation_axis_pixel_position(self) -> float | None:
+        return self.__x_rotation_axis_pixel_position
+
+    @x_rotation_axis_pixel_position.setter
+    def x_rotation_axis_pixel_position(self, value: float | None):
+        assert isinstance(
+            value, (float, type(None))
+        ), f"x_rotation_axis_pixel_position should be None or a float. Got{type(value)}"
+        self.__x_rotation_axis_pixel_position = value
 
     @property
     def axis_url_1(self):
@@ -518,16 +459,6 @@ class AxisRP:
             self.__calculation_input_type = type_
             self.changed()
 
-    @property
-    def use_sinogram(self):
-        return self.__use_sinogram
-
-    @use_sinogram.setter
-    def use_sinogram(self, sinogram):
-        if self.__use_sinogram != sinogram:
-            self.__use_sinogram = sinogram
-            self.changed()
-
     @property
     def sinogram_line(self):
         return self.__sinogram_line
@@ -568,23 +499,24 @@ class AxisRP:
         self.__look_at_stdmax = stdmax
 
     @property
-    def near_wx(self):
-        return self.__near_wx
+    def composite_window_size(self):
+        return self.__composite_window_size
 
-    @near_wx.setter
-    def near_wx(self, width):
-        if self.__near_wx != width:
-            self.__near_wx = width
+    @composite_window_size.setter
+    def composite_window_size(self, width):
+        if self.__composite_window_size != width:
+            self.__composite_window_size = width
             self.changed()
 
     @property
-    def fine_step_x(self):
-        return self.__fine_stepx
-
-    @fine_step_x.setter
-    def fine_step_x(self, step_size):
-        if self.__fine_stepx != step_size:
-            self.__fine_stepx = step_size
+    def composite_fine_step(self):
+        """Fine step along x axis"""
+        return self.__composite_fine_step
+
+    @composite_fine_step.setter
+    def composite_fine_step(self, step_size):
+        if self.__composite_fine_step != step_size:
+            self.__composite_fine_step = step_size
             self.changed()
 
     @property
@@ -620,7 +552,7 @@ class AxisRP:
     @composite_options.setter
     def composite_options(self, opts: dict) -> None:
         """
-        :param dict opts: options to use for the composite COR search
+        :param opts: options to use for the composite COR search
         :raises:
             * KeyError if some provided keys are not handled
             * TypeError if opts is not an instance of dictionary
@@ -641,7 +573,7 @@ class AxisRP:
                 "near_pos",
                 "near_width",
             ):
-                raise KeyError(f"{key} is not recogized")
+                raise KeyError(f"{key} is not recognized")
         self.__composite_options = opts
 
     @property
@@ -655,102 +587,9 @@ class AxisRP:
             self.changed()
 
     def changed(self):
-        """callback to overwrite when the paramter value changed"""
+        """callback to overwrite when the parameter value changed"""
         pass
 
-    def set_position_frm_par_file(self, file_path, entry=None, force=False):
-        """Set position value from a file
-
-        :param str file_path: path to the par file
-        :param bool force: if True, force the mode to read and set
-                           `position_value` to None if failed to read the file.
-                           Otherwise only `mode` and `position_value` when the
-                           file read succeed.
-        """
-
-        def get_position_in_file():
-            if not os.path.isfile(file_path):
-                raise ValueError(file_path, "is not a valid file path")
-
-            if h5py.is_hdf5(file_path):
-                return self.get_cor_position_frm_tomwer_file(
-                    file_path=file_path, entry=entry
-                )
-            elif file_path.lower().endswith(".par") or file_path.lower().endswith(
-                ".info"
-            ):
-                _dict = getParametersFromParOrInfo(file_path)
-                if self.AXIS_POSITION_PAR_KEY.lower() not in _dict:
-                    err = f"fail to find `{self.AXIS_POSITION_PAR_KEY}` in {file_path}"
-                    _logger.info(err)
-                    raise KeyError(err)
-                else:
-                    return _dict[self.AXIS_POSITION_PAR_KEY.lower()]
-            else:
-                with open(file_path, mode="r") as fd:
-                    l1 = fd.readline()
-                    values = l1.split(" ")
-                    if len(values) > 0:
-                        try:
-                            res = float(values[0])
-                        except Exception:
-                            _logger.info(
-                                f"fail to load center of rotation from {file_path}"
-                            )
-                            return None
-                        else:
-                            return res
-
-        if force:
-            try:
-                position = get_position_in_file()
-            except (KeyError, ValueError) as e:
-                _logger.warning(e)
-                position = None
-        else:
-            position = get_position_in_file()
-
-        changed = self.mode != AxisMode.read or position != self.relative_cor_value
-        self.mode = AxisMode.read
-        if position is None:
-            self.set_relative_value(None)
-        else:
-            self.set_relative_value(float(position))
-
-        if changed:
-            self.changed()
-
-    @staticmethod
-    def get_cor_position_frm_tomwer_file(
-        file_path: str, entry=None
-    ) -> Union[None, float]:
-        """
-        Parse the given .h5 file, looking for axis processes. If found some
-        then return the first value discover
-
-        :param str file_path: tomwer processes file (.h5)
-        :return: center of rotation or none
-        :rtype: Union[None, float]
-        """
-        from .axis import AxisTask  # avoid cyclic import
-
-        processes = Task.get_processes_frm_type(
-            process_file=file_path, process_type=AxisTask, entry=entry
-        )
-        if len(processes) == 0:
-            _logger.warning("failed to find any information on center " "of rotation")
-            return None
-        elif len(processes) > 1:
-            _logger.info("found more than one value computed for " "center of rotation")
-        _logger.info(
-            f"load center of rotation from {file_path}: {processes[0].results['center_of_rotation']}"
-        )
-        cor = processes[0].results["center_of_rotation"]
-        if cor in [None, ""]:
-            return None
-        else:
-            return float(cor)
-
     def n_url(self):
         """
 
@@ -781,21 +620,27 @@ class AxisRP:
             "POSITION_VALUE": self.relative_cor_value,
             "CALC_INPUT_TYPE": self.calculation_input_type.to_dict(),
             "ANGLE_MODE": self.angle_mode.value,
-            "USE_SINOGRAM": self.use_sinogram,
-            "SINOGRAM_LINE": self.sinogram_line if self.use_sinogram else "",
+            "SINOGRAM_LINE": (
+                self.sinogram_line if self.mode.requires_sinogram_index() else ""
+            ),
             "SINOGRAM_SUBSAMPLING": self.sinogram_subsampling,
             "AXIS_URL_1": axis_urls_1,
             "AXIS_URL_2": axis_urls_2,
             "LOOK_AT_STDMAX": self.look_at_stdmax,
-            "NEAR_WX": self.near_wx,
-            "FINE_STEP_X": self.fine_step_x,
+            "NEAR_WX": self.composite_window_size,
+            "FINE_STEP_X": self.composite_fine_step,
             "SCALE_IMG2_TO_IMG1": self.scale_img2_to_img1,
-            "NEAR_POSITION": self.estimated_cor,
+            "NEAR_POSITION": (
+                self.estimated_cor.value
+                if isinstance(self.estimated_cor, Side)
+                else self.estimated_cor
+            ),
             "PADDING_MODE": self.padding_mode,
             "FLIP_LR": self.flip_lr,
             "COMPOSITE_OPTS": self.composite_options,
-            "SIDE": self.side,
             "COR_OPTIONS": self.extra_cor_options,
+            "MOTOR_OFFSET": self.x_rotation_axis_pos_px_offset,
+            "X_ROTATION_AXIS_PIXEL_POSITION": self.x_rotation_axis_pixel_position,
         }
         return _dict
 
@@ -820,8 +665,6 @@ class AxisRP:
             self.calculation_input_type = AxisCalculationInput.from_value(
                 _dict["CALC_INPUT_TYPE"]
             )
-        if "USE_SINOGRAM" in _dict:
-            self.use_sinogram = _dict["USE_SINOGRAM"]
         if "ANGLE_MODE" in _dict:
             self.angle_mode = CorAngleMode.from_value(_dict["ANGLE_MODE"])
         if "SINOGRAM_LINE" in _dict:
@@ -833,13 +676,13 @@ class AxisRP:
         if "LOOK_AT_STDMAX" in _dict:
             self.look_at_stdmax = _dict["LOOK_AT_STDMAX"]
         if "NEAR_WX" in _dict:
-            self.near_wx = _dict["NEAR_WX"]
+            self.composite_window_size = _dict["NEAR_WX"]
         if "FINE_STEP_X" in _dict:
-            self.fine_step_x = _dict["FINE_STEP_X"]
+            self.composite_fine_step = _dict["FINE_STEP_X"]
         if "SCALE_IMG2_TO_IMG1" in _dict:
             self.scale_img2_to_img1 = _dict["SCALE_IMG2_TO_IMG1"]
         if "NEAR_POSITION" in _dict:
-            self.estimated_cor = float(_dict["NEAR_POSITION"])
+            self.estimated_cor = _dict["NEAR_POSITION"]
         if "SINOGRAM_SUBSAMPLING" in _dict:
             self.sinogram_subsampling = _dict["SINOGRAM_SUBSAMPLING"]
         if "PADDING_MODE" in _dict:
@@ -848,8 +691,6 @@ class AxisRP:
             self.flip_lr = bool(_dict["FLIP_LR"])
         if "COMPOSITE_OPTS" in _dict:
             self.composite_options = _dict["COMPOSITE_OPTS"]
-        if "SIDE" in _dict:
-            self.side = _dict["SIDE"]
         self.extra_cor_options = _dict.get("COR_OPTIONS", "")
 
     def copy(self, axis_params, copy_axis_url=True, copy_flip_lr=True):
@@ -858,17 +699,17 @@ class AxisRP:
         self.frame_width = axis_params.frame_width
         self.set_relative_value(axis_params.relative_cor_value)
         self.calculation_input_type = axis_params.calculation_input_type
-        self.use_sinogram = axis_params.use_sinogram
         self.angle_mode = axis_params.angle_mode
         self.sinogram_line = axis_params.sinogram_line
         self.sinogram_subsampling = axis_params.sinogram_subsampling
         self.look_at_stdmax = axis_params.look_at_stdmax
-        self.near_wx = axis_params.near_wx
-        self.fine_step_x = axis_params.fine_step_x
+        self.composite_window_size = axis_params.composite_window_size
+        self.composite_fine_step = axis_params.composite_fine_step
         self.scale_img2_to_img1 = axis_params.scale_img2_to_img1
         self.estimated_cor = axis_params.estimated_cor
+        self.x_rotation_axis_pixel_position = axis_params.x_rotation_axis_pixel_position
+        self.x_rotation_axis_pos_px_offset = axis_params.x_rotation_axis_pos_px_offset
         self.padding_mode = axis_params.padding_mode
-        self.side = axis_params.side
         self.composite_options = axis_params.composite_options
         self.extra_cor_options = axis_params.extra_cor_options
         if copy_axis_url:
@@ -895,56 +736,63 @@ class AxisRP:
             AxisMode.sliding_window_radios,
             AxisMode.sliding_window_sinogram,
         ):
-            extra_info = f"side: {self.side}, use sinogram: {self.use_sinogram}"
+            extra_info = f"side: {self.estimated_cor}"
             results = ", ".join((results, extra_info))
         return results
 
     def get_nabu_cor_options_as_dict(self) -> str:
         options = {}
-        if self.mode is AxisMode.near:
-            self.side = "near"
-        request_side = len(AXIS_MODE_METADATAS[self.mode].valid_sides) > 0
-        if request_side:
-
-            if self.side == "near":
-                options["side"] = self.composite_options.get(
-                    "near_pos", self.estimated_cor
-                )
-            else:
-                options["side"] = self.side
+        # provide side. Scalar if a first guess is provided else a value in ('left', 'right', 'center', 'all')
+        if (
+            isinstance(self.estimated_cor, Side)
+            and AXIS_MODE_METADATAS[self.mode].valid_sides
+        ):
+            options["side"] = self.estimated_cor.value
+        elif AXIS_MODE_METADATAS[self.mode].allows_estimated_cor_as_numerical_value:
+            options["side"] = self.estimated_cor
+
+        if self.mode in (AxisMode.composite_coarse_to_fine, AxisMode.near):
+            options["near_width"] = self.composite_options.get(
+                "near_width", DEFAULT_CMP_NEAR_WIDTH
+            )
+            options["theta_interval"] = self.composite_options.get(
+                "theta_interval", DEFAULT_CMP_THETA
+            )
+            options["oversampling"] = self.composite_options.get(
+                "oversampling", DEFAULT_CMP_OVERSAMPLING
+            )
+            options["n_subsampling_y"] = self.composite_options.get(
+                "n_subsampling_y", DEFAULT_CMP_N_SUBSAMPLING_Y
+            )
+            options["take_log"] = self.composite_options.get(
+                "take_log", DEFAULT_CMP_TAKE_LOG
+            )
 
-        if self.side == "near":
-            near_width = self.composite_options.get("near_width", 20.0)
-            options["near_width"] = near_width
+        # provide radio indices or sinogram index
+        if self.mode.requires_radio_indices:
+            # warning: nabu expect radio angles to be in rad, in nxtomo and tomwer they are in degrees
+            options["radio_angles"] = (
+                numpy.deg2rad(self.axis_url_1.angle or 0.0),
+                numpy.deg2rad(self.axis_url_2.angle or 180.0),
+            )
+        if self.mode.requires_sinogram_index:
+            options["slice_idx"] = self.sinogram_line
 
         # append "extra_cor_options" to already handled cor options
+        # expected values: low_pass, high_pass
         extra_cor_options = self.extra_cor_options.replace(" ", "")
 
         if extra_cor_options != "":
             for opt in self.extra_cor_options.replace(" ", "").split(";"):
                 if len(opt.split("=")) == 2:
                     key, value = opt.split("=")
-                    options[key] = value
+                    if key in ("low_pass", "high_pass"):
+                        value = float(value)
+                        options[key] = value
+                    else:
+                        _logger.warning(
+                            f"key {key} is not recognized by nabu. Ignore it."
+                        )
                 else:
-                    _logger.info(f"ignore option {opt}. Invalid synthax")
+                    _logger.info(f"ignore option {opt}. Invalid syntax")
         return options
-
-    @deprecated(replacement="get_nabu_cor_options_as_str", since_version="1.1")
-    def get_nabu_cor_options(self) -> str:
-        return self.get_nabu_cor_options_as_str()
-
-    def get_nabu_cor_options_as_str(self) -> str:
-        """return cor option for nabu"""
-
-        def cast_key_value(key, value):
-            if key in ("side",):
-                return f"{key}='{value}'"
-            else:
-                return f"{key}={value}"
-
-        return " ; ".join(
-            [
-                cast_key_value(key, value)
-                for key, value in self.get_nabu_cor_options_as_dict().items()
-            ]
-        )

tomwer/core/process/reconstruction/axis/projectiontype.py

@@ -1,32 +1,4 @@
 # coding: utf-8
-# /*##########################################################################
-#
-# Copyright (c) 2016-2017 European Synchrotron Radiation Facility
-#
-# Permission is hereby granted, free of charge, to any person obtaining a copy
-# of this software and associated documentation files (the "Software"), to deal
-# in the Software without restriction, including without limitation the rights
-# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-# copies of the Software, and to permit persons to whom the Software is
-# furnished to do so, subject to the following conditions:
-#
-# The above copyright notice and this permission notice shall be included in
-# all copies or substantial portions of the Software.
-#
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-# THE SOFTWARE.
-#
-# ###########################################################################*/
-
-__authors__ = ["H. Payno"]
-__license__ = "MIT"
-__date__ = "15/10/2019"
-
 
 from silx.utils.enum import Enum as _Enum