orthanc-stone: Samples/Sdl/Loader.cpp comparison

comparison Samples/Sdl/Loader.cpp @ 796:d3197e0e321d

DicomStructureSetLoader is working

author	Sebastien Jodogne <s.jodogne@gmail.com>
date	Tue, 28 May 2019 14:09:46 +0200
parents	bc20e4c417ec
children	f38c1fc08655

comparison

equal deleted inserted replaced

-:bc20e4c417ec
+:d3197e0e321d
+// TODO - Refactor using LoaderStateMachine?
 class OrthancSeriesVolumeProgressiveLoader :
 public IObserver,
 public IObservable,
 public IVolumeSlicer
 {
 T& GetLoader() const
 {
 return dynamic_cast<T&>(that_);
 }
-virtual void Handle(const OrthancRestApiCommand::SuccessMessage& message) const
+virtual void Handle(const OrthancRestApiCommand::SuccessMessage& message)
 {
 throw Orthanc::OrthancException(Orthanc::ErrorCode_NotImplemented);
 }
-virtual void Handle(const GetOrthancImageCommand::SuccessMessage& message) const
+virtual void Handle(const GetOrthancImageCommand::SuccessMessage& message)
 {
 throw Orthanc::OrthancException(Orthanc::ErrorCode_NotImplemented);
 }
-virtual void Handle(const GetOrthancWebViewerJpegCommand::SuccessMessage& message) const
+virtual void Handle(const GetOrthancWebViewerJpegCommand::SuccessMessage& message)
 {
 throw Orthanc::OrthancException(Orthanc::ErrorCode_NotImplemented);
 }
 };
 for (PendingCommands::iterator it = pendingCommands_.begin();
 it != pendingCommands_.end(); ++it)
 {
 delete *it;
 }
-}
+pendingCommands_.clear();
-void HandleException(const OracleCommandExceptionMessage& message)
+}
+void HandleExceptionMessage(const OracleCommandExceptionMessage& message)
 {
 LOG(ERROR) << "Error in the state machine, stopping all processing";
 Clear();
 }
 template <typename T>
-void Handle(const T& message)
+void HandleSuccessMessage(const T& message)
 {
-dynamic_cast<const State&>(message.GetOrigin().GetPayload()).Handle(message);
+assert(activeCommands_ > 0);
 activeCommands_--;
-Step();
+try
+{
+dynamic_cast<State&>(message.GetOrigin().GetPayload()).Handle(message);
+Step();
+}
+catch (Orthanc::OrthancException& e)
+{
+LOG(ERROR) << "Error in the state machine, stopping all processing: " << e.What();
+Clear();
+}
 }
 typedef std::list<IOracleCommand*>  PendingCommands;
 IOracle&         oracle_;
 simultaneousDownloads_(4),
 activeCommands_(0)
 {
 oracleObservable.RegisterObserverCallback(
 new Callable<LoaderStateMachine, OrthancRestApiCommand::SuccessMessage>
-(*this, &LoaderStateMachine::Handle<OrthancRestApiCommand::SuccessMessage>));
+(*this, &LoaderStateMachine::HandleSuccessMessage));
 oracleObservable.RegisterObserverCallback(
 new Callable<LoaderStateMachine, GetOrthancImageCommand::SuccessMessage>
-(*this, &LoaderStateMachine::Handle<GetOrthancImageCommand::SuccessMessage>));
+(*this, &LoaderStateMachine::HandleSuccessMessage));
 oracleObservable.RegisterObserverCallback(
 new Callable<LoaderStateMachine, GetOrthancWebViewerJpegCommand::SuccessMessage>
-(*this, &LoaderStateMachine::Handle<GetOrthancWebViewerJpegCommand::SuccessMessage>));
+(*this, &LoaderStateMachine::HandleSuccessMessage));
 oracleObservable.RegisterObserverCallback(
 new Callable<LoaderStateMachine, OracleCommandExceptionMessage>
-(*this, &LoaderStateMachine::HandleException));
+(*this, &LoaderStateMachine::HandleExceptionMessage));
 }
 virtual ~LoaderStateMachine()
 {
 Clear();
 throw Orthanc::OrthancException(Orthanc::ErrorCode_NullPointer);
 }
 }
