QxrdDataProcessorThreaded Class Reference

#include <qxrddataprocessorthreaded.h>

Inheritance diagram for QxrdDataProcessorThreaded:

Collaboration diagram for QxrdDataProcessorThreaded:

Public Slots
void	sumImages (QStringList names)
void	addImages (QStringList names)
void	subtractImages (QStringList names)
void	projectImages (QStringList names, int px, int py, int pz)
void	integrateData (QString name)
void	correlateImages (QStringList names)
void	clearAccumulator ()
void	integrateAndAccumulate (QStringList names)
void	saveAccumulator (QString &path, QString filter)
void	shiftImage (int dx, int dy)
void	reflectVertically ()
void	reflectHorizontally ()
void	fitPeakNear (double x, double y)
void	processData (QString name)
void	processDataSequence (QString path, QString filter="*.tif")
void	processDataSequence (QStringList paths)
void	processDataSequence (QString path, QStringList filter)
void	processNormalizedFile (QString path, double v1)
void	processNormalizedFile (QString path, double v1, double v2)
void	processNormalizedFile (QString path, QcepDoubleList v)
void	setFileNormalization (QString path, double v1)
void	setFileNormalization (QString path, double v1, double v2)
void	setFileNormalization (QString path, QcepDoubleList v)
void	slicePolygon (QVector< QPointF > poly)
void	integrateSaveAndDisplay ()
void	fixupBadBackgroundSubtraction (QString imagePattern, int nImgExposures, QString darkPath, int nDarkExposures)
Public Slots inherited from QxrdDataProcessorBase
void	printMessage (QString msg, QDateTime ts=QDateTime::currentDateTime()) const
void	criticalMessage (QString msg, QDateTime ts=QDateTime::currentDateTime()) const
void	statusMessage (QString msg, QDateTime ts=QDateTime::currentDateTime()) const
void	shutdown ()
void	showMaskRange ()
void	hideMaskRange ()
void	showMaskRange (double min, double max)
void	hideMaskRange (double min, double max)
void	showMaskAll ()
void	hideMaskAll ()
void	invertMask ()
void	growMask ()
void	shrinkMask ()
void	maskCircle (QRectF pt)
void	maskPolygon (QVector< QPointF > poly)
void	measurePolygon (QVector< QPointF > poly)
virtual void	slicePolygon (QVector< QPointF > poly)=0
void	printMeasuredPolygon (QVector< QPointF > poly)
void	summarizeMeasuredPolygon (QVector< QPointF > poly)
virtual void	integrateSaveAndDisplay ()=0
QString	pwd () const
QStringList	ls () const
QStringList	ls (QString pattern) const
void	loadData (QString name)
void	saveData (QString name, int canOverwrite=NoOverwrite)
void	saveData (QcepDataObjectPtr object, QString name, int canOverwrite=NoOverwrite)
void	loadDark (QString name)
void	saveDark (QString name, int canOverwrite=NoOverwrite)
void	loadMask (QString name)
void	saveMask (QString name, int canOverwrite=NoOverwrite)
void	loadBadPixels (QString name)
void	saveBadPixels (QString name, int canOverwrite=NoOverwrite)
void	loadGainMap (QString name)
void	saveGainMap (QString name, int canOverwrite=NoOverwrite)
void	saveCachedGeometry (QString name)
void	saveCachedIntensity (QString name)
void	clearDark ()
void	clearMask ()
void	clearBadPixels ()
void	clearGainMap ()
void	subtractDark ()
void	unsubtractDark ()
void	multiplyData (double scalar)
void	offsetData (double offset)
int	maskStackSize ()
int	maskStackPosition (int pos)
void	newMaskStack ()
void	pushMaskStack (QcepMaskDataPtr mask=QcepMaskDataPtr())
void	popMaskStack (int amount=1)
void	clearMaskStack ()
void	clearMaskStackTop ()
void	rollMaskStack (int amount)
void	exchangeMaskStack (int pos)
void	andMaskStack (int pos)
void	orMaskStack (int pos)
void	xorMaskStack (int pos)
void	andNotMaskStack (int pos)
void	orNotMaskStack (int pos)
void	xorNotMaskStack (int pos)
void	invertMaskStack (int pos)
void	growMaskStack (int pos)
void	shrinkMaskStack (int pos)
void	hideMaskAllStack (int pos)
void	showMaskAllStack (int pos)
void	hideMaskRangeStack (int pos)
void	showMaskRangeStack (int pos)
void	findZingers ()
void	newImage (int ncols, int nrows)
void	exponentialTail (double cx, double cy, double width, int oversample)
void	reciprocalTail (double cx, double cy, double strength, int oversample)
void	powderRing (double cx, double cy, double radius, double width, double strength, int oversample)
void	ellipse (double cx, double cy, double a, double e, double ang, double width, double strength, int oversample)
void	updateEstimatedProcessingTime ()
void	fileWriteTest (int dim, QString path)
int	status (double delay)
void	calculateROI ()
void	calculateHistogram ()
void	displayIntegratedData (QcepIntegratedDataPtr d)
void	writeOutputScan (QcepIntegratedDataPtr d)
void	newOutputScan (QString title)
void	appendToOutputScan (double x, double y)
void	plotOutputScan ()
void	saveOutputScan (QString fileName)
QStringList	integrateRectangle (int x0, int y0, int x1, int y1)
QString	existingOutputDirectory (QString dir, QString subdir) const
QString	filePathInExperimentDirectory (QString name) const
QString	filePathInDataDirectory (QString name) const
QString	filePathInDarkOutputDirectory (QString name) const
QString	filePathInRawOutputDirectory (QString name) const
QString	filePathInSubtractedOutputDirectory (QString name) const
QString	filePathInIntegratedOutputDirectory (QString name) const
QString	experimentDirectory () const
QString	dataDirectory () const
QString	darkOutputDirectory () const
QString	rawOutputDirectory () const
QString	subtractedOutputDirectory () const
QString	integratedOutputDirectory () const
QcepDoubleImageDataPtr	data () const
QcepDoubleImageDataPtr	darkImage () const
QcepDoubleImageDataPtr	gainMap () const
QcepDoubleImageDataPtr	badPixels () const
QcepDoubleImageDataPtr	liveData () const
QcepMaskDataPtr	mask () const
QcepMaskDataPtr	overflow () const
void	newData (QcepDoubleImageDataPtr image, QcepMaskDataPtr overflow)
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)

Public Member Functions
	QxrdDataProcessorThreaded (QcepSettingsSaverWPtr saver, QxrdExperimentWPtr doc, QxrdAcquisitionWPtr acq, QxrdFileSaverWPtr filesaver)
virtual	~QxrdDataProcessorThreaded ()
void	beginAcquisition (int isDark)
void	idleInt16Image (QcepInt16ImageDataPtr image, bool liveView)
void	acquiredInt16Image (QcepInt16ImageDataPtr image, QcepMaskDataPtr overflow)
void	acquiredInt32Image (QcepInt32ImageDataPtr image, QcepMaskDataPtr overflow)
void	acquiredDoubleImage (QcepDoubleImageDataPtr image, QcepMaskDataPtr overflow)
void	acquiredDoubleImage (QcepDoubleImageDataPtr image, QcepMaskDataPtr overflow, QcepDoubleList v)
Public Member Functions inherited from QxrdDataProcessorBase
	QxrdDataProcessorBase (QcepSettingsSaverWPtr saver, QxrdExperimentWPtr doc, QxrdAcquisitionWPtr acq, QxrdFileSaverWPtr filesaver)
virtual	~QxrdDataProcessorBase ()
void	loadDefaultImages ()
QcepDoubleImageDataPtr	takeNextFreeImage (int width, int height)
void	readSettings (QSettings *settings, QString section)
void	writeSettings (QSettings *settings, QString section)
void	setAcquisition (QxrdAcquisitionWPtr acq)
void	setWindow (QxrdWindowWPtr win)
void	createMaskIfNeeded ()
QxrdMaskStackPtr	maskStack ()
QxrdExperimentPtr	experiment () const
QxrdCenterFinderPtr	centerFinder () const
QxrdIntegratorPtr	integrator () const
QxrdPolarTransformPtr	polarTransform () const
QxrdPolarNormalizationPtr	polarNormalization () const
QxrdGenerateTestImageWPtr	generateTestImage () const
QxrdDistortionCorrectionPtr	distortionCorrection () const
void	newMask ()
void	updateEstimatedTime (QcepDoubleProperty *prop, int msec)
Public Member Functions inherited from QcepObject
	QcepObject (QString name, QcepObject *parent)
