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

comparison Samples/Sdl/Loader.cpp @ 782:b24c208fa953

VolumeImageReslicer

author	Sebastien Jodogne <s.jodogne@gmail.com>
date	Mon, 27 May 2019 14:21:04 +0200
parents	2bb72826fa3f
children	cd13a062c9bd

comparison

equal deleted inserted replaced

-:2bb72826fa3f
+:b24c208fa953
 {
 }
 virtual uint64_t GetRevision() const = 0;
-virtual ISceneLayer* CreateFromImage(const Orthanc::ImageAccessor& image) const = 0;
+virtual TextureBaseSceneLayer* CreateTextureFromImage(const Orthanc::ImageAccessor& image) const = 0;
-virtual ISceneLayer* CreateFromDicomImage(const Orthanc::ImageAccessor& frame,
+virtual TextureBaseSceneLayer* CreateTextureFromDicom(const Orthanc::ImageAccessor& frame,
 const DicomInstanceParameters& parameters) const = 0;
 virtual void ApplyStyle(ISceneLayer& layer) const = 0;
 };
 virtual uint64_t GetRevision() const
 {
 return revision_;
 }
-virtual ISceneLayer* CreateFromImage(const Orthanc::ImageAccessor& image) const
+virtual TextureBaseSceneLayer* CreateTextureFromImage(const Orthanc::ImageAccessor& image) const
 {
 throw Orthanc::OrthancException(Orthanc::ErrorCode_NotImplemented);
 }
-virtual ISceneLayer* CreateFromDicomImage(const Orthanc::ImageAccessor& frame,
+virtual TextureBaseSceneLayer* CreateTextureFromDicom(const Orthanc::ImageAccessor& frame,
 const DicomInstanceParameters& parameters) const
 {
 return parameters.CreateLookupTableTexture(frame);
 }
 virtual void ApplyStyle(ISceneLayer& layer) const
 virtual uint64_t GetRevision() const
 {
 return revision_;
 }
-virtual ISceneLayer* CreateFromImage(const Orthanc::ImageAccessor& image) const
+virtual TextureBaseSceneLayer* CreateTextureFromImage(const Orthanc::ImageAccessor& image) const
 {
 throw Orthanc::OrthancException(Orthanc::ErrorCode_NotImplemented);
 }
-virtual ISceneLayer* CreateFromDicomImage(const Orthanc::ImageAccessor& frame,
+virtual TextureBaseSceneLayer* CreateTextureFromDicom(const Orthanc::ImageAccessor& frame,
 const DicomInstanceParameters& parameters) const
 {
 return parameters.CreateTexture(frame);
 }
 virtual void ApplyStyle(ISceneLayer& layer) const
 virtual bool HasGeometry() const = 0;
 virtual const ImageBuffer3D& GetPixelData() const = 0;
 virtual const VolumeImageGeometry& GetGeometry() const = 0;
+virtual bool HasDicomParameters() const = 0;
+virtual const DicomInstanceParameters& GetDicomParameters() const = 0;
 };
 class IVolumeSlicer : public boost::noncopyable
 {
 // This call can take some time
 virtual ISceneLayer* CreateSceneLayer(const ILayerStyleConfigurator* configurator,  // possibly absent
 const CoordinateSystem3D& cuttingPlane) = 0;
 };
+class InvalidSlice : public IExtractedSlice
+{
+public:
+virtual bool IsValid()
+{
+return false;
+}
+virtual uint64_t GetRevision()
+{
+throw Orthanc::OrthancException(Orthanc::ErrorCode_BadSequenceOfCalls);
+}
+virtual ISceneLayer* CreateSceneLayer(const ILayerStyleConfigurator* configurator,
+const CoordinateSystem3D& cuttingPlane)
+{
+throw Orthanc::OrthancException(Orthanc::ErrorCode_BadSequenceOfCalls);
+}
+};
 virtual ~IVolumeSlicer()
 {
 }
-virtual bool HasVolumeImage() const = 0;
+virtual IExtractedSlice* ExtractSlice(const CoordinateSystem3D& cuttingPlane) = 0;
-virtual const IVolumeImage& GetVolumeImage() const = 0;
-virtual IExtractedSlice* ExtractSlice(const CoordinateSystem3D& cuttingPlane) const = 0;
 };
