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

comparison Applications/StoneWebViewer/WebAssembly/StoneWebViewer.cpp @ 1849:023cce3d7844

introduction of the concept of "virtual series"

author	Sebastien Jodogne <s.jodogne@gmail.com>
date	Tue, 29 Jun 2021 12:12:46 +0200
parents	21ccc00839f7
children	932dc2265baa

comparison

equal deleted inserted replaced

-:3751485f1b2e
+:023cce3d7844
 static const unsigned int QUALITY_FULL = 1;
 static const unsigned int DEFAULT_CINE_RATE = 30;
+class VirtualSeries : public boost::noncopyable
+{
+private:
+class Item
+{
+private:
+std::string   seriesInstanceUid_;
+unsigned int  numberOfFrames_;
+public:
+Item(const std::string& seriesInstanceUid,
+unsigned int numberOfFrames) :
+seriesInstanceUid_(seriesInstanceUid),
+numberOfFrames_(numberOfFrames)
+{
+if (numberOfFrames == 0)
+{
+throw Orthanc::OrthancException(Orthanc::ErrorCode_ParameterOutOfRange);
+}
+}
+const std::string& GetSeriesInstanceUid() const
+{
+return seriesInstanceUid_;
+}
+unsigned int GetNumberOfFrames() const
+{
+return numberOfFrames_;
+}
+};
+typedef std::map<std::string, Item>  Content;
+Content  content_;
+const Item& GetItem(const std::string& id) const
+{
+Content::const_iterator found = content_.find(id);
+if (found == content_.end())
+{
+throw Orthanc::OrthancException(Orthanc::ErrorCode_ParameterOutOfRange);
+}
+else
+{
+return found->second;
+}
+}
+public:
+std::string Add(const std::string& seriesInstanceUid,
+const std::string& sopInstanceUid,
+unsigned int numberOfFrames)
+{
+if (content_.find(sopInstanceUid) != content_.end())
+{
+throw Orthanc::OrthancException(Orthanc::ErrorCode_ParameterOutOfRange);
+}
+else
+{
+content_.insert(std::make_pair(sopInstanceUid, Item(seriesInstanceUid, numberOfFrames)));
+return sopInstanceUid;
+}
+}
+const std::string& GetSeriesInstanceUid(const std::string& id) const
+{
+return GetItem(id).GetSeriesInstanceUid();
+}
+unsigned int GetNumberOfFrames(const std::string& id) const
+{
+return GetItem(id).GetNumberOfFrames();
+}
+};
 class ResourcesLoader : public OrthancStone::ObserverBase<ResourcesLoader>
 {
 public:
 class IObserver : public boost::noncopyable
 {
 virtual void SignalSeriesPdfLoaded(const std::string& studyInstanceUid,
 const std::string& seriesInstanceUid,
 const std::string& pdf) = 0;
-virtual void SignalMultiframeInstanceThumbnailLoaded(const std::string& sopInstanceUid,
+virtual void SignalVirtualSeriesThumbnailLoaded(const std::string& virtualSeriesId,
 const std::string& jpeg) = 0;
 };
 private:
 OrthancStone::ILoadersContext&                           context_;
 std::unique_ptr<IObserver>                               observer_;
 boost::shared_ptr<OrthancStone::LoadedDicomResources>    studies_;
 boost::shared_ptr<OrthancStone::LoadedDicomResources>    series_;
 boost::shared_ptr<OrthancStone::DicomResourcesLoader>    resourcesLoader_;
 boost::shared_ptr<OrthancStone::SeriesThumbnailsLoader>  thumbnailsLoader_;
 boost::shared_ptr<OrthancStone::SeriesMetadataLoader>    metadataLoader_;
-std::set<std::string>                                    scheduledMultiframeInstances_;
+std::set<std::string>                                    scheduledVirtualSeriesThumbnails_;
 explicit ResourcesLoader(OrthancStone::ILoadersContext& context,
 const OrthancStone::DicomSource& source) :
 context_(context),
 source_(source),
 LOG(ERROR) << "Unable to extract PDF from series: " << info.GetSeriesInstanceUid();
 }
 }
 }
