orthanc-stone: Framework/Radiography/RadiographyScene.cpp comparison

comparison Framework/Radiography/RadiographyScene.cpp @ 426:660fe6f6bf4a am-vsol-upgrade

split Export in 2

author	am@osimis.io
date	Thu, 22 Nov 2018 23:15:24 +0100
parents	087237703d63
children	3f9017db1738 751fb354149e

comparison

equal deleted inserted replaced

-:087237703d63
+:660fe6f6bf4a
 assert(layer->second != NULL);
 layer_ = layer->second;
 }
 }
 RadiographyScene::LayerAccessor::LayerAccessor(RadiographyScene& scene,
 double x,
 double y) :
 scene_(scene),
 index_(0)  // Dummy initialization
 {
 if (scene.LookupLayer(index_, x, y))
 {
 Layers::iterator layer = scene.layers_.find(index_);
 if (layer == scene.layers_.end())
 {
 throw Orthanc::OrthancException(Orthanc::ErrorCode_InternalError);
 }
 else
 }
 else
 {
 throw Orthanc::OrthancException(Orthanc::ErrorCode_BadSequenceOfCalls);
 }
 }
 class RadiographyScene::AlphaLayer : public RadiographyLayer
 {
 void SetForegroundValue(float foreground)
 {
 useWindowing_ = false;
 foreground_ = foreground;
 }
 void SetAlpha(Orthanc::ImageAccessor* image)
 {
 std::auto_ptr<Orthanc::ImageAccessor> raii(image);
 if (image == NULL)
 {
 throw Orthanc::OrthancException(Orthanc::ErrorCode_NullPointer);
 }
 void LoadText(const Orthanc::Font& font,
 const std::string& utf8)
 {
 SetAlpha(font.RenderAlpha(utf8));
 }
 virtual bool GetDefaultWindowing(float& center,
 float& width) const
 {
 return false;
 }
 virtual void Render(Orthanc::ImageAccessor& buffer,
 const AffineTransform2D& viewTransform,
 ImageInterpolation interpolation) const
 {
 if (alpha_.get() == NULL)
 {
 return;
 }
 if (buffer.GetFormat() != Orthanc::PixelFormat_Float32)
 {
 throw Orthanc::OrthancException(Orthanc::ErrorCode_IncompatibleImageFormat);
 }
 unsigned int cropX, cropY, cropWidth, cropHeight;
 GetCrop(cropX, cropY, cropWidth, cropHeight);
 const AffineTransform2D t = AffineTransform2D::Combine(
 viewTransform, GetTransform(),
 AffineTransform2D::CreateOffset(cropX, cropY));
 Orthanc::ImageAccessor cropped;
 alpha_->GetRegion(cropped, cropX, cropY, cropWidth, cropHeight);
 Orthanc::Image tmp(Orthanc::PixelFormat_Grayscale8, buffer.GetWidth(), buffer.GetHeight(), false);
 t.Apply(tmp, cropped, interpolation, true /* clear */);
 // Blit
 const unsigned int width = buffer.GetWidth();
 const unsigned int height = buffer.GetHeight();
 float value = foreground_;
 if (useWindowing_)
 {
 float center, width;
 if (scene_.GetWindowing(center, width))
 {
 value = center + width / 2.0f;
 }
 }
 for (unsigned int y = 0; y < height; y++)
 {
 float *q = reinterpret_cast<float*>(buffer.GetRow(y));
 const uint8_t *p = reinterpret_cast<uint8_t*>(tmp.GetRow(y));
 for (unsigned int x = 0; x < width; x++, p++, q++)
 {
 float a = static_cast<float>(*p) / 255.0f;
 *q = (a * value + (1.0f - a) * (*q));
 }
 }
 }
 virtual bool GetRange(float& minValue,
 float& maxValue) const
 {
 if (useWindowing_)
 {
 return true;
 }
 }
 };
 class RadiographyScene::DicomLayer : public RadiographyLayer
 {
 private:
 std::auto_ptr<Orthanc::ImageAccessor>  source_;  // Content of PixelData
 static OrthancPlugins::DicomTag  ConvertTag(const Orthanc::DicomTag& tag)
 {
 return OrthancPlugins::DicomTag(tag.GetGroup(), tag.GetElement());
 }
 void ApplyConverter()
 {
 if (source_.get() != NULL &&
 converter_.get() != NULL)
 {
 converted_.reset(converter_->ConvertFrame(*source_));
 }
 }
 public:
 void SetDicomTags(const OrthancPlugins::FullOrthancDataset& dataset)
 {
 converter_.reset(new DicomFrameConverter);
 converter_->ReadParameters(dataset);
 ApplyConverter();
 std::string tmp;
 Vector pixelSpacing;
 if (dataset.GetStringValue(tmp, ConvertTag(Orthanc::DICOM_TAG_PIXEL_SPACING)) &&
 LinearAlgebra::ParseVector(pixelSpacing, tmp) &&
 pixelSpacing.size() == 2)
 {
 SetPixelSpacing(pixelSpacing[0], pixelSpacing[1]);
 {
 SetSize(width, height);
 }
 }
 void SetSourceImage(Orthanc::ImageAccessor* image)   // Takes ownership
 {
 std::auto_ptr<Orthanc::ImageAccessor> raii(image);
 if (image == NULL)
 {
 throw Orthanc::OrthancException(Orthanc::ErrorCode_NullPointer);
 }
 SetSize(image->GetWidth(), image->GetHeight());
 source_ = raii;
 ApplyConverter();
 }
 virtual void Render(Orthanc::ImageAccessor& buffer,
 const AffineTransform2D& viewTransform,
 ImageInterpolation interpolation) const
 {
 if (converted_.get() != NULL)
 unsigned int cropX, cropY, cropWidth, cropHeight;
 GetCrop(cropX, cropY, cropWidth, cropHeight);
 AffineTransform2D t = AffineTransform2D::Combine(
 viewTransform, GetTransform(),
 AffineTransform2D::CreateOffset(cropX, cropY));
 Orthanc::ImageAccessor cropped;
 converted_->GetRegion(cropped, cropX, cropY, cropWidth, cropHeight);
 t.Apply(buffer, cropped, interpolation, false);
 {
 throw Orthanc::OrthancException(Orthanc::ErrorCode_NullPointer);
 }
 std::auto_ptr<RadiographyLayer> raii(layer);
 size_t index = countLayers_++;
 raii->SetIndex(index);
 layers_[index] = raii.release();
 EmitMessage(GeometryChangedMessage(*this));
 EmitMessage(ContentChangedMessage(*this));
 return *layer;
 }
 RadiographyScene::RadiographyScene(MessageBroker& broker) :
 IObserver(broker),
 IObservable(broker),
 countLayers_(0),
 alpha->LoadText(font, utf8);
 return RegisterLayer(alpha.release());
 }
 RadiographyLayer& RadiographyScene::LoadTestBlock(unsigned int width,
 unsigned int height)
 {
 std::auto_ptr<Orthanc::Image>  block(new Orthanc::Image(Orthanc::PixelFormat_Grayscale8, width, height, false));
 alpha->SetAlpha(block.release());
 return RegisterLayer(alpha.release());
 }
 RadiographyLayer& RadiographyScene::LoadDicomFrame(OrthancApiClient& orthanc,
 const std::string& instance,
 unsigned int frame,
 bool httpCompression)
 {
 RadiographyLayer& layer = RegisterLayer(new DicomLayer);
 {
 IWebService::HttpHeaders headers;
 std::string uri = "/instances/" + instance + "/tags";
 orthanc.GetBinaryAsync(
 uri, headers,
 new Callable<RadiographyScene, OrthancApiClient::BinaryResponseReadyMessage>
 (*this, &RadiographyScene::OnTagsReceived), NULL,
 new Orthanc::SingleValueObject<size_t>(layer.GetIndex()));
 }
 {
 IWebService::HttpHeaders headers;
 headers["Accept"] = "image/x-portable-arbitrarymap";
 if (httpCompression)
 {
 headers["Accept-Encoding"] = "gzip";
 }
 std::string uri = ("/instances/" + instance + "/frames/" +
 boost::lexical_cast<std::string>(frame) + "/image-uint16");
 orthanc.GetBinaryAsync(
 uri, headers,
 new Callable<RadiographyScene, OrthancApiClient::BinaryResponseReadyMessage>
 (*this, &RadiographyScene::OnFrameReceived), NULL,
 new Orthanc::SingleValueObject<size_t>(layer.GetIndex()));
 }
 return layer;
 }
 RadiographyLayer& RadiographyScene::LoadDicomWebFrame(IWebService& web)
 {
 RadiographyLayer& layer = RegisterLayer(new DicomLayer);
 return layer;
 }
 void RadiographyScene::OnTagsReceived(const OrthancApiClient::BinaryResponseReadyMessage& message)
 {
 size_t index = dynamic_cast<const Orthanc::SingleValueObject<size_t>&>
 (message.GetPayload()).GetValue();
 LOG(INFO) << "JSON received: " << message.GetUri().c_str()
 << " (" << message.GetAnswerSize() << " bytes) for layer " << index;
 Layers::iterator layer = layers_.find(index);
 if (layer != layers_.end())
 {
 assert(layer->second != NULL);
 OrthancPlugins::FullOrthancDataset dicom(message.GetAnswer(), message.GetAnswerSize());
 dynamic_cast<DicomLayer*>(layer->second)->SetDicomTags(dicom);
 float c, w;
 if (!hasWindowing_ &&
 }
 EmitMessage(GeometryChangedMessage(*this));
 }
 }
 void RadiographyScene::OnFrameReceived(const OrthancApiClient::BinaryResponseReadyMessage& message)
 {
 size_t index = dynamic_cast<const Orthanc::SingleValueObject<size_t>&>(message.GetPayload()).GetValue();
 LOG(INFO) << "DICOM frame received: " << message.GetUri().c_str()
 << " (" << message.GetAnswerSize() << " bytes) for layer " << index;
 Layers::iterator layer = layers_.find(index);
 if (layer != layers_.end())
 {
 assert(layer->second != NULL);
 std::string content;
 if (message.GetAnswerSize() > 0)
 {
 content.assign(reinterpret_cast<const char*>(message.GetAnswer()), message.GetAnswerSize());
 }
 std::auto_ptr<Orthanc::PamReader> reader(new Orthanc::PamReader);
 reader->ReadFromMemory(content);
 dynamic_cast<DicomLayer*>(layer->second)->SetSourceImage(reader.release());
 EmitMessage(ContentChangedMessage(*this));
 extent.Union(it->second->GetExtent());
 }
 return extent;
 }
 void RadiographyScene::Render(Orthanc::ImageAccessor& buffer,
 const AffineTransform2D& viewTransform,
 ImageInterpolation interpolation) const
 {
 }
 return false;
 }
 void RadiographyScene::DrawBorder(CairoContext& context,
 unsigned int layer,
 double zoom)
 {
 Layers::const_iterator found = layers_.find(layer);
 if (found != layers_.end())
 {
 context.SetSourceColor(255, 0, 0);
 found->second->DrawBorders(context, zoom);
 }
 void RadiographyScene::GetRange(float& minValue,
 float& maxValue) const
 {
 bool first = true;
 for (Layers::const_iterator it = layers_.begin();
 it != layers_.end(); it++)
 {
 assert(it->second != NULL);
 maxValue = 0;
 }
 }
-// Export using PAM is faster than using PNG, but requires Orthanc
-// core >= 1.4.3
 void RadiographyScene::ExportDicom(OrthancApiClient& orthanc,
 const Orthanc::DicomMap& dicom,
+const std::string& parentOrthancId,
 double pixelSpacingX,
 double pixelSpacingY,
 bool invert,
 ImageInterpolation interpolation,
 bool usePam)
 {
+Json::Value createDicomRequestContent;
+Export(createDicomRequestContent, dicom, pixelSpacingX, pixelSpacingY, invert, interpolation, usePam);
+if (!parentOrthancId.empty())
+{
+createDicomRequestContent["Parent"] = parentOrthancId;
+}
+orthanc.PostJsonAsyncExpectJson(
+"/tools/create-dicom", createDicomRequestContent,
+new Callable<RadiographyScene, OrthancApiClient::JsonResponseReadyMessage>
+(*this, &RadiographyScene::OnDicomExported),
+NULL, NULL);
+}
+// Export using PAM is faster than using PNG, but requires Orthanc
+// core >= 1.4.3
+void RadiographyScene::Export(Json::Value& createDicomRequestContent,
+const Orthanc::DicomMap& dicom,
+double pixelSpacingX,
+double pixelSpacingY,
+bool invert,
+ImageInterpolation interpolation,
+bool usePam)
+{
 if (pixelSpacingX <= 0 ||
 pixelSpacingY <= 0)
 {
 throw Orthanc::OrthancException(Orthanc::ErrorCode_ParameterOutOfRange);
 }
 LOG(INFO) << "Exporting DICOM";
 Extent2D extent = GetSceneExtent();
 int w = std::ceil(extent.GetWidth() / pixelSpacingX);
 Orthanc::Image layers(Orthanc::PixelFormat_Float32,
 static_cast<unsigned int>(w),
 static_cast<unsigned int>(h), false);
 AffineTransform2D view = AffineTransform2D::Combine(
 AffineTransform2D::CreateScaling(1.0 / pixelSpacingX, 1.0 / pixelSpacingY),
 AffineTransform2D::CreateOffset(-extent.GetX1(), -extent.GetY1()));
 Render(layers, view, interpolation);
 Orthanc::Image rendered(Orthanc::PixelFormat_Grayscale16,
 layers.GetWidth(), layers.GetHeight(), false);
 Orthanc::ImageProcessing::Convert(rendered, layers);
 }
 std::set<Orthanc::DicomTag> tags;
 dicom.GetTags(tags);
-Json::Value json = Json::objectValue;
+createDicomRequestContent["Tags"] = Json::objectValue;
-json["Tags"] = Json::objectValue;
 for (std::set<Orthanc::DicomTag>::const_iterator
 tag = tags.begin(); tag != tags.end(); ++tag)
 {
 const Orthanc::DicomValue& value = dicom.GetValue(*tag);
 if (!value.IsNull() &&
 !value.IsBinary())
 {
-json["Tags"][tag->Format()] = value.GetContent();
+createDicomRequestContent["Tags"][tag->Format()] = value.GetContent();
 }
 }
-json["Tags"][Orthanc::DICOM_TAG_PHOTOMETRIC_INTERPRETATION.Format()] =
+createDicomRequestContent["Tags"][Orthanc::DICOM_TAG_PHOTOMETRIC_INTERPRETATION.Format()] =
 (invert ? "MONOCHROME1" : "MONOCHROME2");
 // WARNING: The order of PixelSpacing is Y/X. We use "%0.8f" to
 // avoid floating-point numbers to grow over 16 characters,
 // which would be invalid according to DICOM standard
 // ("dciodvfy" would complain).
 char buf[32];
 sprintf(buf, "%0.8f\\%0.8f", pixelSpacingY, pixelSpacingX);
-json["Tags"][Orthanc::DICOM_TAG_PIXEL_SPACING.Format()] = buf;
+createDicomRequestContent["Tags"][Orthanc::DICOM_TAG_PIXEL_SPACING.Format()] = buf;
 float center, width;
 if (GetWindowing(center, width))
 {
-json["Tags"][Orthanc::DICOM_TAG_WINDOW_CENTER.Format()] =
+createDicomRequestContent["Tags"][Orthanc::DICOM_TAG_WINDOW_CENTER.Format()] =
 boost::lexical_cast<std::string>(boost::math::iround(center));
-json["Tags"][Orthanc::DICOM_TAG_WINDOW_WIDTH.Format()] =
+createDicomRequestContent["Tags"][Orthanc::DICOM_TAG_WINDOW_WIDTH.Format()] =
 boost::lexical_cast<std::string>(boost::math::iround(width));
 }
 // This is Data URI scheme: https://en.wikipedia.org/wiki/Data_URI_scheme
-json["Content"] = ("data:" +
+createDicomRequestContent["Content"] = ("data:" +
 std::string(usePam ? Orthanc::MIME_PAM : Orthanc::MIME_PNG) +
 ";base64," + base64);
-orthanc.PostJsonAsyncExpectJson(
-"/tools/create-dicom", json,
-new Callable<RadiographyScene, OrthancApiClient::JsonResponseReadyMessage>
-(*this, &RadiographyScene::OnDicomExported),
-NULL, NULL);
 }
 void RadiographyScene::OnDicomExported(const OrthancApiClient::JsonResponseReadyMessage& message)
 {
 {
 LOG(INFO) << "DICOMweb WADO-RS received: " << message.GetAnswerSize() << " bytes";
 const IWebService::HttpHeaders& h = message.GetAnswerHttpHeaders();
 for (IWebService::HttpHeaders::const_iterator
 it = h.begin(); it != h.end(); ++it)
 {
 printf("[%s] = [%s]\n", it->first.c_str(), it->second.c_str());
 }
 }

Mercurial > hg > orthanc-stone

comparison Framework/Radiography/RadiographyScene.cpp @ 426:660fe6f6bf4a am-vsol-upgrade