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

comparison Samples/Sdl/Loader.cpp @ 778:78fcb907caf6

VolumeGeometryReadyMessage

author	Sebastien Jodogne <s.jodogne@gmail.com>
date	Mon, 27 May 2019 09:49:44 +0200
parents	0387485f048b
children	e72a9fef3d19

comparison

equal deleted inserted replaced

-:7b404c853e66
+:78fcb907caf6
 virtual ExtractedSlice* ExtractSlice(const CoordinateSystem3D& cuttingPlane) const = 0;
 };
-// TODO -> Remove
+class VolumeGeometryReadyMessage : public OriginMessage<IVolumeSlicer>
-class IVolumeImageSlicer : public IVolumeSlicer
+{
-{
+ORTHANC_STONE_MESSAGE(__FILE__, __LINE__);
+private:
+const VolumeImageGeometry&  geometry_;
 public:
-virtual bool HasGeometry() const = 0;
+VolumeGeometryReadyMessage(const IVolumeSlicer& slicer,
+const VolumeImageGeometry& geometry) :
-virtual const VolumeImageGeometry& GetGeometry() const = 0;
+OriginMessage(slicer),
+geometry_(geometry)
+{
+}
+const VolumeImageGeometry& GetGeometry() const
+{
+return geometry_;
+}
 };
 class InvalidExtractedSlice : public IVolumeSlicer::ExtractedSlice
 {
 public:
 virtual bool IsValid()
 };
 class OrthancSeriesVolumeProgressiveLoader :
-public IObserver
+public IObserver,
+public IObservable,
+public IVolumeSlicer
 {
 private:
 static const unsigned int LOW_QUALITY = 0;
 static const unsigned int MIDDLE_QUALITY = 1;
 static const unsigned int BEST_QUALITY = 2;
 CoordinateSystem3D geometry = instance->GetGeometry();
 slices.AddSlice(geometry, instance.release());
 }
 volume_.SetGeometry(slices);
+BroadcastMessage(VolumeGeometryReadyMessage(*this, volume_.GetGeometry()));
 }
 if (volume_.GetSlicesCount() != 0)
 {
 strategy_.reset(new BasicFetchingStrategy(sorter_->CreateSorter(
 std::auto_ptr<IFetchingItemsSorter::IFactory>  sorter_;
 std::auto_ptr<IFetchingStrategy>               strategy_;
-IVolumeSlicer::ExtractedSlice* ExtractOrthogonalSlice(const CoordinateSystem3D& cuttingPlane) const
-{
-if (volume_.HasGeometry() &&
-volume_.GetSlicesCount() != 0)
-{
-std::auto_ptr<DicomVolumeImageOrthogonalSlice> slice
-(new DicomSeriesVolumeImage::ExtractedOrthogonalSlice(volume_, cuttingPlane));
-assert(slice.get() != NULL &&
-strategy_.get() != NULL);
-if (slice->IsValid() &&
-slice->GetProjection() == VolumeProjection_Axial)
-{
-strategy_->SetCurrent(slice->GetSliceIndex());
-}
-return slice.release();
-}
-else
-{
-return new InvalidExtractedSlice;
-}
-}
 public:
-class MPRSlicer : public IVolumeImageSlicer
-{
-private:
-boost::shared_ptr<OrthancSeriesVolumeProgressiveLoader>  that_;
-public:
-MPRSlicer(const boost::shared_ptr<OrthancSeriesVolumeProgressiveLoader>& that) :
-that_(that)
-{
-}
-virtual ExtractedSlice* ExtractSlice(const CoordinateSystem3D& cuttingPlane) const
-{
-return that_->ExtractOrthogonalSlice(cuttingPlane);
-}
-virtual bool HasGeometry() const
-{
-return that_->GetVolume().HasGeometry();
-}
-virtual const VolumeImageGeometry& GetGeometry() const
-{
-return that_->GetVolume().GetGeometry();
-}
-};
 OrthancSeriesVolumeProgressiveLoader(IOracle& oracle,
 IObservable& oracleObservable) :
 IObserver(oracleObservable.GetBroker()),
+IObservable(oracleObservable.GetBroker()),
 oracle_(oracle),
 active_(false),
 simultaneousDownloads_(4),
 sorter_(new BasicFetchingItemsSorter::Factory)
 {
 const DicomSeriesVolumeImage& GetVolume() const
 {
 return volume_;
 }
+virtual ExtractedSlice* ExtractSlice(const CoordinateSystem3D& cuttingPlane) const
+{
+if (volume_.HasGeometry() &&
+volume_.GetSlicesCount() != 0)
+{
+std::auto_ptr<DicomVolumeImageOrthogonalSlice> slice
+(new DicomSeriesVolumeImage::ExtractedOrthogonalSlice(volume_, cuttingPlane));
+assert(slice.get() != NULL &&
+strategy_.get() != NULL);
+if (slice->IsValid() &&
+slice->GetProjection() == VolumeProjection_Axial)
+{
+strategy_->SetCurrent(slice->GetSliceIndex());
+}
+return slice.release();
+}
+else
+{
+return new InvalidExtractedSlice;
+}
+}
 };
-class OrthancMultiframeVolumeLoader : public IObserver
+class OrthancMultiframeVolumeLoader :
+public IObserver,
+public IObservable,
+public IVolumeSlicer
 {
 private:
 class State : public Orthanc::IDynamicObject
 {
 private:
 image_.reset(new ImageBuffer3D(format, width, height, depth,
 false /* don't compute range */));
 image_->Clear();
 ScheduleFrameDownloads();
+BroadcastMessage(VolumeGeometryReadyMessage(*this, *geometry_));
 }
 ORTHANC_FORCE_INLINE
 static void CopyPixel(uint32_t& target,
 }
 };
 public:
-class MPRSlicer : public IVolumeImageSlicer
-{
-private:
-boost::shared_ptr<OrthancMultiframeVolumeLoader>  that_;
-public:
-MPRSlicer(const boost::shared_ptr<OrthancMultiframeVolumeLoader>& that) :
-that_(that)
-{
-}
-virtual ExtractedSlice* ExtractSlice(const CoordinateSystem3D& cuttingPlane) const
-{
-if (that_->HasGeometry())
-{
-return new ExtractedOrthogonalSlice(*that_, cuttingPlane);
-}
-else
-{
-return new InvalidExtractedSlice;
-}
-}
-virtual bool HasGeometry() const
-{
-return that_->HasGeometry();
-}
-virtual const VolumeImageGeometry& GetGeometry() const
-{
-return that_->GetGeometry();
-}
-};
 OrthancMultiframeVolumeLoader(IOracle& oracle,
 IObservable& oracleObservable) :
 IObserver(oracleObservable.GetBroker()),
+IObservable(oracleObservable.GetBroker()),
 oracle_(oracle),
 active_(false),
 revision_(0)
 {
 oracleObservable.RegisterObserverCallback(
 std::auto_ptr<OrthancRestApiCommand> command(new OrthancRestApiCommand);
 command->SetUri("/instances/" + instanceId + "/metadata/TransferSyntax");
 command->SetPayload(new LoadTransferSyntax(*this));
 oracle_.Schedule(*this, command.release());
 }
+}
+}
+virtual ExtractedSlice* ExtractSlice(const CoordinateSystem3D& cuttingPlane) const
+{
+if (HasGeometry())
+{
+return new ExtractedOrthogonalSlice(*this, cuttingPlane);
+}
+else
+{
+return new InvalidExtractedSlice;
 }
 }
 };
 }
 public:
 VolumeSceneLayerSource(Scene2D& scene,
 int layerDepth,
-IVolumeSlicer* slicer) :   // Takes ownership
+const boost::shared_ptr<IVolumeSlicer>& slicer) :
 scene_(scene),
 layerDepth_(layerDepth),
 slicer_(slicer)
 {
 if (slicer == NULL)
 class Toto : public OrthancStone::IObserver
 {
 private:
-OrthancStone::IOracle& oracle_;
+OrthancStone::CoordinateSystem3D  plane_;
+OrthancStone::IOracle&            oracle_;
 OrthancStone::Scene2D             scene_;
 std::auto_ptr<OrthancStone::VolumeSceneLayerSource>  source1_, source2_;
+void Handle(const OrthancStone::VolumeGeometryReadyMessage& message)
+{
+printf("Geometry ready\n");
+if (&source1_->GetSlicer() == &message.GetOrigin())
+{
+//plane_ = message.GetGeometry().GetSagittalGeometry();
+//plane_ = message.GetGeometry().GetAxialGeometry();
+plane_ = message.GetGeometry().GetCoronalGeometry();
+plane_.SetOrigin(message.GetGeometry().GetCoordinates(0.5f, 0.5f, 0.5f));
+}
+}
-OrthancStone::CoordinateSystem3D GetSamplePlane
-(const OrthancStone::VolumeSceneLayerSource& source) const
-{
-const OrthancStone::IVolumeImageSlicer& slicer =
-dynamic_cast<const OrthancStone::IVolumeImageSlicer&>(source.GetSlicer());
-OrthancStone::CoordinateSystem3D plane;
-if (slicer.HasGeometry())
-{
-//plane = slicer.GetGeometry().GetSagittalGeometry();
-//plane = slicer.GetGeometry().GetAxialGeometry();
-plane = slicer.GetGeometry().GetCoronalGeometry();
-plane.SetOrigin(slicer.GetGeometry().GetCoordinates(0.5f, 0.5f, 0.5f));
-}
-return plane;
-}
 void Handle(const OrthancStone::SleepOracleCommand::TimeoutMessage& message)
 {
 if (message.GetOrigin().HasPayload())
 {
 printf("TIMEOUT! %d\n", dynamic_cast<const Orthanc::SingleValueObject<unsigned int>& >(message.GetOrigin().GetPayload()).GetValue());
 }
 else
 {
 printf("TIMEOUT\n");
-OrthancStone::CoordinateSystem3D plane;
 if (source1_.get() != NULL)
 {
-plane = GetSamplePlane(*source1_);
+source1_->Update(plane_);
-}
-else if (source2_.get() != NULL)
-{
-plane = GetSamplePlane(*source2_);
-}
-if (source1_.get() != NULL)
-{
-source1_->Update(plane);
 }
 if (source2_.get() != NULL)
 {
-source2_->Update(plane);
+source2_->Update(plane_);
 }
 scene_.FitContent(1024, 768);
 {
 (new OrthancStone::Callable
 <Toto, OrthancStone::OracleCommandExceptionMessage>(*this, &Toto::Handle));
 }
 void SetVolume1(int depth,
-OrthancStone::IVolumeSlicer* volume,
+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));
 source1_.reset(new OrthancStone::VolumeSceneLayerSource(scene_, depth, volume));
 if (style != NULL)
 {
 source1_->SetConfigurator(style);
 }
 }
 void SetVolume2(int depth,
-OrthancStone::IVolumeSlicer* volume,
+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));
 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()));
 }