virtual	~QcepObject ()
QString	get_Name () const
void	set_Name (QString name)

Protected Member Functions
double	estimatedProcessingTime (double estSerTime, double estParallelTime)
Protected Member Functions inherited from QxrdDataProcessorBase
void	saveNamedImageData (QString name, QcepDoubleImageDataPtr image, QcepMaskDataPtr overflow, int canOverwrite=NoOverwrite)
void	saveNamedImageData (QString name, QcepInt16ImageDataPtr image, QcepMaskDataPtr overflow, int canOverwrite=NoOverwrite)
void	saveNamedImageData (QString name, QcepInt32ImageDataPtr image, QcepMaskDataPtr overflow, int canOverwrite=NoOverwrite)
void	saveNamedRawImageData (QString name, QcepInt16ImageDataPtr image, QcepMaskDataPtr overflow, int canOverwrite=NoOverwrite)
void	saveNamedRawImageData (QString name, QcepInt32ImageDataPtr image, QcepMaskDataPtr overflow, int canOverwrite=NoOverwrite)
void	saveNamedMaskData (QString name, QcepMaskDataPtr mask, int canOverwrite=NoOverwrite)
void	saveNamedImageDataAsText (QString name, QcepDoubleImageDataPtr image, QcepMaskDataPtr overflow, int canOverwrite=NoOverwrite)
void	writeOutputScan (QVector< double > x, QVector< double > y)
QcepDoubleImageDataPtr	processAcquiredInt16Image (QcepDoubleImageDataPtr processed, QcepInt16ImageDataPtr image, QcepDoubleImageDataPtr dark, QcepMaskDataPtr mask, QcepMaskDataPtr overflow)
QcepDoubleImageDataPtr	processAcquiredInt32Image (QcepDoubleImageDataPtr processed, QcepInt32ImageDataPtr image, QcepDoubleImageDataPtr dark, QcepMaskDataPtr mask, QcepMaskDataPtr overflow)
QcepDoubleImageDataPtr	processAcquiredDoubleImage (QcepDoubleImageDataPtr processed, QcepDoubleImageDataPtr image, QcepDoubleImageDataPtr dark, QcepMaskDataPtr mask, QcepMaskDataPtr overflow)
QcepDoubleImageDataPtr	processAcquiredDoubleImage (QcepDoubleImageDataPtr processed, QcepDoubleImageDataPtr image, QcepDoubleImageDataPtr dark, QcepMaskDataPtr mask, QcepMaskDataPtr overflow, QcepDoubleList v)
QcepDoubleImageDataPtr	processAcquiredImage (QcepDoubleImageDataPtr processed, QcepDoubleImageDataPtr dimg, QcepDoubleImageDataPtr dark, QcepMaskDataPtr mask, QcepMaskDataPtr overflow, QcepDoubleList v=QcepDoubleList())
void	newDarkImage (QcepInt16ImageDataPtr image)
void	newDarkImage (QcepInt32ImageDataPtr image)
double	estimatedProcessingTime (double estSerTime, double estParallelTime)
void	newDarkImage (QcepDoubleImageDataPtr image)
void	newBadPixelsImage (QcepDoubleImageDataPtr image)
void	newGainMapImage (QcepDoubleImageDataPtr image)
int	newMaskWidth () const
int	newMaskHeight () const
int	incrementAcquiredCount ()
int	decrementAcquiredCount ()
int	getAcquiredCount ()
void	subtractDarkImage (QcepDoubleImageDataPtr image, QcepDoubleImageDataPtr dark)
void	unsubtractDarkImage (QcepDoubleImageDataPtr image, QcepDoubleImageDataPtr dark)
void	correctBadPixels (QcepDoubleImageDataPtr image)
void	correctImageGains (QcepDoubleImageDataPtr image)
void	performImageCorrections (QcepDoubleImageDataPtr image)

Private Slots
void	onCorrectedImageAvailable ()
void	onIntegratedDataAvailable ()
void	onROIDataAvailable ()
void	onHistogramDataAvailable ()

Private Member Functions
QcepDoubleImageDataPtr	correctInt16Image (QcepDoubleImageDataPtr corrected, QcepInt16ImageDataPtr image, QcepDoubleImageDataPtr dark, QcepMaskDataPtr mask, QcepMaskDataPtr overflow)
QcepDoubleImageDataPtr	correctInt32Image (QcepDoubleImageDataPtr corrected, QcepInt32ImageDataPtr image, QcepDoubleImageDataPtr dark, QcepMaskDataPtr mask, QcepMaskDataPtr overflow)
QcepDoubleImageDataPtr	correctDoubleImage (QcepDoubleImageDataPtr corrected, QcepDoubleImageDataPtr image, QcepDoubleImageDataPtr dark, QcepMaskDataPtr mask, QcepMaskDataPtr overflow)
QcepDoubleImageDataPtr	correctDoubleImage (QcepDoubleImageDataPtr corrected, QcepDoubleImageDataPtr image, QcepDoubleImageDataPtr dark, QcepMaskDataPtr overflow, QcepDoubleList v)
QcepIntegratedDataPtr	integrateImage (QcepIntegratedDataPtr integ, QcepDoubleImageDataPtr image, QcepMaskDataPtr mask, double cx, double cy)
QxrdROIDataPtr	calculateROI (QcepDoubleImageDataPtr image, QcepMaskDataPtr mask)
QxrdHistogramDataPtr	calculateHistogram (QcepDoubleImageDataPtr image, QcepMaskDataPtr mask)

Private Attributes
QxrdResultSerializer< QcepDoubleImageDataPtr >	m_CorrectedImages
QxrdResultSerializer< QcepIntegratedDataPtr >	m_IntegratedData
QxrdResultSerializer< QxrdROIDataPtr >	m_ROIData
QxrdResultSerializer< QxrdHistogramDataPtr >	m_HistogramData

Additional Inherited Members
Public Types inherited from QxrdDataProcessorBase
enum	{ NoOverwrite, CanOverwrite }
enum	{ ZingerNoMask = -2, ZingerDataMask = -1, ZingerTopStack = -1 }
Signals inherited from QxrdDataProcessorBase
void	newIntegrationAvailable (QcepIntegratedDataPtr data)
Static Public Member Functions inherited from QcepObject
static int	allocatedObjects ()
static int	deletedObjects ()
static QSet< QcepObject * >	allocatedObjectsSet ()
static QString	addSlashes (QString str)
Public Attributes inherited from QxrdDataProcessorBase
enum QxrdDataProcessorBase:: { ... }	ZingerConstants
Protected Attributes inherited from QxrdDataProcessorBase
QxrdExperimentWPtr	m_Experiment
QcepSettingsSaverWPtr	m_Saver
QxrdWindowWPtr	m_Window
QxrdFileSaverWPtr	m_FileSaver
QxrdAcquisitionWPtr	m_Acquisition
QWaitCondition	m_ProcessWaiting
QcepInt16ImageQueue	m_AcquiredInt16Images
QcepInt32ImageQueue	m_AcquiredInt32Images
QcepDoubleImageDataPtr	m_Data
QcepDoubleImageDataPtr	m_DarkFrame
QcepDoubleImageDataPtr	m_BadPixels
QcepDoubleImageDataPtr	m_GainMap
QcepDoubleImageDataPtr	m_LiveData
QcepMaskDataPtr	m_Overflow
QxrdMaskStack	m_Masks
QAtomicInt	m_AcquiredCount
QxrdCenterFinderPtr	m_CenterFinder
QxrdIntegratorPtr	m_Integrator
QxrdPolarTransformPtr	m_PolarTransform
QxrdPolarNormalizationPtr	m_PolarNormalization
QxrdGenerateTestImagePtr	m_GenerateTestImage
QcepIntegratedDataPtr	m_OutputScan
QxrdDistortionCorrectionPtr	m_DistortionCorrection
Properties inherited from QxrdDataProcessorBase
QString	fileName
QString	dataPath
QString	darkImagePath
QString	badPixelsPath
QString	gainMapPath
QString	maskPath
QString	scriptPath
bool	performDarkSubtraction
bool	saveRawImages
bool	saveDarkImages
bool	performBadPixels
bool	performGainCorrection
bool	saveSubtracted
bool	saveAsText
QString	saveAsTextSeparator
int	saveAsTextPerLine
bool	saveOverflowFiles
bool	performIntegration
bool	displayIntegratedData
bool	saveIntegratedData
QString	saveIntegratedPath
bool	saveDarkInSubdirectory
QString	saveDarkSubdirectory
bool	saveRawInSubdirectory
QString	saveRawSubdirectory
bool	saveSubtractedInSubdirectory
QString	saveSubtractedSubdirectory
bool	saveIntegratedInSeparateFiles
bool	saveIntegratedInSubdirectory
QString	saveIntegratedSubdirectory
bool	accumulateIntegrated2D
QString	accumulateIntegratedName
QString	accumulateIntegratedDirectory
QString	accumulateIntegratedFileName
QString	accumulateIntegratedFormat
double	performDarkSubtractionTime
double	performBadPixelsTime
double	performGainCorrectionTime
double	saveSubtractedTime
double	saveAsTextTime
double	performIntegrationTime
double	displayIntegratedDataTime
double	saveIntegratedDataTime
double	estimatedProcessingTime
double	averagingRatio
double	maskMinimumValue
double	maskMaximumValue
double	maskCircleRadius
bool	maskSetPixels
double	average
double	averageDark
double	averageRaw
int	correctionQueueLength
int	integrationQueueLength
int	saverQueueLength
int	zingerAlgorithm
int	zingerMask
int	zingerDestination
int	zingerSize1
int	zingerSize2
double	zingerThreshold
Properties inherited from QcepObject
QString	name

