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

comparison Applications/Samples/SingleFrameEditorApplication.h @ 356:885f0a5eaa49 am-2

mouse tracker to set windowing

author	Sebastien Jodogne <s.jodogne@gmail.com>
date	Mon, 29 Oct 2018 17:21:40 +0100
parents	d2468dd75b3f
children	ec4ad6c5eb99

comparison

equal deleted inserted replaced

-:d2468dd75b3f
+:885f0a5eaa49
 return extent;
 }
-virtual void Render(Orthanc::ImageAccessor& buffer,
-const ViewportGeometry& view,
-ImageInterpolation interpolation) const = 0;
 bool Contains(double x,
 double y) const
 {
 ApplyTransform(x, y, transformInverse_);
 return (x >= cropX && x <= cropX + cropWidth &&
 y >= cropY && y <= cropY + cropHeight);
 }
-bool GetPixel(unsigned int& pixelX,
+bool GetPixel(unsigned int& imageX,
-unsigned int& pixelY,
+unsigned int& imageY,
 double sceneX,
 double sceneY) const
 {
 if (width_ == 0 ||
 height_ == 0)
 int x = static_cast<int>(std::floor(sceneX));
 int y = static_cast<int>(std::floor(sceneY));
 if (x < 0)
 {
-pixelX = 0;
+imageX = 0;
 }
 else if (x >= static_cast<int>(width_))
 {
-pixelX = width_;
+imageX = width_;
 }
 else
 {
-pixelX = static_cast<unsigned int>(x);
+imageX = static_cast<unsigned int>(x);
 }
 if (y < 0)
 {
-pixelY = 0;
+imageY = 0;
 }
 else if (y >= static_cast<int>(height_))
 {
-pixelY = height_;
+imageY = height_;
 }
 else
 {
-pixelY = static_cast<unsigned int>(y);
+imageY = static_cast<unsigned int>(y);
 }
 return true;
 }
 }
 }
 double GetPanY() const
 {
 return panY_;
-}
-virtual bool GetDefaultWindowing(float& center,
-float& width) const
-{
-return false;
 }
 void GetCenter(double& centerX,
 double& centerY) const
 {
 void SetResizeable(bool resizeable)
 {
 resizeable_ = resizeable;
 }
+virtual bool GetDefaultWindowing(float& center,
+float& width) const
+{
+return false;
+}
+virtual void Render(Orthanc::ImageAccessor& buffer,
+const ViewportGeometry& view,
+ImageInterpolation interpolation) const = 0;
+virtual bool GetRange(float& minValue,
+float& maxValue) const = 0;
 };
 class BitmapAccessor : public boost::noncopyable
 {
 *q = (a * value + (1.0f - a) * (*q));
 }
 }
 }
+virtual bool GetRange(float& minValue,
+float& maxValue) const
+{
+if (useWindowing_)
+{
+return false;
+}
+else
+{
+minValue = 0;
+maxValue = 0;
+if (foreground_ < 0)
+{
+minValue = foreground_;
+}
+if (foreground_ > 0)
+{
+maxValue = foreground_;
+}
+return true;
+}
+}
 };
 private:
 class DicomBitmap : public Bitmap
 {
 private:
 std::auto_ptr<Orthanc::ImageAccessor>  source_;  // Content of PixelData
 std::auto_ptr<DicomFrameConverter>     converter_;
-std::auto_ptr<Orthanc::ImageAccessor>  converted_;  // Float32 or RGB24
+std::auto_ptr<Orthanc::ImageAccessor>  converted_;  // Float32
 static OrthancPlugins::DicomTag  ConvertTag(const Orthanc::DicomTag& tag)
 {
 return OrthancPlugins::DicomTag(tag.GetGroup(), tag.GetElement());
 }
 if (converter_.get() != NULL &&
 converter_->HasDefaultWindow())
 {
 center = static_cast<float>(converter_->GetDefaultWindowCenter());
 width = static_cast<float>(converter_->GetDefaultWindowWidth());
+return true;
+}
+else
+{
+return false;
+}
+}
+virtual bool GetRange(float& minValue,
+float& maxValue) const
+{
+if (converted_.get() != NULL)
+{
+if (converted_->GetFormat() != Orthanc::PixelFormat_Float32)
+{
+throw Orthanc::OrthancException(Orthanc::ErrorCode_InternalError);
+}
+Orthanc::ImageProcessing::GetMinMaxFloatValue(minValue, maxValue, *converted_);
 return true;
 }
 else
 {
 return false;
 return false;
 }
 }