-class InvalidExtractedSlice : public IVolumeSlicer::IExtractedSlice
-{
-public:
-virtual bool IsValid()
-{
-return false;
-}
-virtual uint64_t GetRevision()
-{
-throw Orthanc::OrthancException(Orthanc::ErrorCode_BadSequenceOfCalls);
-}
-virtual ISceneLayer* CreateSceneLayer(const ILayerStyleConfigurator* configurator,
-const CoordinateSystem3D& cuttingPlane)
-{
-throw Orthanc::OrthancException(Orthanc::ErrorCode_BadSequenceOfCalls);
-}
-};
 class DicomVolumeImageOrthogonalSlice : public IVolumeSlicer::IExtractedSlice
 {
 private:
-const ImageBuffer3D&        image_;
+const IVolumeImage&  volume_;
-const VolumeImageGeometry&  geometry_;
+bool                 valid_;
-bool                        valid_;
+VolumeProjection     projection_;
-VolumeProjection            projection_;
+unsigned int         sliceIndex_;
-unsigned int                sliceIndex_;
 void CheckValid() const
 {
 if (!valid_)
 {
 protected:
 virtual uint64_t GetRevisionInternal(VolumeProjection projection,
 unsigned int sliceIndex) const = 0;
-virtual const DicomInstanceParameters& GetDicomParameters(VolumeProjection projection,
-unsigned int sliceIndex) const = 0;
 public:
-DicomVolumeImageOrthogonalSlice(const ImageBuffer3D& image,
+DicomVolumeImageOrthogonalSlice(const IVolumeImage& volume,
-const VolumeImageGeometry& geometry,
 const CoordinateSystem3D& cuttingPlane) :
-image_(image),
+volume_(volume)
-geometry_(geometry)
+{
-{
+valid_ = (volume_.HasDicomParameters() &&
-valid_ = geometry_.DetectSlice(projection_, sliceIndex_, cuttingPlane);
+volume_.GetGeometry().DetectSlice(projection_, sliceIndex_, cuttingPlane));
 }
 VolumeProjection GetProjection() const
 {
 CheckValid();
 }
 std::auto_ptr<TextureBaseSceneLayer> texture;
 {
-const DicomInstanceParameters& parameters = GetDicomParameters(projection_, sliceIndex_);
+const DicomInstanceParameters& parameters = volume_.GetDicomParameters();
-ImageBuffer3D::SliceReader reader(image_, projection_, sliceIndex_);
+ImageBuffer3D::SliceReader reader(volume_.GetPixelData(), projection_, sliceIndex_);
 texture.reset(dynamic_cast<TextureBaseSceneLayer*>
-(configurator->CreateFromDicomImage(reader.GetAccessor(), parameters)));
+(configurator->CreateTextureFromDicom(reader.GetAccessor(), parameters)));
 }
-const CoordinateSystem3D& system = geometry_.GetProjectionGeometry(projection_);
+const CoordinateSystem3D& system = volume_.GetGeometry().GetProjectionGeometry(projection_);
 double x0, y0, x1, y1;
 cuttingPlane.ProjectPoint(x0, y0, system.GetOrigin());
 cuttingPlane.ProjectPoint(x1, y1, system.GetOrigin() + system.GetAxisX());
 texture->SetOrigin(x0, y0);
 !LinearAlgebra::IsCloseToZero(dy))
 {
 texture->SetAngle(atan2(dy, dx));
 }
-Vector tmp = geometry_.GetVoxelDimensions(projection_);
+Vector tmp = volume_.GetGeometry().GetVoxelDimensions(projection_);
 texture->SetPixelSpacing(tmp[0], tmp[1]);
 return texture.release();
 #if 0
 class VolumeImageBase : public IVolumeImage
 {
 private:
-uint64_t                            revision_;
+uint64_t                                revision_;
-std::auto_ptr<VolumeImageGeometry>  geometry_;
+std::auto_ptr<VolumeImageGeometry>      geometry_;
-std::auto_ptr<ImageBuffer3D>        image_;
+std::auto_ptr<ImageBuffer3D>            image_;
+std::auto_ptr<DicomInstanceParameters>  parameters_;
 protected:
 void Finalize()
 {
 geometry_.reset();
 image_.reset(new ImageBuffer3D(format, geometry_->GetWidth(), geometry_->GetHeight(),
 geometry_->GetDepth(), false /* don't compute range */));
 revision_ ++;
 }
+void SetDicomParameters(const DicomInstanceParameters& parameters)
+{
+parameters_.reset(parameters.Clone());
+revision_ ++;
+}
 ImageBuffer3D& GetPixelData()
 {
 return *image_;
 }
 else
 {
 throw Orthanc::OrthancException(Orthanc::ErrorCode_BadSequenceOfCalls);
 }
 }
+virtual bool HasDicomParameters() const
+{
+return parameters_.get() != NULL;
+}
+virtual const DicomInstanceParameters& GetDicomParameters() const
+{
+if (HasDicomParameters())
+{
+return *parameters_;
+}
+else
+{
+throw Orthanc::OrthancException(Orthanc::ErrorCode_BadSequenceOfCalls);
+}
+}
 };
 // revision of the volume
 return that_.GetRevision();
 }
 }
