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

comparison Applications/StoneWebViewer/WebAssembly/StoneWebViewer.cpp @ 2102:9f7604d6b581 deep-learning

integration mainline->deep-learning

author	Sebastien Jodogne <s.jodogne@gmail.com>
date	Tue, 14 Nov 2023 11:45:17 +0100
parents	fdb012c86a75 ec676dbe85ac
children	de049fd88697

comparison

equal deleted inserted replaced

-:a6d5373e471c
+:9f7604d6b581
 static const unsigned int DEFAULT_CINE_RATE = 30;
+class IFramesCollection : public boost::noncopyable
+{
+public:
+virtual ~IFramesCollection()
+{
+}
+virtual size_t GetFramesCount() const = 0;
+virtual const OrthancStone::DicomInstanceParameters& GetInstanceOfFrame(size_t frameIndex) const = 0;
+virtual unsigned int GetFrameNumberInInstance(size_t frameIndex) const = 0;
+virtual bool LookupFrame(size_t& frameIndex,
+const std::string& sopInstanceUid,
+unsigned int frameNumber) const = 0;
+virtual bool FindClosestFrame(size_t& frameIndex,
+const OrthancStone::Vector& point,
+double maximumDistance) const = 0;
+static OrthancStone::CoordinateSystem3D GetFrameGeometry(const IFramesCollection& frames,
+size_t frameIndex)
+{
+return frames.GetInstanceOfFrame(frameIndex).GetFrameGeometry(frames.GetFrameNumberInInstance(frameIndex));
+}
+};
+class SortedFramesCollection : public IFramesCollection
+{
+private:
+std::unique_ptr<OrthancStone::SortedFrames>  frames_;
+public:
+SortedFramesCollection(OrthancStone::SortedFrames* frames)
+{
+if (frames == NULL)
+{
+throw Orthanc::OrthancException(Orthanc::ErrorCode_NullPointer);
+}
+else
+{
+frames_.reset(frames);
+}
+}
+virtual size_t GetFramesCount() const ORTHANC_OVERRIDE
+{
+return frames_->GetFramesCount();
+}
+const OrthancStone::DicomInstanceParameters& GetInstanceOfFrame(size_t frameIndex) const ORTHANC_OVERRIDE
+{
+return frames_->GetInstanceOfFrame(frameIndex);
+}
+virtual unsigned int GetFrameNumberInInstance(size_t frameIndex) const ORTHANC_OVERRIDE
+{
+return frames_->GetFrameNumberInInstance(frameIndex);
+}
+virtual bool LookupFrame(size_t& frameIndex,
+const std::string& sopInstanceUid,
+unsigned int frameNumber) const ORTHANC_OVERRIDE
+{
+return frames_->LookupFrame(frameIndex, sopInstanceUid, frameNumber);
+}
+virtual bool FindClosestFrame(size_t& frameIndex,
+const OrthancStone::Vector& point,
+double maximumDistance) const ORTHANC_OVERRIDE
+{
+return frames_->FindClosestFrame(frameIndex, point, maximumDistance);
+};
+};
 class VirtualSeries : public boost::noncopyable
 {
 private:
 class Item : public boost::noncopyable
 {
 {
 return false;
 }
 }
-bool SortSeriesFrames(OrthancStone::SortedFrames& target,
+IFramesCollection* GetSeriesFrames(const std::string& seriesInstanceUid) const
-const std::string& seriesInstanceUid) const
 {
 OrthancStone::SeriesMetadataLoader::Accessor accessor(*metadataLoader_, seriesInstanceUid);
 if (accessor.IsComplete())
 {
-target.Clear();
+std::unique_ptr<OrthancStone::SortedFrames> target(new OrthancStone::SortedFrames);
+target->Clear();
 for (size_t i = 0; i < accessor.GetInstancesCount(); i++)
 {
-target.AddInstance(accessor.GetInstance(i));
+target->AddInstance(accessor.GetInstance(i));
 }
-target.Sort();
+target->Sort();
-return true;
+return new SortedFramesCollection(target.release());
 }
 else
 {
-return false;
+return NULL;
 }
 }
-bool SortVirtualSeriesFrames(OrthancStone::SortedFrames& target,
+IFramesCollection* GetVirtualSeriesFrames(const std::string& virtualSeriesId) const
-const std::string& virtualSeriesId) const
 {
 const std::string& seriesInstanceUid = virtualSeries_.GetSeriesInstanceUid(virtualSeriesId);
 OrthancStone::SeriesMetadataLoader::Accessor accessor(*metadataLoader_, seriesInstanceUid);
 if (accessor.IsComplete())
 {
 const std::list<std::string>& sopInstanceUids = virtualSeries_.GetSopInstanceUids(virtualSeriesId);
-target.Clear();
+std::unique_ptr<OrthancStone::SortedFrames> target(new OrthancStone::SortedFrames);
+target->Clear();
 for (std::list<std::string>::const_iterator
 it = sopInstanceUids.begin(); it != sopInstanceUids.end(); ++it)
 {
 Orthanc::DicomMap instance;
 if (accessor.LookupInstance(instance, *it))
 {
-target.AddInstance(instance);
+target->AddInstance(instance);
 }
 else
 {
 LOG(ERROR) << "Missing instance: " << *it;
 }
 }
-target.Sort();
+target->Sort();
-return true;
+return new SortedFramesCollection(target.release());
 }
 else
 {
-return false;
+return NULL;
 }
 }
 size_t GetSeriesNumberOfFrames(const std::string& seriesInstanceUid) const
 {
 };
 };
 class ViewerViewport : public OrthancStone::ObserverBase<ViewerViewport>
 {
 public:
 class IObserver : public boost::noncopyable
 {
 class SetFullDicomFrame : public ICommand
 {
 private:
+std::string   studyInstanceUid_;
+std::string   seriesInstanceUid_;
 std::string   sopInstanceUid_;
 unsigned int  frameNumber_;
 int           priority_;
 bool          isPrefetch_;
 bool          serverSideTranscoding_;
 public:
 SetFullDicomFrame(boost::shared_ptr<ViewerViewport> viewport,
+const std::string& studyInstanceUid,
+const std::string& seriesInstanceUid,
 const std::string& sopInstanceUid,
 unsigned int frameNumber,
 int priority,
 bool isPrefetch,
 bool serverSideTranscoding) :
 ICommand(viewport),
+studyInstanceUid_(studyInstanceUid),
+seriesInstanceUid_(seriesInstanceUid),
 sopInstanceUid_(sopInstanceUid),
 frameNumber_(frameNumber),
 priority_(priority),
 isPrefetch_(isPrefetch),
 serverSideTranscoding_(serverSideTranscoding)
 if (!serverSideTranscoding_)
 {
 // If we haven't tried server-side rendering yet, give it a try
 LOG(INFO) << "Switching to server-side transcoding";
 GetViewport().serverSideTranscoding_ = true;
-GetViewport().ScheduleLoadFullDicomFrame(sopInstanceUid_, frameNumber_, priority_, isPrefetch_);
+GetViewport().ScheduleLoadFullDicomFrame(studyInstanceUid_, seriesInstanceUid_, sopInstanceUid_, frameNumber_, priority_, isPrefetch_);
 }
 return;
 }
 else
 {
 OrthancStone::WebAssemblyLoadersContext&               context_;
 boost::shared_ptr<OrthancStone::WebAssemblyViewport>   viewport_;
 boost::shared_ptr<OrthancStone::DicomResourcesLoader> loader_;
 OrthancStone::DicomSource                    source_;
 boost::shared_ptr<FramesCache>               framesCache_;
-std::unique_ptr<OrthancStone::SortedFrames>  frames_;
+std::unique_ptr<IFramesCollection>           frames_;
 std::unique_ptr<SeriesCursor>                cursor_;
 float                                        windowingCenter_;
 float                                        windowingWidth_;
 std::vector<float>                           windowingPresetCenters_;
 std::vector<float>                           windowingPresetWidths_;
 // Only change the scene if the loaded frame still corresponds to the current cursor
 if (instance.GetSopInstanceUid() == loadedSopInstanceUid &&
 frameNumber == loadedFrameNumber)
 {
-const OrthancStone::CoordinateSystem3D plane = frames_->GetFrameGeometry(cursorIndex);
+const OrthancStone::CoordinateSystem3D plane = IFramesCollection::GetFrameGeometry(*frames_, cursorIndex);
 if (quality == DisplayedFrameQuality_Low)
 {
 FramesCache::Accessor accessor(*framesCache_, instance.GetSopInstanceUid(), frameNumber);
 if (accessor.IsValid() &&
 }
 }
 }
 }
-void ScheduleLoadFullDicomFrame(const std::string& sopInstanceUid,
+void ScheduleLoadFullDicomFrame(const std::string& studyInstanceUid,
+const std::string& seriesInstanceUid,
+const std::string& sopInstanceUid,
 unsigned int frameNumber,
 int priority,
 bool isPrefetch)
 {
 if (frames_.get() != NULL)
 {
 std::unique_ptr<OrthancStone::ILoadersContext::ILock> lock(context_.Lock());
 lock->Schedule(
 GetSharedObserver(), priority, OrthancStone::ParseDicomFromWadoCommand::Create(
-source_, frames_->GetStudyInstanceUid(), frames_->GetSeriesInstanceUid(),
+source_, studyInstanceUid, seriesInstanceUid, sopInstanceUid, serverSideTranscoding_,
-sopInstanceUid, serverSideTranscoding_,
 Orthanc::DicomTransferSyntax_LittleEndianExplicit,
-new SetFullDicomFrame(GetSharedObserver(), sopInstanceUid, frameNumber, priority, isPrefetch, serverSideTranscoding_)));
+new SetFullDicomFrame(GetSharedObserver(), studyInstanceUid, seriesInstanceUid,
+sopInstanceUid, frameNumber, priority, isPrefetch, serverSideTranscoding_)));
 }
 }
 void ScheduleLoadFullDicomFrame(size_t cursorIndex,
 int priority,
 bool isPrefetch)
 {
 if (frames_.get() != NULL)
 {
+std::string studyInstanceUid = frames_->GetInstanceOfFrame(cursorIndex).GetStudyInstanceUid();
+std::string seriesInstanceUid = frames_->GetInstanceOfFrame(cursorIndex).GetSeriesInstanceUid();
 std::string sopInstanceUid = frames_->GetInstanceOfFrame(cursorIndex).GetSopInstanceUid();
 unsigned int frameNumber = frames_->GetFrameNumberInInstance(cursorIndex);
-ScheduleLoadFullDicomFrame(sopInstanceUid, frameNumber, priority, isPrefetch);
+ScheduleLoadFullDicomFrame(studyInstanceUid, seriesInstanceUid, sopInstanceUid, frameNumber, priority, isPrefetch);
 }
 }
 void ScheduleLoadRenderedFrame(size_t cursorIndex,
 int priority,
 }
 bool isMonochrome1 = (instance.GetImageInformation().GetPhotometricInterpretation() ==
 Orthanc::PhotometricInterpretation_Monochrome1);
-const std::string uri = ("studies/" + frames_->GetStudyInstanceUid() +
+const std::string uri = ("studies/" + instance.GetStudyInstanceUid() +
-"/series/" + frames_->GetSeriesInstanceUid() +
+"/series/" + instance.GetSeriesInstanceUid() +
 "/instances/" + instance.GetSopInstanceUid() +
 "/frames/" + boost::lexical_cast<std::string>(frameNumber + 1) + "/rendered");
 std::map<std::string, std::string> headers, arguments;
 // arguments["quality"] = "10";   // Low-level quality for test purpose
 lock->Invalidate();
 }
 }
 ViewerViewport(OrthancStone::WebAssemblyLoadersContext& context,
 const OrthancStone::DicomSource& source,
 const std::string& canvas,
 boost::shared_ptr<FramesCache> cache,
 bool softwareRendering,
 if (that.synchronizationEnabled_)
 {
 const size_t currentCursorIndex = that.cursor_->GetCurrentIndex();
-const OrthancStone::CoordinateSystem3D current =
+const OrthancStone::CoordinateSystem3D current = IFramesCollection::GetFrameGeometry(*that.frames_, currentCursorIndex);
-that.frames_->GetFrameGeometry(currentCursorIndex);
 if (isShift &&
 previousCursorIndex != currentCursorIndex)
 {
-const OrthancStone::CoordinateSystem3D previous =
+const OrthancStone::CoordinateSystem3D previous = IFramesCollection::GetFrameGeometry(*that.frames_, previousCursorIndex);
-that.frames_->GetFrameGeometry(previousCursorIndex);
 that.synchronizationOffset_ += previous.GetOrigin() - current.GetOrigin();
 }
 that.observer_->SignalSynchronizedBrowsing(
 that, current.GetOrigin() + that.synchronizationOffset_, current.GetNormal());
 }
 return viewport;
 }
