detectors/slsDetectorPackage
24
0
Fork 0
mirror of https://github.com/slsdetectorgroup/slsDetectorPackage.git synced 2025-12-31 16:41:18 +01:00
Code Issues Actions Packages Releases Activity

Rx: refactor memory structure and listener (#496)

Browse Source 
* gui message doesnt show if it has a '>' symbol in error msg

* minor refactoring for readability (size_t calc fifo size)

* refactoring listening udp socket code: activated and datastream dont create udp sockets anyway, rc<=- should be discarded in any case

* wip

* refactoring memory structure access

* wip: bugfix write header + data to binary

* wip

* wip

* wip

* wip

* wip

* wip

* wip

* wip

* wip

* portRoi no roi effecto on progress

* fail at receiver progress, wip

* segfaults for char pointer in struct

* reference to header to get header and data

* refactoring

* use const defined for size of header of fifo

* updated release notes

* refactoring from review: fwrite, static_cast
This commit is contained in:
Dhanya Thattil
2022-07-22 15:32:41 +02:00
committed by GitHub
parent 26cbfbdb30
commit 4117cda79b
18 changed files with 469 additions and 668 deletions
Download Patch File Download Diff File Expand all files Collapse all files

329
slsReceiverSoftware/src/DataProcessor.cpp
View File

@@ -26,72 +26,72 @@
namespace sls {
const std::string DataProcessor::typeName_ = "DataProcessor";
const std::string DataProcessor::typeName = "DataProcessor";
DataProcessor::DataProcessor(int index, detectorType detectorType, Fifo *fifo,
bool *dataStreamEnable,
uint32_t *streamingFrequency,
uint32_t *streamingTimerInMs,
uint32_t *streamingStartFnum, bool *framePadding,
std::vector<int> *ctbDbitList, int *ctbDbitOffset,
int *ctbAnalogDataBytes)
: ThreadObject(index, typeName_), fifo_(fifo), detectorType_(detectorType),
dataStreamEnable_(dataStreamEnable),
streamingFrequency_(streamingFrequency),
streamingTimerInMs_(streamingTimerInMs),
streamingStartFnum_(streamingStartFnum), framePadding_(framePadding),
ctbDbitList_(ctbDbitList), ctbDbitOffset_(ctbDbitOffset),
ctbAnalogDataBytes_(ctbAnalogDataBytes) {
DataProcessor::DataProcessor(int index, detectorType dType, Fifo *f,
bool *dse,
uint32_t *sf,
uint32_t *st,
uint32_t *sfnum, bool *fp,
std::vector<int> *ctblist, int *ctboff,
int *ctbad)
: ThreadObject(index, typeName), fifo(f), detType(dType),
dataStreamEnable(dse),
streamingFrequency(sf),
streamingTimerInMs(st),
streamingStartFnum(sfnum), framePadding(fp),
ctbDbitList(ctblist), ctbDbitOffset(ctboff),
ctbAnalogDataBytes(ctbad) {
LOG(logDEBUG) << "DataProcessor " << index << " created";
}
DataProcessor::~DataProcessor() { DeleteFiles(); }
bool DataProcessor::GetStartedFlag() const { return startedFlag_; }
bool DataProcessor::GetStartedFlag() const { return startedFlag; }
void DataProcessor::SetFifo(Fifo *fifo) { fifo_ = fifo; }
void DataProcessor::SetFifo(Fifo *fifo) { fifo = fifo; }
void DataProcessor::SetActivate(bool enable) { activated_ = enable; }
void DataProcessor::SetActivate(bool enable) { activated = enable; }
void DataProcessor::SetReceiverROI(ROI roi) {
receiverRoi_ = roi;
receiverRoiEnabled_ = receiverRoi_.completeRoi() ? false : true;
receiverNoRoi_ = receiverRoi_.noRoi();
receiverRoi = roi;
receiverRoiEnabled = receiverRoi.completeRoi() ? false : true;
receiverNoRoi = receiverRoi.noRoi();
}
void DataProcessor::ResetParametersforNewAcquisition() {
StopRunning();
startedFlag_ = false;
numFramesCaught_ = 0;
firstIndex_ = 0;
currentFrameIndex_ = 0;
firstStreamerFrame_ = true;
streamCurrentFrame_ = false;
completeImageToStreamBeforeCropping = make_unique<char[]>(generalData_->imageSize);
startedFlag = false;
numFramesCaught = 0;
firstIndex = 0;
currentFrameIndex = 0;
firstStreamerFrame = true;
streamCurrentFrame = false;
completeImageToStreamBeforeCropping = make_unique<char[]>(generalData->imageSize);
}
void DataProcessor::RecordFirstIndex(uint64_t fnum) {
// listen to this fnum, later +1
currentFrameIndex_ = fnum;
startedFlag_ = true;
firstIndex_ = fnum;
LOG(logDEBUG1) << index << " First Index:" << firstIndex_;
currentFrameIndex = fnum;
startedFlag = true;
firstIndex = fnum;
LOG(logDEBUG1) << index << " First Index:" << firstIndex;
}
void DataProcessor::SetGeneralData(GeneralData *generalData) {
generalData_ = generalData;
void DataProcessor::SetGeneralData(GeneralData *g) {
generalData = g;
}
void DataProcessor::CloseFiles() {
if (dataFile_)
dataFile_->CloseFile();
if (dataFile)
dataFile->CloseFile();
}
void DataProcessor::DeleteFiles() {
CloseFiles();
delete dataFile_;
dataFile_ = nullptr;
delete dataFile;
dataFile = nullptr;
}
void DataProcessor::SetupFileWriter(const bool filewriteEnable,
const fileFormat fileFormatType,
@@ -101,11 +101,11 @@ void DataProcessor::SetupFileWriter(const bool filewriteEnable,
switch (fileFormatType) {
#ifdef HDF5C
case HDF5:
dataFile_ = new HDF5DataFile(index, hdf5LibMutex);
dataFile = new HDF5DataFile(index, hdf5LibMutex);
break;
#endif
case BINARY:
dataFile_ = new BinaryDataFile(index);
dataFile = new BinaryDataFile(index);
break;
default:
throw RuntimeError(
@@ -121,38 +121,38 @@ void DataProcessor::CreateFirstFiles(
const uint32_t udpPortNumber, const uint32_t maxFramesPerFile,
const uint64_t numImages, const uint32_t dynamicRange,
const bool detectorDataStream) {
if (dataFile_ == nullptr) {
if (dataFile == nullptr) {
throw RuntimeError("file object not contstructed");
}
CloseFiles();
// deactivated (half module/ single port or no roi), dont write file
if (!activated_ || !detectorDataStream || receiverNoRoi_) {
if (!activated || !detectorDataStream || receiverNoRoi) {
return;
}
#ifdef HDF5C
int nx = generalData_->nPixelsX;
int ny = generalData_->nPixelsY;
if (receiverRoiEnabled_) {
nx = receiverRoi_.xmax - receiverRoi_.xmin + 1;
ny = receiverRoi_.ymax - receiverRoi_.ymin + 1;
if (receiverRoi_.ymax == -1 || receiverRoi_.ymin == -1) {
int nx = generalData->nPixelsX;
int ny = generalData->nPixelsY;
if (receiverRoiEnabled) {
nx = receiverRoi.xmax - receiverRoi.xmin + 1;
ny = receiverRoi.ymax - receiverRoi.ymin + 1;
if (receiverRoi.ymax == -1 || receiverRoi.ymin == -1) {
ny = 1;
}
}
#endif
switch (dataFile_->GetFileFormat()) {
switch (dataFile->GetFileFormat()) {
#ifdef HDF5C
case HDF5:
dataFile_->CreateFirstHDF5DataFile(
dataFile->CreateFirstHDF5DataFile(
filePath, fileNamePrefix, fileIndex, overWriteEnable, silentMode,
modulePos, numUnitsPerReadout, udpPortNumber, maxFramesPerFile,
numImages, nx, ny, dynamicRange);
break;
#endif
case BINARY:
dataFile_->CreateFirstBinaryDataFile(
dataFile->CreateFirstBinaryDataFile(
filePath, fileNamePrefix, fileIndex, overWriteEnable, silentMode,
modulePos, numUnitsPerReadout, udpPortNumber, maxFramesPerFile);
break;
@@ -163,11 +163,11 @@ void DataProcessor::CreateFirstFiles(
#ifdef HDF5C
uint32_t DataProcessor::GetFilesInAcquisition() const {
if (dataFile_ == nullptr) {
if (dataFile == nullptr) {
throw RuntimeError("No data file object created to get number of "
"files in acquiistion");
}
return dataFile_->GetFilesInAcquisition();
return dataFile->GetFilesInAcquisition();
}
std::string DataProcessor::CreateVirtualFile(
@@ -178,17 +178,17 @@ std::string DataProcessor::CreateVirtualFile(
const int numModX, const int numModY, const uint32_t dynamicRange,
std::mutex *hdf5LibMutex) {
if (receiverRoiEnabled_) {
if (receiverRoiEnabled) {
throw std::runtime_error("Skipping virtual hdf5 file since rx_roi is enabled.");
}
bool gotthard25um =
((detectorType_ == GOTTHARD || detectorType_ == GOTTHARD2) &&
((detType == GOTTHARD || detType == GOTTHARD2) &&
(numModX * numModY) == 2);
// maxframesperfile = 0 for infinite files
uint32_t framesPerFile =
((maxFramesPerFile == 0) ? numFramesCaught_ : maxFramesPerFile);
((maxFramesPerFile == 0) ? numFramesCaught : maxFramesPerFile);
// TODO: assumption 1: create virtual file even if no data in other
// files (they exist anyway) assumption2: virtual file max frame index
@@ -197,9 +197,9 @@ std::string DataProcessor::CreateVirtualFile(
return masterFileUtility::CreateVirtualHDF5File(
filePath, fileNamePrefix, fileIndex, overWriteEnable, silentMode,
modulePos, numUnitsPerReadout, framesPerFile,
generalData_->nPixelsX, generalData_->nPixelsY, dynamicRange,
numFramesCaught_, numModX, numModY, dataFile_->GetPDataType(),
dataFile_->GetParameterNames(), dataFile_->GetParameterDataTypes(),
generalData->nPixelsX, generalData->nPixelsY, dynamicRange,
numFramesCaught, numModX, numModY, dataFile->GetPDataType(),
dataFile->GetParameterNames(), dataFile->GetParameterDataTypes(),
hdf5LibMutex, gotthard25um);
}
@@ -208,16 +208,16 @@ void DataProcessor::LinkFileInMaster(const std::string &masterFileName,
const bool silentMode,
std::mutex *hdf5LibMutex) {
if (receiverRoiEnabled_) {
if (receiverRoiEnabled) {
throw std::runtime_error("Should not be here, roi with hdf5 virtual should throw.");
}
std::string fname{virtualFileName}, masterfname{masterFileName};
// if no virtual file, link data file
if (virtualFileName.empty()) {
fname = dataFile_->GetFileName();
fname = dataFile->GetFileName();
}
masterFileUtility::LinkHDF5FileInMaster(masterfname, fname,
dataFile_->GetParameterNames(),
dataFile->GetParameterNames(),
silentMode, hdf5LibMutex);
}
#endif
@@ -228,7 +228,7 @@ std::string DataProcessor::CreateMasterFile(
const fileFormat fileFormatType, MasterAttributes *attr,
std::mutex *hdf5LibMutex) {
attr->framesInFile = numFramesCaught_;
attr->framesInFile = numFramesCaught;
std::unique_ptr<File> masterFile{nullptr};
switch (fileFormatType) {
@@ -249,35 +249,35 @@ std::string DataProcessor::CreateMasterFile(
void DataProcessor::ThreadExecution() {
char *buffer = nullptr;
fifo_->PopAddress(buffer);
fifo->PopAddress(buffer);
LOG(logDEBUG5) << "DataProcessor " << index << ", " << std::hex
<< static_cast<void *>(buffer) << std::dec << ":" << buffer;
auto *memImage = reinterpret_cast<image_structure *>(buffer);
// check dummy
auto numBytes = *reinterpret_cast<uint32_t *>(buffer);
LOG(logDEBUG1) << "DataProcessor " << index << ", Numbytes:" << numBytes;
if (numBytes == DUMMY_PACKET_VALUE) {
LOG(logDEBUG1) << "DataProcessor " << index << ", Numbytes:" << memImage->size;
if (memImage->size == DUMMY_PACKET_VALUE) {
StopProcessing(buffer);
return;
}
try {
ProcessAnImage(buffer);
ProcessAnImage(memImage->header, memImage->size, memImage->firstIndex, memImage->data);
} catch (const std::exception &e) {
fifo_->FreeAddress(buffer);
fifo->FreeAddress(buffer);
return;
}
// stream (if time/freq to stream) or free
if (streamCurrentFrame_) {
if (streamCurrentFrame) {
// copy the complete image back if roi enabled
if (receiverRoiEnabled_) {
(*((uint32_t *)buffer)) = generalData_->imageSize;
memcpy(buffer + generalData_->fifoBufferHeaderSize, &completeImageToStreamBeforeCropping[0], generalData_->imageSize);
if (receiverRoiEnabled) {
memImage->size = generalData->imageSize;
memcpy(memImage->data, &completeImageToStreamBeforeCropping[0], generalData->imageSize);
}
fifo_->PushAddressToStream(buffer);
fifo->PushAddressToStream(buffer);
} else {
fifo_->FreeAddress(buffer);
fifo->FreeAddress(buffer);
}
}
@@ -285,92 +285,76 @@ void DataProcessor::StopProcessing(char *buf) {
LOG(logDEBUG1) << "DataProcessing " << index << ": Dummy";
// stream or free
if (*dataStreamEnable_)
fifo_->PushAddressToStream(buf);
if (*dataStreamEnable)
fifo->PushAddressToStream(buf);
else
fifo_->FreeAddress(buf);
fifo->FreeAddress(buf);
CloseFiles();
StopRunning();
LOG(logDEBUG1) << index << ": Processing Completed";
}
void DataProcessor::ProcessAnImage(char *buf) {
auto *rheader =
reinterpret_cast<sls_receiver_header *>(buf + FIFO_HEADER_NUMBYTES);
sls_detector_header header = rheader->detHeader;
uint64_t fnum = header.frameNumber;
currentFrameIndex_ = fnum;
numFramesCaught_++;
uint32_t nump = header.packetNumber;
void DataProcessor::ProcessAnImage(sls_receiver_header & header, size_t &size, size_t &firstImageIndex, char* data) {
uint64_t fnum = header.detHeader.frameNumber;
LOG(logDEBUG1) << "DataProcessing " << index << ": fnum:" << fnum;
currentFrameIndex = fnum;
numFramesCaught++;
uint32_t nump = header.detHeader.packetNumber;
if (!startedFlag_) {
if (!startedFlag) {
RecordFirstIndex(fnum);
if (*dataStreamEnable_) {
if (*dataStreamEnable) {
// restart timer
clock_gettime(CLOCK_REALTIME, &timerbegin_);
timerbegin_.tv_sec -= (*streamingTimerInMs_) / 1000;
timerbegin_.tv_nsec -= ((*streamingTimerInMs_) % 1000) * 1000000;
clock_gettime(CLOCK_REALTIME, &timerbegin);
timerbegin.tv_sec -= (*streamingTimerInMs) / 1000;
timerbegin.tv_nsec -= ((*streamingTimerInMs) % 1000) * 1000000;
// to send first image
currentFreqCount_ = *streamingFrequency_ - *streamingStartFnum_;
currentFreqCount = *streamingFrequency - *streamingStartFnum;
}
}
// frame padding
if (activated_ && *framePadding_ && nump < generalData_->packetsPerFrame)
PadMissingPackets(buf);
if (*framePadding && nump < generalData->packetsPerFrame)
PadMissingPackets(header, data);
// rearrange ctb digital bits (if ctbDbitlist is not empty)
if (!(*ctbDbitList_).empty()) {
RearrangeDbitData(buf);
if (!(*ctbDbitList).empty()) {
RearrangeDbitData(size, data);
}
// 'stream Image' check has to be done here before crop image
// stream (if time/freq to stream) or free
if (*dataStreamEnable_ && SendToStreamer()) {
// if first frame to stream, add frame index to fifo header (might
// not be the first)
if (firstStreamerFrame_) {
firstStreamerFrame_ = false;
(*((uint32_t *)(buf + FIFO_DATASIZE_NUMBYTES))) =
(uint32_t)(fnum - firstIndex_);
if (*dataStreamEnable && SendToStreamer()) {
if (firstStreamerFrame) {
firstStreamerFrame = false;
// write to memory structure of first streamer frame
firstImageIndex = firstIndex;
}
streamCurrentFrame_ = true;
streamCurrentFrame = true;
} else {
streamCurrentFrame_ = false;
streamCurrentFrame = false;
}
if (receiverRoiEnabled_) {
if (receiverRoiEnabled) {
// copy the complete image to stream before cropping
if (streamCurrentFrame_) {
memcpy(&completeImageToStreamBeforeCropping[0], buf + generalData_->fifoBufferHeaderSize, generalData_->imageSize);
if (streamCurrentFrame) {
memcpy(&completeImageToStreamBeforeCropping[0], data, generalData->imageSize);
}
CropImage(buf);
CropImage(size, data);
}
try {
// normal call back
if (rawDataReadyCallBack != nullptr) {
std::size_t dsize = *reinterpret_cast<uint32_t *>(buf);
rawDataReadyCallBack(rheader,
buf + FIFO_HEADER_NUMBYTES +
sizeof(sls_receiver_header),
dsize, pRawDataReady);
rawDataReadyCallBack(&header, data, size, pRawDataReady);
}
// call back with modified size
else if (rawDataModifyReadyCallBack != nullptr) {
std::size_t revsize = *reinterpret_cast<uint32_t *>(buf);
rawDataModifyReadyCallBack(rheader,
buf + FIFO_HEADER_NUMBYTES +
sizeof(sls_receiver_header),
revsize, pRawDataReady);
(*((uint32_t *)buf)) = revsize;
rawDataModifyReadyCallBack(&header, data, size, pRawDataReady);
}
} catch (const std::exception &e) {
throw RuntimeError("Get Data Callback Error: " +
@@ -378,14 +362,9 @@ void DataProcessor::ProcessAnImage(char *buf) {
}
// write to file
if (dataFile_) {
if (dataFile) {
try {
dataFile_->WriteToFile(
buf + FIFO_HEADER_NUMBYTES,
sizeof(sls_receiver_header) +
(uint32_t)(*((uint32_t *)buf)), //+ size of data (resizable
// from previous call back
fnum - firstIndex_, nump);
dataFile->WriteToFile(data, header, size, fnum - firstIndex, nump);
} catch (const RuntimeError &e) {
; // ignore write exception for now (TODO: send error message
// via stopReceiver tcp)
@@ -395,7 +374,7 @@ void DataProcessor::ProcessAnImage(char *buf) {
bool DataProcessor::SendToStreamer() {
// skip
if ((*streamingFrequency_) == 0u) {
if ((*streamingFrequency) == 0u) {
if (!CheckTimer())
return false;
} else {
@@ -409,9 +388,9 @@ bool DataProcessor::CheckTimer() {
struct timespec end;
clock_gettime(CLOCK_REALTIME, &end);
auto elapsed_s = (end.tv_sec - timerbegin_.tv_sec) +
(end.tv_nsec - timerbegin_.tv_nsec) / 1e9;
double timer_s = *streamingTimerInMs_ / 1e3;
auto elapsed_s = (end.tv_sec - timerbegin.tv_sec) +
(end.tv_nsec - timerbegin.tv_nsec) / 1e9;
double timer_s = *streamingTimerInMs / 1e3;
LOG(logDEBUG1) << index << " Timer elapsed time:" << elapsed_s
<< " seconds";
@@ -421,16 +400,16 @@ bool DataProcessor::CheckTimer() {
return false;
// restart timer
clock_gettime(CLOCK_REALTIME, &timerbegin_);
clock_gettime(CLOCK_REALTIME, &timerbegin);
return true;
}
bool DataProcessor::CheckCount() {
if (currentFreqCount_ == *streamingFrequency_) {
currentFreqCount_ = 1;
if (currentFreqCount == *streamingFrequency) {
currentFreqCount = 1;
return true;
}
currentFreqCount_++;
currentFreqCount++;
return false;
}
@@ -446,22 +425,20 @@ void DataProcessor::registerCallBackRawDataModifyReady(
pRawDataReady = arg;
}
void DataProcessor::PadMissingPackets(char *buf) {
void DataProcessor::PadMissingPackets(sls_receiver_header header, char* data) {
LOG(logDEBUG) << index << ": Padding Missing Packets";
uint32_t pperFrame = generalData_->packetsPerFrame;
auto *header =
reinterpret_cast<sls_receiver_header *>(buf + FIFO_HEADER_NUMBYTES);
uint32_t nmissing = pperFrame - header->detHeader.packetNumber;
sls_bitset pmask = header->packetsMask;
uint32_t pperFrame = generalData->packetsPerFrame;
uint32_t dsize = generalData_->dataSize;
if (detectorType_ == GOTTHARD2 && index != 0) {
dsize = generalData_->vetoDataSize;
uint32_t nmissing = pperFrame - header.detHeader.packetNumber;
sls_bitset pmask = header.packetsMask;
uint32_t dsize = generalData->dataSize;
if (detType == GOTTHARD2 && index != 0) {
dsize = generalData->vetoDataSize;
}
uint32_t fifohsize = generalData_->fifoBufferHeaderSize;
uint32_t corrected_dsize =
dsize - ((pperFrame * dsize) - generalData_->imageSize);
dsize - ((pperFrame * dsize) - generalData->imageSize);
LOG(logDEBUG1) << "bitmask: " << pmask.to_string();
for (unsigned int pnum = 0; pnum < pperFrame; ++pnum) {
@@ -478,26 +455,26 @@ void DataProcessor::PadMissingPackets(char *buf) {
<< std::endl;
// missing packet
switch (detectorType_) {
switch (detType) {
// for gotthard, 1st packet: 4 bytes fnum, CACA + CACA, 639*2 bytes
// data
// 2nd packet: 4 bytes fnum, previous 1*2 bytes data +
// 640*2 bytes data !!
case GOTTHARD:
if (pnum == 0u)
memset(buf + fifohsize + (pnum * dsize), 0xFF, dsize - 2);
memset(data + (pnum * dsize), 0xFF, dsize - 2);
else
memset(buf + fifohsize + (pnum * dsize), 0xFF, dsize + 2);
memset(data + (pnum * dsize), 0xFF, dsize + 2);
break;
case CHIPTESTBOARD:
case MOENCH:
if (pnum == (pperFrame - 1))
memset(buf + fifohsize + (pnum * dsize), 0xFF, corrected_dsize);
memset(data + (pnum * dsize), 0xFF, corrected_dsize);
else
memset(buf + fifohsize + (pnum * dsize), 0xFF, dsize);
memset(data + (pnum * dsize), 0xFF, dsize);
break;
default:
memset(buf + fifohsize + (pnum * dsize), 0xFF, dsize);
memset(data + (pnum * dsize), 0xFF, dsize);
break;
}
--nmissing;
@@ -505,11 +482,9 @@ void DataProcessor::PadMissingPackets(char *buf) {
}
/** ctb specific */
void DataProcessor::RearrangeDbitData(char *buf) {
void DataProcessor::RearrangeDbitData(size_t & size, char *data) {
// TODO! (Erik) Refactor and add tests
int totalSize = (int)(*((uint32_t *)buf));
int ctbDigitalDataBytes =
totalSize - (*ctbAnalogDataBytes_) - (*ctbDbitOffset_);
int ctbDigitalDataBytes = size - (*ctbAnalogDataBytes) - (*ctbDbitOffset);
// no digital data
if (ctbDigitalDataBytes == 0) {
@@ -519,20 +494,18 @@ void DataProcessor::RearrangeDbitData(char *buf) {
}
const int numSamples = (ctbDigitalDataBytes / sizeof(uint64_t));
const int digOffset = FIFO_HEADER_NUMBYTES + sizeof(sls_receiver_header) +
(*ctbAnalogDataBytes_);
// ceil as numResult8Bits could be decimal
const int numResult8Bits =
ceil((numSamples * (*ctbDbitList_).size()) / 8.00);
ceil((numSamples * (*ctbDbitList).size()) / 8.00);
std::vector<uint8_t> result(numResult8Bits);
uint8_t *dest = &result[0];
auto *source = (uint64_t *)(buf + digOffset + (*ctbDbitOffset_));
auto *source = (uint64_t *)(data + (*ctbAnalogDataBytes) + (*ctbDbitOffset));
// loop through digital bit enable vector
int bitoffset = 0;
for (auto bi : (*ctbDbitList_)) {
for (auto bi : (*ctbDbitList)) {
// where numbits * numsamples is not a multiple of 8
if (bitoffset != 0) {
bitoffset = 0;
@@ -553,18 +526,18 @@ void DataProcessor::RearrangeDbitData(char *buf) {
}
}
// copy back to buf and update size
memcpy(buf + digOffset, result.data(), numResult8Bits * sizeof(uint8_t));
(*((uint32_t *)buf)) = numResult8Bits * sizeof(uint8_t);
// copy back to memory and update size
memcpy(data + (*ctbAnalogDataBytes), result.data(), numResult8Bits * sizeof(uint8_t));
size = numResult8Bits * sizeof(uint8_t);
}
void DataProcessor::CropImage(char *buf) {
LOG(logDEBUG) << "Cropping Image to ROI " << ToString(receiverRoi_);
int nPixelsX = generalData_->nPixelsX;
int xmin = receiverRoi_.xmin;
int xmax = receiverRoi_.xmax;
int ymin = receiverRoi_.ymin;
int ymax = receiverRoi_.ymax;
void DataProcessor::CropImage(size_t & size, char *data) {
LOG(logDEBUG) << "Cropping Image to ROI " << ToString(receiverRoi);
int nPixelsX = generalData->nPixelsX;
int xmin = receiverRoi.xmin;
int xmax = receiverRoi.xmax;
int ymin = receiverRoi.ymin;
int ymax = receiverRoi.ymax;
int xwidth = xmax - xmin + 1;
int ywidth = ymax - ymin + 1;
if (ymin == -1 || ymax == -1) {
@@ -573,16 +546,16 @@ void DataProcessor::CropImage(char *buf) {
}
// calculate total roi size
double bytesPerPixel = generalData_->dynamicRange / 8.00;
double bytesPerPixel = generalData->dynamicRange / 8.00;
int startOffset = (int)((nPixelsX * ymin + xmin) * bytesPerPixel);
// write size into fifo buffer header
// write size into memory
std::size_t roiImageSize = xwidth * ywidth * bytesPerPixel;
LOG(logDEBUG) << "roiImageSize:" << roiImageSize;
(*((uint32_t *)buf)) = roiImageSize;
size = roiImageSize;
// copy the roi to the beginning of the image
char *dstOffset = buf + generalData_->fifoBufferHeaderSize;
char *dstOffset = data;
char *srcOffset = dstOffset + startOffset;
// entire width
@@ -594,7 +567,7 @@ void DataProcessor::CropImage(char *buf) {
for (int y = 0; y != ywidth; ++y) {
memcpy(dstOffset, srcOffset, xwidth * bytesPerPixel);
dstOffset += (int)(xwidth * bytesPerPixel);
srcOffset += (int)(generalData_->nPixelsX * bytesPerPixel);
srcOffset += (int)(generalData->nPixelsX * bytesPerPixel);
}
}
}