image_ref.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 classes CVD::ImageRef and CVD::Image    //
//                                                                      //
//  derived from IPRS_* developed by Tom Drummond                       //
//                                                                      //

#ifndef __CVD_IMAGE_REF_H__
#define __CVD_IMAGE_REF_H__

#include <iostream>
#include <cctype>
#include "exceptions.h"

namespace CVD {


// CVD::ImageRef                    //
class ImageRef
{
public:

    //Construction
    inline ImageRef();
    inline ImageRef(int xp, int yp);
    inline ImageRef(std::istream& is);

    //Iteration

    inline bool next(const ImageRef& max);
    inline bool prev(const ImageRef& max);
    inline bool next(const ImageRef& min, const ImageRef& max);
    inline bool prev(const ImageRef& min, const ImageRef& max);

    inline void home();
    inline void end(const ImageRef& size);


    //Operators

    inline ImageRef&    operator=(const ImageRef& ref);
    inline bool         operator==(const ImageRef& ref) const;
    inline bool         operator!=(const ImageRef& ref) const;
  inline ImageRef  operator-() const;
  inline ImageRef&  operator*=(const double scale);
    inline ImageRef&    operator/=(const double scale);
    inline ImageRef&    operator+=(const ImageRef rhs);
    inline ImageRef&    operator-=(const ImageRef rhs);
    inline ImageRef     operator*(const double scale) const;
    inline ImageRef     operator/(const double scale) const;
    inline ImageRef     operator+(const ImageRef rhs) const;
    inline ImageRef     operator-(const ImageRef rhs) const;
    inline ImageRef&    operator<<=(int i);
    inline ImageRef&    operator>>=(int i);
    inline ImageRef     operator>>(int i) const;
    inline ImageRef     operator<<(int i) const;
  inline bool operator<(const ImageRef & other) const;
  inline bool operator>(const ImageRef & other) const;

    inline unsigned int     mag_squared() const;

    inline int area() const;

    inline ImageRef dot_times(const ImageRef &ref) const;

    inline int& operator[](int i);

    inline int operator[](int i) const;

    //Why do these exist?
    inline ImageRef shiftl(int i) const;
    inline ImageRef shiftr(int i) const;

    // and now the data members (which are public!)
    int x; 
    int y; 

};

inline ImageRef operator*(const int scale, const ImageRef&  ref);

namespace Exceptions
{
  struct BadSubscript: public CVD::Exceptions::All {BadSubscript(){};};
}



    inline ImageRef::ImageRef()
    {
        x=y=0;
    }
    
    inline ImageRef::ImageRef(int xp, int yp)
    :x(xp),y(yp)
    {}
    
    inline ImageRef::ImageRef(std::istream& is)
    {
        is.read((char*)&x,sizeof(int));
        is.read((char*)&y,sizeof(int));
    }
    
    // the following cryptic pieces of rubbish are because inline functions //
    // must have their one and only return function as the last call        //
    // so this code makes use of the fact that expressions to the right     //
    // of || are only evaluated when the left hand side is false            //
    
    inline bool ImageRef::next(const ImageRef& max) // move on to the next value
    {
        return(++x < max.x || (x=0, ++y < max.y) || (y=0, false));
    }
    
    inline bool ImageRef::next(const ImageRef& min, const ImageRef& max)
    {
        return (++x < max.x || (x=min.x, ++y < max.y) || (y=min.y, false));
    }
    
    inline bool ImageRef::prev(const ImageRef& max) // move back to the previous value
    {
        return(--x > -1 || (x=max.x-1, --y > -1) || (y=max.y-1, false));
    }
    
    inline bool ImageRef::prev(const ImageRef& min, const ImageRef& max)
    {
        return (--x > min.x-1 || (x=max.x-1, --y > min.y-1) || (y=max.y-1, false));
    }
    
    inline void ImageRef::home()
    {
        x=y=0;
    }
    
    inline void ImageRef::end(const ImageRef& size)
    {
        x=size.x-1;
        y=size.y-1;
    }
    
    inline ImageRef& ImageRef::operator=(const ImageRef& ref)
    {
        x=ref.x;
        y=ref.y;
        return *this;
    }
    
    inline bool ImageRef::operator ==(const ImageRef& ref) const
    {
        return (x==ref.x && y==ref.y);
    }
    
    inline bool ImageRef::operator !=(const ImageRef& ref) const
    {
        return (x!=ref.x || y!=ref.y);
    }
    
    inline ImageRef ImageRef::operator-() const
    {
        ImageRef v(-x, -y);
        return v;
    }
    
