Image< T > Class Template Reference

#include <Image.h>

Inheritance diagram for Image< T >:

Collaboration diagram for Image< T >:

Public Types
typedef std::vector< T >::iterator	iterator
typedef std::vector< T >::const_iterator	const_iterator

Public Member Functions
	Image ()
	Image (int sx, int sy)
	Image (int sx, int sy, const T &value)
	Image (const Image< T > &rhs)
virtual	~Image ()
void	freeImage ()
void	setSize (int nx, int ny)
void	setSize (int nx, int ny, const T &value)
template<class S >
bool	sameSize (const Image< S > &rhs)
const T *	getData () const
T *	getData ()
int	getSizeX () const
int	getSizeY () const
int	getSize () const
Image< T > &	operator= (const Image< T > &rhs)
Image< T > &	operator= (const T &rhs)
Image< T > &	copy (const Image< T > &rhs)
Image< T > &	copy (const T *rhs)
int	getIndex (int x, int y) const
int	getBoundedIndex (int x, int y) const
const T	getPixel (int x, int y) const
void	setPixel (int x, int y, const T &value)
const T	findMax () const
	calculate maximum More...
const T	findMin () const
	calculate minimum More...
const T	norm () const
double	sum () const
Image< T > &	operator*= (const T &v)
Image< T > &	operator/= (const T &v)
Image< T > &	operator+= (const T &v)
Image< T > &	operator-= (const T &v)
Image< T > &	operator*= (const Image< T > &rhs)
Image< T > &	operator/= (const Image< T > &rhs)
Image< T > &	operator+= (const Image< T > &rhs)
Image< T > &	operator-= (const Image< T > &rhs)
void	addLine (int x0, int y0, int x1, int y1, const T &value)
Image< T > &	unsetNAN (double val=0)
Image< T > &	threshold (const T &th, double binarize=0)
Image< T > &	findMaxima (int env=3)
template<class S >
Image< T > &	convertFrom (const Image< S > &rhs)
const Image< T >	mirror (bool horiz=true, bool vert=true) const
template<class S >
const Image< T >	convolve (const Image< S > &kernel) const
Image< T > &	interleave (const std::vector< Image< T > > &img, dword ncomp=0)
Image< T >	scaleBy (float s)
Image< T >	scaleBy (float sx, float sy)
bool	initialized () const
bool	writePPM (const std::string &fname) const
bool	writePPMstream (std::ostream &os) const
bool	readPPM (const std::string &fname)
bool	readPPMstream (std::istream &is)
void	insert (const Image< T > &ii, const int x=0, const int y=0)
Image< T > &	zeroPad (int brd, const T &col=0, bool smoothbrd=false)

Protected Attributes
int	sizeX
int	sizeY

Friends
std::ostream &	operator<< (std::ostream &os, const Image< T > &rhs)
std::istream &	operator>> (std::istream &is, Image< T > &rhs)

Detailed Description

template<class T>
class Image< T >

Definition at line 16 of file Image.h.

Member Typedef Documentation

template<class T>

typedef std::vector<T>::const_iterator Image< T >::const_iterator

Definition at line 20 of file Image.h.

template<class T>

typedef std::vector<T>::iterator Image< T >::iterator

Definition at line 19 of file Image.h.

Constructor & Destructor Documentation

template<class T >

Image< T >::Image

(

)

Definition at line 249 of file Image.h.

References Image< T >::sizeX, and Image< T >::sizeY.

Referenced by Image< Point2D >::Image().

{
    sizeX = sizeY = 0;
}

template<class T>

Image< T >::Image ( int  sx, int  sy  )

inline

Definition at line 23 of file Image.h.

        : std::vector<T>(sx*sy), sizeX(sx), sizeY(sy) {};

template<class T>

Image< T >::Image ( int  sx, int  sy, const T &  value  )

inline

Definition at line 25 of file Image.h.

        : std::vector<T>(sx*sy, value), sizeX(sx), sizeY(sy) {};

template<class T>

Image< T >::Image

(

const Image< T > &

rhs

)

Definition at line 255 of file Image.h.

References Image< T >::operator=().

{
    operator=(rhs);
}

template<class T>

virtual Image< T >::~Image ( )

inlinevirtual

Definition at line 28 of file Image.h.

{};

Member Function Documentation

template<class T>

