Adds text rendering and line rendering to WorldAnnotator

vtkm/rendering/Canvas.cxx

@@ -26,6 +26,7 @@
 #include <vtkm/rendering/DecodePNG.h>
 #include <vtkm/rendering/LineRenderer.h>
 #include <vtkm/rendering/TextRenderer.h>
+#include <vtkm/rendering/WorldAnnotator.h>
 #include <vtkm/worklet/DispatcherMapField.h>
 #include <vtkm/worklet/WorkletMapField.h>
 
@@ -226,7 +227,8 @@ Canvas::Canvas(vtkm::Id width, vtkm::Id height)
   : Width(0)
   , Height(0)
 {
-  vtkm::MatrixIdentity(Transform);
+  vtkm::MatrixIdentity(ModelView);
+  vtkm::MatrixIdentity(Projection);
   this->ResizeBuffers(width, height);
 }
 
@@ -297,7 +299,7 @@ void Canvas::AddLine(const vtkm::Vec<vtkm::Float64, 2>& point0,
                      const vtkm::rendering::Color& color) const
 {
   vtkm::rendering::Canvas* self = const_cast<vtkm::rendering::Canvas*>(this);
-  LineRenderer renderer(self, Transform);
+  LineRenderer renderer(self, vtkm::MatrixMultiply(Projection, ModelView));
   renderer.RenderLine(point0, point1, linewidth, color);
 }
 
@@ -429,18 +431,18 @@ bool Canvas::LoadFont() const
   return true;
 }
 
-void Canvas::SetViewToWorldSpace(const vtkm::rendering::Camera& camera, bool clip)
+void Canvas::SetViewToWorldSpace(const vtkm::rendering::Camera& camera, bool vtkmNotUsed(clip))
 {
-  Transform = vtkm::MatrixMultiply(camera.CreateProjectionMatrix(this->Width, this->Height),
-                                   camera.CreateViewMatrix());
+  ModelView = camera.CreateViewMatrix();
+  Projection = camera.CreateProjectionMatrix(this->Width, this->Height);
 }
 
-void Canvas::SetViewToScreenSpace(const vtkm::rendering::Camera& camera, bool clip)
+void Canvas::SetViewToScreenSpace(const vtkm::rendering::Camera& vtkmNotUsed(camera),
+                                  bool vtkmNotUsed(clip))
 {
-  vtkm::Matrix<vtkm::Float32, 4, 4> projection;
-  vtkm::MatrixIdentity(projection);
-  projection[2][2] = -1.0f;
-  Transform = projection;
+  vtkm::MatrixIdentity(ModelView);
+  vtkm::MatrixIdentity(Projection);
+  Projection[2][2] = -1.0f;
 }
 
 void Canvas::SaveAs(const std::string& fileName) const
@@ -464,7 +466,7 @@ void Canvas::SaveAs(const std::string& fileName) const
 
 vtkm::rendering::WorldAnnotator* Canvas::CreateWorldAnnotator() const
 {
-  return new vtkm::rendering::WorldAnnotator;
+  return new vtkm::rendering::WorldAnnotator(this);
 }
 }
 } // vtkm::rendering

vtkm/rendering/Canvas.h

@@ -29,13 +29,14 @@
 #include <vtkm/rendering/Color.h>
 #include <vtkm/rendering/ColorTable.h>
 #include <vtkm/rendering/Texture2D.h>
-#include <vtkm/rendering/WorldAnnotator.h>
 
 namespace vtkm
 {
 namespace rendering
 {
 
+class WorldAnnotator;
+
 class VTKM_RENDERING_EXPORT Canvas
 {
 public:
@@ -196,6 +197,8 @@ public:
   friend class ColorBarAnnotation;
   friend class ColorLegendAnnotation;
   friend class TextAnnotationScreen;
+  friend class TextRenderer;
+  friend class WorldAnnotator;
 
 private:
   bool LoadFont() const;
@@ -207,7 +210,8 @@ private:
   DepthBufferType DepthBuffer;
   mutable vtkm::rendering::BitmapFont Font;
   mutable FontTextureType FontTexture;
-  vtkm::Matrix<vtkm::Float32, 4, 4> Transform;
+  vtkm::Matrix<vtkm::Float32, 4, 4> ModelView;
+  vtkm::Matrix<vtkm::Float32, 4, 4> Projection;
 };
 }
 } //namespace vtkm::rendering