-virtual const DicomInstanceParameters& GetDicomParameters(VolumeProjection projection,
-unsigned int sliceIndex) const
-{
-return that_.GetSliceParameters(projection == VolumeProjection_Axial ? sliceIndex : 0);
-}
 public:
 ExtractedOrthogonalSlice(const DicomSeriesVolumeImage& that,
 const CoordinateSystem3D& plane) :
-DicomVolumeImageOrthogonalSlice(that.GetPixelData(), that.GetGeometry(), plane),
+DicomVolumeImageOrthogonalSlice(that, plane),
 that_(that)
 {
 }
 };
 geometry->SetAxialGeometry(slices.GetSliceGeometry(0));
 geometry->SetVoxelDimensions(parameters.GetPixelSpacingX(),
 parameters.GetPixelSpacingY(), spacingZ);
 VolumeImageBase::Initialize(geometry.release(), parameters.GetExpectedPixelFormat());
+VolumeImageBase::SetDicomParameters(parameters);
 }
 GetPixelData().Clear();
 }
 }
 if (volume_.GetSlicesCount() != 0)
 {
 strategy_.reset(new BasicFetchingStrategy(sorter_->CreateSorter(
 static_cast<unsigned int>(volume_.GetSlicesCount())), BEST_QUALITY));
 assert(simultaneousDownloads_ != 0);
 for (unsigned int i = 0; i < simultaneousDownloads_; i++)
 {
 ScheduleNextSliceDownload();
 oracle_.Schedule(*this, command.release());
 }
 }
-virtual bool HasVolumeImage() const
+virtual IExtractedSlice* ExtractSlice(const CoordinateSystem3D& cuttingPlane)
-{
-return true;
-}
-virtual const IVolumeImage& GetVolumeImage() const
-{
-return volume_;
-}
-virtual IExtractedSlice* ExtractSlice(const CoordinateSystem3D& cuttingPlane) const
 {
 if (volume_.HasGeometry() &&
 volume_.GetSlicesCount() != 0)
 {
 std::auto_ptr<DicomVolumeImageOrthogonalSlice> slice
 return slice.release();
 }
 else
 {
-return new InvalidExtractedSlice;
+return new IVolumeSlicer::InvalidSlice;
 }
 }
 };
 IOracle&     oracle_;
 bool         active_;
 std::string  instanceId_;
 std::string  transferSyntaxUid_;
