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

comparison Samples/Sdl/Loader.cpp @ 795:bc20e4c417ec

refactoring OrthancMultiframeVolumeLoader using LoaderStateMachine

author	Sebastien Jodogne <s.jodogne@gmail.com>
date	Tue, 28 May 2019 13:02:56 +0200
parents	04f518ebd132
children	d3197e0e321d 98a89b116b62

comparison

equal deleted inserted replaced

-:04f518ebd132
+:bc20e4c417ec
 State(LoaderStateMachine& that) :
 that_(that)
 {
 }
-void Schedule(OracleCommandWithPayload* command)
+State(const State& currentState) :
+that_(currentState.that_)
+{
+}
+void Schedule(OracleCommandWithPayload* command) const
 {
 that_.Schedule(command);
 }
+template <typename T>
+T& GetLoader() const
+{
+return dynamic_cast<T&>(that_);
+}
 virtual void Handle(const OrthancRestApiCommand::SuccessMessage& message) const
 {
 throw Orthanc::OrthancException(Orthanc::ErrorCode_NotImplemented);
 }
 };
 void Schedule(OracleCommandWithPayload* command)
 {
 std::auto_ptr<OracleCommandWithPayload> protection(command);
+if (command == NULL)
+{
+throw Orthanc::OrthancException(Orthanc::ErrorCode_NullPointer);
+}
 if (!command->HasPayload())
 {
 throw Orthanc::OrthancException(Orthanc::ErrorCode_ParameterOutOfRange,
 "The payload must contain the next state");
 }
 pendingCommands_.push_back(protection.release());
+Step();
 }
 void Start()
 {
 if (active_)
 {
 throw Orthanc::OrthancException(Orthanc::ErrorCode_BadSequenceOfCalls);
 }
+active_ = true;
 for (size_t i = 0; i < simultaneousDownloads_; i++)
 {
 Step();
 }
 }
 private:
 void Step()
 {
-if (!pendingCommands_.empty())
+if (!pendingCommands_.empty() &&
+activeCommands_ < simultaneousDownloads_)
 {
 oracle_.Schedule(*this, pendingCommands_.front());
 pendingCommands_.pop_front();
-}
-}
+activeCommands_++;
+}
-void Handle(const OrthancRestApiCommand::SuccessMessage& message)
+}
+void Clear()
+{
+for (PendingCommands::iterator it = pendingCommands_.begin();
+it != pendingCommands_.end(); ++it)
+{
+delete *it;
+}
+}
+void HandleException(const OracleCommandExceptionMessage& message)
+{
+LOG(ERROR) << "Error in the state machine, stopping all processing";
+Clear();
+}
+template <typename T>
+void Handle(const T& message)
 {
 dynamic_cast<const State&>(message.GetOrigin().GetPayload()).Handle(message);
-Step();
+activeCommands_--;
-}
-void Handle(const GetOrthancImageCommand::SuccessMessage& message)
-{
-dynamic_cast<const State&>(message.GetOrigin().GetPayload()).Handle(message);
-Step();
-}
-void Handle(const GetOrthancWebViewerJpegCommand::SuccessMessage& message)
-{
-dynamic_cast<const State&>(message.GetOrigin().GetPayload()).Handle(message);
 Step();
 }
 typedef std::list<IOracleCommand*>  PendingCommands;
 IOracle&         oracle_;
 bool             active_;
 unsigned int     simultaneousDownloads_;
 PendingCommands  pendingCommands_;
+unsigned int     activeCommands_;
 public:
 LoaderStateMachine(IOracle& oracle,
 IObservable& oracleObservable) :
 IObserver(oracleObservable.GetBroker()),
 oracle_(oracle),
 active_(false),
