can compute matches! no errors! yay!

scripts/runtests.sh

@@ -11,4 +11,4 @@ DIR=$(cd -P "$(dirname "$SOURCE")" >/dev/null 2>&1 && pwd)
 BUILD_DIR=$(realpath ${DIR}/../build)
 
 printf '\033c'
-${BUILD_DIR}/test_image
+${BUILD_DIR}/test_frame

scripts/watch_tests.sh

@@ -10,4 +10,4 @@ DIR=$(cd -P "$(dirname "$SOURCE")" >/dev/null 2>&1 && pwd)
 
 BUILD_DIR=$(realpath ${DIR}/../build)
 
-echo ${BUILD_DIR}/test_image | entr -r ${DIR}/runtests.sh
+echo ${BUILD_DIR}/test_frame | entr -r ${DIR}/runtests.sh

src/CMakeLists.txt

@@ -39,6 +39,7 @@ set (LIBDART_OPENMVG_INCLUDE_DIRS ${CMAKE_CURRENT_SOURCE_DIR}/src)
 
 find_package(JPEG REQUIRED)
 find_package(TIFF REQUIRED)
+find_package(OpenCV REQUIRED)
 
 add_subdirectory(${CMAKE_CURRENT_SOURCE_DIR}/extlib/cwalk)
 
@@ -59,13 +60,17 @@ set(SKIP_INSTALL_ALL OFF CACHE BOOL "" FORCE) # we only want lib
 add_definitions(${PNG_DEFINITIONS})
 
 add_library(${LIBDART_OPENMVG} SHARED
+  "mvg_override/describer/akaze.hpp"
   "frame.cxx"
   "streamingview.cxx"
   "image.cxx"
+  "util.cpp"
 )
 
 set(CEREAL_INCLUDE_DIR ${OpenMVG_DIR}/../../../include/openMVG_dependencies/cereal/include/cereal/)
 
