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

comparison Samples/Sdl/Loader.cpp @ 781:2bb72826fa3f

IVolumeImage

author	Sebastien Jodogne <s.jodogne@gmail.com>
date	Mon, 27 May 2019 11:45:18 +0200
parents	f81655ed96ab
children	b24c208fa953

comparison

equal deleted inserted replaced

-:f81655ed96ab
+:2bb72826fa3f
 #include "../../Framework/StoneInitialization.h"
 #include "../../Framework/Toolbox/GeometryToolbox.h"
 #include "../../Framework/Toolbox/SlicesSorter.h"
 #include "../../Framework/Volumes/ImageBuffer3D.h"
 #include "../../Framework/Volumes/VolumeImageGeometry.h"
+#include "../../Framework/Volumes/VolumeReslicer.h"
 // From Orthanc framework
 #include <Core/DicomFormat/DicomArray.h>
 #include <Core/Images/Image.h>
 #include <Core/Images/ImageProcessing.h>
 {
 }
 };
+class IVolumeImage : public boost::noncopyable
+{
+public:
+ORTHANC_STONE_DEFINE_ORIGIN_MESSAGE(__FILE__, __LINE__, GeometryReadyMessage, IVolumeImage);
+ORTHANC_STONE_DEFINE_ORIGIN_MESSAGE(__FILE__, __LINE__, ContentUpdatedMessage, IVolumeImage);
+virtual ~IVolumeImage()
+{
+}
+virtual uint64_t GetRevision() const = 0;
+virtual bool HasGeometry() const = 0;
+virtual const ImageBuffer3D& GetPixelData() const = 0;
+virtual const VolumeImageGeometry& GetGeometry() const = 0;
+};
 class IVolumeSlicer : public boost::noncopyable
 {
 public:
-class ExtractedSlice : public boost::noncopyable
+class IExtractedSlice : public boost::noncopyable
 {
 public:
-virtual ~ExtractedSlice()
+virtual ~IExtractedSlice()
 {
 }
 virtual bool IsValid() = 0;
 virtual ~IVolumeSlicer()
 {
 }
-virtual ExtractedSlice* ExtractSlice(const CoordinateSystem3D& cuttingPlane) const = 0;
+virtual bool HasVolumeImage() const = 0;
+virtual const IVolumeImage& GetVolumeImage() const = 0;
+virtual IExtractedSlice* ExtractSlice(const CoordinateSystem3D& cuttingPlane) const = 0;
 };
+class InvalidExtractedSlice : public IVolumeSlicer::IExtractedSlice
-class VolumeGeometryReadyMessage : public OriginMessage<IVolumeSlicer>
-{
-ORTHANC_STONE_MESSAGE(__FILE__, __LINE__);
-private:
-const VolumeImageGeometry&  geometry_;
-public:
-VolumeGeometryReadyMessage(const IVolumeSlicer& slicer,
-const VolumeImageGeometry& geometry) :
-OriginMessage(slicer),
-geometry_(geometry)
-{
-}
-const VolumeImageGeometry& GetGeometry() const
-{
-return geometry_;
-}
-};
-class InvalidExtractedSlice : public IVolumeSlicer::ExtractedSlice
 {
 public:
 virtual bool IsValid()
 {
 return false;
 throw Orthanc::OrthancException(Orthanc::ErrorCode_BadSequenceOfCalls);
 }
 };
-class DicomVolumeImageOrthogonalSlice : public IVolumeSlicer::ExtractedSlice
+class DicomVolumeImageOrthogonalSlice : public IVolumeSlicer::IExtractedSlice
 {
 private:
 const ImageBuffer3D&        image_;
 const VolumeImageGeometry&  geometry_;
 bool                        valid_;
 #endif
 }
 };