+void GetWindowingWithDefault(float& center,
+float& width) const
+{
+if (!GetWindowing(center, width))
+{
+center = 128;
+width = 256;
+}
+}
 void SetWindowing(float center,
 float width)
 {
 hasWindowing_ = true;
 windowingCenter_ = center;
 windowingWidth_ = width;
-EmitMessage(ContentChangedMessage(*this));
+//EmitMessage(ContentChangedMessage(*this));
 }
 Bitmap& LoadText(const Orthanc::Font& font,
 const std::string& utf8)
 std::auto_ptr<AlphaBitmap>  alpha(new AlphaBitmap(bitmap, *this));
 alpha->LoadText(font, utf8);
 AlphaBitmap* ptr = alpha.get();
 bitmaps_[bitmap] = alpha.release();
 return *ptr;
 }
 Bitmap& LoadTestBlock(unsigned int width,
 context.SetSourceColor(255, 0, 0);
 view.ApplyTransform(context);
 bitmap->second->DrawBorders(context, view.GetZoom());
 }
+}
+}
+void GetRange(float& minValue,
+float& maxValue) const
+{
+bool first = true;
+for (Bitmaps::const_iterator it = bitmaps_.begin();
+it != bitmaps_.end(); it++)
+{
+assert(it->second != NULL);
+float a, b;
+if (it->second->GetRange(a, b))
+{
+if (first)
+{
+minValue = a;
+maxValue = b;
+first = false;
+}
+else
+{
+minValue = std::min(a, minValue);
+maxValue = std::max(b, maxValue);
+}
+}
+}
+if (first)
+{
+minValue = 0;
+maxValue = 0;
 }
 }
 };
 }
 }
 };
