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

comparison Samples/Sdl/Loader.cpp @ 709:7457b4ee1f29

VolumeSeriesOrthancLoader uses a prefetching strategy

author	Sebastien Jodogne <s.jodogne@gmail.com>
date	Mon, 20 May 2019 12:03:16 +0200
parents	10910827f235
children	3046a603eebf

comparison

equal deleted inserted replaced

-:51976977d2d3
+:7457b4ee1f29
 #include "../../Framework/StoneInitialization.h"
 #include "../../Framework/Toolbox/GeometryToolbox.h"
 #include "../../Framework/Toolbox/SlicesSorter.h"
 #include "../../Framework/Volumes/ImageBuffer3D.h"
 #include "../../Framework/Scene2D/Scene2D.h"
+#include "../../Framework/Loaders/BasicFetchingStrategy.h"
+#include "../../Framework/Loaders/BasicFetchingItemsSorter.h"
 // From Orthanc framework
 #include <Core/Compression/GzipCompressor.h>
 #include <Core/Compression/ZlibCompressor.h>
 #include <Core/DicomFormat/DicomArray.h>
 }
 void SetUri(const std::string& uri)
 {
 uri_ = uri;
+}
+void SetInstanceUri(const std::string& instance,
+Orthanc::PixelFormat pixelFormat)
+{
+uri_ = "/instances/" + instance;
+switch (pixelFormat)
+{
+case Orthanc::PixelFormat_RGB24:
+uri_ += "/preview";
+break;
+case Orthanc::PixelFormat_Grayscale16:
+uri_ += "/image-uint16";
+break;
+case Orthanc::PixelFormat_SignedGrayscale16:
+uri_ += "/image-int16";
+break;
+default:
+throw Orthanc::OrthancException(Orthanc::ErrorCode_ParameterOutOfRange);
+}
 }
 void SetHttpHeader(const std::string& key,
 const std::string& value)
 {
 private:
 std::auto_ptr<OrthancStone::ImageBuffer3D>  image_;
 std::vector<DicomInstanceParameters*>       slices_;
 uint64_t                                    revision_;
 std::vector<uint64_t>                       slicesRevision_;
+std::vector<unsigned int>                   slicesQuality_;
 void CheckSlice(size_t index,
 const DicomInstanceParameters& reference) const
 {
 const DicomInstanceParameters& slice = *slices_[index];
 for (size_t i = 0; i < slices_.size(); i++)
 {
 assert(slices_[i] != NULL);
 delete slices_[i];
 }
+slices_.clear();
+slicesRevision_.clear();
+slicesQuality_.clear();
 }
 void CheckSliceIndex(size_t index) const
 {
 false /* don't compute range */));
 }
 else
 {
 slices_.reserve(slices.GetSlicesCount());
-slicesRevision_.resize(slices.GetSlicesCount());
+slicesRevision_.resize(slices.GetSlicesCount(), 0);
+slicesQuality_.resize(slices.GetSlicesCount(), 0);
 for (size_t i = 0; i < slices.GetSlicesCount(); i++)
 {
 const DicomInstanceParameters& slice =
 dynamic_cast<const DicomInstanceParameters&>(slices.GetSlicePayload(i));
 slices_.push_back(new DicomInstanceParameters(slice));
-slicesRevision_[i] = 0;
 }
 CheckVolume();
 const double spacingZ = slices.ComputeSpacingBetweenSlices();
 CheckSliceIndex(index);
 return slicesRevision_[index];
 }
 void SetSliceContent(size_t index,
-const Orthanc::ImageAccessor& image)
+const Orthanc::ImageAccessor& image,
+unsigned int quality)
 {
 CheckSliceIndex(index);
-{
+// If a better image quality is already available, don't update the content
-OrthancStone::ImageBuffer3D::SliceWriter writer
+if (quality >= slicesQuality_[index])
-(*image_, OrthancStone::VolumeProjection_Axial, index);
+{
-Orthanc::ImageProcessing::Copy(writer.GetAccessor(), image);
+{
-}
+OrthancStone::ImageBuffer3D::SliceWriter writer
+(*image_, OrthancStone::VolumeProjection_Axial, index);
-revision_ ++;
+Orthanc::ImageProcessing::Copy(writer.GetAccessor(), image);
-slicesRevision_[index] += 1;
+}
+revision_ ++;
+slicesRevision_[index] += 1;
+}
 }
 };
 virtual void Handle(const Json::Value& body) const
 {
 throw Orthanc::OrthancException(Orthanc::ErrorCode_NotImplemented);
 }
-virtual void Handle(const Orthanc::ImageAccessor& image) const
+virtual void Handle(const Orthanc::ImageAccessor& image,
+unsigned int quality) const
 {
 throw Orthanc::OrthancException(Orthanc::ErrorCode_NotImplemented);
 }
 };
 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());