+class VolumeImageBase : public IVolumeImage
+{
+private:
+uint64_t                            revision_;
+std::auto_ptr<VolumeImageGeometry>  geometry_;
+std::auto_ptr<ImageBuffer3D>        image_;
+protected:
+void Finalize()
+{
+geometry_.reset();
+image_.reset();
+revision_ ++;
+}
+void Initialize(VolumeImageGeometry* geometry,  // Takes ownership
+Orthanc::PixelFormat format)
+{
+if (geometry == NULL)
+{
+throw Orthanc::OrthancException(Orthanc::ErrorCode_NullPointer);
+}
+geometry_.reset(geometry);
+image_.reset(new ImageBuffer3D(format, geometry_->GetWidth(), geometry_->GetHeight(),
+geometry_->GetDepth(), false /* don't compute range */));
+revision_ ++;
+}
+ImageBuffer3D& GetPixelData()
+{
+return *image_;
+}
+void IncrementRevision()
+{
+revision_ ++;
+}
+public:
+VolumeImageBase() :
+revision_(0)
+{
+}
+virtual uint64_t GetRevision() const
+{
+return revision_;
+}
+virtual bool HasGeometry() const
+{
+return (geometry_.get() != NULL &&
+image_.get() != NULL);
+}
+virtual const ImageBuffer3D& GetPixelData() const
+{
+if (HasGeometry())
+{
+return *image_;
+}
+else
+{
+throw Orthanc::OrthancException(Orthanc::ErrorCode_BadSequenceOfCalls);
+}
+}
+virtual const VolumeImageGeometry& GetGeometry() const
+{
+if (HasGeometry())
+{
+return *geometry_;
+}
+else
+{
+throw Orthanc::OrthancException(Orthanc::ErrorCode_BadSequenceOfCalls);
+}
+}
+};
 // This class combines a 3D image buffer, a 3D volume geometry and
 // information about the DICOM parameters of each slice.
-class DicomSeriesVolumeImage : public boost::noncopyable
+class DicomSeriesVolumeImage : public VolumeImageBase
 {
 public:
 class ExtractedOrthogonalSlice : public DicomVolumeImageOrthogonalSlice
 {
 private:
 }
 public:
 ExtractedOrthogonalSlice(const DicomSeriesVolumeImage& that,
 const CoordinateSystem3D& plane) :
-DicomVolumeImageOrthogonalSlice(that.GetImage(), that.GetGeometry(), plane),
+DicomVolumeImageOrthogonalSlice(that.GetPixelData(), that.GetGeometry(), plane),
 that_(that)
 {
 }
 };
 private:
