FMTlayer.hpp

Go to the documentation of this file.

/*
Copyright (c) 2019 Gouvernement du Québec
 
SPDX-License-Identifier: LiLiQ-R-1.1
License-Filename: LICENSES/EN/LiLiQ-R11unicode.txt
*/
 
#ifndef FMTLAYER_H_INCLUDED
#define FMTLAYER_H_INCLUDED
#include <memory>
#include <map>
#include <vector>
#include "FMTcoordinate.hpp"
#include "FMTobject.hpp"
#include <boost/serialization/nvp.hpp>
#include "FMTexceptionhandler.hpp"
 
namespace Spatial
    {
    // DocString: FMTlayer
    template <typename T>
    class FMTlayer : public Core::FMTobject
        {
        friend class boost::serialization::access;
        // DocString: FMTlifespans::serialize
        template<class Archive>
        void serialize(Archive& ar, const unsigned int version)
        {
            ar & boost::serialization::make_nvp("FMTobject", boost::serialization::base_object<FMTobject>(*this));
            ar & BOOST_SERIALIZATION_NVP(geotransform);
            ar & BOOST_SERIALIZATION_NVP(maxx);
            ar & BOOST_SERIALIZATION_NVP(maxy);
            ar & BOOST_SERIALIZATION_NVP(SRS_WKT);
            ar & BOOST_SERIALIZATION_NVP(cellsize);
            ar & BOOST_SERIALIZATION_NVP(mapping);
        }
        protected:
        // DocString: FMTlayer::geotransform
        std::vector<double>geotransform;
        // DocString: FMTlayer::maxx
        unsigned int maxx;
        // DocString: FMTlayer::maxy
        unsigned int maxy;
        // DocString: FMTlayer::SRS_WKT
        std::string SRS_WKT;
        // DocString: FMTlayer::cellsize
        double cellsize;
        // DocString: FMTlayer::mapping
        std::map<FMTcoordinate, T>mapping;
        public:
            // DocString: FMTlayer::value_type
            typedef typename std::map<FMTcoordinate,T>::value_type value_type;
            // DocString: FMTlayer::iterator
            typedef typename std::map<FMTcoordinate,T>::iterator iterator;
            // DocString: FMTlayer::const_iterator
            typedef typename std::map<FMTcoordinate,T>::const_iterator const_iterator;
            // DocString: FMTlayer::operator[]
            T& operator [](const FMTcoordinate& coordinate)
                {
                return mapping[coordinate];
                }
            // DocString: FMTlayer::at
            const T& at(const FMTcoordinate& coordinate) const
            {
                return mapping.at(coordinate);
            }
            // DocString: FMTlayer::empty
            inline bool empty() const
            {
                return mapping.empty();
            }
            // DocString: FMTlayer::begin
            iterator begin()
            {
                return mapping.begin();
            }
            // DocString: FMTlayer::begin
            const_iterator begin() const
            {
                return mapping.begin();
            }
            // DocString: FMTlayer::end
            iterator  end()
            {
                return mapping.end();
            }
            // DocString: FMTlayer::end
            const_iterator end() const
            {
                return mapping.end();
            }
            // DocString: FMTlayer::find
            const_iterator find(const FMTcoordinate& coordinate) const
            {
                return mapping.find(coordinate);
            }
            // DocString: FMTlayer::find
            iterator find(const FMTcoordinate& coordinate)
            {
                return mapping.find(coordinate);
            }
            // DocString: FMTlayer()
            FMTlayer():Core::FMTobject(),geotransform(),maxx(),maxy(),SRS_WKT(),cellsize(),mapping(){}
            // DocString: ~FMTlayer()
            virtual~FMTlayer()=default;
            // DocString: FMTlayer(FMTlayer&&)
            FMTlayer(FMTlayer&& rhs) noexcept :
                Core::FMTobject(std::move(rhs)),
                geotransform(std::move(rhs.geotransform)),
                maxx(std::move(rhs.maxx)),
                maxy(std::move(rhs.maxy)),
                SRS_WKT(std::move(rhs.SRS_WKT)),
                cellsize(std::move(rhs.cellsize)),
                mapping(std::move(rhs.mapping))
                    {
            
                    }
            // DocString: FMTlayer(const std::vector<double>&,const unsigned int&,const unsigned int&,const std::string&,const double&)
            FMTlayer(const std::vector<double>& lgeotransform,
                     const unsigned int& lmaxx,
                     const unsigned int& lmaxy,
                     const std::string& lSRS_WKT,
                     const double& lcellsize):Core::FMTobject(),
                     geotransform(lgeotransform),
                     maxx(lmaxx),
                     maxy(lmaxy),
                     SRS_WKT(lSRS_WKT),
                     cellsize(lcellsize),
                     mapping(){}
            // DocString: FMTlayer(const std::map<FMTcoordinate,T>&,const std::vector<double>&,const unsigned int&,const unsigned int&,const std::string&,const double&)
            FMTlayer(const std::map<FMTcoordinate,T>& lmapping,
                     const std::vector<double>& lgeotransform,
                     const unsigned int& lmaxx,
                     const unsigned int& lmaxy,
                     const std::string& lSRS_WKT,
                     const double& lcellsize):
                         Core::FMTobject(),
                geotransform(lgeotransform),
                             maxx(lmaxx),
                             maxy(lmaxy),
                             SRS_WKT(lSRS_WKT),
                             cellsize(lcellsize),
                             mapping(lmapping){}
            // DocString: FMTlayer(const FMTlayer&)
            FMTlayer(const FMTlayer& rhs):Core::FMTobject(rhs),
                geotransform(rhs.geotransform),
                maxx(rhs.maxx),
                maxy(rhs.maxy),
                SRS_WKT(rhs.SRS_WKT),
                cellsize(rhs.cellsize),
                mapping(rhs.mapping){}
            // DocString: FMTlayer::operator=
            FMTlayer<T>& operator = (const FMTlayer<T>& rhs)
                {
                if(this!=&rhs)
                    {
                    Core::FMTobject::operator = (rhs);
                    mapping = (rhs.mapping);
                    geotransform = rhs.geotransform;
                    maxx = rhs.maxx;
                    maxy = rhs.maxy;
                    SRS_WKT = rhs.SRS_WKT;
                    cellsize = rhs.cellsize;
                    }
                return *this;
                }
            // DocString: FMTlayer::swap
            void swap(FMTlayer<T>& rhs)
                {
                try {
                    mapping.swap(rhs.mapping);
                    geotransform.swap(rhs.geotransform);
                    std::swap(maxx, rhs.maxx);
                    std::swap(maxy, rhs.maxy);
                    std::swap(SRS_WKT, rhs.SRS_WKT);
                    std::swap(cellsize, rhs.cellsize);
                }catch (...)
                    {
                    _exhandler->raisefromcatch("", "FMTlayer::swap", __LINE__, __FILE__);
                    }
                }
 
            // DocString: FMTlayer::setextentfrom
            void setextentfrom(const FMTlayer<T>& rhs)
                {
                this->geotransform = rhs.geotransform;
                this->maxx = rhs.maxx;
                this->maxy = rhs.maxy;
                this->SRS_WKT = rhs.SRS_WKT;
                this->cellsize = rhs.cellsize;
                }
            // DocString: FMTlayer::copyextent
            template<typename newtype>
            FMTlayer<newtype>copyextent() const
 
                {
                return FMTlayer<newtype>(std::map<FMTcoordinate,newtype>(),
                                         this->geotransform,
                                         this->maxx,
                                         this->maxy,
                                         this->SRS_WKT,
                                         this->cellsize);
                }
            // DocString: FMTlayer::general
            FMTlayer<T>& operator+= (const FMTlayer<T>& rhs)
            {
                return *this;
            }
            // DocString: FMTlayer::GetXSize
            unsigned int GetXSize() const
                {
                return maxx;
                }
            // DocString: FMTlayer::GetYSize
            unsigned int GetYSize() const
                {
                return maxy;
                }
            // DocString: FMTlayer::getgeotransform
            std::vector<double> getgeotransform() const
                {
                return geotransform;
                }
            // DocString: FMTlayer::getprojection
            std::string getprojection() const
                {
                return SRS_WKT;
                }
            // DocString: FMTlayer::getmapping
            std::map<FMTcoordinate,T>getmapping() const
                {
                return mapping;
                }
            // DocString: FMTlayer::area
            double area() const
                {
                return (cellsize * static_cast<double>(mapping.size()));
                }
            // DocString: FMTlayer::getcellsize
            double getcellsize() const
                {
                return cellsize;
                }
            // DocString: FMTlayer::getattributes
            std::vector<T>getattributes() const
                {
                std::vector<T>unique_attributes;
                for(typename std::map<FMTcoordinate,T>::const_iterator it = mapping.begin();it != mapping.end(); it++)
                    {
                    if (std::find(unique_attributes.begin(),unique_attributes.end(),it->second)==unique_attributes.end())
                        {
                        unique_attributes.push_back(it->second);
                        }
                    }
                return unique_attributes;
                }
            // DocString: FMTlayer::size
            size_t size() const
                {
                return mapping.size();
                }
            // DocString: FMTlayer::size
            void replace(typename std::map<FMTcoordinate,T>::const_iterator first,typename std::map<FMTcoordinate,T>::const_iterator last)
                {
                while (first!=last)
                    {
                    typename std::map<FMTcoordinate,T>::iterator it = mapping.find(first->first);
                    if (it != last)
                        {
                        it->second = first->second;
                        }
                    ++first;
                    }
                }
        };
 
        template<> inline FMTlayer<std::string>& FMTlayer<std::string>::operator += (const FMTlayer<std::string>& rhs)
        {
            std::map<FMTcoordinate, std::string>new_mapping;
            for (std::map<FMTcoordinate, std::string>::const_iterator mit = mapping.begin(); mit != mapping.end(); mit++)
            {
                std::map<FMTcoordinate, std::string>::const_iterator rhsit = rhs.mapping.find(mit->first);
                if (rhsit != rhs.mapping.end())
                {
                    new_mapping[mit->first] = (mit->second + "-" + rhsit->second);
                }
            }
            mapping = new_mapping;
            return *this;
        }
 
    }
 
#endif // FMTLAYER_H_INCLUDED