void Image< T >::addLine	(	int	x0,
		int	y0,
		int	x1,
		int	y1,
		const T &	value
	)

Definition at line 441 of file Image.h.

References absint(), Image< T >::getData(), and Image< T >::sizeX.

Referenced by Image< Point2D >::setPixel().

{
    if(std::vector<T>::empty()) return;
    //left point first?
    if(x0>x1) {
        x0 += x1; x1 = x0-x1; x0 -= x1;     //who needs a dummy?
        y0 += y1; y1 = y0-y1; y0 -= y1;
    }
    T* dpos = getData() + x0 + y0*sizeX;
    int pincY = sizeX;
    int xinc = 1;
    int yinc = 1;
    int dy = y1 - y0;
    int dx = x1 - x0;

    int nx = dy;    //normal (negative reciprocal direction)
    int ny = -dx;

    int dir = dx>absint(dy) ? 1 : -1;
    if(dy<0)
    {
        yinc=-1;
        pincY = -pincY;
    }

    if(dir==1)
    {
        int diagInc = 2*(nx+ny*yinc);
        int axisInc = 2*nx;

        int x = x0;
        int y = y0;

        int d = 2*nx + ny*yinc;
        while (x <= x1)
        {
            *dpos += value;
            if (d*yinc >= 0) {                      // move diagonally
                y += yinc;
                dpos += pincY;
                d += diagInc;
            }
            else d += axisInc;
            x += xinc;
            dpos += xinc;
        }
    } else {
        int diagInc = 2*(nx+ny*yinc);
        int axisInc = 2*ny*yinc;

        int x = x0;
        int y = y0;
        int d = 2*ny*yinc + nx;
        int cnt = absint(dy);
        while (cnt--)
        {
            *dpos += value;
            if (d*yinc <= 0) {                      // move diagonally
                x += xinc;
                dpos += xinc;
                d += diagInc;
            }
            else d += axisInc;
            y += yinc;
            dpos += pincY;
        }
        *dpos += value;
    }
}

template<class T>

template<class S >

Image<T>& Image< T >::convertFrom ( const Image< S > &  rhs )

inline

Definition at line 91 of file Image.h.

Referenced by ImageWindow::selectSensor().

        {
            setSize(rhs.getSizeX(),rhs.getSizeY());
            const S* sd = rhs.getData();
            T* dd = getData();
            for(int i=getSize();i>0;i--,dd++,sd++)
                *dd = T(*sd);
            return *this;
        }

template<class T>

template<class S >

const Image<T> Image< T >::convolve ( const Image< S > &  kernel ) const

inline

Definition at line 116 of file Image.h.

Referenced by Image< T >::zeroPad().

        {
            Image<T> dst(sizeX,sizeY);
            int ksx = kernel.getSizeX()/2;
            int ksy = kernel.getSizeY()/2;
            int endX = sizeX-ksx;
            int endY = sizeY-ksy;
            //int offset = ksy*sizeX+ksx;
            int winskip = sizeX-kernel.getSizeX();
            T* dstdat = dst.getData() + ksx + (ksy*sizeX);
            const T* srcdat = getData();
            for(int i=ksy;i<endY;i++)
            {
                for(int j=ksx;j<endX;j++,dstdat++,srcdat++)
                {
                    S sum = 0;
                    const S *kdat = kernel.getData();
                    const T *sdat = srcdat;
                    for(int l=0;l<kernel.getSizeY();l++)
                    {
                        for(int k=0;k<kernel.getSizeX();k++, kdat++, sdat++)
                        {
                            sum += *kdat**sdat;
                        }
                        sdat += winskip;
                    }
                    *dstdat = T(sum);
                }
                dstdat+=ksx*2;
                srcdat+=ksx*2;
            }
            return dst;
        }

template<class T>

Image< T > & Image< T >::copy

(

const Image< T > &

rhs

)

Definition at line 287 of file Image.h.

References Image< T >::getSizeX(), Image< T >::getSizeY(), Image< T >::sizeX, and Image< T >::sizeY.

Referenced by Image< Point2D >::getSize(), and Image< T >::operator=().

{
    if(&rhs == this) return *this;
    std::vector<T>::operator=(rhs);
    sizeX = rhs.getSizeX();
    sizeY = rhs.getSizeY();
    return *this;
}

template<class T>

Image< T > & Image< T >::copy