-std::auto_ptr<ImageBuffer3D>           image_;
-std::auto_ptr<VolumeImageGeometry>     geometry_;
 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
 }
 void Clear()
 {
-image_.reset();
+VolumeImageBase::Finalize();
-geometry_.reset();
 for (size_t i = 0; i < slices_.size(); i++)
 {
 assert(slices_[i] != NULL);
 delete slices_[i];
 }
 void CheckSliceIndex(size_t index) const
 {
-assert(slices_.size() == image_->GetDepth() &&
+assert(slices_.size() == GetPixelData().GetDepth() &&
 slices_.size() == slicesRevision_.size());
 if (!HasGeometry())
 {
 throw Orthanc::OrthancException(Orthanc::ErrorCode_BadSequenceOfCalls);
 }
 }
 public:
-DicomSeriesVolumeImage() :
-revision_(0)
-{
-}
 ~DicomSeriesVolumeImage()
 {
 Clear();
 }
 {
 throw Orthanc::OrthancException(Orthanc::ErrorCode_ParameterOutOfRange,
 "Cannot sort the 3D slices of a DICOM series");
 }
-geometry_.reset(new VolumeImageGeometry);
 if (slices.GetSlicesCount() == 0)
 {
 // Empty volume
-image_.reset(new ImageBuffer3D(Orthanc::PixelFormat_Grayscale8, 0, 0, 0,
+VolumeImageBase::Initialize(new VolumeImageGeometry, Orthanc::PixelFormat_Grayscale8);
-false /* don't compute range */));
 }
 else
 {
 slices_.reserve(slices.GetSlicesCount());
 slicesRevision_.resize(slices.GetSlicesCount(), 0);
 const double spacingZ = slices.ComputeSpacingBetweenSlices();
 LOG(INFO) << "Computed spacing between slices: " << spacingZ << "mm";
 const DicomInstanceParameters& parameters = *slices_[0];
-image_.reset(new ImageBuffer3D(parameters.GetExpectedPixelFormat(),
+std::auto_ptr<VolumeImageGeometry> geometry(new VolumeImageGeometry);
-parameters.GetImageInformation().GetWidth(),
+geometry->SetSize(parameters.GetImageInformation().GetWidth(),
 parameters.GetImageInformation().GetHeight(),
-static_cast<unsigned int>(slices.GetSlicesCount()),
+static_cast<unsigned int>(slices.GetSlicesCount()));
-false /* don't compute range */));
+geometry->SetAxialGeometry(slices.GetSliceGeometry(0));
+geometry->SetVoxelDimensions(parameters.GetPixelSpacingX(),
-geometry_->SetSize(image_->GetWidth(), image_->GetHeight(), image_->GetDepth());
+parameters.GetPixelSpacingY(), spacingZ);
-geometry_->SetAxialGeometry(slices.GetSliceGeometry(0));
-geometry_->SetVoxelDimensions(parameters.GetPixelSpacingX(),
+VolumeImageBase::Initialize(geometry.release(), parameters.GetExpectedPixelFormat());
-parameters.GetPixelSpacingY(), spacingZ);
+}
-}
+GetPixelData().Clear();
-image_->Clear();
-revision_++;
-}
-uint64_t GetRevision() const
-{
-return revision_;
-}
-bool HasGeometry() const
-{
-return (image_.get() != NULL &&
-geometry_.get() != NULL);
-}
-const ImageBuffer3D& GetImage() const
-{
-if (!HasGeometry())
-{
-throw Orthanc::OrthancException(Orthanc::ErrorCode_BadSequenceOfCalls);
-}
-else
-{
-return *image_;
-}
-}
-const VolumeImageGeometry& GetGeometry() const
-{
-if (!HasGeometry())
-{
-throw Orthanc::OrthancException(Orthanc::ErrorCode_BadSequenceOfCalls);
-}
-else
-{
-return *geometry_;
-}
 }
 size_t GetSlicesCount() const
 {
 if (!HasGeometry())
 // If a better image quality is already available, don't update the content
 if (quality >= slicesQuality_[index])
 {
 {
 ImageBuffer3D::SliceWriter writer
-(*image_, VolumeProjection_Axial, static_cast<unsigned int>(index));
+(GetPixelData(), VolumeProjection_Axial, static_cast<unsigned int>(index));
 Orthanc::ImageProcessing::Copy(writer.GetAccessor(), image);
 }
-revision_ ++;
 slicesRevision_[index] += 1;
+VolumeImageBase::IncrementRevision();
 }
 }
 };
 {
 ScheduleNextSliceDownload();
 }
 }
-BroadcastMessage(VolumeGeometryReadyMessage(*this, volume_.GetGeometry()));
+BroadcastMessage(IVolumeImage::GeometryReadyMessage(volume_));
 }
 void LoadBestQualitySliceContent(const GetOrthancImageCommand::SuccessMessage& message)
 {
 volume_.SetSliceContent(GetSliceIndexPayload(message.GetOrigin()),
 message.GetImage(), BEST_QUALITY);
 ScheduleNextSliceDownload();
+BroadcastMessage(IVolumeImage::ContentUpdatedMessage(volume_));
 }
 void LoadJpegSliceContent(const GetOrthancWebViewerJpegCommand::SuccessMessage& message)
 {
 }
 volume_.SetSliceContent(GetSliceIndexPayload(message.GetOrigin()), message.GetImage(), quality);
 ScheduleNextSliceDownload();
