QueuedCPUTracker Class Reference

CPU implementation of the QueuedTracker interface. More...

#include <QueuedCPUTracker.h>

Inheritance diagram for QueuedCPUTracker:

Classes
struct	Job
	Structure around LocalizationJob to link data and job. More...
struct	Thread
	Structure to facilitate the use of threads. More...

Public Member Functions
	QueuedCPUTracker (const QTrkComputedConfig &cc)
	Create a QueuedCPUTracker instance with specified configuration. More...
	~QueuedCPUTracker ()
	Delete the instance and free related memory. More...
void	Start ()
	Start up the threads and initiate their worker function. More...
void	Break (bool pause)
	Enable or disable handling of jobs. More...
void	GenerateTestImage (float *dst, float xp, float yp, float size, float SNratio)
	Generate a test image based on a the point spread function. More...
int	NumThreads ()
	Get the used number of threads. More...
void	SetLocalizationMode (LocMode_t lt) override
	Select which algorithm is to be used. More...
void	SetRadialZLUT (float *data, int num_zluts, int planes) override
	Set the radial lookup tables to be used for z tracking. More...
void	GetRadialZLUT (float *zlut) override
	Get the radial lookup tables used for z tracking. More...
void	GetRadialZLUTSize (int &count, int &planes, int &rsteps) override
	Get the dimensions of the radial lookup table data. More...
void	SetRadialWeights (float *rweights) override
	Set radial weights used for comparing LUT profiles. More...
void	SetRadialWeights (std::vector< float > weights)
	Overload of SetRadialWeights to use a vector. More...
void	ScheduleLocalization (void *data, int pitch, QTRK_PixelDataType pdt, const LocalizationJob *jobInfo) override
	Add a job to the queue to be processed. A job entails running the required algorithms on a single region of interest. More...
void	EnableRadialZLUTCompareProfile (bool enabled)
	Set a flag to enable saving of error curves. More...
void	GetRadialZLUTCompareProfile (float *dst)
	Get saved error curve. More...
void	ZLUTSelfTest ()
	Test the planes saved in the lookup table against itself. More...
void	BeginLUT (uint flags)
	Setup to begin building a lookup table. More...
void	BuildLUT (void *data, int pitch, QTRK_PixelDataType pdt, int plane, vector2f *known_pos=0) override
	Add a new lookup table plane. More...
void	FinalizeLUT () override
	Finalize the lookup tables in memory. More...
void	GetImageZLUTSize (int *dims)
	Get the dimensions of the image lookup table data. More...
void	GetImageZLUT (float *dst)
	Get the image lookup tables used. More...
bool	SetImageZLUT (float *dst, float *radial_zlut, int *dims)
	Set the image lookup tables to be used for z tracking. More...
void	SetPixelCalibrationImages (float *offset, float *gain) override
	Set the pixel calibration images. More...
void	SetPixelCalibrationFactors (float offsetFactor, float gainFactor) override
	Set the pixel calibration factors. More...
int	GetQueueLength (int *maxQueueLength=0) override
	Get the lengths of the queue of jobs to be handled. More...
int	FetchResults (LocalizationResult *dstResult, int maxResults) override
	Fetch available results. More...
void	ClearResults () override
	Clear results. More...
void	Flush () override
	Stop waiting for more jobs to do, and just process the current batch. More...
bool	IsIdle () override
	Test to see if the tracker is idle. More...
int	GetResultCount () override
	Get the number of finished localization jobs (=results) available in memory. More...
bool	GetDebugImage (int id, int *w, int *h, float **data)
	Get the debug image of a tracker. More...
ConfigValueMap	GetConfigValues () override
	Get the used additional configurations. More...
void	SetConfigValue (std::string name, std::string value) override
	Set an additional setting. More...
std::string	GetProfileReport ()
	Get the output of performance profiling. More...
float *	GetZLUTByIndex (int index)
	Get a pointer to the starting pixel of the specified LUT. More...
Public Member Functions inherited from QueuedTracker
	QueuedTracker ()
virtual	~QueuedTracker ()
void	ScheduleImageData (ImageData *data, const LocalizationJob *jobInfo)
	Quick function to schedule a single ROI from an ImageData object. More...
virtual int	ScheduleFrame (void *imgptr, int pitch, int width, int height, ROIPosition *positions, int numROI, QTRK_PixelDataType pdt, const LocalizationJob *jobInfo)
	Schedule an entire frame at once, allowing for further optimizations. More...
virtual std::string	GetWarnings ()
	Get a report of encountered errors. More...
ImageData	DebugImage (int ID)
	Get the debug image as an ImageData object. More...
void	ScheduleLocalization (uchar *data, int pitch, QTRK_PixelDataType pdt, uint frame, uint timestamp, vector3f *initial, uint zlutIndex)
	Add an image to the queue to be processed. Creates a job. More...
void	ComputeZBiasCorrection (int bias_planes, CImageData *result, int smpPerPixel, bool useSplineInterp)
float	ZLUTBiasCorrection (float z, int zlut_planes, int bead)
void	SetZLUTBiasCorrection (const CImageData &data)
CImageData *	GetZLUTBiasCorrection ()

Private Member Functions
void	UpdateZLUTs ()
	Update the ZLUTs for all threads. More...
int	ImageLUTNumBeads ()
	Return the number of beads in the image LUT. More...
int	ImageLUTWidth ()
	Return the height of the image LUT. More...
int	ImageLUTHeight ()
	Return the width of the image LUT. More...
float *	GetImageLUTByIndex (int index, int plane=0)
	Get a specific image LUT or plane from an image LUT. More...
void	JobFinished (Job *j)
	Flag job memory for reuse. More...
Job *	GetNextJob ()
	Get the next job in the queue. More...
Job *	AllocateJob ()
	Allocate job memory. More...
void	AddJob (Job *j)
	Add a job to the queue. More...
void	ProcessJob (Thread *th, Job *j)
	Process a job. More...
void	SetTrackerImage (CPUTracker *trk, Job *job)
	Copy the ROI to the tracker's memory. More...
void	ApplyOffsetGain (CPUTracker *trk, int beadIndex)
	Calibrate an image. More...

Static Private Member Functions
static void	WorkerThreadMain (void *arg)
	The loop executed by the threads. More...

Private Attributes
LocMode_t	localizeMode
	Localization settings. More...
Threads::Mutex	jobs_mutex
	Mutex for the job queue. More...
Threads::Mutex	jobs_buffer_mutex
	Mutex for the job buffer. More...
Threads::Mutex	results_mutex
	Mutex for the results. More...
std::deque< Job * >	jobs
	Queue to hold the jobs. More...
int	jobCount
	Number of jobs in the queue. More...
std::vector< Job * >	jobs_buffer
	Stores memory. Enables reuse of allocated Job memory after a job has been completed. More...
std::deque< LocalizationResult >	results
	Queue to store the localization results. More...
int	resultCount
	Number of results available. More...
int	maxQueueSize
	Maximum number of jobs in the queue. More...
int	jobsInProgress
	Number of jobs currently being processed. More...
Threads::Mutex	gc_mutex
	Image calibration mutex. More...
float *	calib_gain
	Vector with gains used for pixel correction. More...
float *	calib_offset
	Vector with offsets used for pixel correction. More...
float	gc_gainFactor
	Factor by which to scale the gain. More...
float	gc_offsetFactor
	Factor by which to scale the pixel calibration offset. More...
int	downsampleWidth
	Width of ROIs after downsampling. More...
