orthanc-stone: Framework/dev.h comparison

comparison Framework/dev.h @ 551:90f3a60576a9 dev rtviewer19

Merged in ct-pet-dose-struct (pull request #2) Ct pet dose struct

author	Benjamin Golinvaux <bgo@osimis.io>
date	Tue, 02 Apr 2019 14:02:12 +0000
parents	1d9deb4ee84c
children	573e35378999

comparison

equal deleted inserted replaced

-:e1ba16436d59
+:90f3a60576a9
 OrthancSlicesLoader           loader_;
 std::auto_ptr<ImageBuffer3D>  image_;
 std::auto_ptr<DownloadStack>  downloadStack_;
 bool                          computeRange_;
 size_t                        pendingSlices_;
 void ScheduleSliceDownload()
 {
 assert(downloadStack_.get() != NULL);
 unsigned int slice;
 const Slice& b)
 {
 if (!GeometryToolbox::IsParallel(a.GetGeometry().GetNormal(),
 b.GetGeometry().GetNormal()))
 {
-LOG(ERROR) << "Some slice in the volume image is not parallel to the others";
+LOG(ERROR) << "A slice in the volume image is not parallel to the others.";
 return false;
 }
 if (a.GetConverter().GetExpectedPixelFormat() != b.GetConverter().GetExpectedPixelFormat())
 {
-LOG(ERROR) << "The pixel format changes across the slices of the volume image";
+LOG(ERROR) << "The pixel format changes across the slices of the volume image.";
 return false;
 }
 if (a.GetWidth() != b.GetWidth() ||
 a.GetHeight() != b.GetHeight())
 {
-LOG(ERROR) << "The width/height of the slices change across the volume image";
+LOG(ERROR) << "The slices dimensions (width/height) are varying throughout the volume image";
 return false;
 }
 if (!LinearAlgebra::IsNear(a.GetPixelSpacingX(), b.GetPixelSpacingX()) ||
 !LinearAlgebra::IsNear(a.GetPixelSpacingY(), b.GetPixelSpacingY()))
 void OnSliceGeometryReady(const OrthancSlicesLoader::SliceGeometryReadyMessage& message)
 {
 assert(&message.GetOrigin() == &loader_);
 if (loader_.GetSliceCount() == 0)
 {
 LOG(ERROR) << "Empty volume image";
 EmitMessage(ISlicedVolume::GeometryErrorMessage(*this));
 return;
 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(), computeRange_));
+image_.reset(new ImageBuffer3D(format, width, height, static_cast<unsigned int>(loader_.GetSliceCount()), computeRange_));
 image_->SetAxialGeometry(loader_.GetSlice(0).GetGeometry());
 image_->SetVoxelDimensions(loader_.GetSlice(0).GetPixelSpacingX(),
 loader_.GetSlice(0).GetPixelSpacingY(), spacingZ);
 image_->Clear();
-downloadStack_.reset(new DownloadStack(loader_.GetSliceCount()));
+downloadStack_.reset(new DownloadStack(static_cast<unsigned int>(loader_.GetSliceCount())));
 pendingSlices_ = loader_.GetSliceCount();
 for (unsigned int i = 0; i < 4; i++)  // Limit to 4 simultaneous downloads
 {
 ScheduleSliceDownload();
 // TODO Check the DicomFrameConverter are constant
 EmitMessage(ISlicedVolume::GeometryReadyMessage(*this));
 }
 void OnSliceGeometryError(const OrthancSlicesLoader::SliceGeometryErrorMessage& message)
 {
 assert(&message.GetOrigin() == &loader_);
 LOG(ERROR) << "Unable to download a volume image";
 EmitMessage(ISlicedVolume::GeometryErrorMessage(*this));
 }
 void OnSliceImageReady(const OrthancSlicesLoader::SliceImageReadyMessage& message)
 {
 assert(&message.GetOrigin() == &loader_);
 {
 }
 ScheduleSliceDownload();
 }
 void OnSliceImageError(const OrthancSlicesLoader::SliceImageErrorMessage& message)
 {
 assert(&message.GetOrigin() == &loader_);
 LOG(ERROR) << "Cannot download slice " << message.GetSliceIndex() << " in a volume image";
 double               pixelSpacingX_;
 double               pixelSpacingY_;
 double               sliceThickness_;
 CoordinateSystem3D   reference_;
 DicomFrameConverter  converter_;
 double ComputeAxialThickness(const OrthancVolumeImage& volume) const
 {
 double thickness;
 size_t n = volume.GetSliceCount();
 if (n > 1)
 {
 const Slice& a = volume.GetSlice(0);
 const Slice& b = volume.GetSlice(n - 1);
 else
 {
 return thickness;
 }
 }
 void SetupAxial(const OrthancVolumeImage& volume)
 {
 const Slice& axial = volume.GetSlice(0);
 width_ = axial.GetWidth();
 height_ = axial.GetHeight();
 depth_ = volume.GetSliceCount();
 pixelSpacingX_ = axial.GetPixelSpacingX();
 {
 const Slice& axial = volume.GetSlice(0);
 double axialThickness = ComputeAxialThickness(volume);
 width_ = axial.GetWidth();
-height_ = volume.GetSliceCount();
+height_ = static_cast<unsigned int>(volume.GetSliceCount());
 depth_ = axial.GetHeight();
 pixelSpacingX_ = axial.GetPixelSpacingX();
 pixelSpacingY_ = axialThickness;
 sliceThickness_ = axial.GetPixelSpacingY();
 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());
+- axial.GetGeometry().GetNormal());
 }
 void SetupSagittal(const OrthancVolumeImage& volume)
 {
 const Slice& axial = volume.GetSlice(0);
 double axialThickness = ComputeAxialThickness(volume);
 width_ = axial.GetHeight();
-height_ = volume.GetSliceCount();
+height_ = static_cast<unsigned int>(volume.GetSliceCount());
 depth_ = axial.GetWidth();
 pixelSpacingX_ = axial.GetPixelSpacingY();
 pixelSpacingY_ = axialThickness;
 sliceThickness_ = axial.GetPixelSpacingX();
 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());
 }
 converter_ = volume.GetSlice(0).GetConverter();
 switch (projection)
 {
 case VolumeProjection_Axial:
 SetupAxial(volume);
 break;
 case VolumeProjection_Coronal:
 SetupCoronal(volume);
 break;
 case VolumeProjection_Sagittal:
 SetupSagittal(volume);
 break;
 default:
 throw Orthanc::OrthancException(Orthanc::ErrorCode_ParameterOutOfRange);
 }
 }
 size_t GetSliceCount() const
 {
 const Vector& GetNormal() const
 {
 return reference_.GetNormal();
 }
 bool LookupSlice(size_t& index,
 const CoordinateSystem3D& slice) const
 {
 bool opposite;
 if (!GeometryToolbox::IsParallelOrOpposite(opposite,
 reference_.GetNormal(),
 slice.GetNormal()))
 {
 return false;
 }
 double z = (reference_.ProjectAlongNormal(slice.GetOrigin()) -
 reference_.ProjectAlongNormal(reference_.GetOrigin())) / sliceThickness_;
 int s = static_cast<int>(boost::math::iround(z));
 if (s < 0 ||
 s >= static_cast<int>(depth_))
 {
 return false;
 }
 else
 {
 public:
 RendererFactory(const Orthanc::ImageAccessor& frame,
 const Slice& slice,
 bool isFullQuality) :
 frame_(frame),
 slice_(slice),
 isFullQuality_(isFullQuality)
 {
 }
 virtual ILayerRenderer* CreateRenderer() const
 {
 OrthancVolumeImage&                 volume_;
 std::auto_ptr<VolumeImageGeometry>  axialGeometry_;
 std::auto_ptr<VolumeImageGeometry>  coronalGeometry_;
 std::auto_ptr<VolumeImageGeometry>  sagittalGeometry_;
 bool IsGeometryReady() const
 {
 return axialGeometry_.get() != NULL;
 }
 void OnGeometryReady(const ISlicedVolume::GeometryReadyMessage& message)
 {
 assert(&message.GetOrigin() == &volume_);
 // These 3 values are only used to speed up the IVolumeSlicer
 axialGeometry_.reset(new VolumeImageGeometry(volume_, VolumeProjection_Axial));
 coronalGeometry_.reset(new VolumeImageGeometry(volume_, VolumeProjection_Coronal));
 sagittalGeometry_.reset(new VolumeImageGeometry(volume_, VolumeProjection_Sagittal));
 EmitMessage(IVolumeSlicer::GeometryReadyMessage(*this));
 }
 void OnGeometryError(const ISlicedVolume::GeometryErrorMessage& message)
 {
 assert(&message.GetOrigin() == &volume_);
 EmitMessage(IVolumeSlicer::GeometryErrorMessage(*this));
 }
 void OnContentChanged(const ISlicedVolume::ContentChangedMessage& message)
 {
 assert(&message.GetOrigin() == &volume_);
 EmitMessage(IVolumeSlicer::ContentChangedMessage(*this));
 }
 void OnSliceContentChanged(const ISlicedVolume::SliceContentChangedMessage& message)
 {
 throw Orthanc::OrthancException(Orthanc::ErrorCode_BadSequenceOfCalls);
 }
 switch (projection)
 {
 case VolumeProjection_Axial:
 return *axialGeometry_;
 case VolumeProjection_Sagittal:
 return *sagittalGeometry_;
 case VolumeProjection_Coronal:
 return *coronalGeometry_;
 default:
 throw Orthanc::OrthancException(Orthanc::ErrorCode_InternalError);
 }
 }
 bool DetectProjection(VolumeProjection& projection,
 }
 }
 public:
 VolumeImageMPRSlicer(MessageBroker& broker,
 OrthancVolumeImage&  volume) :
 IVolumeSlicer(broker),
 IObserver(broker),
 volume_(volume)
 {
 volume_.RegisterObserverCallback(
 new Callable<VolumeImageMPRSlicer, ISlicedVolume::GeometryReadyMessage>
 (*this, &VolumeImageMPRSlicer::OnGeometryReady));
 virtual bool GetExtent(std::vector<Vector>& points,
 const CoordinateSystem3D& viewportSlice) ORTHANC_OVERRIDE
 {
 VolumeProjection projection;
 if (!IsGeometryReady() ||
 !DetectProjection(projection, viewportSlice))
 {
 return false;
 }
 {
 // As the slices of the volumic image are arranged in a box,
 // we only consider one single reference slice (the one with index 0).
 std::auto_ptr<Slice> slice(GetProjectionGeometry(projection).GetSlice(0));
 slice->GetExtent(points);
 return true;
 }
 }
 virtual void ScheduleLayerCreation(const CoordinateSystem3D& viewportSlice) ORTHANC_OVERRIDE
 {
 VolumeProjection projection;
 if (IsGeometryReady() &&
 DetectProjection(projection, viewportSlice))
 {
 const VolumeImageGeometry& geometry = GetProjectionGeometry(projection);
 bool isFullQuality = true;  // TODO
 std::auto_ptr<Orthanc::Image> frame;
 {
-ImageBuffer3D::SliceReader reader(volume_.GetImage(), projection, closest);
+ImageBuffer3D::SliceReader reader(volume_.GetImage(), projection, static_cast<unsigned int>(closest));
 // TODO Transfer ownership if non-axial, to avoid memcpy
 frame.reset(Orthanc::Image::Clone(reader.GetAccessor()));
 }
 }
 virtual IWorldSceneMouseTracker* CreateMouseTracker(WorldSceneWidget& widget,
 const ViewportGeometry& view,
 MouseButton button,
+KeyboardModifiers modifiers,
+int viewportX,
+int viewportY,
 double x,
 double y,
-IStatusBar* statusBar)
+IStatusBar* statusBar,
-{
+const std::vector<Touch>& touches) ORTHANC_OVERRIDE
-return NULL;
+{
+return  NULL;
 }
 virtual void MouseOver(CairoContext& context,
 WorldSceneWidget& widget,
 const ViewportGeometry& view,
 double x,
 double y,
-IStatusBar* statusBar)
+IStatusBar* statusBar) ORTHANC_OVERRIDE
 {
 }
 virtual void MouseWheel(WorldSceneWidget& widget,
 MouseWheelDirection direction,
 KeyboardModifiers modifiers,
-IStatusBar* statusBar)
+IStatusBar* statusBar) ORTHANC_OVERRIDE
 {
 int scale = (modifiers & KeyboardModifiers_Control ? 10 : 1);
 switch (direction)
 {
 case MouseWheelDirection_Up:
 OffsetSlice(-scale);
 break;
 case MouseWheelDirection_Down:
 OffsetSlice(scale);
 break;
 default:
 break;
 }
 }
 virtual void KeyPressed(WorldSceneWidget& widget,
 KeyboardKeys key,
 char keyChar,
 KeyboardModifiers modifiers,
-IStatusBar* statusBar)
+IStatusBar* statusBar) ORTHANC_OVERRIDE
 {
 switch (keyChar)
 {
 case 's':
 widget.FitContent();
 break;
 default:
 break;
 }
 }
 public:
 VolumeImageInteractor(MessageBroker& broker,
 OrthancVolumeImage& volume,
 SliceViewerWidget& widget,
 VolumeProjection projection) :
 IObserver(broker),
 widget_(widget),
 projection_(projection)
 {
 widget.SetInteractor(*this);
 volume.RegisterObserverCallback(
 new Callable<VolumeImageInteractor, ISlicedVolume::GeometryReadyMessage>
 slice = 0;
 }
 if (slice >= static_cast<int>(slices_->GetSliceCount()))
 {
-slice = slices_->GetSliceCount() - 1;
+slice = static_cast<unsigned int>(slices_->GetSliceCount()) - 1;
 }
 if (slice != static_cast<int>(slice_))
 {
 SetSlice(slice);
 };
 SliceViewerWidget&  otherPlane_;
 public:
 ReferenceLineSource(MessageBroker& broker,
 SliceViewerWidget&  otherPlane) :
 IVolumeSlicer(broker),
 otherPlane_(otherPlane)
 {
 EmitMessage(IVolumeSlicer::GeometryReadyMessage(*this));
 }
 virtual void ScheduleLayerCreation(const CoordinateSystem3D& viewportSlice)
 {
 Slice reference(viewportSlice, 0.001);
 Vector p, d;
 const CoordinateSystem3D& slice = otherPlane_.GetSlice();
 // Compute the line of intersection between the two slices
 double x1, y1, x2, y2;
 viewportSlice.ProjectPoint(x1, y1, p);
 viewportSlice.ProjectPoint(x2, y2, p + 1000.0 * d);
 const Extent2D extent = otherPlane_.GetSceneExtent();
 if (GeometryToolbox::ClipLineToRectangle(x1, y1, x2, y2,
 x1, y1, x2, y2,
 extent.GetX1(), extent.GetY1(),
 extent.GetX2(), extent.GetY2()))
 {

Mercurial > hg > orthanc-stone

comparison Framework/dev.h @ 551:90f3a60576a9 dev rtviewer19