-std::auto_ptr<DicomInstanceParameters>  dicom_;
 const std::string& GetInstanceId() const
 {
 if (active_)
 {
 }
 void SetGeometry(const Orthanc::DicomMap& dicom)
 {
-dicom_.reset(new DicomInstanceParameters(dicom));
+DicomInstanceParameters parameters(dicom);
+VolumeImageBase::SetDicomParameters(parameters);
 Orthanc::PixelFormat format;
-if (!dicom_->GetImageInformation().ExtractPixelFormat(format, true))
+if (!parameters.GetImageInformation().ExtractPixelFormat(format, true))
 {
 throw Orthanc::OrthancException(Orthanc::ErrorCode_NotImplemented);
 }
 double spacingZ;
-switch (dicom_->GetSopClassUid())
+switch (parameters.GetSopClassUid())
 {
 case SopClassUid_RTDose:
-spacingZ = dicom_->GetThickness();
+spacingZ = parameters.GetThickness();
 break;
 default:
 throw Orthanc::OrthancException(
 Orthanc::ErrorCode_NotImplemented,
 "No support for multiframe instances with SOP class UID: " + GetSopClassUid(dicom));
 }
-const unsigned int width = dicom_->GetImageInformation().GetWidth();
+const unsigned int width = parameters.GetImageInformation().GetWidth();
-const unsigned int height = dicom_->GetImageInformation().GetHeight();
+const unsigned int height = parameters.GetImageInformation().GetHeight();
-const unsigned int depth = dicom_->GetImageInformation().GetNumberOfFrames();
+const unsigned int depth = parameters.GetImageInformation().GetNumberOfFrames();
 {
 std::auto_ptr<VolumeImageGeometry> geometry(new VolumeImageGeometry);
 geometry->SetSize(width, height, depth);
-geometry->SetAxialGeometry(dicom_->GetGeometry());
+geometry->SetAxialGeometry(parameters.GetGeometry());
-geometry->SetVoxelDimensions(dicom_->GetPixelSpacingX(),
+geometry->SetVoxelDimensions(parameters.GetPixelSpacingX(),
-dicom_->GetPixelSpacingY(),
+parameters.GetPixelSpacingY(),
 spacingZ);
 VolumeImageBase::Initialize(geometry.release(), format);
 }
 GetPixelData().Clear();
 unsigned int sliceIndex) const
 {
 return that_.GetRevision();
 }
-virtual const DicomInstanceParameters& GetDicomParameters(VolumeProjection projection,
-unsigned int sliceIndex) const
-{
-return that_.GetDicomParameters();
-}
 public:
 ExtractedOrthogonalSlice(const OrthancMultiframeVolumeLoader& that,
 const CoordinateSystem3D& plane) :
-DicomVolumeImageOrthogonalSlice(that.GetPixelData(), that.GetGeometry(), plane),
+DicomVolumeImageOrthogonalSlice(that, plane),
 that_(that)
 {
 }
 };
 new Callable<OrthancMultiframeVolumeLoader, OrthancRestApiCommand::SuccessMessage>
 (*this, &OrthancMultiframeVolumeLoader::Handle));
 }
-virtual bool HasVolumeImage() const
-{
-return true;
-}
-virtual const IVolumeImage& GetVolumeImage() const
-{
-return *this;
-}
-const DicomInstanceParameters& GetDicomParameters() const
-{
-if (!HasGeometry())
-{
-throw Orthanc::OrthancException(Orthanc::ErrorCode_BadSequenceOfCalls);
-}
-else
-{
-return *dicom_;
-}
-}
 void LoadInstance(const std::string& instanceId)
 {
 if (active_)
 {
 throw Orthanc::OrthancException(Orthanc::ErrorCode_BadSequenceOfCalls);
 }
 }
 }
-virtual IExtractedSlice* ExtractSlice(const CoordinateSystem3D& cuttingPlane) const
+virtual IExtractedSlice* ExtractSlice(const CoordinateSystem3D& cuttingPlane)
 {
 if (HasGeometry())
 {
 return new ExtractedOrthogonalSlice(*this, cuttingPlane);
 }
 else
 {
-return new InvalidExtractedSlice;
+return new IVolumeSlicer::InvalidSlice;
 }
 }
 };