int	downsampleHeight
	Height of ROIs after downsampling. More...
std::vector< Thread >	threads
	Vector with active threads. More...
float *	zluts
	Pointer to the first pixel of the Z lookup tables. More...
float *	zlut_cmpprofiles
	Array in which to save errorcurves if enabled with EnableRadialZLUTCompareProfile. More...
bool	zlut_enablecmpprof
	Flag to save errorcurves. See EnableRadialZLUTCompareProfile. More...
int	zlut_count
	Number of ZLUTs (= number of beads). More...
int	zlut_planes
	Number of planes per ZLUT. More...
uint	zlut_buildflags
	ZLUT build flags, set through BeginLUT. More...
std::vector< float >	zcmp
	Scaling factors for the ZLUT algorithm. More...
std::vector< float >	qi_radialbinweights
	Scaling factors for the QI algorithm. More...
int	image_lut_dims [4]
	Image LUT dimensions, 4D. [numBeads][numPlanes][height][width]. More...
int	image_lut_nElem_per_bead
	Image LUT number of pixels in LUT per bead. Is Width * Height * Planes. More...
float *	image_lut
	Image LUT data pointer. More...
float *	image_lut_dz
	Image LUT first derivative. (???) More...
float *	image_lut_dz2
	Image LUT second derivative. (???) More...
bool	quitWork
	Signal threads to stop their work. More...
bool	processJobs
	Flag for threads to continue processing jobs. More...
bool	dbgPrintResults
	Flag to enable easy printing of intermediate data. More...

Additional Inherited Members
Public Types inherited from QueuedTracker
typedef std::map< std::string, std::string >	ConfigValueMap
	Datastructure used to return additional settings in a string-string key-value pair mapping. More...
Public Attributes inherited from QueuedTracker
QTrkComputedConfig	cfg
	The settings used by this instance of QueuedTracker. More...
Protected Attributes inherited from QueuedTracker
CImageData *	zlut_bias_correction

Detailed Description

CPU implementation of the QueuedTracker interface.

Creates and maintains multiple threads (one per available core by default) and schedules localizations over them. Each thread has its own CPUTracker instance which provides the actual calculations.

Definition at line 16 of file QueuedCPUTracker.h.

Constructor & Destructor Documentation

QueuedCPUTracker()

QueuedCPUTracker::QueuedCPUTracker

(

const QTrkComputedConfig &

cc

)

Create a QueuedCPUTracker instance with specified configuration.

Parameters

[in]

cc

Computed config to use.

Returns

A QueuedCPUTracker instance.

Copy the configuration.

If QTrkComputedConfig::numThreads is not specified (<0), select one thread per CPU.

Queue length is 250 per thread, min 500.

Calculate the radial profile weights from the amount of steps.

Initialize to only COM localizations.

Invoke the Start function.

Definition at line 96 of file QueuedCPUTracker.cpp.

    : jobs_mutex("jobs"), jobs_buffer_mutex("jobs_buffer"), results_mutex("results")
{
    if(0){//cc.testRun){
        std::string folder = GetCurrentOutputPath();
        if(GetFileAttributesA(folder.c_str()) & FILE_ATTRIBUTE_DIRECTORY)
            CreateDirectory((LPCTSTR)folder.c_str(),NULL);
    }
    
    cfg = cc;
    quitWork = false;

    if (cfg.numThreads < 0) {
        cfg.numThreads = Threads::GetCPUCount();
        dbgprintf("Using %d threads\n", cfg.numThreads);
    } 

    maxQueueSize = std::max(2,cfg.numThreads) * 250;
    jobCount = 0;
    resultCount = 0;

    zlut_cmpprofiles = 0;
    zlut_enablecmpprof = false;
    zluts = 0;
    zlut_count = zlut_planes = 0;
    processJobs = false;
    jobsInProgress = 0;
    dbgPrintResults = false;

    qi_radialbinweights = ComputeRadialBinWindow(cfg.qi_radialsteps);
    
    calib_gain = calib_offset = 0;
    gc_gainFactor = gc_offsetFactor = 1.0f;
    localizeMode = LT_OnlyCOM;

    for (int i=0;i<4;i++) image_lut_dims[i]=0;
    image_lut_nElem_per_bead=0;
    image_lut = 0;
    image_lut_dz = image_lut_dz2 = 0;

    downsampleWidth = cfg.width >> cfg.downsample;
    downsampleHeight = cfg.height >> cfg.downsample;

    Start();
}

~QueuedCPUTracker()

QueuedCPUTracker::~QueuedCPUTracker

(

)

Delete the instance and free related memory.

Definition at line 148 of file QueuedCPUTracker.cpp.

{
    // wait for threads to finish
    quitWork = true;

    for (int k=0;k<threads.size();k++) {
        delete threads[k].mutex;
        Threads::WaitAndClose(threads[k].thread);
        delete threads[k].tracker;
    }

    // free job memory
    DeleteAllElems(jobs);
    DeleteAllElems(jobs_buffer);

    delete[] calib_gain;
    delete[] calib_offset;
    if (zluts) delete[] zluts;
    if (zlut_cmpprofiles) delete[] zlut_cmpprofiles;
    if (image_lut) delete[] image_lut;
    if (image_lut_dz) delete[] image_lut_dz;
    if (image_lut_dz2) delete[] image_lut_dz2;
}

Member Function Documentation

AddJob()

void QueuedCPUTracker::AddJob ( Job *  j )

private

Add a job to the queue.

Parameters

[in]

j

The job to add.

Definition at line 75 of file QueuedCPUTracker.cpp.

{
    jobs_mutex.lock();
    jobs.push_back(j);
    jobCount++;
    jobs_mutex.unlock();
}

AllocateJob()

QueuedCPUTracker::Job * QueuedCPUTracker::AllocateJob ( )

private

Allocate job memory.

Tries to re-use memory of finished jobs before allocating new memory.

Returns

Pointer to a usable job instance.

Definition at line 62 of file QueuedCPUTracker.cpp.

{
    QueuedCPUTracker::Job *j;
    jobs_buffer_mutex.lock();
    if (!jobs_buffer.empty()) {
        j = jobs_buffer.back();
        jobs_buffer.pop_back();
    } else 
        j = new Job;
    jobs_buffer_mutex.unlock();
    return j;
}

ApplyOffsetGain()

void QueuedCPUTracker::ApplyOffsetGain ( CPUTracker *  trk, int  beadIndex  )

private

Calibrate an image.

Calibrates the image set on a tracker through SetTrackerImage.

Parameters

[in]	trk	The tracker whose image to calibrate.
[in]	beadIndex	The bead this image belongs to.

Definition at line 265 of file QueuedCPUTracker.cpp.

{
    if (calib_offset || calib_gain) {
        int index = cfg.width*cfg.height*beadIndex;

        //gc_mutex.lock();
        //float gf = gc_gainFactor, of = gc_offsetFactor;
        //gc_mutex.unlock();
        float gf=1,of=1;

        trk->ApplyOffsetGain(calib_offset ? &calib_offset[index] : 0, calib_gain ? &calib_gain[index] : 0, of, gf);
//      if (j->job.frame%100==0)
    }
}

BeginLUT()

void QueuedCPUTracker::BeginLUT ( uint  flags )

virtual

Setup to begin building a lookup table.

Sets the flags by which the lookup table is built. Flags are defined in a uint bitmask format as:

Name	Value	Description
	0	Default, no special flags.
