orthanc-stone: Applications/StoneWebViewer/WebAssembly/StoneWebViewer.cpp comparison

comparison Applications/StoneWebViewer/WebAssembly/StoneWebViewer.cpp @ 2003:963f28eb40cb deep-learning

integration default->deep-learning

author	Sebastien Jodogne <s.jodogne@gmail.com>
date	Wed, 02 Nov 2022 15:14:56 +0100
parents	2034ae383cfd e943a84da9ac
children	37d6805b80ee

comparison

equal deleted inserted replaced

-:2034ae383cfd
+:963f28eb40cb
 #include "../../../OrthancStone/Sources/Platforms/WebAssembly/WebAssemblyCairoViewport.h"
 #include "../../../OrthancStone/Sources/Platforms/WebAssembly/WebAssemblyLoadersContext.h"
 #include "../../../OrthancStone/Sources/Platforms/WebAssembly/WebGLViewport.h"
+#include <algorithm>
+#include <boost/make_shared.hpp>
+#include <boost/math/constants/constants.hpp>
 #include <boost/math/special_functions/round.hpp>
-#include <boost/make_shared.hpp>
 #include <stdio.h>
-#include <algorithm>
+static const double PI = boost::math::constants::pi<double>();
 #if !defined(STONE_WEB_VIEWER_EXPORT)
 // We are not running ParseWebAssemblyExports.py, but we're compiling the wasm
 #  define STONE_WEB_VIEWER_EXPORT
 #endif
 WebViewerAction_Windowing,
 WebViewerAction_Zoom,
 WebViewerAction_Pan,
 WebViewerAction_Rotate,
 WebViewerAction_Crosshair,
+WebViewerAction_MagnifyingGlass,       // New in 2.4
 WebViewerAction_CreateAngle,
 WebViewerAction_CreateCircle,
-WebViewerAction_CreateSegment,
+WebViewerAction_CreateLength,
-WebViewerAction_RemoveMeasure
+WebViewerAction_RemoveMeasure,
+WebViewerAction_CreatePixelProbe,      // New in 2.4
+WebViewerAction_CreateEllipseProbe,    // New in 2.4
+WebViewerAction_CreateRectangleProbe,  // New in 2.4
+WebViewerAction_CreateTextAnnotation   // New in 2.4
 };
 static OrthancStone::MouseAction ConvertWebViewerAction(int action)
 return OrthancStone::MouseAction_Pan;
 case WebViewerAction_Rotate:
 return OrthancStone::MouseAction_Rotate;
+case WebViewerAction_MagnifyingGlass:
+return OrthancStone::MouseAction_MagnifyingGlass;
 case WebViewerAction_None:
 case WebViewerAction_Crosshair:
 case WebViewerAction_CreateAngle:
 case WebViewerAction_CreateCircle:
-case WebViewerAction_CreateSegment:
+case WebViewerAction_CreateLength:
 case WebViewerAction_RemoveMeasure:
+case WebViewerAction_CreatePixelProbe:
+case WebViewerAction_CreateEllipseProbe:
+case WebViewerAction_CreateRectangleProbe:
+case WebViewerAction_CreateTextAnnotation:
 return OrthancStone::MouseAction_None;
 default:
 throw Orthanc::OrthancException(Orthanc::ErrorCode_ParameterOutOfRange);
 }
 return ((framesCount_ == 0 && frame == 0) ||
 (framesCount_ > 0 && frame >= 0 && frame < framesCount_));
 }
 public:
-explicit SeriesCursor(size_t framesCount) :
+explicit SeriesCursor(size_t framesCount,
+bool startAtMiddle /* Whether to start at the middle frame */) :
 framesCount_(framesCount),
-currentFrame_(framesCount / 2),  // Start at the middle frame
+currentFrame_(startAtMiddle ? framesCount / 2 : 0),
 isCircularPrefetch_(false),
 lastAction_(Action_None)
 {
 SetFastDelta(framesCount / 20);
 UpdatePrefetch();
 size_t frame) = 0;
 virtual void SignalStoneAnnotationAdded(const ViewerViewport& viewport) = 0;
 virtual void SignalStoneAnnotationRemoved(const ViewerViewport& viewport) = 0;
+virtual void SignalStoneTextAnnotationRequired(const ViewerViewport& viewport,
+const OrthancStone::ScenePoint2D& pointedPosition,
+const OrthancStone::ScenePoint2D& labelPosition) = 0;
 };
 private:
 static const int LAYER_TEXTURE = 0;
 static const int LAYER_OVERLAY = 1;
