orthanc-stone: Applications/StoneWebViewer/WebAssembly/StoneWebViewer.cpp comparison

comparison Applications/StoneWebViewer/WebAssembly/StoneWebViewer.cpp @ 1924:f4050908c6bc

display of overlays

author	Sebastien Jodogne <s.jodogne@gmail.com>
date	Wed, 23 Mar 2022 12:24:35 +0100
parents	bd527bbc34df
children	a7a77488ddb1

comparison

equal deleted inserted replaced

-:f4cdcba8c32a
+:f4050908c6bc
 }
 };
+class OverlaysRegistry : public boost::noncopyable
+{
+private:
+typedef std::map<std::string, OrthancStone::LookupTableTextureSceneLayer*>  Content;
+Content  content_;
+public:
+~OverlaysRegistry()
+{
+for (Content::iterator it = content_.begin(); it != content_.end(); ++it)
+{
+assert(it->second != NULL);
+delete it->second;
+}
+}
+static OverlaysRegistry& GetInstance()
+{
+static OverlaysRegistry singleton;
+return singleton;
+}
+void Register(const std::string& sopInstanceUid,
+const OrthancStone::DicomInstanceParameters& parameters,
+int overlayX,
+int overlayY,
+const Orthanc::ImageAccessor& overlay)
+{
+// Don't register twice the same overlay
+Content::iterator found = content_.find(sopInstanceUid);
+if (found == content_.end())
+{
+content_[sopInstanceUid] = parameters.CreateOverlayTexture(overlayX, overlayY, overlay);
+}
+}
+class Accessor : public boost::noncopyable
+{
+private:
+const OrthancStone::LookupTableTextureSceneLayer* texture_;
+public:
+Accessor(const OverlaysRegistry& registry,
+const std::string& sopInstanceUid)
+{
+Content::const_iterator found = registry.content_.find(sopInstanceUid);
+if (found == registry.content_.end())
+{
+texture_ = NULL;
+}
+else
+{
+assert(found->second != NULL);
+texture_ = found->second;
+}
+}
+bool IsValid() const
+{
+return texture_ != NULL;
+}
+OrthancStone::LookupTableTextureSceneLayer* CreateTexture() const
+{
+if (texture_ == NULL)
+{
+throw Orthanc::OrthancException(Orthanc::ErrorCode_BadSequenceOfCalls);
+}
+else
+{
+return dynamic_cast<OrthancStone::LookupTableTextureSceneLayer*>(texture_->Clone());
+}
+}
+};
+};
 class ViewerViewport : public OrthancStone::ObserverBase<ViewerViewport>
 {
 public:
 class IObserver : public boost::noncopyable
 {
 virtual void SignalStoneAnnotationRemoved(const ViewerViewport& viewport) = 0;
 };
 private:
 static const int LAYER_TEXTURE = 0;
-static const int LAYER_REFERENCE_LINES = 1;
+static const int LAYER_OVERLAY = 1;
-static const int LAYER_ANNOTATIONS_OSIRIX = 2;
+static const int LAYER_REFERENCE_LINES = 2;
-static const int LAYER_ANNOTATIONS_STONE = 3;
+static const int LAYER_ANNOTATIONS_OSIRIX = 3;
+static const int LAYER_ANNOTATIONS_STONE = 4;
 class ICommand : public Orthanc::IDynamicObject
 {
 private:
 std::unique_ptr<Orthanc::ImageAccessor> frameProtection(f);
 Orthanc::DicomMap tags;
 dicom.ExtractDicomSummary(tags, ORTHANC_STONE_MAX_TAG_LENGTH);
+OrthancStone::DicomInstanceParameters parameters(tags);
 std::unique_ptr<Orthanc::ImageAccessor> converted;
 if (frameProtection->GetFormat() == Orthanc::PixelFormat_RGB24)
 {
 converted.reset(frameProtection.release());
 }
 else
 {
-double a = 1;
-double b = 0;
-double doseScaling;
-if (tags.ParseDouble(doseScaling, Orthanc::DICOM_TAG_DOSE_GRID_SCALING))
-{
-a = doseScaling;
-}
-double rescaleIntercept, rescaleSlope;
-dicom.GetRescale(rescaleIntercept, rescaleSlope, frameNumber);
-a *= rescaleSlope;
-b = rescaleIntercept;
 converted.reset(new Orthanc::Image(Orthanc::PixelFormat_Float32, frameProtection->GetWidth(), frameProtection->GetHeight(), false));
 Orthanc::ImageProcessing::Convert(*converted, *frameProtection);
-Orthanc::ImageProcessing::ShiftScale2(*converted, b, a, false);
+parameters.ApplyRescaleAndDoseScaling(*converted, false /* don't use double */);
 }
+try
+{
+int x, y;
+std::unique_ptr<Orthanc::ImageAccessor> overlay(dicom.DecodeAllOverlays(x, y));
+if (overlay.get() != NULL &&
+overlay->GetWidth() > 0 &&
+overlay->GetHeight() > 0)
+{
+OverlaysRegistry::GetInstance().Register(sopInstanceUid, parameters, x, y, *overlay);
+}
+}
+catch (Orthanc::OrthancException& e)
+{
+LOG(ERROR) << "Cannot decode overlays from instance " << sopInstanceUid;
+}
 assert(converted.get() != NULL);
 viewport.RenderCurrentSceneFromCommand(*converted, sopInstanceUid, frameNumber, DisplayedFrameQuality_High);
 viewport.framesCache_->Acquire(sopInstanceUid, frameNumber, converted.release(), QUALITY_FULL);
 }
 };
 else
 {
 layer->SetPixelSpacing(pixelSpacingX, pixelSpacingY);
 }
