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

comparison Samples/Sdl/Loader.cpp @ 765:f6438fdc447e

cont

author	Sebastien Jodogne <s.jodogne@gmail.com>
date	Thu, 23 May 2019 14:57:52 +0200
parents	f36a6f7e7bdf
children	d6cd7c5ca6ea

comparison

equal deleted inserted replaced

-:f36a6f7e7bdf
+:f6438fdc447e
 GetTarget().SetTransferSyntax(message.GetAnswer());
 }
 };
+class LoadUncompressedPixelData : public State
+{
+public:
+LoadUncompressedPixelData(OrthancMultiframeVolumeLoader& that) :
+State(that)
+{
+}
+virtual void Handle(const OrthancRestApiCommand::SuccessMessage& message) const
+{
+GetTarget().SetUncompressedPixelData(message.GetAnswer());
+}
+};
 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_;
 !HasGeometry())
 {
 return;
 }
-if (transferSyntaxUid_ != "1.2.840.10008.1.2" &&
+if (transferSyntaxUid_ == "1.2.840.10008.1.2" ||
-transferSyntaxUid_ != "1.2.840.10008.1.2.1" &&
+transferSyntaxUid_ == "1.2.840.10008.1.2.1" ||
-transferSyntaxUid_ != "1.2.840.10008.1.2.2")
+transferSyntaxUid_ == "1.2.840.10008.1.2.2")
+{
+std::auto_ptr<OrthancRestApiCommand> command(new OrthancRestApiCommand);
+command->SetHttpHeader("Accept-Encoding", "gzip");
+command->SetUri("/instances/" + instanceId_ + "/content/" +
+Orthanc::DICOM_TAG_PIXEL_DATA.Format() + "/0");
+command->SetPayload(new LoadUncompressedPixelData(*this));
+oracle_.Schedule(*this, command.release());
+}
+else
 {
 throw Orthanc::OrthancException(
 Orthanc::ErrorCode_NotImplemented,
 "No support for multiframe instances with transfer syntax: " + transferSyntaxUid_);
 }
 image_.reset(new ImageBuffer3D(format, width, height, depth,
 false /* don't compute range */));
 ScheduleFrameDownloads();
+}
+ORTHANC_FORCE_INLINE
+static void CopyPixel(uint32_t& target,
+const void* source)
+{
+// TODO - check alignement?
+target = le32toh(*reinterpret_cast<const uint32_t*>(source));
+}
+template <typename T>
+void CopyPixelData(const std::string& pixelData)
+{
+const Orthanc::PixelFormat format = image_->GetFormat();
+const unsigned int bpp = image_->GetBytesPerPixel();
+const unsigned int width = image_->GetWidth();
+const unsigned int height = image_->GetHeight();
+const unsigned int depth = image_->GetDepth();
+if (pixelData.size() != bpp * width * height * depth)
+{
+throw Orthanc::OrthancException(Orthanc::ErrorCode_BadFileFormat,
+"The pixel data has not the proper size");
+}
+if (pixelData.empty())
+{
+return;
+}
+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);
+assert (writer.GetAccessor().GetWidth() == width &&
+writer.GetAccessor().GetHeight() == height);
+for (unsigned int y = 0; y < height; y++)
+{
+assert(sizeof(T) == Orthanc::GetBytesPerPixel(format));
+T* target = reinterpret_cast<T*>(writer.GetAccessor().GetRow(y));
+for (unsigned int x = 0; x < width; x++)
+{
+CopyPixel(*target, source);
+target ++;
+source += bpp;
+}
+}
+}
+}
+void SetUncompressedPixelData(const std::string& pixelData)
+{
+switch (image_->GetFormat())
+{
+case Orthanc::PixelFormat_Grayscale32:
+CopyPixelData<uint32_t>(pixelData);
+break;
+default:
+throw Orthanc::OrthancException(Orthanc::ErrorCode_NotImplemented);
+}
+revision_ ++;
 }
 public:
 OrthancMultiframeVolumeLoader(IOracle& oracle,
 active_ = true;
 instanceId_ = instanceId;
 {
 std::auto_ptr<OrthancRestApiCommand> command(new OrthancRestApiCommand);
+command->SetHttpHeader("Accept-Encoding", "gzip");
 command->SetUri("/instances/" + instanceId + "/tags");
 command->SetPayload(new LoadGeometry(*this));
 oracle_.Schedule(*this, command.release());
 }
 Orthanc::PngWriter writer;
 writer.WriteToFile(buf, tmp);
 }
 }
+/**
+* The sleep() leads to a crash if the oracle is still running,
+* while this object is destroyed. Always stop the oracle before
+* destroying active objects.  (*)
+**/
+// boost::this_thread::sleep(boost::posix_time::seconds(2));
 oracle_.Schedule(*this, new OrthancStone::SleepOracleCommand(message.GetOrigin().GetDelay()));
 }
 }
 void Handle(const OrthancStone::OrthancRestApiCommand::SuccessMessage& message)
 }
 };
 void Run(OrthancStone::NativeApplicationContext& context,
-OrthancStone::IOracle& oracle)
+OrthancStone::ThreadedOracle& oracle)
 {
 boost::shared_ptr<Toto> toto;
 boost::shared_ptr<OrthancStone::OrthancSeriesVolumeProgressiveLoader> loader1, loader2;
 boost::shared_ptr<OrthancStone::OrthancMultiframeVolumeLoader> loader3;
 //loader1->LoadSeries("67f1b334-02c16752-45026e40-a5b60b6b-030ecab5");  // Lung 1/10mm
 toto->SetVolume(0, new OrthancStone::OrthancSeriesVolumeProgressiveLoader::MPRSlicer(loader1));
-LOG(WARNING) << "...Waiting for Ctrl-C...";
+{
-Orthanc::SystemToolbox::ServerBarrier();
+oracle.Start();
-//boost::this_thread::sleep(boost::posix_time::seconds(1));
+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
+* the running callback methods. Otherwise, the callbacks methods
+* might still be running while their parent object is destroyed,
+* resulting in crashes. This is very visible if adding a sleep(),
+* as in (*).
+**/
+oracle.Stop();
+}
 }
 /**
 //p.SetUrl("http://localhost:8043/");
 p.SetCredentials("orthanc", "orthanc");
 oracle.SetOrthancParameters(p);
 }
-oracle.Start();
+//oracle.Start();
 Run(context, oracle);
-oracle.Stop();
+//oracle.Stop();
 }
 catch (Orthanc::OrthancException& e)
 {
 LOG(ERROR) << "EXCEPTION: " << e.What();
 }

Mercurial > hg > orthanc-stone

comparison Samples/Sdl/Loader.cpp @ 765:f6438fdc447e