image.h

Go to the documentation of this file.

/*                       
        This file is part of the CVD Library.

        Copyright (C) 2005 The Authors

        This library is free software; you can redistribute it and/or
        modify it under the terms of the GNU Lesser General Public
        License as published by the Free Software Foundation; either
        version 2.1 of the License, or (at your option) any later version.

        This library is distributed in the hope that it will be useful,
        but WITHOUT ANY WARRANTY; without even the implied warranty of
        MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
        Lesser General Public License for more details.

        You should have received a copy of the GNU Lesser General Public
        License along with this library; if not, write to the Free Software
        Foundation, Inc., 
    51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*/
//-*- c++ -*-
//                                                                      //
//  CVD::image.h                                                        //
//                                                                      //
//  Definitions for of template class CVD::Image, fast_image            //
//                                                                      //
//  derived from IPRS_* developed by Tom Drummond                       //
//      Reworked to provide class heirachy and memory managementby E. Rosten//
//                                                                      //

#ifndef CVD_IMAGE_H
#define CVD_IMAGE_H

#include <string.h>
#include <cvd/image_ref.h>
#include <cvd/exceptions.h>
#include <string>
#include <utility>
#include <iterator>
#include <cvd/internal/aligned_mem.h>

namespace CVD {

namespace Exceptions {

  namespace Image {
        struct All: public CVD::Exceptions::All {};

        struct IncompatibleImageSizes : public All {
            IncompatibleImageSizes(const std::string & function)
            {
                what = "Incompatible image sizes in " + function;
            };
        };

        struct ImageRefNotInImage : public All {
            ImageRefNotInImage(const std::string & function)
            {
                what = "Input ImageRefs not in image in " + function;
            };
        };
    }
}

#ifndef DOXYGEN_IGNORE_INTERNAL
namespace Internal
{
        template<class C> class ImagePromise
        {};
};
#endif

#ifdef CVD_IMAGE_DEBUG
        #define CVD_IMAGE_ASSERT(X,Y)  if(!(X)) throw Y()
#else
        #define CVD_IMAGE_ASSERT(X,Y)
#endif

namespace ImageError
{
        class AccessOutsideImage{};
}


namespace ImageUtil
{
        template<class T> inline void memfill(T* data, int n, const T val)
        {
                T* de = data + n;
                for(;data < de; data++)
                        *data=val;
        }

        template<> inline void memfill(unsigned char* data, int n, const unsigned char val)
        {
                memset(data, val, n);
        }

        template<> inline void memfill(signed char* data, int n, const signed char val)
        {
                memset(data, val, n);
        }

