vtkFreeTypeTools.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
// SPDX-License-Identifier: BSD-3-Clause
#ifndef vtkFreeTypeTools_h
#define vtkFreeTypeTools_h
 
#include "vtkObject.h"
#include "vtkRenderingFreeTypeModule.h" // For export macro
#include "vtkSmartPointer.h"            // For smart pointer
#include "vtkTextRenderer.h"            // For Metrics struct
 
#include <array> // for std::array
 
VTK_ABI_NAMESPACE_BEGIN
class vtkImageData;
class vtkPath;
class vtkTextProperty;
class vtkStdString;
 
// FreeType
VTK_ABI_NAMESPACE_END
#include "vtk_freetype.h" //since ft2build.h could be in the path
#include FT_FREETYPE_H
#include FT_GLYPH_H
#include FT_CACHE_H
 
VTK_ABI_NAMESPACE_BEGIN
class FTFont;
 
// PIMPL class for FTC_FaceID->vtkTextProperty lookup
class vtkTextPropertyLookup;
 
//----------------------------------------------------------------------------
// Singleton cleanup
class VTKRENDERINGFREETYPE_EXPORT vtkFreeTypeToolsCleanup
{
public:
  vtkFreeTypeToolsCleanup();
  ~vtkFreeTypeToolsCleanup();
 
private:
  vtkFreeTypeToolsCleanup(const vtkFreeTypeToolsCleanup&) = delete;
  vtkFreeTypeToolsCleanup& operator=(const vtkFreeTypeToolsCleanup&) = delete;
};
 
//----------------------------------------------------------------------------
// Singleton font cache
class VTKRENDERINGFREETYPE_EXPORT vtkFreeTypeTools : public vtkObject
{
public:
  struct FaceMetrics
  {
    int UnitsPerEM;
    int Ascender;
    int Descender;
    int HorizAdvance;
    std::array<int, 4> BoundingBox; // xmin, xmax, ymin, ymax
    std::string FamilyName;
    bool Scalable;
    bool Bold;
    bool Italic;
  };
  struct GlyphOutline
  {
    int HorizAdvance;
    vtkSmartPointer<vtkPath> Path;
  };
 
  vtkTypeMacro(vtkFreeTypeTools, vtkObject);
  void PrintSelf(ostream& os, vtkIndent indent) override;
 
  static vtkFreeTypeTools* GetInstance();
 
  static void SetInstance(vtkFreeTypeTools* instance);
 
 
  vtkSetMacro(DebugTextures, bool);
  vtkGetMacro(DebugTextures, bool);
  vtkBooleanMacro(DebugTextures, bool);
 
  FT_Library* GetLibrary();
 
  FaceMetrics GetFaceMetrics(vtkTextProperty* tprop);
 
  GlyphOutline GetUnscaledGlyphOutline(vtkTextProperty* tprop, vtkTypeUInt32 charId);
 
  std::array<int, 2> GetUnscaledKerning(
    vtkTextProperty* tprop, vtkTypeUInt32 leftChar, vtkTypeUInt32 rightChar);
 
 
  vtkSetClampMacro(MaximumNumberOfFaces, unsigned int, 1, VTK_UNSIGNED_INT_MAX);
  vtkGetMacro(MaximumNumberOfFaces, unsigned int);
  vtkSetClampMacro(MaximumNumberOfSizes, unsigned int, 1, VTK_UNSIGNED_INT_MAX);
  vtkGetMacro(MaximumNumberOfSizes, unsigned int);
  vtkSetClampMacro(MaximumNumberOfBytes, unsigned long, 1, VTK_UNSIGNED_LONG_MAX);
  vtkGetMacro(MaximumNumberOfBytes, unsigned long);
 
 
  bool GetBoundingBox(vtkTextProperty* tprop, const vtkStdString& str, int dpi, int bbox[4]);
 
 
  bool GetMetrics(
    vtkTextProperty* tprop, const vtkStdString& str, int dpi, vtkTextRenderer::Metrics& metrics);
 
 
  bool RenderString(vtkTextProperty* tprop, const vtkStdString& str, int dpi, vtkImageData* data,
    int textDims[2] = nullptr);
 
 
  bool StringToPath(vtkTextProperty* tprop, const vtkStdString& str, int dpi, vtkPath* path);
 
 
  int GetConstrainedFontSize(
    const vtkStdString& str, vtkTextProperty* tprop, int dpi, int targetWidth, int targetHeight);
 
  static vtkTypeUInt16 HashString(const char* str);
 
  static vtkTypeUInt32 HashBuffer(const void* buffer, size_t n, vtkTypeUInt32 hash = 0);
 
 
  void MapTextPropertyToId(vtkTextProperty* tprop, size_t* tprop_cache_id);
  void MapIdToTextProperty(size_t tprop_cache_id, vtkTextProperty* tprop);
 
 
  vtkSetMacro(ScaleToPowerTwo, bool);
  vtkGetMacro(ScaleToPowerTwo, bool);
  vtkBooleanMacro(ScaleToPowerTwo, bool);
 
 
  vtkSetMacro(ForceCompiledFonts, bool);
  vtkGetMacro(ForceCompiledFonts, bool);
  vtkBooleanMacro(ForceCompiledFonts, bool);
 
