Allow image IO for value_types other than uint8_t (#26)

fixed IO for images with value_type != uint8

Author: ukoethe

.travis.yml

@@ -41,7 +41,7 @@ install:
         export CXX=clang++ CC=clang;
         conda install libcxx clangdev -c QuantStack -c conda-forge
       fi
-    - conda install cmake openimageio libsndfile boost zlib xtensor=0.15.5 -c QuantStack -c conda-forge
+    - conda install cmake openimageio libsndfile boost zlib xtensor=0.15.6 -c QuantStack -c conda-forge
     - export LDFLAGS="${LDFLAGS} -Wl,-rpath,$CONDA_PREFIX/lib"
     - export LINKFLAGS="${LDFLAGS}"
     - mkdir build

CMakeLists.txt

@@ -44,6 +44,9 @@ message(STATUS "Building xtensor-io v${${PROJECT_NAME}_VERSION}")
 find_package(xtensor REQUIRED)
 message(STATUS "Found xtensor: ${xtensor_INCLUDE_DIRS}/xtensor")
 
+find_package(xtl REQUIRED)
+message(STATUS "Found xtl: ${xtl_INCLUDE_DIRS}/xtl")
+
 # Find OpenImageIO
 set(CMAKE_MODULE_PATH "${CMAKE_MODULE_PATH}" "${CMAKE_SOURCE_DIR}/modules")
 

include/xtensor-io/ximage.hpp

@@ -12,8 +12,10 @@
 #include <cstddef>
 #include <stdexcept>
 #include <string>
+#include <memory>
 
 #include <xtensor/xarray.hpp>
+#include <xtensor/xmath.hpp>
 #include <xtensor/xeval.hpp>
 
 #include "xtensor_io_config.hpp"
@@ -46,73 +48,128 @@ namespace xt
     template <class T = unsigned char>
     xarray<T> load_image(std::string filename)
     {
-        // TODO handle types better
-        OIIO::ImageInput* in = OIIO::ImageInput::open(filename);
+        auto close_file  =  [](OIIO::ImageInput * file)
+                            {
+                                file->close();
+                                OIIO::ImageInput::destroy(file);
+                            };
+
+        std::unique_ptr<OIIO::ImageInput, decltype(close_file)> in(OIIO::ImageInput::open(filename), close_file);
         if (!in)
         {
-            // something went wrong
-            throw std::runtime_error("Error reading image.");
+            throw std::runtime_error("load_image(): Error reading image '" + filename + "'.");
         }
+
         const OIIO::ImageSpec& spec = in->spec();
-        int xres = spec.width;
-        int yres = spec.height;
-        int channels = spec.nchannels;
 
         // allocate memory
         auto image = xarray<T>::from_shape({static_cast<std::size_t>(spec.height),
                                             static_cast<std::size_t>(spec.width),
                                             static_cast<std::size_t>(spec.nchannels)});
 
-        in->read_image(OIIO::TypeDesc::UINT8, image.raw_data());
-        in->close();
-        OIIO::ImageInput::destroy(in);
+        in->read_image(OIIO::BaseTypeFromC<T>::value, image.raw_data());
 
         return image;
     }
 
+        /** \brief Pass options to dump_image().
+        */
+    struct dump_image_options
+    {
+            /** \brief Initialize options to default values.
+            */
+        dump_image_options()
+        : spec(0,0,0)
+        , autoconvert(true)
+        {
+            spec.attribute("CompressionQuality", 90);
+        }
+
+            /** \brief Forward an attribute to an OpenImageIO ImageSpec.
+
+                See the documentation of OIIO::ImageSpec::attribute() for a list
+                of supported attributes.
+
+                Default: "CompressionQuality" = 90
+            */
+        template <class T>
+        dump_image_options & attribute(OIIO::string_view name, T const & v)
+        {
+            spec.attribute(name, v);
+            return *this;
+        }
+
+        OIIO::ImageSpec spec;
+        bool autoconvert;
+    };
 
     /**
      * Save image to disk.
      * The desired image format is deduced from ``filename``.
      * Supported formats are those supported by OpenImageIO.
      * Most common formats are supported (jpg, png, gif, bmp, tiff).
+     * The shape of the array must be ``HEIGHT x WIDTH`` or ``HEIGHT x WIDTH x CHANNELS``.
      *
      * @param filename The path to the desired file
      * @param data Image data
-     * @param quality If saving in a compressed format such as JPEG, setting the quality
-     *                will select how strong the compression will reduce the image quality.
-     *                Quality is an integer from 100 (best image quality, less compression)
-     *                to 0 (worst image quality, low filesize).
+     * @param options Pass a dump_image_options object to fine-tune image export
      */
     template <class E>
-    void dump_image(std::string filename, const xexpression<E>& data, int quality = 90)
+    void dump_image(std::string filename, const xexpression<E>& data,
+                    dump_image_options const & options = dump_image_options())
     {
-        auto&& ex = eval(data.derived_cast());
+        using value_type = typename std::decay_t<decltype(data.derived_cast())>::value_type;
 
-        XTENSOR_PRECONDITION(ex.dimension() == 2 || ex.dimension() == 3,
+        auto shape = data.derived_cast().shape();
+        XTENSOR_PRECONDITION(shape.size() == 2 || shape.size() == 3,
             "dump_image(): data must have 2 or 3 dimensions (channels must be last).");
 
-        OIIO::ImageOutput* out = OIIO::ImageOutput::create(filename);
+        auto close_file  =  [](OIIO::ImageOutput * file)
+                            {
+                                file->close();
+                                OIIO::ImageOutput::destroy(file);
+                            };
+
+        std::unique_ptr<OIIO::ImageOutput, decltype(close_file)> out(OIIO::ImageOutput::create(filename), close_file);
         if (!out)
         {
-            // something went wrong
             throw std::runtime_error("dump_image(): Error opening file '" + filename + "' to write image.");
         }
 
-        int channels = ex.dimension() == 2
-                           ? 1
-                           : static_cast<int>(ex.shape()[2]);
+        OIIO::ImageSpec spec = options.spec;
 
-        OIIO::ImageSpec spec(static_cast<int>(ex.shape()[1]),
-                             static_cast<int>(ex.shape()[0]),
-                             channels, OIIO::TypeDesc::UINT8);
-
-        spec.attribute("CompressionQuality", quality);
+        spec.width     = static_cast<int>(shape[1]);
+        spec.height    = static_cast<int>(shape[0]);
+        spec.nchannels = (shape.size() == 2)
+                           ? 1
+                           : static_cast<int>(shape[2]);
+        spec.format    = OIIO::BaseTypeFromC<value_type>::value;
 
         out->open(filename, spec);
-        out->write_image(OIIO::TypeDesc::UINT8, ex.raw_data());
-        out->close();
-        OIIO::ImageOutput::destroy(out);
+
+        auto && ex = eval(data.derived_cast());
+        if(out->spec().format != OIIO::BaseTypeFromC<value_type>::value)
+        {
+            // OpenImageIO changed the target type because the file format doesn't support value_type.
+            // It will do automatic conversion, but the data should be in the range 0...1
+            // for good results.
+            auto mM = minmax(ex)();
+
+            if(mM[0] != mM[1])
+            {
+                using real_t = real_promote_type_t<value_type>;
+                auto && normalized = eval((real_t(1.0) / (mM[1] - mM[0])) * (ex - mM[0]));
+                out->write_image(OIIO::BaseTypeFromC<real_t>::value, normalized.raw_data());
+            }
+            else
+            {
+                out->write_image(OIIO::BaseTypeFromC<value_type>::value, ex.raw_data());
+            }
+        }
+        else
+        {
+            out->write_image(OIIO::BaseTypeFromC<value_type>::value, ex.raw_data());
+        }
     }
 }
 

test/test_ximage.cpp

@@ -9,6 +9,7 @@
 #include "gtest/gtest.h"
 #include "xtensor/xoperation.hpp"
 #include "xtensor/xview.hpp"
+#include "xtensor/xio.hpp"
 
 #include "xtensor-io/ximage.hpp"
 
@@ -62,9 +63,18 @@ namespace xt
 
     TEST(ximage, save_png)
     {
-        dump_image("files/dump_test.png", test_image_rgb);
-        auto img = load_image("files/dump_test.png");
-        EXPECT_TRUE(all(equal(test_image_rgb, img)));
+        {
+            // save as 'unsigned char'
+            dump_image("files/dump_test.png", test_image_rgb);
+            auto img = load_image("files/dump_test.png");
+            EXPECT_TRUE(all(equal(test_image_rgb, img)));
+        }
+        {
+            // save as 'int'
+            dump_image("files/dump_test.png", 1*test_image_rgb);
+            auto img = load_image("files/dump_test.png");
+            EXPECT_TRUE(all(equal(test_image_rgb, img)));
+        }
     }
 
     TEST(ximage, save_gif)
@@ -82,4 +92,21 @@ namespace xt
         bool test = (amax(img - img_large)() <= 50);
         EXPECT_TRUE(test);
     }
-}
+
+    TEST(ximage, float_img)
+    {
+        xarray<float> test_float(test_image_rgb);
+
+        // TIFF supports float pixels
+        dump_image("files/dump_test_float.tif", test_float);
+        auto img = load_image<float>("files/dump_test_float.tif");
+        EXPECT_EQ(test_float, img);
+
+        // PNG does not support float pixels => test automatic conversion
+        dump_image("files/dump_test_float.png", test_float);
+        auto cimg = load_image("files/dump_test_float.png");
+        EXPECT_EQ(test_image_rgb, cimg);
+        img = load_image<float>("files/dump_test_float.png");
+        EXPECT_TRUE(allclose(test_float, 255.0*img));
+    }
+}

test/test_xnpz.cpp

@@ -62,7 +62,7 @@ namespace xt
         }
         // this is date + time == 4 bytes per file + once in global header
         std::size_t unequal_allowed = (n_zipped_files + 2) * 4;
-        if (unequal != unequal_allowed)
+        if (unequal > unequal_allowed)
         {
             std::stringstream ss;
             ss << "Number of unequal elements not allowed size: " << unequal << " vs allowed: " << unequal_allowed << std::endl;