orthanc-stone: Framework/dev.h comparison

comparison Framework/dev.h @ 318:3a4ca166fafa am-2

ImageAccessor refactoring + implemented Image Cache in SmartLoader

author	am@osimis.io
date	Mon, 08 Oct 2018 17:10:08 +0200
parents	b4abaeb783b1
children	8716176ff7f0

comparison

equal deleted inserted replaced

-:b66d13708f40
+:3a4ca166fafa
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Affero General Public License for more details.
 *
 * 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/>.
 **/
 namespace OrthancStone
 {
 // TODO: Handle errors while loading
 class OrthancVolumeImage :
 public SlicedVolumeBase,
 public OrthancStone::IObserver
 {
 private:
 OrthancSlicesLoader           loader_;
 std::auto_ptr<ImageBuffer3D>  image_;
 std::auto_ptr<DownloadStack>  downloadStack_;
 bool                          computeRange_;
 loader_.ScheduleLoadSliceImage(slice, SliceImageQuality_Jpeg90);
 }
 }
 static bool IsCompatible(const Slice& a,
 const Slice& b)
 {
 if (!GeometryToolbox::IsParallel(a.GetGeometry().GetNormal(),
 b.GetGeometry().GetNormal()))
 {
 return true;
 }
 static double GetDistance(const Slice& a,
 const Slice& b)
 {
 return fabs(a.GetGeometry().ProjectAlongNormal(a.GetGeometry().GetOrigin()) -
 a.GetGeometry().ProjectAlongNormal(b.GetGeometry().GetOrigin()));
 }
 void OnSliceGeometryReady(const OrthancSlicesLoader& loader)
 SlicedVolumeBase::NotifyGeometryReady();
 }
 virtual void OnSliceImageReady(const OrthancSlicesLoader& loader,
 unsigned int sliceIndex,
 const Slice& slice,
-std::auto_ptr<Orthanc::ImageAccessor>& image,
+const boost::shared_ptr<Orthanc::ImageAccessor>& image,
 SliceImageQuality quality)
 {
 {
 ImageBuffer3D::SliceWriter writer(*image_, VolumeProjection_Axial, sliceIndex);
 Orthanc::ImageProcessing::Copy(writer.GetAccessor(), *image);
 }
 msg.image_,
 msg.effectiveQuality_);
 }; break;
 case MessageType_SliceLoader_ImageError:
 {
 const OrthancSlicesLoader::SliceImageErrorMessage& msg = dynamic_cast<const OrthancSlicesLoader::SliceImageErrorMessage&>(message);
 LOG(ERROR) << "Cannot download slice " << msg.sliceIndex_ << " in a volume image";
 ScheduleSliceDownload();
 }; break;
 default:
 VLOG("unhandled message type" << message.GetType());
 }
 }
 public:
 OrthancVolumeImage(MessageBroker& broker,
 OrthancApiClient& orthanc,
 bool computeRange) :
 OrthancStone::IObserver(broker),
 loader_(broker, orthanc),
 computeRange_(computeRange),
 pendingSlices_(0)
 {
 // TODO: replace with new callables loader_.RegisterObserver(*this);
 }
 void ScheduleLoadSeries(const std::string& seriesId)
 {
 loader_.ScheduleLoadSeries(seriesId);
 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)
 {
 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,
 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
 {
 };
 class VolumeImageSource :
 public LayerSourceBase,
 private ISlicedVolume::IObserver
 {
 private:
 OrthancVolumeImage&                 volume_;
 std::auto_ptr<VolumeImageGeometry>  axialGeometry_;
 std::auto_ptr<VolumeImageGeometry>  coronalGeometry_;
 coronalGeometry_.reset(new VolumeImageGeometry(volume_, VolumeProjection_Coronal));
 sagittalGeometry_.reset(new VolumeImageGeometry(volume_, VolumeProjection_Sagittal));
 LayerSourceBase::NotifyGeometryReady();
 }
 virtual void NotifyGeometryError(const ISlicedVolume& volume)
 {
 LayerSourceBase::NotifyGeometryError();
 }
 virtual void NotifyContentChange(const ISlicedVolume& volume)
 {
 LayerSourceBase::NotifyContentChange();
 }
 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,
 !DetectProjection(projection, viewportSlice))
 {
 return false;
 }
 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).
 std::auto_ptr<Slice> slice(GetProjectionGeometry(projection).GetSlice(0));
 slice->GetExtent(points);
 frame.reset(Orthanc::Image::Clone(reader.GetAccessor()));
 }
 std::auto_ptr<Slice> slice(geometry.GetSlice(closest));
 LayerSourceBase::NotifyLayerReady(
 FrameRenderer::CreateRenderer(frame.release(), *slice, isFullQuality),
 //new SliceOutlineRenderer(slice),
 slice->GetGeometry(), false);
 return;
 }
 }
 // Error
 }
 };
 class VolumeImageInteractor :
 public IWorldSceneInteractor,
 protected ISlicedVolume::IObserver
 {
 private:
 LayerWidget&                        widget_;
 VolumeProjection                    projection_;
 std::auto_ptr<VolumeImageGeometry>  slices_;
 SetSlice(slices_->GetSliceCount() / 2);
 widget_.SetDefaultView();
 }
 }
 virtual void NotifyGeometryError(const ISlicedVolume& volume)
 {
 }
 virtual void NotifyContentChange(const ISlicedVolume& volume)
 {
 }
 virtual void NotifySliceChange(const ISlicedVolume& volume,
 MouseWheelDirection direction,
 KeyboardModifiers modifiers,
 IStatusBar* statusBar)
 {
 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,
 char key,
 KeyboardModifiers modifiers,
 IStatusBar* statusBar)
 {
 switch (key)
 {
 case 's':
 widget.SetDefaultView();
 break;
 default:
 break;
 }
 }
 public:
 VolumeImageInteractor(OrthancVolumeImage& volume,
 LayerWidget& widget,
 VolumeProjection projection) :
 widget_(widget),
 if (slice >= static_cast<int>(slices_->GetSliceCount()))
 {
 slice = slices_->GetSliceCount() - 1;
 }
 if (slice != static_cast<int>(slice_))
 {
 SetSlice(slice);
 }
 }
 }
 void SetSlice(size_t slice)
 {
 if (slices_.get() != NULL)
 {
 slice_ = slice;
 Vector p, d;
 const CoordinateSystem3D& slice = otherPlane_.GetSlice();
 // Compute the line of intersection between the two slices
 if (!GeometryToolbox::IntersectTwoPlanes(p, d,
 slice.GetOrigin(), slice.GetNormal(),
 viewportSlice.GetOrigin(), viewportSlice.GetNormal()))
 {
 // The two slice are parallel, don't try and display the intersection
 NotifyLayerReady(NULL, reference.GetGeometry(), false);
 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()))
 {
 NotifyLayerReady(new LineLayerRenderer(x1, y1, x2, y2, slice), reference.GetGeometry(), false);
 {
 // Parallel slices
 NotifyLayerReady(NULL, reference.GetGeometry(), false);
 }
 }
 }
 };
 }

Mercurial > hg > orthanc-stone

comparison Framework/dev.h @ 318:3a4ca166fafa am-2