(

const T *

rhs

)

Definition at line 297 of file Image.h.

{
    for(iterator pnt = std::vector<T>::begin(); pnt != std::vector<T>::end(); pnt++, rhs++)
        *pnt = *rhs;
    return *this;
}

template<class T >

const T Image< T >::findMax

(

)

const

calculate maximum

Definition at line 322 of file Image.h.

References Image< T >::getData(), and Image< T >::getSize().

Referenced by Image< Point2D >::setPixel().

{
    if(std::vector<T>::empty()) return 0;
    const T* pnt = getData();
    T max = *pnt;
    for(int i=getSize(); i>0; i--, pnt++)
        if(*pnt>max) max = *pnt;
    return max;
}

template<class T >

Image< T > & Image< T >::findMaxima

(

int

env = 3

)

Definition at line 532 of file Image.h.

References Image< T >::getData(), Image< T >::sizeX, and Image< T >::sizeY.

Referenced by Image< Point2D >::setPixel().

{
    env = (env/2)*2 + 1;
    int ksx = env/2;
    int ksy = env/2;
    int endX = sizeX-ksx;
    int endY = sizeY-ksy;
    int offset = ksy*sizeX+ksx;
    int winskip = sizeX-env;
    T* srcdat = getData();
    T* maxpnt = getData()+offset;
    for(int i=ksy;i<endY;i++)
    {
        for(int j=ksx;j<endX;j++,srcdat++, maxpnt++)
        {
            bool ismax = true;
            const T *sdat = srcdat;
            maxpnt = srcdat+offset;
            for(int l=0;l<env && ismax; l++)
            {
                for(int k=0;k<env && ismax; k++, sdat++)
                {
                    if(*maxpnt<=*sdat &&
                       maxpnt != sdat) ismax=false;
                }
                sdat += winskip;    //jump to next line
            }
            if(!ismax) *maxpnt = 0;
        }
        maxpnt+=ksx*2;
        srcdat+=ksx*2;
    }
    return *this;
}

template<class T >

const T Image< T >::findMin

(

)

const

calculate minimum

Definition at line 333 of file Image.h.

References Image< T >::getData(), and Image< T >::getSize().

Referenced by Image< Point2D >::setPixel().

{
    if(std::vector<T>::empty()) return 0;
    const T* pnt = getData();
    T min = *pnt;
    for(int i=getSize(); i>0; i--, pnt++)
        if(*pnt<min) min = *pnt;
    return min;
}

template<class T >

void Image< T >::freeImage

(

)

Definition at line 261 of file Image.h.

References Image< T >::setSize(), Image< T >::sizeX, and Image< T >::sizeY.

Referenced by Image< Point2D >::~Image().

{
    setSize(0);
    sizeX = sizeY = 0;
}

template<class T>

int Image< T >::getBoundedIndex ( int  x, int  y  ) const

inline

Definition at line 52 of file Image.h.

                                            {
        if((dword)x < (dword)sizeX && (dword)y < (dword)sizeY)
            return sizeX*y+x;
        else
            return -1;
    }

template<class T>

const T* Image< T >::getData ( ) const

inline

Definition at line 39 of file Image.h.

Referenced by Image< T >::addLine(), Image< Point2D >::convertFrom(), Image< Point2D >::convolve(), copyFXImage2Image(), copyImage2FXImage(), create2DGaussian(), Dataset::drawImage(), Image< T >::findMax(), Image< T >::findMaxima(), Image< T >::findMin(), Image< Point2D >::interleave(), makeNoiseImage(), Image< T >::norm(), Image< T >::operator*=(), Image< T >::operator+=(), Image< T >::operator-=(), Image< T >::operator/=(), GLImage::setImage(), Image< T >::sum(), Image< T >::threshold(), and Image< T >::unsetNAN().

{return &(*std::vector<T>::begin());}

template<class T>

T* Image< T >::getData ( )

inline

Definition at line 40 of file Image.h.

{return &(*std::vector<T>::begin());}

template<class T>

int Image< T >::getIndex ( int  x, int  y  ) const

inline

Definition at line 51 of file Image.h.

Referenced by Image< Point2D >::getPixel(), Image< T >::insert(), and Image< Point2D >::setPixel().

{ return sizeX*y+x; }

template<class T>

const T Image< T >::getPixel ( int  x, int  y  ) const