Detailed Description

Definition at line 16 of file qxrddataprocessorthreaded.h.

Constructor & Destructor Documentation

QxrdDataProcessorThreaded::QxrdDataProcessorThreaded	(	QcepSettingsSaverWPtr	saver,
		QxrdExperimentWPtr	doc,
		QxrdAcquisitionWPtr	acq,
		QxrdFileSaverWPtr	filesaver
	)

Definition at line 18 of file qxrddataprocessorthreaded.cpp.

References m_CorrectedImages, m_HistogramData, m_IntegratedData, m_ROIData, onCorrectedImageAvailable(), onHistogramDataAvailable(), onIntegratedDataAvailable(), onROIDataAvailable(), and QxrdResultSerializerBase::resultAvailable().

  : QxrdDataProcessorBase(saver, doc, acq, filesaver),
    m_CorrectedImages(prop_CorrectionQueueLength(), this),
    m_IntegratedData(prop_IntegrationQueueLength(), this),
    m_ROIData(NULL, this),
    m_HistogramData(NULL, this)
{
  connect(&m_CorrectedImages, &QxrdResultSerializerBase::resultAvailable, this, &QxrdDataProcessorThreaded::onCorrectedImageAvailable);
  connect(&m_IntegratedData,  &QxrdResultSerializerBase::resultAvailable, this, &QxrdDataProcessorThreaded::onIntegratedDataAvailable);
  connect(&m_ROIData,         &QxrdResultSerializerBase::resultAvailable, this, &QxrdDataProcessorThreaded::onROIDataAvailable);
  connect(&m_HistogramData,   &QxrdResultSerializerBase::resultAvailable, this, &QxrdDataProcessorThreaded::onHistogramDataAvailable);

//  prop_CorrectionQueueLength()->setDebug(true);
//  prop_IntegrationQueueLength()->setDebug(true);
}

Here is the call graph for this function:

QxrdDataProcessorThreaded::~QxrdDataProcessorThreaded ( )

virtual

Definition at line 37 of file qxrddataprocessorthreaded.cpp.

{
}

Member Function Documentation

void QxrdDataProcessorThreaded::acquiredDoubleImage	(	QcepDoubleImageDataPtr	image,
		QcepMaskDataPtr	overflow
	)

Definition at line 98 of file qxrddataprocessorthreaded.cpp.

References correctDoubleImage(), QxrdDataProcessorBase::darkImage(), QxrdResultSerializer< T >::enqueue(), m_CorrectedImages, QxrdDataProcessorBase::mask(), and QxrdDataProcessorBase::takeNextFreeImage().

Referenced by processData(), and processNormalizedFile().

{
  QcepDoubleImageDataPtr corrected = takeNextFreeImage(image->get_Width(), image->get_Height());

  typedef QcepDoubleImageDataPtr (QxrdDataProcessorThreaded::*MFType)(QcepDoubleImageDataPtr, QcepDoubleImageDataPtr, QcepDoubleImageDataPtr, QcepMaskDataPtr, QcepMaskDataPtr);
  MFType p = &QxrdDataProcessorThreaded::correctDoubleImage;

  m_CorrectedImages.enqueue(QtConcurrent::run(this,
                                              p,
                                              corrected, image, darkImage(), mask(), overflow));
}

Here is the call graph for this function:

Here is the caller graph for this function:

void QxrdDataProcessorThreaded::acquiredDoubleImage	(	QcepDoubleImageDataPtr	image,
		QcepMaskDataPtr	overflow,
		QcepDoubleList	v
	)

Definition at line 110 of file qxrddataprocessorthreaded.cpp.

References correctDoubleImage(), QxrdDataProcessorBase::darkImage(), QxrdResultSerializer< T >::enqueue(), m_CorrectedImages, and QxrdDataProcessorBase::takeNextFreeImage().

{
  QcepDoubleImageDataPtr corrected = takeNextFreeImage(image->get_Width(), image->get_Height());

  typedef QcepDoubleImageDataPtr (QxrdDataProcessorThreaded::*MFType)(QcepDoubleImageDataPtr, QcepDoubleImageDataPtr, QcepDoubleImageDataPtr, QcepMaskDataPtr, QList<double>);
  MFType p = &QxrdDataProcessorThreaded::correctDoubleImage;

  m_CorrectedImages.enqueue(QtConcurrent::run(this,
                                              p,
                                              corrected, image, darkImage(), overflow, v));
}

Here is the call graph for this function:

void QxrdDataProcessorThreaded::acquiredInt16Image	(	QcepInt16ImageDataPtr	image,
		QcepMaskDataPtr	overflow
	)

Definition at line 80 of file qxrddataprocessorthreaded.cpp.

References correctInt16Image(), QxrdDataProcessorBase::darkImage(), QxrdResultSerializer< T >::enqueue(), m_CorrectedImages, QxrdDataProcessorBase::mask(), and QxrdDataProcessorBase::takeNextFreeImage().

{
  QcepDoubleImageDataPtr corrected = takeNextFreeImage(image->get_Width(), image->get_Height());

  m_CorrectedImages.enqueue(QtConcurrent::run(this,
                                              &QxrdDataProcessorThreaded::correctInt16Image,
                                              corrected, image, darkImage(), mask(), overflow));
}

Here is the call graph for this function:

void QxrdDataProcessorThreaded::acquiredInt32Image	(	QcepInt32ImageDataPtr	image,
		QcepMaskDataPtr	overflow
	)

Definition at line 89 of file qxrddataprocessorthreaded.cpp.

References correctInt32Image(), QxrdDataProcessorBase::darkImage(), QxrdResultSerializer< T >::enqueue(), m_CorrectedImages, QxrdDataProcessorBase::mask(), and QxrdDataProcessorBase::takeNextFreeImage().

{
  QcepDoubleImageDataPtr corrected = takeNextFreeImage(image->get_Width(), image->get_Height());

  m_CorrectedImages.enqueue(QtConcurrent::run(this,
                                              &QxrdDataProcessorThreaded::correctInt32Image,
                                              corrected, image, darkImage(), mask(), overflow));
}

Here is the call graph for this function:

void QxrdDataProcessorThreaded::addImages ( QStringList  names )

slot

Definition at line 383 of file qxrddataprocessorthreaded.cpp.

