C++ Metadata::Serialize方法代码示例

/*
 * 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;
}