+BroadcastMessage(IVolumeImage::ContentUpdatedMessage(volume_));
 }
 IOracle&                oracle_;
 bool                    active_;
 command->SetUri("/series/" + seriesId + "/instances-tags");
 oracle_.Schedule(*this, command.release());
 }
 }
-const DicomSeriesVolumeImage& GetVolume() const
+virtual bool HasVolumeImage() const
+{
+return true;
+}
+virtual const IVolumeImage& GetVolumeImage() const
 {
 return volume_;
 }
-virtual ExtractedSlice* ExtractSlice(const CoordinateSystem3D& cuttingPlane) const
+virtual IExtractedSlice* ExtractSlice(const CoordinateSystem3D& cuttingPlane) const
 {
 if (volume_.HasGeometry() &&
 volume_.GetSlicesCount() != 0)
 {
 std::auto_ptr<DicomVolumeImageOrthogonalSlice> slice
 class OrthancMultiframeVolumeLoader :
 public IObserver,
 public IObservable,
-public IVolumeSlicer
+public IVolumeSlicer,
+public VolumeImageBase
 {
 private:
 class State : public Orthanc::IDynamicObject
 {
 private:
 IOracle&     oracle_;
 bool         active_;
 std::string  instanceId_;
 std::string  transferSyntaxUid_;
-uint64_t     revision_;
 std::auto_ptr<DicomInstanceParameters>  dicom_;
-std::auto_ptr<VolumeImageGeometry>      geometry_;
-std::auto_ptr<ImageBuffer3D>            image_;
 const std::string& GetInstanceId() const
 {
 if (active_)
 const unsigned int width = dicom_->GetImageInformation().GetWidth();
 const unsigned int height = dicom_->GetImageInformation().GetHeight();
 const unsigned int depth = dicom_->GetImageInformation().GetNumberOfFrames();
-geometry_.reset(new VolumeImageGeometry);
+{
-geometry_->SetSize(width, height, depth);
+std::auto_ptr<VolumeImageGeometry> geometry(new VolumeImageGeometry);
-geometry_->SetAxialGeometry(dicom_->GetGeometry());
+geometry->SetSize(width, height, depth);
-geometry_->SetVoxelDimensions(dicom_->GetPixelSpacingX(),
+geometry->SetAxialGeometry(dicom_->GetGeometry());
-dicom_->GetPixelSpacingY(),
+geometry->SetVoxelDimensions(dicom_->GetPixelSpacingX(),
-spacingZ);
+dicom_->GetPixelSpacingY(),
+spacingZ);
-image_.reset(new ImageBuffer3D(format, width, height, depth,
+VolumeImageBase::Initialize(geometry.release(), format);
-false /* don't compute range */));
+}
-image_->Clear();
+GetPixelData().Clear();
 ScheduleFrameDownloads();
-BroadcastMessage(VolumeGeometryReadyMessage(*this, *geometry_));
+BroadcastMessage(IVolumeImage::GeometryReadyMessage(*this));
 }
 ORTHANC_FORCE_INLINE
 static void CopyPixel(uint32_t& target,
 template <typename T>
 void CopyPixelData(const std::string& pixelData)
 {
-const Orthanc::PixelFormat format = image_->GetFormat();
+const Orthanc::PixelFormat format = GetPixelData().GetFormat();
-const unsigned int bpp = image_->GetBytesPerPixel();
+const unsigned int bpp = GetPixelData().GetBytesPerPixel();
-const unsigned int width = image_->GetWidth();
+const unsigned int width = GetPixelData().GetWidth();
-const unsigned int height = image_->GetHeight();
+const unsigned int height = GetPixelData().GetHeight();
-const unsigned int depth = image_->GetDepth();
+const unsigned int depth = GetPixelData().GetDepth();
 if (pixelData.size() != bpp * width * height * depth)
 {
 throw Orthanc::OrthancException(Orthanc::ErrorCode_BadFileFormat,
 "The pixel data has not the proper size");
 const uint8_t* source = reinterpret_cast<const uint8_t*>(pixelData.c_str());
 for (unsigned int z = 0; z < depth; z++)
 {
-ImageBuffer3D::SliceWriter writer(*image_, VolumeProjection_Axial, z);
+ImageBuffer3D::SliceWriter writer(GetPixelData(), VolumeProjection_Axial, z);
 assert (writer.GetAccessor().GetWidth() == width &&
 writer.GetAccessor().GetHeight() == height);
 for (unsigned int y = 0; y < height; y++)
 }
 void SetUncompressedPixelData(const std::string& pixelData)
 {
-switch (image_->GetFormat())
+switch (GetPixelData().GetFormat())
 {
 case Orthanc::PixelFormat_Grayscale32:
 CopyPixelData<uint32_t>(pixelData);
 break;
 default:
 throw Orthanc::OrthancException(Orthanc::ErrorCode_NotImplemented);
 }
-revision_ ++;
+IncrementRevision();
+BroadcastMessage(IVolumeImage::ContentUpdatedMessage(*this));
 }
 private:
 class ExtractedOrthogonalSlice : public DicomVolumeImageOrthogonalSlice
 protected:
 virtual uint64_t GetRevisionInternal(VolumeProjection projection,
 unsigned int sliceIndex) const
 {
-return that_.revision_;
+return that_.GetRevision();
 }
 virtual const DicomInstanceParameters& GetDicomParameters(VolumeProjection projection,
 unsigned int sliceIndex) const
 {
 }
 public:
 ExtractedOrthogonalSlice(const OrthancMultiframeVolumeLoader& that,
 const CoordinateSystem3D& plane) :
-DicomVolumeImageOrthogonalSlice(that.GetImage(), that.GetGeometry(), plane),
+DicomVolumeImageOrthogonalSlice(that.GetPixelData(), that.GetGeometry(), plane),
 that_(that)
 {
 }
 };
 OrthancMultiframeVolumeLoader(IOracle& oracle,
 IObservable& oracleObservable) :
 IObserver(oracleObservable.GetBroker()),
 IObservable(oracleObservable.GetBroker()),
 oracle_(oracle),
-active_(false),
+active_(false)
-revision_(0)
 {
 oracleObservable.RegisterObserverCallback(
 new Callable<OrthancMultiframeVolumeLoader, OrthancRestApiCommand::SuccessMessage>
 (*this, &OrthancMultiframeVolumeLoader::Handle));
 }
-bool HasGeometry() const
+virtual bool HasVolumeImage() const
 {
-return (dicom_.get() != NULL &&
+return true;
-geometry_.get() != NULL &&
+}
-image_.get() != NULL);
-}
+virtual const IVolumeImage& GetVolumeImage() const
+{
-const ImageBuffer3D& GetImage() const
+return *this;
-{
-if (!HasGeometry())
-{
-throw Orthanc::OrthancException(Orthanc::ErrorCode_BadSequenceOfCalls);
-}
-else
-{
-return *image_;
-}
-}
-const VolumeImageGeometry& GetGeometry() const
-{
-if (!HasGeometry())
-{
-throw Orthanc::OrthancException(Orthanc::ErrorCode_BadSequenceOfCalls);
-}
-else
-{
-return *geometry_;
-}
 }
 const DicomInstanceParameters& GetDicomParameters() const
 {
 }
 }
 }
-virtual ExtractedSlice* ExtractSlice(const CoordinateSystem3D& cuttingPlane) const
+virtual IExtractedSlice* ExtractSlice(const CoordinateSystem3D& cuttingPlane) const
 {
 if (HasGeometry())
 {
 return new ExtractedOrthogonalSlice(*this, cuttingPlane);
 }
 else
 {
 return new InvalidExtractedSlice;
 }
+}
+};
+class DicomSeriesVolumeImageReslicer : public IVolumeSlicer
+{
+private:
+class Slice : public IExtractedSlice
+{
+public:
+virtual bool IsValid()
+{
+}
+virtual uint64_t GetRevision()
+{
+}
+virtual ISceneLayer* CreateSceneLayer(const ILayerStyleConfigurator* configurator,  // possibly absent
+const CoordinateSystem3D& cuttingPlane)
+{
+}
+};
+VolumeReslicer   reslicer_;
+boost::shared_ptr<DicomSeriesVolumeImage>  image_;
+public:
+DicomSeriesVolumeImageReslicer(const boost::shared_ptr<DicomSeriesVolumeImage>& image) :
+image_(image)
+{
+}
+virtual IExtractedSlice* ExtractSlice(const CoordinateSystem3D& cuttingPlane) const
+{
 }
 };
 }
 void Update(const CoordinateSystem3D& plane)
 {
 assert(slicer_.get() != NULL);
-std::auto_ptr<IVolumeSlicer::ExtractedSlice> slice(slicer_->ExtractSlice(plane));
+std::auto_ptr<IVolumeSlicer::IExtractedSlice> slice(slicer_->ExtractSlice(plane));
 if (slice.get() == NULL)
 {
 throw Orthanc::OrthancException(Orthanc::ErrorCode_InternalError);
 }
 writer.WriteToFile(buf, tmp);
 }
 }
-void Handle(const OrthancStone::VolumeGeometryReadyMessage& message)
+void Handle(const OrthancStone::IVolumeImage::GeometryReadyMessage& message)
 {
 printf("Geometry ready\n");
-if (&source1_->GetSlicer() == &message.GetOrigin())
+if (source2_->GetSlicer().HasVolumeImage() &&
-{
+&source2_->GetSlicer().GetVolumeImage() == &message.GetOrigin())
-//plane_ = message.GetGeometry().GetSagittalGeometry();
+{
-//plane_ = message.GetGeometry().GetAxialGeometry();
+//plane_ = message.GetOrigin().GetGeometry().GetSagittalGeometry();
-plane_ = message.GetGeometry().GetCoronalGeometry();
+//plane_ = message.GetOrigin().GetGeometry().GetAxialGeometry();
-plane_.SetOrigin(message.GetGeometry().GetCoordinates(0.5f, 0.5f, 0.5f));
+plane_ = message.GetOrigin().GetGeometry().GetCoronalGeometry();
+plane_.SetOrigin(message.GetOrigin().GetGeometry().GetCoordinates(0.5f, 0.5f, 0.5f));
 }
 Refresh();
 }
 const boost::shared_ptr<OrthancStone::IVolumeSlicer>& volume,
 OrthancStone::ILayerStyleConfigurator* style)
 {
 dynamic_cast<OrthancStone::IObservable&>(*volume).RegisterObserverCallback
 (new OrthancStone::Callable
-<Toto, OrthancStone::VolumeGeometryReadyMessage>(*this, &Toto::Handle));
+<Toto, OrthancStone::IVolumeImage::GeometryReadyMessage>(*this, &Toto::Handle));
 source1_.reset(new OrthancStone::VolumeSceneLayerSource(scene_, depth, volume));
 if (style != NULL)
 {
 const boost::shared_ptr<OrthancStone::IVolumeSlicer>& volume,
 OrthancStone::ILayerStyleConfigurator* style)
 {
 dynamic_cast<OrthancStone::IObservable&>(*volume).RegisterObserverCallback
 (new OrthancStone::Callable
-<Toto, OrthancStone::VolumeGeometryReadyMessage>(*this, &Toto::Handle));
+<Toto, OrthancStone::IVolumeImage::GeometryReadyMessage>(*this, &Toto::Handle));
 source2_.reset(new OrthancStone::VolumeSceneLayerSource(scene_, depth, volume));
 if (style != NULL)
 {

Mercurial > hg > orthanc-stone

comparison Samples/Sdl/Loader.cpp @ 781:2bb72826fa3f