References QxrdDataProcessorBase::darkImage(), QxrdDataProcessorBase::data(), QxrdDataProcessorBase::filePathInDataDirectory(), QcepObject::name, QxrdDataProcessorBase::newData(), QxrdDataProcessorBase::printMessage(), QcepImageDataBase::Raw16Data, QcepImageDataBase::Raw32Data, QxrdDataProcessorBase::statusMessage(), QxrdDataProcessorBase::subtractDarkImage(), and QxrdDataProcessorBase::takeNextFreeImage().

{
  QcepDoubleImageDataPtr summed = data();

  foreach(QString name, names) {
    QcepDoubleImageDataPtr img = takeNextFreeImage(0,0);
    QString path = filePathInDataDirectory(name);

    if (img->readImage(path)) {
      printMessage(tr("Load image from %1").arg(path));
      statusMessage(tr("Load image from %1").arg(path));

      img -> loadMetaData();

      int typ = img->get_DataType();

      if ((typ == QcepDoubleImageData::Raw16Data) ||
          (typ == QcepDoubleImageData::Raw32Data))
      {
        subtractDarkImage(img, darkImage());
      }

      summed->add(img);
    } else {
      printMessage(tr("Couldn't load %1").arg(path));
      statusMessage(tr("Couldn't load %1").arg(path));
    }
  }

  newData(summed, QcepMaskDataPtr());
}

Here is the call graph for this function:

void QxrdDataProcessorThreaded::beginAcquisition

(

int

isDark

)

Definition at line 41 of file qxrddataprocessorthreaded.cpp.

{
}

QxrdHistogramDataPtr QxrdDataProcessorThreaded::calculateHistogram ( QcepDoubleImageDataPtr  image, QcepMaskDataPtr  mask  )

private

Definition at line 309 of file qxrddataprocessorthreaded.cpp.

References DEBUG_PROCESS, and qcepDebug().

{
  QThread::currentThread()->setObjectName("calculateHistogram");

  if (qcepDebug(DEBUG_PROCESS)) {
    printMessage(tr("QxrdDataProcessorThreaded::calculateHistogram"));
  }

  return QxrdHistogramDataPtr();
}

Here is the call graph for this function:

QxrdROIDataPtr QxrdDataProcessorThreaded::calculateROI ( QcepDoubleImageDataPtr  image, QcepMaskDataPtr  mask  )

private

Definition at line 288 of file qxrddataprocessorthreaded.cpp.

References DEBUG_PROCESS, and qcepDebug().

{
  QThread::currentThread()->setObjectName("calculateROI");

  if (qcepDebug(DEBUG_PROCESS)) {
    printMessage(tr("QxrdDataProcessorThreaded::calculateROI"));
  }

  return QxrdROIDataPtr();
}

Here is the call graph for this function:

void QxrdDataProcessorThreaded::clearAccumulator ( )

slot

Definition at line 447 of file qxrddataprocessorthreaded.cpp.

References QxrdDataProcessorBase::m_Integrator.

{
  m_Integrator -> clearAccumulator(get_AccumulateIntegratedName());
}

QcepDoubleImageDataPtr QxrdDataProcessorThreaded::correctDoubleImage ( QcepDoubleImageDataPtr  corrected, QcepDoubleImageDataPtr  image, QcepDoubleImageDataPtr  dark, QcepMaskDataPtr  mask, QcepMaskDataPtr  overflow  )

private

Definition at line 174 of file qxrddataprocessorthreaded.cpp.

References DEBUG_PROCESS, and qcepDebug().

Referenced by acquiredDoubleImage().

{
  QThread::currentThread()->setObjectName("correctDoubleImage");

  if (qcepDebug(DEBUG_PROCESS)) {
    printMessage(tr("QxrdDataProcessorThreaded::correctDoubleImage"));
  }

  if (image) {
    if ((image -> get_ImageNumber()) >= 0) {
      return processAcquiredDoubleImage(corrected, image, dark, mask, overflow);
    } else {
      if (get_SaveDarkImages()) {
        saveNamedImageData(image->get_FileName(), image, overflow);

        set_DarkImagePath(image->get_FileName());
      }

      newDarkImage(image);
    }
  }

  return QcepDoubleImageDataPtr();
}

Here is the call graph for this function:

Here is the caller graph for this function:

QcepDoubleImageDataPtr QxrdDataProcessorThreaded::correctDoubleImage ( QcepDoubleImageDataPtr  corrected, QcepDoubleImageDataPtr  image, QcepDoubleImageDataPtr  dark, QcepMaskDataPtr  overflow, QcepDoubleList  v  )

private

Definition at line 200 of file qxrddataprocessorthreaded.cpp.

References DEBUG_PROCESS, and qcepDebug().

{
  QThread::currentThread()->setObjectName("correctDoubleImage");

  if (qcepDebug(DEBUG_PROCESS)) {
    printMessage(tr("QxrdDataProcessorThreaded::correctDoubleImage"));
  }

  if (image) {
    if ((image -> get_ImageNumber()) >= 0) {
      return processAcquiredDoubleImage(corrected, image, dark, image->mask(), overflow, v);
    } else {
      if (get_SaveDarkImages()) {
        saveNamedImageData(image->get_FileName(), image, overflow);

        set_DarkImagePath(image->get_FileName());
      }

      newDarkImage(image);
    }
  }

  return QcepDoubleImageDataPtr();
}

Here is the call graph for this function:

QcepDoubleImageDataPtr QxrdDataProcessorThreaded::correctInt16Image ( QcepDoubleImageDataPtr  corrected, QcepInt16ImageDataPtr  image, QcepDoubleImageDataPtr  dark, QcepMaskDataPtr  mask, QcepMaskDataPtr  overflow  )

private

Definition at line 123 of file qxrddataprocessorthreaded.cpp.

References DEBUG_PROCESS, and qcepDebug().

Referenced by acquiredInt16Image().

{
  QThread::currentThread()->setObjectName("correctInt16Image");

  if (qcepDebug(DEBUG_PROCESS)) {
    printMessage(tr("QxrdDataProcessorThreaded::correctInt16Image"));
  }

  if (image) {
    if ((image -> get_ImageNumber()) >= 0) {
      return processAcquiredInt16Image(corrected, image, dark, mask, overflow);
    } else {
      if (get_SaveDarkImages()) {
        saveNamedImageData(image->get_FileName(), image, overflow);
        set_DarkImagePath(image->get_FileName());
      }

      newDarkImage(image);
    }
  }

  return QcepDoubleImageDataPtr();
}

Here is the call graph for this function:

Here is the caller graph for this function:

QcepDoubleImageDataPtr QxrdDataProcessorThreaded::correctInt32Image ( QcepDoubleImageDataPtr  corrected, QcepInt32ImageDataPtr  image, QcepDoubleImageDataPtr  dark, QcepMaskDataPtr  mask, QcepMaskDataPtr  overflow  )

private

Definition at line 148 of file qxrddataprocessorthreaded.cpp.

References DEBUG_PROCESS, and qcepDebug().

Referenced by acquiredInt32Image().

{
  QThread::currentThread()->setObjectName("correctInt32Image");

  if (qcepDebug(DEBUG_PROCESS)) {
    printMessage(tr("QxrdDataProcessorThreaded::correctInt32Image"));
  }

  if (image) {
    if ((image -> get_ImageNumber()) >= 0) {
      return processAcquiredInt32Image(corrected, image, dark, mask, overflow);
    } else {
      if (get_SaveDarkImages()) {
        saveNamedImageData(image->get_FileName(), image, overflow);

        set_DarkImagePath(image->get_FileName());
      }

      newDarkImage(image);
    }
  }

  return QcepDoubleImageDataPtr();
}

Here is the call graph for this function:

Here is the caller graph for this function:

void QxrdDataProcessorThreaded::correlateImages ( QStringList  names )

slot

Definition at line 662 of file qxrddataprocessorthreaded.cpp.

References QxrdDataProcessorBase::darkImage(), QxrdDataProcessorBase::data(), QxrdDataProcessorBase::filePathInDataDirectory(), QcepObject::name, QxrdDataProcessorBase::printMessage(), QcepImageDataBase::Raw16Data, QcepImageDataBase::Raw32Data, QxrdDataProcessorBase::statusMessage(), QxrdDataProcessorBase::subtractDarkImage(), and QxrdDataProcessorBase::takeNextFreeImage().

