Match3DCoarse.hpp

//
// COP match tool with coarse alignment
// Copyright (C) 2008-2010 AQSENSE, S.L.
//
#if !defined (AQSENSE_SAL3DPP_MATCH3DCOARSE_HPP)
#define AQSENSE_SAL3DPP_MATCH3DCOARSE_HPP

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

#include <sal3d/match3dcoarse.h>
#include <sal3d/match3d.h>
#include <sal3dpp/Match3D.hpp> /* for SurfacePoints */
#include <sal3dpp/COP.hpp>
#include <vector>

namespace sal3d
{
    class Match3DCoarse
    {
        public:
            explicit Match3DCoarse (const sal3d::COP &cop)
            {
                _match3d.p = 0;
                Error e;
                sal3d_match3d_new_with_cop (cop.c_cop (), &_match3d, &e.e);
                if (e.e.value < 0)
                    throw e;
            }

            explicit Match3DCoarse (const SurfacePoints &points)
            {
                _match3d.p = 0;
                Error e;
                sal3d_match3d_new_with_surface_points (&points[0], points.size(),
                        &_match3d, &e.e);
                if (e.e.value < 0)
                    throw e;
            }

            Match3DCoarse (const Match3DCoarse &match3d):
                _match3d (match3d._match3d)
            {
                Error e;
                sal3d_match3d_share (_match3d, &e.e);
                if (e.e.value < 0)
                    throw e;
            }

            ~Match3DCoarse ()
            {
                sal3d_match3d_release (_match3d);
            }

            Movement3D
            operator() (const sal3d::COP &cop) const
            {
                float quality;
                int iters;
                Match3DParameters params;

                return this->operator()(cop, params, quality, iters);
            }

            Movement3D
            operator() (const sal3d::COP &cop, float &quality) const
            {
                int iters;
                Match3DParameters params;

                return this->operator()(cop, params, quality, iters);
            }

            Movement3D
            operator() (const sal3d::COP &cop, const Match3DParameters &params,
                    float &quality, int &iterations) const
            {
                sal3d_movement_3d movement;
                Error e;
                sal3d_match3dcoarse_align (_match3d, cop.c_cop (),
                        params.maxIterations, params.maxTranslationError,
                        params.maxRotationError, params.extractFeatures,
                        &movement, &quality, &iterations, &e.e);
                if (e.e.value < 0)
                    throw e;

                return Movement3D (movement);
            }

            Match3DCoarse &
            operator= (const Match3DCoarse &rhs)
            {
                sal3d_match3d_share (rhs._match3d);
                sal3d_match3d_release (_match3d);
                _match3d = rhs._match3d;

                return *this;
            }

        private:
            sal3d_match3d _match3d;
    };
}

#endif // !AQSENSE_SAL3DPP_MATCH3DCOARSE_HPP