void CtControl::abortAcq(AcqStatus acq_status, ErrorCode error_code,
Data& data, bool ctrl_mutex_locked)
{
DEB_MEMBER_FUNCT();
if (!ctrl_mutex_locked)
m_cond.mutex().lock();
bool status_change = (m_status.AcquisitionStatus != acq_status);
if (status_change) {
m_status.AcquisitionStatus = acq_status;
m_status.Error = error_code;
}
if (!ctrl_mutex_locked)
m_cond.mutex().unlock();
typedef SinkTaskBase AbortAcqTask;
AbortAcqTask *abort_task = new AbortAcqTask();
_AbortAcqCallback *abort_cb = new _AbortAcqCallback(*this);
abort_task->setEventCallback(abort_cb);
abort_cb->unref();
TaskMgr *mgr = new TaskMgr();
mgr->setInputData(data);
mgr->addSinkTask(0, abort_task);
abort_task->unref();
PoolThreadMgr::get().addProcess(mgr);
}
void Interface::newFrameReady()
{
DEB_MEMBER_FUNCT();
if(m_acq_mode != Normal) // nothing to do
return;
if(!m_first_thrown && // throw first image
!m_sync->m_keep_first_image) // if we don't want it
{
m_first_thrown = true;
return;
}
TrigMode aCurrentMode;
m_sync->getTrigMode(aCurrentMode);
if(aCurrentMode == ExtStartStop)
{
++m_total_acq_frames;
if(!(m_total_acq_frames & 0x1)) // we keep odd frame
return;
}
int nb_frame_2_acquire;
m_sync->getNbHwFrames(nb_frame_2_acquire);
StdBufferCbMgr& buffer_mgr = m_buffer_ctrl_obj.getBuffer();
HwFrameInfoType frame_info;
frame_info.acq_frame_nb = m_acq_frame_nb;
if(!nb_frame_2_acquire || m_acq_frame_nb < nb_frame_2_acquire)
{
void* framePt = buffer_mgr.getFrameBufferPtr(m_acq_frame_nb);
int bufferid = m_sync->m_keep_first_image ? m_acq_frame_nb++ : ++m_acq_frame_nb;
const FrameDim& fDim = buffer_mgr.getFrameDim();
int bufferNb = aCurrentMode == ExtStartStop ?
int(!m_sync->m_keep_first_image) : (bufferid & 0x1);
void* srcPt = ((char*)m_tmp_buffer) + (bufferNb * fDim.getMemSize());
DEB_TRACE() << "memcpy:" << DEB_VAR2(srcPt,framePt);
memcpy(framePt,srcPt,fDim.getMemSize());
bool continueAcq = buffer_mgr.newFrameReady(frame_info);
if(!continueAcq || m_acq_frame_nb == nb_frame_2_acquire)
{
_StopAcq *aStopAcqPt = new _StopAcq(*this);
TaskMgr *mgr = new TaskMgr();
mgr->addSinkTask(0,aStopAcqPt);
aStopAcqPt->unref();
PoolThreadMgr::get().addProcess(mgr);
}
}
}
void* PoolThreadMgr::_run(void *arg)
{
PoolThreadMgr* processMgrPt = (PoolThreadMgr*)arg;
Lock aLock(&processMgrPt->_lock);
processMgrPt->_runningThread++;
while(1)
{
bool aBroadcastFlag = true;
processMgrPt->_runningThread--;
while(processMgrPt->_suspendFlag ||
(!processMgrPt->_stopFlag && processMgrPt->_processQueue.empty()))
{
if(aBroadcastFlag)
{
pthread_cond_broadcast(&processMgrPt->_cond); // synchro if abort
aBroadcastFlag = false;
}
pthread_cond_wait(&processMgrPt->_cond,&processMgrPt->_lock);
}
processMgrPt->_runningThread++;
if(!processMgrPt->_processQueue.empty())
{
TaskMgr *processPt = processMgrPt->_processQueue.front();
TaskMgr::TaskWrap *aNextTask = processPt->next();
aLock.unLock();
try
{
aNextTask->process();
}
catch(ProcessException &exp)
{
aNextTask->error(exp.getErrMsg());
}
catch(...)
{
aNextTask->error("Unknowed exception!");
}
aLock.lock();
delete aNextTask;
}
else break; // stop
}
processMgrPt->_runningThread--;
return NULL;
}
void SoftOpRoi2Spectrum::addTo(TaskMgr &aMgr,int stage)
{
AutoMutex aLock(m_cond.mutex());
for(std::list<ManagerNCounter>::iterator i = m_manager_tasks.begin();
i != m_manager_tasks.end();++i)
aMgr.addSinkTask(stage,i->second);
++m_counter_status;
}
bool CtControl::newFrameReady(Data& fdata)
{
DEB_MEMBER_FUNCT();
DEB_PARAM() << DEB_VAR1(fdata);
DEB_TRACE() << "Frame acq.nb " << fdata.frameNumber << " received";
bool aContinueFlag = true;
AutoMutex aLock(m_cond.mutex());
if(_checkOverrun(fdata))
aContinueFlag = false;// Stop Acquisition on overun
else
{
m_status.ImageCounters.LastImageAcquired= fdata.frameNumber;
aLock.unlock();
TaskMgr *mgr = new TaskMgr();
mgr->setEventCallback(m_soft_op_error_handler);
mgr->setInputData(fdata);
int internal_stage = 0;
if (!m_ct_buffer->isAccumulationActive())
m_op_int->addTo(*mgr, internal_stage);
int last_link,last_sink;
m_op_ext->addTo(*mgr, internal_stage, last_link, last_sink);
if (internal_stage || (last_link >= 0) || (last_sink >= 0))
PoolThreadMgr::get().addProcess(mgr);
else
delete mgr;
if (!internal_stage)
newBaseImageReady(fdata);
if (m_img_status_cb)
m_img_status_cb->imageStatusChanged(m_status.ImageCounters);
_calcAcqStatus();
}
return aContinueFlag;
}
void SoftOpExternalMgr::addTo(TaskMgr &aTaskMgr,
int begin_stage,
int &last_link_task,int &last_sink_task)
{
DEB_MEMBER_FUNCT();
DEB_PARAM() << DEB_VAR1(begin_stage);
AutoMutex aLock(m_cond.mutex());
last_link_task = last_sink_task = -1;
int nextStage = begin_stage;
for(Stage2Instance::iterator i = m_stage2instance.begin();
i != m_stage2instance.end();++i,++nextStage)
{
for(std::list<SoftOpInstance>::const_iterator k = i->second.begin();
k != i->second.end();++k)
{
if(!k->m_opt->addTo(aTaskMgr,nextStage)) continue;
if(k->m_linkable)
last_link_task = nextStage;
else
last_sink_task = nextStage;
}
}
std::pair<int,LinkTask*> aLastLink(0,NULL);
std::pair<int,SinkTaskBase*> aLastSink(0,NULL);
aTaskMgr.getLastTask(aLastLink,aLastSink);
if(aLastLink.first >= begin_stage)
aLastLink.second->setEventCallback(m_end_link_callback);
if(aLastSink.first >= begin_stage)
{
SinkTaskBase *aDummyPt = new SinkTaskBase();
aDummyPt->setEventCallback(m_end_sink_callback);
aTaskMgr.addSinkTask(aLastSink.first + 1,aDummyPt);
aDummyPt->unref();
}
DEB_RETURN() << DEB_VAR2(last_link_task,last_sink_task);
}
int main(int argc, char *argv[])
{
QApplication a(argc, argv);
try {
TaskMgr *mgr = new TaskMgr();
mgr->show();
} catch (int n) {
if (n == 0) {
QMessageBox::critical(0, "error", "can not find ui file...");
exit(0);
}
else {
;
}
} catch (...) {
QMessageBox::critical(0, "error", "unknow problem...");
exit(0);
}
return a.exec();
}
void SoftOpInternalMgr::addTo(TaskMgr &aTaskMgr,
int &aLastStage) const
{
aLastStage = 0;
if(m_reconstruction_task)
{
aTaskMgr.setLinkTask(aLastStage,m_reconstruction_task);
++aLastStage;
}
Tasks::Binning *aBinTaskPt = NULL;
if(m_bin.getX() > 1 || m_bin.getY() > 1)
{
aBinTaskPt = new Tasks::Binning();
if(m_rotation == Rotation_90 || m_rotation == Rotation_270)
{
aBinTaskPt->mXFactor = m_bin.getY();
aBinTaskPt->mYFactor = m_bin.getX();
}
else
{
aBinTaskPt->mXFactor = m_bin.getX();
aBinTaskPt->mYFactor = m_bin.getY();
}
aTaskMgr.setLinkTask(aLastStage,aBinTaskPt);
aBinTaskPt->unref();
++aLastStage;
}
Tasks::Flip *aFlipTaskPt = NULL;
if(m_flip.x || m_flip.y)
{
Tasks::Flip::FLIP_MODE aMode = Tasks::Flip::FLIP_NONE;
if(m_flip.x && m_flip.y)
aMode = Tasks::Flip::FLIP_ALL;
else if(m_flip.x)
aMode = Tasks::Flip::FLIP_X;
else
aMode = Tasks::Flip::FLIP_Y;
aFlipTaskPt = new Tasks::Flip();
aFlipTaskPt->setFlip(aMode);
aTaskMgr.setLinkTask(aLastStage,aFlipTaskPt);
aFlipTaskPt->unref();
++aLastStage;
}
Tasks::Rotation *aRotationTaskPt = NULL;
if(m_rotation != Rotation_0)
{
Tasks::Rotation::Type aMode;
switch(m_rotation)
{
case Rotation_180: aMode = Tasks::Rotation::R_180;break;
case Rotation_270: aMode = Tasks::Rotation::R_270;break;
default: aMode = Tasks::Rotation::R_90;break;
}
aRotationTaskPt = new Tasks::Rotation();
aRotationTaskPt->setType(aMode);
aTaskMgr.setLinkTask(aLastStage,aRotationTaskPt);
aRotationTaskPt->unref();
++aLastStage;
}
Tasks::SoftRoi *aSoftRoiTaskPt = NULL;
if(m_roi.isActive())
{
Point topl= m_roi.getTopLeft();
Point botr= m_roi.getBottomRight();
aSoftRoiTaskPt = new Tasks::SoftRoi();
aSoftRoiTaskPt->setRoi(topl.x, botr.x, topl.y, botr.y);
aTaskMgr.setLinkTask(aLastStage,aSoftRoiTaskPt);
aSoftRoiTaskPt->unref();
++aLastStage;
}
bool removeReconstructionTaskCallback = true;
//Check now what is the last task to add a callback
if(aSoftRoiTaskPt)
aSoftRoiTaskPt->setEventCallback(m_end_callback);
else if(aRotationTaskPt)
aRotationTaskPt->setEventCallback(m_end_callback);
else if(aFlipTaskPt)
aFlipTaskPt->setEventCallback(m_end_callback);
else if(aBinTaskPt)
aBinTaskPt->setEventCallback(m_end_callback);
else if(m_reconstruction_task)
m_reconstruction_task->setEventCallback(m_end_callback),removeReconstructionTaskCallback = false;
//Clear eventCallback for reconstruction task
if(m_reconstruction_task && removeReconstructionTaskCallback)
m_reconstruction_task->setEventCallback(NULL);
}
/**
* Process raw data from Hexitec detector
* This method will be called for each frame
* this code must be thread safe
* the frame order is not guaranteed (use data.frameNumber)
*
* 1. Re-format raw data
* 2. Perform charge sharing discrimination or addition
* 3. Perform next frame correction
* 4. Create Histogram
*/
Data HexitecProcessingTask::process(Data& srcData) {
DEB_MEMBER_FUNCT();
int frameNb = srcData.frameNumber;
DEB_TRACE() << "Processing frame " << frameNb << " processedCounter " << processedCounter;
// Split the data into current srcData and last frame
std::vector<int> frameDimensions;
Data lastFrameData;
Data currFrameData;
uint16_t* srcPtr;
int width = srcData.dimensions[0];
int height = srcData.dimensions[1];
frameDimensions.push_back(width);
frameDimensions.push_back(height);
currFrameData.type = Data::UINT16;
currFrameData.frameNumber = frameNb;
currFrameData.dimensions = frameDimensions;
Buffer *newCurrFrameBuffer = new Buffer(width*height*sizeof(uint16_t));
currFrameData.setBuffer(newCurrFrameBuffer);
newCurrFrameBuffer->unref();
lastFrameData.type = Data::UINT16;
lastFrameData.dimensions = frameDimensions;
lastFrameData.frameNumber = frameNb - 1;
Buffer *newlastFrameBuffer = new Buffer(width*height*sizeof(uint16_t));
lastFrameData.setBuffer(newlastFrameBuffer);
newlastFrameBuffer->unref();
srcPtr = (uint16_t*)srcData.data();
memcpy(currFrameData.data(), srcPtr, width*height*sizeof(uint16_t));
srcPtr += width*height;
memcpy(lastFrameData.data(), srcPtr, width*height*sizeof(uint16_t));
Data dstData = sort(currFrameData);
if (m_asicPitch == 250) {
switch (m_processType) {
case Camera::CSA:
chargeSharingAddition_3x3(dstData);
break;
case Camera::CSD:
chargeSharingDiscrimination_3x3(dstData);
break;
case Camera::CSA_NF:
if (frameNb > 0) {
nextFrameCorrection(dstData, lastFrameData);
}
chargeSharingAddition_3x3(dstData);
break;
case Camera::CSD_NF:
if (frameNb > 0) {
nextFrameCorrection(dstData, lastFrameData);
}
chargeSharingDiscrimination_3x3(dstData);
break;
case Camera::SORT:
default:
break;
}
} else {
switch (m_processType) {
case Camera::CSA:
chargeSharingAddition_5x5(dstData);
break;
case Camera::CSD:
chargeSharingDiscrimination_5x5(dstData);
break;
case Camera::CSA_NF:
if (frameNb > 0) {
nextFrameCorrection(dstData, lastFrameData);
}
chargeSharingAddition_5x5(dstData);
break;
case Camera::CSD_NF:
if (frameNb > 0) {
nextFrameCorrection(dstData, lastFrameData);
}
chargeSharingDiscrimination_5x5(dstData);
break;
case Camera::SORT:
default:
break;
}
}
// if (m_savingTask != nullptr) {
if (m_saveOpt & 2) {
TaskMgr *taskMgr = new TaskMgr();
taskMgr->setLinkTask(2, m_savingTask);
taskMgr->setInputData(dstData);
DEB_TRACE() << "Adding processed frame " << frameNb << " to task to pool (saveproc) ";
PoolThreadMgr::get().addProcess(taskMgr);
}
createSpectra(dstData);
processedCounter++;
return dstData;
}
void SoftOpBpm::addTo(TaskMgr &aMgr,int stage)
{
aMgr.addSinkTask(stage,m_task);
}
void SoftUserSinkTask::addTo(TaskMgr &aMgr,int stage)
{
if(m_sink_task)
aMgr.addSinkTask(stage,m_sink_task);
}
void SoftOpBinning::addTo(TaskMgr &aMgr,int stage)
{
aMgr.setLinkTask(stage,m_opt);
}
void SoftUserLinkTask::addTo(TaskMgr &aMgr,int stage)
{
if(m_link_task)
aMgr.setLinkTask(stage,m_link_task);
}
void SoftOpSoftRoi::addTo(TaskMgr &aMgr,int stage)
{
aMgr.setLinkTask(stage,m_opt);
}
void SoftOpBackgroundSubstraction::addTo(TaskMgr &aMgr,int stage)
{
aMgr.setLinkTask(stage,m_opt);
}
void SoftOpFlatfieldCorrection::addTo(TaskMgr &aMgr,int stage)
{
aMgr.setLinkTask(stage,m_opt);
}