inline

Definition at line 59 of file Image.h.

Referenced by Image< Point2D >::mirror().

                                         {
        return std::vector<T>::at(getIndex(x,y));
    }

template<class T>

int Image< T >::getSize ( ) const

inline

Definition at line 44 of file Image.h.

Referenced by Image< Point2D >::convertFrom(), Image< T >::findMax(), Image< T >::findMin(), Image< T >::norm(), Image< T >::operator*=(), Image< T >::operator+=(), Image< T >::operator-=(), Image< T >::operator/=(), Image< T >::sum(), Image< T >::threshold(), Image< T >::unsetNAN(), and SmoothIntensitySensor::updateScale().

{ return std::vector<T>::size();}

template<class T>

int Image< T >::getSizeX ( ) const

inline

Definition at line 42 of file Image.h.

Referenced by PPSensor::calcAllValues(), Image< Point2D >::convertFrom(), Image< Point2D >::convolve(), Image< T >::copy(), copyImage2FXImage(), create2DGaussian(), Dataset::drawImage(), PPSensor::fitSheets(), Image< T >::insert(), Image< Point2D >::interleave(), Dataset::load(), makeNoiseImage(), Image< Point2D >::mirror(), Image< Point2D >::sameSize(), Image< Point2D >::scaleBy(), GLImage::setImage(), and Image< T >::zeroPad().

{ return sizeX;}

template<class T>

int Image< T >::getSizeY ( ) const

inline

Definition at line 43 of file Image.h.

Referenced by PPSensor::calcAllValues(), Image< Point2D >::convertFrom(), Image< Point2D >::convolve(), Image< T >::copy(), copyImage2FXImage(), create2DGaussian(), Dataset::drawImage(), PPSensor::fitSheets(), Image< T >::insert(), Image< Point2D >::interleave(), Dataset::load(), makeNoiseImage(), Image< Point2D >::mirror(), Image< Point2D >::sameSize(), Image< Point2D >::scaleBy(), GLImage::setImage(), and Image< T >::zeroPad().

{ return sizeY;}

template<class T>

bool Image< T >::initialized ( ) const

inline

Returns

true if image has been initialized (data is not NULL)

Definition at line 191 of file Image.h.

{ return !std::vector<T>::empty(); }

template<class T>

void Image< T >::insert	(	const Image< T > &	ii,
		const int	x = 0,
		const int	y = 0
	)

Definition at line 568 of file Image.h.

References Image< T >::getIndex(), Image< T >::getSizeX(), and Image< T >::getSizeY().

Referenced by Dataset::load(), GLImage::setImage(), and Image< T >::zeroPad().

{
    const int iwidth = std::min(getSizeX() - x, ii.getSizeX());
    const int iheight = std::min(getSizeY() - y, ii.getSizeY());
    if(iwidth>0 && iheight>0)
    {
        for(int j=0; j<iheight; j++) {
            const_iterator src = ii.begin()+ii.getIndex(0,j);
            iterator dst = std::vector<T>::begin()+getIndex(x,j+y);
            for(int i=0; i<iwidth; i++, src++, dst++)
            {
                *dst = *src;
            }
        }
    }
}

template<class T>

Image<T>& Image< T >::interleave ( const std::vector< Image< T > > &  img, dword  ncomp = 0  )

inline

Definition at line 150 of file Image.h.

Referenced by GLImage::setImage().

        {
            if(!ncomp) ncomp = img.size();
            const int comp = img.size()>ncomp ? ncomp : img.size();
            const int size = img[0].size();
            setSize(img[0].getSizeX()*ncomp, img[0].getSizeY());
            Image<byte>::const_iterator bi[comp];
            for(int a=0; a<comp; a++) bi[a] = img[a].begin();
            T *cv = getData();
            const int cvinc = ncomp-comp;
            for(int i=0; i<size; i++) {
                for(int a=0; a<comp; a++) {
                    *(cv++) = *bi[a];
                    bi[a]++;
                }
                cv += cvinc;
            }
            return *this;
        }

template<class T>

const Image<T> Image< T >::mirror ( bool  horiz = true, bool  vert = true  ) const

inline