+toto->SetVolume1(0, loader1, new OrthancStone::GrayscaleStyleConfigurator);
+toto->SetVolume2(1, loader3, new OrthancStone::LookupTableStyleConfigurator);
 oracle.Schedule(*toto, new OrthancStone::SleepOracleCommand(100));
 if (0)
 {
 Json::Value v = Json::objectValue;
 // Delphine
 //loader1->LoadSeries("5990e39c-51e5f201-fe87a54c-31a55943-e59ef80e");  // CT
 //loader1->LoadSeries("67f1b334-02c16752-45026e40-a5b60b6b-030ecab5");  // Lung 1/10mm
-toto->SetVolume2(1, new OrthancStone::OrthancMultiframeVolumeLoader::MPRSlicer(loader3),
+{
-new OrthancStone::LookupTableStyleConfigurator);
+LOG(WARNING) << "...Waiting for Ctrl-C...";
-toto->SetVolume1(0, new OrthancStone::OrthancSeriesVolumeProgressiveLoader::MPRSlicer(loader1),
-new OrthancStone::GrayscaleStyleConfigurator);
-{
 oracle.Start();
-LOG(WARNING) << "...Waiting for Ctrl-C...";
 Orthanc::SystemToolbox::ServerBarrier();
 /**
 * WARNING => The oracle must be stopped BEFORE the objects using
 * it are destroyed!!! This forces to wait for the completion of
 * to `SDL_main'". https://wiki.libsdl.org/FAQWindows
 **/
 int main(int argc, char* argv[])
 {
 OrthancStone::StoneInitialize();
-Orthanc::Logging::EnableInfoLevel(true);
+//Orthanc::Logging::EnableInfoLevel(true);
 try
 {
 OrthancStone::NativeApplicationContext context;

Mercurial > hg > orthanc-stone

comparison Samples/Sdl/Loader.cpp @ 778:78fcb907caf6