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

comparison Samples/Sdl/Loader.cpp @ 712:f334b098b243

IDicomVolumeSource

author	Sebastien Jodogne <s.jodogne@gmail.com>
date	Mon, 20 May 2019 14:56:03 +0200
parents	70d1c28560b3
children	e63c8b9b7b02

comparison

equal deleted inserted replaced

-:70d1c28560b3
+:f334b098b243
 * You should have received a copy of the GNU Affero General Public License
 * along with this program. If not, see <http://www.gnu.org/licenses/>.
 **/
 // From Stone
+#include "../../Framework/Loaders/BasicFetchingItemsSorter.h"
+#include "../../Framework/Loaders/BasicFetchingStrategy.h"
 #include "../../Framework/Messages/ICallable.h"
 #include "../../Framework/Messages/IMessage.h"
 #include "../../Framework/Messages/IObservable.h"
 #include "../../Framework/Messages/MessageBroker.h"
+#include "../../Framework/Scene2D/ColorTextureSceneLayer.h"
+#include "../../Framework/Scene2D/FloatTextureSceneLayer.h"
+#include "../../Framework/Scene2D/Scene2D.h"
 #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>
 double                            pixelSpacingY_;
 OrthancStone::CoordinateSystem3D  geometry_;
 OrthancStone::Vector              frameOffsets_;
 bool                              isColor_;
 bool                              hasRescale_;
-double                            rescaleOffset_;
+double                            rescaleIntercept_;
 double                            rescaleSlope_;
 bool                              hasDefaultWindowing_;
 float                             defaultWindowingCenter_;
 float                             defaultWindowingWidth_;
 Orthanc::PixelFormat              expectedPixelFormat_;
 isColor_ = (imageInformation_.GetPhotometricInterpretation() != Orthanc::PhotometricInterpretation_Monochrome1 &&
 imageInformation_.GetPhotometricInterpretation() != Orthanc::PhotometricInterpretation_Monochrome2);
 double doseGridScaling;
-if (dicom.ParseDouble(rescaleOffset_, Orthanc::DICOM_TAG_RESCALE_INTERCEPT) &&
+if (dicom.ParseDouble(rescaleIntercept_, Orthanc::DICOM_TAG_RESCALE_INTERCEPT) &&
 dicom.ParseDouble(rescaleSlope_, Orthanc::DICOM_TAG_RESCALE_SLOPE))
 {
 hasRescale_ = true;
 }
 else if (dicom.ParseDouble(doseGridScaling, Orthanc::DICOM_TAG_DOSE_GRID_SCALING))
 {
 hasRescale_ = true;
-rescaleOffset_ = 0;
+rescaleIntercept_ = 0;
 rescaleSlope_ = doseGridScaling;
 }
 else
 {
 hasRescale_ = false;
 double distance;
 return (OrthancStone::CoordinateSystem3D::GetDistance(distance, tmp, plane) &&
 distance <= thickness_ / 2.0);
 }
+void ApplyRescale(Orthanc::ImageAccessor& image,
+bool useDouble) const
+{
+if (image.GetFormat() != Orthanc::PixelFormat_Float32)
+{
+throw Orthanc::OrthancException(Orthanc::ErrorCode_IncompatibleImageFormat);
+}
+if (hasRescale_)
+{
+const unsigned int width = image.GetWidth();
+const unsigned int height = image.GetHeight();
+for (unsigned int y = 0; y < height; y++)
+{
+float* p = reinterpret_cast<float*>(image.GetRow(y));
+if (useDouble)
+{
+// Slower, accurate implementation using double
+for (unsigned int x = 0; x < width; x++, p++)
+{
+double value = static_cast<double>(*p);
+*p = static_cast<float>(value * rescaleSlope_ + rescaleIntercept_);
+}
+}
+else
+{
+// Fast, approximate implementation using float
+for (unsigned int x = 0; x < width; x++, p++)
+{
+*p = (*p) * static_cast<float>(rescaleSlope_) + static_cast<float>(rescaleIntercept_);
+}
+}
+}
+}
+}
 };
 Data  data_;
 public:
 bool HasRescale() const
 {
 return data_.hasRescale_;
 }