-static const int LAYER_ORIENTATION_MARKERS = 2;
+static const int LAYER_DEEP_LEARNING = 2;
-static const int LAYER_REFERENCE_LINES = 3;
+static const int LAYER_ORIENTATION_MARKERS = 3;
-static const int LAYER_ANNOTATIONS_OSIRIX = 4;
+static const int LAYER_REFERENCE_LINES = 4;
-static const int LAYER_ANNOTATIONS_STONE = 5;
+static const int LAYER_ANNOTATIONS_OSIRIX = 5;
-static const int LAYER_DEEP_LEARNING = 6;
+static const int LAYER_ANNOTATIONS_STONE = 6;
 class ICommand : public Orthanc::IDynamicObject
 {
 private:
 float                                        windowingWidth_;
 std::vector<float>                           windowingPresetCenters_;
 std::vector<float>                           windowingPresetWidths_;
 unsigned int                                 cineRate_;
 bool                                         inverted_;
-bool                                         flipX_;
-bool                                         flipY_;
 bool                                         fitNextContent_;
 std::list<PrefetchItem>                      prefetchQueue_;
 bool                                         serverSideTranscoding_;
 OrthancStone::Vector                         synchronizationOffset_;
 bool                                         synchronizationEnabled_;
 // The coordinates of Stone annotations are expressed in 2D
 // coordinates of the current texture, with (0,0) corresponding to
 // the center of the top-left pixel
 boost::shared_ptr<OrthancStone::AnnotationsSceneLayer>  stoneAnnotations_;
+bool linearInterpolation_;
 boost::shared_ptr<Orthanc::ImageAccessor>  deepLearningMask_;
 std::string deepLearningSopInstanceUid_;
 unsigned int deepLearningFrameNumber_;
 void ScheduleNextPrefetch()
 {
 while (!prefetchQueue_.empty())
 {
 throw Orthanc::OrthancException(Orthanc::ErrorCode_IncompatibleImageFormat);
 }
 assert(layer.get() != NULL);
-layer->SetLinearInterpolation(true);
+layer->SetLinearInterpolation(linearInterpolation_);
-layer->SetFlipX(flipX_);
-layer->SetFlipY(flipY_);
 double pixelSpacingX, pixelSpacingY;
 if (instance.HasPixelSpacing())
 {
 {
 OverlaysRegistry::Accessor accessor(OverlaysRegistry::GetInstance(), instance.GetSopInstanceUid());
 if (accessor.IsValid())
 {
 overlay.reset(accessor.CreateTexture());
-overlay->SetFlipX(flipX_);
+overlay->SetLinearInterpolation(false);
-overlay->SetFlipY(flipY_);
 }
 }
 std::unique_ptr<OrthancStone::MacroSceneLayer>  annotationsOsiriX;
 }
 deepLearningLayer.reset(new OrthancStone::LookupTableTextureSceneLayer(*deepLearningMask_));
 deepLearningLayer->SetLookupTable(lut);
 deepLearningLayer->SetPixelSpacing(pixelSpacingX, pixelSpacingY);
-deepLearningLayer->SetFlipX(flipX_);
-deepLearningLayer->SetFlipY(flipY_);
 }
 StoneAnnotationsRegistry::GetInstance().Load(*stoneAnnotations_, instance.GetSopInstanceUid(), frameIndex);
 // Orientation markers, new in Stone Web viewer 2.4
 {
 dynamic_cast<OrthancStone::FloatTextureSceneLayer&>(
 lock->GetController().GetScene().GetLayer(LAYER_TEXTURE)).
 SetCustomWindowing(windowingCenter_, windowingWidth_);
 }
-{
-OrthancStone::TextureBaseSceneLayer& layer =
-dynamic_cast<OrthancStone::TextureBaseSceneLayer&>(
-lock->GetController().GetScene().GetLayer(LAYER_TEXTURE));
-layer.SetFlipX(flipX_);
-layer.SetFlipY(flipY_);
-}
-if (lock->GetController().GetScene().HasLayer(LAYER_OVERLAY))
-{
-OrthancStone::TextureBaseSceneLayer& layer =
-dynamic_cast<OrthancStone::TextureBaseSceneLayer&>(
-lock->GetController().GetScene().GetLayer(LAYER_OVERLAY));
-layer.SetFlipX(flipX_);
-layer.SetFlipY(flipY_);
-}
 lock->Invalidate();
 }
 }
 ViewerViewport(OrthancStone::WebAssemblyLoadersContext& context,
 const OrthancStone::DicomSource& source,
 const std::string& canvas,
 boost::shared_ptr<FramesCache> cache,
-bool softwareRendering) :
+bool softwareRendering,
+bool linearInterpolation) :
 context_(context),
 source_(source),
 framesCache_(cache),
 fitNextContent_(true),
