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

comparison Applications/StoneWebViewer/WebAssembly/StoneWebViewer.cpp @ 1813:53aa3f72b539

synchronization of annotations across viewports

author	Sebastien Jodogne <s.jodogne@gmail.com>
date	Tue, 25 May 2021 15:27:35 +0200
parents	db341679dc9f
children	53f3411bf94b

comparison

equal deleted inserted replaced

-:db341679dc9f
+:53aa3f72b539
 }
 }
+class StoneAnnotationsRegistry : public boost::noncopyable
+{
+private:
+class Index
+{
+private:
+std::string  sopInstanceUid_;
+size_t       frame_;
+public:
+Index(const std::string& sopInstanceUid,
+size_t frame) :
+sopInstanceUid_(sopInstanceUid),
+frame_(frame)
+{
+}
+const std::string& GetSopInstanceUid() const
+{
+return sopInstanceUid_;
+}
+size_t GetFrame() const
+{
+return frame_;
+}
+bool operator< (const Index& other) const
+{
+if (sopInstanceUid_ < other.sopInstanceUid_)
+{
+return true;
+}
+else if (sopInstanceUid_ > other.sopInstanceUid_)
+{
+return false;
+}
+else
+{
+return frame_ < other.frame_;
+}
+}
+};
+typedef std::map<Index, Json::Value*>  Content;
+Content  content_;
+void Clear()
+{
+for (Content::iterator it = content_.begin(); it != content_.end(); ++it)
+{
+assert(it->second != NULL);
+delete it->second;
+}
+content_.clear();
+}
+StoneAnnotationsRegistry()
+{
+}
+public:
+~StoneAnnotationsRegistry()
+{
+Clear();
+}
+static StoneAnnotationsRegistry& GetInstance()
+{
+static StoneAnnotationsRegistry singleton;
+return singleton;
+}
+void Save(const std::string& sopInstanceUid,
+size_t frame,
+const OrthancStone::AnnotationsSceneLayer& layer)
+{
+std::unique_ptr<Json::Value> serialized;
+layer.Serialize(*serialized);
+const Index index(sopInstanceUid, frame);
+Content::iterator found = content_.find(index);
+if (found == content_.end())
+{
+content_[index] = serialized.release();
+}
+else
+{
+assert(found->second != NULL);
+delete found->second;
+found->second = serialized.release();
+}
+}
+void Load(OrthancStone::AnnotationsSceneLayer& layer,
+const std::string& sopInstanceUid,
+size_t frame) const
+{
+const Index index(sopInstanceUid, frame);
+Content::const_iterator found = content_.find(index);
+if (found == content_.end())
+{
+layer.Clear();
+}
+else
+{
+assert(found->second != NULL);
+layer.Unserialize(*found->second);
+}
+}
+};
 class ViewerViewport : public OrthancStone::ObserverBase<ViewerViewport>
 {
 public:
-typedef std::map<std::string, boost::shared_ptr<Json::Value> >  StoneAnnotationsRegistry;
 class IObserver : public boost::noncopyable
 {
 public:
 virtual ~IObserver()
 {
 const OrthancStone::Vector& normal) = 0;
 virtual void SignalWindowingUpdated(const ViewerViewport& viewport,
 double windowingCenter,
 double windowingWidth) = 0;
+virtual void SignalStoneAnnotationsChanged(const ViewerViewport& viewport,
+const std::string& sopInstanceUid,
+size_t frame) = 0;
 };
 private:
 static const int LAYER_TEXTURE = 0;
 static const int LAYER_REFERENCE_LINES = 1;
 // The coordinates of Stone annotations are expressed in 2D
 // coordinates of the current texture, with (0,0) corresponding to
 // the center of the top-left pixel
 boost::shared_ptr<OrthancStone::AnnotationsSceneLayer>  stoneAnnotations_;
-boost::shared_ptr<StoneAnnotationsRegistry>             stoneAnnotationsRegistry_;
 void ScheduleNextPrefetch()
 {
 while (!prefetchQueue_.empty())
 }
 void RenderCurrentScene(const Orthanc::ImageAccessor& frame,
 const OrthancStone::DicomInstanceParameters& instance,
+size_t frameIndex,
 const OrthancStone::CoordinateSystem3D& plane)
 {
 /**
 * IMPORTANT - DO NOT use "instance.GetWidth()" and
 * "instance.GetHeight()" in this method. Use the information from
 annotationsOsiriX->AddLayer(factory.Create(annotation, plane));
 }
 }
 }
-if (stoneAnnotationsRegistry_.get() == NULL)
+StoneAnnotationsRegistry::GetInstance().Load(*stoneAnnotations_, instance.GetSopInstanceUid(), frameIndex);
-{
-stoneAnnotations_->Clear();
+{
-}
+std::unique_ptr<OrthancStone::IViewport::ILock> lock(viewport_->Lock());
-else
-{
+OrthancStone::Scene2D& scene = lock->GetController().GetScene();
-StoneAnnotationsRegistry::const_iterator found = stoneAnnotationsRegistry_->find(instance.GetSopInstanceUid());
-if (found == stoneAnnotationsRegistry_->end())
+scene.SetLayer(LAYER_TEXTURE, layer.release());
-{
-stoneAnnotations_->Clear();
+if (annotationsOsiriX.get() != NULL)
+{
+scene.SetLayer(LAYER_ANNOTATIONS_OSIRIX, annotationsOsiriX.release());
 }
 else
 {
-stoneAnnotations_->Unserialize(*found->second);
-}
-}
-{
-std::unique_ptr<OrthancStone::IViewport::ILock> lock(viewport_->Lock());
-OrthancStone::Scene2D& scene = lock->GetController().GetScene();
-scene.SetLayer(LAYER_TEXTURE, layer.release());
-if (annotationsOsiriX.get() != NULL)
-{
-scene.SetLayer(LAYER_ANNOTATIONS_OSIRIX, annotationsOsiriX.release());
-}
-else
-{
 scene.DeleteLayer(LAYER_ANNOTATIONS_OSIRIX);
 }
+stoneAnnotations_->Render(scene);  // Necessary for "FitContent()" to work
 if (fitNextContent_)
 {
 lock->RefreshCanvasSize();
 lock->GetCompositor().FitContent(scene);
+stoneAnnotations_->Render(scene);
 fitNextContent_ = false;
 }
-stoneAnnotations_->Render(scene);
 //lock->GetCompositor().Refresh(scene);
 lock->Invalidate();
 }
 }
 FramesCache::Accessor accessor(*framesCache_, instance.GetSopInstanceUid(), frameNumber);
 if (accessor.IsValid() &&
 accessor.GetQuality() == QUALITY_FULL)
 {
 // A high-res image was downloaded in between: Use this cached image instead of the low-res
-RenderCurrentScene(accessor.GetImage(), instance, plane);
+RenderCurrentScene(accessor.GetImage(), instance, frameNumber, plane);
 SetupPrefetchAfterRendering(frame, DisplayedFrameQuality_High);
 }
 else
 {
 // This frame is only available in low-res: Download the full DICOM
-RenderCurrentScene(frame, instance, plane);
+RenderCurrentScene(frame, instance, frameNumber, plane);
 SetupPrefetchAfterRendering(frame, quality);
 /**
 * The command "SetupPrefetchAfterRendering()" must be
 * after "SetupPrefetchAfterRendering(quality)", as the
 }
 else
 {
 assert(quality == DisplayedFrameQuality_High);
 SetupPrefetchAfterRendering(frame, quality);
-RenderCurrentScene(frame, instance, plane);
+RenderCurrentScene(frame, instance, frameNumber, plane);
 }
 }
 }
 }
 hasFocusOnInstance_(false),
 focusFrameNumber_(0),
 synchronizationOffset_(OrthancStone::LinearAlgebra::CreateVector(0, 0, 0)),
 synchronizationEnabled_(false),
 centralPhysicalWidth_(1),
-centralPhysicalHeight_(1),
+centralPhysicalHeight_(1)
-stoneAnnotationsRegistry_(NULL)
 {
 if (!framesCache_)
 {
 throw Orthanc::OrthancException(Orthanc::ErrorCode_NullPointer);
 }
 if (cursor_.get() != NULL &&
 frames_.get() != NULL)
 {
 const size_t cursorIndex = cursor_->GetCurrentIndex();
 const OrthancStone::DicomInstanceParameters& instance = frames_->GetInstanceOfFrame(cursorIndex);
+const size_t frameNumber = frames_->GetFrameNumberInInstance(cursorIndex);
-boost::shared_ptr<Json::Value> v(new Json::Value);
-stoneAnnotations_->Serialize(*v);
+StoneAnnotationsRegistry::GetInstance().Save(instance.GetSopInstanceUid(), frameNumber, *stoneAnnotations_);
-(*stoneAnnotationsRegistry_) [instance.GetSopInstanceUid()] = v;
+if (observer_.get() != NULL)
+{
+observer_->SignalStoneAnnotationsChanged(*this, instance.GetSopInstanceUid(), frameNumber);
+}
 }
 }
 }
 void Handle(const OrthancStone::ViewportController::SceneTransformChanged& message)
 const size_t frameNumber = frames_->GetFrameNumberInInstance(cursorIndex);
 FramesCache::Accessor accessor(*framesCache_, instance.GetSopInstanceUid(), frameNumber);
 if (accessor.IsValid())
 {
-RenderCurrentScene(accessor.GetImage(), instance, frames_->GetFrameGeometry(cursorIndex));
+RenderCurrentScene(accessor.GetImage(), instance, frameNumber, frames_->GetFrameGeometry(cursorIndex));
 DisplayedFrameQuality quality;
 if (accessor.GetQuality() < QUALITY_FULL)
 {
 OrthancStone::LinearAlgebra::AssignVector(synchronizationOffset_, 0, 0, 0);
 synchronizationEnabled_ = enabled;
 }
-void SetStoneAnnotationsRegistry(boost::shared_ptr<ViewerViewport::StoneAnnotationsRegistry>& registry)
+void SignalStoneAnnotationsChanged(const std::string& sopInstanceUid,
-{
+size_t frame)
-stoneAnnotationsRegistry_ = registry;
+{
+if (cursor_.get() != NULL &&
+frames_.get() != NULL)
+{
+const size_t cursorIndex = cursor_->GetCurrentIndex();
+const OrthancStone::DicomInstanceParameters& instance = frames_->GetInstanceOfFrame(cursorIndex);
+const size_t frameNumber = frames_->GetFrameNumberInInstance(cursorIndex);
+if (instance.GetSopInstanceUid() == sopInstanceUid &&
+frameNumber == frame)
+{
+StoneAnnotationsRegistry::GetInstance().Load(*stoneAnnotations_, instance.GetSopInstanceUid(), frame);
+{
+std::unique_ptr<OrthancStone::IViewport::ILock> lock(viewport_->Lock());
+stoneAnnotations_->Render(lock->GetController().GetScene());
+lock->Invalidate();
+}
+}
+}
 }
 };
 typedef std::map<std::string, boost::shared_ptr<ViewerViewport> >  Viewports;
 static Viewports allViewports_;
 static bool showReferenceLines_ = true;
 static boost::shared_ptr<OrthancStone::OsiriX::CollectionOfAnnotations>  osiriXAnnotations_;
-static boost::shared_ptr<ViewerViewport::StoneAnnotationsRegistry> stoneAnnotationsRegistry_;
 static void UpdateReferenceLines()
 {
 if (showReferenceLines_)
 static_cast<int>(boost::math::iround<double>(windowingCenter)),
 static_cast<int>(boost::math::iround<double>(windowingWidth)));
 UpdateReferenceLines();
 }
+virtual void SignalStoneAnnotationsChanged(const ViewerViewport& viewport,
+const std::string& sopInstanceUid,
+size_t frame) ORTHANC_OVERRIDE
+{
+for (Viewports::const_iterator it = allViewports_.begin(); it != allViewports_.end(); ++it)
+{
+assert(it->second.get() != NULL);
+if (it->second.get() != &viewport)
+{
+it->second->SignalStoneAnnotationsChanged(sopInstanceUid, frame);
+}
+}
+}
 };
 static OrthancStone::DicomSource source_;
 boost::shared_ptr<ViewerViewport> viewport(
 ViewerViewport::Create(*context_, source_, canvas, framesCache_, softwareRendering_));
 viewport->SetMouseButtonActions(leftButtonAction_, middleButtonAction_, rightButtonAction_);
 viewport->AcquireObserver(new WebAssemblyObserver);
 viewport->SetOsiriXAnnotations(osiriXAnnotations_);
-viewport->SetStoneAnnotationsRegistry(stoneAnnotationsRegistry_);
 allViewports_[canvas] = viewport;
 return viewport;
 }
 else
 {
 context_.reset(new OrthancStone::WebAssemblyLoadersContext(1, 4, 1));
 context_->SetDicomCacheSize(128 * 1024 * 1024);  // 128MB
 framesCache_.reset(new FramesCache);
 osiriXAnnotations_.reset(new OrthancStone::OsiriX::CollectionOfAnnotations);
-stoneAnnotationsRegistry_.reset(new ViewerViewport::StoneAnnotationsRegistry);
 {
 // TODO - TEST
 OrthancStone::AnnotationsSceneLayer l(0);
 l.AddSegmentAnnotation(OrthancStone::ScenePoint2D(0, 0),
 OrthancStone::ScenePoint2D(150, 40),
 OrthancStone::ScenePoint2D(200, 50));
 l.AddCircleAnnotation(OrthancStone::ScenePoint2D(50, 200),
 OrthancStone::ScenePoint2D(100, 250));
 l.SetActiveTool(OrthancStone::AnnotationsSceneLayer::Tool_Edit);
-boost::shared_ptr<Json::Value> s(new Json::Value);
+StoneAnnotationsRegistry::GetInstance().Save("1.2.840.113543.6.6.4.7.64234348190163144631511103849051737563212", 0, l);
-l.Serialize(*s);
-(*stoneAnnotationsRegistry_) ["1.2.840.113543.6.6.4.7.64234348190163144631511103849051737563212"] = s;
 }
 DISPATCH_JAVASCRIPT_EVENT("StoneInitialized");
 }

Mercurial > hg > orthanc-stone

comparison Applications/StoneWebViewer/WebAssembly/StoneWebViewer.cpp @ 1813:53aa3f72b539