{
  QcepDoubleImageDataPtr imga = data();

  foreach(QString name, names) {
    QcepDoubleImageDataPtr imgb = takeNextFreeImage(0,0);
    QString path = filePathInDataDirectory(name);

    if (imgb->readImage(path)) {
      printMessage(tr("Load image from %1").arg(path));
      statusMessage(tr("Load image from %1").arg(path));

      imgb -> loadMetaData();

      int typ = imgb->get_DataType();

      if ((typ == QcepDoubleImageData::Raw16Data) ||
          (typ == QcepDoubleImageData::Raw32Data))
      {
        subtractDarkImage(imgb, darkImage());
      }

      printMessage("dx\tdy\tcorr");

      for (int dy = -10; dy<=10; dy++) {
        for (int dx = -10; dx<=10; dx++) {
          double corr = imga->correlate(imgb, dx, dy, 10, 10);

          printMessage(tr("%1\t%2\t%3").arg(dx).arg(dy).arg(corr));
        }
      }
    } else {
      printMessage(tr("Couldn't load %1").arg(path));
      statusMessage(tr("Couldn't load %1").arg(path));
    }
  }
}

Here is the call graph for this function:

double QxrdDataProcessorThreaded::estimatedProcessingTime ( double  estSerTime, double  estParallelTime  )

protected

Definition at line 329 of file qxrddataprocessorthreaded.cpp.

{
  int nThreads = QThreadPool::globalInstance()->maxThreadCount();

  if (nThreads >= 2) {
    return qMax(estSerialTime, estParallelTime/((double)nThreads));
  } else {
    return estSerialTime + estParallelTime;
  }
}

void QxrdDataProcessorThreaded::fitPeakNear ( double  x, double  y  )

slot

Definition at line 947 of file qxrddataprocessorthreaded.cpp.

References QxrdDataProcessorBase::centerFinder().

{
  QxrdCenterFinderPtr cf(centerFinder());

  if (cf) {
    cf->fitPeakNear(x,y);
  }
}

Here is the call graph for this function:

void QxrdDataProcessorThreaded::fixupBadBackgroundSubtraction ( QString  imagePattern, int  nImgExposures, QString  darkPath, int  nDarkExposures  )

slot

Definition at line 904 of file qxrddataprocessorthreaded.cpp.

References QxrdDataProcessorBase::dataDirectory(), QxrdDataProcessorBase::filePathInDataDirectory(), QxrdDataProcessorBase::m_FileSaver, QxrdDataProcessorBase::NoOverwrite, QxrdDataProcessorBase::printMessage(), and QxrdDataProcessorBase::takeNextFreeImage().

{
  QDirIterator imagePaths(dataDirectory(), QStringList(imagePattern));

  QcepDoubleImageDataPtr dark = takeNextFreeImage(0,0);
  QString path = filePathInDataDirectory(darkPath);

  if (dark->readImage(path)) {
    dark->loadMetaData();

    int nFileDarkExposures = dark->get_SummedExposures();

    printMessage(tr("Loaded Dark image from %1 (%2 summed)").arg(path).arg(nFileDarkExposures));

    while (imagePaths.hasNext()) {
      QString imagePath=imagePaths.next();

      QString path = filePathInDataDirectory(imagePath);
      QcepDoubleImageDataPtr image = takeNextFreeImage(0,0);

      if (image->readImage(path)) {
        image->loadMetaData();

        int nFileImageExposures = image->get_SummedExposures();

        printMessage(tr("Loaded image from %1 (%2 summed)").arg(path).arg(nFileImageExposures));

        image->correctBadBackgroundSubtraction(dark,nImgExposures,nDarkExposures);

        QxrdFileSaverPtr saver(m_FileSaver);

        if (saver) {
          saver->saveDoubleData(path, image, QcepMaskDataPtr(), NoOverwrite);
        }
      } else {
        printMessage(tr("Failed to load image from %1").arg(path));
      }
    }
  } else {
    printMessage(tr("Failed to load Dark image from %1").arg(path));
  }
}

Here is the call graph for this function:

void QxrdDataProcessorThreaded::idleInt16Image	(	QcepInt16ImageDataPtr	image,
		bool	liveView
	)

Definition at line 45 of file qxrddataprocessorthreaded.cpp.

References QxrdDataProcessorBase::darkImage(), DEBUG_PROCESS, QxrdDataProcessorBase::m_LiveData, QxrdDataProcessorBase::newData(), QxrdDataProcessorBase::printMessage(), qcepDebug(), QxrdDataProcessorBase::subtractDarkImage(), and QxrdDataProcessorBase::takeNextFreeImage().

{
  QcepMutexLocker lock(__FILE__, __LINE__, image->mutex());
  int height = image->get_Height();
  int width  = image->get_Width();
  int nres = image-> get_SummedExposures();
  int npixels = width*height;
  if (nres <= 0) nres = 1;
  double avgraw = 0;
  quint16 *img = image->data();

  for (int i=0; i<npixels; i++) {
    avgraw += *img++;
  }

  set_AverageRaw(avgraw/npixels/nres);
  set_Average(get_AverageRaw() - get_AverageDark());

  if (liveView) {
    if (qcepDebug(DEBUG_PROCESS)) {
      printMessage("Image Live View");
    }

    QcepDoubleImageDataPtr corrected = takeNextFreeImage(image->get_Width(), image->get_Height());
    QcepDoubleImageDataPtr dark      = darkImage();

    corrected->copyFrom(image);
    subtractDarkImage(corrected, dark);

    newData(corrected, QcepMaskDataPtr());

    m_LiveData = corrected;
  }
}

Here is the call graph for this function:

void QxrdDataProcessorThreaded::integrateAndAccumulate ( QStringList  names )

slot

Definition at line 452 of file qxrddataprocessorthreaded.cpp.

References QxrdDataProcessorBase::filePathInDataDirectory(), QxrdDataProcessorBase::m_Integrator, QxrdDataProcessorBase::mask(), QcepObject::name, QxrdDataProcessorBase::printMessage(), QxrdDataProcessorBase::statusMessage(), and QxrdDataProcessorBase::takeNextFreeImage().

{
  int nImages   = names.count();
  m_Integrator -> prepareAccumulator(get_AccumulateIntegratedName(), nImages);

  foreach(QString name, names) {
    QcepDoubleImageDataPtr img = takeNextFreeImage(0,0);
    QString path = filePathInDataDirectory(name);

    if (img->readImage(path)) {
      printMessage(tr("Load image from %1").arg(path));
      statusMessage(tr("Load image from %1").arg(path));

      img -> loadMetaData();

      m_Integrator -> appendIntegration(get_AccumulateIntegratedName(), img, mask());
    } else {
      printMessage(tr("Couldn't load %1").arg(path));
      statusMessage(tr("Couldn't load %1").arg(path));
    }
  }

  m_Integrator -> completeAccumulator(get_AccumulateIntegratedName());
}

Here is the call graph for this function:

void QxrdDataProcessorThreaded::integrateData ( QString  name )

slot

Definition at line 713 of file qxrddataprocessorthreaded.cpp.

References QcepAllocator::AlwaysAllocate, QxrdDataProcessorBase::centerFinder(), QxrdResultSerializer< T >::enqueue(), QxrdDataProcessorBase::filePathInDataDirectory(), integrateImage(), m_IntegratedData, QxrdDataProcessorBase::mask(), QcepAllocator::newDoubleImageAndIntegratedData(), QxrdDataProcessorBase::printMessage(), and QxrdDataProcessorBase::statusMessage().

{
  QThread::currentThread()->setObjectName("integrateData");

  QcepDoubleImageDataPtr img;
  QcepIntegratedDataPtr  result;

  QcepAllocator::newDoubleImageAndIntegratedData(QcepAllocator::AlwaysAllocate, 0,0, this, img, result);

  QString path = filePathInDataDirectory(name);

  if (img -> readImage(path)) {
    printMessage(tr("Load image from %1").arg(path));
    statusMessage(tr("Load image from %1").arg(path));

    //  printf("Read %d x %d image\n", res->get_Width(), res->get_Height());

    img -> loadMetaData();

    m_IntegratedData.enqueue(QtConcurrent::run(this, &QxrdDataProcessorThreaded::integrateImage,
                                               result,
                                               img, mask(),
                                               centerFinder() -> get_CenterX(),
                                               centerFinder() -> get_CenterY()));
  } else {
    printMessage(tr("Couldn't load %1").arg(path));
    statusMessage(tr("Couldn't load %1").arg(path));
  }
}

