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

comparison Samples/Sdl/Loader.cpp @ 711:70d1c28560b3

simplification

author	Sebastien Jodogne <s.jodogne@gmail.com>
date	Mon, 20 May 2019 13:40:23 +0200
parents	3046a603eebf
children	f334b098b243

comparison

equal deleted inserted replaced

-:3046a603eebf
+:70d1c28560b3
 class VolumeSeriesOrthancLoader : public OrthancStone::IObserver
 {
 private:
-class MessageHandler : public Orthanc::IDynamicObject
+static const unsigned int LOW_QUALITY = 0;
-{
+static const unsigned int MIDDLE_QUALITY = 1;
-public:
+static const unsigned int BEST_QUALITY = 2;
-virtual void Handle(const Json::Value& body) const
-{
-throw Orthanc::OrthancException(Orthanc::ErrorCode_NotImplemented);
+static unsigned int GetSliceIndexPayload(const OracleCommandWithPayload& command)
-}
+{
+return dynamic_cast< const Orthanc::SingleValueObject<unsigned int>& >(command.GetPayload()).GetValue();
-virtual void Handle(const Orthanc::ImageAccessor& image,
-unsigned int quality) const
-{
-throw Orthanc::OrthancException(Orthanc::ErrorCode_NotImplemented);
-}
-};
-void Handle(const OrthancRestApiCommand::SuccessMessage& message)
-{
-Json::Value body;
-message.ParseJsonBody(body);
-if (body.type() != Json::objectValue)
-{
-throw Orthanc::OrthancException(Orthanc::ErrorCode_NetworkProtocol);
-}
-dynamic_cast<const MessageHandler&>(message.GetOrigin().GetPayload()).Handle(body);
-}
-void Handle(const Refactoring::GetOrthancImageCommand::SuccessMessage& message)
-{
-dynamic_cast<const MessageHandler&>(message.GetOrigin().GetPayload()).Handle(message.GetImage(), 2 /* best quality */);
-}
-void Handle(const Refactoring::GetOrthancWebViewerJpegCommand::SuccessMessage& message)
-{
-unsigned int quality;
-switch (message.GetOrigin().GetQuality())
-{
-case 50:
-quality = 0;
-break;
-case 95:
-quality = 1;
-break;
-default:
-throw Orthanc::OrthancException(Orthanc::ErrorCode_InternalError);
-}
-dynamic_cast<const MessageHandler&>(message.GetOrigin().GetPayload()).Handle(message.GetImage(), quality);
-}
-class LoadSliceImage : public MessageHandler
-{
-private:
-VolumeSeriesOrthancLoader&  that_;
-size_t                      slice_;
-public:
-LoadSliceImage(VolumeSeriesOrthancLoader& that,
-size_t slice) :
-that_(that),
-slice_(slice)
-{
-}
-virtual void Handle(const Orthanc::ImageAccessor& image,
-unsigned int quality) const
-{
-that_.SetSliceContent(slice_, image, quality);
-}
-};
-class LoadSeriesGeometryHandler : public MessageHandler
-{
-private:
-VolumeSeriesOrthancLoader&  that_;
-public:
-LoadSeriesGeometryHandler(VolumeSeriesOrthancLoader& that) :
-that_(that)
-{
-}
-virtual void Handle(const Json::Value& body) const
-{
-that_.SetGeometry(body);
-}
-};
-void SetGeometry(const Json::Value& body)
-{
-{
-Json::Value::Members instances = body.getMemberNames();
-OrthancStone::SlicesSorter slices;
-for (size_t i = 0; i < instances.size(); i++)
-{
-Orthanc::DicomMap dicom;
-dicom.FromDicomAsJson(body[instances[i]]);
-std::auto_ptr<DicomInstanceParameters> instance(new DicomInstanceParameters(dicom));
-instance->SetOrthancInstanceIdentifier(instances[i]);
-OrthancStone::CoordinateSystem3D geometry = instance->GetGeometry();
-slices.AddSlice(geometry, instance.release());
-}
-volume_.SetGeometry(slices);
-}
-if (volume_.GetSlicesCount() != 0)
-{
-strategy_.reset(new OrthancStone::BasicFetchingStrategy(
-new OrthancStone::BasicFetchingItemsSorter(volume_.GetSlicesCount()), 2));
-for (unsigned int i = 0; i < 4; i++)   // Schedule up to 4 simultaneous downloads (TODO - parameter)
-{
-ScheduleNextSliceDownload();
-}
-}
 }
 void ScheduleNextSliceDownload()
 {
 unsigned int sliceIndex, quality;
 if (strategy_->GetNext(sliceIndex, quality))
 {
-assert(quality <= 2);
+assert(quality <= BEST_QUALITY);
 const DicomInstanceParameters& slice = volume_.GetSliceParameters(sliceIndex);
 const std::string& instance = slice.GetOrthancInstanceIdentifier();
 if (instance.empty())
 {
 throw Orthanc::OrthancException(Orthanc::ErrorCode_InternalError);
 }
-std::auto_ptr<Refactoring::IOracleCommand> command;
+std::auto_ptr<Refactoring::OracleCommandWithPayload> command;
-if (quality == 2)   // Best quality
+if (quality == BEST_QUALITY)
 {
 std::auto_ptr<Refactoring::GetOrthancImageCommand> tmp(
 new Refactoring::GetOrthancImageCommand);
 tmp->SetHttpHeader("Accept-Encoding", "gzip");
 tmp->SetHttpHeader("Accept", std::string(Orthanc::EnumerationToString(Orthanc::MimeType_Pam)));
 tmp->SetInstanceUri(instance, slice.GetExpectedPixelFormat());
 tmp->SetExpectedPixelFormat(slice.GetExpectedPixelFormat());
-tmp->SetPayload(new LoadSliceImage(*this, sliceIndex));
 command.reset(tmp.release());
 }
 else
 {
 std::auto_ptr<Refactoring::GetOrthancWebViewerJpegCommand> tmp(
 new Refactoring::GetOrthancWebViewerJpegCommand);
 tmp->SetHttpHeader("Accept-Encoding", "gzip");
 tmp->SetInstance(instance);
 tmp->SetQuality((quality == 0 ? 50 : 95));
 tmp->SetExpectedPixelFormat(slice.GetExpectedPixelFormat());
-tmp->SetPayload(new LoadSliceImage(*this, sliceIndex));
 command.reset(tmp.release());
 }
+command->SetPayload(new Orthanc::SingleValueObject<unsigned int>(sliceIndex));
 oracle_.Schedule(*this, command.release());
 }
 }
-void SetSliceContent(unsigned int sliceIndex,
+void LoadGeometry(const OrthancRestApiCommand::SuccessMessage& message)
-const Orthanc::ImageAccessor& image,
+{
-unsigned int quality)
+Json::Value body;
-{
+message.ParseJsonBody(body);
-assert(quality <= 2);
-volume_.SetSliceContent(sliceIndex, image, quality);
+if (body.type() != Json::objectValue)
+{
+throw Orthanc::OrthancException(Orthanc::ErrorCode_NetworkProtocol);
+}
+{
+Json::Value::Members instances = body.getMemberNames();
+OrthancStone::SlicesSorter slices;
+for (size_t i = 0; i < instances.size(); i++)
+{
+Orthanc::DicomMap dicom;
+dicom.FromDicomAsJson(body[instances[i]]);
+std::auto_ptr<DicomInstanceParameters> instance(new DicomInstanceParameters(dicom));
+instance->SetOrthancInstanceIdentifier(instances[i]);
+OrthancStone::CoordinateSystem3D geometry = instance->GetGeometry();
+slices.AddSlice(geometry, instance.release());
+}
+volume_.SetGeometry(slices);
+}
+if (volume_.GetSlicesCount() != 0)
+{
+strategy_.reset(new OrthancStone::BasicFetchingStrategy(
+new OrthancStone::BasicFetchingItemsSorter(volume_.GetSlicesCount()), BEST_QUALITY));
+for (unsigned int i = 0; i < 4; i++)   // Schedule up to 4 simultaneous downloads (TODO - parameter)
+{
+ScheduleNextSliceDownload();
+}
+}
+}
+void LoadBestQualitySliceContent(const Refactoring::GetOrthancImageCommand::SuccessMessage& message)
+{
+volume_.SetSliceContent(GetSliceIndexPayload(message.GetOrigin()),
+message.GetImage(), BEST_QUALITY);
 ScheduleNextSliceDownload();
 }
+void LoadJpegSliceContent(const Refactoring::GetOrthancWebViewerJpegCommand::SuccessMessage& message)
+{
+unsigned int quality;
+switch (message.GetOrigin().GetQuality())
+{
+case 50:
+quality = LOW_QUALITY;
+break;
+case 90:
+quality = MIDDLE_QUALITY;
+break;
+default:
+throw Orthanc::OrthancException(Orthanc::ErrorCode_InternalError);
+}
+volume_.SetSliceContent(GetSliceIndexPayload(message.GetOrigin()), message.GetImage(), quality);
+ScheduleNextSliceDownload();
+}
 IOracle&          oracle_;
 bool              active_;
 DicomVolumeImage  volume_;
 oracle_(oracle),
 active_(false)
 {
 oracleObservable.RegisterObserverCallback(
 new OrthancStone::Callable<VolumeSeriesOrthancLoader, OrthancRestApiCommand::SuccessMessage>
-(*this, &VolumeSeriesOrthancLoader::Handle));
+(*this, &VolumeSeriesOrthancLoader::LoadGeometry));
 oracleObservable.RegisterObserverCallback(
 new OrthancStone::Callable<VolumeSeriesOrthancLoader, GetOrthancImageCommand::SuccessMessage>
-(*this, &VolumeSeriesOrthancLoader::Handle));
+(*this, &VolumeSeriesOrthancLoader::LoadBestQualitySliceContent));
 oracleObservable.RegisterObserverCallback(
 new OrthancStone::Callable<VolumeSeriesOrthancLoader, GetOrthancWebViewerJpegCommand::SuccessMessage>
-(*this, &VolumeSeriesOrthancLoader::Handle));
+(*this, &VolumeSeriesOrthancLoader::LoadJpegSliceContent));
 }
 void LoadSeries(const std::string& seriesId)
 {
 if (active_)
 active_ = true;
 std::auto_ptr<Refactoring::OrthancRestApiCommand> command(new Refactoring::OrthancRestApiCommand);
 command->SetUri("/series/" + seriesId + "/instances-tags");
-command->SetPayload(new LoadSeriesGeometryHandler(*this));
 oracle_.Schedule(*this, command.release());
 }
 };
 }
 #endif
 /*  class VolumeSlicerBase : public IVolumeSlicer
 {
 private:
 OrthancStone::Scene2D&            scene_;
 int                               layerDepth_;
 bool                              first_;
 OrthancStone::CoordinateSystem3D  lastPlane_;
 protected:
 bool HasViewportPlaneChanged(const OrthancStone::CoordinateSystem3D& plane) const
 {
 if (first_ ||
 !OrthancStone::LinearAlgebra::IsCloseToZero(
 boost::numeric::ublas::norm_2(lastPlane_.GetNormal() - plane.GetNormal())))
 {
 // This is the first rendering, or the plane has not the same orientation
 return false;
 }
 else
 {
 double offset1 = lastPlane_.ProjectAlongNormal(plane.GetOrigin());
 double offset2 = lastPlane_.ProjectAlongNormal(lastPlane_.GetOrigin());
 return OrthancStone::LinearAlgebra::IsCloseToZero(offset2 - offset1);
 }
 }
 void SetLastViewportPlane(const OrthancStone::CoordinateSystem3D& plane)
 {
 first_ = false;
 lastPlane_ = plane;
 }
 void SetLayer(OrthancStone::ISceneLayer* layer)
 {
 scene_.SetLayer(layerDepth_, layer);
 }
 void DeleteLayer()
 {
 scene_.DeleteLayer(layerDepth_);
 }
 public:
 VolumeSlicerBase(OrthancStone::Scene2D& scene,
 int layerDepth) :
 scene_(scene),
 layerDepth_(layerDepth),
 first_(true)
 {
 }
 };*/
 class DicomVolumeSlicer : public IVolumeSlicer
 {
 }
 public:
 NativeOracle(IMessageEmitter& emitter) :
 emitter_(emitter),
 state_(State_Setup),
 workers_(4)
 {
 }
 NativeApplicationContext&                that_;
 boost::shared_lock<boost::shared_mutex>  lock_;
 public:
 ReaderLock(NativeApplicationContext& that) :
 that_(that),
 lock_(that.mutex_)
 {
 }
 };
 NativeApplicationContext&                that_;
 boost::unique_lock<boost::shared_mutex>  lock_;
 public:
 WriterLock(NativeApplicationContext& that) :
 that_(that),
 lock_(that.mutex_)
 {
 }
 OrthancStone::MessageBroker& GetBroker()
 {
 (new OrthancStone::Callable
 <Toto, Refactoring::GetOrthancImageCommand::SuccessMessage>(*this, &Toto::Handle));
 oracle.RegisterObserverCallback
 (new OrthancStone::Callable
 <Toto, Refactoring::GetOrthancWebViewerJpegCommand::SuccessMessage>(*this, &Toto::Handle));
 oracle.RegisterObserverCallback
 (new OrthancStone::Callable
 <Toto, Refactoring::OracleCommandExceptionMessage>(*this, &Toto::Handle));
 }

Mercurial > hg > orthanc-stone

comparison Samples/Sdl/Loader.cpp @ 711:70d1c28560b3