BUILDLUT_IMAGELUT	1 (2^0)	Build an image LUT. An image LUT seems to be a work in progress to save ROIs rather than profiles in the LUT.
BUILDLUT_FOURIER	2 (2^1)	Build a fourier LUT.
BUILDLUT_NORMALIZE	4 (2^2)	Normalize radial profiles. Irrelevant, since FinalizeLUT always normalizes.
BUILDLUT_BIASCORRECT	8 (2^3)	Enable bias correction. Currently only partly implemented, don't use.

Parameters

[in]

flags

UINT interpreted as a series of bits to set settings.

Implements QueuedTracker.

Definition at line 584 of file QueuedCPUTracker.cpp.

{
    zlut_buildflags = flags;
}

Break()

void QueuedCPUTracker::Break

(

bool

pause

)

Enable or disable handling of jobs.

Parameters

[in]

pause

True stops new jobs from being started.

Definition at line 214 of file QueuedCPUTracker.cpp.

{
    processJobs = !brk;
}

BuildLUT()

void QueuedCPUTracker::BuildLUT ( void *  data, int  pitch, QTRK_PixelDataType  pdt, int  plane, vector2f *  known_pos = 0  )

overridevirtual

Add a new lookup table plane.

Takes a stack of ROI images through data. Determines and adds the profile for each ROI to its respective LUT.

Parameters

[in]	data	Pointer to the start of an image stack.
[in]	pitch	Width of the data in memory so offsets can be calculated.
[in]	pdt	Pixel data type for the data. See QTRK_PixelDataType.
[in]	plane	The plane number the ROIs are taken for.
[in]	known_pos	Center position from which to start making the radial profile. A standard QI localization with applied settings is performed if 0 (default).

Implements QueuedTracker.

Definition at line 589 of file QueuedCPUTracker.cpp.

{
    parallel_for(zlut_count,[&] (int i) {
//  for(int i=0;i<zlut_count;i++) {
        CPUTracker trk (cfg.width,cfg.height);
        void *img_data = (uchar*)data + pitch * cfg.height * i;

        if (pdt == QTrkFloat) {
            trk.SetImage((float*)img_data, pitch);
        } else if (pdt == QTrkU8) {
            trk.SetImage8Bit((uchar*)img_data, pitch);
        } else {
            trk.SetImage16Bit((ushort*)img_data,pitch);
        }
        ApplyOffsetGain(&trk, i);

        vector2f pos;

        if (known_pos) {
            pos = known_pos[i];
        } else {
            vector2f com = trk.ComputeMeanAndCOM();
            bool bhit;
            pos = trk.ComputeQI(com, cfg.qi_iterations, cfg.qi_radialsteps, cfg.qi_angstepspq, cfg.qi_angstep_factor, cfg.qi_minradius, cfg.qi_maxradius, bhit);
            //dbgprintf("BuildLUT() COMPos: %f,%f, QIPos: x=%f, y=%f\n", com.x,com.y, pos.x, pos.y);
        }
        if (zlut_buildflags & BUILDLUT_IMAGELUT) {
            int h=ImageLUTHeight(), w=ImageLUTWidth();
            float* lut_dst = &image_lut[ i * image_lut_nElem_per_bead + w*h* plane ];

            vector2f ilut_scale(1,1);
            float startx = pos.x - w/2*ilut_scale.x;
            float starty = pos.y - h/2*ilut_scale.y;

            for (int y=0;y<h;y++) {
                for (int x=0;x<w;x++) {

                    float px = startx + x*ilut_scale.x;
                    float py = starty + y*ilut_scale.y;

                    bool outside=false;
                    float v = Interpolate(trk.srcImage, trk.width, trk.height, px, py, &outside);
                    lut_dst[y*w+x] += v - trk.mean;
                }
            }
        }

        float *bead_zlut=GetZLUTByIndex(i);
        float *tmp = new float[cfg.zlut_radialsteps];

        if (zlut_buildflags  & BUILDLUT_FOURIER){
            trk.FourierRadialProfile(tmp, cfg.zlut_radialsteps, cfg.zlut_angularsteps, cfg.zlut_minradius, cfg.zlut_maxradius);
            if (plane==0) {
                for (int i=0;i<trk.width*trk.height;i++)
                    trk.srcImage[i]=sqrtf(trk.srcImage[i]);
                trk.SaveImage("freqimg.jpg");
            }
        } else {
            trk.ComputeRadialProfile(tmp, cfg.zlut_radialsteps, cfg.zlut_angularsteps, cfg.zlut_minradius, cfg.zlut_maxradius, pos, false);
        }
    //  WriteArrayAsCSVRow("rlut-test.csv", tmp, cfg.zlut_radialsteps, plane>0);
        for(int i=0;i<cfg.zlut_radialsteps;i++) 
            bead_zlut[plane*cfg.zlut_radialsteps+i] += tmp[i];
        delete[] tmp;
    } );
}

ClearResults()

void QueuedCPUTracker::ClearResults ( )

overridevirtual

Clear results.

Implements QueuedTracker.

Definition at line 29 of file QueuedCPUTracker.cpp.

{
    results_mutex.lock();
    resultCount = 0;
    results.clear();
    results_mutex.unlock();
}

EnableRadialZLUTCompareProfile()

void QueuedCPUTracker::EnableRadialZLUTCompareProfile ( bool  enabled )

virtual

Set a flag to enable saving of error curves.

Errors obtained by comparing a radial profile to a ZLUT will be kept in memory rather than destroyed. Only saves for one localization. Error curve can be retreived by GetRadialZLUTCompareProfile.

Note

Not implemented for CUDA.

Parameters

[in]

enabled

Flag (boolean) to save error curves. Default is false.

Implements QueuedTracker.

Definition at line 544 of file QueuedCPUTracker.cpp.

{
    zlut_enablecmpprof=enabled;
}

FetchResults()

int QueuedCPUTracker::FetchResults ( LocalizationResult *  results, int  maxResults  )

overridevirtual

Fetch available results.

Note

Removes results from internal QueuedTracker memory.

Parameters

[in]	results	Array of pre-allocated LocalizationResult to which to add the results.
[in]	maxResults	Maximum number of results to fetch. Corresponds to maximum size of dstResult.

Returns

Number of fetched results.

Implements QueuedTracker.

Definition at line 473 of file QueuedCPUTracker.cpp.

{
    int numResults = 0;
    results_mutex.lock();
    while (numResults < maxResults && !results.empty()) {
        dstResults[numResults++] = results.back();
        results.pop_back();
        resultCount--;
    }
    results_mutex.unlock();
    return numResults;
}

FinalizeLUT()

void QueuedCPUTracker::FinalizeLUT ( )

overridevirtual

Finalize the lookup tables in memory.

Normalizes the profiles for radial lookup tables and calculates derivates and adds boundary conditions for image LUTs.

Implements QueuedTracker.

Definition at line 656 of file QueuedCPUTracker.cpp.