-flipX_(false),
-flipY_(false),
 hasFocusOnInstance_(false),
 focusFrameNumber_(0),
 synchronizationOffset_(OrthancStone::LinearAlgebra::CreateVector(0, 0, 0)),
 synchronizationEnabled_(false),
 centralPhysicalWidth_(1),
 centralPhysicalHeight_(1),
 centralPixelSpacingX_(1),
-centralPixelSpacingY_(1)
+centralPixelSpacingY_(1),
+linearInterpolation_(linearInterpolation)
 {
 if (!framesCache_)
 {
 throw Orthanc::OrthancException(Orthanc::ErrorCode_NullPointer);
 }
 emscripten_set_wheel_callback(viewport_->GetCanvasCssSelector().c_str(), this, true, OnWheel);
 SetWindowingPreset();
 stoneAnnotations_.reset(new OrthancStone::AnnotationsSceneLayer(LAYER_ANNOTATIONS_STONE));
+stoneAnnotations_->SetProbedLayer(LAYER_TEXTURE);
 }
 void Handle(const OrthancStone::ViewportController::GrayscaleWindowingChanged& message)
 {
 {
 observer_->SignalStoneAnnotationRemoved(*this);
 }
 }
+void Handle(const OrthancStone::AnnotationsSceneLayer::TextAnnotationRequiredMessage& message)
+{
+if (observer_.get() != NULL)
+{
+observer_->SignalStoneTextAnnotationRequired(*this, message.GetPointedPosition(), message.GetLabelPosition());
+}
+}
 public:
 virtual ~ViewerViewport()
 {
 // Unregister the callbacks to avoid any call with a "void*" that
 // has been destroyed. "WebAssemblyViewport::CreateObjectCookie()"
 static boost::shared_ptr<ViewerViewport> Create(OrthancStone::WebAssemblyLoadersContext& context,
 const OrthancStone::DicomSource& source,
 const std::string& canvas,
 boost::shared_ptr<FramesCache> cache,
-bool softwareRendering)
+bool softwareRendering,
+bool linearInterpolation)
 {
 boost::shared_ptr<ViewerViewport> viewport(
-new ViewerViewport(context, source, canvas, cache, softwareRendering));
+new ViewerViewport(context, source, canvas, cache, softwareRendering, linearInterpolation));
 {
 std::unique_ptr<OrthancStone::ILoadersContext::ILock> lock(context.Lock());
 viewport->loader_ = OrthancStone::DicomResourcesLoader::Create(*lock);
 viewport->Register<OrthancStone::AnnotationsSceneLayer::AnnotationAddedMessage>(
 *viewport->stoneAnnotations_, &ViewerViewport::Handle);
 viewport->Register<OrthancStone::AnnotationsSceneLayer::AnnotationRemovedMessage>(
 *viewport->stoneAnnotations_, &ViewerViewport::Handle);
+viewport->Register<OrthancStone::AnnotationsSceneLayer::TextAnnotationRequiredMessage>(
+*viewport->stoneAnnotations_, &ViewerViewport::Handle);
 }
 {
 std::unique_ptr<OrthancStone::IViewport::ILock> lock(viewport->viewport_->Lock());
 viewport->Register<OrthancStone::ViewportController::GrayscaleWindowingChanged>(lock->GetController(), &ViewerViewport::Handle);
 if (frames == NULL)
 {
 throw Orthanc::OrthancException(Orthanc::ErrorCode_NullPointer);
 }
-flipX_ = false;
-flipY_ = false;
 fitNextContent_ = true;
 cineRate_ = DEFAULT_CINE_RATE;
 inverted_ = false;
 serverSideTranscoding_ = false;
 OrthancStone::LinearAlgebra::AssignVector(synchronizationOffset_, 0, 0, 0);
 frames_.reset(frames);
-cursor_.reset(new SeriesCursor(frames_->GetFramesCount()));
+cursor_.reset(new SeriesCursor(frames_->GetFramesCount(), false));
+if (frames_->GetFramesCount() != 0)
+{
+const OrthancStone::DicomInstanceParameters& firstInstance = frames_->GetInstanceOfFrame(0);
+std::string modality;
+if (firstInstance.GetTags().LookupStringValue(modality, Orthanc::DICOM_TAG_MODALITY, false))
+{
+if (modality == "MR" ||
+modality == "CT" ||
+modality == "NM" ||
+modality == "OPT" ||
+modality == "PT" ||
+modality == "RTDOSE" ||
+modality == "XA")
+{
+// For series that might correspond to 3D images, use their
+// central frame as the first frame to be displayed
+cursor_.reset(new SeriesCursor(frames_->GetFramesCount(), true));
+}
+}
+}
 LOG(INFO) << "Number of frames in series: " << frames_->GetFramesCount();
 SetWindowingPreset();
 ClearViewport();
 }
 }
 void FlipX()
 {
-flipX_ = !flipX_;
+{
-UpdateCurrentTextureParameters();
+std::unique_ptr<OrthancStone::IViewport::ILock> lock(viewport_->Lock());
+lock->GetController().GetScene().FlipViewportX(
+lock->GetCompositor().GetCanvasWidth(), lock->GetCompositor().GetCanvasHeight());
+lock->Invalidate();
+}
 }
 void FlipY()
 {
-flipY_ = !flipY_;
+{
-UpdateCurrentTextureParameters();
+std::unique_ptr<OrthancStone::IViewport::ILock> lock(viewport_->Lock());
+lock->GetController().GetScene().FlipViewportY(
+lock->GetCompositor().GetCanvasWidth(), lock->GetCompositor().GetCanvasHeight());
+lock->Invalidate();
+}
+}
+void RotateLeft()
+{
+{
+std::unique_ptr<OrthancStone::IViewport::ILock> lock(viewport_->Lock());
+lock->GetController().GetScene().RotateViewport(
+-PI / 2.0, lock->GetCompositor().GetCanvasWidth(), lock->GetCompositor().GetCanvasHeight());
+lock->Invalidate();
+}
+}
+void RotateRight()
+{
+{
+std::unique_ptr<OrthancStone::IViewport::ILock> lock(viewport_->Lock());
+lock->GetController().GetScene().RotateViewport(
+PI / 2.0, lock->GetCompositor().GetCanvasWidth(), lock->GetCompositor().GetCanvasHeight());
+lock->Invalidate();
+}
 }
 void Invert()
 {
 inverted_ = !inverted_;
 case WebViewerAction_CreateCircle:
 viewer_.stoneAnnotations_->SetActiveTool(OrthancStone::AnnotationsSceneLayer::Tool_Circle);
 break;
-case WebViewerAction_CreateSegment:
+case WebViewerAction_CreateLength:
-viewer_.stoneAnnotations_->SetActiveTool(OrthancStone::AnnotationsSceneLayer::Tool_Segment);
+viewer_.stoneAnnotations_->SetActiveTool(OrthancStone::AnnotationsSceneLayer::Tool_Length);
 break;
 case WebViewerAction_RemoveMeasure:
 viewer_.stoneAnnotations_->SetActiveTool(OrthancStone::AnnotationsSceneLayer::Tool_Remove);
+break;
+case WebViewerAction_CreatePixelProbe:
+viewer_.stoneAnnotations_->SetActiveTool(OrthancStone::AnnotationsSceneLayer::Tool_PixelProbe);
+break;
+case WebViewerAction_CreateEllipseProbe:
+viewer_.stoneAnnotations_->SetActiveTool(OrthancStone::AnnotationsSceneLayer::Tool_EllipseProbe);
+break;
+case WebViewerAction_CreateRectangleProbe:
+viewer_.stoneAnnotations_->SetActiveTool(OrthancStone::AnnotationsSceneLayer::Tool_RectangleProbe);
+break;
+case WebViewerAction_CreateTextAnnotation:
+viewer_.stoneAnnotations_->SetActiveTool(OrthancStone::AnnotationsSceneLayer::Tool_TextAnnotation);
 break;
 default:
 viewer_.stoneAnnotations_->SetActiveTool(OrthancStone::AnnotationsSceneLayer::Tool_Edit);
 break;
 stoneAnnotations_->Render(lock->GetController().GetScene());
 lock->Invalidate();
 }
 }
 }