+dynamic_cast<const MessageHandler&>(message.GetOrigin().GetPayload()).Handle(message.GetImage(), 2 /* best quality */);
 }
 void Handle(const Refactoring::GetOrthancWebViewerJpegCommand::SuccessMessage& message)
 {
-dynamic_cast<const MessageHandler&>(message.GetOrigin().GetPayload()).Handle(message.GetImage());
+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:
-DicomVolumeImage&   target_;
-size_t              slice_;
-public:
-LoadSliceImage(DicomVolumeImage& target,
-size_t slice) :
-target_(target),
-slice_(slice)
-{
-}
-virtual void Handle(const Orthanc::ImageAccessor& image) const
-{
-target_.SetSliceContent(slice_, image);
-}
-};
-class LoadSeriesGeometryHandler : 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
+{
+assert(quality <= 2);
+that_.volume_.SetSliceContent(slice_, image, quality);
+that_.ScheduleNextSliceDownload();
+}
+};
+class LoadSeriesGeometryHandler : public MessageHandler
+{
+private:
+VolumeSeriesOrthancLoader&  that_;
 public:
 LoadSeriesGeometryHandler(VolumeSeriesOrthancLoader& that) :
 that_(that)
 {
 }
 virtual void Handle(const Json::Value& body) const
 {
-Json::Value::Members instances = body.getMemberNames();
+{
+Json::Value::Members instances = body.getMemberNames();
-OrthancStone::SlicesSorter slices;
+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());
-}
-that_.volume_.SetGeometry(slices);
-{
-OrthancStone::LinearAlgebra::Print(that_.volume_.GetImage().GetGeometry().GetCoordinates(0, 0, 0));
-OrthancStone::LinearAlgebra::Print(that_.volume_.GetImage().GetGeometry().GetCoordinates(1, 1, 1));
-return;
-}
-for (size_t i = 0; i < that_.volume_.GetSlicesCount(); i++)
-{
-const DicomInstanceParameters& slice = that_.volume_.GetSliceParameters(i);
-const std::string& instance = slice.GetOrthancInstanceIdentifier();
-if (instance.empty())
 {
-throw Orthanc::OrthancException(Orthanc::ErrorCode_InternalError);
+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());
 }
-#if 0
+that_.volume_.SetGeometry(slices);
-std::auto_ptr<Refactoring::GetOrthancWebViewerJpegCommand> command(
+}
-new Refactoring::GetOrthancWebViewerJpegCommand);
-command->SetInstance(instance);
+if (that_.volume_.GetSlicesCount() != 0)
-command->SetQuality(95);
+{
-#else
+that_.strategy_.reset(new OrthancStone::BasicFetchingStrategy(
-std::string uri = "/instances/" + instance;
+new OrthancStone::BasicFetchingItemsSorter(that_.volume_.GetSlicesCount()), 2));
-switch (slice.GetExpectedPixelFormat())
+for (unsigned int i = 0; i < 4; i++)   // Schedule up to 4 simultaneous downloads (TODO - parameter)
 {
-case Orthanc::PixelFormat_RGB24:
+that_.ScheduleNextSliceDownload();
-uri += "/preview";
-break;
-case Orthanc::PixelFormat_Grayscale16:
-uri += "/image-uint16";
-break;
-case Orthanc::PixelFormat_SignedGrayscale16:
-uri += "/image-int16";
-break;
-default:
-throw Orthanc::OrthancException(Orthanc::ErrorCode_ParameterOutOfRange);
 }
-std::auto_ptr<Refactoring::GetOrthancImageCommand> command(
-new Refactoring::GetOrthancImageCommand);
-command->SetHttpHeader("Accept-Encoding", "gzip");
-command->SetHttpHeader("Accept", std::string(Orthanc::EnumerationToString(Orthanc::MimeType_Pam)));
-command->SetUri(uri);
-#endif
-command->SetExpectedPixelFormat(slice.GetExpectedPixelFormat());
-command->SetPayload(new LoadSliceImage(that_.volume_, i));
-that_.oracle_.Schedule(that_, command.release());
 }
 }
 };
 DicomInstanceParameters instance(dicom);
 }
 };
+void ScheduleNextSliceDownload()
+{
+assert(strategy_.get() != NULL);
+unsigned int sliceIndex, quality;
+if (strategy_->GetNext(sliceIndex, quality))
+{
+assert(quality <= 2);
+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;
+if (quality == 2)   // 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());
+}
+oracle_.Schedule(*this, command.release());
+}
+}
 IOracle&          oracle_;
 bool              active_;
 DicomVolumeImage  volume_;
+std::auto_ptr<OrthancStone::IFetchingStrategy>   strategy_;
 public:
 VolumeSeriesOrthancLoader(IOracle& oracle,
 OrthancStone::IObservable& oracleObservable) :
 IObserver(oracleObservable.GetBroker()),

Mercurial > hg > orthanc-stone

comparison Samples/Sdl/Loader.cpp @ 709:7457b4ee1f29