-void FetchInstanceThumbnail(const std::string& studyInstanceUid,
+void FetchVirtualSeriesThumbnail(const std::string& virtualSeriesId,
-const std::string& seriesInstanceUid,
+const std::string& studyInstanceUid,
-const std::string& sopInstanceUid)
+const std::string& seriesInstanceUid,
-{
+const std::string& sopInstanceUid)
-if (scheduledMultiframeInstances_.find(sopInstanceUid) == scheduledMultiframeInstances_.end())
+{
-{
+if (scheduledVirtualSeriesThumbnails_.find(virtualSeriesId) == scheduledVirtualSeriesThumbnails_.end())
-scheduledMultiframeInstances_.insert(sopInstanceUid);
+{
+scheduledVirtualSeriesThumbnails_.insert(virtualSeriesId);
 std::map<std::string, std::string> arguments;
 std::map<std::string, std::string> headers;
 arguments["viewport"] = (
 boost::lexical_cast<std::string>(thumbnailsLoader_->GetThumbnailWidth()) + "," +
 {
 std::unique_ptr<OrthancStone::ILoadersContext::ILock> lock(context_.Lock());
 lock->Schedule(
 GetSharedObserver(), PRIORITY_LOW + 2, source_.CreateDicomWebCommand(
-uri, arguments, headers, new Orthanc::SingleValueObject<std::string>(sopInstanceUid)));
+uri, arguments, headers, new Orthanc::SingleValueObject<std::string>(virtualSeriesId)));
 }
 }
 }
 void HandleInstanceThumbnail(const OrthancStone::HttpCommand::SuccessMessage& message)
 {
 if (observer_.get() != NULL)
 {
-const std::string& sopInstanceUid =
+const std::string& virtualSeriesId =
 dynamic_cast<const Orthanc::SingleValueObject<std::string>&>(
 message.GetOrigin().GetPayload()).GetValue();
-observer_->SignalMultiframeInstanceThumbnailLoaded(sopInstanceUid, message.GetAnswer());
+observer_->SignalVirtualSeriesThumbnailLoaded(virtualSeriesId, message.GetAnswer());
 }
 }
 public:
 static boost::shared_ptr<ResourcesLoader> Create(OrthancStone::ILoadersContext::ILock& lock,
 {
 OrthancStone::SeriesMetadataLoader::Accessor accessor(*metadataLoader_, seriesInstanceUid);
 return accessor.IsComplete();
 }
-bool LookupMultiframeSeries(std::map<std::string, unsigned int>& numberOfFramesPerInstance,
+bool LookupVirtualSeries(VirtualSeries& target /* out */,
-const std::string& seriesInstanceUid)
+std::set<std::string>& virtualSeriesIds /* out */,
-{
+const std::string& seriesInstanceUid)
-numberOfFramesPerInstance.clear();
+{
 OrthancStone::SeriesMetadataLoader::Accessor accessor(*metadataLoader_, seriesInstanceUid);
 if (accessor.IsComplete() &&
 accessor.GetInstancesCount() >= 2)
 {
-bool isMultiframe = false;
+bool hasMultiframe = false;
 for (size_t i = 0; i < accessor.GetInstancesCount(); i++)
 {
 OrthancStone::DicomInstanceParameters p(accessor.GetInstance(i));
-numberOfFramesPerInstance[p.GetSopInstanceUid()] = p.GetNumberOfFrames();
 if (p.GetNumberOfFrames() > 1)
 {
-isMultiframe = true;
+hasMultiframe = true;
 }
 }
-if (isMultiframe)
+if (hasMultiframe)
 {
 for (size_t i = 0; i < accessor.GetInstancesCount(); i++)
 {
 OrthancStone::DicomInstanceParameters p(accessor.GetInstance(i));
-FetchInstanceThumbnail(p.GetStudyInstanceUid(), p.GetSeriesInstanceUid(), p.GetSopInstanceUid());
+std::string virtualSeriesId = target.Add(seriesInstanceUid, p.GetSopInstanceUid(), p.GetNumberOfFrames());
+virtualSeriesIds.insert(virtualSeriesId);
+FetchVirtualSeriesThumbnail(virtualSeriesId, p.GetStudyInstanceUid(), p.GetSeriesInstanceUid(), p.GetSopInstanceUid());
 }
-}
+return true;
-return isMultiframe;
+}
+else
+{
+return false;
+}
 }
 else
 {
 return false;
 }
 pdf.empty() ? 0 : reinterpret_cast<intptr_t>(pdf.c_str()),  // Explicit conversion to an integer
 pdf.size());
 }
-virtual void SignalMultiframeInstanceThumbnailLoaded(const std::string& sopInstanceUid,
+virtual void SignalVirtualSeriesThumbnailLoaded(const std::string& virtualSeriesId,
 const std::string& jpeg) ORTHANC_OVERRIDE
 {
 std::string dataUriScheme;
 Orthanc::Toolbox::EncodeDataUriScheme(dataUriScheme, "image/jpeg", jpeg);
 EM_ASM({
 const customEvent = document.createEvent("CustomEvent");
-customEvent.initCustomEvent("MultiframeInstanceThumbnailLoaded", false, false,
+customEvent.initCustomEvent("VirtualSeriesThumbnailLoaded", false, false,
-{ "sopInstanceUid" : UTF8ToString($0),
+{ "virtualSeriesId" : UTF8ToString($0),
 "thumbnail" : UTF8ToString($1) });
 window.dispatchEvent(customEvent);
 },
-sopInstanceUid.c_str(),
+virtualSeriesId.c_str(),
 dataUriScheme.c_str());
 }
 virtual void SignalWindowingUpdated(const ViewerViewport& viewport,
 double windowingCenter,
 static std::string stringBuffer_;
 static bool softwareRendering_ = false;
 static WebViewerAction leftButtonAction_ = WebViewerAction_Windowing;
 static WebViewerAction middleButtonAction_ = WebViewerAction_Pan;
 static WebViewerAction rightButtonAction_ = WebViewerAction_Zoom;
+static VirtualSeries virtualSeries_;
 static void FormatTags(std::string& target,
 const Orthanc::DicomMap& tags)
 {
 return 0;
 }
 EMSCRIPTEN_KEEPALIVE
-int LoadMultipartInstanceInViewport(const char* canvas,
+int LoadVirtualSeriesInViewport(const char* canvas,
-const char* seriesInstanceUid,
+const char* virtualSeriesId)
-const char* sopInstanceUid)
 {
 try
 {
 std::unique_ptr<OrthancStone::SortedFrames> frames(new OrthancStone::SortedFrames);
+const std::string sopInstanceUid = virtualSeriesId;  // TODO
-if (GetResourcesLoader().SortMultipartInstanceFrames(*frames, seriesInstanceUid, sopInstanceUid))
+if (GetResourcesLoader().SortMultipartInstanceFrames(
+*frames, virtualSeries_.GetSeriesInstanceUid(virtualSeriesId), sopInstanceUid))
 {
 GetViewport(canvas)->SetFrames(frames.release());
 return 1;
 }
 else
 EXTERN_CATCH_EXCEPTIONS;
 }
 EMSCRIPTEN_KEEPALIVE
-int LoadMultiframeInstancesFromSeries(const char* seriesInstanceUid)
+int LookupVirtualSeries(const char* seriesInstanceUid)
 {
 try
 {
-std::map<std::string, unsigned int> numberOfFramesPerInstance;
+std::set<std::string> virtualSeriesIds;
-if (GetResourcesLoader().LookupMultiframeSeries(numberOfFramesPerInstance, seriesInstanceUid))
+if (GetResourcesLoader().LookupVirtualSeries(virtualSeries_, virtualSeriesIds, seriesInstanceUid))
 {
-Json::Value json = Json::objectValue;
+Json::Value json = Json::arrayValue;
-for (std::map<std::string, unsigned int>::const_iterator it =
+for (std::set<std::string>::const_iterator it = virtualSeriesIds.begin();
-numberOfFramesPerInstance.begin(); it != numberOfFramesPerInstance.end(); ++it)
+it != virtualSeriesIds.end(); ++it)
 {
-json[it->first] = it->second;
+Json::Value item = Json::objectValue;
+item["ID"] = *it;
+item["NumberOfFrames"] = virtualSeries_.GetNumberOfFrames(*it);
+json.append(item);
 }
 stringBuffer_ = json.toStyledString();
 return true;
 }

Mercurial > hg > orthanc-stone

comparison Applications/StoneWebViewer/WebAssembly/StoneWebViewer.cpp @ 1849:023cce3d7844