#include <qcepimagedata-ptr.h>

Inheritance diagram for QcepImageData< T >:

[legend]

Collaboration diagram for QcepImageData< T >:

[legend]

Public Member Functions
	QcepImageData (QcepSettingsSaverWPtr saver, int width, int height, T def, QcepObject *parent)

virtual	~QcepImageData ()

bool	readImage (QString filename)

void	resize (int width, int height)

void	clear ()

void	fill (double val)

double	getImageData (int x, int y) const

QVector< double >	getImageData (int x0, int y0, int x1, int y1) const

void	setImageData (int x, int y, double v)

virtual void	saveData (QString &name, QString filter, Overwrite canOverwrite=NoOverwrite)

void	saveTIFFData (QString name)

double	minValue () const

double	maxValue () const

QPointF	percentileRange (double lowpct, double highpct)

double	sumInRectangle (QRectF rect)

double	averageInRectangle (QRectF rect)

double	minInRectangle (QRectF rect)

double	maxInRectangle (QRectF rect)

double	sumInEllipse (QRectF rect)

double	averageInEllipse (QRectF rect)

double	minInEllipse (QRectF rect)

double	maxInEllipse (QRectF rect)

double	sumInPeak (QRectF rect)

template<typename T2 >
void	subtractDark (const QSharedPointer< QcepImageData< T2 > > dark)

void	calculateRange ()

void	calculateRangeInCircle ()

void	dumpPixels (int x0, int y0, int x1, int y1)

T *	data ()

T	value (int x, int y) const

T	value (double x, double y) const

void	setValue (int x, int y, T val)

void	addValue (int x, int y, T val)

void	subtractValue (int x, int y, T val)

void	multiplyValue (int x, int y, T val)

void	divideValue (int x, int y, T val)

T	defaultValue () const

void	setDefaultValue (T def)

QString	rawFileName ()

template<typename T2 >
void	copyImage (QSharedPointer< QcepImageData< T2 > > dest)

template<typename T2 >
void	copyFrom (const QSharedPointer< QcepImageData< T2 > > img)

template<typename T2 >
void	accumulateImage (QSharedPointer< QcepImageData< T2 > > image)

template<typename T2 >
void	add (QSharedPointer< QcepImageData< T2 > > image)

template<typename T2 >
void	subtract (QSharedPointer< QcepImageData< T2 > > image)

template<typename T2 >
void	multiply (QSharedPointer< QcepImageData< T2 > > image)

template<typename T2 >
void	divide (QSharedPointer< QcepImageData< T2 > > image)

void	setMask (QcepMaskDataPtr mask, QcepMaskDataPtr overflow)

QcepMaskDataPtr	mask () const

QcepMaskDataPtr	overflow () const

double	correlate (QSharedPointer< QcepImageData< T > > image, int dx, int dy, int mx, int my)

void	shiftImage (QSharedPointer< QcepImageData< T > > image, double dx, double dy)

T	findMin () const

T	findMax () const

double	findAverage () const

void	correctBadBackgroundSubtraction (QcepDoubleImageDataPtr dark, int nImgExposures, int nDarkExposures)

template<>
void	saveTIFFData (QString name)

Public Member Functions inherited from QcepImageDataBase
	QcepImageDataBase (QcepSettingsSaverWPtr saver, int width, int height, int size, QcepObject *parent)

virtual	~QcepImageDataBase ()

QString	get_DateString () const

void	set_DateString (QString)

QString	get_DataTypeName () const

void	set_DataTypeName (QString)

void	copyProperties (QcepImageDataBase *dest)

void	copyPropertiesFrom (QSharedPointer< QcepImageDataBase > src)

void	loadMetaData ()

void	saveMetaData ()

void	saveMetaData (QString name)

void	saveTextData (QString name, QString sep, bool transp=false)

void	setDefaultFileName (QString path)

virtual QString	fileFormatFilterString ()

QString	fileFormatTIFF ()

QString	fileFormatTabDelimited ()

QString	fileFormatTransposedTabDelimited ()

QString	fileFormatCSV ()

QString	fileFormatTransposedCSV ()

QMutex *	mutex ()

Public Member Functions inherited from QcepDataObject
	QcepDataObject (QcepSettingsSaverWPtr saver, QString name, int byteSize, QcepObject *parent)

virtual	~QcepDataObject ()

QcepSettingsSaverWPtr	saver ()

virtual int	childCount () const

virtual QcepDataObjectPtr	item (int n)

virtual QcepDataObjectPtr	item (QString nm)

virtual void	setParentItem (QcepDataGroupWPtr parent)

virtual int	indexInParent () const

virtual int	rowCount () const

virtual int	columnCount () const

virtual QVariant	columnData (int col) const

Public Member Functions inherited from QcepObject
	QcepObject (QString name, QcepObject *parent)

virtual	~QcepObject ()

virtual void	writeSettings (QSettings *set, QString section)

virtual void	readSettings (QSettings *set, QString section)

QString	get_Name () const

void	set_Name (QString name)

Static Public Member Functions
static QSharedPointer< QcepImageData< T > >	newImage (QcepSettingsSaverWPtr saver, QString name, int width, int height, QcepObject *parent)

static QScriptValue	toScriptValue (QScriptEngine *engine, const QSharedPointer< QcepImageData< T > > &data)

static void	fromScriptValue (const QScriptValue &obj, QSharedPointer< QcepImageData< T > > &data)

Static Public Member Functions inherited from QcepImageDataBase
static double	secondsSinceEpoch ()

Static Public Member Functions inherited from QcepDataObject
static QcepDataObjectPtr	newDataObject (QcepSettingsSaverWPtr saver, QString name, QcepObject *parent)

static QScriptValue	toScriptValue (QScriptEngine *engine, const QcepDataObjectPtr &data)

static void	fromScriptValue (const QScriptValue &obj, QcepDataObjectPtr &data)

static int	allocatedObjects ()

static int	deletedObjects ()

Static Public Member Functions inherited from QcepObject
static int	allocatedObjects ()

static int	deletedObjects ()

static QSet< QcepObject * >	allocatedObjectsSet ()

static QString	addSlashes (QString str)

Protected Attributes
QVector< T >	m_Image

T	m_MinValue

T	m_MaxValue

T	m_Default

QcepMaskDataPtr	m_Mask

QcepMaskDataPtr	m_Overflow

Protected Attributes inherited from QcepImageDataBase
int	m_ImageCounter

QcepSettingsSaverWPtr	m_Saver

Additional Inherited Members
Public Types inherited from QcepImageDataBase
enum	{ UndefinedData, Raw16Data, Raw32Data, DarkData, MaskData, SubtractedData, GainData, BadPixelsData }

Public Types inherited from QcepDataObject
enum	Overwrite { NoOverwrite, CanOverwrite }

Public Slots inherited from QcepImageDataBase
virtual QString	description () const

void	printMessage (QString msg, QDateTime ts=QDateTime::currentDateTime()) const

double	hValue (int n) const

double	vValue (int n) const

Public Slots inherited from QcepDataObject
virtual QString	description () const

QString	metaTypeName (int id) const

QString	pathName () const

QcepDataGroupPtr	rootItem ()

virtual QcepDataGroupPtr	parentItem () const