-void SetFrames(OrthancStone::SortedFrames* frames)
+void SetFrames(IFramesCollection* frames)
 {
 if (frames == NULL)
 {
 throw Orthanc::OrthancException(Orthanc::ErrorCode_NullPointer);
 }
 uid != OrthancStone::SopClassUid_RTPlan &&
 uid != OrthancStone::SopClassUid_RTStruct &&
 GetSeriesThumbnailType(uid) != OrthancStone::SeriesThumbnailType_Video)
 {
 // Fetch the details of the series from the central instance
-const std::string uri = ("studies/" + frames_->GetStudyInstanceUid() +
+const std::string uri = ("studies/" + centralInstance.GetStudyInstanceUid() +
-"/series/" + frames_->GetSeriesInstanceUid() +
+"/series/" + centralInstance.GetSeriesInstanceUid() +
 "/instances/" + centralInstance.GetSopInstanceUid() + "/metadata");
 loader_->ScheduleGetDicomWeb(
 boost::make_shared<OrthancStone::LoadedDicomResources>(Orthanc::DICOM_TAG_SOP_INSTANCE_UID),
 0, source_, uri, new LoadSeriesDetailsFromInstance(GetSharedObserver()));
 const unsigned int frameNumber = frames_->GetFrameNumberInInstance(cursorIndex);
 FramesCache::Accessor accessor(*framesCache_, instance.GetSopInstanceUid(), frameNumber);
 if (accessor.IsValid())
 {
-RenderCurrentScene(accessor.GetImage(), instance, frameNumber, frames_->GetFrameGeometry(cursorIndex));
+RenderCurrentScene(accessor.GetImage(), instance, frameNumber, IFramesCollection::GetFrameGeometry(*frames_, cursorIndex));
 DisplayedFrameQuality quality;
 if (accessor.GetQuality() < QUALITY_FULL)
 {
 bool GetCurrentPlane(OrthancStone::CoordinateSystem3D& plane) const
 {
 if (cursor_.get() != NULL &&
 frames_.get() != NULL)
 {
-plane = frames_->GetFrameGeometry(cursor_->GetCurrentIndex());
+plane = IFramesCollection::GetFrameGeometry(*frames_, cursor_->GetCurrentIndex());
 return true;
 }
 else
 {
 return false;
 void SetWindowingPreset()
 {
 assert(windowingPresetCenters_.size() == windowingPresetWidths_.size());
 if (windowingPresetCenters_.empty())
 {
 SetWindowing(128, 256);
 }
 else
 frames_.get() != NULL &&
 cursor_.get() != NULL)
 {
 const size_t currentCursorIndex = cursor_->GetCurrentIndex();
-const OrthancStone::CoordinateSystem3D current =
+const OrthancStone::CoordinateSystem3D current = IFramesCollection::GetFrameGeometry(*frames_, currentCursorIndex);
-frames_->GetFrameGeometry(currentCursorIndex);
 observer_->SignalSynchronizedBrowsing(
 *this, current.GetOrigin() + synchronizationOffset_, current.GetNormal());
 }
 }
 int LoadSeriesInViewport(const char* canvas,
 const char* seriesInstanceUid)
 {
 try
 {
-std::unique_ptr<OrthancStone::SortedFrames> frames(new OrthancStone::SortedFrames);
+std::unique_ptr<IFramesCollection> frames(GetResourcesLoader().GetSeriesFrames(seriesInstanceUid));
-if (GetResourcesLoader().SortSeriesFrames(*frames, seriesInstanceUid))
+if (frames.get() != NULL)
 {
 GetViewport(canvas)->SetFrames(frames.release());
 return 1;
 }
 else
 int LoadVirtualSeriesInViewport(const char* canvas,
 const char* virtualSeriesId)
 {
 try
 {
-std::unique_ptr<OrthancStone::SortedFrames> frames(new OrthancStone::SortedFrames);
+std::unique_ptr<IFramesCollection> frames(GetResourcesLoader().GetVirtualSeriesFrames(virtualSeriesId));
-if (GetResourcesLoader().SortVirtualSeriesFrames(*frames, virtualSeriesId))
+if (frames.get() != NULL)
 {
 GetViewport(canvas)->SetFrames(frames.release());
 return 1;
 }
 else

Mercurial > hg > orthanc-stone

comparison Applications/StoneWebViewer/WebAssembly/StoneWebViewer.cpp @ 2102:9f7604d6b581 deep-learning