+class WindowingTracker : public IWorldSceneMouseTracker
+{
+public:
+enum Action
+{
+Action_IncreaseWidth,
+Action_DecreaseWidth,
+Action_IncreaseCenter,
+Action_DecreaseCenter
+};
+private:
+UndoRedoStack&  undoRedoStack_;
+BitmapStack&    stack_;
+int             clickX_;
+int             clickY_;
+Action          leftAction_;
+Action          rightAction_;
+Action          upAction_;
+Action          downAction_;
+float           strength_;
+float           sourceCenter_;
+float           sourceWidth_;
+static void ComputeAxisEffect(int& deltaCenter,
+int& deltaWidth,
+int delta,
+Action actionNegative,
+Action actionPositive)
+{
+if (delta < 0)
+{
+switch (actionNegative)
+{
+case Action_IncreaseWidth:
+deltaWidth = -delta;
+break;
+case Action_DecreaseWidth:
+deltaWidth = delta;
+break;
+case Action_IncreaseCenter:
+deltaCenter = -delta;
+break;
+case Action_DecreaseCenter:
+deltaCenter = delta;
+break;
+default:
+throw Orthanc::OrthancException(Orthanc::ErrorCode_InternalError);
+}
+}
+else if (delta > 0)
+{
+switch (actionPositive)
+{
+case Action_IncreaseWidth:
+deltaWidth = delta;
+break;
+case Action_DecreaseWidth:
+deltaWidth = -delta;
+break;
+case Action_IncreaseCenter:
+deltaCenter = delta;
+break;
+case Action_DecreaseCenter:
+deltaCenter = -delta;
+break;
+default:
+throw Orthanc::OrthancException(Orthanc::ErrorCode_InternalError);
+}
+}
+}
+class UndoRedoCommand : public UndoRedoStack::ICommand
+{
+private:
+BitmapStack&  stack_;
+float         sourceCenter_;
+float         sourceWidth_;
+float         targetCenter_;
+float         targetWidth_;
+public:
+UndoRedoCommand(const WindowingTracker& tracker) :
+stack_(tracker.stack_),
+sourceCenter_(tracker.sourceCenter_),
+sourceWidth_(tracker.sourceWidth_)
+{
+stack_.GetWindowingWithDefault(targetCenter_, targetWidth_);
+}
+virtual void Undo() const
+{
+stack_.SetWindowing(sourceCenter_, sourceWidth_);
+}
+virtual void Redo() const
+{
+stack_.SetWindowing(targetCenter_, targetWidth_);
+}
+};
+public:
+WindowingTracker(UndoRedoStack& undoRedoStack,
+BitmapStack& stack,
+int x,
+int y,
+Action leftAction,
+Action rightAction,
+Action upAction,
+Action downAction) :
+undoRedoStack_(undoRedoStack),
+stack_(stack),
+clickX_(x),
+clickY_(y),
+leftAction_(leftAction),
+rightAction_(rightAction),
+upAction_(upAction),
+downAction_(downAction)
+{
+stack_.GetWindowingWithDefault(sourceCenter_, sourceWidth_);
+float minValue, maxValue;
+stack.GetRange(minValue, maxValue);
+assert(minValue <= maxValue);
+float tmp;
+float delta = (maxValue - minValue);
+if (delta <= 1)
+{
+tmp = 0;
+}
+else
+{
+tmp = log2(delta);
+}
+strength_ = tmp - 7;
+if (strength_ < 1)
+{
+strength_ = 1;
+}
+}
+virtual bool HasRender() const
+{
+return false;
+}
+virtual void Render(CairoContext& context,
+double zoom)
+{
+throw Orthanc::OrthancException(Orthanc::ErrorCode_InternalError);
+}
+virtual void MouseUp()
+{
+undoRedoStack_.Add(new UndoRedoCommand(*this));
+}
+virtual void MouseMove(int displayX,
+int displayY,
+double sceneX,
+double sceneY)
+{
+// https://bitbucket.org/osimis/osimis-webviewer-plugin/src/master/frontend/src/app/viewport/image-plugins/windowing-viewport-tool.class.js
+static const float SCALE = 1.0;
+int deltaCenter = 0;
+int deltaWidth = 0;
+ComputeAxisEffect(deltaCenter, deltaWidth, displayX - clickX_, leftAction_, rightAction_);
+ComputeAxisEffect(deltaCenter, deltaWidth, displayY - clickY_, upAction_, downAction_);
+float newCenter = sourceCenter_ + (deltaCenter / SCALE * strength_);
+float newWidth = sourceWidth_ + (deltaWidth / SCALE * strength_);
+stack_.SetWindowing(newCenter, newWidth);
+}
+};
 class BitmapStackInteractor : public IWorldSceneInteractor
 {
 private:
 enum Tool
 {
 Tool_Move,
 Tool_Rotate,
 Tool_Crop,
-Tool_Resize
+Tool_Resize,
+Tool_Windowing
 };
 static double GetHandleSize()
 {
 return 10.0;
 virtual IWorldSceneMouseTracker* CreateMouseTracker(WorldSceneWidget& widget,
 const ViewportGeometry& view,
 MouseButton button,
 KeyboardModifiers modifiers,
+int viewportX,
+int viewportY,
 double x,
 double y,
 IStatusBar* statusBar)
 {
 if (button == MouseButton_Left)
 {
 size_t selected;
-if (!stack_.GetSelectedBitmap(selected))
+if (tool_ == Tool_Windowing)
+{
+return new WindowingTracker(undoRedoStack_, stack_,
+viewportX, viewportY,
+WindowingTracker::Action_DecreaseWidth,
+WindowingTracker::Action_IncreaseWidth,
+WindowingTracker::Action_DecreaseCenter,
+WindowingTracker::Action_IncreaseCenter);
+}
+else if (!stack_.GetSelectedBitmap(selected))
 {
 size_t bitmap;
 if (stack_.LookupBitmap(bitmap, x, y))
 {
 printf("CLICK on bitmap %ld\n", bitmap);
 case 's':
 tool_ = Tool_Resize;
 break;
+case 'w':
+tool_ = Tool_Windowing;
+break;
 case 'z':
 if (modifiers & KeyboardModifiers_Control)
 {
 undoRedoStack_.Undo();
 widget.NotifyContentChanged();
 //stack_.Render(buffer, GetView(), ImageInterpolation_Bilinear);
 // As in GrayscaleFrameRenderer => TODO MERGE?
 float windowCenter, windowWidth;
-if (!stack_.GetWindowing(windowCenter, windowWidth))
+stack_.GetWindowingWithDefault(windowCenter, windowWidth);
-{
-windowCenter = 128;
-windowWidth = 256;
-}
 float x0 = windowCenter - windowWidth / 2.0f;
 float x1 = windowCenter + windowWidth / 2.0f;
 if (windowWidth >= 0.001f)  // Avoid division by zero at (*)
 virtual IWorldSceneMouseTracker* CreateMouseTracker(WorldSceneWidget& widget,
 const ViewportGeometry& view,
 MouseButton button,
 KeyboardModifiers modifiers,
+int viewportX,
+int viewportY,
 double x,
 double y,
 IStatusBar* statusBar)
 {
 switch (application_.currentTool_) {

Mercurial > hg > orthanc-stone

comparison Applications/Samples/SingleFrameEditorApplication.h @ 356:885f0a5eaa49 am-2