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

comparison Applications/StoneWebViewer/WebAssembly/StoneWebViewer.cpp @ 1593:b782f78aed42

rendering osirix annotations

author	Sebastien Jodogne <s.jodogne@gmail.com>
date	Fri, 23 Oct 2020 17:39:16 +0200
parents	5887a4f8594b
children	4fb8fdf03314

comparison

equal deleted inserted replaced

-:0d4b11ba86df
+:b782f78aed42
 * 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/>.
 **/
+#include <EmbeddedResources.h>
 #include <emscripten.h>
 #define DISPATCH_JAVASCRIPT_EVENT(name)                         \
 EM_ASM(                                                       \
 #include <Oracle/ParseDicomFromWadoCommand.h>
 #include <Oracle/ParseDicomSuccessMessage.h>
 #include <Scene2D/ColorTextureSceneLayer.h>
 #include <Scene2D/FloatTextureSceneLayer.h>
 #include <Scene2D/PolylineSceneLayer.h>
+#include <Scene2D/TextSceneLayer.h>
 #include <Scene2DViewport/ViewportController.h>
 #include <StoneException.h>
 #include <Toolbox/DicomInstanceParameters.h>
 #include <Toolbox/GeometryToolbox.h>
+#include <Toolbox/OsiriX/AngleAnnotation.h>
+#include <Toolbox/OsiriX/CollectionOfAnnotations.h>
+#include <Toolbox/OsiriX/LineAnnotation.h>
+#include <Toolbox/OsiriX/TextAnnotation.h>
 #include <Toolbox/SortedFrames.h>
 #include <Viewport/DefaultViewportInteractor.h>
 // WebAssembly includes
 #include <WebAssemblyCairoViewport.h>
 else
 {
 return false;
 }
 }
+bool ProjectPoint(double& x,
+double& y,
+const OrthancStone::Vector& v) const
+{
+if (IsValid())
+{
+coordinates_.ProjectPoint(x, y, v);
+return true;
+}
+else
+{
+return false;
+}
+}
 };
 class ViewerViewport : public OrthancStone::ObserverBase<ViewerViewport>
 };
 private:
 static const int LAYER_TEXTURE = 0;
 static const int LAYER_REFERENCE_LINES = 1;
