cvd/image.h

/*                       
    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()
    #define CVD_IMAGE_ASSERT2(X,Y,Z)  if(!(X)) throw Y(Z)
#else
    #define CVD_IMAGE_ASSERT(X,Y)
    #define CVD_IMAGE_ASSERT2(X,Y,Z)
#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 std::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;

        typedef T value_type;
        
        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_ASSERT2(other.size() == this->size(), Exceptions::Image::IncompatibleImageSizes, "copy_from");
            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;

        typedef T value_type;

        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, std::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:

        typedef T value_type;

        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)
        {
          //If the size of the image is zero pixels along any dimension,
          //still keep any of the non-zero dimensions in the size. The
          //caller should expect the size passed to the constructor
          //to be the same as the value returned by .size()
          if (size.x == 0 || size.y == 0) {
            dup_from(NULL);
            this->my_size = size;
            this->my_stride = size.x;
          }
          else
          {
            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)
            {
              //For images with zero pixels (e.g. 0 by 100 image),
              //we still want to preserve non-zero dimensions in the size.
                this->my_size = copyof->my_size;
                this->my_stride = copyof->my_stride;
                if (copyof->my_data != NULL) {
                  this->my_data = copyof->my_data;
                  num_copies = copyof->num_copies;
                  (*num_copies)++;
                }
                else {
                  this->my_data = 0;
                  num_copies = 0;
                }
            }
            else
            {
                this->my_size.home();
                this->my_data = 0;
                this->my_stride = 0;
                num_copies = 0;
            }
        }
};


} // end namespace
#endif