orthanc-stone: Framework/dev.h comparison

comparison Framework/dev.h @ 119:ba83e38cf3ff wasm

rendering of rt-dose

author	Sebastien Jodogne <s.jodogne@gmail.com>
date	Mon, 02 Oct 2017 22:01:41 +0200
parents	42c05a3baee3
children	063f7f3d9f14

comparison

equal deleted inserted replaced

-:a4d0b6c82b29
+:ba83e38cf3ff
 {
 private:
 OrthancSlicesLoader           loader_;
 std::auto_ptr<ImageBuffer3D>  image_;
 std::auto_ptr<DownloadStack>  downloadStack_;
+bool                          computeRange_;
 void ScheduleSliceDownload()
 {
 assert(downloadStack_.get() != NULL);
 unsigned int height = loader.GetSlice(0).GetHeight();
 Orthanc::PixelFormat format = loader.GetSlice(0).GetConverter().GetExpectedPixelFormat();
 LOG(INFO) << "Creating a volume image of size " << width << "x" << height
 << "x" << loader.GetSliceCount() << " in " << Orthanc::EnumerationToString(format);
-image_.reset(new ImageBuffer3D(format, width, height, loader.GetSliceCount()));
+image_.reset(new ImageBuffer3D(format, width, height, loader.GetSliceCount(), computeRange_));
 image_->SetAxialGeometry(loader.GetSlice(0).GetGeometry());
 image_->SetVoxelDimensions(loader.GetSlice(0).GetPixelSpacingX(),
 loader.GetSlice(0).GetPixelSpacingY(), spacingZ);
 image_->Clear();
 LOG(ERROR) << "Cannot download slice " << sliceIndex << " in a volume image";
 ScheduleSliceDownload();
 }
 public:
-OrthancVolumeImage(IWebService& orthanc) :
+OrthancVolumeImage(IWebService& orthanc,
-loader_(*this, orthanc)
+bool computeRange) :
+loader_(*this, orthanc),
+computeRange_(computeRange)
 {
 }
 void ScheduleLoadSeries(const std::string& seriesId)
 {
 throw Orthanc::OrthancException(Orthanc::ErrorCode_BadSequenceOfCalls);
 }
 else
 {
 return *image_;
+}
+}
+bool FitWindowingToRange(RenderStyle& style,
+const DicomFrameConverter& converter) const
+{
+if (image_.get() == NULL)
+{
+return false;
+}
+else
+{
+return image_->FitWindowingToRange(style, converter);
 }
 }
 };
 Vector origin = axial.GetGeometry().GetOrigin();
 origin += (static_cast<double>(volume.GetSliceCount() - 1) *
 axialThickness * axial.GetGeometry().GetNormal());
 reference_ = CoordinateSystem3D(origin,
 axial.GetGeometry().GetAxisX(),
 -axial.GetGeometry().GetNormal());
 }
 void SetupSagittal(const OrthancVolumeImage& volume)
 {
 const Slice& axial = volume.GetSlice(0);
 Vector origin = axial.GetGeometry().GetOrigin();
 origin += (static_cast<double>(volume.GetSliceCount() - 1) *
 axialThickness * axial.GetGeometry().GetNormal());
 reference_ = CoordinateSystem3D(origin,
 axial.GetGeometry().GetAxisY(),
 axial.GetGeometry().GetNormal());
 }
 public:
 VolumeImageGeometry(const OrthancVolumeImage& volume,
 VolumeProjection projection)
 break;
 default:
 throw Orthanc::OrthancException(Orthanc::ErrorCode_ParameterOutOfRange);
 }
+//sliceThickness_ = 3.0f;  // TODO XXXXX
 }
 size_t GetSliceCount() const
 {
 return depth_;
 index = static_cast<size_t>(s);
 return true;
 }
 }
-Slice GetSlice(size_t slice) const
+Slice* GetSlice(size_t slice) const
 {
 if (slice < 0 ||
 slice >= depth_)
 {
 throw Orthanc::OrthancException(Orthanc::ErrorCode_ParameterOutOfRange);
 }
 else
 {
 CoordinateSystem3D origin(reference_.GetOrigin() +
 static_cast<double>(slice) * sliceThickness_ * reference_.GetNormal(),
 reference_.GetAxisX(),
 reference_.GetAxisY());
-return Slice(origin, pixelSpacingX_, pixelSpacingY_, sliceThickness_,
+return new Slice(origin, pixelSpacingX_, pixelSpacingY_, sliceThickness_,
 width_, height_, converter_);
 }
 }
 };
 }
 else
 {
 // As the slices of the volumic image are arranged in a box,
 // we only consider one single reference slice (the one with index 0).
-GetProjectionGeometry(projection).GetSlice(0).GetExtent(points);
+std::auto_ptr<Slice> slice(GetProjectionGeometry(projection).GetSlice(0));
+slice->GetExtent(points);
 return true;
 }
 }
 // TODO Transfer ownership if non-axial, to avoid memcpy
 frame.reset(Orthanc::Image::Clone(reader.GetAccessor()));
 }
-Slice slice = geometry.GetSlice(closest);
+std::auto_ptr<Slice> slice(geometry.GetSlice(closest));
 LayerSourceBase::NotifyLayerReady(
-FrameRenderer::CreateRenderer(frame.release(), slice, isFullQuality),
+FrameRenderer::CreateRenderer(frame.release(), *slice, isFullQuality),
 //new SliceOutlineRenderer(slice),
-slice, false);
+*slice, false);
 return;
 }
 }
 // Error
 };
 class VolumeImageInteractor :
 public IWorldSceneInteractor,
-private ISlicedVolume::IObserver
+protected ISlicedVolume::IObserver
 {
 private:
 LayerWidget&                        widget_;
 VolumeProjection                    projection_;
 std::auto_ptr<VolumeImageGeometry>  slices_;
 size_t                              slice_;
+protected:
 virtual void NotifyGeometryReady(const ISlicedVolume& volume)
 {
 if (slices_.get() == NULL)
 {
 const OrthancVolumeImage& image = dynamic_cast<const OrthancVolumeImage&>(volume);
 void SetSlice(size_t slice)
 {
 if (slices_.get() != NULL)
 {
 slice_ = slice;
-widget_.SetSlice(slices_->GetSlice(slice_).GetGeometry());
+std::auto_ptr<Slice> tmp(slices_->GetSlice(slice_));
+widget_.SetSlice(tmp->GetGeometry());
 }
 }
 };

Mercurial > hg > orthanc-stone

comparison Framework/dev.h @ 119:ba83e38cf3ff wasm