image_ref.h

//-*- 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 <cassert>
#include <cctype>
#include <cvd/exceptions.h>
#include <iostream>

namespace CVD
{


// CVD::ImageRef                    //
class ImageRef
{
    public:
    //Construction
    constexpr ImageRef();
    constexpr ImageRef(const ImageRef&) = default;

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

    //#if __cplusplus >= 201103
    //
    //ImageRef(const std::initializer_list<int>& init)
    //  :
    //  #endif

    //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

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

    constexpr unsigned int mag_squared() const;

    constexpr int area() const;

    constexpr ImageRef dot_times(const ImageRef& ref) const;

    constexpr int& operator[](int i);

    constexpr int operator[](int i) const;

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

    constexpr ImageRef transpose() const
    {
        return ImageRef(y, x);
    }

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

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

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

#include <cvd/internal/image_ref_implementation.hh>

// 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;

    int c = is.get();

    if(c == -1)
        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