image.h

Go to the documentation of this file.

#ifndef IMAGE_INCLUDED
#define IMAGE_INCLUDED
 
#include <stdio.h>
#include <string>
#include <stdexcept>
#include <Util/geometry.h>
#include "lineSegments.h"
 
namespace Image
{
    class Pixel32
    {
    public:
        unsigned char r;
 
        unsigned char g;
 
        unsigned char b;
 
        unsigned char a;
 
        Pixel32( void );
    };
    class Pixel32 {…};
 
 
    class Image32
    {
        int _width , _height;
 
        Pixel32* _pixels;
 
        void _assertInBounds( int x , int y ) const;
    public:
 
        struct iterator
        {
            using iterator_category = std::forward_iterator_tag;
            using reference = Pixel32 &;
            using pointer = Pixel32 *;
            using value_type = Pixel32;
            using difference_type = std::ptrdiff_t;
 
            iterator( void ) : _p(NULL) {}
            iterator( Pixel32 *p ) : _p(p) {}
            bool operator == ( const iterator &it ) const { return _p==it._p; }
            bool operator != ( const iterator &it ) const { return _p!=it._p; }
            iterator operator ++( int ){ iterator it = *this ; _p++ ; return it; }
            iterator &operator ++( void ){ _p++ ; return *this; }
            Pixel32 &operator * ( void ){ return *_p; }
            Pixel32 *operator -> ( void ){ return _p; }
        protected:
            friend Image32;
            Pixel32 *_p;
        };
        struct iterator {…};
 
        struct const_iterator
        {
            using iterator_category = std::forward_iterator_tag;
            using reference = const Pixel32 &;
            using pointer = const Pixel32 *;
            using value_type = Pixel32;
            using difference_type = std::ptrdiff_t;
 
            const_iterator( void ) : _p(nullptr) {}
            const_iterator( const Pixel32 *p ) : _p(p) {}
            bool operator == ( const const_iterator &it ) const { return _p==it._p; }
            bool operator != ( const const_iterator &it ) const { return _p!=it._p; }
            const_iterator operator ++( int ){ const_iterator it = *this ; _p++ ; return it; }
            const_iterator &operator ++( void ){ _p++ ; return *this; }
            const Pixel32 &operator * ( void ){ return *_p; }
            const Pixel32 *operator -> ( void ){ return _p; }
        protected:
            friend Image32;
            const Pixel32 *_p;
        };
        struct const_iterator {…};
 
        iterator begin( void ){ return iterator( _pixels ); }
        iterator   end( void ){ return iterator( _pixels+_width*_height ); }
        const_iterator begin( void ) const { return const_iterator( _pixels ); }
        const_iterator   end( void ) const { return const_iterator( _pixels+_width*_height ); }
 
        Image32( void );
 
        Image32( const Image32& img );
 
        Image32( Image32&& img );
 
        Image32& operator = ( const Image32& img );
 
        Image32& operator = ( Image32&& img );
 
        ~Image32( void );
 
        void setSize( int width , int height );
 
        int width( void ) const;
 
        int height( void ) const;
 
        Pixel32& operator() ( int x , int y );
 
        const Pixel32& operator() ( int x , int y ) const;
 
        void read( std::string fileName );
 
        void write( std::string fileName ) const;
 
        Image32 addRandomNoise( double noise ) const;
 
        Image32 brighten( double brightness ) const;
 
        Image32 luminance( void ) const;
 
        Image32 contrast( double contrast ) const;
 
        Image32 saturate( double saturation ) const;
 
        Image32 quantize( int bits ) const;
 
        Image32 randomDither( int bits ) const;
 
        Image32 orderedDither2X2( int bits ) const;
 
        Image32 floydSteinbergDither( int bits ) const;
 
        Image32 blur3X3( void ) const;
 
        Image32 edgeDetect3X3( void ) const;
 
        Image32 scaleNearest( double scaleFactor ) const;
 
        Image32 scaleBilinear( double scaleFactor ) const;
 
        Image32 scaleGaussian( double scaleFactor ) const;
 
        Image32 rotateNearest( double angle ) const;
 
        Image32 rotateBilinear( double angle ) const;
 
        Image32 rotateGaussian( double angle ) const;
 
        void setAlpha( const Image32& matte );
 
        Image32 composite( const Image32& overlay ) const;
 
        Image32 crop( int x1 , int y1 , int x2 , int y2 ) const;
 
        Image32 funFilter( void ) const;
 
        static Image32 BeierNeelyMorph( const Image32& source , const Image32& destination , const OrientedLineSegmentPairs& olsp , double timeStep );
 
        Image32 warp( const OrientedLineSegmentPairs& olsp ) const;
 
        static Image32 CrossDissolve( const Image32& source , const Image32& destination , double blendWeight );
 
        Pixel32 nearestSample( Util::Point2D p ) const;
 
        Pixel32 bilinearSample( Util::Point2D p ) const;
 
        Pixel32 gaussianSample( Util::Point2D p , double variance , double radius ) const;
    };
    class Image32 {…};
}
#endif // IMAGE_INCLUDED