orthanc-stone: Applications/Samples/SingleFrameEditorApplication.h comparison

comparison Applications/Samples/SingleFrameEditorApplication.h @ 342:4297d6c5eef9 am-2

moving bitmap

author	Sebastien Jodogne <s.jodogne@gmail.com>
date	Mon, 22 Oct 2018 09:44:52 +0200
parents	7bebbfa56bde
children	712acc87fa2e

comparison

equal deleted inserted replaced

-:7bebbfa56bde
+:4297d6c5eef9
 unsigned int                           cropX_;
 unsigned int                           cropY_;
 unsigned int                           cropWidth_;
 unsigned int                           cropHeight_;
 Matrix                                 transform_;
+double                                 pixelSpacingX_;
+double                                 pixelSpacingY_;
+double                                 panX_;
+double                                 panY_;
+void UpdateTransform()
+{
+transform_ = LinearAlgebra::IdentityMatrix(3);
+transform_(0, 0) = pixelSpacingX_;
+transform_(1, 1) = pixelSpacingY_;
+transform_(0, 2) = panX_;
+transform_(1, 2) = panY_;
+#if 0
+double a = 10.0 / 180.0 * boost::math::constants::pi<double>();
+Matrix m;
+const double v[] = { cos(a), -sin(a), 0,
+sin(a), cos(a), 0,
+0, 0, 1 };
+LinearAlgebra::FillMatrix(m, 3, 3, v);
+transform_ = LinearAlgebra::Product(m, transform_);
+#endif
+}
 void ApplyConverter()
 {
 if (source_.get() != NULL &&
 converter_.get() != NULL)
 {
 Bitmap() :
 visible_(true),
 width_(0),
 height_(0),
 hasCrop_(false),
-transform_(LinearAlgebra::IdentityMatrix(3))
+pixelSpacingX_(1),
-{
+pixelSpacingY_(1),
+panX_(0),
+panY_(0)
+{
+UpdateTransform();
 }
 void ResetCrop()
 {
 hasCrop_ = false;
 if (dataset.GetStringValue(tmp, ConvertTag(Orthanc::DICOM_TAG_PIXEL_SPACING)) &&
 LinearAlgebra::ParseVector(pixelSpacing, tmp) &&
 pixelSpacing.size() == 2)
 {
-transform_(0, 0) = pixelSpacing[0];
+pixelSpacingX_ = pixelSpacing[0];
-transform_(1, 1) = pixelSpacing[1];
+pixelSpacingY_ = pixelSpacing[1];
 }
-#if 0
-double a = 10.0 / 180.0 * boost::math::constants::pi<double>();
-Matrix m;
-const double v[] = { cos(a), -sin(a), 0,
-sin(a), cos(a), 0,
-0, 0, 1 };
-LinearAlgebra::FillMatrix(m, 3, 3, v);
-transform_ = LinearAlgebra::Product(m, transform_);
-#else
 static unsigned int c = 0;
 if (c == 0)
 {
-transform_(0, 2) = 400;
+panX_ = 400;
 c ++;
 }
-#endif
 OrthancPlugins::DicomDatasetReader reader(dataset);
 if (!reader.GetUnsignedIntegerValue(width_, ConvertTag(Orthanc::DICOM_TAG_COLUMNS)) ||
 !reader.GetUnsignedIntegerValue(height_, ConvertTag(Orthanc::DICOM_TAG_ROWS)))
 {
 throw Orthanc::OrthancException(Orthanc::ErrorCode_BadFileFormat);
 }
+UpdateTransform();
 }
 void SetSourceImage(Orthanc::ImageAccessor* image)   // Takes ownership
 {
 double dx = static_cast<double>(x) - 0.5;
 double dy = static_cast<double>(y) - 0.5;
 double dwidth = static_cast<double>(width);
 double dheight = static_cast<double>(height);
+LinearAlgebra::Print(transform_);
 AddToExtent(extent, dx, dy);
 AddToExtent(extent, dx + dwidth, dy);
 AddToExtent(extent, dx, dy + dheight);
 AddToExtent(extent, dx + dwidth, dy + dheight);
 const ViewportGeometry& view) const
 {
 if (converted_.get() != NULL)
 {
 Matrix m = LinearAlgebra::Product(view.GetMatrix(), transform_);
-ApplyProjectiveTransform(buffer, *converted_, m, ImageInterpolation_Bilinear, false);
+//ApplyProjectiveTransform(buffer, *converted_, m, ImageInterpolation_Bilinear, false);
+ApplyProjectiveTransform(buffer, *converted_, m, ImageInterpolation_Nearest, false);
 }
 }
 bool Contains(double x,
 {
 throw Orthanc::OrthancException(Orthanc::ErrorCode_InternalError);
 }
 else
 {
+printf("at: (%.02f, %.02f)\n", q[0], q[1]);
 return (q[0] >= 0 &&
 q[1] >= 0 &&
 q[0] <= static_cast<double>(width_) &&
 q[1] <= static_cast<double>(height_));
 }
+}
+void SetPan(double x,
+double y)
+{
+panX_ = x;
+panY_ = y;
+UpdateTransform();
+}
+double GetPanX() const
+{
+return panX_;
+}
+double GetPanY() const
+{
+return panY_;
 }
 };
 typedef std::map<size_t, Bitmap*>  Bitmaps;
 return extent;
 }
 void Render(Orthanc::ImageAccessor& buffer,
-const ViewportGeometry& view)
+const ViewportGeometry& view) const
 {
 Orthanc::ImageProcessing::Set(buffer, 0);
 for (Bitmaps::const_iterator it = bitmaps_.begin();
 it != bitmaps_.end(); ++it)
 {
 assert(it->second != NULL);
 it->second->Render(buffer, view);
 }
 }