-virtual void Handle(const OrthancRestApiCommand::SuccessMessage& message) const
+virtual void Handle(const OrthancRestApiCommand::SuccessMessage& message)
 {
 // Complete the DICOM tags with just-received "Grid Frame Offset Vector"
 std::string s = Orthanc::Toolbox::StripSpaces(message.GetAnswer());
 dicom_->SetValue(Orthanc::DICOM_TAG_GRID_FRAME_OFFSET_VECTOR, s, false);
 LoadGeometry(OrthancMultiframeVolumeLoader& that) :
 State(that)
 {
 }
-virtual void Handle(const OrthancRestApiCommand::SuccessMessage& message) const
+virtual void Handle(const OrthancRestApiCommand::SuccessMessage& message)
 {
 OrthancMultiframeVolumeLoader& loader = GetLoader<OrthancMultiframeVolumeLoader>();
 Json::Value body;
 message.ParseJsonBody(body);
 LoadTransferSyntax(OrthancMultiframeVolumeLoader& that) :
 State(that)
 {
 }
-virtual void Handle(const OrthancRestApiCommand::SuccessMessage& message) const
+virtual void Handle(const OrthancRestApiCommand::SuccessMessage& message)
 {
 GetLoader<OrthancMultiframeVolumeLoader>().SetTransferSyntax(message.GetAnswer());
 }
 };
 LoadUncompressedPixelData(OrthancMultiframeVolumeLoader& that) :
 State(that)
 {
 }
-virtual void Handle(const OrthancRestApiCommand::SuccessMessage& message) const
+virtual void Handle(const OrthancRestApiCommand::SuccessMessage& message)
 {
 GetLoader<OrthancMultiframeVolumeLoader>().SetUncompressedPixelData(message.GetAnswer());
 }
 };
 }
 };