+static const int LAYER_ANNOTATIONS = 2;
+static const int LAYER_TEMP = 3;  // TODO - REMOVE
 class ICommand : public Orthanc::IDynamicObject
 {
 private:
 }
 GetViewport().DisplayCurrentFrame();
 }
 };
 class SetLowQualityFrame : public ICommand
 {
 private:
 std::string   sopInstanceUid_;
 bool                                         fitNextContent_;
 bool                                         isCtrlDown_;
 FrameGeometry                                currentFrameGeometry_;
 std::list<PrefetchItem>                      prefetchQueue_;
+boost::shared_ptr<OrthancStone::OsiriX::CollectionOfAnnotations>  annotations_;
 void ScheduleNextPrefetch()
 {
 while (!prefetchQueue_.empty())
 {
 size_t index = prefetchQueue_.front().GetFrameIndex();
 DisplayCurrentFrame();
 }
 }
 }
 void DisplayCurrentFrame()
 {
 DisplayedFrameQuality quality = DisplayedFrameQuality_None;
 if (cursor_.get() != NULL &&
 else
 {
 currentFrameGeometry_ = FrameGeometry();
 }
 }
 void ClearViewport()
 {
 {
 std::unique_ptr<OrthancStone::IViewport::ILock> lock(viewport_->Lock());
 double pixelSpacingX, pixelSpacingY;
 OrthancStone::GeometryToolbox::GetPixelSpacing(
 pixelSpacingX, pixelSpacingY, frames_->GetFrameTags(index));
 layer->SetPixelSpacing(pixelSpacingX, pixelSpacingY);
+/****
+* BEGINNING OF EXPERIMENTAL CODE
+****/
+std::unique_ptr<OrthancStone::ISceneLayer>  annotationsLayer;  // TODO - Macro layer
+std::unique_ptr<OrthancStone::ISceneLayer>  tempLayer;  // TODO - Macro layer
+if (annotations_)
+{
+std::set<size_t> a;
+annotations_->LookupSopInstanceUid(a, sopInstanceUid);
+if (!a.empty())
+{
+using namespace OrthancStone::OsiriX;
+std::unique_ptr<OrthancStone::PolylineSceneLayer> layer(new OrthancStone::PolylineSceneLayer);
+for (std::set<size_t>::const_iterator it = a.begin(); it != a.end(); ++it)
+{
+const Annotation& annotation = annotations_->GetAnnotation(*it);
+switch (annotation.GetType())
+{
+case Annotation::Type_Line:
+{
+const LineAnnotation& line = dynamic_cast<const LineAnnotation&>(annotation);
+double x1, y1, x2, y2;
+if (GetCurrentFrameGeometry().ProjectPoint(x1, y1, line.GetPoint1()) &&
+GetCurrentFrameGeometry().ProjectPoint(x2, y2, line.GetPoint2()))
+{
+OrthancStone::PolylineSceneLayer::Chain chain;
+chain.push_back(OrthancStone::ScenePoint2D(x1, y1));
+chain.push_back(OrthancStone::ScenePoint2D(x2, y2));
+// TODO - IsArrow
+layer->AddChain(chain, false, 0, 255, 0);
+}
+break;
+}
+case Annotation::Type_Angle:
+{
+const AngleAnnotation& angle = dynamic_cast<const AngleAnnotation&>(annotation);
+double x1, y1, x2, y2, x3, y3;
+if (GetCurrentFrameGeometry().ProjectPoint(x1, y1, angle.GetA()) &&
+GetCurrentFrameGeometry().ProjectPoint(x2, y2, angle.GetCenter()) &&
+GetCurrentFrameGeometry().ProjectPoint(x3, y3, angle.GetB()))
+{
+OrthancStone::PolylineSceneLayer::Chain chain;
+chain.push_back(OrthancStone::ScenePoint2D(x1, y1));
+chain.push_back(OrthancStone::ScenePoint2D(x2, y2));
+chain.push_back(OrthancStone::ScenePoint2D(x3, y3));
+layer->AddChain(chain, false, 0, 255, 0);
+}
+break;
+}
+case Annotation::Type_Text:
+{
+const TextAnnotation& text = dynamic_cast<const TextAnnotation&>(annotation);
+double x, y;
+OrthancStone::LinearAlgebra::Print(text.GetCenter());
+if (GetCurrentFrameGeometry().ProjectPoint(x, y, text.GetCenter()))
+{
+std::unique_ptr<OrthancStone::TextSceneLayer> layer2(new OrthancStone::TextSceneLayer());
+layer2->SetPosition(x, y);
+layer2->SetText(text.GetText());
+layer2->SetAnchor(OrthancStone::BitmapAnchor_Center);
+layer2->SetColor(255, 0, 0);
+tempLayer.reset(layer2.release());
+}
+break;
+}
+default:
+LOG(ERROR) << "Annotation type not implemented: " << annotation.GetType();
+}
+}
+annotationsLayer.reset(layer.release());
+}
+}
+/****
+* END OF EXPERIMENTAL CODE
+****/
 if (layer.get() == NULL)
 {
 return false;
 }
 else
 std::unique_ptr<OrthancStone::IViewport::ILock> lock(viewport_->Lock());
 OrthancStone::Scene2D& scene = lock->GetController().GetScene();
 scene.SetLayer(LAYER_TEXTURE, layer.release());
+if (annotationsLayer.get() != NULL)
+{
+scene.SetLayer(LAYER_ANNOTATIONS, annotationsLayer.release());
+}
+else
+{
+scene.DeleteLayer(LAYER_ANNOTATIONS);
+}
+if (tempLayer.get() != NULL)   // TODO - REMOVE
+{
+scene.SetLayer(LAYER_TEMP, tempLayer.release());
+}
+else
+{
+scene.DeleteLayer(LAYER_TEMP);
+}
 if (fitNextContent_)
 {
 lock->RefreshCanvasSize();
 lock->GetCompositor().FitContent(scene);
 }
 else
 {
 LOG(INFO) << "Creating WebGL viewport in canvas: " << canvas;
 viewport_ = OrthancStone::WebGLViewport::Create(canvas);
+}
+{
+std::unique_ptr<OrthancStone::IViewport::ILock> lock(viewport_->Lock());
+std::string ttf;
+Orthanc::EmbeddedResources::GetFileResource(ttf, Orthanc::EmbeddedResources::UBUNTU_FONT);
+lock->GetCompositor().SetFont(0, ttf, 24 /* font size */, Orthanc::Encoding_Latin1);
 }
 emscripten_set_wheel_callback(viewport_->GetCanvasCssSelector().c_str(), this, true, OnWheel);
 emscripten_set_keydown_callback(EMSCRIPTEN_EVENT_TARGET_WINDOW, this, false, OnKey);
 emscripten_set_keyup_callback(EMSCRIPTEN_EVENT_TARGET_WINDOW, this, false, OnKey);
 0, source_, uri, new SetDefaultWindowingCommand(GetSharedObserver()));
 }
 }
 }