{
    // normalize radial LUT?

    if (zluts) {
        for (int i=0;i<zlut_count*zlut_planes;i++) {

        //  WriteArrayAsCSVRow("finalize-lut.csv", &zluts[cfg.zlut_radialsteps*i], cfg.zlut_radialsteps, i>0);
            NormalizeRadialProfile(&zluts[cfg.zlut_radialsteps*i], cfg.zlut_radialsteps);

        }
    }

    int w = ImageLUTWidth();
    int h = ImageLUTHeight();

    if (w * h > 0) {

        image_lut_dz = new float [image_lut_nElem_per_bead * ImageLUTNumBeads()];
        image_lut_dz2 = new float [image_lut_nElem_per_bead * ImageLUTNumBeads()];

        // Compute 1st and 2nd order derivatives
        for (int i=0;i<image_lut_dims[0];i++) {
            for (int z=1;z<image_lut_dims[1]-1;z++) {
                float *img = &image_lut[ image_lut_nElem_per_bead * i + w*h*z ]; // current plane
                float *imgL = &image_lut[ image_lut_nElem_per_bead * i + w*h*(z-1) ]; // one plane below
                float *imgU = &image_lut[ image_lut_nElem_per_bead * i + w*h*(z+1) ]; // one plane above

                float *img_dz = &image_lut_dz[ image_lut_nElem_per_bead * i + w*h*z ];
                float *img_dz2 = &image_lut_dz2[ image_lut_nElem_per_bead * i + w*h*z ];

                // Numerical approx of derivatives..
                for (int y=0;y<h;y++) {
                    for (int x=0;x<w;x++) {
                        const float h = 1.0f;
                        img_dz[y*w+x] = 0.5f * ( imgU[y*w+x] - imgL[y*w+x] ) / h;
                        img_dz2[y*w+x] = (imgU[y*w+x] - 2*img[y*w+x] + imgL[y*w+x]) / (h*h);
                    }
                }
            }
            for (int k=0;k<w*h;k++) {
                // Top and bottom planes are simply copied from the neighbouring planes
                image_lut_dz[ image_lut_nElem_per_bead * i + w*h*0 + k] = image_lut_dz[ image_lut_nElem_per_bead * i + w*h*1 + k];
                image_lut_dz[ image_lut_nElem_per_bead * i + w*h*(image_lut_dims[1]-1) + k] = image_lut_dz[ image_lut_nElem_per_bead * i + w*h*(image_lut_dims[1]-2) + k];
                image_lut_dz2[ image_lut_nElem_per_bead * i + w*h*0 + k] = image_lut_dz2[ image_lut_nElem_per_bead * i + w*h*1 + k];
                image_lut_dz2[ image_lut_nElem_per_bead * i + w*h*(image_lut_dims[1]-1) + k] = image_lut_dz2[ image_lut_nElem_per_bead * i + w*h*(image_lut_dims[1]-2) + k];
            }
        }
    }
}

Flush()

void QueuedCPUTracker::Flush ( )

inlineoverridevirtual

Stop waiting for more jobs to do, and just process the current batch.

Implements QueuedTracker.

Definition at line 94 of file QueuedCPUTracker.h.

{ };

GenerateTestImage()

void QueuedCPUTracker::GenerateTestImage	(	float *	dst,
		float	xp,
		float	yp,
		float	size,
		float	SNratio
	)

Generate a test image based on a the point spread function.

Creates an ImageData object and calls GenerateTestImage. Automatically uses ROI size from QtrkComputedConfig::width and QtrkComputedConfig::height.

Parameters

[out]	dst	Pre-allocated float array in which to save the image.
[in]	xp	X coordinate of the PSF center.
[in]	yp	Y coordinate of the PSF center.
[in]	size	Spread of the PSF. Can't be zero. Higher size increases radius of created diffraction pattern.
[in]	SNratio	Signal to noise ratio.

Definition at line 486 of file QueuedCPUTracker.cpp.

{
    ImageData img(dst,cfg.width,cfg.height);
    ::GenerateTestImage(img,xp,yp,size,SNratio);
}

GetConfigValues()

QueuedTracker::ConfigValueMap QueuedCPUTracker::GetConfigValues ( )

overridevirtual

Get the used additional configurations.

Implements QueuedTracker.

Definition at line 510 of file QueuedCPUTracker.cpp.

{
    ConfigValueMap cvm;
    cvm["trace"] = dbgPrintResults ? "1" : "0";
    return cvm;
}

GetDebugImage()

bool QueuedCPUTracker::GetDebugImage ( int  id, int *  w, int *  h, float **  data  )

virtual

Get the debug image of a tracker.

Parameters

[in]	id	ID of the tracker (= threadID).
[out]	w	Reference to an int in which the image width will be stored.
[out]	h	Reference to an int in which the image height will be stored.
[out]	data	Pointer to a float array that will be filled with the image.

Returns

True if the call was valid.

Reimplemented from QueuedTracker.

Definition at line 492 of file QueuedCPUTracker.cpp.

{
    if (id >= 0 && id < threads.size()) {
        threads[id].lock();

        *w = cfg.width;
        *h = cfg.height;

        *data = new float [cfg.width*cfg.height];
        memcpy(*data, threads[id].tracker->GetDebugImage(), sizeof(float)* cfg.width*cfg.height);
        
        threads[id].unlock();
        return true;
    }

    return false;
}

GetImageLUTByIndex()

float* QueuedCPUTracker::GetImageLUTByIndex ( int  index, int  plane = 0  )

inlineprivate

Get a specific image LUT or plane from an image LUT.

Parameters

[in]	index	The beadindex of the requested LUT.
[in]	plane	Index of the requested plane. 0 by default.

Returns

Pointer to the first element of the requested LUT or plane.

Definition at line 210 of file QueuedCPUTracker.h.

                                                      { 
        return &image_lut [ index * image_lut_nElem_per_bead + plane * (image_lut_dims[2]*image_lut_dims[3]) ]; 
    }

GetImageZLUT()

void QueuedCPUTracker::GetImageZLUT ( float *  dst )

virtual

Get the image lookup tables used.

Note

Use of image LUT is currently not clear. Radial ZLUT is always used.

Parameters

[out]

dst

Pointer to the pre-allocated memory in which to save the data.

Reimplemented from QueuedTracker.

Definition at line 537 of file QueuedCPUTracker.cpp.

{
    if (image_lut) {
        memcpy(dst, image_lut, sizeof(float)*image_lut_nElem_per_bead*image_lut_dims[0]);
    }
}

GetImageZLUTSize()

void QueuedCPUTracker::GetImageZLUTSize ( int *  dims )

virtual

Get the dimensions of the image lookup table data.

Note

Use of image LUT is currently not clear. Radial ZLUT is always used.

Parameters

[out]

dims

Reference to pre-allocated int array. Returns [ count, planes, height, width ].

Reimplemented from QueuedTracker.

Definition at line 530 of file QueuedCPUTracker.cpp.

{
    for (int i=0;i<4;i++)
        dims[i]=image_lut_dims[i];
}

GetNextJob()

QueuedCPUTracker::Job * QueuedCPUTracker::GetNextJob ( )

private

Get the next job in the queue.

Returns

The next job in the queue.

Definition at line 48 of file QueuedCPUTracker.cpp.

{
    QueuedCPUTracker::Job *j = 0;
    jobs_mutex.lock();
    if (!jobs.empty()) {
        j = jobs.front();
        jobs.pop_front();
        jobCount --;
        jobsInProgress ++;
    }
    jobs_mutex.unlock();
    return j;
}

GetProfileReport()

std::string QueuedCPUTracker::GetProfileReport ( )

inlinevirtual

Get the output of performance profiling.

Note

Profiling is only implemented in CUDA at the moment.

Returns

String with the parsed profiling output.

Reimplemented from QueuedTracker.

Definition at line 113 of file QueuedCPUTracker.h.

{ return "CPU tracker currently has no profile reporting"; }

GetQueueLength()

int QueuedCPUTracker::GetQueueLength ( int *  maxQueueLen = 0 )

overridevirtual

Get the lengths of the queue of jobs to be handled.

Parameters

[out]

maxQueueLen