Here is the call graph for this function:

QcepIntegratedDataPtr QxrdDataProcessorThreaded::integrateImage ( QcepIntegratedDataPtr  integ, QcepDoubleImageDataPtr  image, QcepMaskDataPtr  mask, double  cx, double  cy  )

private

Definition at line 247 of file qxrddataprocessorthreaded.cpp.

References DEBUG_PROCESS, and qcepDebug().

Referenced by integrateData(), and onCorrectedImageAvailable().

{
  QThread::currentThread()->setObjectName("integrateImage");

  if (qcepDebug(DEBUG_PROCESS)) {
    printMessage(tr("QxrdDataProcessorThreaded::integrateImage"));
  }

  if (image && get_PerformIntegration()) {
    QTime tic;
    tic.start();

    m_Integrator -> performIntegration(integ, image, mask);

    updateEstimatedTime(prop_PerformIntegrationTime(), tic.restart());

    return integ;
  }

  return QcepIntegratedDataPtr();
}

Here is the call graph for this function:

Here is the caller graph for this function:

void QxrdDataProcessorThreaded::integrateSaveAndDisplay ( )

slot

Definition at line 888 of file qxrddataprocessorthreaded.cpp.

References QxrdDataProcessorBase::data(), DEBUG_INTEGRATOR, QxrdResultSerializer< T >::enqueue(), QxrdDataProcessorBase::m_CenterFinder, m_IntegratedData, QxrdDataProcessorBase::m_Integrator, QxrdDataProcessorBase::mask(), QcepAllocator::newIntegratedData(), QxrdIntegrator::performIntegration(), QxrdDataProcessorBase::printMessage(), qcepDebug(), and QcepAllocator::WaitTillAvailable.

Referenced by QxrdWindow::initialize(), and QxrdIntegratorDialog::QxrdIntegratorDialog().

{
  if (qcepDebug(DEBUG_INTEGRATOR)) {
    printMessage(tr("processor.integrateSaveAndDisplay: %1, %2, %3")
                 .arg(data()->get_FileName()).arg(m_CenterFinder->get_CenterX()).arg(m_CenterFinder->get_CenterY()));
  }

  QcepIntegratedDataPtr integ = QcepAllocator::newIntegratedData(QcepAllocator::WaitTillAvailable, data(), this);

  m_IntegratedData.enqueue(
      QtConcurrent::run(m_Integrator.data(),
                        &QxrdIntegrator::performIntegration,
                        integ,
                        data(), mask()));
}

Here is the call graph for this function:

Here is the caller graph for this function:

void QxrdDataProcessorThreaded::onCorrectedImageAvailable ( )

privateslot

Definition at line 225 of file qxrddataprocessorthreaded.cpp.

References QcepAllocator::AlwaysAllocate, QxrdDataProcessorBase::calculateHistogram(), QxrdDataProcessorBase::calculateROI(), QxrdDataProcessorBase::centerFinder(), QxrdResultSerializer< T >::dequeue(), QxrdResultSerializer< T >::enqueue(), integrateImage(), m_CorrectedImages, m_HistogramData, m_IntegratedData, m_ROIData, and QcepAllocator::newIntegratedData().

Referenced by QxrdDataProcessorThreaded().