Public Slots inherited from QcepObject
virtual void	printLine (QString line)

virtual void	printMessage (QString msg, QDateTime dt=QDateTime::currentDateTime()) const

virtual void	criticalMessage (QString msg, QDateTime ts=QDateTime::currentDateTime()) const

virtual void	statusMessage (QString msg, QDateTime ts=QDateTime::currentDateTime()) const

virtual QString	settingsScript ()

QString	scriptValueLiteral (QVariant v)

Signals inherited from QcepDataObject
void	dataObjectChanged ()

Protected Member Functions inherited from QcepDataObject
void	mkPath (QString filePath)

QString	uniqueFileName (QString name)

Properties inherited from QcepImageDataBase
int	width

int	height

double	hStart

double	hStep

double	vStart

double	vStep

QString	hLabel

QString	hUnits

QString	vLabel

QString	vUnits

int	dataType

QString	dataTypeName

QString	fileBase

QString	title

int	readoutMode

double	exposureTime

int	summedExposures

int	imageSequenceNumber

int	imageNumber

int	phaseNumber

int	nPhases

QDateTime	dateTime

QString	dateString

double	timeStamp

int	hBinning

int	vBinning

double	cameraGain

int	triggered

QString	userComment1

QString	userComment2

QString	userComment3

QString	userComment4

QcepDoubleList	normalization

QcepDoubleList	extraInputs

bool	used

Properties inherited from QcepDataObject
QString	type

quint64	byteSize

QString	creator

QString	version

QString	qtVersion

QString	description

QString	fileName

int	objectSaved

Properties inherited from QcepObject
QString	name

Detailed Description

template<typename T>
class QcepImageData< T >

Definition at line 7 of file qcepimagedata-ptr.h.

Constructor & Destructor Documentation

template<typename T>

QcepImageData< T >::QcepImageData	(	QcepSettingsSaverWPtr	saver,
		int	width,
		int	height,
		T	def,
		QcepObject *	parent
	)

Definition at line 338 of file qcepimagedata.cpp.

References DEBUG_CONSTRUCTORS, HEXARG, QcepImageData< T >::m_Image, QcepObject::name, QcepImageDataBase::printMessage(), and qcepDebug().

   : QcepImageDataBase(saver, width, height, width*height*sizeof(T), parent),
     //    m_Image(width*height, def),
     m_Image(width*height),
     m_MinValue(0),
     m_MaxValue(0),
     m_Default(def),
     m_Mask(NULL),
     m_Overflow(NULL)
 {
   if (qcepDebug(DEBUG_CONSTRUCTORS)) {
     printMessage(tr("QcepImageData<%1>::QcepImageData %2")
                                 .arg(typeid(T).name())
                                 .HEXARG(this));
   }
 
   if (def) {
     m_Image.fill(def);
   }
 
   set_Type("Image Data");
 }

Here is the call graph for this function:

template<typename T >

QcepImageData< T >::~QcepImageData ( )

virtual

Definition at line 362 of file qcepimagedata.cpp.

References DEBUG_CONSTRUCTORS, HEXARG, QcepObject::name, QcepImageDataBase::printMessage(), and qcepDebug().

 {
   if (qcepDebug(DEBUG_CONSTRUCTORS)) {
     printMessage(tr("QcepImageData<%1>::~QcepImageData %2")
                       .arg(typeid(T).name())
                       .HEXARG(this));
   }
 }

Here is the call graph for this function:

Member Function Documentation

template<typename T >

template<typename T2 >

template void QcepImageData< T >::accumulateImage< double > ( QSharedPointer< QcepImageData< T2 > > image )

Definition at line 770 of file qcepimagedata.cpp.

References QcepImageData< T >::addValue(), and QcepImageData< T >::data().

 {
   if (image) {
     int ncols = this -> get_Width();
     int nrows = this -> get_Height();
 
     this->prop_SummedExposures()->incValue(image->get_SummedExposures());
 
     if (ncols == image->get_Width() && nrows == image->get_Height()) {
       int npix = ncols*nrows;
 
       T *srcp = this -> data();
       T2 *destp = image -> data();
 
       for (int i=0; i<npix; i++) {
         *srcp++ += *destp++;
       }
     } else {
       for (int row=0; row<nrows; row++) {
         for (int col=0; col<ncols; col++) {
           this -> addValue(col, row, image->value(col, row));
         }
       }
 
       QcepDoubleList norm  = this->get_Normalization();
       QcepDoubleList extra = this->get_ExtraInputs();
 
       QcepDoubleList norm2 = image->get_Normalization();
       QcepDoubleList extra2= image->get_ExtraInputs();
 
       for (int i=0; i<norm.count(); i++) {
         norm[i] += norm2.value(i);
       }
 
       for (int i=0; i<extra.count(); i++) {
         extra[i] += extra2.value(i);
       }
 
       this->set_Normalization(norm);
       this->set_ExtraInputs(extra);
     }
   }
 }

Here is the call graph for this function:

template<typename T >

template<typename T2 >

template void QcepImageData< T >::add< double > ( QSharedPointer< QcepImageData< T2 > > image )

Definition at line 816 of file qcepimagedata.cpp.

References QcepImageData< T >::addValue(), and QcepImageData< T >::data().

 {
   if (image) {
     int ncols = this -> get_Width();
     int nrows = this -> get_Height();
 
     this->prop_SummedExposures()->incValue(image->get_SummedExposures());
 
     if (ncols == image->get_Width() && nrows == image->get_Height()) {
       int npix = ncols*nrows;
 
       T *srcp = this -> data();
       T2 *destp = image -> data();
 
       for (int i=0; i<npix; i++) {
         *srcp++ += *destp++;
       }
     } else {
       for (int row=0; row<nrows; row++) {
         for (int col=0; col<ncols; col++) {
           this -> addValue(col, row, image->value(col, row));
         }
       }
     }
   }
 }

Here is the call graph for this function:

template<typename T>

void QcepImageData< T >::addValue	(	int	x,
		int	y,
		T	val
	)

Definition at line 466 of file qcepimagedata.cpp.

References QcepImageData< T >::m_Image.

Referenced by QcepImageData< T >::accumulateImage(), and QcepImageData< T >::add().

 {
   if (x >= 0 && x < get_Width() && y >= 0 && y < get_Height()) {
     m_Image[(get_Height()-y-1)*get_Width()+x] += val;
   }
 }

Here is the caller graph for this function:

template<typename T >

double QcepImageData< T >::averageInEllipse ( QRectF rect )

virtual

Implements QcepImageDataBase.

Definition at line 1583 of file qcepimagedata.cpp.

References QcepImageData< T >::m_Mask, and QcepImageData< T >::value().

 {
   QPointF c = rect.center();
   double  a = rect.width()/2;
   double  b = rect.height()/2;
 
   int bt = qRound(rect.bottom());
   int tp = qRound(rect.top());
 
   int np = 0;
   double sum = 0;
 
   for (int row=tp; row<=bt; row++) {
     double y=row - c.y();
     double xx = a*sqrt(1 - pow(y/b,2));
     int x1 = qRound(c.x() - xx);
     int x2 = qRound(c.x() + xx);
 
     for (int col=x1; col<=x2; col++) {
       if (m_Mask == NULL || m_Mask->value(col, row)) {
         T val = value(col, row);
 
         if (val==val) {
           np++;
           sum += val;
         }
       }
     }
   }
 
   return sum/np;
 }