Pre-allocated integer that returns the maximum size of the queue if nonzero.

Returns

Number of jobs currently being handled and in the queue.

Implements QueuedTracker.

Definition at line 83 of file QueuedCPUTracker.cpp.

{
    int jc;
    jobs_mutex.lock();
    jc = jobCount + jobsInProgress;
    jobs_mutex.unlock();

    if (maxQueueLength) 
        *maxQueueLength = this->maxQueueSize;

    return jc;
}

GetRadialZLUT()

void QueuedCPUTracker::GetRadialZLUT ( float *  dst )

overridevirtual

Get the radial lookup tables used for z tracking.

Parameters

[out]

dst

Pointer to the pre-allocated memory in which to save the data.

Implements QueuedTracker.

Definition at line 440 of file QueuedCPUTracker.cpp.

{
    int nElem = zlut_planes*cfg.zlut_radialsteps*zlut_count;
    if (nElem>0) {
        results_mutex.lock();
        memcpy(zlut, zluts, sizeof(float)* nElem);
        results_mutex.unlock();
    }
}

GetRadialZLUTCompareProfile()

void QueuedCPUTracker::GetRadialZLUTCompareProfile ( float *  dst )

virtual

Get saved error curve.

See EnableRadialZLUTCompareProfile.

Note

Not implemented for CUDA.

Parameters

[in]

dst

Pointer to the pre-allocated memory in which to save the error curve. Size is count * planes.

Implements QueuedTracker.

Definition at line 550 of file QueuedCPUTracker.cpp.

{
    if (zlut_cmpprofiles){ 
        for (int i=0;i<zlut_count*zlut_planes;i++)
            dst[i]=zlut_cmpprofiles[i];
    }
}

GetRadialZLUTSize()

void QueuedCPUTracker::GetRadialZLUTSize ( int &  count, int &  planes, int &  radialsteps  )

overridevirtual

Get the dimensions of the radial lookup table data.

Parameters

[out]	count	Reference to pre-allocated int. Returns number of lookup tables.
[out]	planes	Reference to pre-allocated int. Returns number of planes per lookup table.
[out]	radialsteps	Reference to pre-allocated int. Returns number of steps per plane.

Implements QueuedTracker.

Definition at line 433 of file QueuedCPUTracker.cpp.

{
    count = zlut_count;
    planes = zlut_planes;
    rsteps = cfg.zlut_radialsteps;
}

GetResultCount()

int QueuedCPUTracker::GetResultCount ( )

overridevirtual

Get the number of finished localization jobs (=results) available in memory.

Returns

The number of available results.

Implements QueuedTracker.

Definition at line 21 of file QueuedCPUTracker.cpp.

{
    results_mutex.lock();
    int rc = resultCount;
    results_mutex.unlock();
    return rc;
}

GetZLUTByIndex()

float* QueuedCPUTracker::GetZLUTByIndex ( int  index )

inline

Get a pointer to the starting pixel of the specified LUT.

LUTs are saved in one large contiguous memory region. This function returns a reference to a specific LUT.

Parameters

[in]

index

Index of the requested LUT.

Returns

Pointer to the LUT starting pixel

Definition at line 123 of file QueuedCPUTracker.h.

{ return &zluts[ index * (zlut_planes*cfg.zlut_radialsteps) ]; }

ImageLUTHeight()

int QueuedCPUTracker::ImageLUTHeight ( )

inlineprivate

Return the width of the image LUT.

Definition at line 198 of file QueuedCPUTracker.h.

ImageLUTNumBeads()

int QueuedCPUTracker::ImageLUTNumBeads ( )

inlineprivate

Return the number of beads in the image LUT.

Definition at line 196 of file QueuedCPUTracker.h.

ImageLUTWidth()

int QueuedCPUTracker::ImageLUTWidth ( )

inlineprivate

Return the height of the image LUT.

Definition at line 197 of file QueuedCPUTracker.h.

IsIdle()

bool QueuedCPUTracker::IsIdle ( )

overridevirtual

Test to see if the tracker is idle.

That is, GetQueueLength == 0.

Returns

Boolean indicating if the tracker is idle.

Implements QueuedTracker.

Definition at line 16 of file QueuedCPUTracker.cpp.

{
    return GetQueueLength() == 0;
}

JobFinished()

void QueuedCPUTracker::JobFinished ( QueuedCPUTracker::Job *  j )

private

Flag job memory for reuse.

See jobs_buffer.

Warning

Only call when a job is fully finished, including results copying.

Parameters

[in]

j

The job to free.

Definition at line 37 of file QueuedCPUTracker.cpp.

{
    jobs_buffer_mutex.lock();
    jobs_buffer.push_back(j);
    jobs_buffer_mutex.unlock();

    jobs_mutex.lock();
    jobsInProgress--;
    jobs_mutex.unlock();
}

NumThreads()

int QueuedCPUTracker::NumThreads ( )

inline

Get the used number of threads.

Returns

The number of threads.

Definition at line 54 of file QueuedCPUTracker.h.

{ return cfg.numThreads; }

ProcessJob()

void QueuedCPUTracker::ProcessJob ( QueuedCPUTracker::Thread *  th, Job *  j  )

private

Process a job.

Parameters

[in]	th	The thread on which to execute.
[in]	j	The job to execute.

Choose the CPUTracker instance based on the specified thread.

Set the tracker's image memory.

Calibrate the images if needed.

Always compute the COM.

Compute 1DXCor, QI or 2DGaussian based on settings.

Compute Z profile and Z position if Z localization is requested.

Add the results to the available results.

Definition at line 280 of file QueuedCPUTracker.cpp.

