vtkFreeTypeTools.h

Go to the documentation of this file.

/*=========================================================================

  Program:   Visualization Toolkit
  Module:    vtkFreeTypeTools.h

  Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
  All rights reserved.
  See Copyright.txt or http://www.kitware.com/Copyright.htm for details.

     This software is distributed WITHOUT ANY WARRANTY; without even
     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
     PURPOSE.  See the above copyright notice for more information.

=========================================================================*/
#ifndef vtkFreeTypeTools_h
#define vtkFreeTypeTools_h

#include "vtkRenderingFreeTypeModule.h" // For export macro
#include "vtkObject.h"
#include "vtkSmartPointer.h" // For smart pointer
#include "vtkTextRenderer.h" // For Metrics struct
#include "vtkUnicodeString.h" // For vtkUnicodeStringValueType

#include <array> // for std::array

class vtkImageData;
class vtkPath;
class vtkTextProperty;
class vtkStdString;

// FreeType
#include "vtk_freetype.h"  //since ft2build.h could be in the path
#include FT_FREETYPE_H
#include FT_GLYPH_H
#include FT_CACHE_H

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,
                                       vtkUnicodeStringValueType charId);

  std::array<int, 2> GetUnscaledKerning(vtkTextProperty *tprop,
                                        vtkUnicodeStringValueType leftChar,
                                        vtkUnicodeStringValueType 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 GetBoundingBox(vtkTextProperty *tprop, const vtkUnicodeString& str,
                      int dpi, int bbox[4]);


  bool GetMetrics(vtkTextProperty *tprop, const vtkStdString& str, int dpi,
                  vtkTextRenderer::Metrics &metrics);
  bool GetMetrics(vtkTextProperty *tprop, const vtkUnicodeString& str, int dpi,
                  vtkTextRenderer::Metrics &metrics);


  bool RenderString(vtkTextProperty *tprop, const vtkStdString& str, int dpi,
                    vtkImageData *data, int textDims[2] = nullptr);
  bool RenderString(vtkTextProperty *tprop, const vtkUnicodeString& str,
                    int dpi, vtkImageData *data, int textDims[2] = nullptr);


  bool StringToPath(vtkTextProperty *tprop, const vtkStdString& str, int dpi,
                    vtkPath *path);
  bool StringToPath(vtkTextProperty *tprop, const vtkUnicodeString& str,
                    int dpi, vtkPath *path);


  int GetConstrainedFontSize(const vtkStdString &str, vtkTextProperty *tprop,
                             int dpi, int targetWidth, int targetHeight);
  int GetConstrainedFontSize(const vtkUnicodeString &str,
                             vtkTextProperty *tprop, int dpi,
                             int targetWidth, int targetHeight);

  static vtkTypeUInt16 HashString(const char *str);

  static vtkTypeUInt32 HashBuffer(const void* str, 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;

  template <typename StringType>
  bool RenderStringInternal(vtkTextProperty *tprop, const StringType &str,
                            int dpi, vtkImageData *data, int textDims[2]);

  template <typename StringType>
  bool StringToPathInternal(vtkTextProperty *tprop, const StringType &str,
                            int dpi, vtkPath *path);


  bool CalculateBoundingBox(const vtkStdString& str, MetaData &metaData);
  bool CalculateBoundingBox(const vtkUnicodeString& str, MetaData &metaData);
  template <typename T>
  bool CalculateBoundingBox(const T& str, MetaData &metaData, const T& defaultHeightString);

  template <typename StringType, typename DataType>
  bool PopulateData(const StringType& str, DataType data, MetaData &metaData);

  template <typename IteratorType, typename DataType>
  bool RenderLine(IteratorType begin, IteratorType end, int lineIndex,
                  DataType data, MetaData &metaData);


  template <typename CharType>
  bool RenderCharacter(CharType character, int &x, int &y,
                       FT_UInt &previousGlyphIndex, vtkImageData *image,
                       MetaData &metaData);
  template <typename CharType>
  bool RenderCharacter(CharType character, int &x, int &y,
                       FT_UInt &previousGlyphIndex, vtkPath *path,
                       MetaData &metaData);

  void OutlineToPath(int x, int y, FT_Outline *outline, vtkPath *path);

  template <typename T>
  int FitStringToBBox(const T &str, MetaData &metaData, int targetWidth,
                      int targetHeight);


  template<typename T>
  void GetLineMetrics(T begin, T end, MetaData &metaData, int &width,
                      int bbox[4]);
};

// This is here to implement the Schwarz counter idiom.
static vtkFreeTypeToolsCleanup vtkFreeTypeToolsCleanupInstance;

#endif