-simultaneousDownloads_(4)
+simultaneousDownloads_(4),
+activeCommands_(0)
 {
 oracleObservable.RegisterObserverCallback(
 new Callable<LoaderStateMachine, OrthancRestApiCommand::SuccessMessage>
-(*this, &LoaderStateMachine::Handle));
+(*this, &LoaderStateMachine::Handle<OrthancRestApiCommand::SuccessMessage>));
 oracleObservable.RegisterObserverCallback(
 new Callable<LoaderStateMachine, GetOrthancImageCommand::SuccessMessage>
-(*this, &LoaderStateMachine::Handle));
+(*this, &LoaderStateMachine::Handle<GetOrthancImageCommand::SuccessMessage>));
 oracleObservable.RegisterObserverCallback(
 new Callable<LoaderStateMachine, GetOrthancWebViewerJpegCommand::SuccessMessage>
-(*this, &LoaderStateMachine::Handle));
+(*this, &LoaderStateMachine::Handle<GetOrthancWebViewerJpegCommand::SuccessMessage>));
+oracleObservable.RegisterObserverCallback(
+new Callable<LoaderStateMachine, OracleCommandExceptionMessage>
+(*this, &LoaderStateMachine::HandleException));
 }
 virtual ~LoaderStateMachine()
 {
-for (PendingCommands::iterator it = pendingCommands_.begin();
+Clear();
-it != pendingCommands_.end(); ++it)
+}
-{
-delete *it;
+bool IsActive() const
-}
+{
-}
+return active_;
+}
-virtual void SetSimultaneousDownloads(unsigned int count)
+void SetSimultaneousDownloads(unsigned int count)
 {
 if (active_)
 {
 throw Orthanc::OrthancException(Orthanc::ErrorCode_BadSequenceOfCalls);
 }
 };
 class OrthancMultiframeVolumeLoader :
-public IObserver,
+public LoaderStateMachine,
 public IObservable
 {
 private:
-class State : public Orthanc::IDynamicObject
-{
-private:
-OrthancMultiframeVolumeLoader&  that_;
-protected:
-void Schedule(OrthancRestApiCommand* command) const
-{
-that_.oracle_.Schedule(that_, command);
-}
-OrthancMultiframeVolumeLoader& GetTarget() const
-{
-return that_;
-}
-public:
-State(OrthancMultiframeVolumeLoader& that) :
-that_(that)
-{
-}
-virtual void Handle(const OrthancRestApiCommand::SuccessMessage& message) const = 0;
-};
-void Handle(const OrthancRestApiCommand::SuccessMessage& message)
-{
-dynamic_cast<const State&>(message.GetOrigin().GetPayload()).Handle(message);
-}
 class LoadRTDoseGeometry : public State
 {
 private:
 std::auto_ptr<Orthanc::DicomMap>  dicom_;
 {
 if (dicom == NULL)
 {
 throw Orthanc::OrthancException(Orthanc::ErrorCode_NullPointer);
 }
 }
 virtual void Handle(const OrthancRestApiCommand::SuccessMessage& message) const
 {
 // 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);
-GetTarget().SetGeometry(*dicom_);
+GetLoader<OrthancMultiframeVolumeLoader>().SetGeometry(*dicom_);
 }
 };
 static std::string GetSopClassUid(const Orthanc::DicomMap& dicom)
 {
 }
 virtual void Handle(const OrthancRestApiCommand::SuccessMessage& message) const
 {
+OrthancMultiframeVolumeLoader& loader = GetLoader<OrthancMultiframeVolumeLoader>();
 Json::Value body;
 message.ParseJsonBody(body);
 if (body.type() != Json::objectValue)
 {
 {
 // Download the "Grid Frame Offset Vector" DICOM tag, that is
 // mandatory for RT-DOSE, but is too long to be returned by default
 std::auto_ptr<OrthancRestApiCommand> command(new OrthancRestApiCommand);
-command->SetUri("/instances/" + GetTarget().GetInstanceId() + "/content/" +
+command->SetUri("/instances/" + loader.GetInstanceId() + "/content/" +
 Orthanc::DICOM_TAG_GRID_FRAME_OFFSET_VECTOR.Format());
-command->SetPayload(new LoadRTDoseGeometry(GetTarget(), dicom.release()));
+command->SetPayload(new LoadRTDoseGeometry(loader, dicom.release()));
 Schedule(command.release());
 }
 else
 {
-GetTarget().SetGeometry(*dicom);
+loader.SetGeometry(*dicom);
 }
 }
 };
 {
 }
 virtual void Handle(const OrthancRestApiCommand::SuccessMessage& message) const
 {
-GetTarget().SetTransferSyntax(message.GetAnswer());
+GetLoader<OrthancMultiframeVolumeLoader>().SetTransferSyntax(message.GetAnswer());
 }
 };
 class LoadUncompressedPixelData : public State
 {
 }
 virtual void Handle(const OrthancRestApiCommand::SuccessMessage& message) const
 {
-GetTarget().SetUncompressedPixelData(message.GetAnswer());
+GetLoader<OrthancMultiframeVolumeLoader>().SetUncompressedPixelData(message.GetAnswer());
 }
 };
 boost::shared_ptr<DicomVolumeImage>   volume_;
