AngularMetricConfig.hpp

//
// Angular Metric Tool for SAL3D.
// Copyright 2008-2010 AQSENSE, S.L.
//
#if !defined (AQSENSE_SAL3DPP_ANGULAR_METRIC_CONFIG_HPP)
#define AQSENSE_SAL3DPP_ANGULAR_METRIC_CONFIG_HPP

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

#include <limits>
#include <string>
#include <cassert>
#include <cstddef>
#include <stdexcept>
#include <vector>
#include <sal3dpp/Common.hpp>
#include <sal3dpp/RangeMap.hpp>
#include <sal3d/angularmetricconfig.h>

namespace sal3d
{
    namespace AngularMetric
    {
        class Config
        {
            public:
                explicit Config (
                    const sal3d_angular_metric_config &config):
                    _config (config)
                {
                    Error e;
                    sal3d_angular_metric_config_check_validity (config, &e.e);
                    if (e.e.value < 0)
                        throw e;
                }

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

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

                explicit Config (const std::string &filename)
                {
                    _config.p = 0;
                    Error e;
                    sal3d_angular_metric_config_new_from_file (
                            filename.c_str (), &_config, &e.e);
                    if (e.e.value < 0)
                        throw e;
                }

                ~Config ()
                {
                    sal3d_angular_metric_config_release (_config);
                }

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

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

                const sal3d_angular_metric_config &
                c_metric_config () const
                {
                    return _config;
                }

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

                Point3D
                toPoint3D (float angle, int v, float g) const
                {
                    Point3D point3d;
                    Error e;
                    sal3d_angular_metric_config_point3d_from_range_map_point (v, g,
                            angle, _config, &point3d.c_point_3d(), &e.e);
                    if (e.e.value < 0)
                        throw e;
                    return point3d;
                }

                LensDistortion::Model
                getLensDistortionModel() const
                {
                    sal3d_lens_distortion dm;
                    Error e;
                    sal3d_angular_metric_config_get_lens_distortion(
                            _config, &dm, &e.e);
                    if (e.e.value < 0)
                        throw e;

                    return LensDistortion::Model(dm);
                }

            private:
                sal3d_angular_metric_config _config;
        };
    }
}

#endif // !AQSENSE_SAL3DPP_ANGULAR_METRIC_CONFIG_HPP