{
    CPUTracker* trk = th->tracker;
    th->lock();

    SetTrackerImage(trk, j);

    //FloatToJPEGFile("dbg.jpg",(float*)j->data,cfg.width,cfg.height);

    if (localizeMode & LT_ClearFirstFourPixels) {
        trk->srcImage[0]=trk->srcImage[1]=trk->srcImage[2]=trk->srcImage[3]=0;
    }

    ApplyOffsetGain(trk, j->job.zlutIndex);

//  dbgprintf("Job: id %d, bead %d\n", j->id, j->zlut);

    LocalizationResult result={};
    result.job = j->job;

    vector2f com = trk->ComputeMeanAndCOM(cfg.com_bgcorrection);
    result.imageMean = trk->mean;

    if (_isnan(com.x) || _isnan(com.y))
        com = vector2f(cfg.width/2,cfg.height/2);

    bool boundaryHit = false;

    if (localizeMode & LT_XCor1D) {
        result.firstGuess = com;
        vector2f resultPos = trk->ComputeXCorInterpolated(com, cfg.xc1_iterations, cfg.xc1_profileWidth, boundaryHit);
        result.pos.x = resultPos.x;
        result.pos.y = resultPos.y;
    } else if (localizeMode & LT_QI ){ 
        result.firstGuess = com;
        vector2f resultPos = trk->ComputeQI(com, cfg.qi_iterations, cfg.qi_radialsteps, cfg.qi_angstepspq, cfg.qi_angstep_factor, cfg.qi_minradius, cfg.qi_maxradius, boundaryHit, &qi_radialbinweights[0]);
        result.pos.x = resultPos.x;
        result.pos.y = resultPos.y;
    } else if (localizeMode & LT_Gaussian2D) {
        result.firstGuess = com;
        CPUTracker::Gauss2DResult gr = trk->Compute2DGaussianMLE(com, cfg.gauss2D_iterations, cfg.gauss2D_sigma);
        vector2f xy = gr.pos;
        result.pos = vector3f(xy.x,xy.y,0.0f);
    } else {
        result.firstGuess.x = result.pos.x = com.x;
        result.firstGuess.y = result.pos.y = com.y;
    }

    bool normalizeProfile = (localizeMode & LT_NormalizeProfile)!=0;
    if(localizeMode & LT_LocalizeZ) {
        float* prof=ALLOCA_ARRAY(float,cfg.zlut_radialsteps);

        for (int i=0;i< ((localizeMode & LT_ZLUTAlign) ? 5 : 1) ; i++) {
            if (localizeMode & LT_FourierLUT) {
                trk->FourierRadialProfile(prof,cfg.zlut_radialsteps, cfg.zlut_angularsteps, cfg.zlut_minradius, cfg.zlut_maxradius);
            } else {
                trk->ComputeRadialProfile(prof,cfg.zlut_radialsteps, cfg.zlut_angularsteps, cfg.zlut_minradius, cfg.zlut_maxradius, result.pos2D(), false, &boundaryHit, normalizeProfile );
            }

            float *cmpprof = 0;

            if (zlut_enablecmpprof)
                cmpprof = &zlut_cmpprofiles[j->job.zlutIndex*zlut_planes];

            if (i > 0) {
                // update with Quadrant Align
                result.pos = trk->QuadrantAlign(result.pos, j->job.zlutIndex, cfg.qi_angstepspq, boundaryHit);
            }
            result.pos.z = trk->LUTProfileCompare(prof, j->job.zlutIndex, cmpprof, CPUTracker::LUTProfMaxQuadraticFit,(float*)0,(int*)0,j->job.frame);
            //dbgprintf("[%d] x=%f, y=%f, z=%f\n", i, result.pos.x,result.pos.y,result.pos.z);
            
        }

        if (localizeMode & LT_LocalizeZWeighted) {
            result.pos.z = trk->LUTProfileCompareAdjustedWeights(prof, j->job.zlutIndex, result.pos.z);
        }

        if (zlut_bias_correction)
            result.pos.z = ZLUTBiasCorrection(result.pos.z, zlut_planes, j->job.zlutIndex);
    }

    if(dbgPrintResults)
        dbgprintf("fr:%d, bead: %d: x=%f, y=%f, z=%f\n",result.job.frame, result.job.zlutIndex, result.pos.x, result.pos.y, result.pos.z);

    th->unlock();

    result.error = boundaryHit ? 1 : 0;
    results_mutex.lock();
    results.push_back(result);
    resultCount++;
    results_mutex.unlock();
}

ScheduleLocalization()

void QueuedCPUTracker::ScheduleLocalization ( void *  data, int  pitch, QTRK_PixelDataType  pdt, const LocalizationJob *  jobInfo  )

overridevirtual

Add a job to the queue to be processed. A job entails running the required algorithms on a single region of interest.

If a localization can not be added to the queue because it is full, the thread will be put to sleep and periodically try again.

Parameters

[in]	data	Pointer to the data. Type specified by pdt.
[in]	pitch	Distance in bytes between two successive rows of pixels (e.g. address of (0,0) - address of (0,1)).
[in]	pdt	Type of data, specified by QTRK_PixelDataType.
[in]	jobInfo	Structure with metadata for the ROI to be handled. See LocalizationJob.

Bug:

So if process is stopped, it'll just queue regardless of queue sizes?

Implements QueuedTracker.

Definition at line 450 of file QueuedCPUTracker.cpp.

{
    if (processJobs) { 
        while(maxQueueSize != 0 && GetQueueLength () >= maxQueueSize)
            Threads::Sleep(5);
    }

    Job* j = AllocateJob();
    int dstPitch = PDT_BytesPerPixel(pdt) * cfg.width;

    if(!j->data || j->dataType != pdt) {
        if (j->data) delete[] j->data;
        j->data = new uchar[dstPitch * cfg.height];
    }
    for (int y=0; y<cfg.height; y++)
        memcpy(&j->data[dstPitch*y], & ((uchar*)data)[pitch*y], dstPitch);

    j->dataType = pdt;
    j->job = *jobInfo;

    AddJob(j);
}

SetConfigValue()

void QueuedCPUTracker::SetConfigValue ( std::string  name, std::string  value  )

overridevirtual

Set an additional setting.

Parameters

[in]	name	Name of the setting.
[in]	value	Value of the setting.

Implements QueuedTracker.

Definition at line 518 of file QueuedCPUTracker.cpp.

{
    if (name == "trace")
        dbgPrintResults = !!atoi(value.c_str());
}

SetImageZLUT()

bool QueuedCPUTracker::SetImageZLUT ( float *  src, float *  radial_zlut, int *  dims  )

virtual

Set the image lookup tables to be used for z tracking.

Note

Use of image LUT is currently not clear. Radial ZLUT is always used.

Parameters

[in]	src	Pointer to the data for the image LUT.
[in]	radial_zlut	Pointer to the data for the radial LUT.
[in]	dims	Array of dimension sizes for the image LUT. See GetImageZLUTSize.

Reimplemented from QueuedTracker.

Definition at line 558 of file QueuedCPUTracker.cpp.

{
    if (image_lut)  {
        delete[] image_lut;
        image_lut=0;
    }

    for (int i=0;i<4;i++)
        image_lut_dims[i]=dims[i];

    image_lut_nElem_per_bead = dims[1]*dims[2]*dims[3];

    if (image_lut_nElem_per_bead > 0 && dims[0] > 0) {
        image_lut = new float [image_lut_nElem_per_bead*image_lut_dims[0]];
        memset(image_lut, 0, sizeof(float)*image_lut_nElem_per_bead*image_lut_dims[0]);
    }

    if (src) {
        memcpy(image_lut, src, sizeof(float)*image_lut_nElem_per_bead*image_lut_dims[0]);
    }

    SetRadialZLUT(radial_lut, dims[0], dims[1]);

    return true; // returning true indicates this implementation supports ImageLUT
}

SetLocalizationMode()

void QueuedCPUTracker::SetLocalizationMode ( LocMode_t  locType )

overridevirtual

Select which algorithm is to be used.

Parameters

[in]

locType

An integer used as a bitmask for settings based on LocalizeModeEnum.

Implements QueuedTracker.

Definition at line 524 of file QueuedCPUTracker.cpp.

{
    while (!IsIdle());
    localizeMode = lt;
}

SetPixelCalibrationFactors()

void QueuedCPUTracker::SetPixelCalibrationFactors ( float  offsetFactor, float  gainFactor  )

overridevirtual

Set the pixel calibration factors.

The factors can be used to increase or decrease the effects of the images supplied through SetPixelCalibrationImages for further finetuning. These only have an effect when an image is actually set through that function.

Parameters

[in]	offsetFactor	Factor by which to scale the offset values.
[in]	gainFactor	Factor by which to scale the gain values.

Implements QueuedTracker.

Definition at line 205 of file QueuedCPUTracker.cpp.

{
    gc_mutex.lock();
    gc_gainFactor = gainFactor;
    gc_offsetFactor = offsetFactor;
    gc_mutex.unlock();
}

SetPixelCalibrationImages()

void QueuedCPUTracker::SetPixelCalibrationImages ( float *  offset, float *  gain  )

overridevirtual

Set the pixel calibration images.

These images are used to scale the input image to get rid of background influences in the image. The values are per-pixel-per-ROI. Result = gain*(pixel+offset).

Parameters