vtkm/rendering/CanvasGL.cxx

@@ -276,7 +276,7 @@ void CanvasGL::AddText(const vtkm::Vec<vtkm::Float32, 2>& position,
 
 vtkm::rendering::WorldAnnotator* CanvasGL::CreateWorldAnnotator() const
 {
-  return new vtkm::rendering::WorldAnnotatorGL;
+  return new vtkm::rendering::WorldAnnotatorGL(this);
 }
 
 void CanvasGL::RenderText(vtkm::Float32 scale,

vtkm/rendering/LineRenderer.cxx

@@ -30,7 +30,7 @@ namespace vtkm
 namespace rendering
 {
 
-LineRenderer::LineRenderer(vtkm::rendering::Canvas* canvas,
+LineRenderer::LineRenderer(const vtkm::rendering::Canvas* canvas,
                            vtkm::Matrix<vtkm::Float32, 4, 4> transform)
   : Canvas(canvas)
   , Transform(transform)
@@ -66,16 +66,16 @@ void LineRenderer::RenderLine(const vtkm::Vec<vtkm::Float64, 3>& point0,
   vtkm::Id dy = -vtkm::Abs(y1 - y0), sy = y0 < y1 ? 1 : -1;
   vtkm::Id err = dx + dy, err2 = 0;
   vtkm::rendering::Canvas::ColorBufferType::PortalControl colorPortal =
-    Canvas->GetColorBuffer().GetPortalControl();
+    vtkm::rendering::Canvas::ColorBufferType(Canvas->GetColorBuffer()).GetPortalControl();
   vtkm::rendering::Canvas::DepthBufferType::PortalControl depthPortal =
-    Canvas->GetDepthBuffer().GetPortalControl();
+    vtkm::rendering::Canvas::DepthBufferType(Canvas->GetDepthBuffer()).GetPortalControl();
   vtkm::Vec<vtkm::Float32, 4> colorC = color.Components;
-  while (true)
+  while (x0 >= 0 && x0 < Canvas->GetWidth() && y0 >= 0 && y0 < Canvas->GetHeight())
   {
     vtkm::Float32 t = (dx == 0) ? 1.0f : (static_cast<vtkm::Float32>(x0) - p0[0]) / (p1[0] - p0[0]);
     vtkm::Float32 z = vtkm::Lerp(z0, z1, t);
     vtkm::Id index = y0 * Canvas->GetWidth() + x0;
-    if (depthPortal.Get(index) >= z)
+    if (depthPortal.Get(index) > z)
     {
       depthPortal.Set(index, z);
       colorPortal.Set(index, colorC);
@@ -113,6 +113,7 @@ vtkm::Vec<vtkm::Float32, 3> LineRenderer::TransformPoint(
   }
   p[0] = (p[0] * 0.5f + 0.5f) * static_cast<vtkm::Float32>(Canvas->GetWidth());
   p[1] = (p[1] * 0.5f + 0.5f) * static_cast<vtkm::Float32>(Canvas->GetHeight());
+  p[2] = (p[2] * 0.5f + 0.5f) - 0.001f;
   return p;
 }
 }

vtkm/rendering/LineRenderer.h

@@ -35,7 +35,7 @@ class VTKM_RENDERING_EXPORT LineRenderer
 {
 public:
   VTKM_CONT
-  LineRenderer(vtkm::rendering::Canvas* canvas, vtkm::Matrix<vtkm::Float32, 4, 4> transform);
+  LineRenderer(const vtkm::rendering::Canvas* canvas, vtkm::Matrix<vtkm::Float32, 4, 4> transform);
 
   VTKM_CONT
   void RenderLine(const vtkm::Vec<vtkm::Float64, 2>& point0,
@@ -53,7 +53,7 @@ private:
   VTKM_CONT
   vtkm::Vec<vtkm::Float32, 3> TransformPoint(const vtkm::Vec<vtkm::Float64, 3>& point) const;
 
-  vtkm::rendering::Canvas* Canvas;
+  const vtkm::rendering::Canvas* Canvas;
   vtkm::Matrix<vtkm::Float32, 4, 4> Transform;
 }; // class LineRenderer
 }

vtkm/rendering/TextRenderer.cxx

@@ -153,7 +153,7 @@ struct RenderBitmapFontExecutor
 }; // struct RenderBitmapFontExecutor
 } // namespace internal
 
-TextRenderer::TextRenderer(vtkm::rendering::Canvas* canvas,
+TextRenderer::TextRenderer(const vtkm::rendering::Canvas* canvas,
                            const vtkm::rendering::BitmapFont& font,
                            const vtkm::rendering::Canvas::FontTextureType& fontTexture)
   : Canvas(canvas)
@@ -192,6 +192,8 @@ void TextRenderer::RenderText(const vtkm::Vec<vtkm::Float32, 3>& origin,
   vtkm::Normalize(n);
 
   vtkm::Matrix<vtkm::Float32, 4, 4> transform = MatrixHelpers::WorldMatrix(origin, right, up, n);
+  transform = vtkm::MatrixMultiply(Canvas->ModelView, transform);
+  transform = vtkm::MatrixMultiply(Canvas->Projection, transform);
   RenderText(transform, scale, anchor, color, text);
 }
 

vtkm/rendering/TextRenderer.h

@@ -37,7 +37,7 @@ class VTKM_RENDERING_EXPORT TextRenderer
 {
 public:
   VTKM_CONT
-  TextRenderer(vtkm::rendering::Canvas* canvas,
+  TextRenderer(const vtkm::rendering::Canvas* canvas,
                const vtkm::rendering::BitmapFont& font,
                const vtkm::rendering::Canvas::FontTextureType& fontTexture);
 
@@ -67,7 +67,7 @@ public:
                   const std::string& text);
 
 private:
-  vtkm::rendering::Canvas* Canvas;
+  const vtkm::rendering::Canvas* Canvas;
   vtkm::rendering::BitmapFont Font;
   vtkm::rendering::Canvas::FontTextureType FontTexture;
 };

vtkm/rendering/View.cxx

@@ -56,7 +56,7 @@ View::View(const vtkm::rendering::Scene& scene,
   : Scene(scene)
   , MapperPointer(mapper.NewCopy())
   , CanvasPointer(canvas.NewCopy())
-  , WorldAnnotatorPointer(canvas.CreateWorldAnnotator())
+  , WorldAnnotatorPointer(CanvasPointer->CreateWorldAnnotator())
   , Camera(camera)
 {
   this->CanvasPointer->SetBackgroundColor(backgroundColor);

vtkm/rendering/WorldAnnotator.cxx

@@ -18,6 +18,10 @@
 //  this software.
 //============================================================================
 
+#include <vtkm/rendering/BitmapFontFactory.h>
+#include <vtkm/rendering/DecodePNG.h>
+#include <vtkm/rendering/LineRenderer.h>
+#include <vtkm/rendering/TextRenderer.h>
 #include <vtkm/rendering/WorldAnnotator.h>
 
 namespace vtkm
@@ -25,32 +29,75 @@ namespace vtkm
 namespace rendering
 {
 
+WorldAnnotator::WorldAnnotator(const vtkm::rendering::Canvas* canvas)
+  : Canvas(canvas)
+{
+}
+
 WorldAnnotator::~WorldAnnotator()
 {
 }
 
-void WorldAnnotator::AddLine(const vtkm::Vec<vtkm::Float64, 3>& vtkmNotUsed(point0),
-                             const vtkm::Vec<vtkm::Float64, 3>& vtkmNotUsed(point1),
-                             vtkm::Float32 vtkmNotUsed(lineWidth),
-                             const vtkm::rendering::Color& vtkmNotUsed(color),
+void WorldAnnotator::AddLine(const vtkm::Vec<vtkm::Float64, 3>& point0,
+                             const vtkm::Vec<vtkm::Float64, 3>& point1,
+                             vtkm::Float32 lineWidth,
+                             const vtkm::rendering::Color& color,
                              bool vtkmNotUsed(inFront)) const
 {
   // Default implementation does nothing. Should this be pure virtual and force
   // all subclasses to implement this? We would have to implement a
   // WorldAnnotator for ray tracing first.
+  vtkm::Matrix<vtkm::Float32, 4, 4> transform =
+    vtkm::MatrixMultiply(Canvas->Projection, Canvas->ModelView);
+  LineRenderer renderer(Canvas, transform);
+  renderer.RenderLine(point0, point1, lineWidth, color);
 }
 
-void WorldAnnotator::AddText(const vtkm::Vec<vtkm::Float32, 3>& vtkmNotUsed(origin),
-                             const vtkm::Vec<vtkm::Float32, 3>& vtkmNotUsed(right),
-                             const vtkm::Vec<vtkm::Float32, 3>& vtkmNotUsed(up),
-                             vtkm::Float32 vtkmNotUsed(scale),
-                             const vtkm::Vec<vtkm::Float32, 2>& vtkmNotUsed(anchor),
-                             const vtkm::rendering::Color& vtkmNotUsed(color),
-                             const std::string& vtkmNotUsed(text)) const
+void WorldAnnotator::AddText(const vtkm::Vec<vtkm::Float32, 3>& origin,
+                             const vtkm::Vec<vtkm::Float32, 3>& right,
+                             const vtkm::Vec<vtkm::Float32, 3>& up,
+                             vtkm::Float32 scale,
+                             const vtkm::Vec<vtkm::Float32, 2>& anchor,
+                             const vtkm::rendering::Color& color,
+                             const std::string& text) const
 {
   // Default implementation does nothing. Should this be pure virtual and force
   // all subclasses to implement this? We would have to implement a
   // WorldAnnotator for ray tracing first.
+  if (!FontTexture.IsValid())
+  {
+    if (!LoadFont())
+    {
+      return;
+    }
+  }
+  TextRenderer renderer(Canvas, Font, FontTexture);
+  renderer.RenderText(origin, right, up, scale, anchor, color, text);
+}
+
+bool WorldAnnotator::LoadFont() const
+{
+  this->Font = BitmapFontFactory::CreateLiberation2Sans();
+  const std::vector<unsigned char>& rawPNG = this->Font.GetRawImageData();
+  std::vector<unsigned char> rgba;
+  unsigned long textureWidth, textureHeight;
+  int error = DecodePNG(rgba, textureWidth, textureHeight, &rawPNG[0], rawPNG.size());
+  if (error != 0)
+  {
+    return false;
+  }
+  std::size_t numValues = textureWidth * textureHeight;
+  std::vector<unsigned char> alpha(numValues);
+  for (std::size_t i = 0; i < numValues; ++i)
+  {
+    alpha[i] = rgba[i * 4 + 3];
+  }
+  vtkm::cont::ArrayHandle<vtkm::UInt8> textureHandle = vtkm::cont::make_ArrayHandle(alpha);
+  this->FontTexture = vtkm::rendering::Canvas::FontTextureType(
+    vtkm::Id(textureWidth), vtkm::Id(textureHeight), textureHandle);
+  this->FontTexture.SetFilterMode(TextureFilterMode::Linear);
+  this->FontTexture.SetWrapMode(TextureWrapMode::Clamp);
+  return true;
 }
 }
 } // namespace vtkm::rendering

vtkm/rendering/WorldAnnotator.h

@@ -23,16 +23,23 @@
 #include <vtkm/rendering/vtkm_rendering_export.h>
 
 #include <vtkm/Types.h>
+#include <vtkm/rendering/BitmapFont.h>
+#include <vtkm/rendering/Canvas.h>
 #include <vtkm/rendering/Color.h>
+#include <vtkm/rendering/Texture2D.h>
 
 namespace vtkm
 {
 namespace rendering
 {
 
+class Canvas;
+
 class VTKM_RENDERING_EXPORT WorldAnnotator
 {
 public:
+  WorldAnnotator(const vtkm::rendering::Canvas* canvas);
+
   virtual ~WorldAnnotator();
 
   virtual void AddLine(const vtkm::Vec<vtkm::Float64, 3>& point0,
@@ -88,6 +95,15 @@ public:
                   color,
                   text);
   }
+
+protected:
+  mutable BitmapFont Font;
+
+private:
+  bool LoadFont() const;
+
+  const vtkm::rendering::Canvas* Canvas;
+  mutable vtkm::rendering::Canvas::FontTextureType FontTexture;
 };
 }
 } //namespace vtkm::rendering

vtkm/rendering/WorldAnnotatorGL.cxx

@@ -34,6 +34,11 @@ namespace vtkm
 namespace rendering
 {
 
+WorldAnnotatorGL::WorldAnnotatorGL(const vtkm::rendering::Canvas* canvas)
+  : WorldAnnotator(canvas)
+{
+}
+
 WorldAnnotatorGL::~WorldAnnotatorGL()
 {
 }

vtkm/rendering/WorldAnnotatorGL.h

@@ -23,6 +23,7 @@
 #include <vtkm/rendering/WorldAnnotator.h>
 
 #include <vtkm/rendering/BitmapFont.h>
+#include <vtkm/rendering/Canvas.h>
 #include <vtkm/rendering/TextureGL.h>
 
 namespace vtkm
@@ -33,6 +34,8 @@ namespace rendering
 class VTKM_RENDERING_EXPORT WorldAnnotatorGL : public WorldAnnotator
 {
 public:
+  WorldAnnotatorGL(const vtkm::rendering::Canvas* canvas);
+
   ~WorldAnnotatorGL();
 
   void AddLine(const vtkm::Vec<vtkm::Float64, 3>& point0,
@@ -50,7 +53,6 @@ public:
                const std::string& text) const VTKM_OVERRIDE;
 
 private:
-  BitmapFont Font;
   TextureGL FontTexture;
 
   void RenderText(vtkm::Float32 scale,

vtkm/rendering/testing/RenderTest.h

@@ -98,7 +98,7 @@ void Render(const vtkm::cont::DataSet& ds,
             const std::string& outputFile)
 {
   MapperType mapper;
-  CanvasType canvas(512, 512);
+  CanvasType canvas(1024, 1024);
   canvas.SetBackgroundColor(vtkm::rendering::Color::white);
   vtkm::rendering::Scene scene;
 
@@ -127,7 +127,7 @@ void Render(const vtkm::cont::DataSet& ds,
             const bool logY = false)
 {
   MapperType mapper;
-  CanvasType canvas(512, 512);
+  CanvasType canvas(1024, 1024);
   canvas.SetBackgroundColor(vtkm::rendering::Color::white);
   vtkm::rendering::Scene scene;
 
@@ -160,7 +160,7 @@ void MultiMapperRender(const vtkm::cont::DataSet& ds1,
   MapperType1 mapper1;
   MapperType2 mapper2;
 
-  CanvasType canvas(512, 512);
+  CanvasType canvas(1024, 1024);
   canvas.SetBackgroundColor(vtkm::rendering::Color(0.8f, 0.8f, 0.8f, 1.0f));
   canvas.Clear();