RangeMap.hpp

//
// Range Map class for the SAL3D library.
// Copyright (C) 2008-2010 AQSENSE, S.L.
//
#if !defined (AQSENSE_SAL3DPP_RANGE_MAP_HPP)
#define AQSENSE_SAL3DPP_RANGE_MAP_HPP

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

#include <limits>
#include <stdexcept>
#include <string>
#include <vector>
#include <sal3d/rangemap.h>
#include <sal3dpp/Common.hpp>
#include <sal3dpp/Frame.hpp>
#include <sal3dpp/Profile.hpp>

namespace sal3d
{
    class RangeMap
    {
        public:
            RangeMap (int profilesLength, int maxProfiles)
            {
                _rangemap.p = 0;
                Error e;
                sal3d_range_map_new (profilesLength, maxProfiles,
                        &_rangemap, &e.e);
                if ( e.e.value < 0 )
                    throw e;
            }

            explicit RangeMap (const std::string &fileName)
            {
                _rangemap.p = 0;
                Error e;
                sal3d_range_map_new_from_file (fileName.c_str (),
                        &_rangemap, 0, &e.e);
                if ( e.e.value < 0 )
                    throw e;
            }

            RangeMap (const Frame &frame, int plane)
            {
                _rangemap.p = 0;
                Error e;
                sal3d_range_map_new_from_frame (frame.c_frame (),
                        plane, &_rangemap, &e.e);
                if ( e.e.value < 0 )
                    throw e;
            }

            RangeMap (const RangeMap &rangeMap):
                _rangemap (rangeMap._rangemap)
            {
                Error e;
                sal3d_range_map_share (_rangemap, &e.e);
                if ( e.e.value < 0 )
                    throw e;
            }

            explicit RangeMap (sal3d_range_map rangemap):
                _rangemap (rangemap)
            {
                Error e;
                sal3d_range_map_check_validity (rangemap, &e.e);
                if ( e.e.value < 0 )
                    throw e;
            }

            ~RangeMap ()
            {
                sal3d_range_map_release (_rangemap);
            }

            RangeMap
            copy() const
            {
                sal3d_range_map rangemap;
                Error e;
                sal3d_range_map_duplicate (_rangemap, &rangemap, &e.e);
                if ( e.e.value < 0 )
                    throw e;
                return RangeMap (rangemap);
            }

            int
            countProfiles () const
            {
                Error e;
                int count = sal3d_range_map_count_profiles (_rangemap, &e.e);
                if ( e.e.value < 0 )
                    throw e;
                return count;
            }

            int
            maxProfiles () const
            {
                Error e;
                int count = sal3d_range_map_max_profiles (_rangemap, &e.e);
                if ( e.e.value < 0 )
                    throw e;
                return count;
            }

            sal3d_range_map
            c_range_map () const
            {
                return _rangemap;
            }

            RangeMap &
            operator= (const RangeMap &rhs)
            {
                Error e;
                sal3d_range_map_share (rhs._rangemap, &e.e);
                if ( e.e.value < 0 )
                    throw e;
                sal3d_range_map_release (_rangemap);
                _rangemap = rhs._rangemap;

                return *this;
            }

            Profile
            getNewProfile () const
            {
                sal3d_profile profile;
                profile.p = 0;
                Error e;
                sal3d_range_map_get_new_profile (_rangemap,
                        &profile, &e.e);
                if ( e.e.value < 0 )
                    throw e;
                return Profile (profile);
            }

            const Profile
            operator[] (int index) const
            {
                sal3d_profile profile;
                profile.p = 0;
                Error e;
                sal3d_range_map_get_profile (_rangemap, index,
                        &profile, &e.e);
                if ( e.e.value < 0 )
                    throw e;
                return Profile (profile);
            }

            Profile
            operator[] (int index)
            {
                return static_cast<const RangeMap &>(*this)[index];
            }

            int
            profilesLength () const
            {
                Error e;
                int length = sal3d_range_map_get_profiles_length (_rangemap,
                        &e.e);
                if ( e.e.value < 0 )
                    throw e;

                return length;
            }

            Frame
            newFrame () const
            {
                sal3d_frame frame;
                Error e;
                sal3d_range_map_get_frame (_rangemap,
                        &frame, &e.e);
                if ( e.e.value < 0 )
                    throw e;
                return Frame (frame);
            }

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

        private:
            sal3d_range_map _rangemap;
    };
}

#endif // !AQSENSE_SAL3DPP_RANGE_MAP_HPP