Definition at line 101 of file Image.h.

        {
            Image<T> dimg(getSizeX(),getSizeY());
            int i,j;
            for(j=0;j<getSizeY();j++)
                for(i=0;i<getSizeX();i++)
                {
                    int si = horiz ? getSizeX()-i-1 : i;
                    int sj = vert ? getSizeY()-j-1 : j;
                    dimg.setPixel(i,j,getPixel(si,sj));
                }
            return dimg;
        }

template<class T >

const T Image< T >::norm

(

)

const

calculate 2-norm of 2D array internally using double, so only works on scalar data types

Definition at line 344 of file Image.h.

References Image< T >::getData(), Image< T >::getSize(), dmutil::sqrt(), and Image< T >::sum().

Referenced by Image< Point2D >::setPixel().

{
    double sum=0;
    const T* pnt = getData();
    for(int i=getSize(); i>0; i--, pnt++)
        sum += *pnt**pnt;
    sum = T(sqrt(sum));
    return T(sum);
}

template<class T>

Image< T > & Image< T >::operator*=

(

const T &

v

)

Definition at line 365 of file Image.h.

References Image< T >::getData(), and Image< T >::getSize().

Referenced by Image< Point2D >::setPixel().

{
    T* pnt = getData();
    for(int i=getSize(); i>0; i--, pnt++)
        *pnt *= v;
    return *this;
}

template<class T>

Image< T > & Image< T >::operator*=

(

const Image< T > &

rhs

)

Definition at line 401 of file Image.h.

References Image< T >::getData(), and Image< T >::getSize().

{
    T* pnt = getData();
    const T* rval = rhs.getData();
    for(int i=getSize(); i>0; i--, pnt++, rval++)
        *pnt *= *rval;
    return *this;
}

template<class T>

Image< T > & Image< T >::operator+=

(

const T &

v

)

Definition at line 383 of file Image.h.

References Image< T >::getData(), and Image< T >::getSize().

Referenced by Image< Point2D >::setPixel().

{
    T* pnt = getData();
    for(int i=getSize(); i>0; i--, pnt++)
        *pnt += v;
    return *this;
}

template<class T>

Image< T > & Image< T >::operator+=

(

const Image< T > &

rhs

)

Definition at line 421 of file Image.h.

References Image< T >::getData(), and Image< T >::getSize().

{
    T* pnt = getData();
    const T* rval = rhs.getData();
    for(int i=getSize(); i>0; i--, pnt++)
        *pnt += *rval;
    return *this;
}

template<class T>

Image< T > & Image< T >::operator-=

(

const T &

v

)

Definition at line 392 of file Image.h.

References Image< T >::getData(), and Image< T >::getSize().

Referenced by Image< Point2D >::setPixel().

{
    T* pnt = getData();
    for(int i=getSize(); i>0; i--, pnt++)
        *pnt -= v;
    return *this;
}

template<class T>

Image< T > & Image< T >::operator-=

(

const Image< T > &

rhs

)

Definition at line 431 of file Image.h.

References Image< T >::getData(), and Image< T >::getSize().

{
    T* pnt = getData();
    const T* rval = rhs.getData();
    for(int i=getSize(); i>0; i--, pnt++)
        *pnt -= *rval;
    return *this;
}

template<class T>

Image< T > & Image< T >::operator/=

(

const T &

v

)

Definition at line 374 of file Image.h.

References Image< T >::getData(), and Image< T >::getSize().

Referenced by Image< Point2D >::setPixel().

{
    T* pnt = getData();
    for(int i=getSize(); i>0; i--, pnt++)
        *pnt /= v;
    return *this;
}

template<class T>

Image< T > & Image< T >::operator/=

(

const Image< T > &

rhs

)

Definition at line 411 of file Image.h.

References Image< T >::getData(), and Image< T >::getSize().

{
    T* pnt = getData();
    const T* rval = rhs.getData();
    for(int i=getSize(); i>0; i--, pnt++)
        *pnt /= *rval;
    return *this;
}

template<class T>

Image< T > & Image< T >::operator=

(

const Image< T > &

rhs

)

Definition at line 305 of file Image.h.

References Image< T >::copy().

Referenced by Image< Point2D >::getSize(), and Image< T >::Image().

{
    return copy(rhs);
}

template<class T>

Image< T > & Image< T >::operator=

(

const T &

rhs

)

Definition at line 311 of file Image.h.

References Image< T >::sizeX, and Image< T >::sizeY.