{
  QcepDoubleImageDataPtr img = m_CorrectedImages.dequeue();
  QcepMaskDataPtr mask = (img ? img->mask() : QcepMaskDataPtr());
  QcepIntegratedDataPtr integ = QcepAllocator::newIntegratedData(QcepAllocator::AlwaysAllocate, img, this);

  if (img) {
    m_IntegratedData.enqueue(QtConcurrent::run(this, &QxrdDataProcessorThreaded::integrateImage,
                                               integ,
                                               img, mask,
                                               centerFinder() -> get_CenterX(),
                                               centerFinder() -> get_CenterY()));

    m_ROIData.enqueue(QtConcurrent::run(this, &QxrdDataProcessorThreaded::calculateROI,
                                        img, mask));

    m_HistogramData.enqueue(QtConcurrent::run(this, &QxrdDataProcessorThreaded::calculateHistogram,
                                              img, mask));
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void QxrdDataProcessorThreaded::onHistogramDataAvailable ( )

privateslot

Definition at line 320 of file qxrddataprocessorthreaded.cpp.

References DEBUG_PROCESS, QxrdResultSerializer< T >::dequeue(), m_HistogramData, QxrdDataProcessorBase::printMessage(), and qcepDebug().

Referenced by QxrdDataProcessorThreaded().

{
  if (qcepDebug(DEBUG_PROCESS)) {
    printMessage(tr("QxrdDataProcessorThreaded::onHistogramDataAvailable"));
  }

  QxrdHistogramDataPtr histData = m_HistogramData.dequeue();
}

Here is the call graph for this function:

Here is the caller graph for this function:

void QxrdDataProcessorThreaded::onIntegratedDataAvailable ( )

privateslot

Definition at line 269 of file qxrddataprocessorthreaded.cpp.

References DEBUG_PROCESS, QxrdResultSerializer< T >::dequeue(), QxrdDataProcessorBase::displayIntegratedData, m_IntegratedData, QxrdDataProcessorBase::m_Integrator, QxrdDataProcessorBase::printMessage(), qcepDebug(), and QxrdDataProcessorBase::writeOutputScan().

Referenced by QxrdDataProcessorThreaded().

{
  if (qcepDebug(DEBUG_PROCESS)) {
    printMessage(tr("QxrdDataProcessorThreaded::onIntegratedDataAvailable"));
  }

  QcepIntegratedDataPtr integ = m_IntegratedData.dequeue();

  if (integ) {
    writeOutputScan(integ);
    displayIntegratedData(integ);

    if (get_AccumulateIntegrated2D()) {
      m_Integrator -> appendIntegration(get_AccumulateIntegratedName(), integ);
    }
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void QxrdDataProcessorThreaded::onROIDataAvailable ( )

privateslot

Definition at line 299 of file qxrddataprocessorthreaded.cpp.

References DEBUG_PROCESS, QxrdResultSerializer< T >::dequeue(), m_ROIData, QxrdDataProcessorBase::printMessage(), and qcepDebug().

Referenced by QxrdDataProcessorThreaded().

{
  if (qcepDebug(DEBUG_PROCESS)) {
    printMessage(tr("QxrdDataProcessorThreaded::onROIDataAvailable"));
  }

  QxrdROIDataPtr roiData = m_ROIData.dequeue();
}

Here is the call graph for this function:

Here is the caller graph for this function:

void QxrdDataProcessorThreaded::processData ( QString  name )

slot

Definition at line 743 of file qxrddataprocessorthreaded.cpp.

References acquiredDoubleImage(), QxrdDataProcessorBase::filePathInDataDirectory(), QxrdDataProcessorBase::printMessage(), QxrdDataProcessorBase::statusMessage(), and QxrdDataProcessorBase::takeNextFreeImage().

Referenced by processDataSequence().

{
  QcepDoubleImageDataPtr res = takeNextFreeImage(0,0);

  QString path = filePathInDataDirectory(name);

  if (res -> readImage(path)) {
    printMessage(tr("Load image from %1").arg(path));
    statusMessage(tr("Load image from %1").arg(path));

    //  printf("Read %d x %d image\n", res->get_Width(), res->get_Height());

    res -> loadMetaData();

    acquiredDoubleImage(res, /*darkImage(), mask(),*/ QcepMaskDataPtr());

    set_DataPath(res -> get_FileName());
  } else {
    printMessage(tr("Couldn't load %1").arg(path));
    statusMessage(tr("Couldn't load %1").arg(path));
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void QxrdDataProcessorThreaded::processDataSequence ( QString  path, QString  filter = "*.tif"  )

slot

Definition at line 766 of file qxrddataprocessorthreaded.cpp.

References QxrdDataProcessorBase::printMessage(), and processData().

{
  QDirIterator iter(path, QStringList(filter));

  while (iter.hasNext()) {
    QString path = iter.next();

    printMessage(path);

    processData(path);
  }
}

Here is the call graph for this function:

void QxrdDataProcessorThreaded::processDataSequence ( QStringList  paths )

slot

Definition at line 779 of file qxrddataprocessorthreaded.cpp.

References QxrdDataProcessorBase::printMessage(), and processData().

{
  QString path;

  foreach(path, paths) {
    printMessage(path);

    processData(path);
  }
}

Here is the call graph for this function:

void QxrdDataProcessorThreaded::processDataSequence ( QString  path, QStringList  filter  )

slot

Definition at line 790 of file qxrddataprocessorthreaded.cpp.

References QxrdDataProcessorBase::printMessage(), and processData().

{
  QDirIterator iter(path, filters);

  while (iter.hasNext()) {
    QString path = iter.next();

    printMessage(path);

    processData(path);
  }
}

Here is the call graph for this function:

void QxrdDataProcessorThreaded::processNormalizedFile ( QString  path, double  v1  )

slot

Definition at line 803 of file qxrddataprocessorthreaded.cpp.

Referenced by processNormalizedFile().

{
  QList<double> v;
  v << v1;

  processNormalizedFile(path, v);
}

Here is the caller graph for this function:

void QxrdDataProcessorThreaded::processNormalizedFile ( QString  path, double  v1, double  v2  )

slot

Definition at line 811 of file qxrddataprocessorthreaded.cpp.

References processNormalizedFile().

{
  QList<double> v;
  v << v1 << v2;

  processNormalizedFile(path, v);
}

Here is the call graph for this function:

void QxrdDataProcessorThreaded::processNormalizedFile ( QString  path, QcepDoubleList  v  )

slot

Definition at line 819 of file qxrddataprocessorthreaded.cpp.

References acquiredDoubleImage(), QxrdDataProcessorBase::filePathInDataDirectory(), QxrdDataProcessorBase::mask(), QxrdDataProcessorBase::printMessage(), and QxrdDataProcessorBase::takeNextFreeImage().

{
  QcepDoubleImageDataPtr res = takeNextFreeImage(0,0);

  QString path = filePathInDataDirectory(name);

  if (res -> readImage(path)) {

    //  printf("Read %d x %d image\n", res->get_Width(), res->get_Height());

    res -> loadMetaData();
    res -> setMask(mask(), QcepMaskDataPtr());

    acquiredDoubleImage(res, /*darkImage(), mask(),*/ QcepMaskDataPtr(), v);

    set_DataPath(res -> get_FileName());
  } else {
    printMessage(tr("Couldn't load %1").arg(path));
  }
}

Here is the call graph for this function:

void QxrdDataProcessorThreaded::projectImages ( QStringList  names, int  px, int  py, int  pz  )

slot

Definition at line 526 of file qxrddataprocessorthreaded.cpp.

References QxrdDataProcessorBase::darkImage(), QxrdDataProcessorBase::filePathInDataDirectory(), QxrdDataProcessorBase::m_Experiment, QxrdDataProcessorBase::newData(), QxrdDataProcessorBase::printMessage(), QcepImageDataBase::Raw16Data, QcepImageDataBase::Raw32Data, QxrdDataProcessorBase::statusMessage(), QxrdDataProcessorBase::subtractDarkImage(), and QxrdDataProcessorBase::takeNextFreeImage().

{
  QcepDoubleImageDataPtr sumx, sumy, sumz;

  int nx = 0;
  int ny = 0;
  int nz = names.count();
  int first = true;

  if (px) {
    sumx = takeNextFreeImage(0,0);
    printMessage(tr("Projecting %1 images onto X").arg(nz));
  }

  if (py) {
    sumy = takeNextFreeImage(0,0);
    printMessage(tr("Projecting %1 images onto Y").arg(nz));
  }

  if (pz) {
    sumz = takeNextFreeImage(0,0);
    printMessage(tr("Projecting %1 images onto Z").arg(nz));
  }

  QxrdExperimentPtr expt(m_Experiment);

  if (expt) {
    expt->commenceWork(nz);
  }

  for (int i=0; i<nz; i++) {
    QcepDoubleImageDataPtr img = takeNextFreeImage(0,0);
    QString path = filePathInDataDirectory(names[i]);

    if (img->readImage(path)) {
      printMessage(tr("Load image from %1").arg(path));
      statusMessage(tr("Load image from %1").arg(path));

      img->loadMetaData();
      int typ = img->get_DataType();

      if ((typ == QcepDoubleImageData::Raw16Data) ||
          (typ == QcepDoubleImageData::Raw32Data))
      {
        subtractDarkImage(img, darkImage());
      }

      if (first) {
        nx = img->get_Width();
        ny = img->get_Height();

        if (px) {
          sumx->copyPropertiesFrom(img);
          sumx->resize(nz,ny);
          sumx->clear();
          sumx->set_SummedExposures(0);
        }

        if (py) {
          sumy->copyPropertiesFrom(img);
          sumy->resize(nz,nx);
          sumy->clear();
          sumy->set_SummedExposures(0);
        }

        if (pz) {
          sumz->copyPropertiesFrom(img);
          sumz->resize(nx,ny);
          sumz->clear();
          sumz->set_SummedExposures(0);
        }

        first = false;
      }

      if (px) {
        sumx->prop_SummedExposures()->incValue(1);

        for (int y=0; y<ny; y++) {
          double sum=0;

          for (int x=0; x<nx; x++) {
            sum += img->getImageData(x,y);
          }

          sumx->addValue(i,y, sum);
        }
      }

      if (py) {
        sumy->prop_SummedExposures()->incValue(1);

        for (int x=0; x<nx; x++) {
          double sum=0;

          for (int y=0; y<ny; y++) {
            sum += img->getImageData(x,y);
          }

          sumy->addValue(i,x, sum);
        }
      }

      if (pz) {
        sumz->prop_SummedExposures()->incValue(1);

        for (int x=0; x<nx; x++) {
          for (int y=0; y<ny; y++) {
            sumz->addValue(x,y, img->getImageData(x,y));
          }
        }
      }
    }

    if (expt) {
      expt->completeWork(1);
    }
  }

  if (px) {
    newData(sumx, QcepMaskDataPtr());
  }

  if (py) {
    newData(sumy, QcepMaskDataPtr());
  }

  if (pz) {
    newData(sumz, QcepMaskDataPtr());
  }

  if (expt) {
    expt->finishedWork(nz);
  }
}

Here is the call graph for this function:

void QxrdDataProcessorThreaded::reflectHorizontally ( )

slot

Definition at line 482 of file qxrddataprocessorthreaded.cpp.

References QxrdDataProcessorBase::data(), and QxrdDataProcessorBase::newData().

{
  QcepDoubleImageDataPtr image = data();

  if (image) {
    int wid = image->get_Width();
    int hgt = image->get_Height();

    for (int y=0; y<hgt; y++) {
      for (int x=0; x<wid/2; x++) {
        double val1 = image->getImageData(x,y);
        double val2 = image->getImageData(wid-x-1, y);

        image->setValue(wid-x-1, y, val1);
        image->setValue(x,y, val2);
      }
    }
  }

  newData(image, QcepMaskDataPtr());
}

Here is the call graph for this function:

void QxrdDataProcessorThreaded::reflectVertically ( )

slot

Definition at line 504 of file qxrddataprocessorthreaded.cpp.

References QxrdDataProcessorBase::data(), and QxrdDataProcessorBase::newData().

{
  QcepDoubleImageDataPtr image = data();

  if (image) {
    int wid = image->get_Width();
    int hgt = image->get_Height();

    for (int x=0; x<wid; x++) {
      for (int y=0; y<hgt/2; y++) {
        double val1 = image->getImageData(x,y);
        double val2 = image->getImageData(x, hgt-y-1);

        image->setValue(x, hgt-y-1, val1);
        image->setValue(x,y, val2);
      }
    }
  }

  newData(image, QcepMaskDataPtr());
}

Here is the call graph for this function:

void QxrdDataProcessorThreaded::saveAccumulator ( QString &  path, QString  filter  )

slot

Definition at line 477 of file qxrddataprocessorthreaded.cpp.

References QxrdDataProcessorBase::m_Integrator.

{
  m_Integrator -> saveAccumulator(get_AccumulateIntegratedName(), path, filter);
}

void QxrdDataProcessorThreaded::setFileNormalization ( QString  path, double  v1  )

slot

Definition at line 840 of file qxrddataprocessorthreaded.cpp.

Referenced by setFileNormalization().

{
  QList<double> v;
  v << v1;

  setFileNormalization(path, v);
}

Here is the caller graph for this function:

void QxrdDataProcessorThreaded::setFileNormalization ( QString  path, double  v1, double  v2  )

slot

Definition at line 848 of file qxrddataprocessorthreaded.cpp.

References setFileNormalization().

{
  QList<double> v;
  v << v1 << v2;

  setFileNormalization(path, v);
}

Here is the call graph for this function:

void QxrdDataProcessorThreaded::setFileNormalization ( QString  path, QcepDoubleList  v  )

slot

Definition at line 856 of file qxrddataprocessorthreaded.cpp.

References QxrdDataProcessorBase::filePathInDataDirectory(), QxrdDataProcessorBase::m_Experiment, QxrdDataProcessorBase::mask(), QxrdDataProcessorBase::printMessage(), and QxrdDataProcessorBase::takeNextFreeImage().

{
  QcepDoubleImageDataPtr res = takeNextFreeImage(0,0);

  QString path = filePathInDataDirectory(name);

  if (res -> readImage(path)) {

    //  printf("Read %d x %d image\n", res->get_Width(), res->get_Height());

    QxrdExperimentPtr exp(m_Experiment);

    res -> loadMetaData();
    res -> setMask(mask(), QcepMaskDataPtr());
    res -> set_Normalization(v);
    res -> saveMetaData(name);
  } else {
    printMessage(tr("Couldn't load %1").arg(path));
  }
}

Here is the call graph for this function:

void QxrdDataProcessorThreaded::shiftImage ( int  dx, int  dy  )

slot

Definition at line 700 of file qxrddataprocessorthreaded.cpp.

References QxrdDataProcessorBase::data(), QxrdDataProcessorBase::newData(), and QxrdDataProcessorBase::takeNextFreeImage().

{
  QcepDoubleImageDataPtr img = data();

  if (img) {
    QcepDoubleImageDataPtr shft = takeNextFreeImage(img->get_Width(), img->get_Height());

    shft->shiftImage(img, dx, dy);

    newData(shft, QcepMaskDataPtr());
  }
}

Here is the call graph for this function:

void QxrdDataProcessorThreaded::slicePolygon ( QVector< QPointF >  poly )

slot

Definition at line 877 of file qxrddataprocessorthreaded.cpp.

References QxrdDataProcessorBase::data(), QxrdResultSerializer< T >::enqueue(), QxrdDataProcessorBase::m_Data, m_IntegratedData, QxrdDataProcessorBase::m_Integrator, QcepAllocator::newIntegratedData(), QxrdIntegrator::slicePolygon(), and QcepAllocator::WaitTillAvailable.

{
  QcepIntegratedDataPtr integ = QcepAllocator::newIntegratedData(QcepAllocator::WaitTillAvailable, data(), this);

  m_IntegratedData.enqueue(
      QtConcurrent::run(m_Integrator.data(),
                        &QxrdIntegrator::slicePolygon,
                        integ,
                        m_Data, poly, 0));
}

Here is the call graph for this function:

void QxrdDataProcessorThreaded::subtractImages ( QStringList  names )

slot

Definition at line 415 of file qxrddataprocessorthreaded.cpp.

References QxrdDataProcessorBase::darkImage(), QxrdDataProcessorBase::data(), QxrdDataProcessorBase::filePathInDataDirectory(), QcepObject::name, QxrdDataProcessorBase::newData(), QxrdDataProcessorBase::printMessage(), QcepImageDataBase::Raw16Data, QcepImageDataBase::Raw32Data, QxrdDataProcessorBase::statusMessage(), QxrdDataProcessorBase::subtractDarkImage(), and QxrdDataProcessorBase::takeNextFreeImage().

{
  QcepDoubleImageDataPtr summed = data();

  foreach(QString name, names) {
    QcepDoubleImageDataPtr img = takeNextFreeImage(0,0);
    QString path = filePathInDataDirectory(name);

    if (img->readImage(path)) {
      printMessage(tr("Load image from %1").arg(path));
      statusMessage(tr("Load image from %1").arg(path));

      img -> loadMetaData();

      int typ = img->get_DataType();

      if ((typ == QcepDoubleImageData::Raw16Data) ||
          (typ == QcepDoubleImageData::Raw32Data))
      {
        subtractDarkImage(img, darkImage());
      }

      summed->subtract(img);
    } else {
      printMessage(tr("Couldn't load %1").arg(path));
      statusMessage(tr("Couldn't load %1").arg(path));
    }
  }

  newData(summed, QcepMaskDataPtr());
}

Here is the call graph for this function:

void QxrdDataProcessorThreaded::sumImages ( QStringList  names )

slot

Definition at line 340 of file qxrddataprocessorthreaded.cpp.

References QxrdDataProcessorBase::darkImage(), QxrdDataProcessorBase::filePathInDataDirectory(), QcepObject::name, QxrdDataProcessorBase::newData(), QxrdDataProcessorBase::printMessage(), QcepImageDataBase::Raw16Data, QcepImageDataBase::Raw32Data, QxrdDataProcessorBase::statusMessage(), QxrdDataProcessorBase::subtractDarkImage(), and QxrdDataProcessorBase::takeNextFreeImage().

{
  QcepDoubleImageDataPtr summed = takeNextFreeImage(0,0);
  int first = true;

  foreach(QString name, names) {
    QcepDoubleImageDataPtr img = takeNextFreeImage(0,0);
    QString path = filePathInDataDirectory(name);

    if (img->readImage(path)) {
      printMessage(tr("Load image from %1").arg(path));
      statusMessage(tr("Load image from %1").arg(path));

      img -> loadMetaData();

      int typ = img->get_DataType();

      if ((typ == QcepDoubleImageData::Raw16Data) ||
          (typ == QcepDoubleImageData::Raw32Data))
      {
        subtractDarkImage(img, darkImage());
      }

      if (first) {
        summed->copyFrom(img);
        first = false;
      } else {
        summed->accumulateImage(img);
      }
    } else {
      printMessage(tr("Couldn't load %1").arg(path));
      statusMessage(tr("Couldn't load %1").arg(path));
    }
  }

  if (first) {
    printMessage(tr("No images were loaded"));
    statusMessage(tr("No images were loaded"));
  } else {
    newData(summed, QcepMaskDataPtr());
  }
}

Here is the call graph for this function:

Member Data Documentation

QxrdResultSerializer<QcepDoubleImageDataPtr> QxrdDataProcessorThreaded::m_CorrectedImages

private

Definition at line 85 of file qxrddataprocessorthreaded.h.

Referenced by acquiredDoubleImage(), acquiredInt16Image(), acquiredInt32Image(), onCorrectedImageAvailable(), and QxrdDataProcessorThreaded().

QxrdResultSerializer<QxrdHistogramDataPtr> QxrdDataProcessorThreaded::m_HistogramData

private

Definition at line 88 of file qxrddataprocessorthreaded.h.

Referenced by onCorrectedImageAvailable(), onHistogramDataAvailable(), and QxrdDataProcessorThreaded().

QxrdResultSerializer<QcepIntegratedDataPtr> QxrdDataProcessorThreaded::m_IntegratedData

private

Definition at line 86 of file qxrddataprocessorthreaded.h.

Referenced by integrateData(), integrateSaveAndDisplay(), onCorrectedImageAvailable(), onIntegratedDataAvailable(), QxrdDataProcessorThreaded(), and slicePolygon().

QxrdResultSerializer<QxrdROIDataPtr> QxrdDataProcessorThreaded::m_ROIData

private

Definition at line 87 of file qxrddataprocessorthreaded.h.

Referenced by onCorrectedImageAvailable(), onROIDataAvailable(), and QxrdDataProcessorThreaded().

---

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

• qxrddataprocessorthreaded.h (Commit a65ccc9... : jennings : 2016-03-15 14:00:18 -0500)
• qxrddataprocessorthreaded.cpp (Commit a65ccc9... : jennings : 2016-03-15 14:00:18 -0500)