i_image.h

Go to the documentation of this file.

/*
 * $Id: i_image.h 18301 2014-11-26 19:17:13Z ksimek $
 */

#ifndef KJB_CPP_IMAGE_H
#define KJB_CPP_IMAGE_H

//#include "m_cpp/m_concept.h"
#include "i/i_matrix.h"
#include "i/i_float.h"
#include "i/i_float_io.h"
#include "i/i_transform.h"
#include "i/i_arithmetic.h"
#include "i/i_draw.h"
#include "i2/i2_draw_text.h"

// if not for intensity_histogram(), we could remove all 
// dependencies to m_cpp from i_image.h .  Consider moving to 
// i2_cpp.
#include "m_cpp/m_vector.h"
#include "m_cpp/m_matrix.h"

#include <boost/shared_ptr.hpp>
//#include <boost/concept_check.hpp>

//define YES_WE_WANT_GARBAGE_POLICE /* for debugging */

#include <string>
#include <exception>
#include <stdexcept>
#ifdef YES_WE_WANT_GARBAGE_POLICE
#include <sstream>
#endif

namespace kjb
{
    class Matrix;
    class Int_matrix;
    class Vector;

// some trivial forward declaration stuff we need
class Image;
Image scale_image(const Image&, double);
Image get_inverted(const Image&);
Image rgb_matrices_to_image(const Matrix&, const Matrix&, const Matrix&);



class Image
{
public:
    typedef kjb_c::KJB_image    Impl_type;
    typedef kjb_c::Pixel        Pixel_type;

protected:
    Impl_type* m_image;

private:
    static const char* BAD_CHANNEL;

    static
    void sort2( int& smaller, int& bigger )
    {
        if ( smaller > bigger )
        {
            std::swap( smaller, bigger );
        }
    }

    void compute_row_col( int index, int* row, int* col ) const
    {
        // Test program was HERE.
        *row = index / get_num_cols();
        *col = index - *row * get_num_cols();
    }

    void compute_row_col_carefully( int index, int* row, int* col ) const
    {
        if ( 0 == get_num_cols() )
        {
            *row = *col = 0;
        }
        else
        {
            // Test program was HERE.
            compute_row_col( index, row, col );
        }
    }

#ifdef YES_WE_WANT_GARBAGE_POLICE
    mutable std::string info;
    static int live_object_counter;
    static int serial_counter;
#endif

    void call_me_in_every_ctor()
    {
#ifdef YES_WE_WANT_GARBAGE_POLICE
        ++live_object_counter;
        ++serial_counter;
        std::ostringstream s;
        s << '(' << serial_counter << ')';
        info = s.str() + info;
#endif
    }



public:


    enum RGB_channel { RED, GREEN, BLUE, END_CHANNELS };

    Image(int rows = 0, int cols = 0);

    explicit Image( const kjb_c::Matrix& src );

    explicit Image( const Matrix& src );

    Image( const Image& src );

#ifdef KJB_HAVE_CXX11

    Image(Image&& src)
        : m_image( nullptr )
    {
        m_image = src.m_image;
        src.m_image = 0;
    }
#endif /* KJB_HAVE_CXX11 */



    explicit Image(const std::string& fname);

    explicit Image( Impl_type* wrap_me );

    Image(int num_rows, int num_cols, int r, int g, int b);

    /* /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ */

    /*---------------------------------------------------------------------*
     * "NAMED CONSTRUCTORS"
     *---------------------------------------------------------------------*/

    static
    Image create_zero_image( int rows, int cols )
    {
        return create_initialized_image( rows, cols, 0, 0, 0 );
    }

    static
    Image create_initialized_image( int rows, int cols, int r, int g, int b );

    /* /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ */


    virtual ~Image()
    {
        #ifdef YES_WE_WANT_GARBAGE_POLICE
        fprintf( stderr, "DTOR: %s\n", info.c_str() );
        --live_object_counter;
        #endif

        kjb_c::kjb_free_image(m_image);
    }

    void swap( Image& other )
    {
        using std::swap;
        swap( m_image, other.m_image );
    }