{
    if(!std::vector<T>::empty() && sizeX>0 && sizeY>0)
    {
        for(iterator pnt = std::vector<T>::begin(); pnt != std::vector<T>::end(); pnt++)
            *pnt = rhs;
    }
    return *this;
}

template<class T>

bool Image< T >::readPPM ( const std::string &  fname )

inline

Definition at line 218 of file Image.h.

                                         {
        std::fstream ifile(fname.c_str(), std::ios::binary|std::ios::in);
        return readPPMstream(ifile);
    }

template<class T>

bool Image< T >::readPPMstream ( std::istream &  is )

inline

Definition at line 223 of file Image.h.

Referenced by Image< Point2D >::readPPM().

                                       {
        if(!is) return false;
        is >> sizeX;
        is >> sizeY;
        std::vector<T>::resize(sizeX*sizeY);
        is.read((char*)&std::vector<T>::front(), sizeX*sizeY);
        return true;
    }

template<class T>

template<class S >

bool Image< T >::sameSize ( const Image< S > &  rhs )

inline

Definition at line 35 of file Image.h.

        { return rhs.getSizeX()==sizeX && rhs.getSizeY()==sizeY; }

template<class T>

Image<T> Image< T >::scaleBy ( float  s )

inline

Definition at line 171 of file Image.h.

Referenced by Image< Point2D >::scaleBy().

{ return scaleBy(s,s); }

template<class T>

Image<T> Image< T >::scaleBy ( float  sx, float  sy  )

inline

Definition at line 172 of file Image.h.

        {
            //can only scale down by integral numbers
            int stepx = (int)round(1/sx); if(stepx<=0) stepx=1;
            int stepy = (int)round(1/sy); if(stepy<=0) stepy=1;
            Image<T> nimg(getSizeX()/stepx, getSizeY()/stepy);
            Image<T>::const_iterator src = std::vector<T>::begin();
            Image<T>::iterator dst = nimg.begin();
            for(int j=0; j<nimg.sizeY; j++) {
                Image<T>::const_iterator linebegin = src;
                for(int i=0; i<nimg.sizeX; i++, dst++, src+=stepx) {
                    *dst = *src;
                }
                src = linebegin+(stepy*sizeX);
            }
            return nimg;
        }

template<class T>

void Image< T >::setPixel ( int  x, int  y, const T &  value  )

inline

Definition at line 62 of file Image.h.

Referenced by Sensor::createSensorImage(), and Image< Point2D >::mirror().

                                                {
        std::vector<T>::at(getIndex(x,y)) = value;
    }

template<class T >

void Image< T >::setSize	(	int	nx,
		int	ny
	)

Definition at line 268 of file Image.h.

References Image< T >::sizeX, and Image< T >::sizeY.

Referenced by Image< Point2D >::convertFrom(), copyFXImage2Image(), PPSensor::fitSheets(), Image< T >::freeImage(), Image< Point2D >::interleave(), ImageWindow::onLoadImage(), and Image< Point2D >::~Image().

{
    if(!std::vector<T>::empty() && nx==sizeX && ny==sizeY) return;
    sizeX = nx;
    sizeY = ny;
    std::vector<T>::clear();
    if(nx*ny) std::vector<T>::resize(nx*ny);
}

template<class T>

void Image< T >::setSize	(	int	nx,
		int	ny,
		const T &	value
	)

Definition at line 278 of file Image.h.

References Image< T >::sizeX, and Image< T >::sizeY.

{
    sizeX = nx;
    sizeY = ny;
    std::vector<T>::clear();
    if(nx*ny) resize(nx*ny, value);
}

template<class T >

double Image< T >::sum

(

)

const

Definition at line 355 of file Image.h.

References Image< T >::getData(), and Image< T >::getSize().

Referenced by Dataset::load(), Image< T >::norm(), and Image< Point2D >::setPixel().

{
    double sum=0;
    const T* pnt = getData();
    for(int i=getSize(); i>0; i--, pnt++)
        sum += (double)*pnt;
    return sum;
}

template<class T>

Image< T > & Image< T >::threshold	(	const T &	th,
		double	binarize = 0
	)

Definition at line 512 of file Image.h.

References Image< T >::getData(), and Image< T >::getSize().

Referenced by Image< Point2D >::setPixel().

