Merger.hpp

//
// Profile Merger Tool for SAL3D.
// Copyright 2008-2010 AQSENSE, S.L.
//
#if !defined (AQSENSE_SAL3DPP_MERGER_HPP)
#define AQSENSE_SAL3DPP_MERGER_HPP

#if defined (_MSC_VER) && (_MSC_VER >= 1020)
#pragma once
#endif

#include <sal3d/merger.h>
#include <cstddef>
#include <limits>
#include <stdexcept>
#include <vector>
#include "RangeMap.hpp"
#include "Profile.hpp"
#include "Common.hpp"

// Remove the definition of max that some headers include (notably windows.h)
#if defined (max)
#undef max
#endif

namespace sal3d
{
    namespace Merger
    {
        class Config
        {
        public:
            explicit Config (sal3d_merger_config c_config):
                _c_config(c_config)
            {
            }

            Config (const Config &mc)
                : _c_config(mc._c_config)
            {
                Error e;
                sal3d_merger_config_share(_c_config, &e.e);
                if (e.e.value < 0)
                    throw e;
            }

            Config &
            operator= (const Config &mc)
            {
                _c_config = mc._c_config;
                Error e;
                sal3d_merger_config_share(_c_config, &e.e);
                if (e.e.value < 0)
                    throw e;
                return *this;
            }

            explicit Config (const std::string &filename):
                _c_config()
            {
                Error e;
                sal3d_merger_config_new_from_file (filename.c_str(),
                        &_c_config, &e.e);
                if (e.e.value < 0)
                    throw e;
            }

            ~Config ()
            {
                sal3d_merger_config_release (_c_config);
            }

            std::vector<float> accuracyMean() const
            {
                std::vector<float> vec(2);
                Error e;
                sal3d_merger_config_get_accuracy_mean(_c_config,
                        &vec[0], &vec[1], &e.e);
                if (e.e.value < 0)
                    throw e;
                return vec;
            }

            std::vector<float> accuracyStdDev() const
            {
                std::vector<float> vec(2);
                Error e;
                sal3d_merger_config_get_accuracy_stddev(_c_config,
                        &vec[0], &vec[1], &e.e);
                if (e.e.value < 0)
                    throw e;
                return vec;
            }

            sal3d_merger_config c_config() const
            {
                return _c_config;
            }

            std::vector<float> patternMisorientation() const
            {
                std::vector<float> vec(2);
                Error e;
                sal3d_merger_config_get_misorientation(_c_config,
                        &vec[0], &vec[1], &e.e);
                if (e.e.value < 0)
                    throw e;
                return vec;
            }

            void
            saveToFile (const std::string &fileName) const
            {
                Error e;
                sal3d_merger_config_save_to_file (_c_config,
                        fileName.c_str (), &e.e);
                if (e.e.value < 0)
                    throw e;
            }

        private:
            sal3d_merger_config _c_config;
        };

        inline void
        average (const Profile &base, const Profile &aux,
                 Profile &result, const Merger::Config &config,
                 float tolerancy = std::numeric_limits<float>::max())
        {
            const sal3d_merger_config c_config = config.c_config();
            Error e;
            sal3d_merger_average (base.c_profile (),
                    aux.c_profile(), c_config, tolerancy, result.c_profile(),
                    &e.e);
            if (e.e.value < 0)
                throw e;
        }

        inline Merger::Config
        calibrate (const RangeMap &base, const RangeMap &aux)
        {
            sal3d_merger_config config;

            Error e;
            sal3d_merger_calibrate (base.c_range_map (),
                aux.c_range_map(), &config, &e.e);

            if (e.e.value < 0)
                throw e;

            return Merger::Config(config);
        }

        inline Merger::Config
        calibrate (const RangeMap &base, const RangeMap &aux, int top,
                int bottom, int leftBase, int rightBase, int leftAux,
                int rightAux)
        {
            sal3d_merger_config config;

            Error e;
            sal3d_merger_calibrate_crop (base.c_range_map (),
                aux.c_range_map(), top, bottom, leftBase, rightBase,
                leftAux, rightAux, &config, &e.e);

            if (e.e.value < 0)
                throw e;

            return Merger::Config(config);
        }
    }
}

#endif // !AQSENSE_SAL3DPP_MERGER_HPP