Here is the call graph for this function:

template<typename T >

double QcepImageData< T >::averageInRectangle ( QRectF rect )

virtual

Implements QcepImageDataBase.

Definition at line 1430 of file qcepimagedata.cpp.

References QcepImageData< T >::m_Mask, and QcepImageData< T >::value().

 {
   int l = qRound(rect.left());
   int t = qRound(rect.top());
   int r = qRound(rect.right());
   int b = qRound(rect.bottom());
 
   if (l > r) {
     l = qRound(rect.right());
     r = qRound(rect.left());
   }
 
   if (b > t) {
     b = qRound(rect.top());
     t = qRound(rect.bottom());
   }
 
   int np = 0;
   double sum = 0;
 
   for (int row=b; row<=t; row++) {
     for (int col=l; col<=r; col++) {
       if (m_Mask == NULL || m_Mask->value(col, row)) {
         T val = value(col, row);
 
         if (val==val) {
           np++;
           sum += val;
         }
       }
     }
   }
 
   return sum/np;
 }

Here is the call graph for this function:

template<typename T >

void QcepImageData< T >::calculateRange ( )

Definition at line 510 of file qcepimagedata.cpp.

References QcepImageData< T >::m_Image, QcepImageData< T >::m_MaxValue, and QcepImageData< T >::m_MinValue.

 {
   T *img = m_Image.data();
   int total = m_Image.count();
   int first = true;
 
   m_MinValue = 0;
   m_MaxValue = 0;
 
   for (int i = 0; i<total; i++) {
     T val = img[i];
 
     if (val == val) { // NaN test...
       if (first) {
         m_MaxValue = val;
         m_MinValue = val;
         first = false;
       } else if (val > m_MaxValue) {
         m_MaxValue = val;
       } else if (val < m_MinValue) {
         m_MinValue = val;
       }
     }
   }
 }

template<typename T >

void QcepImageData< T >::calculateRangeInCircle ( )

Definition at line 537 of file qcepimagedata.cpp.

References QcepImageData< T >::m_MaxValue, QcepImageData< T >::m_MinValue, and QcepImageData< T >::value().

 {
   bool first = 1;
 
   double cx = get_Width()/2, cy = get_Height()/2;
 
   m_MinValue = 0;
   m_MaxValue = 0;
 
   for (int y=0; y<get_Height(); y++) {
     double dy = (((double)y)-cy)/cy;
     double dx = sqrt(1-dy*dy);
     int x0 = (int) (cx-dx*cx);
     int x1 = (int) (cx+dx*cx);
 
     for (int x=x0; x<x1; x++) {
       T val = value(x,y);
 
       if (val == val) { // NaN test...
         if (first) {
           m_MinValue = val;
           m_MaxValue = val;
           first = false;
         } else if (val > m_MaxValue) {
           m_MaxValue = val;
         } else if (val < m_MinValue) {
           m_MinValue = val;
         }
       }
     }
   }
 }

Here is the call graph for this function:

template<typename T >

void QcepImageData< T >::clear ( )

virtual

Implements QcepImageDataBase.

Definition at line 612 of file qcepimagedata.cpp.

References QcepImageData< T >::m_Default, and QcepImageData< T >::m_Image.

 {
   m_Image.fill(m_Default);
 }

template<typename T >

template<typename T2 >

template void QcepImageData< T >::copyFrom< unsigned int > ( const QSharedPointer< QcepImageData< T2 > > img )

Definition at line 748 of file qcepimagedata.cpp.

References QcepImageDataBase::copyPropertiesFrom(), QcepImageData< T >::data(), and QcepImageData< T >::resize().

 {
   if (img) {
     int ncols = img -> get_Width();
     int nrows = img -> get_Height();
     int npix = ncols*nrows;
 
     this -> resize(ncols, nrows);
 
     this -> copyPropertiesFrom(img);
 
     T2 *srcp  = img -> data();
     T  *destp = this -> data();
 
     for (int i=0; i<npix; i++) {
       *destp++ = *srcp++;
     }
   }
 }

Here is the call graph for this function:

template<typename T >

template<typename T2 >

void QcepImageData< T >::copyImage ( QSharedPointer< QcepImageData< T2 > > dest )

Definition at line 726 of file qcepimagedata.cpp.

References QcepImageDataBase::copyProperties(), QcepImageData< T >::data(), and QcepImageData< T >::resize().

 {
   if (dest) {
     int ncols = this -> get_Width();
     int nrows = this -> get_Height();
     int npix = ncols*nrows;
 
     dest -> resize(ncols, nrows);
 
     this -> copyProperties(dest.data());
 
     T *srcp = this -> data();
     T2 *destp = dest -> data();
 
     for (int i=0; i<npix; i++) {
       *destp++ = *srcp++;
     }
   }
 }

Here is the call graph for this function:

template<typename T >

void QcepImageData< T >::correctBadBackgroundSubtraction	(	QcepDoubleImageDataPtr	dark,
		int	nImgExposures,
		int	nDarkExposures
	)

Definition at line 1146 of file qcepimagedata.cpp.

References QcepImageData< T >::setValue(), and QcepImageData< T >::value().

 {
   int ncols = this -> get_Width();
   int nrows = this -> get_Height();
 
   double badRatio = ((double) this->get_SummedExposures())/((double) dark->get_SummedExposures());
   double goodRatio = ((double) nImgExposures)/((double) nDarkExposures);
 
   for (int row=0; row<nrows; row++) {
     for (int col=0; col<ncols; col++) {
       double darkValue = dark->value(col,row);
       double imgValue  = this->value(col,row);
 
       imgValue += darkValue*badRatio;
       imgValue -= darkValue*goodRatio;
 
       this->setValue(col, row, imgValue);
     }
   }
 
   this->set_SummedExposures(nImgExposures);
 }

Here is the call graph for this function:

template<typename T>

double QcepImageData< T >::correlate	(	QSharedPointer< QcepImageData< T > >	image,
		int	dx,
		int	dy,
		int	mx,
		int	my
	)

Definition at line 931 of file qcepimagedata.cpp.

References QcepImageData< T >::value().

 {
   double sum=0;
 
   if (image) {
     int wd = this->get_Width();
     int ht = this->get_Height();
 
     for (int y=my; y<ht-my; y++) {
       for (int x=mx; x<wd-mx; x++) {
         sum += this->value(x,y)*image->value(x+dx,y+dy);
       }
     }
   }
 
   return sum;
 }

Here is the call graph for this function:

template<typename T >

T * QcepImageData< T >::data ( )

Definition at line 383 of file qcepimagedata.cpp.

References QcepImageData< T >::m_Image.

Referenced by QcepImageData< T >::accumulateImage(), QcepImageData< T >::add(), QcepImageData< T >::copyFrom(), QcepImageData< T >::copyImage(), QcepImageData< T >::divide(), QcepImageData< T >::fromScriptValue(), QcepImageData< T >::multiply(), QcepImageData< T >::subtract(), QcepImageData< T >::subtractDark(), and QcepImageData< T >::toScriptValue().

 {
   return m_Image.data();
 }