-double GetRescaleOffset() const
+double GetRescaleIntercept() const
 {
 if (data_.hasRescale_)
 {
-return data_.rescaleOffset_;
+return data_.rescaleIntercept_;
 }
 else
 {
 throw Orthanc::OrthancException(Orthanc::ErrorCode_BadSequenceOfCalls);
 }
 }
 Orthanc::PixelFormat GetExpectedPixelFormat() const
 {
 return data_.expectedPixelFormat_;
+}
+OrthancStone::TextureBaseSceneLayer* CreateTexture(const Orthanc::ImageAccessor& source) const
+{
+assert(sizeof(float) == 4);
+Orthanc::PixelFormat sourceFormat = source.GetFormat();
+if (sourceFormat != GetExpectedPixelFormat())
+{
+throw Orthanc::OrthancException(Orthanc::ErrorCode_IncompatibleImageFormat);
+}
+if (sourceFormat == Orthanc::PixelFormat_RGB24)
+{
+// This is the case of a color image. No conversion has to be done.
+return new OrthancStone::ColorTextureSceneLayer(source);
+}
+else
+{
+if (sourceFormat != Orthanc::PixelFormat_Grayscale16 &&
+sourceFormat != Orthanc::PixelFormat_Grayscale32 &&
+sourceFormat != Orthanc::PixelFormat_SignedGrayscale16)
+{
+throw Orthanc::OrthancException(Orthanc::ErrorCode_NotImplemented);
+}
+std::auto_ptr<OrthancStone::FloatTextureSceneLayer> texture;
+{
+// This is the case of a grayscale frame. Convert it to Float32.
+std::auto_ptr<Orthanc::Image> converted(new Orthanc::Image(Orthanc::PixelFormat_Float32,
+source.GetWidth(),
+source.GetHeight(),
+false));
+Orthanc::ImageProcessing::Convert(*converted, source);
+// Correct rescale slope/intercept if need be
+data_.ApplyRescale(*converted, (sourceFormat == Orthanc::PixelFormat_Grayscale32));
+texture.reset(new OrthancStone::FloatTextureSceneLayer(*converted));
+}
+if (data_.hasDefaultWindowing_)
+{
+texture->SetCustomWindowing(data_.defaultWindowingCenter_,
+data_.defaultWindowingWidth_);
+}
+return texture.release();
+}
 }
 };
 class DicomVolumeImage : public boost::noncopyable
 revision_ ++;
 slicesRevision_[index] += 1;
 }
 }
 };
+class IDicomVolumeSource : public boost::noncopyable
+{
+public:
+virtual ~IDicomVolumeSource()
+{
+}
+virtual const DicomVolumeImage& GetVolume() const = 0;
+virtual void NotifyAxialSliceAccessed(unsigned int sliceIndex) = 0;
+};
-class VolumeSeriesOrthancLoader : public OrthancStone::IObserver
+class VolumeSeriesOrthancLoader :
+public OrthancStone::IObserver,
+public IDicomVolumeSource
 {
 private:
 static const unsigned int LOW_QUALITY = 0;
 static const unsigned int MIDDLE_QUALITY = 1;
 static const unsigned int BEST_QUALITY = 2;
 std::auto_ptr<Refactoring::OrthancRestApiCommand> command(new Refactoring::OrthancRestApiCommand);
 command->SetUri("/series/" + seriesId + "/instances-tags");
 oracle_.Schedule(*this, command.release());
 }
+virtual const DicomVolumeImage& GetVolume() const
+{
+return volume_;
+}
+virtual void NotifyAxialSliceAccessed(unsigned int sliceIndex)
+{
+if (strategy_.get() == NULL)
+{
+// Should have called GetVolume().HasGeometry() before
+throw Orthanc::OrthancException(Orthanc::ErrorCode_BadSequenceOfCalls);
+}
+else
+{
+strategy_->SetCurrent(sliceIndex);
+}
+}
 };
 #if 0
 }
 };*/