+}
+void SetLinearInterpolation(bool linearInterpolation)
+{
+if (linearInterpolation_ != linearInterpolation)
+{
+linearInterpolation_ = linearInterpolation;
+Redraw();
+}
+}
+void AddTextAnnotation(const std::string& label,
+const OrthancStone::ScenePoint2D& pointedPosition,
+const OrthancStone::ScenePoint2D& labelPosition)
+{
+stoneAnnotations_->AddTextAnnotation(label, pointedPosition, labelPosition);
+Redraw();
 }
 bool GetCurrentFrame(std::string& sopInstanceUid /* out */,
 unsigned int& frameNumber /* out */) const
 { "canvasId" : UTF8ToString($0) });
 window.dispatchEvent(customEvent);
 },
 viewport.GetCanvasId().c_str());
 }
+virtual void SignalStoneTextAnnotationRequired(const ViewerViewport& viewport,
+const OrthancStone::ScenePoint2D& pointedPosition,
+const OrthancStone::ScenePoint2D& labelPosition) ORTHANC_OVERRIDE
+{
+EM_ASM({
+const customEvent = document.createEvent("CustomEvent");
+customEvent.initCustomEvent("TextAnnotationRequired", false, false,
+{ "canvasId" : UTF8ToString($0),
+"pointedX" : $1,
+"pointedY" : $2,
+"labelX" : $3,
+"labelY" : $4 });
+window.dispatchEvent(customEvent);
+},
+viewport.GetCanvasId().c_str(),
+pointedPosition.GetX(),
+pointedPosition.GetY(),
+labelPosition.GetX(),
+labelPosition.GetY() );
+}
 };
 static OrthancStone::DicomSource source_;
 static boost::shared_ptr<FramesCache> framesCache_;
 static boost::shared_ptr<OrthancStone::WebAssemblyLoadersContext> context_;
 static std::string stringBuffer_;
 static bool softwareRendering_ = false;