-class VolumeImageReslicer : public IVolumeSlicer
+class DicomVolumeImageReslicer : public IVolumeSlicer
 {
 private:
 class Slice : public IExtractedSlice
 {
 private:
-VolumeImageReslicer&  that_;
+DicomVolumeImageReslicer&  that_;
-CoordinateSystem3D    cuttingPlane_;
+CoordinateSystem3D         cuttingPlane_;
 public:
-Slice(VolumeImageReslicer& that,
+Slice(DicomVolumeImageReslicer& that,
 const CoordinateSystem3D& cuttingPlane) :
 that_(that),
 cuttingPlane_(cuttingPlane)
 {
 }
 virtual uint64_t GetRevision()
 {
 return that_.volume_->GetRevision();
 }
-virtual ISceneLayer* CreateSceneLayer(const ILayerStyleConfigurator* configurator,  // possibly absent
+virtual ISceneLayer* CreateSceneLayer(const ILayerStyleConfigurator* configurator,
 const CoordinateSystem3D& cuttingPlane)
 {
 VolumeReslicer& reslicer = that_.reslicer_;
 if (configurator == NULL)
 boost::shared_ptr<DicomVolumeImage>  volume_;
 VolumeReslicer                       reslicer_;
 public:
-VolumeImageReslicer(const boost::shared_ptr<DicomVolumeImage>& volume) :
+DicomVolumeImageReslicer(const boost::shared_ptr<DicomVolumeImage>& volume) :
 volume_(volume)
 {
 if (volume.get() == NULL)
 {
 throw Orthanc::OrthancException(Orthanc::ErrorCode_NullPointer);
 };
 class DicomStructureSetLoader :
-public IObserver,
+public LoaderStateMachine,
 public IVolumeSlicer
 {
 private:
+class AddReferencedInstance : public State
+{
+private:
+std::string instanceId_;
+public:
+AddReferencedInstance(DicomStructureSetLoader& that,
+const std::string& instanceId) :
+State(that),
+instanceId_(instanceId)
+{
+}
+virtual void Handle(const OrthancRestApiCommand::SuccessMessage& message)
+{
+Json::Value tags;
+message.ParseJsonBody(tags);
+Orthanc::DicomMap dicom;
+dicom.FromDicomAsJson(tags);
+DicomStructureSetLoader& loader = GetLoader<DicomStructureSetLoader>();
+loader.content_->AddReferencedSlice(dicom);
+loader.countProcessedInstances_ ++;
+assert(loader.countProcessedInstances_ <= loader.countReferencedInstances_);
+if (loader.countProcessedInstances_ == loader.countReferencedInstances_)
+{
+// All the referenced instances have been loaded, finalize the RT-STRUCT
+loader.content_->CheckReferencedSlices();
+loader.revision_++;
+}
+}
+};
+// State that converts a "SOP Instance UID" to an Orthanc identifier
+class LookupInstance : public State
+{
+private:
+std::string  sopInstanceUid_;
+public:
+LookupInstance(DicomStructureSetLoader& that,
+const std::string& sopInstanceUid) :
+State(that),
+sopInstanceUid_(sopInstanceUid)
+{
+}
+virtual void Handle(const OrthancRestApiCommand::SuccessMessage& message)
+{
+DicomStructureSetLoader& loader = GetLoader<DicomStructureSetLoader>();
+Json::Value lookup;
+message.ParseJsonBody(lookup);
+if (lookup.type() != Json::arrayValue ||
+lookup.size() != 1 ||
+!lookup[0].isMember("Type") ||
+!lookup[0].isMember("Path") ||
+lookup[0]["Type"].type() != Json::stringValue ||
+lookup[0]["ID"].type() != Json::stringValue ||
+lookup[0]["Type"].asString() != "Instance")
+{
+throw Orthanc::OrthancException(Orthanc::ErrorCode_UnknownResource);
+}
+const std::string instanceId = lookup[0]["ID"].asString();
+{
+std::auto_ptr<OrthancRestApiCommand> command(new OrthancRestApiCommand);
+command->SetHttpHeader("Accept-Encoding", "gzip");
+command->SetUri("/instances/" + instanceId + "/tags");
+command->SetPayload(new AddReferencedInstance(loader, instanceId));
+Schedule(command.release());
+}
+}
+};
+class LoadStructure : public State
+{
+public:
+LoadStructure(DicomStructureSetLoader& that) :
+State(that)
+{
+}
+virtual void Handle(const OrthancRestApiCommand::SuccessMessage& message)
+{
+DicomStructureSetLoader& loader = GetLoader<DicomStructureSetLoader>();
+{
+OrthancPlugins::FullOrthancDataset dicom(message.GetAnswer());
+loader.content_.reset(new DicomStructureSet(dicom));
+}
+std::set<std::string> instances;
+loader.content_->GetReferencedInstances(instances);
+loader.countReferencedInstances_ = instances.size();
+for (std::set<std::string>::const_iterator
+it = instances.begin(); it != instances.end(); ++it)
+{
+std::auto_ptr<OrthancRestApiCommand> command(new OrthancRestApiCommand);
+command->SetUri("/tools/lookup");
+command->SetMethod(Orthanc::HttpMethod_Post);
+command->SetBody(*it);
+command->SetPayload(new LookupInstance(loader, *it));
+Schedule(command.release());
+printf("[%s]\n", it->c_str());
+}
+}
+};
 std::auto_ptr<DicomStructureSet>  content_;
-IOracle&                          oracle_;
-bool                              active_;
 uint64_t                          revision_;
 std::string                       instanceId_;
+unsigned int                      countProcessedInstances_;
-void Handle(const OrthancRestApiCommand::SuccessMessage& message)
+unsigned int                      countReferencedInstances_;
-{
-assert(active_);
-{
-OrthancPlugins::FullOrthancDataset dicom(message.GetAnswer());
-content_.reset(new DicomStructureSet(dicom));
-}
-std::set<std::string> instances;
-content_->GetReferencedInstances(instances);
-for (std::set<std::string>::const_iterator
-it = instances.begin(); it != instances.end(); ++it)
-{
-printf("[%s]\n", it->c_str());
-}
-}
 class Slice : public IExtractedSlice
 {
 private:
 const CoordinateSystem3D& cuttingPlane)
 {
 assert(isValid_);
 std::auto_ptr<PolylineSceneLayer> layer(new PolylineSceneLayer);
+layer->SetThickness(2);
 for (size_t i = 0; i < content_.GetStructuresCount(); i++)
 {
 std::vector< std::vector<DicomStructureSet::PolygonPoint> > polygons;
 if (content_.ProjectStructure(polygons, i, cuttingPlane))
 {
-printf(">> %d\n", polygons.size());
 for (size_t j = 0; j < polygons.size(); j++)
 {
 PolylineSceneLayer::Chain chain;
 chain.resize(polygons[j].size());
-for (size_t k = 0; k < polygons[i].size(); k++)
+for (size_t k = 0; k < polygons[j].size(); k++)
 {
 chain[k] = ScenePoint2D(polygons[j][k].first, polygons[j][k].second);
 }
 layer->AddChain(chain, true /* closed */);
 }
 }
 }
-printf("OK\n");
 return layer.release();
 }
 };
 public:
 DicomStructureSetLoader(IOracle& oracle,
 IObservable& oracleObservable) :
-IObserver(oracleObservable.GetBroker()),
+LoaderStateMachine(oracle, oracleObservable),
-oracle_(oracle),
+revision_(0),
-active_(false),
+countProcessedInstances_(0),
-revision_(0)
+countReferencedInstances_(0)
 {
-oracleObservable.RegisterObserverCallback(
-new Callable<DicomStructureSetLoader, OrthancRestApiCommand::SuccessMessage>
-(*this, &DicomStructureSetLoader::Handle));
 }
 void LoadInstance(const std::string& instanceId)
 {
-if (active_)
+Start();
-{
-throw Orthanc::OrthancException(Orthanc::ErrorCode_BadSequenceOfCalls);
+instanceId_ = instanceId;
-}
-else
+{
-{
+std::auto_ptr<OrthancRestApiCommand> command(new OrthancRestApiCommand);
-active_ = true;
+command->SetHttpHeader("Accept-Encoding", "gzip");
-instanceId_ = instanceId;
+command->SetUri("/instances/" + instanceId + "/tags?ignore-length=3006-0050");
+command->SetPayload(new LoadStructure(*this));
-{
+Schedule(command.release());
-std::auto_ptr<OrthancRestApiCommand> command(new OrthancRestApiCommand);
-command->SetHttpHeader("Accept-Encoding", "gzip");
-command->SetUri("/instances/" + instanceId + "/tags?ignore-length=3006-0050");
-oracle_.Schedule(*this, command.release());
-}
 }
 }
 virtual IExtractedSlice* ExtractSlice(const CoordinateSystem3D& cuttingPlane)
 {
 #if 1
 toto->SetVolume1(0, ctLoader, new OrthancStone::GrayscaleStyleConfigurator);
 #else
 {
-boost::shared_ptr<OrthancStone::IVolumeSlicer> reslicer(new OrthancStone::VolumeImageReslicer(ct));
+boost::shared_ptr<OrthancStone::IVolumeSlicer> reslicer(new OrthancStone::DicomVolumeImageReslicer(ct));
 toto->SetVolume1(0, reslicer, new OrthancStone::GrayscaleStyleConfigurator);
 }
 #endif
 }
 // 2017-11-17-Anonymized
 //ctLoader->LoadSeries("cb3ea4d1-d08f3856-ad7b6314-74d88d77-60b05618");  // CT
-doseLoader->LoadInstance("41029085-71718346-811efac4-420e2c15-d39f99b6");  // RT-DOSE
+//doseLoader->LoadInstance("41029085-71718346-811efac4-420e2c15-d39f99b6");  // RT-DOSE
 //rtstructLoader->LoadInstance("83d9c0c3-913a7fee-610097d7-cbf0522d-fd75bee6");  // RT-STRUCT
+// 2017-05-16
+ctLoader->LoadSeries("a04ecf01-79b2fc33-58239f7e-ad9db983-28e81afa");  // CT
+doseLoader->LoadInstance("eac822ef-a395f94e-e8121fe0-8411fef8-1f7bffad");  // RT-DOSE
+rtstructLoader->LoadInstance("54460695-ba3885ee-ddf61ac0-f028e31d-a6e474d9");  // RT-STRUCT
 // 2015-01-28-Multiframe
 //doseLoader->LoadInstance("88f71e2a-5fad1c61-96ed14d6-5b3d3cf7-a5825279");  // Multiframe CT
 // Delphine

Mercurial > hg > orthanc-stone

comparison Samples/Sdl/Loader.cpp @ 796:d3197e0e321d