Here is the caller graph for this function:

template<typename T >

T QcepImageData< T >::defaultValue ( ) const

Definition at line 618 of file qcepimagedata.cpp.

References QcepImageData< T >::m_Default.

 {
   return m_Default;
 }

template<typename T >

template<typename T2 >

template void QcepImageData< T >::divide< double > ( QSharedPointer< QcepImageData< T2 > > image )

Definition at line 903 of file qcepimagedata.cpp.

References QcepImageData< T >::data(), and QcepImageData< T >::divideValue().

 {
   if (image) {
     int ncols = this -> get_Width();
     int nrows = this -> get_Height();
 
     this->prop_SummedExposures()->incValue(image->get_SummedExposures());
 
     if (ncols == image->get_Width() && nrows == image->get_Height()) {
       int npix = ncols*nrows;
 
       T *srcp = this -> data();
       T2 *destp = image -> data();
 
       for (int i=0; i<npix; i++) {
         *srcp++ /= *destp++;
       }
     } else {
       for (int row=0; row<nrows; row++) {
         for (int col=0; col<ncols; col++) {
           this -> divideValue(col, row, image->value(col, row));
         }
       }
     }
   }
 }

Here is the call graph for this function:

template<typename T>

void QcepImageData< T >::divideValue	(	int	x,
		int	y,
		T	val
	)

Definition at line 490 of file qcepimagedata.cpp.

References QcepImageData< T >::m_Image.

Referenced by QcepImageData< T >::divide().

 {
   if (x >= 0 && x < get_Width() && y >= 0 && y < get_Height()) {
     m_Image[(get_Height()-y-1)*get_Width()+x] /= val;
   }
 }

Here is the caller graph for this function:

template<typename T >

void QcepImageData< T >::dumpPixels	(	int	x0,
		int	y0,
		int	x1,
		int	y1
	)

Definition at line 571 of file qcepimagedata.cpp.

References QcepImageData< T >::value().

 {
   for (int y=y0; y<y1; y++) {
     for (int x=x0; x<x1; x++) {
       printf("%g ", (double) value(x,y));
     }
     printf("\n");
   }
 }

Here is the call graph for this function:

template<typename T >

void QcepImageData< T >::fill ( double val )

virtual

Implements QcepImageDataBase.

Definition at line 444 of file qcepimagedata.cpp.

References QcepImageData< T >::m_Image.

 {
   m_Image.fill(val);
 }

template<typename T >

double QcepImageData< T >::findAverage ( ) const

Definition at line 1052 of file qcepimagedata.cpp.

References QcepImageData< T >::m_Mask, and QcepImageData< T >::value().

 {
   int ncols = this -> get_Width();
   int nrows = this -> get_Height();
   double npix = 0;
   double sum = 0;
 
   for (int row=0; row<nrows; row++) {
     for (int col=0; col<ncols; col++) {
       if (m_Mask == NULL || m_Mask->value(col,row)) {
         double val = this -> value(col, row);
 
         if (val==val) {
           npix += 1;
           sum += val;
         }
       }
     }
   }
 
   if (npix <= 0) {
     return 0;
   } else {
     return sum/npix;
   }
 }

Here is the call graph for this function:

template<typename T >

T QcepImageData< T >::findMax ( ) const

Definition at line 1024 of file qcepimagedata.cpp.

References QcepImageData< T >::m_Mask, and QcepImageData< T >::value().