    friend void swap(kjb::Image& a, kjb::Image& b)
    {
        a.swap(b);
    }

    Image& scale(double factor)
    {
        Image i(scale_image(*this, factor));
        swap(i);
        return *this;
    }

    Image& crop(int r, int c, int num_rows, int num_cols);

    #ifdef YES_WE_WANT_GARBAGE_POLICE
    void infocat( const std::string& concat_me ) const { info += concat_me; }
    std::string get_info() const        { return info;                  }
    static int  query_live_counter()    { return live_object_counter;   }
    static int  query_serial_counter()  { return serial_counter;        }
    #endif


    void write(const std::string& fname) const;

    int get_num_rows() const
    {
        return m_image->num_rows;
    }

    int get_num_cols() const
    {
        return m_image->num_cols;
    }

    int get_length() const
    {
        return get_num_rows() * get_num_cols();
    }

    Image& operator=(const kjb_c::KJB_image& src);

    Image& operator=(const Image& src);

#ifdef KJB_HAVE_CXX11

    Image& operator=(Image&& other)
    {
        if(this == &other)
            return *this;

        kjb_c::kjb_free_image( m_image );
        m_image = other.m_image;
        other.m_image = 0;
        return *this;
    }
#endif /* KJB_HAVE_CXX11 */

    Image& operator+=(const Image& op2);

    Image& operator-=(const Image& op2);

    Image& operator*=(double op2);

    Image& operator/=(double op2);

    float& operator()(int row, int col, int channel)
    {
        // Test program was HERE.
        switch(channel)
        {
        case RED:
            return operator()( row, col ).r;
        case GREEN:
            return operator()( row, col ).g;
        case BLUE:
            return operator()( row, col ).b;
        default:
            throw std::out_of_range("Invalid channel");
        }
    }

    float operator()(int row, int col, int channel) const
    {
        switch(channel)
        {
        case RED:
            return operator()( row, col ).r;
        case GREEN:
            return operator()( row, col ).g;
        case BLUE:
            return operator()( row, col ).b;
        default:
            throw std::out_of_range("Invalid channel");
        }
    }

    Pixel_type& operator()( int row, int col )
    {
        return m_image -> pixels[ row ][ col ];
    }

    const Pixel_type& operator()( int row, int col ) const
    {
        return m_image -> pixels[ row ][ col ];
    }

    Pixel_type& operator()( int index )
    {
        int row, col;
        compute_row_col( index, &row, &col );
        return operator()( row, col );
    }

    const Pixel_type& operator()( int index ) const;

    void invert();

    Image get_inverted() const
    {
        return kjb::get_inverted(*this);
    }

    Matrix get_channel(int index) const;

    void check_bounds( int row, int col ) const;


    float& at(int row, int col, int channel);
    float at(int row, int col, int channel) const;

    Pixel_type& at( int row, int col );

    const Pixel_type& at( int row, int col ) const;

    const Pixel_type& at( int index ) const;

    Pixel_type& at( int index );

    const Impl_type* c_ptr() const;

    Impl_type* non_const_c_ptr() const
    {
        return m_image;
    }

    void set_c_ptr(Impl_type * iimage)
    {
#ifdef YES_WE_WANT_GARBAGE_POLICE
       fprintf( stderr, "DTOR: %s\n", info.c_str() );
       --live_object_counter;
#endif

       kjb_c::kjb_free_image(m_image);
       m_image = iimage;
    }

    Matrix to_grayscale_matrix() const;

    Matrix to_grayscale_matrix(double r_w, double g_w, double b_w) const;

    Matrix to_channel_matrix(RGB_channel channel) const;


    Int_matrix to_color_matrix(double scale = 1.0) const;

    void from_color_matrix(const Int_matrix& m);

    void from_color_matrices(
        const Matrix& red,
        const Matrix& green,
        const Matrix& blue
    );

    template<class InputIterator>
    Vector intensity_histogram(InputIterator first, InputIterator last) const;

    void draw_point(
        int row,      
        int col,      
        int width,    
        Pixel_type p  
    );

