KeyframeSelection: Add support for several output extension files

Keyframes may be written as JPG, PNG or EXR files. If the EXR format is
selected, the storage data type can be specified as well.

src/aliceVision/keyframe/KeyframeSelector.cpp

@@ -5,7 +5,6 @@
 // You can obtain one at https://mozilla.org/MPL/2.0/.
 
 #include "KeyframeSelector.hpp"
-#include <aliceVision/image/all.hpp>
 #include <aliceVision/sensorDB/parseDatabase.hpp>
 #include <aliceVision/system/Logger.hpp>
 
@@ -370,7 +369,9 @@ bool KeyframeSelector::computeScores(const std::size_t rescaledWidth, const std:
 
 bool KeyframeSelector::writeSelection(const std::vector<std::string>& brands,
                                       const std::vector<std::string>& models,
-                                      const std::vector<float>& mmFocals) const
+                                      const std::vector<float>& mmFocals,
+                                      const std::string& outputExtension,
+                                      const image::EStorageDataType storageDataType) const
 {
     image::Image<image::RGBColor> image;
     camera::PinholeRadialK3 queryIntrinsics;
@@ -422,7 +423,7 @@ bool KeyframeSelector::writeSelection(const std::vector<std::string>& brands,
 
             fs::path folder = _outputFolder;
             std::ostringstream filenameSS;
-            filenameSS << std::setw(5) << std::setfill('0') << pos << ".exr";
+            filenameSS << std::setw(5) << std::setfill('0') << pos << "." << outputExtension;
             const auto filepath = (processedOutputFolder / fs::path(filenameSS.str())).string();
 
             image::ImageWriteOptions options;
@@ -432,6 +433,10 @@ bool KeyframeSelector::writeSelection(const std::vector<std::string>& brands,
                 options.toColorSpace(image::EImageColorSpace::AUTO);
             }
 
+            if (storageDataType != image::EStorageDataType::Undefined && outputExtension == "exr"){
+                options.storageDataType(storageDataType);
+            }
+
             image::writeImage(filepath, image, options, metadata);
             ALICEVISION_LOG_DEBUG("Wrote selected keyframe " << pos);
         }

src/aliceVision/keyframe/KeyframeSelector.hpp

@@ -7,6 +7,7 @@
 #pragma once
 
 #include <aliceVision/dataio/FeedProvider.hpp>
+#include <aliceVision/image/all.hpp>
 
 #include <OpenImageIO/imageio.h>
 #include <opencv2/optflow.hpp>
@@ -98,10 +99,13 @@ class KeyframeSelector
      * @param[in] brands brand name for each camera
      * @param[in] models model name for each camera
      * @param[in] mmFocals focal in millimeters for each camera
+     * @param[in] outputExtension file extension of the written keyframes
+     * @param[in] storageDataType EXR storage data type for the output keyframes (ignored when the extension is not EXR)
      * @return true if all the selected keyframes were successfully written, false otherwise
      */
     bool writeSelection(const std::vector<std::string>& brands, const std::vector<std::string>& models,
-                    const std::vector<float>& mmFocals) const;
+                    const std::vector<float>& mmFocals, const std::string& outputExtension,
+                    const image::EStorageDataType storageDataType = image::EStorageDataType::Undefined) const;
 
     /**
      * @brief Export the computed sharpness and optical flow scores to a CSV file

src/software/utils/CMakeLists.txt

@@ -223,6 +223,7 @@ if(ALICEVISION_HAVE_OPENCV)
     SOURCE main_keyframeSelection.cpp
     FOLDER ${FOLDER_SOFTWARE_UTILS}
     LINKS aliceVision_system
+          aliceVision_image
           aliceVision_keyframe
           ${OPENIMAGEIO_LIBRARIES}
           Boost::program_options

src/software/utils/main_keyframeSelection.cpp

@@ -4,6 +4,7 @@
 // v. 2.0. If a copy of the MPL was not distributed with this file,
 // You can obtain one at https://mozilla.org/MPL/2.0/.
 
+#include <aliceVision/image/all.hpp>
 #include <aliceVision/keyframe/KeyframeSelector.hpp>
 #include <aliceVision/system/Logger.hpp>
 #include <aliceVision/system/cmdline.hpp>
@@ -20,11 +21,13 @@
 #define ALICEVISION_SOFTWARE_VERSION_MAJOR 3
 #define ALICEVISION_SOFTWARE_VERSION_MINOR 0
 
-using namespace aliceVision::keyframe;
+using namespace aliceVision;
 
 namespace po = boost::program_options;
 namespace fs = boost::filesystem;
 
+const std::string supportedExtensions = "exr, jpg, png";
+
 int aliceVision_main(int argc, char** argv)
 {
     // Command-line parameters
@@ -45,6 +48,9 @@ int aliceVision_main(int argc, char** argv)
     std::size_t rescaledWidth = 720;        // width of the rescaled frames; 0 if no rescale is performed (smart selection)
     std::size_t sharpnessWindowSize = 200;  // sliding window's size in sharpness computation (smart selection)
     std::size_t flowCellSize = 90;          // size of the cells within a frame used to compute the optical flow (smart selection)
+    std::string outputExtension = "exr";    // file extension of the written keyframes
+    image::EStorageDataType exrDataType =   // storage data type for EXR output files
+        image::EStorageDataType::Float;
 
     // Debug options
     bool exportScores = false;              // export the sharpness and optical flow scores to a CSV file
@@ -79,7 +85,11 @@ int aliceVision_main(int argc, char** argv)
             "\t- For the regular method, 0 = no limit. 'minFrameStep' and 'maxFrameStep' will always be respected, "
             "so combining them with this parameter might cause the selection to stop before reaching the end of the "
             "input sequence(s).\n"
-            "\t- For the smart method, the default value is set to 2000.");
+            "\t- For the smart method, the default value is set to 2000.")
+        ("outputExtension", po::value<std::string>(&outputExtension)->default_value(outputExtension),
+            "File extension of the output keyframes.")
+        ("storageDataType", po::value<image::EStorageDataType>(&exrDataType)->default_value(exrDataType),
+            ("Storage data type for EXR output files: " + image::EStorageDataType_informations()).c_str());
 
     po::options_description regularAlgorithmParams("Regular algorithm parameters");
     regularAlgorithmParams.add_options()
@@ -160,6 +170,12 @@ int aliceVision_main(int argc, char** argv)
         return EXIT_FAILURE;
     }
 
+    if (supportedExtensions.find(outputExtension) == std::string::npos) {
+        ALICEVISION_LOG_ERROR("Unsupported extension for the output file. Supported extensions are: "
+                              << supportedExtensions);
+        return EXIT_FAILURE;
+    }
+
     brands.resize(nbCameras);
     models.resize(nbCameras);
     mmFocals.resize(nbCameras);
@@ -180,7 +196,7 @@ int aliceVision_main(int argc, char** argv)
     }
 
     // Initialize KeyframeSelector
-    KeyframeSelector selector(mediaPaths, sensorDbPath, outputFolder);
+    keyframe::KeyframeSelector selector(mediaPaths, sensorDbPath, outputFolder);
 
     // Set frame-related algorithm parameters
     selector.setMinFrameStep(minFrameStep);
@@ -213,7 +229,7 @@ int aliceVision_main(int argc, char** argv)
         selector.processRegular();
 
     // Write selected keyframes
-    selector.writeSelection(brands, models, mmFocals);
+    selector.writeSelection(brands, models, mmFocals, outputExtension, exrDataType);
 
     // If debug options are set, export the scores as a CSV file and / or the motion vectors as images
     if (exportScores)