+static bool linearInterpolation_ = true;
 static WebViewerAction leftButtonAction_ = WebViewerAction_Windowing;
 static WebViewerAction middleButtonAction_ = WebViewerAction_Pan;
 static WebViewerAction rightButtonAction_ = WebViewerAction_Zoom;
 {
 Viewports::iterator found = allViewports_.find(canvas);
 if (found == allViewports_.end())
 {
 boost::shared_ptr<ViewerViewport> viewport(
-ViewerViewport::Create(*context_, source_, canvas, framesCache_, softwareRendering_));
+ViewerViewport::Create(*context_, source_, canvas, framesCache_, softwareRendering_, linearInterpolation_));
 viewport->SetMouseButtonActions(leftButtonAction_, middleButtonAction_, rightButtonAction_);
 viewport->AcquireObserver(new WebAssemblyObserver);
 viewport->SetOsiriXAnnotations(osiriXAnnotations_);
 allViewports_[canvas] = viewport;
 return viewport;
 EXTERN_CATCH_EXCEPTIONS;
 }
 EMSCRIPTEN_KEEPALIVE
+void RotateLeft(const char* canvas)
+{
+try
+{
+GetViewport(canvas)->RotateLeft();
+}
+EXTERN_CATCH_EXCEPTIONS;
+}
+EMSCRIPTEN_KEEPALIVE
+void RotateRight(const char* canvas)
+{
+try
+{
+GetViewport(canvas)->RotateRight();
+}
+EXTERN_CATCH_EXCEPTIONS;
+}
+EMSCRIPTEN_KEEPALIVE
 void SetSoftwareRendering(int softwareRendering)
 {
 softwareRendering_ = softwareRendering;
 }
 EMSCRIPTEN_KEEPALIVE
 int IsSoftwareRendering()
 {
 return softwareRendering_;
+}
+EMSCRIPTEN_KEEPALIVE
+void SetLinearInterpolation(int linearInterpolation)
+{
+linearInterpolation_ = linearInterpolation;
+try
+{
+for (Viewports::iterator it = allViewports_.begin(); it != allViewports_.end(); ++it)
+{
+assert(it->second != NULL);
+it->second->SetLinearInterpolation(linearInterpolation);
+}
+}
+EXTERN_CATCH_EXCEPTIONS;
 }
 EMSCRIPTEN_KEEPALIVE
 void SetMouseButtonActions(int leftAction,
 }
 }
 EXTERN_CATCH_EXCEPTIONS;
 return false;
 }
+EMSCRIPTEN_KEEPALIVE
+void AddTextAnnotation(const char* canvas,
+const char* label,
+double pointedX,
+double pointedY,
+double labelX,
+double labelY)
+{
+try
+{
+GetViewport(canvas)->AddTextAnnotation(label, OrthancStone::ScenePoint2D(pointedX, pointedY),
+OrthancStone::ScenePoint2D(labelX, labelY));
+}
+EXTERN_CATCH_EXCEPTIONS;
+}
 }

Mercurial > hg > orthanc-stone

comparison Applications/StoneWebViewer/WebAssembly/StoneWebViewer.cpp @ 2003:963f28eb40cb deep-learning