Merge 19c2e33 into 754153f

mantidimaging/core/io/loader/loader.py

@@ -2,20 +2,27 @@
 # SPDX - License - Identifier: GPL-3.0-or-later
 import os
 from dataclasses import dataclass
-from logging import getLogger
+from logging import getLogger, Logger
+from pathlib import Path
 from typing import Tuple, List
 
 import numpy as np
 
 from mantidimaging.core.data import Images
 from mantidimaging.core.data.dataset import Dataset
 from mantidimaging.core.io.loader import img_loader
-from mantidimaging.core.io.utility import (DEFAULT_IO_FILE_FORMAT, get_file_names, get_prefix, get_file_extension)
-from mantidimaging.core.utility.data_containers import ImageParameters
+from mantidimaging.core.io.utility import (DEFAULT_IO_FILE_FORMAT, get_file_names, get_prefix, get_file_extension,
+                                           find_images, find_first_file_that_is_possibly_a_sample, find_log,
+                                           find_180deg_proj)
+from mantidimaging.core.utility.data_containers import ImageParameters, LoadingParameters
 from mantidimaging.core.utility.imat_log_file_parser import IMATLogFile
 
 LOG = getLogger(__name__)
 
+DEFAULT_IS_SINOGRAM = False
+DEFAULT_PIXEL_SIZE = 0
+DEFAULT_PIXEL_DEPTH = "float32"
+
 
 def _fitsread(filename):
     """
@@ -63,8 +70,8 @@ def supported_formats():
         fits_available = False  # pragma: no cover
 
     avail_list = \
-        (['fits', 'fit'] if fits_available else []) + \
-        (['tif', 'tiff'] if skio_available else [])
+        (['fits', 'fit', '.fits', '.fit'] if fits_available else []) + \
+        (['tif', 'tiff', '.tif', '.tiff'] if skio_available else [])
 
     return avail_list
 
@@ -190,3 +197,108 @@ def load(input_path=None,
         LOG.debug('No metadata file found')
 
     return dataset
+
+
+def find_and_verify_sample_log(sample_directory: str, image_filenames: list):
+    sample_log = find_log(dirname=Path(sample_directory), log_name=sample_directory)
+
+    log = load_log(sample_log)
+    log.raise_if_angle_missing(image_filenames)
+
+    return sample_log
+
+
+def create_loading_parameters_for_file_path(file_path: str, logger: Logger = None):
+    sample_file = find_first_file_that_is_possibly_a_sample(file_path)
+    if sample_file is None:
+        return
+
+    loading_parameters = LoadingParameters()
+    loading_parameters.dtype = DEFAULT_PIXEL_DEPTH
+    loading_parameters.pixel_size = DEFAULT_PIXEL_SIZE
+    loading_parameters.sinograms = DEFAULT_IS_SINOGRAM
+    loading_parameters.name = os.path.basename(sample_file)
+    _, image_format = os.path.splitext(sample_file)
+    sample_directory = os.path.dirname(sample_file)
+    last_file_info = read_in_file_information(sample_directory,
+                                              in_prefix=get_prefix(sample_file),
+                                              in_format=image_format)
+
+    try:
+        sample_log = find_and_verify_sample_log(sample_directory, last_file_info.filenames)
+    except FileNotFoundError:
+        sample_log = None
+
+    loading_parameters.sample = ImageParameters(input_path=sample_directory,
+                                                format=image_format,
+                                                prefix=get_prefix(sample_file),
+                                                log_file=sample_log)
+
+    # Flat before
+    flat_before_images = find_images(Path(sample_directory),
+                                     "Flat",
+                                     suffix="Before",
+                                     look_without_suffix=True,
+                                     image_format=image_format,
+                                     logger=logger)
+    if len(flat_before_images) > 0:
+        flat_before_image = flat_before_images[0]
+        flat_before_directory = os.path.dirname(flat_before_image)
+        flat_before_log = find_log(Path(sample_directory), flat_before_directory, logger)
+
+        loading_parameters.flat_before = ImageParameters(input_path=flat_before_directory,
+                                                         format=image_format,
+                                                         prefix=get_prefix(flat_before_image),
+                                                         log_file=flat_before_log)
+
+    # Flat after
+    flat_after_images = find_images(Path(sample_directory),
+                                    "Flat",
+                                    suffix="After",
+                                    image_format=image_format,
+                                    logger=logger)
+    if len(flat_after_images) > 0:
+        flat_after_image = flat_after_images[0]
+        flat_after_directory = os.path.dirname(flat_after_image)
+        flat_after_log = find_log(Path(sample_directory), flat_after_directory, logger)
+
+        loading_parameters.flat_after = ImageParameters(input_path=flat_after_directory,
+                                                        format=image_format,
+                                                        prefix=get_prefix(flat_after_image),
+                                                        log_file=flat_after_log)
+
+    # Dark before
+    dark_before_images = find_images(Path(sample_directory),
+                                     "Dark",
+                                     suffix="Before",
+                                     look_without_suffix=True,
+                                     image_format=image_format,
+                                     logger=logger)
+    if len(dark_before_images) > 0:
+        dark_before_image = dark_before_images[0]
+        dark_before_directory = os.path.dirname(dark_before_image)
+        loading_parameters.dark_before = ImageParameters(input_path=dark_before_directory,
+                                                         prefix=get_prefix(dark_before_image),
+                                                         format=image_format)
+
+    # Dark after
+    dark_after_images = find_images(Path(sample_directory),
+                                    "Dark",
+                                    suffix="After",
+                                    image_format=image_format,
+                                    logger=logger)
+    if len(dark_after_images) > 0:
+        dark_after_image = dark_after_images[0]
+        dark_after_directory = os.path.dirname(dark_after_image)
+        loading_parameters.dark_after = ImageParameters(input_path=dark_after_directory,
+                                                        prefix=get_prefix(dark_after_image),
+                                                        format=image_format)
+
+    # 180 Degree projection
+    proj_180deg = find_180deg_proj(Path(sample_directory), image_format, logger)
+    if proj_180deg != "":
+        loading_parameters.proj_180deg = ImageParameters(input_path=proj_180deg,
+                                                         prefix=get_prefix(proj_180deg),
+                                                         format=image_format)
+
+    return loading_parameters

mantidimaging/core/io/loader/test/loader_test.py

@@ -1,14 +1,16 @@
 # Copyright (C) 2020 ISIS Rutherford Appleton Laboratory UKRI
 # SPDX - License - Identifier: GPL-3.0-or-later
-
-import unittest
+import os
 from unittest import mock
 
-from mantidimaging.core.io.loader import load_stack
 from mantidimaging.core.io import loader
+from mantidimaging.core.io.loader import load_stack
+from mantidimaging.core.io.loader.loader import create_loading_parameters_for_file_path, DEFAULT_PIXEL_DEPTH, \
+    DEFAULT_PIXEL_SIZE, DEFAULT_IS_SINOGRAM
+from mantidimaging.test_helpers import FileOutputtingTestCase
 
 
-class LoaderTest(unittest.TestCase):
+class LoaderTest(FileOutputtingTestCase):
     def test_raise_on_invalid_format(self):
         self.assertRaises(ValueError, loader.load, "/some/path", file_names=["/somefile"], in_format='txt')
 
@@ -26,3 +28,123 @@ def test_load_stack(self, get_file_names_mock: mock.Mock, load_mock: mock.Mock):
         get_file_names_mock.assert_called_once_with(path="/path/to/file/that/is",
                                                     img_format="tif",
                                                     prefix="/path/to/file/that/is/fake.ti")
+
+    def _create_test_sample(self):
+        # Logs
+        with open(os.path.join(self.output_directory, "Tomo_log.txt"), "w") as f:
+            f.write("log")
+        with open(os.path.join(self.output_directory, "Flat_After_log.txt"), "w") as f:
+            f.write("log")
+        with open(os.path.join(self.output_directory, "Flat_Before_log.txt"), "w") as f:
+            f.write("log")
+
+        # Flat
+        os.mkdir(os.path.join(self.output_directory, "Flat_Before"))
+        os.mkdir(os.path.join(self.output_directory, "Flat_After"))
+        for ii in range(0, 10):
+            with open(os.path.join(self.output_directory, "Flat_Before", f"Flat_Before_00{ii}.tif"), "wb") as f:
+                f.write(b"\0")
+
+            with open(os.path.join(self.output_directory, "Flat_After", f"Flat_After_00{ii}.tif"), "wb") as f:
+                f.write(b"\0")
+
+        # Dark
+        os.mkdir(os.path.join(self.output_directory, "Dark_Before"))
+        os.mkdir(os.path.join(self.output_directory, "Dark_After"))
+        for ii in range(0, 10):
+            with open(os.path.join(self.output_directory, "Dark_Before", f"Dark_Before_00{ii}.tif"), "wb") as f:
+                f.write(b"\0")
+
+            with open(os.path.join(self.output_directory, "Dark_After", f"Dark_After_00{ii}.tif"), "wb") as f:
+                f.write(b"\0")
+
+        # Tomo
+        os.mkdir(os.path.join(self.output_directory, "Tomo"))
+        for ii in range(0, 200):
+            with open(os.path.join(self.output_directory, "Tomo", f"Tomo_00{ii}.tif"), "wb") as f:
+                f.write(b"\0")
+
+        # 180 degree projection
+        os.mkdir(os.path.join(self.output_directory, "180deg"))
+        with open(os.path.join(self.output_directory, "180deg", "180deg_000.tif"), "wb") as f:
+            f.write(b"\0")
+
+    @mock.patch("mantidimaging.core.io.loader.loader.find_and_verify_sample_log")
+    @mock.patch("mantidimaging.core.io.loader.loader.read_in_file_information")
+    def test_create_loading_parameters_for_file_path(self, mock_read_in_file_information,
+                                                     mock_find_and_verify_sample_log):
+        self._create_test_sample()
+        tomo_dir = os.path.join(self.output_directory, "Tomo")
+        tomo_prefix = os.path.join(tomo_dir, "Tomo")
+        image_format = ".tif"
+        flat_before_dir = os.path.join(self.output_directory, "Flat_Before")
+        flat_before_prefix = os.path.join(flat_before_dir, "Flat_Before")
+        flat_before_log = os.path.join(self.output_directory, "Flat_Before_log.txt")
+
+        flat_after_dir = os.path.join(self.output_directory, "Flat_After")
+        flat_after_prefix = os.path.join(flat_after_dir, "Flat_After")
+        flat_after_log = os.path.join(self.output_directory, "Flat_After_log.txt")
+
+        dark_before_dir = os.path.join(self.output_directory, "Dark_Before")
+        dark_before_prefix = os.path.join(dark_before_dir, "Dark_Before")
+
+        dark_after_dir = os.path.join(self.output_directory, "Dark_After")
+        dark_after_prefix = os.path.join(dark_after_dir, "Dark_After")
+
+        proj_180_file_prefix = os.path.join(self.output_directory, "180deg", "180deg")
+        proj_180_file = proj_180_file_prefix + "_000.tif"
+
+        lp = create_loading_parameters_for_file_path(self.output_directory)
+
+        mock_read_in_file_information.assert_called_once_with(tomo_dir, in_prefix=tomo_prefix, in_format=image_format)
+        mock_find_and_verify_sample_log.assert_called_once_with(tomo_dir,
+                                                                mock_read_in_file_information.return_value.filenames)
+        self.assertEqual(DEFAULT_PIXEL_DEPTH, lp.dtype)
+        self.assertEqual(DEFAULT_PIXEL_SIZE, lp.pixel_size)
+        self.assertEqual(DEFAULT_IS_SINOGRAM, lp.sinograms)
+
+        # Sample checking
+        sample = lp.sample
+        self.assertEqual(image_format, sample.format)
+        self.assertEqual(None, sample.indices)
+        self.assertEqual(tomo_dir, sample.input_path)
+        self.assertEqual(mock_find_and_verify_sample_log.return_value, sample.log_file)
+        self.assertEqual(tomo_prefix, sample.prefix)
+
+        # Flat before checking
+        flat_before = lp.flat_before
+        self.assertEqual(image_format, flat_before.format)
+        self.assertEqual(None, flat_before.indices)
+        self.assertEqual(flat_before_log, flat_before.log_file)
+        self.assertEqual(flat_before_dir, flat_before.input_path)
+        self.assertEqual(flat_before_prefix, flat_before.prefix)
+
+        # Flat after checking
+        flat_after = lp.flat_after
+        self.assertEqual(image_format, flat_after.format)
+        self.assertEqual(None, flat_after.indices)
+        self.assertEqual(flat_after_log, flat_after.log_file)
+        self.assertEqual(flat_after_dir, flat_after.input_path)
+        self.assertEqual(flat_after_prefix, flat_after.prefix)
+
+        # Dark before checking
+        dark_before = lp.dark_before
+        self.assertEqual(image_format, dark_before.format)
+        self.assertEqual(None, dark_before.indices)
+        self.assertEqual(dark_before_dir, dark_before.input_path)
+        self.assertEqual(dark_before_prefix, dark_before.prefix)
+
+        # Dark after checking
+        dark_after = lp.dark_after
+        self.assertEqual(image_format, dark_after.format)
+        self.assertEqual(None, dark_after.indices)
+        self.assertEqual(dark_after_dir, dark_after.input_path)
+        self.assertEqual(dark_after_prefix, dark_after.prefix)
+
+        # 180 degree checking
+        proj180 = lp.proj_180deg
+        self.assertEqual(image_format, proj180.format)
+        self.assertEqual(None, proj180.indices)
+        self.assertEqual(proj_180_file, proj180.input_path)
+        self.assertEqual(None, proj180.log_file)
+        self.assertEqual(proj_180_file_prefix, proj180.prefix)

mantidimaging/core/io/test/utility_test.py

@@ -2,6 +2,7 @@
 # SPDX - License - Identifier: GPL-3.0-or-later
 
 import os
+from pathlib import Path
 
 from mantidimaging.helper import initialise_logging
 from mantidimaging.core.io import utility
@@ -33,3 +34,9 @@ def test_get_file_names(self):
 
         # Expect to find the .tiff file
         self.assertEqual([tiff_filename], found_files)
+
+    def test_find_log(self):
+        with open(os.path.join(self.output_directory, "../sample_log.txt"), 'w') as f:
+            f.write("sample logs")
+
+        self.assertNotEqual("", utility.find_log(Path(self.output_directory), "sample"))