Referenced by QcepImageData< T >::maxValue().

 {
   int ncols = this -> get_Width();
   int nrows = this -> get_Height();
   int first = true;
   T maxv = 0;
 
   for (int row=0; row<nrows; row++) {
     for (int col=0; col<ncols; col++) {
       if (m_Mask == NULL || m_Mask->value(col,row)) {
         T val = this -> value(col, row);
 
         if (val == val) {
           if (first) {
             maxv = val;
             first = false;
           } else if (val > maxv){
             maxv = val;
           }
         }
       }
     }
   }
 
   return maxv;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

template<typename T >

T QcepImageData< T >::findMin ( ) const

Definition at line 996 of file qcepimagedata.cpp.

References QcepImageData< T >::m_Mask, and QcepImageData< T >::value().

Referenced by QcepImageData< T >::minValue().

 {
   int ncols = this -> get_Width();
   int nrows = this -> get_Height();
   int first = true;
   T minv = 0;
 
   for (int row=0; row<nrows; row++) {
     for (int col=0; col<ncols; col++) {
       if (m_Mask == NULL || m_Mask->value(col,row)) {
         T val = this->value(col, row);
 
         if (val == val) { // Skip NaNs
           if (first) {
             minv = val;
             first = false;
           } else if (val < minv){
             minv = val;
           }
         }
       }
     }
   }
 
   return minv;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

template<typename T>

void QcepImageData< T >::fromScriptValue	(	const QScriptValue &	obj,
		QSharedPointer< QcepImageData< T > > &	data
	)

static

Definition at line 1176 of file qcepimagedata.cpp.

References QcepImageData< T >::data().

 {
   QObject *qobj = obj.toQObject();
 
   if (qobj) {
     QcepDataObject *qdobj = qobject_cast<QcepDataObject*>(qobj);
 
     if (qdobj) {
       QcepDataObjectPtr p = qdobj->sharedFromThis();
 
       if (p) {
         QSharedPointer<QcepImageData<T> > cs = qSharedPointerDynamicCast< QcepImageData<T> >(p);
 
         if (cs) {
           data = cs;
         }
       }
     }
   }
 }

Here is the call graph for this function:

template<typename T >

double QcepImageData< T >::getImageData	(	int	x,
		int	y
	)		const

virtual

Implements QcepImageDataBase.

Definition at line 432 of file qcepimagedata.cpp.

References QcepImageData< T >::value().

 {
   return this->value(x,y);
 }

Here is the call graph for this function:

template<typename T >

QVector< double > QcepImageData< T >::getImageData	(	int	x0,
		int	y0,
		int	x1,
		int	y1
	)		const

virtual

Implements QcepImageDataBase.

Definition at line 418 of file qcepimagedata.cpp.

References QcepImageData< T >::value().

 {
   QVector<double> res;
 
   for (int y=y0; y<y1; y++) {
     for (int x=x0; x<x1; x++) {
       res << this->value(x,y);
     }
   }
 
   return res;
 }

Here is the call graph for this function:

template<typename T >

QcepMaskDataPtr QcepImageData< T >::mask ( ) const

Definition at line 972 of file qcepimagedata.cpp.

References QcepImageData< T >::m_Mask.

Referenced by QcepImageData< T >::setMask().

 {
   return m_Mask;
 }

Here is the caller graph for this function:

template<typename T >

double QcepImageData< T >::maxInEllipse ( QRectF rect )

virtual

Implements QcepImageDataBase.

Definition at line 1655 of file qcepimagedata.cpp.

References QcepImageData< T >::m_Mask, and QcepImageData< T >::value().

 {
   QPointF c = rect.center();
   double  a = rect.width()/2;
   double  b = rect.height()/2;
 
   int bt = qRound(rect.bottom());
   int tp = qRound(rect.top());
 
   int first = true;
   double max = 0;
 
   for (int row=tp; row<=bt; row++) {
     double y=row - c.y();
     double xx = a*sqrt(1 - pow(y/b,2));
     int x1 = qRound(c.x() - xx);
     int x2 = qRound(c.x() + xx);
 
     for (int col=x1; col<=x2; col++) {
       if (m_Mask == NULL || m_Mask->value(col, row)) {
         T val = value(col, row);
 
         if (val==val) {
           if (first) {
             max = val;
             first = false;
           } else if (val > max) {
             max = val;
           }
         }
       }
     }
   }
 
   return max;
 }

Here is the call graph for this function:

template<typename T >

double QcepImageData< T >::maxInRectangle ( QRectF rect )

virtual

Implements QcepImageDataBase.

Definition at line 1508 of file qcepimagedata.cpp.

References QcepImageData< T >::m_Mask, and QcepImageData< T >::value().

 {
   int l = qRound(rect.left());
   int t = qRound(rect.top());
   int r = qRound(rect.right());
   int b = qRound(rect.bottom());
 
   if (l > r) {
     l = qRound(rect.right());
     r = qRound(rect.left());
   }
 
   if (b > t) {
     b = qRound(rect.top());
     t = qRound(rect.bottom());
   }
 
   int first  = true;
   double max = 0;
 
   for (int row=b; row<=t; row++) {
     for (int col=l; col<=r; col++) {
       if (m_Mask == NULL || m_Mask->value(col, row)) {
         T val = value(col, row);
 
         if (val==val) {
           if (first) {
             max = val;
             first = false;
           } else if (val > max) {
             max = val;
           }
         }
       }
     }
   }
 
   return max;
 }

Here is the call graph for this function:

template<typename T >

double QcepImageData< T >::maxValue ( ) const

virtual

Implements QcepImageDataBase.

Definition at line 990 of file qcepimagedata.cpp.

References QcepImageData< T >::findMax().

Referenced by QcepImageData< T >::percentileRange().

 {
   return findMax();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

template<typename T >

double QcepImageData< T >::minInEllipse ( QRectF rect )

virtual

Implements QcepImageDataBase.

Definition at line 1617 of file qcepimagedata.cpp.

References QcepImageData< T >::m_Mask, and QcepImageData< T >::value().

 {
   QPointF c = rect.center();
   double  a = rect.width()/2;
   double  b = rect.height()/2;
 
   int bt = qRound(rect.bottom());
   int tp = qRound(rect.top());
 
   int first = true;
   double min = 0;
 
   for (int row=tp; row<=bt; row++) {
     double y=row - c.y();
     double xx = a*sqrt(1 - pow(y/b,2));
     int x1 = qRound(c.x() - xx);
     int x2 = qRound(c.x() + xx);
 
     for (int col=x1; col<=x2; col++) {
       if (m_Mask == NULL || m_Mask->value(col, row)) {
         T val = value(col, row);
 
         if (val==val) {
           if (first) {
             min = val;
             first = false;
           } else if (val < min) {
             min = val;
           }
         }
       }
     }
   }
 
   return min;
 }

Here is the call graph for this function:

template<typename T >

double QcepImageData< T >::minInRectangle ( QRectF rect )

virtual

Implements QcepImageDataBase.

Definition at line 1467 of file qcepimagedata.cpp.

References QcepImageData< T >::m_Mask, and QcepImageData< T >::value().

 {
   int l = qRound(rect.left());
   int t = qRound(rect.top());
   int r = qRound(rect.right());
   int b = qRound(rect.bottom());
 
   if (l > r) {
     l = qRound(rect.right());
     r = qRound(rect.left());
   }
 
   if (b > t) {
     b = qRound(rect.top());
     t = qRound(rect.bottom());
   }
 
   int first  = true;
   double min = 0;
 
   for (int row=b; row<=t; row++) {
     for (int col=l; col<=r; col++) {
       if (m_Mask == NULL || m_Mask->value(col, row)) {
         T val = value(col, row);
 
         if (val==val) {
           if (first) {
             min = val;
             first = false;
           } else if (val < min) {
             min = val;
           }
         }
       }
     }
   }
 
   return min;
 }

Here is the call graph for this function:

template<typename T >

double QcepImageData< T >::minValue ( ) const

virtual

Implements QcepImageDataBase.

Definition at line 984 of file qcepimagedata.cpp.

References QcepImageData< T >::findMin().

Referenced by QcepImageData< T >::percentileRange().

 {
   return findMin();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

template<typename T >

template<typename T2 >

template void QcepImageData< T >::multiply< double > ( QSharedPointer< QcepImageData< T2 > > image )

Definition at line 874 of file qcepimagedata.cpp.

References QcepImageData< T >::data(), and QcepImageData< T >::multiplyValue().

 {
   if (image) {
     int ncols = this -> get_Width();
     int nrows = this -> get_Height();
 
     this->prop_SummedExposures()->incValue(image->get_SummedExposures());
 
     if (ncols == image->get_Width() && nrows == image->get_Height()) {
       int npix = ncols*nrows;
 
       T *srcp = this -> data();
       T2 *destp = image -> data();
 
       for (int i=0; i<npix; i++) {
         *srcp++ *= *destp++;
       }
     } else {
       for (int row=0; row<nrows; row++) {
         for (int col=0; col<ncols; col++) {
           this -> multiplyValue(col, row, image->value(col, row));
         }
       }
     }
   }
 }

Here is the call graph for this function:

template<typename T>

void QcepImageData< T >::multiplyValue	(	int	x,
		int	y,
		T	val
	)

Definition at line 482 of file qcepimagedata.cpp.

References QcepImageData< T >::m_Image.

Referenced by QcepImageData< T >::multiply().

 {
   if (x >= 0 && x < get_Width() && y >= 0 && y < get_Height()) {
     m_Image[(get_Height()-y-1)*get_Width()+x] *= val;
   }
 }

Here is the caller graph for this function:

template<typename T >

QSharedPointer< QcepImageData< T > > QcepImageData< T >::newImage	(	QcepSettingsSaverWPtr	saver,
		QString	name,
		int	width,
		int	height,
		QcepObject *	parent
	)

static

Definition at line 372 of file qcepimagedata.cpp.

Referenced by QcepDataGroup::newImage(), and QcepDatasetModel::newImage().

 {
   QSharedPointer< QcepImageData<T> > res(new QcepImageData<T>(saver, width, height, 0, parent));
 
   res->setObjectName(name);
 
   return res;
 }

Here is the caller graph for this function:

template<typename T >

QcepMaskDataPtr QcepImageData< T >::overflow ( ) const

Definition at line 978 of file qcepimagedata.cpp.

References QcepImageData< T >::m_Overflow.

Referenced by QcepImageData< T >::setMask().

 {
   return m_Overflow;
 }

Here is the caller graph for this function:

template<typename T >

QPointF QcepImageData< T >::percentileRange	(	double	lowpct,
		double	highpct
	)

virtual

Implements QcepImageDataBase.

Definition at line 1080 of file qcepimagedata.cpp.

References QcepImageData< T >::m_Mask, QcepImageData< T >::maxValue(), QcepImageData< T >::minValue(), and QcepImageData< T >::value().

 {
   const int histSize = 65536;
   QVector<int> histogramVec(histSize+1);
   histogramVec.fill(0.0);
   int *histogram = histogramVec.data();
 
   int ncols = this -> get_Width();
   int nrows = this -> get_Height();
 
   double minVal = minValue();
   double maxVal = maxValue();
 
   double histStep = (maxVal - minVal + 2)/histSize;
   int nAbove = 0, nBelow = 0, nTotal = 0;
 
   for (int row=0; row<nrows; row++) {
     for (int col=0; col<ncols; col++) {
       if (m_Mask == NULL || m_Mask->value(col, row)) {
         double val = value(col, row);
 
         if (val==val) {
           double bin = (val - minVal)/histStep;
 
           if (bin < 0) {
             nBelow += 1;
           } else if (bin >= histSize) {
             nAbove += 1;
           } else {
             histogram[(int) bin] += 1;
           }
 
           nTotal += 1;
         }
       }
     }
   }
 
   double lowCount = ((double) nTotal) * lowpct / 100.0;
   double highCount = ((double) nTotal) * highpct / 100.0;
   double count = nBelow;
 
   QPointF res(0,0);
 
   for (int i=0; i<histSize; i++) {
     double binVal = minVal + i*histStep;
 
     count += histogram[i];
 
     if (count < lowCount) {
       res.setX(binVal);
     }
 
     if (count < highCount) {
       res.setY(binVal);
     }
   }
 
   if (res.y() <= res.x()) {
     res.setY(res.x() + 1);
   }
 
   return res;
 }

Here is the call graph for this function:

template<typename T >

QString QcepImageData< T >::rawFileName ( )

Definition at line 715 of file qcepimagedata.cpp.

References QcepObject::name.

 {
   QFileInfo info(QcepImageData<T>::get_FileName());
 
   QString name = info.dir().filePath(info.completeBaseName()+".raw.tif");
 
   return name;
 }

template<typename T >

bool QcepImageData< T >::readImage ( QString filename )

Definition at line 630 of file qcepimagedata.cpp.

References QcepImageDataFormatFactory< T >::factory(), and QcepImageDataBase::fileBase.

 {
   QcepImageDataFormat<T> *loader =
       QcepImageDataFormatFactory<T>::factory()->canLoad(path);
 
   if (loader) {
     bool res = loader -> loadFile(path, this);
 
     if (res) {
       QString fileBase = QFileInfo(path).fileName();
 
       set_FileBase(fileBase);
       set_Title(fileBase);
       set_FileName(path);
       set_ObjectSaved(true);
     }
 
     return res;
   } else {
     return false;
   }
 }

Here is the call graph for this function:

template<typename T >

void QcepImageData< T >::resize	(	int	width,
		int	height
	)

virtual

Implements QcepImageDataBase.

Definition at line 582 of file qcepimagedata.cpp.

References QcepAllocator::allocate(), QcepImageDataBase::height, QcepImageData< T >::m_Image, QcepImageData< T >::setValue(), QcepImageData< T >::value(), and QcepImageDataBase::width.

Referenced by QcepImageData< T >::copyFrom(), and QcepImageData< T >::copyImage().

 {
   QcepImageData<T> temp(QcepSettingsSaverPtr(), get_Width(), get_Height(), 0, this);
 
   int oldwidth = get_Width();
   int oldheight= get_Height();
 
   for (int y=0; y<oldheight; y++) {
     for (int x=0; x<oldwidth; x++) {
       temp.setValue(x, y, value(x,y));
     }
   }
 
   set_Width(width);
   set_Height(height);
 
   m_Image.resize(width*height);
 
   for (int y=0; y<height; y++) {
     for (int x=0; x<width; x++) {
       setValue(x, y, temp.value(x,y));
     }
   }
 
   set_ByteSize(width*height*sizeof(T));
 
   QcepAllocator::allocate((width*height - oldwidth*oldheight)*sizeof(T));
 }

Here is the call graph for this function:

Here is the caller graph for this function:

template<typename T >

void QcepImageData< T >::saveData	(	QString &	name,
		QString	filter,
		Overwrite	canOverwrite = `NoOverwrite`
	)

virtual

Reimplemented from QcepDataObject.

Definition at line 1371 of file qcepimagedata.cpp.

References QcepImageDataBase::fileFormatCSV(), QcepImageDataBase::fileFormatTabDelimited(), QcepImageDataBase::fileFormatTIFF(), QcepImageDataBase::fileFormatTransposedCSV(), QcepImageDataBase::fileFormatTransposedTabDelimited(), QcepDataObject::mkPath(), QcepDataObject::NoOverwrite, QcepImageDataBase::saveTextData(), QcepImageData< T >::saveTIFFData(), and QcepDataObject::uniqueFileName().

 {
   mkPath(name);
 
   if (canOverwrite == NoOverwrite) {
     name = uniqueFileName(name);
   }
 
   if (filter == fileFormatTIFF()) {
     saveTIFFData(name);
   } else if (filter == fileFormatTabDelimited()) {
     saveTextData(name, "\t", false);
   } else if (filter == fileFormatTransposedTabDelimited()) {
     saveTextData(name, "\t", true);
   } else if (filter == fileFormatCSV()) {
     saveTextData(name, ", ", false);
   } else if (filter == fileFormatTransposedCSV()) {
     saveTextData(name, ", ", true);
   }
 }

Here is the call graph for this function:

template<typename T >

void QcepImageData< T >::saveTIFFData ( QString name )

Definition at line 1241 of file qcepimagedata.cpp.

References QcepImageDataBase::saveMetaData(), TIFFCHECK, and QcepImageData< T >::value().

Referenced by QcepImageData< T >::saveData().

 {
   int nrows = get_Height();
   int ncols = get_Width();
 
   TIFF* tif = TIFFOpen(qPrintable(name),"w");
   int res = 1;
 
   if (tif) {
     int nsum = get_SummedExposures();
 
     TIFFCHECK(TIFFSetField(tif, TIFFTAG_IMAGEWIDTH, ncols));
     TIFFCHECK(TIFFSetField(tif, TIFFTAG_IMAGELENGTH, nrows));
     TIFFCHECK(TIFFSetField(tif, TIFFTAG_SAMPLESPERPIXEL, 1));
 
     TIFFCHECK(TIFFSetField(tif, TIFFTAG_PLANARCONFIG, PLANARCONFIG_CONTIG));
 
     if (nsum == 0) {
       TIFFCHECK(TIFFSetField(tif, TIFFTAG_BITSPERSAMPLE, 8));
     } else if (nsum == 1) {
       TIFFCHECK(TIFFSetField(tif, TIFFTAG_BITSPERSAMPLE, 16));
     } else {
       TIFFCHECK(TIFFSetField(tif, TIFFTAG_BITSPERSAMPLE, 32));
     }
 
     TIFFCHECK(TIFFSetField(tif, TIFFTAG_SAMPLEFORMAT, SAMPLEFORMAT_UINT));
 
     TIFFCHECK(TIFFSetField(tif, TIFFTAG_DOCUMENTNAME, qPrintable(get_FileName())));
     TIFFCHECK(TIFFSetField(tif, TIFFTAG_DATETIME,     qPrintable(get_DateTime().toString("yyyy:MM:dd hh:mm:ss"))));
 
     if (nsum == 0) {
       QVector<quint8> buffvec(ncols);
       quint8* buffer = buffvec.data();
 
       for (int y=0; y<nrows; y++) {
         for (int x=0; x<ncols; x++) {
           buffer[x] = value(x,y);
         }
 
         TIFFCHECK(TIFFWriteScanline(tif, buffer, y, 0));
       }
     } else if (nsum == 1) {
       QVector<quint16> buffvec(ncols);
       quint16* buffer = buffvec.data();
 
       for (int y=0; y<nrows; y++) {
         for (int x=0; x<ncols; x++) {
           buffer[x] = value(x,y);
         }
 
         TIFFCHECK(TIFFWriteScanline(tif, buffer, y, 0));
       }
     } else {
       QVector<quint32> buffvec(ncols);
       quint32* buffer = buffvec.data();
 
       for (int y=0; y<nrows; y++) {
         for (int x=0; x<ncols; x++) {
           buffer[x] = value(x,y);
         }
 
         TIFFCHECK(TIFFWriteScanline(tif, buffer, y, 0));
       }
     }
 
     TIFFClose(tif);
 
     set_FileName(name);
     set_ObjectSaved(true);
 
     saveMetaData();
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

template<>

void QcepImageData< double >::saveTIFFData ( QString name )

Definition at line 1200 of file qcepimagedata.cpp.

References QcepImageDataBase::saveMetaData(), TIFFCHECK, and QcepImageData< T >::value().

 {
   int nrows = get_Height();
   int ncols = get_Width();
 
   TIFF* tif = TIFFOpen(qPrintable(name),"w");
   int res = 1;
 
   if (tif) {
     TIFFCHECK(TIFFSetField(tif, TIFFTAG_IMAGEWIDTH, ncols));
     TIFFCHECK(TIFFSetField(tif, TIFFTAG_IMAGELENGTH, nrows));
     TIFFCHECK(TIFFSetField(tif, TIFFTAG_SAMPLESPERPIXEL, 1));
 
     TIFFCHECK(TIFFSetField(tif, TIFFTAG_PLANARCONFIG, PLANARCONFIG_CONTIG));
     TIFFCHECK(TIFFSetField(tif, TIFFTAG_BITSPERSAMPLE, 32));
     TIFFCHECK(TIFFSetField(tif, TIFFTAG_SAMPLEFORMAT, SAMPLEFORMAT_IEEEFP));
 
     TIFFCHECK(TIFFSetField(tif, TIFFTAG_DOCUMENTNAME, qPrintable(get_FileName())));
     TIFFCHECK(TIFFSetField(tif, TIFFTAG_DATETIME,     qPrintable(get_DateTime().toString("yyyy:MM:dd hh:mm:ss"))));
 
     QVector<float> buffvec(ncols);
     float* buffer = buffvec.data();
 
     for (int y=0; y<nrows; y++) {
       for (int x=0; x<ncols; x++) {
         buffer[x] = value(x,y);
       }
 
       TIFFCHECK(TIFFWriteScanline(tif, buffer, y, 0));
     }
 
     TIFFClose(tif);
 
     set_FileName(name);
     set_ObjectSaved(true);
 
     saveMetaData();
   }
 }

Here is the call graph for this function:

template<typename T>

void QcepImageData< T >::setDefaultValue ( T def )

Definition at line 624 of file qcepimagedata.cpp.

References QcepImageData< T >::m_Default.

 {
   m_Default = def;
 }

template<typename T >

void QcepImageData< T >::setImageData	(	int	x,
		int	y,
		double	v
	)

virtual

Implements QcepImageDataBase.

Definition at line 450 of file qcepimagedata.cpp.

References QcepImageData< T >::m_Image.

 {
   if (x >= 0 && x < get_Width() && y >= 0 && y < get_Height()) {
     m_Image[(get_Height()-y-1)*get_Width()+x] = v;
   }
 }

template<typename T >

void QcepImageData< T >::setMask	(	QcepMaskDataPtr	mask,
		QcepMaskDataPtr	overflow
	)

Definition at line 965 of file qcepimagedata.cpp.

References QcepImageData< T >::m_Mask, QcepImageData< T >::m_Overflow, QcepImageData< T >::mask(), and QcepImageData< T >::overflow().

 {
   m_Mask     = mask;
   m_Overflow = overflow;
 }

Here is the call graph for this function:

template<typename T>

void QcepImageData< T >::setValue	(	int	x,
		int	y,
		T	val
	)

Definition at line 458 of file qcepimagedata.cpp.

References QcepImageData< T >::m_Image.

Referenced by QcepImageData< T >::correctBadBackgroundSubtraction(), QcepImageData< T >::resize(), and QcepImageData< T >::shiftImage().

 {
   if (x >= 0 && x < get_Width() && y >= 0 && y < get_Height()) {
     m_Image[(get_Height()-y-1)*get_Width()+x] = val;
   }
 }

Here is the caller graph for this function:

template<typename T>

void QcepImageData< T >::shiftImage	(	QSharedPointer< QcepImageData< T > >	image,
		double	dx,
		double	dy
	)

Definition at line 950 of file qcepimagedata.cpp.

References QcepImageData< T >::setValue().

 {
   if (image) {
     int wd = this->get_Width();
     int ht = this->get_Height();
 
     for (int y=0; y<ht; y++) {
       for (int x=0; x<wd; x++) {
         this->setValue(x,y, image->value(x+dx,y+dy));
       }
     }
   }
 }

Here is the call graph for this function:

template<typename T >

template<typename T2 >

template void QcepImageData< T >::subtract< double > ( QSharedPointer< QcepImageData< T2 > > image )

Definition at line 845 of file qcepimagedata.cpp.

References QcepImageData< T >::data(), and QcepImageData< T >::subtractValue().

 {
   if (image) {
     int ncols = this -> get_Width();
     int nrows = this -> get_Height();
 
     this->prop_SummedExposures()->incValue(image->get_SummedExposures());
 
     if (ncols == image->get_Width() && nrows == image->get_Height()) {
       int npix = ncols*nrows;
 
       T *srcp = this -> data();
       T2 *destp = image -> data();
 
       for (int i=0; i<npix; i++) {
         *srcp++ -= *destp++;
       }
     } else {
       for (int row=0; row<nrows; row++) {
         for (int col=0; col<ncols; col++) {
           this -> subtractValue(col, row, image->value(col, row));
         }
       }
     }
   }
 }

Here is the call graph for this function:

template<typename T >

template<typename T2 >

template void QcepImageData< T >::subtractDark ( const QSharedPointer< QcepImageData< T2 > > dark )

Definition at line 655 of file qcepimagedata.cpp.

References QcepImageData< T >::data(), QcepImageDataBase::height, QcepImageDataBase::mutex(), QcepImageDataBase::printMessage(), QcepImageDataBase::SubtractedData, and QcepImageDataBase::width.

 {
   //  if (get_PerformDarkSubtraction()) {
   if (dark->get_ExposureTime() != this->get_ExposureTime()) {
     printMessage("Exposure times of acquired data and dark image are different, skipping");
     return;
   }
 
   if (dark->get_Width() != this->get_Width() ||
       dark->get_Height() != this->get_Height()) {
     printMessage("Dimensions of acquired data and dark image are different, skipping");
     return;
   }
 
   if (dark->get_CameraGain() != this->get_CameraGain()) {
     printMessage("Gains of acquired data and dark image are different, skipping");
     return;
   }
 
   //    if (!(image->get_DataType() == QcepDoubleImageData::Raw16Data ||
   //          image->get_DataType() == QcepDoubleImageData::Raw32Data)) {
   //      printMessage("Acquired data is not a raw image, skipping background subtraction");
   //      return;
   //    }
 
   QcepMutexLocker lock1(__FILE__, __LINE__, dark->mutex());
   QcepMutexLocker lock2(__FILE__, __LINE__, this->mutex());
 
   int height = this->get_Height();
   int width  = this->get_Width();
   int nres = this -> get_SummedExposures();
   int ndrk = dark -> get_SummedExposures();
   int npixels = width*height;
 
   if (nres <= 0) nres = 1;
 
   double ratio = ((double) nres)/((double) ndrk);
 
   //      printf("Dark subtraction nres=%d, ndrk=%d, npixels=%d, ratio=%g\n",
   //             nres, ndrk, npixels, ratio);
 
   double *result = this->data();
   T2     *dk     = dark->data();
   double avgraw  = 0;
   //      double avgdark = 0;
 
   for (int i=0; i<npixels; i++) {
     //        avgdark  += dk[i];
     avgraw   += result[i];
     result[i] = result[i]-ratio*dk[i];
   }
 
   //      set_AverageDark(avgdark/npixels/ndrk);
 //  set_AverageRaw(avgraw/npixels/nres);
 //  set_Average(get_AverageRaw() - get_AverageDark());
 
   this -> set_DataType(SubtractedData);
 }

Here is the call graph for this function:

template<typename T>

void QcepImageData< T >::subtractValue	(	int	x,
		int	y,
		T	val
	)

Definition at line 474 of file qcepimagedata.cpp.

References QcepImageData< T >::m_Image.

Referenced by QcepImageData< T >::subtract().

 {
   if (x >= 0 && x < get_Width() && y >= 0 && y < get_Height()) {
     m_Image[(get_Height()-y-1)*get_Width()+x] -= val;
   }
 }

Here is the caller graph for this function:

template<typename T >

double QcepImageData< T >::sumInEllipse ( QRectF rect )

virtual

Implements QcepImageDataBase.

Definition at line 1549 of file qcepimagedata.cpp.

References QcepImageData< T >::m_Mask, and QcepImageData< T >::value().

 {
   QPointF c = rect.center();
   double  a = rect.width()/2;
   double  b = rect.height()/2;
 
   int bt = qRound(rect.bottom());
   int tp = qRound(rect.top());
 
   int np = 0;
   double sum = 0;
 
   for (int row=tp; row<=bt; row++) {
     double y=row - c.y();
     double xx = a*sqrt(1 - pow(y/b,2));
     int x1 = qRound(c.x() - xx);
     int x2 = qRound(c.x() + xx);
 
     for (int col=x1; col<=x2; col++) {
       if (m_Mask == NULL || m_Mask->value(col, row)) {
         T val = value(col, row);
 
         if (val==val) {
           np++;
           sum += val;
         }
       }
     }
   }
 
   return sum;
 }

Here is the call graph for this function:

template<typename T >

double QcepImageData< T >::sumInPeak ( QRectF rect )

virtual

Implements QcepImageDataBase.

Definition at line 1693 of file qcepimagedata.cpp.

References QcepImageData< T >::m_Mask, and QcepImageData< T >::value().

 {
   QPointF c = rect.center();
   double  w = rect.width()/2;
   double  h = rect.height()/2;
 
   int bt = qRound(rect.bottom());
   int tp = qRound(rect.top());
   int lf = qRound(rect.left());
   int rt = qRound(rect.right());
 
   int ptp = qRound(c.y() - h/2);
   int pbt = qRound(c.y() + h/2);
   int plf = qRound(c.x() - w/2);
   int prt = qRound(c.x() + w/2);
 
   int    np    = 0;
   double sum   = 0;
   int    npk   = 0;
   double sumpk = 0;
 
   for (int row=tp; row<=bt; row++) {
     for (int col=lf; col<=rt; col++) {
       if (m_Mask == NULL || m_Mask->value(col,row)) {
         T val = value(col,row);
 
         if (val == val) {
           if (ptp <= row && row <= pbt && plf <= col && col <= prt) {
             npk++;
             sumpk += val;
           } else {
             np++;
             sum += val;
           }
         }
       }
     }
   }
 
   if (np > 0 && npk > 0) {
     double avbk = sum/np;
     double avpk = sumpk/npk;
 
     return (avpk-avbk)*npk;
   } else {
     return 0;
   }
 }

Here is the call graph for this function:

template<typename T >

double QcepImageData< T >::sumInRectangle ( QRectF rect )

virtual

Implements QcepImageDataBase.

Definition at line 1393 of file qcepimagedata.cpp.

References QcepImageData< T >::m_Mask, and QcepImageData< T >::value().

 {
   int l = qRound(rect.left());
   int t = qRound(rect.top());
   int r = qRound(rect.right());
   int b = qRound(rect.bottom());
 
   if (l > r) {
     l = qRound(rect.right());
     r = qRound(rect.left());
   }
 
   if (b > t) {
     b = qRound(rect.top());
     t = qRound(rect.bottom());
   }
 
   int np = 0;
   double sum = 0;
 
   for (int row=b; row<=t; row++) {
     for (int col=l; col<=r; col++) {
       if (m_Mask == NULL || m_Mask->value(col, row)) {
         T val = value(col, row);
 
         if (val==val) {
           np++;
           sum += val;
         }
       }
     }
   }
 
   return sum;
 }

Here is the call graph for this function:

template<typename T>

QScriptValue QcepImageData< T >::toScriptValue	(	QScriptEngine *	engine,
		const QSharedPointer< QcepImageData< T > > &	data
	)

static

Definition at line 1170 of file qcepimagedata.cpp.

References QcepImageData< T >::data().

 {
   return engine->newQObject(data.data());
 }

Here is the call graph for this function:

template<typename T >

T QcepImageData< T >::value	(	int	x,
		int	y
	)		const

Definition at line 389 of file qcepimagedata.cpp.

References QcepImageData< T >::m_Default, and QcepImageData< T >::m_Image.

 {
   if (x >= 0 && x < get_Width() && y >= 0 && y < get_Height()) {
     return m_Image.value((get_Height()-y-1)*get_Width()+x);
   }
 
   return m_Default;
 }

Here is the caller graph for this function:

template<typename T >

T QcepImageData< T >::value	(	double	x,
		double	y
	)		const

Definition at line 399 of file qcepimagedata.cpp.

References QcepImageData< T >::value().

 {
   int ix = ((int) x), iy = ((int) y);
   double dx = x-ix, dy = y-iy;
 
   double f00 = value((ix)   , (iy));
   double f10 = value((ix+1) , (iy));
   double f01 = value((ix)   , (iy+1));
   double f11 = value((ix+1) , (iy+1));
 
   double f0 = f00*(1-dx)+f10*dx;
   double f1 = f01*(1-dx)+f11*dx;
 
   double f = f0*(1-dy)+f1*dy;
 
   return f;
 }