+std::unique_ptr<OrthancStone::LookupTableTextureSceneLayer> overlay;
+{
+OverlaysRegistry::Accessor accessor(OverlaysRegistry::GetInstance(), instance.GetSopInstanceUid());
+if (accessor.IsValid())
+{
+overlay.reset(accessor.CreateTexture());
+overlay->SetFlipX(flipX_);
+overlay->SetFlipY(flipY_);
+}
+}
 std::unique_ptr<OrthancStone::MacroSceneLayer>  annotationsOsiriX;
 if (osiriXAnnotations_)
 {
 std::set<size_t> a;
 std::unique_ptr<OrthancStone::IViewport::ILock> lock(viewport_->Lock());
 OrthancStone::Scene2D& scene = lock->GetController().GetScene();
 scene.SetLayer(LAYER_TEXTURE, layer.release());
+if (overlay.get() != NULL)
+{
+scene.SetLayer(LAYER_OVERLAY, overlay.release());
+}
+else
+{
+scene.DeleteLayer(LAYER_OVERLAY);
+}
 if (annotationsOsiriX.get() != NULL)
 {
 scene.SetLayer(LAYER_ANNOTATIONS_OSIRIX, annotationsOsiriX.release());
 }
 {
 OrthancStone::TextureBaseSceneLayer& layer =
 dynamic_cast<OrthancStone::TextureBaseSceneLayer&>(
 lock->GetController().GetScene().GetLayer(LAYER_TEXTURE));
+layer.SetFlipX(flipX_);
+layer.SetFlipY(flipY_);
+}
+{
+OrthancStone::TextureBaseSceneLayer& layer =
+dynamic_cast<OrthancStone::TextureBaseSceneLayer&>(
+lock->GetController().GetScene().GetLayer(LAYER_OVERLAY));
 layer.SetFlipX(flipX_);
 layer.SetFlipY(flipY_);
 }

Mercurial > hg > orthanc-stone

comparison Applications/StoneWebViewer/WebAssembly/StoneWebViewer.cpp @ 1924:f4050908c6bc