+void UpdateCurrentFrame()
+{
+if (cursor_.get() != NULL)
+{
+unsigned int quality;
+DisplayFrame(quality, cursor_->GetCurrentIndex());
+}
+}
 // This method is used when the layout of the HTML page changes,
 // which does not trigger the "emscripten_set_resize_callback()"
 void UpdateSize(bool fitContent)
 {
 std::unique_ptr<OrthancStone::IViewport::ILock> lock(viewport_->Lock());
 void FitForPrint()
 {
 viewport_->FitForPrint();
 }
+void SetAnnotations(boost::shared_ptr<OrthancStone::OsiriX::CollectionOfAnnotations> annotations)
+{
+annotations_ = annotations;
+}
 };
 typedef std::map<std::string, boost::shared_ptr<ViewerViewport> >  Viewports;
 static Viewports allViewports_;
 static bool showReferenceLines_ = true;
+static boost::shared_ptr<OrthancStone::OsiriX::CollectionOfAnnotations>  annotations_;
 static void UpdateReferenceLines()
 {
 if (showReferenceLines_)
 std::unique_ptr<OrthancStone::ILoadersContext::ILock> lock(context_->Lock());
 boost::shared_ptr<ViewerViewport> viewport(
 ViewerViewport::Create(*lock, source_, canvas, cache_, softwareRendering_));
 viewport->SetMouseButtonActions(leftButtonAction_, middleButtonAction_, rightButtonAction_);
 viewport->AcquireObserver(new WebAssemblyObserver);
+viewport->SetAnnotations(annotations_);
 allViewports_[canvas] = viewport;
 return viewport;
 }
 else
 {
 Orthanc::Logging::EnableInfoLevel(true);
 //Orthanc::Logging::EnableTraceLevel(true);
 context_.reset(new OrthancStone::WebAssemblyLoadersContext(1, 4, 1));
 cache_.reset(new FramesCache);
+annotations_.reset(new OrthancStone::OsiriX::CollectionOfAnnotations);
 DISPATCH_JAVASCRIPT_EVENT("StoneInitialized");
 }
 it->second->FitForPrint();
 }
 }
 EXTERN_CATCH_EXCEPTIONS;
 }
+EMSCRIPTEN_KEEPALIVE
+int LoadOsiriXAnnotations(const char* xml,
+int clearPreviousAnnotations)
+{
+try
+{
+if (clearPreviousAnnotations)
+{
+annotations_->Clear();
+}
+annotations_->LoadXml(xml);
+for (Viewports::iterator it = allViewports_.begin(); it != allViewports_.end(); ++it)
+{
+// TODO - Check if the viewport contains one of the SOP
+// Instance UID from the loaded annotations => focus on this
+// instance
+// TODO - If no viewport contains the instance => monitor the
+// "ResourcesLoader" as new series get loaded
+assert(it->second != NULL);
+it->second->UpdateCurrentFrame();
+}
+LOG(WARNING) << "Loaded " << annotations_->GetSize() << " annotations from OsiriX";
+return 1;
+}
+EXTERN_CATCH_EXCEPTIONS;
+return 0;
+}
 }

Mercurial > hg > orthanc-stone

comparison Applications/StoneWebViewer/WebAssembly/StoneWebViewer.cpp @ 1593:b782f78aed42