/* * Inserts Image and MetaData into MMCore circular Buffer */ int ThorlabsUSBCam::InsertImage() { // Image metadata Metadata md; char label[MM::MaxStrLength]; this->GetLabel(label); md.put("Camera", label); md.put(MM::g_Keyword_Metadata_StartTime, CDeviceUtils::ConvertToString(sequenceStartTime_.getMsec())); md.put(MM::g_Keyword_Elapsed_Time_ms, CDeviceUtils::ConvertToString((GetCurrentMMTime() - sequenceStartTime_).getMsec())); md.put(MM::g_Keyword_Metadata_ImageNumber, CDeviceUtils::ConvertToString(imageCounter_)); imageCounter_++; MMThreadGuard g(imgPixelsLock_); int ret = GetCoreCallback()->InsertImage(this, img_.GetPixels(), img_.Width(), img_.Height(), img_.Depth(), md.Serialize().c_str()); if (!stopOnOverFlow_ && ret == DEVICE_BUFFER_OVERFLOW) { // do not stop on overflow, reset the buffer and insert the same image again GetCoreCallback()->ClearImageBuffer(this); return GetCoreCallback()->InsertImage(this, img_.GetPixels(), img_.Width(), img_.Height(), img_.Depth(), md.Serialize().c_str()); } else return ret; }
/* * Inserts Image and MetaData into MMCore circular Buffer */ int CIDS_uEye::InsertImage() { MM::MMTime timeStamp = this->GetCurrentMMTime(); char label[MM::MaxStrLength]; this->GetLabel(label); // Important: metadata about the image are generated here: Metadata md; /* // Copy the metadata inserted by other processes: std::vector<std::string> keys = metadata_.GetKeys(); for (unsigned int i= 0; i < keys.size(); i++) { MetadataSingleTag mst = metadata_.GetSingleTag(keys[i].c_str()); md.PutTag(mst.GetName(), mst.GetDevice(), mst.GetValue()); } */ // Add our own metadata md.put("Camera", label); md.put(MM::g_Keyword_Metadata_StartTime, CDeviceUtils::ConvertToString(sequenceStartTime_.getMsec())); md.put(MM::g_Keyword_Elapsed_Time_ms, CDeviceUtils::ConvertToString((timeStamp - sequenceStartTime_).getMsec())); md.put(MM::g_Keyword_Metadata_ImageNumber, CDeviceUtils::ConvertToString(imageCounter_)); md.put(MM::g_Keyword_Metadata_ROI_X, CDeviceUtils::ConvertToString( (long) roiX_)); md.put(MM::g_Keyword_Metadata_ROI_Y, CDeviceUtils::ConvertToString( (long) roiY_)); imageCounter_++; char buf[MM::MaxStrLength]; GetProperty(MM::g_Keyword_Binning, buf); md.put(MM::g_Keyword_Binning, buf); MMThreadGuard g(imgPixelsLock_); const unsigned char* pI = GetImageBuffer(); unsigned int w = GetImageWidth(); unsigned int h = GetImageHeight(); unsigned int b = GetImageBytesPerPixel(); int ret = GetCoreCallback()->InsertImage(this, pI, w, h, b, md.Serialize().c_str()); if (!stopOnOverflow_ && ret == DEVICE_BUFFER_OVERFLOW) { // do not stop on overflow - just reset the buffer GetCoreCallback()->ClearImageBuffer(this); // don't process this same image again... return GetCoreCallback()->InsertImage(this, pI, w, h, b, md.Serialize().c_str(), false); } else return ret; }
/* * Inserts Image and MetaData into MMCore circular Buffer */ int CAndorSDK3Camera::InsertImage() { char deviceName[MM::MaxStrLength]; GetProperty(MM::g_Keyword_Name, deviceName); Metadata md; MetadataSingleTag mstCount(MM::g_Keyword_Metadata_ImageNumber, deviceName, true); mstCount.SetValue(CDeviceUtils::ConvertToString(thd_->GetImageCounter())); md.SetTag(mstCount); if (0 == thd_->GetImageCounter()) { sequenceStartTime_ = timeStamp_; } stringstream ss; ss << sequenceStartTime_; MetadataSingleTag mstStartTime(MM::g_Keyword_Metadata_StartTime, deviceName, true); mstStartTime.SetValue(ss.str().c_str()); md.SetTag(mstStartTime); ss.str(""); ss.clear(); double d_result = (timeStamp_-sequenceStartTime_)/static_cast<double>(fpgaTSclockFrequency_); ss << d_result*1000 << " [" << d_result << " seconds]"; MetadataSingleTag mst(MM::g_Keyword_Elapsed_Time_ms, deviceName, true); mst.SetValue(ss.str().c_str()); md.SetTag(mst); MMThreadGuard g(imgPixelsLock_); const unsigned char * pData = img_.GetPixels(); unsigned int w = img_.Width(); unsigned int h = img_.Height(); unsigned int b = img_.Depth(); int ret = GetCoreCallback()->InsertImage(this, pData, w, h, b, md.Serialize().c_str(), false); if (!stopOnOverflow_ && ret == DEVICE_BUFFER_OVERFLOW) { // do not stop on overflow - just reset the buffer GetCoreCallback()->ClearImageBuffer(this); // don't process this same image again... ret = GetCoreCallback()->InsertImage(this, pData, w, h, b, md.Serialize().c_str(), false); } return ret; }
void ImgBuffer::SetMetadata(const Metadata& md) { //metadata_ = md; // Serialize/Restore instead of =operator used to avoid object new/delete // issues accross the DLL boundary (on Windows) // TODO: this is inefficient and should be revised metadata_.Restore(md.Serialize().c_str()); }
/* * Inserts Image and MetaData into MMCore circular Buffer */ int COpenCVgrabber::InsertImage() { MM::MMTime timeStamp = this->GetCurrentMMTime(); char label[MM::MaxStrLength]; this->GetLabel(label); // Important: metadata about the image are generated here: Metadata md; md.put("Camera", label); md.put(MM::g_Keyword_Metadata_StartTime, CDeviceUtils::ConvertToString(sequenceStartTime_.getMsec())); md.put(MM::g_Keyword_Elapsed_Time_ms, CDeviceUtils::ConvertToString((timeStamp - sequenceStartTime_).getMsec())); md.put(MM::g_Keyword_Metadata_ImageNumber, CDeviceUtils::ConvertToString(imageCounter_)); md.put(MM::g_Keyword_Metadata_ROI_X, CDeviceUtils::ConvertToString( (long) roiX_)); md.put(MM::g_Keyword_Metadata_ROI_Y, CDeviceUtils::ConvertToString( (long) roiY_)); imageCounter_++; char buf[MM::MaxStrLength]; GetProperty(MM::g_Keyword_Binning, buf); md.put(MM::g_Keyword_Binning, buf); MMThreadGuard g(imgPixelsLock_); const unsigned char* pI = GetImageBuffer(); unsigned int w = GetImageWidth(); unsigned int h = GetImageHeight(); unsigned int b = GetImageBytesPerPixel(); int ret = GetCoreCallback()->InsertImage(this, pI, w, h, b, md.Serialize().c_str()); if (!stopOnOverFlow_ && ret == DEVICE_BUFFER_OVERFLOW) { // do not stop on overflow - just reset the buffer GetCoreCallback()->ClearImageBuffer(this); // don't process this same image again... return GetCoreCallback()->InsertImage(this, pI, w, h, b, md.Serialize().c_str(), false); //return GetCoreCallback()->InsertImage(this, pI, w, h, b); } else return ret; }
int EagleIce::InsertImage() { char label[MM::MaxStrLength]; this->GetLabel(label); Metadata md; md.put("Camera", label); int ret = GetCoreCallback()->InsertImage(this, GetImageBuffer(), GetImageWidth(), GetImageHeight(), GetImageBytesPerPixel(), md.Serialize().c_str()); g_Self->_capturing = false; if(liveView_ == 1) g_device->Start_Integration(&lastResolution); if (ret == DEVICE_BUFFER_OVERFLOW) { // do not stop on overflow - just reset the buffer GetCoreCallback()->ClearImageBuffer(this); return GetCoreCallback()->InsertImage(this, GetImageBuffer(), GetImageWidth(), GetImageHeight(), GetImageBytesPerPixel(), md.Serialize().c_str()); } else return ret; }
/** * Waits for new image and inserts it in the circular buffer. * This method is called by the acquisition thread AcqSequenceThread::svc() * in an infinite loop. * * In case of error or if the sequence is finished StopSequenceAcquisition() * is called, which will raise the stop_ flag and cause the thread to exit. */ int DVCCamera::PushImage(int userBufferId) { // create metadata char label[MM::MaxStrLength]; this->GetLabel(label); MM::MMTime timestamp = this->GetCurrentMMTime(); Metadata md; // Copy the metadata inserted by other processes: std::vector<std::string> keys = metadata_.GetKeys(); for (unsigned int i = 0; i < keys.size(); i++) { md.put(keys[i], metadata_.GetSingleTag(keys[i].c_str()).GetValue().c_str()); } ImageMetaDataP pMd = userBuffers_.pMeta + userBufferId; md.put("Camera", label); md.put(MM::g_Keyword_Metadata_StartTime, dvcStartTs_); // LARGE_INTEGER perfCounter; // QueryPerformanceCounter(&perfCounter); // md.put(MM::g_Keyword_Elapsed_Time_ms, // (double) (perfCounter.QuadPart - perfStartCounter_.QuadPart) // / (double) perfFreq_.QuadPart); md.put(MM::g_Keyword_Elapsed_Time_ms, pMd->dExposeTimeStamp - dvcStartTs_); md.put(MM::g_Keyword_Metadata_ImageNumber, CDeviceUtils::ConvertToString((long) (pMd->ulStreamCount))); md.put(MM::g_Keyword_Binning, binSize_); md.PutTag(g_hBinning, label, pMd->hBin); md.PutTag(g_vBinning, label, pMd->vBin); md.PutTag(g_MD_ExposeTime, label, pMd->dExposeTime); md.PutTag(g_MD_ExposeTimestamp, label, pMd->dExposeTimeStamp); md.PutTag(g_MD_FrameTimestamp, label, pMd->dFrameTime); md.PutTag(g_MD_TransferTime, label, pMd->dTransferTime); md.PutTag(g_MD_TriggerTimestamp, label, pMd->dTriggerTimeStamp); const int height = GetImageHeight(); const int width = GetImageWidth(); const int bytesPerPixel = GetImageBytesPerPixel(); imageCounter_++; // This method inserts new image in the circular buffer (residing in MMCore) const int retCode = GetCoreCallback()->InsertImage(this, (const unsigned char*) (userBuffers_.pBuffers[userBufferId]), (unsigned int) width, (unsigned int) height, (unsigned int) bytesPerPixel, &md); if (!stopOnOverflow_ && retCode == DEVICE_BUFFER_OVERFLOW) { // LogMessage("Overflow occured."); // do not stop on overflow - just reset the buffer GetCoreCallback()->ClearImageBuffer(this); return GetCoreCallback()->InsertImage(this, (const unsigned char*) (userBuffers_.pBuffers[userBufferId]), (unsigned int) width, (unsigned int) height, (unsigned int) bytesPerPixel, md.Serialize().c_str()); } userBuffers_.pBufferStatus[userBufferId] = 0; return DEVICE_OK; }
int BitFlowCamera::LiveThread::svc() { stopRunning_ = false; running_ = true; imageCounter_ = 0; // put the hardware into a continuous acqusition state while (true) { if (stopRunning_) break; int ret = cam_->SnapImage(); if (ret != DEVICE_OK) { char txt[1000]; sprintf(txt, "BitFlow live thread: ImageSnap() error %d", ret); cam_->GetCoreCallback()->LogMessage(cam_, txt, false); break; } char label[MM::MaxStrLength]; cam_->GetLabel(label); MM::MMTime timestamp = cam_->GetCurrentMMTime(); Metadata md; MetadataSingleTag mstStartTime(MM::g_Keyword_Metadata_StartTime, label, true); mstStartTime.SetValue(CDeviceUtils::ConvertToString(cam_->startTime_.getMsec())); md.SetTag(mstStartTime); MetadataSingleTag mstElapsed(MM::g_Keyword_Elapsed_Time_ms, label, true); MM::MMTime elapsed = timestamp - cam_->startTime_; mstElapsed.SetValue(CDeviceUtils::ConvertToString(elapsed.getMsec())); md.SetTag(mstElapsed); MetadataSingleTag mstCount(MM::g_Keyword_Metadata_ImageNumber, label, true); mstCount.SetValue(CDeviceUtils::ConvertToString(imageCounter_)); md.SetTag(mstCount); // insert all channels for (unsigned i=0; i<cam_->GetNumberOfChannels(); i++) { char buf[MM::MaxStrLength]; MetadataSingleTag mstChannel(MM::g_Keyword_CameraChannelIndex, label, true); snprintf(buf, MM::MaxStrLength, "%d", i); mstChannel.SetValue(buf); md.SetTag(mstChannel); MetadataSingleTag mstChannelName(MM::g_Keyword_CameraChannelName, label, true); cam_->GetChannelName(i, buf); mstChannelName.SetValue(buf); md.SetTag(mstChannelName); ret = cam_->GetCoreCallback()->InsertImage(cam_, cam_->GetImageBuffer(i), cam_->GetImageWidth(), cam_->GetImageHeight(), cam_->GetImageBytesPerPixel(), md.Serialize().c_str()); if (ret == DEVICE_BUFFER_OVERFLOW) { cam_->GetCoreCallback()->ClearImageBuffer(cam_); cam_->GetCoreCallback()->InsertImage(cam_, cam_->GetImageBuffer(i), cam_->GetImageWidth(), cam_->GetImageHeight(), cam_->GetImageBytesPerPixel(), md.Serialize().c_str()); } else if (ret != DEVICE_OK) { cam_->GetCoreCallback()->LogMessage(cam_, "BitFlow thread: error inserting image", false); break; } } imageCounter_++; if (numImages_ >=0 && imageCounter_ >= numImages_) { cam_->bfDev_.StopContinuousAcq(); break; } } running_ = false; return 0; }