can compute matches! no errors! yay!

README.md

@@ -5,6 +5,9 @@ OpenMVG bindings for dart.
 [OpenMVG](https://openmvg.readthedocs.io/) is an AI graphics application that supports
 feature detection and surface-from-motion capabilities
 
+If you'd like to contribute, financially, please visit https://ko-fi.com/damngood and
+mention "libdart_openmvg" in your message.
+
 ## Getting Started
 
 This project is a starting point for a Flutter

ffigen.yaml

@@ -3,11 +3,12 @@ name: LibDartOpenMVG
 description: |
   Dart bindings for the OpenMVG library.
 output: 'lib/libdart_openmvg_generated.dart'
-compiler-opts: '-I/usr/include -L /usr/lib/ -lpng'
 headers:
   entry-points:
+    - 'src/frame.h'
     - 'src/image.h'
   include-directives:
+    - 'src/frame.h'
     - 'src/image.h'
 preamble: |
   // ignore_for_file: always_specify_types

lib/libdart_openmvg_generated.dart

@@ -25,50 +25,44 @@ class LibDartOpenMVG {
           lookup)
       : _lookup = lookup;
 
-  ffi.Pointer<ImageResult> image_result_new(
-    ffi.Pointer<u_char> arg0,
-    int data_len,
+  ffi.Pointer<FILE> make_buffer(
+    ffi.Pointer<ffi.Uint8> arg0,
+    int arg1,
   ) {
-    return _image_result_new(
+    return _make_buffer(
       arg0,
-      data_len,
+      arg1,
     );
   }
 
-  late final _image_result_newPtr = _lookup<
+  late final _make_bufferPtr = _lookup<
       ffi.NativeFunction<
-          ffi.Pointer<ImageResult> Function(
-              ffi.Pointer<u_char>, ffi.Size)>>('image_result_new');
-  late final _image_result_new = _image_result_newPtr.asFunction<
-      ffi.Pointer<ImageResult> Function(ffi.Pointer<u_char>, int)>();
+          ffi.Pointer<FILE> Function(
+              ffi.Pointer<ffi.Uint8>, ffi.Size)>>('make_buffer');
+  late final _make_buffer = _make_bufferPtr
+      .asFunction<ffi.Pointer<FILE> Function(ffi.Pointer<ffi.Uint8>, int)>();
 
-  ffi.Pointer<ImageResult> image_result_new_error(
-    int error_t,
+  int read_buffer(
+    ffi.Pointer<FILE> arg0,
+    ffi.Pointer<ffi.Pointer<ffi.Uint8>> arg1,
+    ffi.Pointer<ffi.Size> arg2,
   ) {
-    return _image_result_new_error(
-      error_t,
-    );
-  }
-
-  late final _image_result_new_errorPtr =
-      _lookup<ffi.NativeFunction<ffi.Pointer<ImageResult> Function(ffi.Int)>>(
-          'image_result_new_error');
-  late final _image_result_new_error = _image_result_new_errorPtr
-      .asFunction<ffi.Pointer<ImageResult> Function(int)>();
-
-  int image_result_free(
-    ffi.Pointer<ImageResult> arg0,
-  ) {
-    return _image_result_free(
+    return _read_buffer(
       arg0,
+      arg1,
+      arg2,
     );
   }
 
-  late final _image_result_freePtr =
-      _lookup<ffi.NativeFunction<ffi.Int Function(ffi.Pointer<ImageResult>)>>(
-          'image_result_free');
-  late final _image_result_free = _image_result_freePtr
-      .asFunction<int Function(ffi.Pointer<ImageResult>)>();
+  late final _read_bufferPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Int Function(
+              ffi.Pointer<FILE>,
+              ffi.Pointer<ffi.Pointer<ffi.Uint8>>,
+              ffi.Pointer<ffi.Size>)>>('read_buffer');
+  late final _read_buffer = _read_bufferPtr.asFunction<
+      int Function(ffi.Pointer<FILE>, ffi.Pointer<ffi.Pointer<ffi.Uint8>>,
+          ffi.Pointer<ffi.Size>)>();
 
   ffi.Pointer<Frame> new_frame_from_handle(
     ffi.Pointer<FILE> arg0,
@@ -115,6 +109,51 @@ class LibDartOpenMVG {
       ffi.Pointer<Frame> Function(
           ffi.Pointer<ffi.Uint8>, int, int, int, int)>();
 
+  ffi.Pointer<ImageResult> image_result_new(
+    ffi.Pointer<u_char> arg0,
+    int data_len,
+  ) {
+    return _image_result_new(
+      arg0,
+      data_len,
+    );
+  }
+
+  late final _image_result_newPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Pointer<ImageResult> Function(
+              ffi.Pointer<u_char>, ffi.Size)>>('image_result_new');
+  late final _image_result_new = _image_result_newPtr.asFunction<
+      ffi.Pointer<ImageResult> Function(ffi.Pointer<u_char>, int)>();
+
+  ffi.Pointer<ImageResult> image_result_new_error(
+    int arg0,
+  ) {
+    return _image_result_new_error(
+      arg0,
+    );
+  }
+
+  late final _image_result_new_errorPtr =
+      _lookup<ffi.NativeFunction<ffi.Pointer<ImageResult> Function(ffi.Int)>>(
+          'image_result_new_error');
+  late final _image_result_new_error = _image_result_new_errorPtr
+      .asFunction<ffi.Pointer<ImageResult> Function(int)>();
+
+  int image_result_free(
+    ffi.Pointer<ImageResult> arg0,
+  ) {
+    return _image_result_free(
+      arg0,
+    );
+  }
+
+  late final _image_result_freePtr =
+      _lookup<ffi.NativeFunction<ffi.Int Function(ffi.Pointer<ImageResult>)>>(
+          'image_result_free');
+  late final _image_result_free = _image_result_freePtr
+      .asFunction<int Function(ffi.Pointer<ImageResult>)>();
+
   ffi.Pointer<ImageResult> archimedes_get_image_data(
     ffi.Pointer<Frame> arg0,
   ) {
@@ -244,6 +283,8 @@ final class _IO_codecvt extends ffi.Opaque {}
 
 final class _IO_wide_data extends ffi.Opaque {}
 
+typedef Frame = _Frame;
+
 final class _ImageResult extends ffi.Struct {
   external ffi.Pointer<u_char> data;
 
@@ -257,4 +298,3 @@ final class _ImageResult extends ffi.Struct {
 typedef u_char = __u_char;
 typedef __u_char = ffi.UnsignedChar;
 typedef ImageResult = _ImageResult;
-typedef Frame = _Frame;

pubspec.yaml

@@ -1,4 +1,4 @@
-name: dart_openmvg
+name: libdart_openmvg
 description: "Dart Bindings for OpenMVG"
 version: 0.0.1
 homepage:

scripts/compilelib.sh

@@ -24,6 +24,4 @@ cmake \
     -DCMAKE_BUILD_TYPE=Debug
 make
 
-printf "\033c"
-
-set +e
+set +e

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_compilelib.sh

@@ -10,5 +10,5 @@ DIR=$(cd -P "$(dirname "$SOURCE")" >/dev/null 2>&1 && pwd)
 
 SRC_DIR=$(realpath ${DIR}/../src)
 
-find ${SRC_DIR} -name "*.c*" -o -name "*.h" -o -name "CMakeLists.txt" | \
+find ${SRC_DIR} -name "*.c*" -o -name "*.h*" -o -name "CMakeLists.txt" | \
     entr -r ${DIR}/compilelib.sh

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,26 +60,34 @@ 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
   ${FFMPEG_INCLUDE_DIRS}
   ${PNG_INCLUDE_DIRS}
   ${ARCHIMEDES_INCLUDE_DIRS}
-  ${OPENMVG_INCLUDE_DIRS}/src
+  ${CEREAL_INCLUDE_DIR}
+  ${OpenCV_INCLUDE_DIRS}
 )
 
-# message("LIBRARIES:" ${OpenMVG_LIBRARIES})
-
 target_link_libraries(
   ${LIBDART_OPENMVG}
    cwalk
    jpeg
    tiff
    png
+   ${OpenCV_LIBS}
    OpenMVG::openMVG_image
    OpenMVG::openMVG_numeric
    OpenMVG::openMVG_features
@@ -93,7 +102,6 @@ set_target_properties(${LIBDART_OPENMVG}
   OUTPUT_NAME ${LIBDART_OPENMVG}
 )
 
-target_link_options(${LIBDART_OPENMVG} PRIVATE "-Wl,-Bstatic")
 target_link_options(${LIBDART_OPENMVG} PRIVATE "-Wl,-Bdynamic")
 
 add_executable(
@@ -101,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
@@ -115,16 +128,40 @@ 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
   ${LIBDART_OPENMVG_INCLUDE_DIRS}
   ${OpenMVG_INCLUDE_DIRS}/src
+  ${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 (
@@ -132,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/base.hpp

@@ -0,0 +1,15 @@
+#ifdef __cplusplus
+#define EXTC extern "C"
+#define START_EXTC_GRP extern "C" {
+#define END_EXTC_GRP }
+#else
+#define EXTC
+#define START_EXTC_GRP
+#define END_EXTC_GRP
+#endif // _CPLUSPLUS
+
+#ifdef __cplusplus
+#  define _FFI_PLUGIN extern "C" __attribute__((visibility("default"))) __attribute__((used))
+#else
+#  define _FFI_PLUGIN __attribute__((visibility("default"))) __attribute__((used))
+#endif // __cplusplus

src/frame.cxx

@@ -0,0 +1,206 @@
+#include "frame.h"
+#include <iostream>
+#include <stdexcept>
+#include <stdlib.h>
+
+FILE *make_buffer(const uint8_t *data, const size_t data_len)
+{
+  FILE *file = fmemopen((void *)data, data_len, "r+");
+
+  if (file == NULL)
+  {
+    perror("Error opening file");
+    return NULL;
+  }
+
+  // Seek to the beginning of the file
+  rewind(file);
+
+  // Write the data to the file
+  fwrite(data, sizeof(uint8_t), data_len, file);
+
+  return file;
+}
+
+int read_buffer(FILE *file, uint8_t **buffer, size_t *length)
+{
+  if (file != NULL)
+  {
+    // Get the file size
+    fseek(file, 0, SEEK_END);
+    (*length) = ftell(file);
+    fseek(file, 0, SEEK_SET);
+
+    // Allocate memory
+    *buffer = (uint8_t *)malloc((*length) * sizeof(char));
+    if (buffer == NULL)
+    {
+      printf("Error: Unable to allocate memory.\n");
+      return 1;
+    }
+
+    // Read file
+    size_t newLen = fread(*buffer, sizeof(char), *length, file);
+    if (newLen == 0)
+    {
+      if (feof(file))
+      {
+        printf("Error: End of file reached.\n");
+        return 2;
+      }
+      printf("Error: Reading file.\n");
+      return 3;
+    }
+    return 4;
+  }
+  return 5;
+}
+
+Frame *new_frame_from_data(const uint8_t *data, const size_t data_len, int w, int h, int depth)
+{
+  FILE *buf = make_buffer(data, data_len);
+  return new_frame_from_handle(buf, w, h, depth);
+}
+
+Frame *new_frame_from_handle(FILE *stream, int w, int h, int depth)
+{
+  Frame *f = (Frame *)malloc(sizeof(Frame));
+  f->stream = stream;
+  f->w = w;
+  f->h = h;
+  f->depth = 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);
+  std::vector<unsigned char> imageData;
+  if (!openMVG::image::ReadPngStream(frame->stream, &imageData, (int *)&(frame->w), (int *)&(frame->h), (int *)&(frame->depth)))
+  {
+    throw std::runtime_error("Could not read stream");
+  };
+  int w = frame->w, h = frame->h;
+  Eigen::Matrix<u_char, Eigen::Dynamic, Eigen::Dynamic, 1> eigenMatrix(frame->w, frame->h);
+  for (int i = 0; i < w * h; ++i)
+  {
+    eigenMatrix(i / h, i % h) = imageData[i];
+  }
+
+  return openMVG::image::Image<uint8_t>(eigenMatrix);
+}
+
+DartOpenMvg::Frames::Frames(openMVG::sfm::Bundle_Adjustment_Ceres::BA_Ceres_options &options)
+{
+  mAdjustment = openMVG::sfm::Bundle_Adjustment_Ceres(options);
+}
+
+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()
+{
+
+  // 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;
+  using namespace openMVG::features;
+  MvgOverride::AKAZE_OCV_Image_describer desc;
+  auto im = imageFromFrame(cFrame);
+  mRegions = desc.Describe(im);
+
+  if (!mRegions.get()) {
+    throw std::range_error("Could not set regions member.");
+  }
+}
+
+void DartOpenMvg::Frames::resection()
+{
+  // openMVG::tracks::TracksUtilsMap::GetFeatIndexPerViewAndTrackId(
+  //   mTracks;
+  // )
+}
+
+openMVG::image::Image<u_char> DartOpenMvg::Frame::getMvgImage()
+{
+  return imageFromFrame(this->cFrame);
+}
+
+#endif // __cplusplus

src/frame.h

@@ -0,0 +1,126 @@
+#include <stdlib.h>
+#include <stdio.h>
+#include <stdint.h>
+#include <string>
+#include <openMVG/matching/cascade_hasher.hpp>
+#include <openMVG/matching/regions_matcher.hpp>
+#include <openMVG/matching_image_collection/Matcher.hpp>
+#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>
+#include <openMVG/features/sift/sift_DescriptorExtractor.hpp>
+#include <openMVG/features/sift/sift_KeypointExtractor.hpp>
+#include <openMVG/features/akaze/AKAZE.hpp>
+#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
+
+typedef struct _Frame
+{
+    FILE *stream;
+    int w;
+    int h;
+    int depth;
+} Frame;
+
+FILE *make_buffer(const uint8_t *, const size_t);
+int read_buffer(FILE *, uint8_t **, size_t *);
+
+#ifdef __cplusplus
+
+typedef Frame CFrame;
+
+namespace DartOpenMvg
+{
+    openMVG::image::Image<uint8_t> imageFromFrame(const Frame *);
+
+    class Frame
+    {
+    protected:
+        std::stringstream mStream;
+        int mW;
+        int mH;
+        int mDepth;
+
+    public:
+        // 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));
+        }
+        Frame(const Frame &);
+        openMVG::image::Image<u_char> getMvgImage();
+        void calculateFeatures();
+    };
+
+    typedef std::pair<const Frame &, const Frame &> FrameMatchKey;
+    typedef std::map<std::pair<size_t, size_t>, openMVG::matching::IndMatches> FrameFeatureMatch;
+
+    class Frames
+    {
+
+    protected:
+
+    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
+
+_FFI_PLUGIN
+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/image.cxx

@@ -1,86 +1,67 @@
 #include "./image.h"
 
 #ifdef __cplusplus
+#include <cereal/archives/binary.hpp>
 #include <openMVG/image/image_io.hpp>
 #include <openMVG/image/image_concat.hpp>
+#include <openMVG/sfm/sfm_view.hpp>
+#include <openMVG/sfm/sfm_view_io.hpp>
+#include <Eigen/src/Core/util/Constants.h>
 #endif // __ cplusplus
 
 _FFI_PLUGIN
-ImageResult *image_result_new(const u_char *data, const size_t data_len) {
-    ImageResult *r  = (ImageResult *) malloc(sizeof(ImageResult));
-    r->data = (u_char *) calloc(sizeof(u_char), data_len);
-    memcpy(r->data, data, data_len * sizeof(u_char));
-    r->data_len = data_len;
-    r->error = 0;
-    return r;
+ImageResult *image_result_new(const u_char *data, const size_t data_len)
+{
+  ImageResult *r = (ImageResult *)malloc(sizeof(ImageResult));
+  r->data = (u_char *)calloc(sizeof(u_char), data_len);
+  memcpy(r->data, data, data_len * sizeof(u_char));
+  r->data_len = data_len;
+  r->error = 0;
+  return r;
 }
 
 _FFI_PLUGIN
-ImageResult *image_result_new_error(const error_t err) {
-    ImageResult *r  = (ImageResult *) malloc(sizeof(ImageResult));
-    r->data = NULL;
-    r->data_len = 0;
-    r->error = err;
-    return r;
+ImageResult *image_result_new_error(const error_t err)
+{
+  ImageResult *r = (ImageResult *)malloc(sizeof(ImageResult));
+  r->data = NULL;
+  r->data_len = 0;
+  r->error = err;
+  return r;
 }
 
 _FFI_PLUGIN
-void free_image_result(ImageResult *image_result) {
-   free(image_result->data);
-   free(image_result);
+void free_image_result(ImageResult *image_result)
+{
+  free(image_result->data);
+  free(image_result);
 }
 
-const Frame *new_frame_from_handle(FILE *stream, int w, int h, int depth)
-{
-  Frame *f = (Frame *)malloc(sizeof(Frame));
-  f->stream = stream;
-  f->w = w;
-  f->h = h;
-  f->depth = depth;
-  return f;
-}
 
-FILE *make_buffer(const uint8_t *data, const size_t data_len)
+std::vector<u_char> DartOpenmvg::get_image_data_as_vector(const Frame *frame)
 {
-  FILE *file = fmemopen((void *)data, data_len, "r+");
-
-  if (file == NULL)
+  rewind(frame->stream);
+  std::vector<unsigned char> imageData;
+  if (!openMVG::image::ReadPngStream(frame->stream, &imageData, (int *)&(frame->w), (int *)&(frame->h), (int *)&(frame->depth)))
   {
-    perror("Error opening file");
-    return NULL;
+    throw std::runtime_error("Could not read stream");
   }
-
-  // Seek to the beginning of the file
-  rewind(file);
-
-  // Write the data to the file
-  fwrite(data, sizeof(uint8_t), data_len, file);
-
-  return file;
-}
-
-_FFI_PLUGIN
-const Frame *
-new_frame_from_data(const uint8_t *data, const size_t data_len, int w, int h, int depth)
-{
-  FILE *buf = make_buffer(data, data_len);
-  return new_frame_from_handle(buf, w, h, depth);
+  return imageData;
 }
 
 #ifdef __cplusplus
 
-extern "C"
-ImageResult *Archimedes::get_image_data(const Frame *frame)
+ImageResult *DartOpenmvg::get_image_data(const Frame *frame)
 {
-  std::vector<unsigned char> imageData;
-  rewind(frame->stream);
-  if (!openMVG::image::ReadPngStream(frame->stream, &imageData, (int *)&(frame->w), (int *)&(frame->h), (int *)&(frame->depth))) {
-    printf("ERROR: Could not read stream!\n");
+  try {
+    const std::vector<u_char> imageData = get_image_data_as_vector(frame);
+    printf("Read %lu bytes.\n", imageData.size());
+    const unsigned char *data = imageData.data();
+    return image_result_new(data, imageData.size());
+  } catch (const std::runtime_error& e) {
+    std::cerr << e.what() << std::endl;
     return image_result_new_error(1);
   }
-  printf("Read %lu bytes.\n", imageData.size());
-  const unsigned char *data = imageData.data();
-  return image_result_new(data, imageData.size());
 }
 
 #endif
@@ -88,18 +69,19 @@ ImageResult *Archimedes::get_image_data(const Frame *frame)
 _FFI_PLUGIN
 ImageResult *archimedes_get_image_data(const Frame *frame)
 {
-  return Archimedes::get_image_data(frame);
+  return DartOpenmvg::get_image_data(frame);
 }
 
-_FFI_PLUGIN
-int Archimedes::images_to_sfm(const Frame **frames, size_t n_frames)
+int DartOpenmvg::images_to_sfm(const Frame **frames, size_t n_frames)
 {
+  // TODO
   
+
   return 0;
 }
 
 _FFI_PLUGIN
 int archimedes_images_to_sfm(const Frame **frames, size_t n_frames)
 {
-  return Archimedes::images_to_sfm(frames, n_frames);
+  return DartOpenmvg::images_to_sfm(frames, n_frames);
 }

src/image.h

@@ -17,6 +17,13 @@
 #include <openMVG/sfm/sfm_view.hpp>
 #include <openMVG/system/timer.hpp>
 #include <openMVG/types.hpp>
+#include <openMVG/tracks/tracks.hpp>
+#include <openMVG/multiview/rotation_averaging.hpp>
+#include <openMVG/multiview/rotation_averaging_l1.hpp>
+#include <openMVG/multiview/triangulation.hpp>
+#include <openMVG/multiview/triangulation_method.hpp>
+#include <openMVG/multiview/triangulation_nview.hpp>
+#include <openMVG/multiview/translation_averaging_solver.hpp>
 
 // SfM Engines
 #include <openMVG/sfm/pipelines/global/GlobalSfM_rotation_averaging.hpp>
@@ -27,35 +34,36 @@
 #include <openMVG/sfm/pipelines/sequential/SfmSceneInitializerMaxPair.hpp>
 #include <openMVG/sfm/pipelines/sequential/SfmSceneInitializerStellar.hpp>
 #include <openMVG/sfm/pipelines/stellar/sfm_stellar_engine.hpp>
+#include <openMVG/sfm/sfm_data.hpp>
+
+#include <openMVG/sfm/pipelines/sfm_features_provider.hpp>
+#include <openMVG/features/sift/octaver.hpp>
+#include <openMVG/features/sift/sift_DescriptorExtractor.hpp>
+#include <openMVG/features/sift/hierarchical_gaussian_scale_space.hpp>
+#include <openMVG/features/sift/sift_keypoint.hpp>
+#include <openMVG/features/sift/SIFT_Anatomy_Image_Describer.hpp>
+#include <openMVG/features/feature.hpp>
+
 #endif // __cplusplus
 
+#include "./base.hpp"
+#include "frame.h"
 #include <stdio.h>
 #include <stdlib.h>
 #include <stdint.h>
+#include <error.h>
 #include <png.h>
 
-#ifdef __cplusplus
-#  define _FFI_PLUGIN extern "C" __attribute__((visibility("default"))) __attribute__((used))
-#else
-#  define _FFI_PLUGIN __attribute__((visibility("default"))) __attribute__((used))
-#endif // __cplusplus
-
 #if defined(__cplusplus)
 
 extern "C" {
     auto png_sig_cm = png_sig_cmp;
 }
 
+
 #endif // __cplusplus
 
-
-typedef struct _Frame
-{
-    FILE *stream;
-    int w;
-    int h;
-    int depth;
-} Frame;
+#define error_t int
 
 
 typedef struct _ImageResult
@@ -72,21 +80,12 @@ ImageResult *image_result_new_error(const error_t);
 _FFI_PLUGIN
 int image_result_free(ImageResult *);
 
-_FFI_PLUGIN
-const Frame *new_frame_from_handle(FILE *, int, int, int);
-_FFI_PLUGIN
-const Frame *
-new_frame_from_data(const uint8_t *, const size_t, int, int, int);
 
 #ifdef __cplusplus
-typedef openMVG::image::Image<openMVG::image::RGBColor> RgbImage;
-typedef std::vector<openMVG::features::AffinePointFeature> FeatureVector;
-typedef openMVG::image::Image<unsigned char> UImage;
-typedef std::vector<openMVG::features::MSER::MSERRegion> RegionVector;
-typedef openMVG::sfm::SfM_Data Sfm_Data;
 
-extern "C" namespace Archimedes
+namespace DartOpenmvg
 {
+    std::vector<u_char> get_image_data_as_vector(const Frame *frame);
     ImageResult *get_image_data(const Frame *);
     int images_to_sfm(const Frame **, size_t);
 }

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/streamingview.cxx

@@ -0,0 +1,22 @@
+#include "streamingview.hpp"
+#include <string.h>
+
+void libdart_openmvg::StreamingView::load(cereal::BinaryInputArchive &ar) const {
+    uint8_t *data = NULL;
+    const size_t dLen1 = (mFrame->w * mFrame->h * mFrame->depth * sizeof(uint8_t));
+    size_t sz1 = sizeof(uint8_t) * dLen1;
+    ar.loadBinary(data, sz1);
+    const size_t dlen2 = sizeof(data) * sizeof(uint8_t);
+    mFrame->stream = make_buffer(data, dlen2);
+    rewind(mFrame->stream);
+}
+
+void libdart_openmvg::StreamingView::save(cereal::BinaryOutputArchive &ar) const {
+    uint8_t * data = NULL;
+    size_t data_len = 0;
+    int ret = 0;
+    if(ret = read_buffer(mFrame->stream, &data, &data_len)) {
+        std::cerr << "ERROR: " << ret << std::endl;
+    }
+    ar.saveBinary(data, data_len);
+}

src/streamingview.hpp

@@ -0,0 +1,23 @@
+#include <archives/binary.hpp>
+#include <openMVG/sfm/sfm_view.hpp>
+#include <stdio.h>
+#include "frame.h"
+
+typedef openMVG::sfm::View View;
+
+namespace libdart_openmvg
+{
+
+    struct StreamingView : View
+    {
+
+    private:
+        Frame *mFrame;
+
+    public:
+        StreamingView(Frame *frame) : mFrame(frame), View () {}
+        void save(cereal::BinaryOutputArchive &) const;
+        void load(cereal::BinaryInputArchive &) const;
+    };
+
+}

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

@@ -1,44 +1,18 @@
+#include <archives/binary.hpp>
 #include <CUnit/Basic.h>
 #include "../image.h"
+#include "../streamingview.hpp"
+#include "../util.h"
 #include <cwalk.h>
+#ifdef __cplusplus
+#include <iostream>
+#endif // __cplusplus
 
 #define STRLEN 2048
 
 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)
@@ -54,10 +28,11 @@ int setUp(void)
 
 int tearDown(void)
 {
-  if (imageHandle) {
-    fclose(imageHandle);
-  }
-  return 0;
+    if (imageHandle)
+    {
+        fclose(imageHandle);
+    }
+    return 0;
 }
 
 void test_create_frame(void)
@@ -67,8 +42,7 @@ void test_create_frame(void)
         imageHandle,
         768,
         768,
-        64
-    );
+        64);
     CU_ASSERT_PTR_NOT_NULL(f->stream);
     CU_ASSERT(f->w == 768);
 }
@@ -89,9 +63,8 @@ void test_archimedes_get_data(void)
         imageHandle,
         768,
         768,
-        64
-    );
-    
+        64);
+
     unsigned char *image_data = NULL;
     size_t image_data_len = 0;
     ImageResult *result = archimedes_get_image_data(f);
@@ -100,32 +73,59 @@ void test_archimedes_get_data(void)
     CU_ASSERT_TRUE(result->data_len > 0);
 }
 
-int main() {
-   CU_pSuite pSuite = NULL;
+void test_archimedes_streamed_view(void)
+{
+    return ;
+    imageHandle = fopen(frame1Path, "rw+");
+    Frame *f = new_frame_from_handle(
+        imageHandle,
+        768,
+        768,
+        64);
 
-   /* initialize the CUnit test registry */
-   if (CUE_SUCCESS != CU_initialize_registry())
-      return CU_get_error();
+    const libdart_openmvg::StreamingView view(f);
 
-   /* add a suite to the registry */
-   pSuite = CU_add_suite("ImageSuite", setUp, tearDown);
-   if (NULL == pSuite) {
-      CU_cleanup_registry();
-      return CU_get_error();
-   }
+    std::stringbuf buffer; // empty stringbuf
 
-   /* add the tests to the suite */
-   if ((NULL == CU_add_test(pSuite, "frame can be created", test_create_frame)) ||
-       (NULL == CU_add_test(pSuite, "frame can be created from data", test_frame_from_data)) ||
-       (NULL == CU_add_test(pSuite, "data can be retrieved from frame", test_archimedes_get_data)))
-   {
-      CU_cleanup_registry();
-      return CU_get_error();
-   }
+    std::ostream os(&buffer); // associate stream buffer to stream
+    std::istream is(&buffer); // associate stream buffer to stream
 
-   /* 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();
+    cereal::BinaryInputArchive inArchive(is);
+    cereal::BinaryOutputArchive outArchive(os);
+
+    // view.save(outArchive);
+    view.load(inArchive);
+}
+
+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("ImageSuite", 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 can be created", test_create_frame)) ||
+        (NULL == CU_add_test(pSuite, "frame can be created from data", test_frame_from_data)) ||
+        (NULL == CU_add_test(pSuite, "data can be retrieved from frame", test_archimedes_get_data)) ||
+        (NULL == CU_add_test(pSuite, "Streaming view can read & write data", test_archimedes_streamed_view)))
+    {
+        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/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