[in]	offset	Array with the offset values to use per pixel. Size and order is [width*height*numbeads].
[in]	gain	Array with gain values to use per pixel. Size and order is [width*height*numbeads].

Implements QueuedTracker.

Definition at line 172 of file QueuedCPUTracker.cpp.

{
    if (zlut_count > 0) {
        int nelem = cfg.width*cfg.height*zlut_count;

        if (calib_gain == 0 && gain)  {
            calib_gain = new float[nelem];
            memcpy(calib_gain, gain, sizeof(float)*nelem);
        }
        else if (calib_gain && gain == 0) {
            delete[] calib_gain;
            calib_gain = 0;
        }

        if (calib_offset == 0 && offset) {
            calib_offset = new float[nelem];
            memcpy(calib_offset, offset, sizeof(float)*nelem);
        }
        else if (calib_offset && offset == 0) {
            delete[] calib_offset;
            calib_offset = 0;
        }

#ifdef _DEBUG
        std::string path = GetLocalModulePath();
        for (int i=0;i<zlut_count;i++) {
            if(calib_gain) FloatToJPEGFile( SPrintf("%s/gain-bead%d.jpg", path.c_str(), i).c_str(), &calib_gain[cfg.width*cfg.height*i], cfg.width,cfg.height);
            if(calib_offset) FloatToJPEGFile( SPrintf("%s/offset-bead%d.jpg", path.c_str(), i).c_str(), &calib_offset[cfg.width*cfg.height*i], cfg.width,cfg.height);
        }
#endif
    }
}

SetRadialWeights() [1/2]

void QueuedCPUTracker::SetRadialWeights ( float *  zcmp )

overridevirtual

Set radial weights used for comparing LUT profiles.

Parameters

[in]

zcmp

Array of radial weights to use. zcmp has to have zlut_radialsteps elements.

Implements QueuedTracker.

Definition at line 409 of file QueuedCPUTracker.cpp.

{
    if (rweights)
        zcmp.assign(rweights, rweights + cfg.zlut_radialsteps);
    else
        zcmp.clear();

    for (int i=0;i<threads.size();i++){
        threads[i].lock();
        threads[i].tracker->SetRadialWeights(rweights);
        threads[i].unlock();
    }

}

SetRadialWeights() [2/2]

void QueuedCPUTracker::SetRadialWeights ( std::vector< float >  weights )

inline

Overload of SetRadialWeights to use a vector.

Parameters

[in]

weights

Float vector with the radial weights.

Definition at line 67 of file QueuedCPUTracker.h.

{ SetRadialWeights(&weights[0]); }

SetRadialZLUT()

void QueuedCPUTracker::SetRadialZLUT ( float *  data, int  count, int  planes  )

overridevirtual

Set the radial lookup tables to be used for z tracking.

Data can be zero to allocate ZLUT data. LUTs should have been created before by BuildLUT, but not necessarily by the current instance as long as setting match.

Parameters

[in]	data	Pointer to the start of the ZLUT data.
[in]	count	Number of ZLUTs in the dataset.
[in]	planes	Number of planes per ZLUT.

Implements QueuedTracker.

Definition at line 380 of file QueuedCPUTracker.cpp.

{
//  jobs_mutex.lock();
//  results_mutex.lock();
    if (zlut_bias_correction)
        delete zlut_bias_correction;

    if (zluts) delete[] zluts;
    int res = cfg.zlut_radialsteps;
    int total = num_zluts*res*planes;
    if (total > 0) {
        zluts = new float[planes*res*num_zluts];
        std::fill(zluts,zluts+(planes*res*num_zluts), 0.0f);
        zlut_planes = planes;
        zlut_count = num_zluts;
        if(data)
            std::copy(data, data+(planes*res*num_zluts), zluts);
    }
    else
        zluts = 0;

    if (zlut_cmpprofiles) delete[] zlut_cmpprofiles;
    zlut_cmpprofiles = new float [num_zluts*planes];

    UpdateZLUTs();
//  results_mutex.unlock();
//  jobs_mutex.unlock();
}

SetTrackerImage()

void QueuedCPUTracker::SetTrackerImage ( CPUTracker *  trk, Job *  job  )

private

Copy the ROI to the tracker's memory.

Parameters

[in]	trk	The tracker for which to set the image.
[in]	job	The job this tracker will execute. Image data is taken from the job.

Definition at line 736 of file QueuedCPUTracker.cpp.

{
    if (j->dataType == QTrkU8) {
        trk->SetImage8Bit(j->data, cfg.width);
    } else if (j->dataType == QTrkU16) {
        trk->SetImage16Bit((ushort*)j->data, cfg.width*2);
    } else {
        trk->SetImageFloat((float*)j->data);
    }
}

Start()

void QueuedCPUTracker::Start

(

)

Start up the threads and initiate their worker function.

Definition at line 220 of file QueuedCPUTracker.cpp.

{
    quitWork = false;

    threads.resize(cfg.numThreads);
    for (int k=0;k<cfg.numThreads;k++) {

        threads[k].mutex = new Threads::Mutex();
#if 0
        threads[k].mutex->name = SPrintf("thread%d", k);
        threads[k].mutex->trace = true;
#endif
        threads[k].tracker = new CPUTracker(downsampleWidth, downsampleHeight, cfg.xc1_profileLength, false);//cfg.testRun);
        threads[k].manager = this;
        threads[k].tracker->trackerID = k;
    }

    for (int k=0;k<threads.size();k++) {
        threads[k].thread = Threads::Create(WorkerThreadMain, &threads[k]);
        Threads::SetBackgroundPriority(threads[k].thread, true);
    }

    processJobs = true;
}

UpdateZLUTs()

void QueuedCPUTracker::UpdateZLUTs ( )

private

Update the ZLUTs for all threads.

Definition at line 424 of file QueuedCPUTracker.cpp.

{
    for (int i=0;i<threads.size();i++){
        threads[i].lock();
        threads[i].tracker->SetRadialZLUT(zluts, zlut_planes, cfg.zlut_radialsteps, zlut_count, cfg.zlut_minradius, cfg.zlut_maxradius, false, false);
        threads[i].unlock();
    }
}

WorkerThreadMain()

void QueuedCPUTracker::WorkerThreadMain ( void *  arg )

staticprivate

The loop executed by the threads.

Will start execution of a new job whenever available and allowed.

Parameters

[in]

arg

Reference to the QueuedCPUTracker::Thread that will execute this loop.

Definition at line 245 of file QueuedCPUTracker.cpp.

{
    Thread* th = (Thread*)arg;
    QueuedCPUTracker* this_ = th->manager;

    while (!this_->quitWork) {
        Job* j = 0;
        if (this_->processJobs) 
            j = this_->GetNextJob();

        if (j) {
            this_->ProcessJob(th, j);
            this_->JobFinished(j);
        } else {
            Threads::Sleep(1);
        }
    }
    //dbgprintf("Thread %p ending.\n", arg);
}

ZLUTSelfTest()

void QueuedCPUTracker::ZLUTSelfTest

(

)

Test the planes saved in the lookup table against itself.

Implemented for testing purposes. Writes the output to a CSV file. Can be used to inspect ZLUT quality.

Definition at line 707 of file QueuedCPUTracker.cpp.