+dump_cmake_variables("^opencv")
+
 target_include_directories(
   ${LIBDART_OPENMVG}
   PRIVATE
@@ -73,6 +78,7 @@ target_include_directories(
   ${PNG_INCLUDE_DIRS}
   ${ARCHIMEDES_INCLUDE_DIRS}
   ${CEREAL_INCLUDE_DIR}
+  ${OpenCV_INCLUDE_DIRS}
 )
 
 target_link_libraries(
@@ -81,6 +87,7 @@ target_link_libraries(
    jpeg
    tiff
    png
+   ${OpenCV_LIBS}
    OpenMVG::openMVG_image
    OpenMVG::openMVG_numeric
    OpenMVG::openMVG_features
@@ -102,6 +109,11 @@ add_executable(
   ${CMAKE_CURRENT_SOURCE_DIR}/tests/test_image.cxx
 )
 
+add_executable(
+  test_frame
+  ${CMAKE_CURRENT_SOURCE_DIR}/tests/test_frame.cxx
+)
+
 target_link_libraries(
   test_image
   cunit
@@ -116,6 +128,20 @@ target_link_libraries(
   OpenMVG::openMVG_exif
 )
 
+target_link_libraries(
+  test_frame
+  cunit
+  cwalk
+  ${LIBDART_OPENMVG}
+  png
+  OpenMVG::openMVG_image
+  OpenMVG::openMVG_numeric
+  OpenMVG::openMVG_features
+  OpenMVG::openMVG_sfm
+  OpenMVG::openMVG_features
+  OpenMVG::openMVG_exif
+)
+
 target_include_directories(
   test_image
   PRIVATE
@@ -124,9 +150,18 @@ target_include_directories(
   ${CEREAL_INCLUDE_DIR}
 )
 
-set_target_properties(test_image
-PROPERTIES
-LINKER_LANGUAGE CXX
+target_include_directories(
+  test_frame
+  PRIVATE
+  ${LIBDART_OPENMVG_INCLUDE_DIRS}
+  ${OpenMVG_INCLUDE_DIRS}/src
+  ${CEREAL_INCLUDE_DIR}
+)
+
+set_target_properties(
+  test_image
+  PROPERTIES
+  LINKER_LANGUAGE CXX
 )
 
 add_test (
@@ -134,4 +169,9 @@ add_test (
   COMMAND test_image
 )
 
+add_test (
+  NAME test_frame
+  COMMAND test_frame
+)
+
 target_compile_definitions(${LIBDART_OPENMVG} PUBLIC DART_SHARED_LIB)

src/frame.cxx

@@ -1,5 +1,7 @@
 #include "frame.h"
 #include <iostream>
+#include <stdexcept>
+#include <stdlib.h>
 
 FILE *make_buffer(const uint8_t *data, const size_t data_len)
 {
@@ -70,8 +72,20 @@ Frame *new_frame_from_handle(FILE *stream, int w, int h, int depth)
   return f;
 }
 
+void clean_frame(Frame *f)
+{
+  fclose(f->stream);
+  free(f);
+}
+
 #ifdef __cplusplus
 
+DartOpenMvg::Frame::Frame(const DartOpenMvg::Frame &frame)
+{
+  cFrame = frame.cFrame;
+  // mRegions = std::unique_ptr<openMVG::features::Regions>(frame.mRegions.get());
+}
+
 openMVG::image::Image<u_char> DartOpenMvg::imageFromFrame(const CFrame *frame)
 {
   rewind(frame->stream);
@@ -90,39 +104,103 @@ openMVG::image::Image<u_char> DartOpenMvg::imageFromFrame(const CFrame *frame)
   return openMVG::image::Image<uint8_t>(eigenMatrix);
 }
 
-void DartOpenMvg::Frame::calculateFeatures()
+DartOpenMvg::Frames::Frames(openMVG::sfm::Bundle_Adjustment_Ceres::BA_Ceres_options &options)
 {
-  using namespace openMVG::image;
-  using namespace openMVG::features;
-  auto desc = SIFT_Anatomy_Image_describer(SIFT_Anatomy_Image_describer::Params());
-  auto image = imageFromFrame(cFrame);
-  mRegions = desc.Describe(image);
+  mAdjustment = openMVG::sfm::Bundle_Adjustment_Ceres(options);
 }
 
-openMVG::image::Image<u_char> DartOpenMvg::Frame::getMvgImage() {
-  return imageFromFrame(this->cFrame);
+void DartOpenMvg::Frames::add_frame(FILE *handle, int w, int h, int depth)
+{
+  CFrame *f = new_frame_from_handle(handle, w, h, depth);
+  mFrames.push_back(
+      Frame(f));
 }
 
 void DartOpenMvg::Frames::computeMatches()
 {
-  using namespace openMVG::matching;
-  using namespace openMVG::matching_image_collection;
-  using namespace openMVG::sfm;
+
+  // Match the pairs as a sequence
+  // Within openMvg::matching_image_collection::Matcher
+  // they matcha gainst *ALL* images. However, since we know the order of the
+  // image sequences (video frames), we'll stick to the sequence order.
+  for (size_t i = 0; i < mFrames.size() - 1; ++i)
+  {
+    Frame &frame1 = mFrames[i];
+    Frame &frame2 = mFrames[i + 1];
+    frame1.calculateFeatures();
+    frame2.calculateFeatures();
+    auto regions1 = frame1.mRegions.get();
+    auto regions2 = frame2.mRegions.get();
+    if (!regions1)
+    {
+      std::string msg = std::string("No frame. Did you remember to calculate regions for frame ") + std::to_string(i) + "?";
+      throw std::out_of_range(msg);
+    }
+
+    // regions1->Load();
+    std::cerr << "Loading " << std::to_string(regions1->RegionCount()) << " regions" << std::endl;
+
+    auto is_binary = regions1->IsBinary();
+
+    // Initialize the matching interface
+    const std::unique_ptr<openMVG::matching::RegionsMatcher> matcher =
+        openMVG::matching::RegionMatcherFactory(openMVG::matching::EMatcherType::HNSW_L2, *regions1);
+    if (!matcher)
+      continue;
+    openMVG::matching::IndMatches vec_putative_matches;
+    matcher->MatchDistanceRatio(0.5, *regions2, vec_putative_matches);
+    if (vec_putative_matches.empty())
+    {
+      return;
+    }
+    mFeatureMap[std::make_pair(i, i + 1)] = vec_putative_matches;
+  }
+};
+
+void DartOpenMvg::Frames::buildTracks()
+{
+  openMVG::tracks::TracksBuilder trackBuilder;
+
+  openMVG::matching::PairWiseMatches matches;
+
+  trackBuilder.Build(mFeatureMap);
+  trackBuilder.Filter();
+  trackBuilder.ExportToSTL(mTracks);
+}
+
+void DartOpenMvg::Frames::adjust()
+{
+  const openMVG::sfm::Optimize_Options ba_refine_options(openMVG::cameras::Intrinsic_Parameter_Type::ADJUST_ALL,
+                                                         openMVG::sfm::Extrinsic_Parameter_Type::ADJUST_ALL, // Adjust camera motion
+                                                         openMVG::sfm::Structure_Parameter_Type::ADJUST_ALL, // Adjust scene structure
+                                                         openMVG::sfm::Control_Point_Parameter(),
+                                                         false);
+  mAdjustment.Adjust(mSfmData, ba_refine_options);
+}
+
+void DartOpenMvg::Frame::calculateFeatures()
+{
   using namespace openMVG::image;
-  Matcher *matcher = nullptr;
+  using namespace openMVG::features;
+  MvgOverride::AKAZE_OCV_Image_describer desc;
+  auto im = imageFromFrame(cFrame);
+  mRegions = desc.Describe(im);
 
-  Regions_Provider provider = Regions_Provider();
+  if (!mRegions.get()) {
+    throw std::range_error("Could not set regions member.");
+  }
+}
 
-  matcher = new Matcher_Regions(0.8f, CASCADE_HASHING_L2);
+void DartOpenMvg::Frames::resection()
+{
+  // openMVG::tracks::TracksUtilsMap::GetFeatIndexPerViewAndTrackId(
+  //   mTracks;
+  // )
+}
 
-  openMVG::Pair_Set pairs = openMVG::Pair_Set();
-  Image im1 = this->at(0).getMvgImage();
-  Image im2 = this->at(1).getMvgImage();
-  auto pair = openMVG::Pair(0, 1);
-  pairs.insert(pair);
-
-  PairWiseMatches map_punitive_matches;
-
-  // matcher->Match(provider, pairs, map_punitive_matches, NULL);
+openMVG::image::Image<u_char> DartOpenMvg::Frame::getMvgImage()
+{
+  return imageFromFrame(this->cFrame);
+}
 
 #endif // __cplusplus

src/frame.h

@@ -8,6 +8,8 @@
 #include <openMVG/matching_image_collection/Matcher_Regions.hpp>
 #include <openMVG/matching_image_collection/Pair_Builder.hpp>
 #include <openMVG/sfm/pipelines/sfm_regions_provider.hpp>
+#include <openMVG/sfm/pipelines/sfm_engine.hpp>
+#include <openMVG/sfm/sfm_data_BA_ceres.hpp>
 #include <openMVG/features/feature.hpp>
 #include <openMVG/features/sift/octaver.hpp>
 #include <openMVG/features/sift/SIFT_Anatomy_Image_Describer.hpp>
@@ -17,10 +19,25 @@
 #include <openMVG/image/image_container.hpp>
 #include <openMVG/image/image_io.hpp>
 #include <openMVG/numeric/numeric.h>
+#include <openMVG/tracks/tracks.hpp>
+#include <opencv2/opencv.hpp>
+#include <string>
+#include <vector>
+#include <memory>
+
+#include <openMVG/matching/indMatch.hpp>
+#include <openMVG/matching_image_collection/Matcher_Regions.hpp>
+#include <openMVG/matching_image_collection/Matcher.hpp>
+#include <openMVG/matching/regions_matcher.hpp>
+#include <openMVG/sfm/pipelines/sfm_regions_provider.hpp>
+#include <openMVG/system/progressinterface.hpp>
+#include <openMVG/system/logger.hpp>
+
 #include <iostream>
 #include <map>
 #include <utility>
 #include "./base.hpp"
+#include "./mvg_override/describer/akaze.hpp"
 
 #ifndef __FRAME_H
 #define __FRAME_H
@@ -44,46 +61,56 @@ namespace DartOpenMvg
 {
     openMVG::image::Image<uint8_t> imageFromFrame(const Frame *);
 
-    class InMemoryMatcherRegions : public openMVG::matching_image_collection::Matcher {
-        void Match(
-            const Pair_Set &,
-            PariWiseMatchesContainer &,
-        ) const override;
-    };
-
     class Frame
     {
     protected:
-        const CFrame *cFrame;
         std::stringstream mStream;
         int mW;
         int mH;
         int mDepth;
-        std::unique_ptr<openMVG::features::Regions> mRegions;
 
     public:
-        Frame(const _Frame *f) : mW(f->w), mH(f->h), mDepth(f->depth)
+        // TODO make this private
+        const CFrame *cFrame;
+        // TODO make this private
+        std::unique_ptr<openMVG::features::Regions> mRegions;
+        Frame(const CFrame *f) : mW(f->w), mH(f->h), mDepth(f->depth)
         {
             cFrame = f;
             uint8_t *buffer_data = NULL;
             size_t len = 0;
+            rewind(f->stream);
             read_buffer(f->stream, &buffer_data, &len);
             mStream = std::stringstream(std::string((char *)buffer_data));
         }
-        openMVG::image::Image<u_char> DartOpenMvg::Frame::getMvgImage();
+        Frame(const Frame &);
+        openMVG::image::Image<u_char> getMvgImage();
         void calculateFeatures();
     };
 
-    typedef std::pair<Frame, Frame> FrameMatchKey;
-    typedef std::map<FrameMatchKey, openMVG::matching::IndMatches> FrameFeatureMatch;
+    typedef std::pair<const Frame &, const Frame &> FrameMatchKey;
+    typedef std::map<std::pair<size_t, size_t>, openMVG::matching::IndMatches> FrameFeatureMatch;
 
-    class Frames : std::vector<Frame>
+    class Frames
     {
 
     protected:
-        FrameFeatureMatch mFeatureMap;
+
     public:
+        // TODO: make private with accessors
+        openMVG::matching::PairWiseMatches mFeatureMap;
+        openMVG::tracks::STLMAPTracks mTracks;
+        openMVG::sfm::SfM_Data mSfmData;
+        openMVG::sfm::Bundle_Adjustment_Ceres mAdjustment;
+        std::vector<Frame> mFrames;
+
+        Frames(openMVG::sfm::Bundle_Adjustment_Ceres::BA_Ceres_options &);
+        void add_frame(FILE *, int, int, int);
         void computeMatches();
+        void buildTracks();
+        void adjust();
+        void resection();
+        void resectionAll();
     };
 }
 #endif
@@ -94,4 +121,6 @@ Frame *new_frame_from_handle(FILE *, int, int, int);
 _FFI_PLUGIN
 Frame *new_frame_from_data(const uint8_t *, const size_t, int, int, int);
 
+void frame_cleanup(Frame *);
+
 #endif // __FRAME_H

src/mvg_override/describer/akaze.hpp

@@ -0,0 +1,152 @@
+// This file is part of OpenMVG, an Open Multiple View Geometry C++ library.
+
+// Copyright (c) 2012, 2013 Pierre MOULON.
+
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+// The <cereal/archives> headers are special and must be included first.
+#include <cereal/archives/json.hpp>
+
+#include "openMVG/image/image_io.hpp"
+#include "openMVG/features/regions_factory_io.hpp"
+#include "openMVG/sfm/sfm.hpp"
+#include "openMVG/system/timer.hpp"
+
+/// OpenCV Includes
+#include <opencv2/opencv.hpp>
+#include <opencv2/core/eigen.hpp>
+
+#include <cstdlib>
+#include <fstream>
+
+#ifndef __MVG_OVERRIDE_DESCRIBER_AKAZE_H
+#define __MVG_OVERRIDE_DESCRIBER_AKAZE_H
+
+
+namespace MvgOverride
+{
+
+  using namespace openMVG;
+  using namespace openMVG::image;
+  using namespace openMVG::features;
+  using namespace openMVG::sfm;
+
+  enum eGeometricModel
+  {
+    FUNDAMENTAL_MATRIX = 0,
+    ESSENTIAL_MATRIX = 1,
+    HOMOGRAPHY_MATRIX = 2
+  };
+
+  enum ePairMode
+  {
+    PAIR_EXHAUSTIVE = 0,
+    PAIR_CONTIGUOUS = 1,
+    PAIR_FROM_FILE = 2
+  };
+
+  ///
+  //- Create an Image_describer interface that use an OpenCV feature extraction method
+  // i.e. with the AKAZE detector+descriptor
+  //--/!\ If you use a new Regions type you define and register it in
+  //   "openMVG/features/regions_factory.hpp" file.
+  ///
+  // Reuse the existing AKAZE floating point Keypoint.
+  typedef features::AKAZE_Float_Regions AKAZE_OpenCV_Regions;
+  // Define the Interface
+  class AKAZE_OCV_Image_describer : public Image_describer
+  {
+  public:
+    using Regions_type = AKAZE_OpenCV_Regions;
+
+    cv::Ptr<cv::Feature2D> extractor;
+
+    AKAZE_OCV_Image_describer() : Image_describer()
+    {
+      extractor = cv::AKAZE::create(cv::AKAZE::DESCRIPTOR_KAZE);
+    }
+
+    bool Set_configuration_preset(EDESCRIBER_PRESET preset) override
+    {
+      return false;
+    }
+    /**
+    @brief Detect regions on the image and compute their attributes (description)
+    @param image Image.
+    @param mask 8-bit gray image for keypoint filtering (optional).
+       Non-zero values depict the region of interest.
+    @return regions The detected regions and attributes (the caller must delete the allocated data)
+    */
+    std::unique_ptr<Regions> Describe(
+        const Image<unsigned char> &image,
+        const Image<unsigned char> *mask = nullptr) override
+    {
+      return Describe_AKAZE_OCV(image, mask);
+    }
+
+    /**
+    @brief Detect regions on the image and compute their attributes (description)
+    @param image Image.
+    @param mask 8-bit gray image for keypoint filtering (optional).
+       Non-zero values depict the region of interest.
+    @return regions The detected regions and attributes (the caller must delete the allocated data)
+    */
+    std::unique_ptr<Regions_type> Describe_AKAZE_OCV(
+        const Image<unsigned char> &image,
+        const Image<unsigned char> *mask = nullptr)
+    {
+      auto regions = std::unique_ptr<Regions_type>(new Regions_type);
+
+      cv::Mat img;
+      cv::eigen2cv(image.GetMat(), img);
+
+      cv::Mat m_mask;
+      if (mask != nullptr)
+      {
+        cv::eigen2cv(mask->GetMat(), m_mask);
+      }
+
+      std::vector<cv::KeyPoint> vec_keypoints;
+      cv::Mat m_desc;
+
+      extractor->detectAndCompute(img, m_mask, vec_keypoints, m_desc);
+
+      if (!vec_keypoints.empty())
+      {
+        // reserve some memory for faster keypoint saving
+        regions->Features().reserve(vec_keypoints.size());
+        regions->Descriptors().reserve(vec_keypoints.size());
+
+        using DescriptorT = Descriptor<float, 64>;
+        DescriptorT descriptor;
+        int cpt = 0;
+        for (auto i_keypoint = vec_keypoints.begin(); i_keypoint != vec_keypoints.end(); ++i_keypoint, ++cpt)
+        {
+          const SIOPointFeature feat((*i_keypoint).pt.x, (*i_keypoint).pt.y, (*i_keypoint).size, (*i_keypoint).angle);
+          regions->Features().push_back(feat);
+
+          memcpy(descriptor.data(),
+                 m_desc.ptr<typename DescriptorT::bin_type>(cpt),
+                 DescriptorT::static_size * sizeof(DescriptorT::bin_type));
+          regions->Descriptors().push_back(descriptor);
+        }
+      }
+      return regions;
+    };
+
+    /// Allocate Regions type depending of the Image_describer
+    std::unique_ptr<Regions> Allocate() const override
+    {
+      return std::unique_ptr<Regions_type>(new Regions_type);
+    }
+
+    template <class Archive>
+    void serialize(Archive &ar)
+    {
+    }
+  };
+}
+
+#endif // __MVG_OVERRIDE_DESCRIBER_AKAZE_H

src/tests/test_frame.cxx

@@ -0,0 +1,130 @@
+#include <sys/stat.h>
+#include <archives/binary.hpp>
+#include <CUnit/Basic.h>
+#include <errno.h>
+#include <ios>
+#include "../image.h"
+#include "../streamingview.hpp"
+#include "../util.h"
+#include <cwalk.h>
+#ifdef __cplusplus
+#include <iostream>
+#endif // __cplusplus
+
+#define STRLEN 2048
+#define FRAME_COUNT 200
+
+typedef Frame CFrame;
+
+char *framePaths[FRAME_COUNT];
+
+#define HERE __FILE__
+
+int setUp(void)
+{
+    char framesDir[STRLEN];
+    size_t length;
+    char framePathTpl[STRLEN];
+    cwk_path_get_dirname(HERE, &length); // archimedes_mobile_lib/src/tests
+    cwk_path_join(HERE, "../../../assets/test/frames", framesDir, STRLEN);
+    cwk_path_join(framesDir, "%04d.png", framePathTpl, STRLEN);
+    // Set the length to be the length of the "template" plus enough room
+    // for the sequence number.
+    size_t pathLen = strlen(framePathTpl) + 5;
+    for (size_t i = 0; i < FRAME_COUNT; ++i)
+    {
+        framePaths[i] = (char *)calloc(pathLen, sizeof(char *));
+        snprintf(framePaths[i], pathLen, framePathTpl, i+1, 4);
+        printf("Load frame %s\n", framePaths[i]);
+    }
+    return 0;
+}
+
+CFrame *get_nth_frame(size_t frame_num)
+{
+    struct stat statbuf;
+    if (stat(framePaths[frame_num], &statbuf) < 0)
+    {
+        // std::cerr << "ERROR reading \"" << framePaths << "\"" << std::endl;
+        std::cerr << std::string("Reading \"") << std::string(framePaths[frame_num]) << std::string("\"") << std::endl;
+        throw new std::ios_base::failure(std::string(strerror(errno)));
+    }
+    FILE *handle = fopen(framePaths[frame_num], "r");
+
+    CFrame *f = new_frame_from_handle(
+        handle,
+        768,
+        768,
+        64);
+    return f;
+}
+
+int tearDown(void)
+{
+    for (int i = 0; i < FRAME_COUNT; ++i)
+    {
+        free(framePaths[i]);
+    }
+    return 0;
+}
+
+void test_calculate_fetures(void)
+{
+    Frame *f = get_nth_frame(0);
+    DartOpenMvg::Frame frame(f);
+
+    frame.calculateFeatures();
+    CU_ASSERT_TRUE(frame.mRegions.get()->RegionCount() > 0);
+}
+
+void test_compute_matches(void)
+{
+    Frame *f1 = get_nth_frame(0);
+    Frame *f2 = get_nth_frame(1);
+    DartOpenMvg::Frame frame1(f1), frame2(f2);
+    openMVG::sfm::Bundle_Adjustment_Ceres::BA_Ceres_options opts;
+    DartOpenMvg::Frames frames(opts);
+
+    frame1.calculateFeatures();
+    frame2.calculateFeatures();
+
+    frames.mFrames.push_back(frame1);
+    frames.mFrames.push_back(frame2);
+
+    CU_ASSERT_EQUAL(frames.mFeatureMap.size(), 0)
+
+    frames.computeMatches();
+
+    CU_ASSERT_TRUE(frames.mFeatureMap.size() > 0);
+}
+
+int main()
+{
+    CU_pSuite pSuite = NULL;
+
+    /* initialize the CUnit test registry */
+    if (CUE_SUCCESS != CU_initialize_registry())
+        return CU_get_error();
+
+    /* add a suite to the registry */
+    pSuite = CU_add_suite("FrameSuite", setUp, tearDown);
+    if (NULL == pSuite)
+    {
+        CU_cleanup_registry();
+        return CU_get_error();
+    }
+
+    /* add the tests to the suite */
+    if ((NULL == CU_add_test(pSuite, "frame features can be calculated", test_calculate_fetures)) ||
+        (NULL == CU_add_test(pSuite, "matches can be computed", test_compute_matches)))
+    {
+        CU_cleanup_registry();
+        return CU_get_error();
+    }
+
+    /* Run all tests using the CUnit Basic interface */
+    CU_basic_set_mode(CU_BRM_VERBOSE);
+    CU_basic_run_tests();
+    CU_cleanup_registry();
+    return CU_get_error();
+}

src/tests/test_image.cxx

@@ -2,6 +2,7 @@
 #include <CUnit/Basic.h>
 #include "../image.h"
 #include "../streamingview.hpp"
+#include "../util.h"
 #include <cwalk.h>
 #ifdef __cplusplus
 #include <iostream>
@@ -12,41 +13,6 @@
 FILE *imageHandle = NULL;
 char frame1Path[STRLEN];
 
-/*
- * Read the contents of a file into an array
- * path: path to the file
- * contents: array we'll write to that contains the contents of the file.
- */
-size_t read_file(const char *path, uint8_t **contents)
-{
-    FILE *file = fopen(path, "rb");
-    if (file == NULL)
-    {
-        printf("Error: Unable to open file.\n");
-        return 0;
-    }
-
-    // Determine the file size
-    fseek(file, 0, SEEK_END);
-    size_t file_size = ftell(file);
-    rewind(file);
-
-    // Allocate memory for the contents array
-    *contents = (uint8_t *)malloc(file_size);
-    if (*contents == NULL)
-    {
-        printf("Error: Unable to allocate memory.\n");
-        fclose(file);
-        return 0;
-    }
-
-    // Read the file contents into the array
-    fread(*contents, 1, file_size, file);
-    fclose(file);
-
-    return file_size;
-}
-
 #define HERE __FILE__
 
 int setUp(void)

src/util.cpp

@@ -0,0 +1,31 @@
+#include "./util.h"
+
+size_t read_file(const char *path, uint8_t **contents)
+{
+    FILE *file = fopen(path, "rb");
+    if (file == NULL)
+    {
+        printf("Error: Unable to open file.\n");
+        return 0;
+    }
+
+    // Determine the file size
+    fseek(file, 0, SEEK_END);
+    size_t file_size = ftell(file);
+    rewind(file);
+
+    // Allocate memory for the contents array
+    *contents = (uint8_t *)malloc(file_size);
+    if (*contents == NULL)
+    {
+        printf("Error: Unable to allocate memory.\n");
+        fclose(file);
+        return 0;
+    }
+
+    // Read the file contents into the array
+    fread(*contents, 1, file_size, file);
+    fclose(file);
+
+    return file_size;
+}

src/util.h

@@ -0,0 +1,10 @@
+#include <stdlib.h>
+#include <stdio.h>
+#include <stdint.h>
+
+/*
+ * Read the contents of a file into an array
+ * path: path to the file
+ * contents: array we'll write to that contains the contents of the file.
+ */
+size_t read_file(const char *path, uint8_t **contents);

src/workflow.h

@@ -0,0 +1,14 @@
+#include <vector>
+
+#ifndef __WORKFLOW_H
+#define __WORKFLOW_H
+
+#ifdef __cplusplus
+namespace DartOpenmvg {
+    class MvgWorkflow {
+        MvgWorkflow();
+    };
+}
+#endif // __cplusplus
+
+#endif // __WORKFLOW_H