        template<> inline void memfill(char* data, int n, const char val)
        {
                memset(data, val, n);
        }
}

template<class T> class SubImage;


template<class T> class ConstSubImageIterator
{
        public:
                const ConstSubImageIterator& operator++()
                {
                        ptr++;
                        if(ptr == row_end)
                        {
                                ptr += row_increment;
                                row_end += total_width;

                                if(ptr >= end)
                                        end = NULL;
                        }
                        return *this;
                }

                void operator++(int)
                {
                        operator++();
                }
        
                const T* operator->() const { return ptr; }
                const T& operator*() const { return *ptr;}

                bool operator<(const ConstSubImageIterator& s) const 
                { 
                        //It's illegal to iterate _past_ end(), so < is equivalent to !=
                        //for end iterators.
                        if(is_end && s.is_end)
                                return 0;
                        else if(is_end)
                                return s.end != NULL;
                        else if(s.is_end) 
                                return end != NULL; 
                        else 
                                return ptr < s.ptr; 
                }

                bool operator==(const ConstSubImageIterator& s) const 
                { 
                        return !((*this)!=s);
                }

                bool operator!=(const ConstSubImageIterator& s) const 
                { 
                        if(is_end && s.is_end)
                                return 0;
                        else if(is_end)
                                return s.end != NULL;
                        else if(s.is_end) 
                                return end != NULL; 
                        else 
                                return ptr != s.ptr; 
                }


                //Make it look like a standard iterator
                typedef std::forward_iterator_tag iterator_category;
                typedef T value_type;
                typedef ptrdiff_t difference_type;
                typedef const T* pointer;
                typedef const T& reference;



                ConstSubImageIterator()
                {}

                ConstSubImageIterator(const T* start, int image_width, int row_stride, const T* off_end)
                :ptr(const_cast<T*>(start)),
                 row_end(start + image_width), 
                 end(off_end), 
                 is_end(0),
                 row_increment(row_stride-image_width), 
                 total_width(row_stride)
                { }

                //Prevent automatic conversion from a pointer (ie Image::iterator)
                explicit ConstSubImageIterator(const T* end) 
                :ptr(const_cast<T*>(end)),is_end(1),row_increment(0),total_width(0)
                { }

        protected:
                T* ptr;
                const T *row_end, *end;
                bool is_end;
                int row_increment, total_width;
};

template<class T> class SubImageIterator: public ConstSubImageIterator<T>
{
        public:
                SubImageIterator(T* start, int image_width, int row_stride, const T* off_end)
                :ConstSubImageIterator<T>(start, image_width, row_stride, off_end)
                {}
                
                explicit SubImageIterator(T* end) 
                :ConstSubImageIterator<T>(end)
                { }

                SubImageIterator()
                {}

                typedef T* pointer;
                typedef T& reference;

                T* operator->() { return ConstSubImageIterator<T>::ptr; }
                T& operator*() { return *ConstSubImageIterator<T>::ptr;}
};

template<class T> class SubImage
{
        public:
                SubImage(T* data, const ImageRef& size, int stride)
                :my_data(data),my_size(size),my_stride(stride)
                {
                }


                bool in_image(const ImageRef& ir) const
                {
                        return ir.x >=0 && ir.y >=0 && ir.x < my_size.x && ir.y < my_size.y;
                }

                bool in_image_with_border(const ImageRef& ir, int border) const
                {
                        return ir.x >=border && ir.y >=border && ir.x < my_size.x - border && ir.y < my_size.y - border;
                }

                ~SubImage()
                {}

                inline T& operator[](const ImageRef& pos)
                {
                        CVD_IMAGE_ASSERT(in_image(pos), ImageError::AccessOutsideImage);
                        return (my_data[pos.y*my_stride + pos.x]);
                }
                
                inline const T& operator[](const ImageRef& pos) const 
                {
                        CVD_IMAGE_ASSERT(in_image(pos), ImageError::AccessOutsideImage);
                        return (my_data[pos.y*my_stride + pos.x]);
                }

        inline T* operator[](int row)
        {
            CVD_IMAGE_ASSERT(in_image(ImageRef(0,row)), ImageError::AccessOutsideImage);
            return my_data+row*my_stride;
        }

        inline const T* operator[](int row) const
        {
            CVD_IMAGE_ASSERT(in_image(ImageRef(0,row)), ImageError::AccessOutsideImage);
            return my_data+row*my_stride;
        }

                inline ImageRef pos(const T* ptr) const
                {
                        int diff = ptr - data();
                        return ImageRef(diff % my_stride, diff / my_size.x);
                }

                inline const T* data() const
                {
                        return my_data;
                }
                
                inline T* data()
                {
                        return my_data;
                }

                typedef SubImageIterator<T> iterator;
                typedef ConstSubImageIterator<T> const_iterator;
                
                inline iterator begin()
                {
                        return SubImageIterator<T>(data(), size().x, my_stride, end_ptr());
                }
                inline const_iterator begin() const
                {
                        return ConstSubImageIterator<T>(data(), size().x, my_stride, end_ptr());
                }

                inline iterator end()
                {
                        //Operator [] would always throw here!
                        return SubImageIterator<T>(end_ptr());
                }
                inline const_iterator end() const
                {
                        //Operator [] would always throw here!
                        return ConstSubImageIterator<T>(end_ptr());
                }

                inline void copy_from( const SubImage<T> & other ){
                        CVD_IMAGE_ASSERT(other.size() == this->size(), Exceptions::Image::IncompatibleImageSizes);
                        std::copy(other.begin(), other.end(), this->begin());
                }

                inline ImageRef size() const
                {
                        return my_size;
                }

                inline int row_stride() const
                {
                        return my_stride;
                }

                inline int totalsize() const
                {
                        return my_stride * my_size.y;
                }

                inline void zero() 
                {
                        memset(my_data, 0, totalsize()*sizeof(T));
                }

                inline void fill(const T d)
                {
                        for(int y=0; y < my_size.y; y++)
                                ImageUtil::memfill( (*this)[y], my_size.x, d);
                }

                SubImage(const SubImage& copyof)
                {
                  my_size = copyof.my_size;
                  my_data = copyof.my_data;
                  my_stride = copyof.my_stride;
                }
                

                SubImage sub_image(const ImageRef& start, const ImageRef& size)
                {
                        CVD_IMAGE_ASSERT(in_image(start), ImageError::AccessOutsideImage);
                        CVD_IMAGE_ASSERT(in_image(start + size - ImageRef(1,1)), ImageError::AccessOutsideImage);
                        return SubImage( &operator[](start), size, my_stride);
                }

                const SubImage sub_image(const ImageRef& start, const ImageRef& size) const
                {       
                        CVD_IMAGE_ASSERT(in_image(start), ImageError::AccessOutsideImage);
                        CVD_IMAGE_ASSERT(in_image(start + size - ImageRef(1,1)), ImageError::AccessOutsideImage);

                        T*ptr = my_data + start.y * my_stride + start.x;
                        return SubImage(ptr, size, my_stride);
                }

                SubImage& ref()
                {
                        return *this;
                }

        protected:
                T* my_data;       
                ImageRef my_size; 
                int my_stride;    
                
                T* end_ptr() { return my_data+my_size.y*my_stride; }

                const T* end_ptr() const { return my_data+my_size.y*my_stride; }

                SubImage()
                {}

};


template<class T> class BasicImage: public SubImage<T>
{
        public:
                BasicImage(T* data, const ImageRef& size)
                :SubImage<T>(data, size, size.x)
                {
                }

                BasicImage(const BasicImage& copyof)
                :SubImage<T>(copyof)
                {
                }

                void operator=(const BasicImage&copyof)
                {
                        SubImage<T>::my_size = copyof.my_size;
                        SubImage<T>::my_data = copyof.my_data;
                        SubImage<T>::my_stride = copyof.my_stride;
                }
        
                ~BasicImage()
                {}

                typedef T* iterator;
                typedef const T* const_iterator;

                const_iterator begin() const { return SubImage<T>::my_data; }
                iterator begin() { return SubImage<T>::my_data; }

                const_iterator end() const { return SubImage<T>::my_data+SubImage<T>::totalsize(); }
                iterator end() { return SubImage<T>::my_data+SubImage<T>::totalsize(); }



        protected:
                BasicImage()
                {}
        private:
};


template<class T> class ImageCreationIterator: public std::iterator<std::input_iterator_tag, T, ptrdiff_t>
{
        public:
                void operator++(int) { num++; }
                void operator++() { num++; }
                bool operator==(const ImageCreationIterator& i){return num == i.num;}
                bool operator!=(const ImageCreationIterator& i){return num != i.num;}
                
                const T& operator*() { return *construct_from_me; }
                
                ImageCreationIterator(const T& data)
                :construct_from_me(&data),num(0){}

                ImageCreationIterator(int i)
                :construct_from_me(0),num(i){}

        private:
                const T* construct_from_me;
                int num;
};


template<class C> inline ImageCreationIterator<C> CreateImagesBegin(const C& from_me)
{
        return ImageCreationIterator<C>(from_me);
}
template<class C> inline ImageCreationIterator<C> CreateImagesEnd(const C&, int i)
{
        return ImageCreationIterator<C>(i);
}

template<class C> inline ImageCreationIterator<C> CreateImagesEnd(int i)
{
        return ImageCreationIterator<C>(i);
}

template<class T> 
class Image: public BasicImage<T>
{
        private:
                struct CopyPlaceHolder
                {
                        const Image* im;
                };