  static bool LookupFace(vtkTextProperty* tprop, FT_Library lib, FT_Face* face);
 
protected:
  virtual FT_Error CreateFTCManager();
 
 
  class MetaData;
  class ImageMetaData;
  bool PrepareMetaData(vtkTextProperty* tprop, int dpi, MetaData& metaData);
  bool PrepareImageMetaData(vtkTextProperty* tprop, vtkImageData* image, ImageMetaData& metaData);
 
  void PrepareImageData(vtkImageData* data, int bbox[4]);
 
  void RenderBackground(vtkTextProperty* tprop, vtkImageData* image, ImageMetaData& metaData);
 
  bool GetSize(vtkTextProperty* tprop, FT_Size* size);
 
  bool GetFace(vtkTextProperty* tprop, FT_Face* face);
 
  bool GetGlyphIndex(vtkTextProperty* tprop, FT_UInt32 c, FT_UInt* gindex);
 
 
  enum
  {
    GLYPH_REQUEST_DEFAULT = 0,
    GLYPH_REQUEST_BITMAP = 1,
    GLYPH_REQUEST_OUTLINE = 2
  };
  bool GetGlyph(
    vtkTextProperty* tprop, FT_UInt32 c, FT_Glyph* glyph, int request = GLYPH_REQUEST_DEFAULT);
  bool GetSize(size_t tprop_cache_id, int font_size, FT_Size* size);
  bool GetSize(FTC_Scaler scaler, FT_Size* size);
  bool GetFace(size_t tprop_cache_id, FT_Face* face);
  bool GetGlyphIndex(size_t tprop_cache_id, FT_UInt32 c, FT_UInt* gindex);
  bool GetGlyph(size_t tprop_cache_id, int font_size, FT_UInt gindex, FT_Glyph* glyph,
    int request = GLYPH_REQUEST_DEFAULT);
  bool GetGlyph(
    FTC_Scaler scaler, FT_UInt gindex, FT_Glyph* glyph, int request = GLYPH_REQUEST_DEFAULT);
 
  bool ScaleToPowerTwo;
 
  vtkFreeTypeTools();
  ~vtkFreeTypeTools() override;
 
  bool GetFace(vtkTextProperty* prop, size_t& prop_cache_id, FT_Face& face, bool& face_has_kerning);
 
 
  FT_Bitmap* GetBitmap(FT_UInt32 c, size_t prop_cache_id, int prop_font_size, FT_UInt& gindex,
    FT_BitmapGlyph& bitmap_glyph);
  FT_Bitmap* GetBitmap(
    FT_UInt32 c, FTC_Scaler scaler, FT_UInt& gindex, FT_BitmapGlyph& bitmap_glyph);
 
 
  FT_Outline* GetOutline(FT_UInt32 c, size_t prop_cache_id, int prop_font_size, FT_UInt& gindex,
    FT_OutlineGlyph& outline_glyph);
  FT_Outline* GetOutline(
    FT_UInt32 c, FTC_Scaler scaler, FT_UInt& gindex, FT_OutlineGlyph& outline_glyph);
 
  static vtkFreeTypeTools* Instance;
 
  vtkTextPropertyLookup* TextPropertyLookup;
 
  FT_Library* Library;
 
 
  FTC_Manager* CacheManager;
  FTC_ImageCache* ImageCache;
  FTC_CMapCache* CMapCache;
 
 
  FTC_Manager* GetCacheManager();
  FTC_ImageCache* GetImageCache();
  FTC_CMapCache* GetCMapCache();
 
  unsigned int MaximumNumberOfFaces;
  unsigned int MaximumNumberOfSizes;
  unsigned long MaximumNumberOfBytes;
 
  bool ForceCompiledFonts;
  bool DebugTextures;
 
  void InitializeCacheManager();
  void ReleaseCacheManager();
 
private:
  vtkFreeTypeTools(const vtkFreeTypeTools&) = delete;
  void operator=(const vtkFreeTypeTools&) = delete;
 
  bool RenderStringInternal(
    vtkTextProperty* tprop, const std::string& str, int dpi, vtkImageData* data, int textDims[2]);
 
  bool StringToPathInternal(vtkTextProperty* tprop, const std::string& str, int dpi, vtkPath* path);
 
 
  bool CalculateBoundingBox(const vtkStdString& str, MetaData& metaData);
  bool CalculateBoundingBox(
    const std::string& str, MetaData& metaData, const std::string& defaultHeightString);
 
  template <typename DataType>
  bool PopulateData(const std::string& str, DataType data, MetaData& metaData);
 
  template <typename DataType>
  bool RenderLine(std::string::const_iterator begin, std::string::const_iterator end, int lineIndex,
    DataType data, MetaData& metaData);
 
 
  bool RenderCharacter(FT_UInt32 codepoint, int& x, int& y, FT_UInt& previousGlyphIndex,
    vtkImageData* image, MetaData& metaData);
  bool RenderCharacter(FT_UInt32 codepoint, int& x, int& y, FT_UInt& previousGlyphIndex,
    vtkPath* path, MetaData& metaData);
 
  void OutlineToPath(int x, int y, FT_Outline* outline, vtkPath* path);
 
  int FitStringToBBox(
    const std::string& str, MetaData& metaData, int targetWidth, int targetHeight);
 
 
  void GetLineMetrics(std::string::const_iterator begin, std::string::const_iterator end,
    MetaData& metaData, int& width, int bbox[4]);
};
 
// This is here to implement the Schwarz counter idiom.
static vtkFreeTypeToolsCleanup vtkFreeTypeToolsCleanupInstance;
 
VTK_ABI_NAMESPACE_END
#endif