-IOracle&     oracle_;
-bool         active_;
 std::string  instanceId_;
 std::string  transferSyntaxUid_;
 const std::string& GetInstanceId() const
 {
-if (active_)
+if (IsActive())
 {
 return instanceId_;
 }
 else
 {
 std::auto_ptr<OrthancRestApiCommand> command(new OrthancRestApiCommand);
 command->SetHttpHeader("Accept-Encoding", "gzip");
 command->SetUri("/instances/" + instanceId_ + "/content/" +
 Orthanc::DICOM_TAG_PIXEL_DATA.Format() + "/0");
 command->SetPayload(new LoadUncompressedPixelData(*this));
-oracle_.Schedule(*this, command.release());
+Schedule(command.release());
 }
 else
 {
 throw Orthanc::OrthancException(
 Orthanc::ErrorCode_NotImplemented,
 public:
 OrthancMultiframeVolumeLoader(const boost::shared_ptr<DicomVolumeImage>& volume,
 IOracle& oracle,
 IObservable& oracleObservable) :
-IObserver(oracleObservable.GetBroker()),
+LoaderStateMachine(oracle, oracleObservable),
 IObservable(oracleObservable.GetBroker()),
-volume_(volume),
+volume_(volume)
-oracle_(oracle),
-active_(false)
 {
 if (volume.get() == NULL)
 {
 throw Orthanc::OrthancException(Orthanc::ErrorCode_NullPointer);
 }
-oracleObservable.RegisterObserverCallback(
-new Callable<OrthancMultiframeVolumeLoader, OrthancRestApiCommand::SuccessMessage>
-(*this, &OrthancMultiframeVolumeLoader::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");
+command->SetPayload(new LoadGeometry(*this));
-{
+Schedule(command.release());
-std::auto_ptr<OrthancRestApiCommand> command(new OrthancRestApiCommand);
+}
-command->SetHttpHeader("Accept-Encoding", "gzip");
-command->SetUri("/instances/" + instanceId + "/tags");
+{
-command->SetPayload(new LoadGeometry(*this));
+std::auto_ptr<OrthancRestApiCommand> command(new OrthancRestApiCommand);
-oracle_.Schedule(*this, command.release());
+command->SetUri("/instances/" + instanceId + "/metadata/TransferSyntax");
-}
+command->SetPayload(new LoadTransferSyntax(*this));
+Schedule(command.release());
-{
-std::auto_ptr<OrthancRestApiCommand> command(new OrthancRestApiCommand);
-command->SetUri("/instances/" + instanceId + "/metadata/TransferSyntax");
-command->SetPayload(new LoadTransferSyntax(*this));
-oracle_.Schedule(*this, command.release());
-}
 }
 }
 };
 void Handle(const OrthancStone::DicomVolumeImage::GeometryReadyMessage& message)
 {
 printf("Geometry ready\n");
 //plane_ = message.GetOrigin().GetGeometry().GetSagittalGeometry();
-plane_ = message.GetOrigin().GetGeometry().GetAxialGeometry();
+//plane_ = message.GetOrigin().GetGeometry().GetAxialGeometry();
-//plane_ = message.GetOrigin().GetGeometry().GetCoronalGeometry();
+plane_ = message.GetOrigin().GetGeometry().GetCoronalGeometry();
 plane_.SetOrigin(message.GetOrigin().GetGeometry().GetCoordinates(0.5f, 0.5f, 0.5f));
 Refresh();
 }
 // 2017-11-17-Anonymized
 //ctLoader->LoadSeries("cb3ea4d1-d08f3856-ad7b6314-74d88d77-60b05618");  // CT
 doseLoader->LoadInstance("41029085-71718346-811efac4-420e2c15-d39f99b6");  // RT-DOSE
-rtstructLoader->LoadInstance("83d9c0c3-913a7fee-610097d7-cbf0522d-fd75bee6");  // RT-STRUCT
+//rtstructLoader->LoadInstance("83d9c0c3-913a7fee-610097d7-cbf0522d-fd75bee6");  // 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 @ 795:bc20e4c417ec