        public:
                Image(const Image& copy) :
                        BasicImage<T>(copy)
                {
                        dup_from(&copy);
                }


                Image(const CopyPlaceHolder& c)
                {
                        dup_from(NULL);
                        copy_from(*(c.im));
                }
                
                CopyPlaceHolder copy_from_me() const
                {       
                        CopyPlaceHolder c = {this};
                        return c;
                }


                void copy_from(const BasicImage<T>& copy)
                {
            resize(copy.size());
            std::copy(copy.begin(), copy.end(), this->begin());
                }




                void copy_from(const SubImage<T>& copy)
                {
                        Image<T> tmp(copy.size());
                        *this = tmp;
                        
                        std::copy(copy.begin(), copy.end(), this->begin());
                }

                void make_unique()
                {
                        if(*num_copies > 1)
                        {
                                Image<T> tmp(*this);
                                copy_from(tmp);
                        }
                }

                const Image& operator=(const Image& copyof)
                {
                        remove();
                        dup_from(&copyof);
                        return *this;
                }
                
                #ifndef DOXYGEN_IGNORE_INTERNAL
                template<class C> const Image& operator=(Internal::ImagePromise<C> p)
                {
                        p.execute(*this);
                        return *this;
                }

                template<class C> Image(Internal::ImagePromise<C> p)
                {
                        dup_from(NULL);
                        p.execute(*this);
                }
                #endif
                
