fimImgTransMap.hpp

//
// Copyright (c) Singular Inversions Inc. 2001.
//
// File:        fimImgTransMap.hpp
// Description: A simple class for storing image transform mapping between
//              two images.
// Authors:     John Leung
// Created:     June 29, 2001
//
 
#ifndef FIM_IMG_TRANS_MAP_HPP
#define FIM_IMG_TRANS_MAP_HPP
 
#include "vect2.hpp"
 
namespace Fg {
 
template <typename T>
class FimImgTransMapT
{
    private:
 
                std::size_t                   nrows;
        std::size_t                   ncols;
        std::vector< FR2Vect2TC<T> >    mapping;
 
        class RowT
        {
            public:
                RowT(FR2Vect2TC<T> *pp, size_t nc) : 
                        ptr(pp), ncol(nc) {}
                FR2Vect2TC<T> &operator[](size_t ii) const 
                        { FGASSERT_FAST(ii<ncol); return ptr[ii]; }
 
            private:
                FR2Vect2TC<T>* const    ptr;
                size_t const            ncol;
        };
 
        class ConstRowT
        {
            public:
                ConstRowT(const FR2Vect2TC<T> *pp, size_t nc) : 
                        ptr(pp), ncol(nc) {}
                const FR2Vect2TC<T> &operator[](size_t ii) const 
                        { FGASSERT_FAST(ii<ncol); return ptr[ii]; }
 
            private:
                const FR2Vect2TC<T>* const  ptr;
                size_t const                ncol;
        };
 
    public:
 
        FimImgTransMapT() : nrows(0), ncols(0), mapping(0) {}
 
        FimImgTransMapT(size_t width, size_t height) : 
            nrows(height), ncols(width), mapping(width*height) {}
 
        void        resize(size_t width, size_t height)
                    { nrows = height; ncols = width; 
                      mapping.resize(height*width); }
 
        size_t      numRows() const { return nrows; }
        size_t      numCols() const { return ncols; }
        size_t      rowByteSize() const 
                    { return (sizeof(FR2Vect2TC<T>)*ncols); }
 
        RowT        operator[](size_t ii)
                    { FGASSERT_FAST(ii<nrows);
                      return RowT(&mapping[0]+ii*ncols,ncols); }
        ConstRowT   operator[](size_t ii) const
                    { FGASSERT_FAST(ii<nrows);
                      return ConstRowT(&mapping[0]+ii*ncols,ncols); }
        const FimImgTransMapT<T> & operator=(const FimImgTransMapT<T> &aa)
                    {
                        if (this == &aa)
                            return *this;
                        nrows = aa.nrows;
                        ncols = aa.ncols;
                        mapping.resize(aa.mapping.size());
                        memcpy(&mapping[0],&aa.mapping[0],
                               sizeof(FR2Vect2TC<T>)*aa.mapping.size());
                                                return *this;
                    }
 
        typename std::vector< FR2Vect2TC<T> >::iterator begin() 
                    { return mapping.begin(); }
        typename std::vector< FR2Vect2TC<T> >::const_iterator begin() const
                    { return mapping.begin(); }
 
        typename std::vector< FR2Vect2TC<T> >::iterator end() 
                    { return mapping.end(); }
        typename std::vector< FR2Vect2TC<T> >::const_iterator end() const
                    { return mapping.end(); }
};
 
 
//****************************************************************************
// Some aliases
//****************************************************************************
typedef FimImgTransMapT<int>        FimImgTransMapIC;
typedef FimImgTransMapT<float>      FimImgTransMapFC;
typedef FimImgTransMapT<double>     FimImgTransMapDC;
 
}
 
#endif