    inline ImageRef& ImageRef::operator*=(const double scale)
    {
        x=(int)(x*scale);
        y=(int)(y*scale);
        return *this;
    }
    
    inline ImageRef& ImageRef::operator/=(const double scale)
    {
        x=(int)(x/scale);
        y=(int)(y/scale);
        return *this;
    }
    
    inline ImageRef& ImageRef::operator+=(const ImageRef rhs)
    {
        x+=rhs.x;
        y+=rhs.y;
        return *this;
    }
    
    inline ImageRef& ImageRef::operator-=(const ImageRef rhs)
    {
        x-=rhs.x;
        y-=rhs.y;
        return *this;
    }
    
    inline ImageRef ImageRef::operator*(const double scale) const
    {
        ImageRef v((int)(x*scale),(int)(y*scale));
        return v;
    }
    
    inline ImageRef ImageRef::operator/(const double scale) const
    {
        ImageRef v((int)(x/scale),(int)(y/scale));
        return v;
    }
    
    inline ImageRef ImageRef::operator+(const ImageRef rhs) const
    {
        ImageRef v(x+rhs.x, y+rhs.y);
        return v;
    }
    
    inline ImageRef ImageRef::operator-(const ImageRef rhs) const
    {
        ImageRef v(x-rhs.x, y-rhs.y);
        return v;
    }
    
    inline ImageRef& ImageRef::operator<<=(int i)
    {
        x = x << i;
        y=y << i;
        return *this;
    }
    
    inline ImageRef& ImageRef::operator>>=(int i)
    {
        x = x >> i;
        y=y >> i;
        return *this;
    }
    
    inline ImageRef ImageRef::shiftl(int i) const
    {
        ImageRef result;
        result.x = x << i;
        result.y=y << i;
        return result;
    }
    
    inline ImageRef ImageRef::shiftr(int i) const
    {
        ImageRef result;
        result.x = x >> i;
        result.y=y >> i;
        return result;
    }
    
    inline ImageRef ImageRef::operator<<(int i) const
    {
        return shiftl(i);
    }
    
    inline ImageRef ImageRef::operator>>(int i) const
    {
        return shiftr(i);
    }
    
    
    inline ImageRef operator*(const int scale, const ImageRef&  ref)
    {
        return ImageRef(ref.x*scale, ref.y*scale);
    }
    
    inline bool ImageRef::operator<(const ImageRef & other) const
    {
        return y < other.y || ( y == other.y && x < other.x);
    }
    
    inline bool ImageRef::operator>(const ImageRef & other) const
    {
        return y > other.y || ( y == other.y && x > other.x);
    }
    
    
    inline int& ImageRef::operator[](int i)
    {
        if(i==0)
            return x;
        if(i==1)
            return y;
        throw Exceptions::BadSubscript();
    }
    
    inline int ImageRef::operator[](int i) const
    {
        if(i==0)
            return x;
        if(i==1)
            return y;
        throw Exceptions::BadSubscript();
    }
    
    inline unsigned int ImageRef::mag_squared() const
    {
        typedef unsigned int uint;
        return uint(x*x) + uint(y*y);
    }
    
    inline int ImageRef::area() const
    {
        return x * y;
    }
    
    inline ImageRef ImageRef::dot_times(const ImageRef &ref) const
    {
        return ImageRef(x * ref.x, y * ref.y);
    }
    

// Streams stuff for ImageRef class //

inline std::ostream& operator<<(std::ostream& os, const ImageRef& ref)
{
    return os << "[" << ref.x << " " << ref.y << "]";
}

inline std::istream& operator>>(std::istream& is, ImageRef& ref)
{
    //Full parsing for ImageRefs, to allow it to accept the
    //output produced above, as well as the older (x,y) format
    is >> std::ws;

    unsigned char c = is.get();

    if(is.eof())
        return is;

    if(c == '(' )
    {
        is >> std::ws >> ref.x >> std::ws;

        if(is.get() != ',')
            goto bad;

        is >> std::ws >> ref.y >> std::ws;

        if(is.get() != ')')
            goto bad;
    }
    else if(c == '[' )
    {
        is >> std::ws >> ref.x >> std::ws >> ref.y >> std::ws;
        if(is.get() != ']')
            goto bad;
    }
    else if(isdigit(c))
    {
        is.unget();
        is >> ref.x >> ref.y;
    }
    else
        goto bad;

    return is;

    bad:
    is.setstate(std::ios_base::badbit);

    return is;
}

const ImageRef ImageRef_zero(0, 0);


} //namespace CVD


#endif