                Image()
                {
                        dup_from(NULL);
                }

                Image(const ImageRef& size)
                {
                        num_copies = new int;
                        *num_copies = 1;
                        this->my_size = size;
                        this->my_stride = size.x;
            this->my_data = Internal::aligned_alloc<T>(this->totalsize(), 16);
                }

                Image(const ImageRef& size, const T& val)
                {
                        Image<T> tmp(size);
                        tmp.fill(val);
                        dup_from(&tmp);
                }

                Image(const std::pair<ImageRef, T>& p)
                {
                        Image<T> tmp(p.first);
                        tmp.fill(p.second);
                        dup_from(&tmp);
                }

                void resize(const ImageRef& size)
                {       
                        if(size != BasicImage<T>::my_size || *num_copies > 1)
                        {
                                Image<T> new_im(size);
                                *this = new_im;
                        }
                }

                //The resized image is filled with val.
                void resize(const ImageRef& size, const T& val)
                {
                        if(*num_copies > 1 || size != BasicImage<T>::my_size)
                        {
                                Image<T> new_im(size, val);
                                *this = new_im;
                        }
                                else fill(val);
                }

                ~Image()
                {
                        remove();
                }

                
        private:


                int* num_copies;                        //Reference count.

                inline void remove()            //Get rid of a reference to the data
                {
                        if(this->my_data && *num_copies && --(*num_copies) == 0)
                        {
                Internal::aligned_free<T>(this->my_data, this->totalsize());
                            this->my_data = 0;
                            delete   num_copies;
                            num_copies = 0;
                        }
                }

                inline void dup_from(const Image* copyof)  //Duplicate from another image
                {
                        if(copyof != NULL && copyof->my_data != NULL)
                        {
                                this->my_size = copyof->my_size;
                                this->my_stride = copyof->my_stride;
                                this->my_data = copyof->my_data;
                                num_copies = copyof->num_copies;
                                (*num_copies)++;
                        }
                        else
                        {
                                this->my_size.home();
                                this->my_stride=0;
                                this->my_data = 0;
                                num_copies = 0;
                        }
                }
};


} // end namespace
#endif

---

libcvd
Author(s): Edward Rosten, Paul Smith, Tom Drummond, Gerhard Reitmayr, Ethan Eade, Timothy Gan, Chris Kemp, Georg Klein
autogenerated on Fri Jan 11 09:13:09 2013