-class DicomVolumeSlicer : public IVolumeSlicer
+class DicomVolumeMPRSlicer : public IVolumeSlicer
 {
 private:
 OrthancStone::Scene2D&          scene_;
 int                             layerDepth_;
-const DicomVolumeImage&         volume_;
+IDicomVolumeSource&             source_;
 bool                            first_;
 OrthancStone::VolumeProjection  lastProjection_;
 unsigned int                    lastSliceIndex_;
 uint64_t                        lastSliceRevision_;
 public:
-DicomVolumeSlicer(OrthancStone::Scene2D& scene,
+DicomVolumeMPRSlicer(OrthancStone::Scene2D& scene,
 int layerDepth,
-const DicomVolumeImage& volume) :
+IDicomVolumeSource& source) :
 scene_(scene),
 layerDepth_(layerDepth),
-volume_(volume),
+source_(source),
 first_(true)
 {
 }
 virtual void SetViewportPlane(const OrthancStone::CoordinateSystem3D& plane)
 {
-if (!volume_.HasGeometry())
+if (!source_.GetVolume().HasGeometry() ||
+source_.GetVolume().GetSlicesCount() == 0)
 {
 scene_.DeleteLayer(layerDepth_);
 return;
 }
 OrthancStone::VolumeProjection projection;
 unsigned int sliceIndex;
-if (!volume_.GetImage().GetGeometry().DetectSlice(projection, sliceIndex, plane))
+if (!source_.GetVolume().GetImage().GetGeometry().DetectSlice(projection, sliceIndex, plane))
 {
 // The cutting plane is neither axial, nor coronal, nor
 // sagittal. Could use "VolumeReslicer" here.
 scene_.DeleteLayer(layerDepth_);
 return;
 }
 uint64_t sliceRevision;
 if (projection == OrthancStone::VolumeProjection_Axial)
 {
-sliceRevision = volume_.GetSliceRevision(sliceIndex);
+sliceRevision = source_.GetVolume().GetSliceRevision(sliceIndex);
+if (first_ ||
+lastSliceIndex_ != sliceIndex)
+{
+// Reorder the prefetching queue
+source_.NotifyAxialSliceAccessed(sliceIndex);
+}
 }
 else
 {
 // For coronal and sagittal projections, we take the global
 // revision of the volume
-sliceRevision = volume_.GetRevision();
+sliceRevision = source_.GetVolume().GetRevision();
 }
 if (first_ ||
-lastProjection_ == projection ||
+lastProjection_ != projection ||
-lastSliceIndex_ == sliceIndex ||
+lastSliceIndex_ != sliceIndex ||
-lastSliceRevision_ == sliceRevision)
+lastSliceRevision_ != sliceRevision)
 {
-// Eiter the viewport plane, or the content of the slice have not
+// Either the viewport plane, or the content of the slice have not
 // changed since the last time the layer was set: Update is needed
 first_ = false;
 lastProjection_ = projection;
 lastSliceIndex_ = sliceIndex;
 lastSliceRevision_ = sliceRevision;
+std::auto_ptr<OrthancStone::TextureBaseSceneLayer> texture;
 {
-OrthancStone::ImageBuffer3D::SliceReader reader(volume_.GetImage(), projection, sliceIndex);
+const DicomInstanceParameters& parameters = source_.GetVolume().GetSliceParameters
+(projection == OrthancStone::VolumeProjection_Axial ? sliceIndex : 0);
-// TODO: Convert the image to Float32 or RGB24
+OrthancStone::ImageBuffer3D::SliceReader reader(source_.GetVolume().GetImage(), projection, sliceIndex);
-// TODO: Set the layer
+texture.reset(parameters.CreateTexture(reader.GetAccessor()));
 }
+// TODO -
+// void SetOrigin(double x, double y);
+// void SetPixelSpacing(double sx, double sy);
+// void SetAngle(double angle);
+// void SetLinearInterpolation(bool isLinearInterpolation);
+scene_.SetLayer(layerDepth_, texture.release());
 }
 }
 };

Mercurial > hg > orthanc-stone

comparison Samples/Sdl/Loader.cpp @ 712:f334b098b243