{
    bool bin = (binarize>0);
    T* pnt = getData();
    for(int i=getSize(); i>0; i--, pnt++)
        if(*pnt<th) *pnt = 0;
        else if (bin) *pnt = T(binarize);
    return *this;
}

template<class T >

Image< T > & Image< T >::unsetNAN

(

double

val = 0

)

Definition at line 523 of file Image.h.

References Image< T >::getData(), and Image< T >::getSize().

Referenced by ImageWindow::selectSensor(), and Image< Point2D >::setPixel().

{
    T* pnt = getData();
    for(int i=getSize(); i>0; i--, pnt++)
        if(isnan(*pnt)) *pnt = val;
    return *this;
}

template<class T>

bool Image< T >::writePPM ( const std::string &  fname ) const

inline

Definition at line 206 of file Image.h.

                                                {
        std::fstream ofile(fname.c_str(), std::ios::binary|std::ios::out);
        return writePPMstream(ofile);
    }

template<class T>

bool Image< T >::writePPMstream ( std::ostream &  os ) const

inline

Definition at line 211 of file Image.h.

Referenced by Image< Point2D >::writePPM().

                                             {
        if(!os) return false;
        os << sizeX << " " << sizeY << std::endl;
        os.write((const char*)&std::vector<T>::front(), sizeX*sizeY);
        return true;
    }

template<class T>

Image< T > & Image< T >::zeroPad	(	int	brd,
		const T &	col = 0,
		bool	smoothbrd = false
	)

Definition at line 586 of file Image.h.

References Image< T >::convolve(), Image< T >::getSizeX(), Image< T >::getSizeY(), and Image< T >::insert().

{
    if(brd>0)
    {
        Image<T> ni(getSizeX()+2*brd, getSizeY()+2*brd, col);
        ni.insert(*this, brd, brd);
        if(smoothbrd) {
            //smooth the inner image and blit again
            Image<float> flt(2*brd,2*brd, 1.0f/(4*brd*brd));
            ni.convolve(flt);
            ni.insert(*this, brd, brd);
        }
        *this = ni;
    }
    return *this;
}

Friends And Related Function Documentation

template<class T>

std::ostream& operator<< ( std::ostream &  os, const Image< T > &  rhs  )

friend

Definition at line 193 of file Image.h.

                                                                       {
        os << rhs.sizeX << " " << rhs.sizeY << std::endl;
        int xc = rhs.sizeX;
        for(const_iterator pnt = rhs.begin(); pnt != rhs.end(); pnt++) {
            os<<*pnt;
            if(--xc == 0) {
                std::cout << std::endl;
                xc = rhs.sizeX;
            } else std::cout << " ";
        }
        return os;
    }

template<class T>

std::istream& operator>> ( std::istream &  is, Image< T > &  rhs  )

friend

Definition at line 232 of file Image.h.

                                                                 {
        is >> rhs.sizeX;
        is >> rhs.sizeY;
        rhs.resize(rhs.sizeX*rhs.sizeY);
        for(iterator pnt = rhs.begin(); is && pnt != rhs.end(); pnt++)
            is>>*pnt;
        return is;
    }

Member Data Documentation

template<class T>

int Image< T >::sizeX

protected

Definition at line 245 of file Image.h.

Referenced by Image< T >::addLine(), Image< Point2D >::convolve(), Image< T >::copy(), Image< T >::findMaxima(), Image< T >::freeImage(), Image< Point2D >::getBoundedIndex(), Image< Point2D >::getIndex(), Image< Point2D >::getSizeX(), Image< T >::Image(), Image< T >::operator=(), Image< Point2D >::readPPMstream(), Image< Point2D >::sameSize(), Image< Point2D >::scaleBy(), Image< T >::setSize(), and Image< Point2D >::writePPMstream().

template<class T>

int Image< T >::sizeY

protected

Definition at line 245 of file Image.h.

Referenced by Image< Point2D >::convolve(), Image< T >::copy(), Image< T >::findMaxima(), Image< T >::freeImage(), Image< Point2D >::getBoundedIndex(), Image< Point2D >::getSizeY(), Image< T >::Image(), Image< T >::operator=(), Image< Point2D >::readPPMstream(), Image< Point2D >::sameSize(), Image< Point2D >::scaleBy(), Image< T >::setSize(), and Image< Point2D >::writePPMstream().

---

The documentation for this class was generated from the following file:

• src/Image.h