[Git][freetype/freetype-demos][gsoc-2022-chariri-3] [ftinspect] Add cach

Charlie Jiang pushed to branch gsoc-2022-chariri-3 at FreeType / FreeType Demo Programs

Commits:

794b613d

by Charlie Jiang at 2022-07-27T18:32:42+08:00

[ftinspect] Add caching of `QImage` and dimension info in Continuous View.

This gives further possibility of implementation click-for-detail and
dragging features.
Also improves performance, but very slightly because the cache is purged
aggresively.

* src/ftinspect/rendering/glyphcontinuous.cpp,
  src/ftinspect/rendering/glyphcontinuous.hpp:
  Implementation the caching, remove non-cached drawing of the glyphs.

* src/ftinspect/engine/stringrenderer.cpp,
  src/ftinspect/engine/stringrenderer.hpp:
  Add an argument to pass the current `GlyphContext` to both callbacks.

* src/ftinspect/panels/continuous.cpp: Purge caches at proper time.

5 changed files:

src/ftinspect/engine/stringrenderer.cpp
src/ftinspect/engine/stringrenderer.hpp
src/ftinspect/panels/continuous.cpp
src/ftinspect/rendering/glyphcontinuous.cpp
src/ftinspect/rendering/glyphcontinuous.hpp

Changes:

src/ftinspect/engine/stringrenderer.cpp


     {
       rect.setX(rect.x() + (pen.x >> 6));
       rect.setY(height - rect.y() - (pen.y >> 6));
-      renderImageCallback_(colorLayerImage, rect);
+      renderImageCallback_(colorLayerImage, rect, ctx);
     }
     else
     {

           && bbox.yMin <= height)
       {
         FT_Vector penPos = { (pen.x >> 6), height - (pen.y >> 6) };
-        renderCallback_(image, penPos);
+        renderCallback_(image, penPos, ctx);
       }
 
       FT_Done_Glyph(image);

src/ftinspect/engine/stringrenderer.hpp

