Make a library for writing and reading tiff, added tests (#347)

* removed Makefile for moench and integrated the build in CMake
* broke out tiff reading and writing to its own library
* moved tiff includes to include/sls
* moved tiffio source to src
* removed incorrectly used bps
* cleanup and tests for tiffio
* removed using namespace std from header
* some fixing for moench04
* Program for offline processing renamed

Co-authored-by: Anna Bergamaschi <anna.bergamaschi@psi.ch>

slsDetectorCalibration/tiffio/CMakeLists.txt

@@ -0,0 +1,14 @@
+find_package(TIFF REQUIRED)
+add_library(tiffio STATIC src/tiffIO.cpp)
+target_include_directories(tiffio PUBLIC include/)
+target_link_libraries(tiffio 
+    PUBLIC 
+        TIFF::TIFF 
+    PRIVATE 
+        slsProjectWarnings
+        slsProjectOptions
+)
+
+if(SLS_USE_TESTS)
+    add_subdirectory(tests)
+endif()

slsDetectorCalibration/tiffio/include/sls/tiffIO.h

@@ -0,0 +1,16 @@
+// SPDX-License-Identifier: LGPL-3.0-or-other
+// Copyright (C) 2021 Contributors to the SLS Detector Package
+#pragma once
+#include <cstdint>
+
+//Write 32bit float data to tiff file
+//Always returns nullptr, prints message on failure
+void *WriteToTiff(float *imgData, const char *imgname, int nrow, int ncol);
+
+//Read 32bit float data from tiff file, returns pointer to data and sets
+//image dimensions in the out parameters nrow, ncol. 
+//Returns nullptr on failure
+//The caller is responsible to deallocate the memory that the returned
+//pointer points to. 
+float *ReadFromTiff(const char *imgname, uint32_t &nrow, uint32_t &ncol);
+

slsDetectorCalibration/tiffio/src/tiffIO.cpp

@@ -0,0 +1,48 @@
+// SPDX-License-Identifier: LGPL-3.0-or-other
+// Copyright (C) 2021 Contributors to the SLS Detector Package
+
+#include "sls/tiffIO.h"
+#include <iostream>
+#include <tiffio.h>
+
+void *WriteToTiff(float *imgData, const char *imgname, int nrow, int ncol) {
+    constexpr uint32_t sampleperpixel = 1;
+    TIFF *tif = TIFFOpen(imgname, "w");
+    if (tif) {
+        TIFFSetField(tif, TIFFTAG_IMAGEWIDTH, ncol);
+        TIFFSetField(tif, TIFFTAG_IMAGELENGTH, nrow);
+        TIFFSetField(tif, TIFFTAG_SAMPLESPERPIXEL, sampleperpixel);
+        TIFFSetField(tif, TIFFTAG_BITSPERSAMPLE, 32);
+        TIFFSetField(tif, TIFFTAG_ORIENTATION, ORIENTATION_BOTLEFT);
+        TIFFSetField(tif, TIFFTAG_PLANARCONFIG, PLANARCONFIG_CONTIG);
+        TIFFSetField(tif, TIFFTAG_PHOTOMETRIC, PHOTOMETRIC_MINISBLACK);
+        TIFFSetField(tif, TIFFTAG_SAMPLEFORMAT, SAMPLEFORMAT_IEEEFP);
+        TIFFSetField(tif, TIFFTAG_ROWSPERSTRIP,
+                     TIFFDefaultStripSize(tif, ncol * sampleperpixel));
+
+        for (int irow = 0; irow < nrow; irow++) {
+            TIFFWriteScanline(tif, &imgData[irow * ncol], irow, 0);
+        }
+        TIFFClose(tif);
+    } else {
+        std::cout << "could not open file " << imgname << " for writing\n";
+    }
+    return nullptr;
+}
+
+float *ReadFromTiff(const char *imgname, uint32_t &nrow, uint32_t &ncol) {
+    TIFF *tif = TIFFOpen(imgname, "r");
+    if (tif) {
+        TIFFGetField(tif, TIFFTAG_IMAGEWIDTH, &ncol);
+        TIFFGetField(tif, TIFFTAG_IMAGELENGTH, &nrow);
+        float *imgData = new float[ncol * nrow];
+        for (uint32_t irow = 0; irow < nrow; ++irow) {
+            TIFFReadScanline(tif, &imgData[irow * ncol], irow);
+        }
+        TIFFClose(tif);
+        return imgData;
+    } else {
+        std::cout << "could not open file " << imgname << " for reading\n";
+        return nullptr;
+    }
+}

slsDetectorCalibration/tiffio/tests/CMakeLists.txt

@@ -0,0 +1,5 @@
+# SPDX-License-Identifier: LGPL-3.0-or-other
+# Copyright (C) 2021 Contributors to the SLS Detector Package
+target_sources(tests PRIVATE 
+                ${CMAKE_CURRENT_SOURCE_DIR}/test-tiffio.cpp
+)

slsDetectorCalibration/tiffio/tests/test-tiffio.cpp

@@ -0,0 +1,54 @@
+
+
+#include "catch.hpp"
+#include "sls/tiffIO.h"
+#include <cstdio>
+#include <ftw.h>
+#include <iostream>
+#include <vector>
+
+/* Call-back to the 'remove()' function called by nftw() */
+static int remove_callback(const char *pathname,
+                           __attribute__((unused)) const struct stat *sbuf,
+                           __attribute__((unused)) int type,
+                           __attribute__((unused)) struct FTW *ftwb) {
+    return remove(pathname);
+}
+
+TEST_CASE("Write and read back data from tiff file") {
+
+    std::vector<float> data{1, 2, 3, 4, 5, 6, 7, 8, 9};
+
+    /* Create the temporary directory */
+    char tmp[] = "/tmp/tmpdir.XXXXXX";
+    char *tmp_dirname = mkdtemp(tmp);
+
+    if (tmp_dirname == NULL) {
+        perror("tempdir: error: Could not create tmp directory");
+        CHECK(false);
+    }
+
+    std::string fname = std::string(tmp_dirname) + std::string("/test.tif");
+    std::cout << "Writing to: " << fname<< '\n';
+    
+    WriteToTiff(data.data(), fname.c_str(), 3, 3);
+
+    //Readback
+    uint32_t nrow, ncol;
+    float* ptr = ReadFromTiff(fname.c_str(), nrow, ncol);
+    CHECK(nrow == 3);
+    CHECK(ncol == 3);
+    uint32_t size = nrow*ncol;
+    for (uint32_t i = 0; i!=size; ++i){
+        CHECK(data[i] == ptr[i]);
+    }
+
+    delete[] ptr;
+
+    /* Delete the temporary directory */
+    if (nftw(tmp_dirname, remove_callback, FOPEN_MAX,
+             FTW_DEPTH | FTW_MOUNT | FTW_PHYS) == -1) {
+        perror("tempdir: error: ");
+        exit(EXIT_FAILURE);
+    }
+}