+bool LookupBitmap(size_t& index /* out */,
+double x,
+double y) const
+{
+for (Bitmaps::const_iterator it = bitmaps_.begin();
+it != bitmaps_.end(); ++it)
+{
+assert(it->second != NULL);
+if (it->second->Contains(x, y))
+{
+index = it->first;
+return true;
+}
+}
+return false;
+}
+void SetPan(size_t index,
+double panX,
+double panY)
+{
+Bitmaps::iterator bitmap = bitmaps_.find(index);
+if (bitmap != bitmaps_.end())
+{
+assert(bitmap->second != NULL);
+bitmap->second->SetPan(panX, panY);
+}
+}
+void GetPan(double& panX,
+double& panY,
+size_t index) const
+{
+Bitmaps::const_iterator bitmap = bitmaps_.find(index);
+if (bitmap != bitmaps_.end())
+{
+assert(bitmap->second != NULL);
+panX = bitmap->second->GetPanX();
+panY = bitmap->second->GetPanY();
+}
+else
+{
+panX = 0;
+panY = 0;
+}
+}
 };
 class BitmapStackInteractor : public IWorldSceneInteractor
 {
+private:
+BitmapStack&  stack_;
+class MoveBitmapTracker : public IWorldSceneMouseTracker
+{
+private:
+WorldSceneWidget&  widget_;
+BitmapStack&       stack_;
+size_t             bitmap_;
+double             clickX_;
+double             clickY_;
+public:
+MoveBitmapTracker(WorldSceneWidget&  widget,
+BitmapStack& stack,
+size_t bitmap,
+double x,
+double y) :
+widget_(widget),
+stack_(stack),
+bitmap_(bitmap),
+clickX_(x),
+clickY_(y)
+{
+double panX, panY;
+stack.GetPan(panX, panY, bitmap_);
+clickX_ -= panX;
+clickY_ -= panY;
+}
+virtual bool HasRender() const
+{
+return false;
+}
+virtual void Render(CairoContext& context,
+double zoom)
+{
+throw Orthanc::OrthancException(Orthanc::ErrorCode_InternalError);
+}
+virtual void MouseUp()
+{
+}
+virtual void MouseMove(int displayX,
+int displayY,
+double sceneX,
+double sceneY)
+{
+stack_.SetPan(bitmap_, sceneX - clickX_, sceneY - clickY_);
+}
+};
 public:
+BitmapStackInteractor(BitmapStack& stack) :
+stack_(stack)
+{
+}
 virtual IWorldSceneMouseTracker* CreateMouseTracker(WorldSceneWidget& widget,
 const ViewportGeometry& view,
 MouseButton button,
 KeyboardModifiers modifiers,
 double x,
 double y,
 IStatusBar* statusBar)
 {
-printf("CLICK\n");
+if (button == MouseButton_Left)
-return NULL;
+{
+size_t bitmap;
+if (stack_.LookupBitmap(bitmap, x, y))
+{
+printf("CLICK on bitmap %d\n", bitmap);
+return new MoveBitmapTracker(widget, stack_, bitmap, x, y);
+}
+else
+{
+printf("CLICK outside\n");
+return NULL;
+}
+}
+else
+{
+return NULL;
+}
 }
 virtual void MouseOver(CairoContext& context,
 WorldSceneWidget& widget,
 const ViewportGeometry& view,
 KeyboardKeys key,
 char keyChar,
 KeyboardModifiers modifiers,
 IStatusBar* statusBar)
 {
+if (keyChar == 's')
+widget.FitContent();
 }
 };
 BitmapStack& stack,
 const std::string& name) :
 WorldSceneWidget(name),
 IObservable(broker),
 IObserver(broker),
-stack_(stack)
+stack_(stack),
+myInteractor_(stack_)
 {
 stack.RegisterObserverCallback(new Callable<BitmapStackWidget, BitmapStack::GeometryChangedMessage>(*this, &BitmapStackWidget::OnGeometryChanged));
 stack.RegisterObserverCallback(new Callable<BitmapStackWidget, BitmapStack::ContentChangedMessage>(*this, &BitmapStackWidget::OnContentChanged));
 SetInteractor(myInteractor_);

Mercurial > hg > orthanc-stone

comparison Applications/Samples/SingleFrameEditorApplication.h @ 342:4297d6c5eef9 am-2