    void draw_line_segment(
        int row_from, 
        int col_from, 
        int row_to,   
        int col_to,   
        int width,    
        Pixel_type p  
    );

    void draw_arrow
    (
        const Vector& src,
        const Vector& dest,
        const Image::Pixel_type pixel
    );

    template <class Iterator>
    void draw_polyline(
            Iterator begin,
            Iterator end,
            int width,
            Pixel_type p  
    )
    {
        typedef typename std::iterator_traits<Iterator>::value_type value_type;
//        BOOST_CONCEPT_ASSERT((kjb::SimpleVector<value_type>));

        if(begin == end) return; // empty range

        Iterator it = begin;
        Iterator it2 = begin;
        ++it2;
        for(; it2 != end; ++it, ++it2)
        {
            draw_line_segment((*it)[1], (*it)[0], (*it2)[1], (*it2)[0], width, p);
        }
    }

    void draw_aa_rectangle(
        int first_row,      
        int first_col,      
        int last_row,       
        int last_col,       
        Pixel_type p        
    );

    void draw_aa_rectangle_outline(
        int first_row,      
        int first_col,      
        int last_row,       
        int last_col,       
        Pixel_type p        
    );

    void draw_circle(
        int center_row,     
        int center_col,     
        int radius,         
        int line_width,     
        Pixel_type p        
    );


    void draw_disk(
        int center_row,     
        int center_col,     
        int radius,         
        Pixel_type p        
    );


    int draw_text_center(
        int row,
        int col,
        const std::string& text,
        const std::string& font_file = "times14"
    );

    int draw_text_top_left(
        int row,
        int col,
        const std::string& text,
        const std::string& font_file = "times14"
    );

    void draw_image(
        const kjb_c::KJB_image* overlay,
        int row = 0,
        int col = 0,
        int scale = 1
    );

    void draw_image(
        const Image& overlay,
        int row = 0,
        int col = 0,
        int scale = 1
    );

    int display( const std::string& title = std::string() ) const;

    int get_flags() const
    {
        return m_image -> flags;
    }

    int set_flags(int new_flags)
    {
        int old_flags = m_image -> flags;
        m_image -> flags = new_flags;
        return old_flags;
    }
};

typedef boost::shared_ptr<Image> Image_ptr;


Image scale_image(const Image& i, double factor);



Matrix to_grayscale_matrix(const Image& i);

inline Image get_inverted(const Image& i)
{
    Image res(i);
    res.invert();
    return res;
}


//---------------------------------------------------------
// ARITHMETIC OPERATORS
//---------------------------------------------------------

inline
Image operator*(const Image& op1, double op2)
{
    return Image(op1) *= op2;
}

inline
Image operator/(const Image& op1, double op2)
{
    return Image(op1) /= op2;
}

inline
Image operator+(const Image& op1, const Image& op2)
{
    return Image(op1) += op2;
}

inline
Image operator-(const Image& im1, const Image& im2)
{
    return Image(im1) -= im2;
}


inline void enable_transparency(Image& i)
{
    i.set_flags(i.get_flags() | HAS_ALPHA_CHANNEL);
}


inline void disable_transparency(Image& i)
{
    i.set_flags(i.get_flags() & ~HAS_ALPHA_CHANNEL);
}


inline bool is_transparency_enabled(const Image& i)
{
    return i.get_flags() & HAS_ALPHA_CHANNEL;
}


//---------------------------------------------------------
// IMPLEMENTATION OF TEMPLATE MEMBERS
//---------------------------------------------------------

template<class InputIterator>
Vector Image::intensity_histogram(InputIterator first, InputIterator last) const
{
    Matrix I = to_grayscale_matrix();
    Vector hist(static_cast<int>(256), static_cast<double>(get_length() / 256.0));

    for(; first != last; first++)
    {
        int val = static_cast<int>(I(first->first, first->second));
        hist[val] += 0.7;

        if(val != 0)
        {
            hist[val - 1] += 0.15;
        }

        if(val != 255)
        {
            hist[val + 1] += 0.15;
        }
    }

    return hist;
}



} //namespace kjb

#endif /*KJB_CPP_IMAGE_H */