-class DicomSeriesVolumeImageReslicer : public IVolumeSlicer
+class VolumeImageReslicer : public IVolumeSlicer
 {
 private:
 class Slice : public IExtractedSlice
 {
+private:
+VolumeImageReslicer&  that_;
+CoordinateSystem3D    cuttingPlane_;
 public:
+Slice(VolumeImageReslicer& that,
+const CoordinateSystem3D& cuttingPlane) :
+that_(that),
+cuttingPlane_(cuttingPlane)
+{
+}
 virtual bool IsValid()
 {
+return true;
 }
 virtual uint64_t GetRevision()
 {
+return that_.volume_->GetRevision();
 }
 virtual ISceneLayer* CreateSceneLayer(const ILayerStyleConfigurator* configurator,  // possibly absent
 const CoordinateSystem3D& cuttingPlane)
 {
+if (configurator == NULL)
+{
+throw Orthanc::OrthancException(Orthanc::ErrorCode_InternalError,
+"Must provide a layer style configurator");
+}
+that_.reslicer_.SetOutputFormat(that_.volume_->GetPixelData().GetFormat());
+if (that_.reslicer_.IsSuccess())
+{
+std::auto_ptr<TextureBaseSceneLayer> layer
+(configurator->CreateTextureFromDicom(that_.reslicer_.GetOutputSlice(),
+that_.volume_->GetDicomParameters()));
+if (layer.get() == NULL)
+{
+return NULL;
+}
+return layer.release();
+}
+else
+{
+return NULL;
+}
 }
 };
-VolumeReslicer   reslicer_;
+boost::shared_ptr<IVolumeImage>  volume_;
-boost::shared_ptr<DicomSeriesVolumeImage>  image_;
+VolumeReslicer                   reslicer_;
 public:
-DicomSeriesVolumeImageReslicer(const boost::shared_ptr<DicomSeriesVolumeImage>& image) :
+VolumeImageReslicer(const boost::shared_ptr<IVolumeImage>& volume) :
-image_(image)
+volume_(volume)
 {
-}
+if (volume.get() == NULL)
+{
-virtual IExtractedSlice* ExtractSlice(const CoordinateSystem3D& cuttingPlane) const
+throw Orthanc::OrthancException(Orthanc::ErrorCode_NullPointer);
-{
+}
+}
+ImageInterpolation GetInterpolation() const
+{
+return reslicer_.GetInterpolation();
+}
+void SetInterpolation(ImageInterpolation interpolation)
+{
+reslicer_.SetInterpolation(interpolation);
+}
+bool IsFastMode() const
+{
+return reslicer_.IsFastMode();
+}
+void SetFastMode(bool fast)
+{
+reslicer_.EnableFastMode(fast);
+}
+virtual IExtractedSlice* ExtractSlice(const CoordinateSystem3D& cuttingPlane)
+{
+if (volume_->HasGeometry())
+{
+return new Slice(*this, cuttingPlane);
+}
+else
+{
+return new IVolumeSlicer::InvalidSlice;
+}
 }
 };
 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_)
 {
 }
 MessageBroker& GetBroker()
 {
 void Handle(const OrthancStone::IVolumeImage::GeometryReadyMessage& message)
 {
 printf("Geometry ready\n");
-if (source2_->GetSlicer().HasVolumeImage() &&
+//plane_ = message.GetOrigin().GetGeometry().GetSagittalGeometry();
-&source2_->GetSlicer().GetVolumeImage() == &message.GetOrigin())
+//plane_ = message.GetOrigin().GetGeometry().GetAxialGeometry();
-{
+plane_ = message.GetOrigin().GetGeometry().GetCoronalGeometry();
-//plane_ = message.GetOrigin().GetGeometry().GetSagittalGeometry();
+plane_.SetOrigin(message.GetOrigin().GetGeometry().GetCoordinates(0.5f, 0.5f, 0.5f));
-//plane_ = message.GetOrigin().GetGeometry().GetAxialGeometry();
-plane_ = message.GetOrigin().GetGeometry().GetCoronalGeometry();
-plane_.SetOrigin(message.GetOrigin().GetGeometry().GetCoordinates(0.5f, 0.5f, 0.5f));
-}
 Refresh();
 }
 void SetVolume2(int depth,
 const boost::shared_ptr<OrthancStone::IVolumeSlicer>& volume,
 OrthancStone::ILayerStyleConfigurator* style)
 {
-dynamic_cast<OrthancStone::IObservable&>(*volume).RegisterObserverCallback
-(new OrthancStone::Callable
-<Toto, OrthancStone::IVolumeImage::GeometryReadyMessage>(*this, &Toto::Handle));
 source2_.reset(new OrthancStone::VolumeSceneLayerSource(scene_, depth, volume));
 if (style != NULL)
 {
 source2_->SetConfigurator(style);
 loader1.reset(new OrthancStone::OrthancSeriesVolumeProgressiveLoader(oracle, lock.GetOracleObservable()));
 loader2.reset(new OrthancStone::OrthancSeriesVolumeProgressiveLoader(oracle, lock.GetOracleObservable()));
 loader3.reset(new OrthancStone::OrthancMultiframeVolumeLoader(oracle, lock.GetOracleObservable()));
 }
+#if 1
 toto->SetVolume1(0, loader1, new OrthancStone::GrayscaleStyleConfigurator);
+#else
+{
+boost::shared_ptr<OrthancStone::IVolumeSlicer> reslicer(new OrthancStone::VolumeImageReslicer(loader1));
+toto->SetVolume1(0, reslicer, new OrthancStone::GrayscaleStyleConfigurator);
+}
+#endif
 {
 std::auto_ptr<OrthancStone::LookupTableStyleConfigurator> config(new OrthancStone::LookupTableStyleConfigurator);
 config->SetLookupTable(Orthanc::EmbeddedResources::COLORMAP_HOT);
 toto->SetVolume2(1, loader3, config.release());

Mercurial > hg > orthanc-stone

comparison Samples/Sdl/Loader.cpp @ 782:b24c208fa953