{
    if (zluts){
        /*bool compEnabled = zlut_enablecmpprof;
        if(!compEnabled)
            EnableRadialZLUTCompareProfile(true);*/


        threads[0].lock();
        CPUTracker* trk = threads[0].tracker;
        
        for (int ii=0;ii<zlut_count;ii++) {
            //trk.SetRadialZLUT(&zluts[cfg.zlut_radialsteps*zlut_planes*ii],zlut_planes,cfg.zlut_radialsteps,zlut_count,cfg.zlut_minradius,cfg.zlut_maxradius,false,false);
            
            float* curZLUT = GetZLUTByIndex(ii);            
            for(int plane=0;plane<zlut_planes;plane++){
                float* cmpprof = new float[zlut_planes];
                trk->LUTProfileCompare(&curZLUT[plane*cfg.zlut_radialsteps],ii,cmpprof,CPUTracker::LUTProfMaxQuadraticFit);
                WriteArrayAsCSVRow("D:\\TestImages\\zlutSelfTest.csv",cmpprof,zlut_planes,true);
                delete[] cmpprof;
            }           
        }

        threads[0].unlock();
        
        //EnableRadialZLUTCompareProfile(compEnabled);
    }
}

Member Data Documentation

calib_gain

float* QueuedCPUTracker::calib_gain

private

Vector with gains used for pixel correction.

Definition at line 166 of file QueuedCPUTracker.h.

calib_offset

float* QueuedCPUTracker::calib_offset

private

Vector with offsets used for pixel correction.

Definition at line 167 of file QueuedCPUTracker.h.

dbgPrintResults

bool QueuedCPUTracker::dbgPrintResults

private

Flag to enable easy printing of intermediate data.

Definition at line 216 of file QueuedCPUTracker.h.

downsampleHeight

int QueuedCPUTracker::downsampleHeight

private

Height of ROIs after downsampling.

Definition at line 172 of file QueuedCPUTracker.h.

downsampleWidth

int QueuedCPUTracker::downsampleWidth

private

Width of ROIs after downsampling.

Definition at line 171 of file QueuedCPUTracker.h.

gc_gainFactor

float QueuedCPUTracker::gc_gainFactor

private

Factor by which to scale the gain.

Definition at line 168 of file QueuedCPUTracker.h.

gc_mutex

Threads::Mutex QueuedCPUTracker::gc_mutex

private

Image calibration mutex.

Definition at line 165 of file QueuedCPUTracker.h.

gc_offsetFactor

float QueuedCPUTracker::gc_offsetFactor

private

Factor by which to scale the pixel calibration offset.

Definition at line 169 of file QueuedCPUTracker.h.

image_lut

float* QueuedCPUTracker::image_lut

private

Image LUT data pointer.

Definition at line 199 of file QueuedCPUTracker.h.

image_lut_dims

int QueuedCPUTracker::image_lut_dims[4]

private

Image LUT dimensions, 4D. [numBeads][numPlanes][height][width].

Definition at line 194 of file QueuedCPUTracker.h.

image_lut_dz

float* QueuedCPUTracker::image_lut_dz

private

Image LUT first derivative. (???)

Definition at line 200 of file QueuedCPUTracker.h.

image_lut_dz2

float* QueuedCPUTracker::image_lut_dz2

private

Image LUT second derivative. (???)

Definition at line 201 of file QueuedCPUTracker.h.

image_lut_nElem_per_bead

int QueuedCPUTracker::image_lut_nElem_per_bead

private

Image LUT number of pixels in LUT per bead. Is Width * Height * Planes.

Definition at line 195 of file QueuedCPUTracker.h.

jobCount

int QueuedCPUTracker::jobCount

private

Number of jobs in the queue.

Note

Why maintain this manually and not just use jobs.size()?

Definition at line 158 of file QueuedCPUTracker.h.

jobs

std::deque<Job*> QueuedCPUTracker::jobs

private

Queue to hold the jobs.

Definition at line 152 of file QueuedCPUTracker.h.

jobs_buffer

std::vector<Job*> QueuedCPUTracker::jobs_buffer

private

Stores memory. Enables reuse of allocated Job memory after a job has been completed.

Definition at line 159 of file QueuedCPUTracker.h.

jobs_buffer_mutex

Threads::Mutex QueuedCPUTracker::jobs_buffer_mutex

private

Mutex for the job buffer.

Definition at line 150 of file QueuedCPUTracker.h.

jobs_mutex

Threads::Mutex QueuedCPUTracker::jobs_mutex

private

Mutex for the job queue.

Definition at line 149 of file QueuedCPUTracker.h.

jobsInProgress

int QueuedCPUTracker::jobsInProgress

private

Number of jobs currently being processed.

Definition at line 163 of file QueuedCPUTracker.h.

localizeMode

LocMode_t QueuedCPUTracker::localizeMode

private

Localization settings.

Definition at line 148 of file QueuedCPUTracker.h.

maxQueueSize

int QueuedCPUTracker::maxQueueSize

private

Maximum number of jobs in the queue.

Definition at line 162 of file QueuedCPUTracker.h.

processJobs

bool QueuedCPUTracker::processJobs

private

Flag for threads to continue processing jobs.

Definition at line 215 of file QueuedCPUTracker.h.

qi_radialbinweights

std::vector<float> QueuedCPUTracker::qi_radialbinweights

private

Scaling factors for the QI algorithm.

Definition at line 190 of file QueuedCPUTracker.h.

quitWork

bool QueuedCPUTracker::quitWork

private

Signal threads to stop their work.

Definition at line 214 of file QueuedCPUTracker.h.

resultCount

int QueuedCPUTracker::resultCount

private

Number of results available.

Definition at line 161 of file QueuedCPUTracker.h.

results

std::deque<LocalizationResult> QueuedCPUTracker::results

private

Queue to store the localization results.

Definition at line 160 of file QueuedCPUTracker.h.

results_mutex

Threads::Mutex QueuedCPUTracker::results_mutex

private

Mutex for the results.

Definition at line 151 of file QueuedCPUTracker.h.

threads

std::vector<Thread> QueuedCPUTracker::threads

private

Vector with active threads.

Definition at line 174 of file QueuedCPUTracker.h.

zcmp

std::vector<float> QueuedCPUTracker::zcmp

private

Scaling factors for the ZLUT algorithm.

Definition at line 189 of file QueuedCPUTracker.h.

zlut_buildflags

uint QueuedCPUTracker::zlut_buildflags

private

ZLUT build flags, set through BeginLUT.

Definition at line 187 of file QueuedCPUTracker.h.

zlut_cmpprofiles

float* QueuedCPUTracker::zlut_cmpprofiles

private

Array in which to save errorcurves if enabled with EnableRadialZLUTCompareProfile.

Definition at line 183 of file QueuedCPUTracker.h.

zlut_count

int QueuedCPUTracker::zlut_count

private

Number of ZLUTs (= number of beads).

Definition at line 185 of file QueuedCPUTracker.h.

zlut_enablecmpprof

bool QueuedCPUTracker::zlut_enablecmpprof

private

Flag to save errorcurves. See EnableRadialZLUTCompareProfile.

Definition at line 184 of file QueuedCPUTracker.h.

zlut_planes

int QueuedCPUTracker::zlut_planes

private

Number of planes per ZLUT.

Definition at line 186 of file QueuedCPUTracker.h.

zluts

float* QueuedCPUTracker::zluts

private

Pointer to the first pixel of the Z lookup tables.

All LUTs are saved in one big contiguous section of memory. Calculate specific LUTs or planes based on their indexes. Order is [beadIndex][plane][step]. See GetZLUTByIndex.

Definition at line 182 of file QueuedCPUTracker.h.

---

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

• cputrack/QueuedCPUTracker.h
• cputrack/QueuedCPUTracker.cpp