@@ -61,13 +61,17 @@ public:
     * contains no points, and thus can't be translated to the desired pen
     * position.
     */
 -  using RenderCallback = std::function<void(FT_Glyph, FT_Vector)>;
 +  using RenderCallback = std::function<void(FT_Glyph,
 +                                            FT_Vector,
 +                                            GlyphContext&)>;
    /*
     * For color layered fonts, this will direct render the QImage for you.
     * TODO: Remove `RenderCallback` and do QImage creation in this class?
     * The receiver is responsible for deleteing the QImage.
     */
 -  using RenderImageCallback = std::function<void(QImage*, QRect)>;
 +  using RenderImageCallback = std::function<void(QImage*,
 +                                                 QRect,
 +                                                 GlyphContext&)>;
    /*
     * The glyph pointer may be replaced. In that case, ownership is transfered
     * to the renderer, and the new glyph will be eventually freed by

src/ftinspect/panels/continuous.cpp

@@ -30,6 +30,7 @@ ContinuousTab::repaintGlyph()
    sizeSelector_->applyToEngine(engine_);
    syncSettings();
 +  canvas_->purgeCache();
    canvas_->repaint();
+ }
@@ -41,6 +42,7 @@ ContinuousTab::reloadFont()
    setGlyphCount(qBound(0, currentGlyphCount_, INT_MAX));
    setCharMaps(engine_->currentFontCharMaps());
    canvas_->stringRenderer().reloadAll();
 +  canvas_->purgeCache();
    repaintGlyph();
+ }

src/ftinspect/rendering/glyphcontinuous.cpp

@@ -12,6 +12,37 @@
  #include <freetype/ftbitmap.h>
 +GlyphCacheEntry::~GlyphCacheEntry()
 +{
 +  delete image;
 +}
++
++
 +GlyphCacheEntry::GlyphCacheEntry(GlyphCacheEntry&& other) noexcept
 +{
 +  *this = std::move(other);
 +}
++
++
 +GlyphCacheEntry&
 +GlyphCacheEntry::operator=(GlyphCacheEntry&& other) noexcept
 +{
 +  if (this == &other)
 +    return *this;
++
 +  auto oldImage = image;
 +  image = other.image;
 +  basePosition = other.basePosition;
 +  penPos = other.penPos;
 +  charCode = other.charCode;
 +  glyphIndex = other.glyphIndex;
 +  advance = other.advance;
 +  hasAdvance = other.hasAdvance;
 +  other.image = oldImage;
 +  return *this;
 +}
++
++
  GlyphContinuous::GlyphContinuous(QWidget* parent, Engine* engine)
  : QWidget(parent),
    engine_(engine),
@@ -38,9 +69,11 @@ GlyphContinuous::setSource(Source source)
+   {
    case SRC_AllGlyphs:
      stringRenderer_.setUseAllGlyphs();
 +    positionDelta_ = {};
      break;
    case SRC_TextStringRepeated:
 +    positionDelta_ = {};
    case SRC_TextString:
      updateRendererText();
      break;
@@ -56,6 +89,14 @@ GlyphContinuous::setSourceText(QString text)
+ }
 +void
 +GlyphContinuous::purgeCache()
 +{
 +  glyphCache_.clear();
 +  currentWritingLine_ = NULL;
 +}
++
++
  void
  GlyphContinuous::paintEvent(QPaintEvent* event)
+ {
@@ -63,10 +104,9 @@ GlyphContinuous::paintEvent(QPaintEvent* event)
    painter.begin(this);
    painter.fillRect(rect(), Qt::white);
 -  prePaint();
+-
 -  paintByRenderer(&painter);
 -  emit displayingCountUpdated(displayingCount_);
 +  if (glyphCache_.empty())
 +    fillCache();
 +  paintCache(&painter);
    painter.end();
+ }
@@ -84,27 +124,28 @@ GlyphContinuous::wheelEvent(QWheelEvent* event)
  void
 -GlyphContinuous::paintByRenderer(QPainter* painter)
 +GlyphContinuous::resizeEvent(QResizeEvent* event)
+ {
 -  if (mode_ == M_Stroked)
 -  {
 -    auto radius = static_cast<FT_Fixed>(metrics_.y_ppem * 64 * strokeRadius_);
 -    FT_Stroker_Set(stroker_, radius,
 -                   FT_STROKER_LINECAP_ROUND,
 -                   FT_STROKER_LINEJOIN_ROUND,
 -                   0);
 -  }
 +  purgeCache();
 +  QWidget::resizeEvent(event);
 +}
++
++
 +void
 +GlyphContinuous::paintByRenderer()
 +{
 +  purgeCache();
    stringRenderer_.setRepeated(source_ == SRC_TextStringRepeated);
    stringRenderer_.setCallback(
 -    [&](FT_Glyph glyph, FT_Vector penPos)
 +    [&](FT_Glyph glyph, FT_Vector penPos, GlyphContext& ctx)
+     {
 -      drawSingleGlyph(painter, glyph, penPos);
 +      saveSingleGlyph(glyph, penPos, ctx);
      });
    stringRenderer_.setImageCallback(
 -    [&](QImage* image, QRect pos)
 +    [&](QImage* image, QRect pos, GlyphContext& ctx)
+     {
 -      drawSingleGlyphImage(painter, image, pos);
 +      saveSingleGlyphImage(image, pos, ctx);
      });
    stringRenderer_.setPreprocessCallback(
      [&](FT_Glyph* ptr)
@@ -114,7 +155,7 @@ GlyphContinuous::paintByRenderer(QPainter* painter)
    stringRenderer_.setLineBeginCallback(
      [&](FT_Vector pos, double size)
+     {
 -      beginLine(painter, pos, size);
 +      beginSaveLine(pos, size);
      });
    displayingCount_ = stringRenderer_.render(width(), height(), beginIndex_);
+ }
@@ -168,6 +209,31 @@ GlyphContinuous::transformGlyphStroked(FT_Glyph glyph)
+ }
 +void
 +GlyphContinuous::paintCache(QPainter* painter)
 +{
 +  if (stringRenderer_.isWaterfall())
 +    positionDelta_.setY(0);
 +  for (auto& line : glyphCache_)
 +  {
 +    beginDrawCacheLine(painter, line);
 +    for (auto& glyph : line.entries)
 +    {
 +      drawCacheGlyph(painter, glyph);
 +    }
 +  }
 +}
++
++
 +void
 +GlyphContinuous::fillCache()
 +{
 +  prePaint();
 +  paintByRenderer();
 +  emit displayingCountUpdated(displayingCount_);
 +}
++
++
  void
  GlyphContinuous::prePaint()
+ {
@@ -204,6 +270,15 @@ GlyphContinuous::prePaint()
    emboldeningX_ = (FT_Pos)(metrics_.y_ppem * 64 * boldX_);
    emboldeningY_ = (FT_Pos)(metrics_.y_ppem * 64 * boldY_);
++
 +  if (mode_ == M_Stroked)
 +  {
 +    auto radius = static_cast<FT_Fixed>(metrics_.y_ppem * 64 * strokeRadius_);
 +    FT_Stroker_Set(stroker_, radius,
 +                   FT_STROKER_LINECAP_ROUND,
 +                   FT_STROKER_LINEJOIN_ROUND,
 +                   0);
 +  }
+ }
@@ -240,9 +315,65 @@ GlyphContinuous::preprocessGlyph(FT_Glyph* glyphPtr)
  void
 -GlyphContinuous::beginLine(QPainter* painter,
 -                           FT_Vector pos,
 -                           double sizePoint)
 +GlyphContinuous::beginSaveLine(FT_Vector pos,
 +                               double sizePoint)
 +{
 +  glyphCache_.emplace_back();
 +  currentWritingLine_ = &glyphCache_.back();
 +  currentWritingLine_->sizePoint = sizePoint;
 +  currentWritingLine_->basePosition = { static_cast<int>(pos.x),
 +                                        static_cast<int>(pos.y) };
 +}
++
++
 +void
 +GlyphContinuous::saveSingleGlyph(FT_Glyph glyph,
 +                                 FT_Vector penPos,
 +                                 GlyphContext gctx)
 +{
 +  if (!currentWritingLine_)
 +    return;
++
 +  currentWritingLine_->entries.push_back(std::move(GlyphCacheEntry{}));
 +  auto& entry = currentWritingLine_->entries.back();
++
 +  QRect rect;
 +  QImage* image = engine_->convertGlyphToQImage(glyph, &rect, false);
 +  rect.setTop(height() - rect.top()); // TODO Don't place this here...
++
 +  entry.image = image;
 +  entry.basePosition = rect;
 +  entry.charCode = gctx.charCode;
 +  entry.glyphIndex = gctx.glyphIndex;
 +  entry.advance = glyph->advance;
 +  entry.penPos = { penPos.x, penPos.y };
++
 +  // todo more info
 +}
++
++
 +void
 +GlyphContinuous::saveSingleGlyphImage(QImage* image,
 +                                      QRect pos,
 +                                      GlyphContext gctx)
 +{
 +  if (!currentWritingLine_)
 +    return;
++
 +  currentWritingLine_->entries.push_back(std::move(GlyphCacheEntry{}));
 +  auto& entry = currentWritingLine_->entries.back();
++
 +  entry.image = image;
 +  entry.basePosition = pos;
 +  entry.charCode = gctx.charCode;
 +  entry.glyphIndex = gctx.glyphIndex;
 +  entry.hasAdvance = false;
 +}
++
++
 +void
 +GlyphContinuous::beginDrawCacheLine(QPainter* painter,
 +                                    const GlyphCacheLine& line)
+ {
    // Now only used by waterfall mode to draw a size indicator.
    if (!stringRenderer_.isWaterfall())
@@ -252,54 +383,38 @@ GlyphContinuous::beginLine(QPainter* painter,
+   }
    auto oldFont = painter->font();
 -  oldFont.setPointSizeF(sizePoint);
 +  oldFont.setPointSizeF(line.sizePoint);
    painter->setFont(oldFont);
    auto metrics = painter->fontMetrics();
 -  auto sizePrefix = QString("%1: ").arg(sizePoint);
 -  QPoint posQ = { static_cast<int>(pos.x),
 -                  static_cast<int>(pos.y) };
 -  painter->drawText(posQ, sizePrefix);
 +  auto sizePrefix = QString("%1: ").arg(line.sizePoint);
 +  painter->drawText(line.basePosition, sizePrefix);
    sizeIndicatorOffset_ = metrics.horizontalAdvance(sizePrefix);
+ }
  void
 -GlyphContinuous::drawSingleGlyph(QPainter* painter,
 -                                 FT_Glyph glyph,
 -                                 FT_Vector penPos)
 +GlyphContinuous::drawCacheGlyph(QPainter* painter,
 +                                const GlyphCacheEntry& entry)
+ {
    // ftview.c:557
 -  int width = glyph->advance.x ? glyph->advance.x >> 16
 -                               : metrics_.y_ppem / 2;
 +  // Well, metrics is also part of the cache...
 +  int width = entry.advance.x ? entry.advance.x >> 16
 +                              : metrics_.y_ppem / 2;
 -  if (glyph->advance.x == 0 && !stringRenderer_.isWaterfall())
 +  if (entry.advance.x == 0 && !stringRenderer_.isWaterfall())
+   {
      // Draw a red square to indicate
 -    painter->fillRect(penPos.x, penPos.y - width, width, width, Qt::red);
 +    auto squarePoint = entry.penPos;
 +    squarePoint.setY(squarePoint.y() - width);
 +    painter->fillRect(QRect(squarePoint, QSize(width, width)), Qt::red);
+   }
 -  QRect rect;
 -  QImage* image = engine_->convertGlyphToQImage(glyph, &rect, false);
 -  rect.setTop(height() - rect.top()); // TODO Don't place this here...
 +  QRect rect = entry.basePosition;
    rect.setLeft(rect.left() + sizeIndicatorOffset_);
 -  painter->drawImage(rect.topLeft(), *image);
 -  delete image;
 -}
+-
+-
 -void
 -GlyphContinuous::drawSingleGlyphImage(QPainter* painter,
 -                                      QImage* image,
 -                                      QRect pos)
 -{
 -  // TODO red square?
+-
 -  pos.setLeft(pos.left() + sizeIndicatorOffset_);
 -  painter->drawImage(pos, *image);
 -  delete image;
 +  painter->drawImage(rect.topLeft(), *entry.image);
+ }

src/ftinspect/rendering/glyphcontinuous.hpp

@@ -8,8 +8,10 @@
  #include "../engine/stringrenderer.hpp"
  #include <utility>
 +#include <vector>
  #include <QWidget>
 +#include <QImage>
  #include <freetype/freetype.h>
  #include <freetype/ftglyph.h>
@@ -17,6 +19,34 @@
  #include <freetype/ftstroke.h>
 +struct GlyphCacheEntry
 +{
 +  QImage* image = NULL;
 +  QRect basePosition = {};
 +  QPoint penPos = {};
 +  int charCode = -1;
 +  int glyphIndex = -1;
++
 +  FT_Vector advance = {};
 +  bool hasAdvance = false;
++
 +  GlyphCacheEntry() {}
 +  ~GlyphCacheEntry();
 +  GlyphCacheEntry(const GlyphCacheEntry& other) = delete;
 +  GlyphCacheEntry& operator=(const GlyphCacheEntry& other) = delete;
 +  GlyphCacheEntry(GlyphCacheEntry&& other) noexcept;
 +  GlyphCacheEntry& operator=(GlyphCacheEntry&& other) noexcept;
 +};
++
++
 +struct GlyphCacheLine
 +{
 +  QPoint basePosition = {};
 +  double sizePoint = 0.0;
 +  std::vector<GlyphCacheEntry> entries;
 +};
++
++
  class Engine;
  class GlyphContinuous
  : public QWidget
@@ -56,6 +86,8 @@ public:
    void setStrokeRadius(double radius) { strokeRadius_ = radius; }
    void setSourceText(QString text);
 +  void purgeCache();
++
  signals:
    void wheelNavigate(int steps);
    void wheelResize(int steps);
@@ -64,6 +96,7 @@ signals:
  protected:
    void paintEvent(QPaintEvent* event) override;
    void wheelEvent(QWheelEvent* event) override;
 +  void resizeEvent(QResizeEvent* event) override;
  private:
    Engine* engine_;
@@ -86,7 +119,12 @@ private:
    FT_Stroker stroker_;
 -  void paintByRenderer(QPainter* painter);
 +  std::vector<GlyphCacheLine> glyphCache_;
 +  GlyphCacheLine* currentWritingLine_ = NULL;
++
 +  QPoint positionDelta_;
++
 +  void paintByRenderer();
    // These two are used indendpent of current glyph variables
    // and assumes ownership of glyphs, but don't free them.
@@ -94,18 +132,23 @@ private:
    void transformGlyphFancy(FT_Glyph glyph);
    FT_Glyph transformGlyphStroked(FT_Glyph glyph);
 +  void paintCache(QPainter* painter);
 +  void fillCache();
    void prePaint();
    void updateRendererText();
    void preprocessGlyph(FT_Glyph* glyphPtr);
 -  void beginLine(QPainter* painter,
 -                 FT_Vector pos,
 -                 double sizePoint);
 -  void drawSingleGlyph(QPainter* painter,
 -                       FT_Glyph glyph,
 -                       FT_Vector penPos);
 -  void drawSingleGlyphImage(QPainter* painter,
 -                            QImage* image,
 -                            QRect pos);
 +  void beginSaveLine(FT_Vector pos,
 +                     double sizePoint);
 +  void saveSingleGlyph(FT_Glyph glyph,
 +                       FT_Vector penPos,
 +                       GlyphContext gctx);
 +  void saveSingleGlyphImage(QImage* image,
 +                            QRect pos,
 +                            GlyphContext gctx);
 +  void beginDrawCacheLine(QPainter* painter,
 +                          const GlyphCacheLine& line);
 +  void drawCacheGlyph(QPainter* painter,
 +                      const GlyphCacheEntry& entry);
  };

From:	Charlie Jiang (@cqjjjzr)
Subject:	[Git][freetype/freetype-demos][gsoc-2022-chariri-3] [ftinspect] Add caching of `QImage` and dimension info in Continuous View.
Date:	Wed, 27 Jul 2022 10:33:01 +0000