mirror of
https://github.com/opencv/opencv.git
synced 2026-07-30 15:53:03 +04:00
Merge pull request #29300 from vpisarev:add_harfbuzz
Added harfbuzz; use it instead of STB to render text #29300 Merge with https://github.com/opencv/opencv_extra/pull/1378. This is the next big step to improve font rendering in OpenCV 5.x. See #18760, #26301. See also OpenCV 5.0 release notes, where it was pointed out that complex scripts are not rendered correctly, and HarfBuzz integration is needed to fix it. So, here it is — HarfBuzz integration: * Removed tweaked STB engine. STB truetype rendering engine was included into OpenCV 5.0-pre/5.0 and it was extended to instantiate and render variable fonts, but the support was incomplete and immature. * Instead, we now use [HarfBuzz](https://github.com/harfbuzz/harfbuzz) — famous font shaping library and now also font rendering library, used by many big companies and organizations. * As a result, we now correctly render complex scripts, such as arabic or devanagari, correctly handle font ligatures (ff, fi, ft etc.) <img width="1300" height="600" alt="text_test" src="https://github.com/user-attachments/assets/a7d2c754-0fcf-40f8-8104-578f3a14850b" /> * Potentially, we could also support color emoji, but that would be a next step. * As with STB-based engine, glyphs are cached (the same glyph from the same font is not rendered twice), so the performance should be on par with the previous engine. * When OpenCV is built with `-DWITH_HARFBUZZ=ON`, which is set by default, it tries to detect HarfBuzz in the system and use it. If it's not detected, OpenCV builds our own small subset of HarfBuzz. The following table compares size of libopencv_imgproc.dylib.5.0.0 (Release mode) in different configurations: | Configuration | libopencv_imgproc (stripped) | delta vs 5.0 | |----------------------------------------|------------------------------|----------| | imgproc without text rendering (`-DWITH_HARFBUZZ=OFF`) | 4.27 MB | −2.35 MB | | imgproc with stb-based engine (5.0) | 6.62 MB | 0.0 Mb | | imgproc with HarfBuzz-based engine (this PR) | 7.07 MB | +0.45 MB | The biggest source of the size increase when OpenCV is built with text rendering support (STB- or Harfbuzz-based) is that imgproc in this case includes .ttf fonts (Rubik and 'Wen Quan Yi Micro Hei'), which are gzip-compressed, but still have noticeable size, especially 'Wen Quan Yi' (~2Mb). HarfBuzz itself, compared to STB engine, adds just 0.45Mb, or ~7% to imgproc size. On other platforms (Linux x64, Windows), where IPP or other acceleration libraries are linked into libopencv_imgproc, the harfbuzz footprint is even less noticeable. ### Pull Request Readiness Checklist See details at https://github.com/opencv/opencv/wiki/How_to_contribute#making-a-good-pull-request - [x] I agree to contribute to the project under Apache 2 License. - [x] To the best of my knowledge, the proposed patch is not based on a code under GPL or another license that is incompatible with OpenCV - [x] The PR is proposed to the proper branch - [x] There is a reference to the original bug report and related work - [x] There is accuracy test, performance test and test data in opencv_extra repository, if applicable Patch to opencv_extra has the same branch name. - [x] The feature is well documented and sample code can be built with the project CMake
This commit is contained in:
Vadim Pisarevsky
GitHub
@@ -2,85 +2,61 @@
|
||||
// It is subject to the license terms in the LICENSE file found in the top-level directory
|
||||
// of this distribution and at http://opencv.org/license.html
|
||||
|
||||
//
|
||||
// Unicode text rendering (cv::putText / cv::getTextSize for TrueType/OpenType
|
||||
// fonts), implemented on top of HarfBuzz.
|
||||
//
|
||||
// Pipeline (FontRenderEngine::putText_):
|
||||
// 1. Decode the UTF-8 string to UTF-32 code points.
|
||||
// 2. Segment the code points into runs of uniform script, direction and font.
|
||||
// Script/category come from HarfBuzz's Unicode functions; direction is a
|
||||
// lightweight RTL heuristic (full UAX#9 BiDi is a TODO). For each code point
|
||||
// the engine picks the first font that covers it: the user font first, then
|
||||
// the built-in fallbacks (sans/italic/unifont); uncovered -> '?'. Adjacent
|
||||
// compatible runs are then merged.
|
||||
// 3. Shape each run with hb_shape(), yielding glyph ids and positions
|
||||
// (advances include GPOS kerning); RTL runs come out already reordered.
|
||||
// 4. Lay out and render the glyphs. Each glyph is rasterized once by HarfBuzz's
|
||||
// built-in rasterizer (hb-raster) into a grayscale A8 coverage mask and
|
||||
// cached; the layout walks the pen, applies offsets/advances, handles line
|
||||
// wrapping/alignment, and alpha-blends the masks onto the image.
|
||||
//
|
||||
// Conventions:
|
||||
// * Positions/advances are HarfBuzz 26.6 fixed point (1/64 px); the layout
|
||||
// shifts right by 6 to get pixels.
|
||||
// * Each font is scaled so the ascender maps to the requested pixel size
|
||||
// (matching the historical stb sizing): scale = size*64*upem/ascent.
|
||||
// * The weight argument is 16.16 fixed point; it drives the 'wght' variable
|
||||
// axis (design value = weight/65536).
|
||||
// * The whole engine (cache, scratch buffers, shaping buffer) lives in a
|
||||
// thread_local FontRenderEngine, so it is lock-free across threads.
|
||||
//
|
||||
// Built without HarfBuzz (WITH_HARFBUZZ=OFF) the public API still links but
|
||||
// throws cv::Error::StsNotImplemented (see the #else stub block at end of file).
|
||||
//
|
||||
|
||||
#include "precomp.hpp"
|
||||
|
||||
#include <list>
|
||||
#include <tuple>
|
||||
#include <unordered_map>
|
||||
#include "zlib.h"
|
||||
#include "stb_truetype.hpp"
|
||||
|
||||
namespace cv
|
||||
{
|
||||
|
||||
#ifdef HAVE_HARFBUZZ
|
||||
|
||||
#include <hb.h>
|
||||
#include <hb-ot.h>
|
||||
#include <hb-raster.h>
|
||||
|
||||
#include "builtin_font_sans.h"
|
||||
#include "builtin_font_italic.h"
|
||||
#ifdef HAVE_UNIFONT
|
||||
#include "builtin_font_uni.h"
|
||||
#endif
|
||||
|
||||
typedef stbtt_fontinfo font_t;
|
||||
|
||||
/////////////////////// Some temporary stub for Harfbuzz API /////////////////////////
|
||||
|
||||
#ifndef HAVE_HARFBUZZ
|
||||
|
||||
typedef struct hb_glyph_position_t
|
||||
{
|
||||
int x_advance;
|
||||
int y_advance;
|
||||
int x_offset;
|
||||
int y_offset;
|
||||
} hb_glyph_position_t;
|
||||
|
||||
typedef struct hb_font_t
|
||||
{
|
||||
int font_data;
|
||||
} hb_font_t;
|
||||
|
||||
typedef struct hb_buffer_t
|
||||
{
|
||||
int buf_data;
|
||||
} hb_buffer_t;
|
||||
|
||||
typedef enum hb_direction_t
|
||||
{
|
||||
HB_DIRECTION_INVALID = 0,
|
||||
HB_DIRECTION_LTR = 1,
|
||||
HB_DIRECTION_RTL = 2
|
||||
} hb_direction_t;
|
||||
|
||||
typedef enum hb_script_t
|
||||
{
|
||||
HB_SCRIPT_INVALID = -1,
|
||||
HB_SCRIPT_UNKNOWN = 0,
|
||||
HB_SCRIPT_COMMON = 1,
|
||||
HB_SCRIPT_INHERITED,
|
||||
HB_SCRIPT_LATIN,
|
||||
HB_SCRIPT_CYRILLIC,
|
||||
HB_SCRIPT_GREEK,
|
||||
|
||||
HB_SCRIPT_HAN,
|
||||
HB_SCRIPT_HIRAGANA,
|
||||
|
||||
HB_SCRIPT_ARABIC,
|
||||
HB_SCRIPT_HEBREW,
|
||||
HB_SCRIPT_SYRIAC,
|
||||
HB_SCRIPT_THAANA
|
||||
} hb_script_t;
|
||||
|
||||
typedef struct hb_unicode_funcs_t
|
||||
{
|
||||
int funcs_data;
|
||||
} hb_unicode_funcs_t;
|
||||
|
||||
static hb_buffer_t* hb_buffer_create() { return 0; }
|
||||
static void hb_buffer_destroy(hb_buffer_t*) {}
|
||||
static void hb_buffer_guess_segment_properties(hb_buffer_t *) {}
|
||||
static hb_unicode_funcs_t* hb_unicode_funcs_get_default() { return 0; }
|
||||
|
||||
#endif
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
typedef struct BuiltinFontData
|
||||
@@ -148,8 +124,9 @@ struct FontFace::Impl {
|
||||
Impl()
|
||||
{
|
||||
initParams();
|
||||
ttface = 0;
|
||||
hb_font = 0;
|
||||
hb_upem = 0;
|
||||
hb_ascent = 0;
|
||||
scalefactor = 1.0;
|
||||
italic = false;
|
||||
}
|
||||
@@ -161,29 +138,54 @@ struct FontFace::Impl {
|
||||
|
||||
void deleteFont()
|
||||
{
|
||||
stbtt_ReleaseFont(&ttface);
|
||||
if (hb_font)
|
||||
hb_font_destroy(hb_font);
|
||||
hb_font = 0;
|
||||
currname.clear();
|
||||
initParams();
|
||||
}
|
||||
|
||||
// hb_font references fontbuf read-only, so fontbuf must outlive it;
|
||||
// deleteFont() always runs before fontbuf changes.
|
||||
void createHbFont()
|
||||
{
|
||||
if (hb_font)
|
||||
{
|
||||
hb_font_destroy(hb_font);
|
||||
hb_font = 0;
|
||||
}
|
||||
if (fontbuf.empty())
|
||||
return;
|
||||
hb_blob_t* blob = hb_blob_create((const char*)&fontbuf[0], (unsigned)fontbuf.size(),
|
||||
HB_MEMORY_MODE_READONLY, 0, 0);
|
||||
hb_face_t* face = hb_face_create(blob, 0);
|
||||
hb_blob_destroy(blob);
|
||||
hb_upem = hb_face_get_upem(face);
|
||||
hb_font = hb_font_create(face);
|
||||
hb_face_destroy(face);
|
||||
// A fresh hb_font has scale == upem, so extents come back in font units.
|
||||
hb_font_extents_t fe;
|
||||
hb_ascent = hb_font_get_h_extents(hb_font, &fe) && fe.ascender > 0 ?
|
||||
(int)fe.ascender : (int)hb_upem;
|
||||
}
|
||||
|
||||
void initParams()
|
||||
{
|
||||
currweight = -1;
|
||||
currsize = -1;
|
||||
scale = 1;
|
||||
}
|
||||
|
||||
bool setStd(const BuiltinFontData& fontdata)
|
||||
{
|
||||
if(fontdata.size <= 1)
|
||||
return false;
|
||||
if(ttface == 0 || currname != fontdata.name)
|
||||
if(hb_font == 0 || currname != fontdata.name)
|
||||
{
|
||||
deleteFont();
|
||||
if(!inflate(fontdata.gzdata, fontdata.size, fontbuf))
|
||||
return false;
|
||||
ttface = stbtt_CreateFont(&fontbuf[0], (unsigned)fontbuf.size(), stbtt_GetFontOffsetForIndex(&fontbuf[0],0));
|
||||
if (!ttface)
|
||||
createHbFont();
|
||||
if (!hb_font)
|
||||
return false;
|
||||
}
|
||||
currname = fontdata.name;
|
||||
@@ -197,7 +199,7 @@ struct FontFace::Impl {
|
||||
{
|
||||
CV_Assert(!fontname.empty());
|
||||
|
||||
if(ttface != 0 && fontname == currname)
|
||||
if(hb_font != 0 && fontname == currname)
|
||||
return true;
|
||||
|
||||
deleteFont();
|
||||
@@ -228,8 +230,8 @@ struct FontFace::Impl {
|
||||
fontbuf.resize(srcdata.size());
|
||||
std::copy(srcdata.begin(), srcdata.end(), fontbuf.begin());
|
||||
}
|
||||
ttface = stbtt_CreateFont(&fontbuf[0], (unsigned)fontbuf.size(), stbtt_GetFontOffsetForIndex(&fontbuf[0],0));
|
||||
if (!ttface)
|
||||
createHbFont();
|
||||
if (!hb_font)
|
||||
return false;
|
||||
currname = fontname;
|
||||
initParams();
|
||||
@@ -238,22 +240,21 @@ struct FontFace::Impl {
|
||||
|
||||
bool setParams(int size, int weight)
|
||||
{
|
||||
if (ttface == 0)
|
||||
if (!hb_font)
|
||||
return false;
|
||||
if (std::abs(size - currsize) < 1e-3 &&
|
||||
(weight == currweight || weight == 0))
|
||||
return true;
|
||||
|
||||
if (weight != currweight && weight != 0) {
|
||||
int params[] = {STBTT_FOURCC('w','g','h','t'), weight};
|
||||
if (!stbtt_SetInstance(ttface, params, 1, 0))
|
||||
return false;
|
||||
int hbscale = (hb_ascent > 0)
|
||||
? cvRound((double)size * 64.0 * hb_upem / hb_ascent)
|
||||
: size*64;
|
||||
hb_font_set_scale(hb_font, hbscale, hbscale);
|
||||
if (weight != 0)
|
||||
{
|
||||
hb_variation_t var = { HB_TAG('w','g','h','t'), weight / 65536.0f };
|
||||
hb_font_set_variations(hb_font, &var, 1);
|
||||
currweight = weight;
|
||||
}
|
||||
|
||||
if(size != currsize)
|
||||
scale = stbtt_ScaleForPixelHeightNoDesc(ttface, (float)size);
|
||||
|
||||
currsize = size;
|
||||
return true;
|
||||
}
|
||||
@@ -263,9 +264,9 @@ struct FontFace::Impl {
|
||||
bool italic;
|
||||
int currsize;
|
||||
int currweight;
|
||||
float scale;
|
||||
stbtt_fontinfo* ttface;
|
||||
hb_font_t* hb_font;
|
||||
unsigned hb_upem; // units per em (HarfBuzz)
|
||||
int hb_ascent; // unscaled hhea ascender, for stb-compatible text sizing
|
||||
std::vector<uchar> fontbuf;
|
||||
};
|
||||
|
||||
@@ -273,20 +274,24 @@ struct GlyphCacheKey
|
||||
{
|
||||
GlyphCacheKey()
|
||||
{
|
||||
ttface = 0;
|
||||
face = 0;
|
||||
glyph_index = 0;
|
||||
size = 0;
|
||||
weight = 0;
|
||||
scale = 1.f;
|
||||
}
|
||||
GlyphCacheKey(font_t* ttface_, int index_, double size_, int weight_, float scale_)
|
||||
// 'face' is an opaque per-font identity: the stb font in the stb path,
|
||||
// the hb_font in the HarfBuzz path.
|
||||
GlyphCacheKey(const void* face_, int index_, double size_, int weight_, float scale_ = 1.f)
|
||||
{
|
||||
ttface = ttface_;
|
||||
face = face_;
|
||||
glyph_index = index_;
|
||||
size = cvRound(size_*256);
|
||||
weight = weight_;
|
||||
scale = scale_;
|
||||
}
|
||||
|
||||
font_t* ttface;
|
||||
const void* face;
|
||||
int glyph_index;
|
||||
int size;
|
||||
int weight;
|
||||
@@ -295,7 +300,7 @@ struct GlyphCacheKey
|
||||
|
||||
static bool operator == (const GlyphCacheKey& k1, const GlyphCacheKey& k2)
|
||||
{
|
||||
return k1.ttface == k2.ttface && k1.glyph_index == k2.glyph_index &&
|
||||
return k1.face == k2.face && k1.glyph_index == k2.glyph_index &&
|
||||
k1.size == k2.size && k1.weight == k2.weight && k1.scale == k2.scale;
|
||||
}
|
||||
|
||||
@@ -314,7 +319,7 @@ struct GlyphCacheHash
|
||||
{
|
||||
size_t operator()(const GlyphCacheKey& key) const noexcept
|
||||
{
|
||||
size_t hs[] = {(size_t)(void*)key.ttface, (size_t)key.glyph_index,
|
||||
size_t hs[] = {(size_t)key.face, (size_t)key.glyph_index,
|
||||
(size_t)key.size, (size_t)key.weight}; // do not include scale, because it's completely defined by size
|
||||
return hash_seq(hs, sizeof(hs)/sizeof(hs[0]));
|
||||
}
|
||||
@@ -346,22 +351,19 @@ struct TextSegment
|
||||
{
|
||||
TextSegment()
|
||||
{
|
||||
ttface = 0;
|
||||
fontidx = 0;
|
||||
start = end = 0;
|
||||
script = HB_SCRIPT_UNKNOWN;
|
||||
dir = HB_DIRECTION_LTR;
|
||||
}
|
||||
TextSegment(font_t* ttface_, int fontidx_, int start_, int end_, hb_script_t script_, hb_direction_t dir_)
|
||||
TextSegment(int fontidx_, int start_, int end_, hb_script_t script_, hb_direction_t dir_)
|
||||
{
|
||||
ttface = ttface_;
|
||||
fontidx = fontidx_;
|
||||
start = start_;
|
||||
end = end_;
|
||||
script = script_;
|
||||
dir = dir_;
|
||||
}
|
||||
font_t* ttface;
|
||||
int fontidx;
|
||||
int start, end;
|
||||
hb_script_t script;
|
||||
@@ -370,17 +372,16 @@ struct TextSegment
|
||||
|
||||
struct FontGlyph
|
||||
{
|
||||
FontGlyph() { ttface = 0; index = -1; scale = 1.f; }
|
||||
FontGlyph(font_t* ttface_, int glyph_index_, const hb_glyph_position_t& pos_, float scale_)
|
||||
FontGlyph() { hb_font = 0; index = -1; }
|
||||
FontGlyph(hb_font_t* hb_font_, int glyph_index_,
|
||||
const hb_glyph_position_t& pos_)
|
||||
{
|
||||
ttface = ttface_;
|
||||
hb_font = hb_font_;
|
||||
index = glyph_index_;
|
||||
pos = pos_;
|
||||
scale = scale_;
|
||||
}
|
||||
font_t* ttface;
|
||||
hb_font_t* hb_font;
|
||||
int index;
|
||||
float scale;
|
||||
hb_glyph_position_t pos;
|
||||
};
|
||||
|
||||
@@ -395,19 +396,16 @@ public:
|
||||
hb_buffer_guess_segment_properties(hb_buf);
|
||||
hb_uni_funcs = hb_unicode_funcs_get_default();
|
||||
max_cache_size = (size_t)MAX_CACHE_SIZE;
|
||||
glyph_buf = 0;
|
||||
glyph_bufsz = 0;
|
||||
raster_draw = 0;
|
||||
}
|
||||
|
||||
~FontRenderEngine()
|
||||
{
|
||||
hb_buffer_destroy(hb_buf);
|
||||
if(raster_draw)
|
||||
hb_raster_draw_destroy(raster_draw); // also frees its recycled image
|
||||
for(int i = 0; i < BUILTIN_FONTS_NUM; i++)
|
||||
builtin_ffaces[i] = FontFace();
|
||||
if (glyph_buf)
|
||||
free(glyph_buf);
|
||||
glyph_buf = 0;
|
||||
glyph_bufsz = 0;
|
||||
}
|
||||
|
||||
void addToCache(const GlyphCacheKey& key, const GlyphCacheVal& val)
|
||||
@@ -459,12 +457,12 @@ protected:
|
||||
size_t max_cache_size;
|
||||
|
||||
hb_buffer_t* hb_buf;
|
||||
hb_raster_draw_t* raster_draw; // reused across glyphs (thread_local engine)
|
||||
std::vector<unsigned> u32buf;
|
||||
std::vector<TextSegment> segments;
|
||||
std::vector<FontGlyph> glyphs;
|
||||
std::vector<uchar> pixbuf;
|
||||
uchar* glyph_buf;
|
||||
int glyph_bufsz;
|
||||
std::vector<uchar> glyph_buf;
|
||||
};
|
||||
|
||||
thread_local FontRenderEngine fontRenderEngine;
|
||||
@@ -481,7 +479,7 @@ bool FontFace::set(const String& fontname_)
|
||||
String fontname = fontname_;
|
||||
if(fontname.empty())
|
||||
fontname = "sans";
|
||||
if(impl->ttface != 0 && impl->currname == fontname)
|
||||
if(impl->hb_font != 0 && impl->currname == fontname)
|
||||
return true;
|
||||
int i = 0;
|
||||
for( ; i < BUILTIN_FONTS_NUM; i++ )
|
||||
@@ -498,7 +496,7 @@ bool FontFace::set(const String& fontname_)
|
||||
if( i >= 0 )
|
||||
{
|
||||
FontFace& builtin_fface = engine.getStdFontFace(i);
|
||||
if(builtin_fface.impl->ttface)
|
||||
if(builtin_fface.impl->hb_font)
|
||||
{
|
||||
impl = builtin_fface.impl;
|
||||
ok = true;
|
||||
@@ -506,7 +504,7 @@ bool FontFace::set(const String& fontname_)
|
||||
}
|
||||
else
|
||||
{
|
||||
if(impl->ttface != 0)
|
||||
if(impl->hb_font != 0)
|
||||
impl = makePtr<Impl>();
|
||||
ok = impl->set(fontname);
|
||||
}
|
||||
@@ -526,7 +524,7 @@ bool FontFace::getBuiltinFontData(const String& fontname_,
|
||||
if(builtinFontData[i].name == fontname && builtinFontData[i].size > 1)
|
||||
{
|
||||
FontFace& builtin_fface = fontRenderEngine.getStdFontFace(i);
|
||||
if( builtin_fface.impl->ttface )
|
||||
if( builtin_fface.impl->hb_font )
|
||||
{
|
||||
std::vector<uchar>& fbuf = builtin_fface.impl->fontbuf;
|
||||
size = fbuf.size();
|
||||
@@ -547,28 +545,53 @@ bool FontFace::setInstance(const std::vector<int>& params)
|
||||
{
|
||||
if (params.empty())
|
||||
return true;
|
||||
if (!impl->ttface)
|
||||
return false;
|
||||
CV_Assert(params.size() % 2 == 0);
|
||||
return stbtt_SetInstance(impl->ttface, ¶ms[0], (int)(params.size()/2), 1) > 0;
|
||||
if (!impl->hb_font)
|
||||
return false;
|
||||
int n = (int)(params.size()/2);
|
||||
std::vector<hb_variation_t> vars((size_t)n);
|
||||
for (int i = 0; i < n; i++)
|
||||
{
|
||||
unsigned t = (unsigned)params[i*2];
|
||||
// params hold CV_FOURCC tags (LSB-first); HarfBuzz wants MSB-first tags.
|
||||
vars[i].tag = ((t & 0xFF) << 24) | (((t >> 8) & 0xFF) << 16) |
|
||||
(((t >> 16) & 0xFF) << 8) | ((t >> 24) & 0xFF);
|
||||
// axis values arrive in 16.16 fixed point.
|
||||
vars[i].value = params[i*2+1] / 65536.0f;
|
||||
}
|
||||
hb_font_set_variations(impl->hb_font, vars.data(), n);
|
||||
// Force the next setParams() to re-apply weight (an explicit weight should
|
||||
// override this instance).
|
||||
impl->currweight = -1;
|
||||
return true;
|
||||
}
|
||||
|
||||
bool FontFace::getInstance(std::vector<int>& params) const
|
||||
{
|
||||
if (!impl->ttface)
|
||||
if (!impl->hb_font)
|
||||
return false;
|
||||
|
||||
stbtt_axisinfo axes[STBTT_MAX_AXES];
|
||||
int i, naxes = stbtt_GetInstance(impl->ttface, axes, STBTT_MAX_AXES);
|
||||
params.resize(naxes*2);
|
||||
hb_face_t* face = hb_font_get_face(impl->hb_font);
|
||||
unsigned naxes = hb_ot_var_get_axis_count(face);
|
||||
if (naxes == 0)
|
||||
return false;
|
||||
|
||||
for( i = 0; i < naxes; i++ )
|
||||
std::vector<hb_ot_var_axis_info_t> axes(naxes);
|
||||
unsigned n = naxes;
|
||||
hb_ot_var_get_axis_infos(face, 0, &n, &axes[0]);
|
||||
|
||||
unsigned ncoords = 0;
|
||||
const float* coords = hb_font_get_var_coords_design(impl->hb_font, &ncoords);
|
||||
|
||||
params.resize(naxes*2);
|
||||
for( unsigned i = 0; i < naxes; i++ )
|
||||
{
|
||||
int tag = axes[i].tag;
|
||||
unsigned tag = axes[i].tag; // HarfBuzz tag is MSB-first
|
||||
params[i*2] = CV_FOURCC((char)(tag >> 24), (char)(tag >> 16), (char)(tag >> 8), (char)tag);
|
||||
params[i*2+1] = axes[i].currval;
|
||||
float v = (i < ncoords && coords) ? coords[i] : axes[i].default_value;
|
||||
params[i*2+1] = cvRound(v * 65536.0);
|
||||
}
|
||||
return naxes > 0;
|
||||
return true;
|
||||
}
|
||||
|
||||
static unsigned calccrc(const std::vector<uchar>& buf)
|
||||
@@ -844,7 +867,6 @@ static void drawCharacter(
|
||||
}
|
||||
}
|
||||
|
||||
#ifdef HAVE_HARFBUZZ
|
||||
//by amarullz from https://stackoverflow.com/questions/5423960/how-can-i-recognize-rtl-strings-in-c
|
||||
static bool isRightToLeft(unsigned c)
|
||||
{
|
||||
@@ -881,7 +903,20 @@ static bool isRightToLeft(unsigned c)
|
||||
((c>=0x10B40)&&(c<=0x10C48))||
|
||||
((c>=0x1EE00)&&(c<=0x1EEBB)));
|
||||
}
|
||||
#endif
|
||||
|
||||
// Glyph id for a code point, or 0 if the font has no glyph for it.
|
||||
static int hbGlyphIndex(hb_font_t* font, unsigned c)
|
||||
{
|
||||
hb_codepoint_t g = 0;
|
||||
return font && hb_font_get_nominal_glyph(font, c, &g) ? (int)g : 0;
|
||||
}
|
||||
|
||||
// Round fixed-point value to the nearest whole pixel.
|
||||
static inline int roundFixPt(int64_t v, int n) {
|
||||
int64_t half = int64_t(1) << (n - 1);
|
||||
int64_t delta = half - 1 + ((v >> n) & 1);
|
||||
return int((v + delta) >> n);
|
||||
}
|
||||
|
||||
Point FontRenderEngine::putText_(
|
||||
Mat& img, Size imgsize, const String& str_, Point org,
|
||||
@@ -889,13 +924,13 @@ Point FontRenderEngine::putText_(
|
||||
int weight_, PutTextFlags flags, Range wrapRange,
|
||||
bool render, Rect* bbox_ )
|
||||
{
|
||||
constexpr int FRAC_BITS = 6;
|
||||
bool bottom_left = (flags & PUT_TEXT_ORIGIN_BL) != 0;
|
||||
int saved_weights[BUILTIN_FONTS_NUM+1]={0};
|
||||
int weight = weight_*65536;
|
||||
|
||||
if(fontface.getName().empty())
|
||||
fontface.set("sans");
|
||||
if(!fontface->ttface)
|
||||
if(!fontface->hb_font)
|
||||
CV_Error(Error::StsError, "No available fonts for putText()");
|
||||
|
||||
Point pen = org;
|
||||
@@ -926,7 +961,6 @@ Point FontRenderEngine::putText_(
|
||||
return org;
|
||||
}
|
||||
|
||||
saved_weights[BUILTIN_FONTS_NUM] = stbtt_GetWeight(fontface->ttface);
|
||||
fontface->setParams(size, weight);
|
||||
|
||||
for(j = 0; j < BUILTIN_FONTS_NUM; j++)
|
||||
@@ -934,11 +968,8 @@ Point FontRenderEngine::putText_(
|
||||
FontFace& fface = builtin_ffaces[j];
|
||||
if(!builtin_ffaces_initialized)
|
||||
fface.set(builtinFontData[j].name);
|
||||
|
||||
if (fface->ttface) {
|
||||
saved_weights[j] = stbtt_GetWeight(fface->ttface);
|
||||
if (fface->hb_font)
|
||||
fface->setParams(size, weight);
|
||||
}
|
||||
}
|
||||
builtin_ffaces_initialized = true;
|
||||
|
||||
@@ -989,24 +1020,20 @@ Point FontRenderEngine::putText_(
|
||||
unsigned* chars = &u32buf[0];
|
||||
int prev_dy = 0;
|
||||
|
||||
#ifdef HAVE_HARFBUZZ
|
||||
hb_direction_t glob_dir = HB_DIRECTION_INVALID;
|
||||
#endif
|
||||
|
||||
while(len > 0)
|
||||
{
|
||||
int nextline_dy = 0;
|
||||
font_t* ttface0 = fontface->ttface;
|
||||
float scale0 = fontface->scale;
|
||||
font_t* curr_ttface = ttface0;
|
||||
|
||||
segments.clear();
|
||||
glyphs.clear();
|
||||
|
||||
#ifdef HAVE_HARFBUZZ
|
||||
hb_script_t curr_script = HB_SCRIPT_UNKNOWN;
|
||||
hb_direction_t curr_dir = HB_DIRECTION_INVALID;
|
||||
int curr_fontidx = -1;
|
||||
hb_font_t* hb_font0 = fontface->hb_font;
|
||||
hb_font_t* curr_hb_font = hb_font0;
|
||||
|
||||
int k, segstart = 0, punctstart = -1;
|
||||
// TODO: possibly implement https://unicode.org/reports/tr9/ or find compact implementation of it
|
||||
@@ -1017,7 +1044,7 @@ Point FontRenderEngine::putText_(
|
||||
break;
|
||||
hb_unicode_general_category_t cat = hb_unicode_general_category(hb_uni_funcs, c);
|
||||
hb_script_t script = hb_unicode_script(hb_uni_funcs, c);
|
||||
int glyph_index = stbtt_FindGlyphIndex(curr_ttface, c);
|
||||
int glyph_index = hbGlyphIndex(curr_hb_font, c);
|
||||
bool is_rtl = isRightToLeft(c);
|
||||
hb_direction_t dir = HB_DIRECTION_INVALID;
|
||||
|
||||
@@ -1088,11 +1115,11 @@ Point FontRenderEngine::putText_(
|
||||
glob_dir = dir;
|
||||
}
|
||||
|
||||
font_t* ttface = 0;
|
||||
hb_font_t* cand_hb = hb_font0;
|
||||
for(j = -1; j < BUILTIN_FONTS_NUM; j++)
|
||||
{
|
||||
ttface = j < 0 ? ttface0 : builtin_ffaces[j]->ttface;
|
||||
glyph_index = stbtt_FindGlyphIndex(ttface, c);
|
||||
cand_hb = j < 0 ? hb_font0 : builtin_ffaces[j]->hb_font;
|
||||
glyph_index = hbGlyphIndex(cand_hb, c);
|
||||
if(glyph_index != 0)
|
||||
break;
|
||||
if(j+1 == BUILTIN_FONTS_NUM)
|
||||
@@ -1117,7 +1144,7 @@ Point FontRenderEngine::putText_(
|
||||
{
|
||||
for(k = i; k > punctstart; k--)
|
||||
{
|
||||
if(stbtt_FindGlyphIndex(ttface, chars[k-1]) == 0)
|
||||
if(hbGlyphIndex(cand_hb, chars[k-1]) == 0)
|
||||
break;
|
||||
}
|
||||
seglen = k - segstart;
|
||||
@@ -1126,12 +1153,12 @@ Point FontRenderEngine::putText_(
|
||||
if(seglen > 0)
|
||||
{
|
||||
//printf("segment of %d characters pushed\n", seglen);
|
||||
segments.push_back(TextSegment(curr_ttface, curr_fontidx,
|
||||
segments.push_back(TextSegment(curr_fontidx,
|
||||
segstart, segstart + seglen, curr_script, curr_dir));
|
||||
}
|
||||
segstart += seglen;
|
||||
punctstart = punctstart >= 0 && is_punct ? segstart : -1;
|
||||
curr_ttface = ttface;
|
||||
curr_hb_font = cand_hb;
|
||||
curr_fontidx = fontidx;
|
||||
curr_script = script;
|
||||
curr_dir = dir;
|
||||
@@ -1139,7 +1166,7 @@ Point FontRenderEngine::putText_(
|
||||
|
||||
if(i > segstart)
|
||||
{
|
||||
segments.push_back(TextSegment(curr_ttface, curr_fontidx,
|
||||
segments.push_back(TextSegment(curr_fontidx,
|
||||
segstart, i, curr_script, curr_dir));
|
||||
}
|
||||
|
||||
@@ -1147,7 +1174,6 @@ Point FontRenderEngine::putText_(
|
||||
glob_dir = HB_DIRECTION_LTR;
|
||||
|
||||
int nsegments = (int)segments.size();
|
||||
ttface0 = segments[0].ttface;
|
||||
|
||||
if(nsegments > 0)
|
||||
{
|
||||
@@ -1168,7 +1194,7 @@ Point FontRenderEngine::putText_(
|
||||
if(script == HB_SCRIPT_INVALID)
|
||||
seg.script = script = HB_SCRIPT_COMMON;
|
||||
TextSegment& prev = segments[k];
|
||||
if(seg.ttface == prev.ttface && seg.dir == prev.dir &&
|
||||
if(seg.fontidx == prev.fontidx && seg.dir == prev.dir &&
|
||||
(script == prev.script ||
|
||||
((script == HB_SCRIPT_COMMON || script == HB_SCRIPT_LATIN ||
|
||||
script == HB_SCRIPT_CYRILLIC || script == HB_SCRIPT_GREEK ||
|
||||
@@ -1207,7 +1233,6 @@ Point FontRenderEngine::putText_(
|
||||
const TextSegment& seg = segments[j];
|
||||
int fontidx = seg.fontidx;
|
||||
FontFace& fface = fontidx < 0 ? fontface : builtin_ffaces[fontidx];
|
||||
font_t* ttface = fface->ttface;
|
||||
hb_font_t* hb_font = fface->hb_font;
|
||||
hb_buffer_reset(hb_buf);
|
||||
hb_buffer_add_utf32(hb_buf, chars, len, seg.start, seg.end - seg.start);
|
||||
@@ -1221,45 +1246,10 @@ Point FontRenderEngine::putText_(
|
||||
|
||||
for(k = 0; k < (int)nglyphs; k++)
|
||||
{
|
||||
FontGlyph glyph(ttface, ginfo[k].codepoint, gpos[k], fface->scale);
|
||||
FontGlyph glyph(hb_font, ginfo[k].codepoint, gpos[k]);
|
||||
glyphs.push_back(glyph);
|
||||
}
|
||||
}
|
||||
#else
|
||||
for(i = 0; i < len; i++)
|
||||
{
|
||||
int c = chars[i];
|
||||
if(c == '\n')
|
||||
break;
|
||||
font_t* ttface = ttface0;
|
||||
float scale = scale0;
|
||||
int q_glyph_index = stbtt_FindGlyphIndex(ttface0, '?');
|
||||
for(j = -1; j < BUILTIN_FONTS_NUM; j++)
|
||||
{
|
||||
if (j >= 0)
|
||||
{
|
||||
ttface = builtin_ffaces[j]->ttface;
|
||||
scale = builtin_ffaces[j]->scale;
|
||||
}
|
||||
int glyph_index = ttface ? stbtt_FindGlyphIndex(ttface, c) : 0;
|
||||
if(glyph_index == 0)
|
||||
{
|
||||
if (j+1 < BUILTIN_FONTS_NUM)
|
||||
continue;
|
||||
ttface = ttface0;
|
||||
scale = scale0;
|
||||
glyph_index = q_glyph_index;
|
||||
}
|
||||
hb_glyph_position_t pos;
|
||||
pos.x_advance = pos.y_advance = 0;
|
||||
pos.x_offset = pos.y_offset = 0;
|
||||
glyphs.push_back(FontGlyph(ttface, glyph_index, pos, scale));
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (i == 0)
|
||||
nextline_dy = prev_dy;
|
||||
#endif
|
||||
|
||||
chars += i;
|
||||
len -= i;
|
||||
@@ -1274,26 +1264,28 @@ Point FontRenderEngine::putText_(
|
||||
// (TODO: in the case of right alignment we need to render it from the right-most character)
|
||||
int nglyphs = (int)glyphs.size();
|
||||
int space_glyph = -1;
|
||||
curr_ttface = 0;
|
||||
min_x = std::min(min_x, pen.x);
|
||||
max_x = std::max(max_x, pen.x);
|
||||
|
||||
curr_ttface = 0;
|
||||
curr_hb_font = 0;
|
||||
int ascent = 0, descent = 0, linegap = 0;
|
||||
for(j = 0; j < nglyphs; j++)
|
||||
{
|
||||
const FontGlyph& glyph = glyphs[alignment == PUT_TEXT_ALIGN_RIGHT ? nglyphs - j - 1 : j];
|
||||
font_t* ttface = glyph.ttface;
|
||||
if(ttface != curr_ttface)
|
||||
hb_font_t* hbf = glyph.hb_font;
|
||||
if(hbf != curr_hb_font)
|
||||
{
|
||||
curr_ttface = ttface;
|
||||
space_glyph = stbtt_FindGlyphIndex(ttface, ' ');
|
||||
stbtt_GetFontVMetrics(ttface, &ascent, &descent, &linegap);
|
||||
curr_hb_font = hbf;
|
||||
hb_codepoint_t sp = 0;
|
||||
space_glyph = hb_font_get_nominal_glyph(hbf, ' ', &sp) ? (int)sp : -1;
|
||||
hb_font_extents_t fext;
|
||||
hb_font_get_h_extents(hbf, &fext);
|
||||
ascent = fext.ascender;
|
||||
descent = fext.descender;
|
||||
linegap = fext.line_gap;
|
||||
if (linegap == 0) linegap = ascent - descent;
|
||||
}
|
||||
|
||||
float scale = glyph.scale;
|
||||
GlyphCacheKey key(curr_ttface, glyph.index, size, weight, scale);
|
||||
GlyphCacheKey key(hbf, glyph.index, size, weight);
|
||||
GlyphCacheVal* cached = findCachedGlyph(key);
|
||||
const uchar* bitmap_buf = 0;
|
||||
int bitmap_step = 0;
|
||||
@@ -1302,22 +1294,68 @@ Point FontRenderEngine::putText_(
|
||||
if(!cached)
|
||||
{
|
||||
cached = &new_cached;
|
||||
int w=0, h=0, xoff=0, yoff=0;
|
||||
float advx = 0.f;
|
||||
bitmap_buf = stbtt_GetGlyphBitmapSubpixelRealloc(ttface, scale, scale, 0.f, 0.f,
|
||||
glyph.index, &w, &h, &bitmap_step, &xoff, &yoff, &advx, &glyph_buf, &glyph_bufsz);
|
||||
if(!bitmap_buf)
|
||||
int w=0, h=0;
|
||||
// One rasterizer per thread_local engine: its internal scratch
|
||||
// (edges, row buffers, edge buckets) and the output image are
|
||||
// reused across glyphs instead of reallocated per glyph.
|
||||
if(!raster_draw)
|
||||
raster_draw = hb_raster_draw_create_or_fail();
|
||||
hb_raster_draw_t* rd = raster_draw;
|
||||
if(!rd)
|
||||
continue;
|
||||
//printf("j=%d. bw=%d, bh=%d, step=%d, xoff=%d, yoff=%d, advx=%.1f, glyph_bufsz=%d\n", j, w, h, bitmap_step, xoff, yoff, advx, glyph_bufsz);
|
||||
// Outline coords come in 26.6 (font scaled to size*64); the
|
||||
// rasterizer divides by the scale factor, so 64 -> device pixels
|
||||
// and the output extents are whole pixels.
|
||||
hb_raster_draw_set_scale_factor(rd, 64.f, 64.f);
|
||||
hb_raster_extents_t zext;
|
||||
memset(&zext, 0, sizeof(zext));
|
||||
hb_raster_draw_set_extents(rd, &zext);
|
||||
hb_glyph_extents_t gext;
|
||||
if(hb_font_get_glyph_extents(hbf, glyph.index, &gext))
|
||||
hb_raster_draw_set_glyph_extents(rd, &gext);
|
||||
hb_raster_draw_glyph(rd, hbf, glyph.index);
|
||||
hb_raster_image_t* rimg = hb_raster_draw_render(rd);
|
||||
|
||||
hb_raster_extents_t rext;
|
||||
memset(&rext, 0, sizeof(rext));
|
||||
const uint8_t* rbuf = 0;
|
||||
if(rimg)
|
||||
{
|
||||
hb_raster_image_get_extents(rimg, &rext);
|
||||
rbuf = hb_raster_image_get_buffer(rimg);
|
||||
}
|
||||
w = (int)rext.width;
|
||||
h = (int)rext.height;
|
||||
|
||||
// Copy the A8 mask into the persistent scratch buffer (it must
|
||||
// outlive the raster image) flipping rows: hb-raster buffers are
|
||||
// bottom-up (y-up), drawCharacter expects top-down.
|
||||
bitmap_step = w;
|
||||
if(w > 0 && h > 0 && rbuf)
|
||||
{
|
||||
size_t need = (size_t)w*h;
|
||||
if(need > glyph_buf.size())
|
||||
glyph_buf.resize(need);
|
||||
unsigned src_step = rext.stride ? rext.stride : (unsigned)w;
|
||||
for(int yy = 0; yy < h; yy++)
|
||||
memcpy(glyph_buf.data() + yy*w, rbuf + (size_t)(h-1-yy)*src_step, w);
|
||||
}
|
||||
bitmap_buf = glyph_buf.empty() ? 0 : glyph_buf.data();
|
||||
|
||||
// Hand the image back to the rasterizer to reuse next time
|
||||
// instead of freeing it (render() already cleared geometry).
|
||||
if(rimg)
|
||||
hb_raster_draw_recycle_image(rd, rimg);
|
||||
|
||||
cached->width = w;
|
||||
cached->height = h;
|
||||
cached->advance.x = cvRound(advx*64);
|
||||
cached->advance.x = 0; // advance comes from the shaped position
|
||||
cached->advance.y = 0;
|
||||
cached->ascent = cvRound(ascent*glyph.scale);
|
||||
cached->linegap = cvRound(linegap*glyph.scale);
|
||||
cached->horiBearingX = (int)(xoff*64);
|
||||
cached->horiBearingY = (int)(-yoff*64);
|
||||
cached->ascent = cvRound(ascent/double(1 << FRAC_BITS));
|
||||
cached->linegap = cvRound(linegap/double(1 << FRAC_BITS));
|
||||
// extents are whole pixels (scale factor 64); bearings are 1/64 px
|
||||
cached->horiBearingX = rext.x_origin * (1 << FRAC_BITS);
|
||||
cached->horiBearingY = (rext.y_origin + h) * (1 << FRAC_BITS);
|
||||
|
||||
bbox = Rect(0, 0, w, h);
|
||||
|
||||
@@ -1344,8 +1382,14 @@ Point FontRenderEngine::putText_(
|
||||
}
|
||||
|
||||
const hb_glyph_position_t& pos = glyph.pos;
|
||||
int dx = cached->advance.x >> 6;
|
||||
int dy = cached->advance.y >> 6;
|
||||
// Advances are 26.6 fixed point. Round each advance to the nearest
|
||||
// whole pixel and keep the pen on integer pixels (rather than flooring
|
||||
// with >>6): glyphs are rasterized/cached at integer positions, so a
|
||||
// sub-pixel pen would only add jitter to the inter-glyph gaps, while
|
||||
// flooring every advance systematically tightens the spacing. Rounding
|
||||
// the advance keeps the gaps even and removes that bias.
|
||||
int dx = roundFixPt(pos.x_advance, FRAC_BITS);
|
||||
int dy = roundFixPt(pos.y_advance, FRAC_BITS);
|
||||
int new_pen_x = pen.x + dx*alignSign;
|
||||
nextline_dy = max(nextline_dy, cached->linegap);
|
||||
// TODO: this wrapping algorithm is quite dumb,
|
||||
@@ -1363,14 +1407,15 @@ Point FontRenderEngine::putText_(
|
||||
|
||||
if(!wrapped)
|
||||
max_dy = std::max(max_dy, cached->ascent);
|
||||
int baseline = cached->height - (cached->horiBearingY >> 6);
|
||||
int baseline = cached->height - (cached->horiBearingY >> FRAC_BITS);
|
||||
max_baseline = std::max(max_baseline, baseline);
|
||||
|
||||
if(alignment == PUT_TEXT_ALIGN_RIGHT)
|
||||
pen.x = new_pen_x;
|
||||
|
||||
int x = pen.x + bbox.x + ((pos.x_offset + cached->horiBearingX) >> 6);
|
||||
int y = pen.y + (bottom_left ? 1 : -1)*(((pos.y_offset + cached->horiBearingY) >> 6) - bbox.y);
|
||||
int x = pen.x + bbox.x + ((pos.x_offset + cached->horiBearingX) >> FRAC_BITS);
|
||||
int y = pen.y + (bottom_left ? 1 : -1)*(((pos.y_offset +
|
||||
cached->horiBearingY) >> FRAC_BITS) - bbox.y);
|
||||
|
||||
if( render )
|
||||
{
|
||||
@@ -1400,17 +1445,6 @@ Point FontRenderEngine::putText_(
|
||||
*bbox_ = Rect(min_x, org.y - max_dy, max_x - min_x + 1, pen.y - org.y + max_dy + max_baseline);
|
||||
}
|
||||
|
||||
// restore the weights
|
||||
if (weight != 0)
|
||||
for(j = 0; j <= BUILTIN_FONTS_NUM; j++)
|
||||
{
|
||||
font_t* ttface = (j < BUILTIN_FONTS_NUM ? builtin_ffaces[j] : fontface)->ttface;
|
||||
if (!ttface || stbtt_GetWeight(ttface) == saved_weights[j])
|
||||
continue;
|
||||
int params[] = {STBTT_FOURCC('w', 'g', 'h', 't'), saved_weights[j]};
|
||||
stbtt_SetInstance(ttface, params, 1, 0);
|
||||
}
|
||||
|
||||
return pen;
|
||||
}
|
||||
|
||||
@@ -1446,6 +1480,38 @@ Rect getTextSize(Size imgsize, const String& str, Point org,
|
||||
return bbox;
|
||||
}
|
||||
|
||||
#else // HAVE_HARFBUZZ
|
||||
|
||||
// Text rendering is implemented entirely on top of HarfBuzz. When OpenCV is
|
||||
// built without it, the public text API is present but throws.
|
||||
struct FontFace::Impl {};
|
||||
|
||||
FontFace::FontFace() {}
|
||||
FontFace::FontFace(const String&) {}
|
||||
bool FontFace::set(const String&) { return false; }
|
||||
String FontFace::getName() const { return String(); }
|
||||
FontFace::Impl* FontFace::operator -> () { return impl.get(); }
|
||||
FontFace::~FontFace() {}
|
||||
bool FontFace::setInstance(const std::vector<int>&) { return false; }
|
||||
bool FontFace::getInstance(std::vector<int>&) const { return false; }
|
||||
bool FontFace::getBuiltinFontData(const String&, const uchar*&, size_t&) { return false; }
|
||||
|
||||
#define OPENCV_NO_TEXT_RENDERING_MSG \
|
||||
"Text rendering is not supported. Compile OpenCV with WITH_HARFBUZZ=ON."
|
||||
|
||||
Point putText(InputOutputArray, const String&, Point, Scalar,
|
||||
FontFace&, int, int, PutTextFlags, Range)
|
||||
{
|
||||
CV_Error(Error::StsNotImplemented, OPENCV_NO_TEXT_RENDERING_MSG);
|
||||
}
|
||||
|
||||
Rect getTextSize(Size, const String&, Point, FontFace&, int, int, PutTextFlags, Range)
|
||||
{
|
||||
CV_Error(Error::StsNotImplemented, OPENCV_NO_TEXT_RENDERING_MSG);
|
||||
}
|
||||
|
||||
#endif // HAVE_HARFBUZZ
|
||||
|
||||
}
|
||||
|
||||
//////////////////////////// text drawing functions for backward compatibility ///////////////////////////
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
@@ -1,692 +0,0 @@
|
||||
// This file is part of OpenCV project.
|
||||
// It is subject to the license terms in the LICENSE file found in the top-level directory
|
||||
// of this distribution and at http://opencv.org/license.html.
|
||||
|
||||
// This is refactored (and split into 2 files) version of stb_truetype.h
|
||||
// from https://github.com/nothings/stb.
|
||||
// Support for variable fonts has been added and
|
||||
// a few other modifications & optimizations have been done.
|
||||
|
||||
//////////////// Below is the original copyright information /////////////////
|
||||
///////// (btw, OpenCV chooses the option A (MIT) for the license) ///////////
|
||||
|
||||
// Authored from 2009-2020 by Sean Barrett / RAD Game Tools.
|
||||
// See stb_truetype.cpp for the details
|
||||
|
||||
/*
|
||||
------------------------------------------------------------------------------
|
||||
This software is available under 2 licenses -- choose whichever you prefer.
|
||||
------------------------------------------------------------------------------
|
||||
ALTERNATIVE A - MIT License
|
||||
Copyright (c) 2017 Sean Barrett
|
||||
Permission is hereby granted, free of charge, to any person obtaining a copy of
|
||||
this software and associated documentation files (the "Software"), to deal in
|
||||
the Software without restriction, including without limitation the rights to
|
||||
use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
|
||||
of the Software, and to permit persons to whom the Software is furnished to do
|
||||
so, subject to the following conditions:
|
||||
The above copyright notice and this permission notice shall be included in all
|
||||
copies or substantial portions of the Software.
|
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
||||
SOFTWARE.
|
||||
------------------------------------------------------------------------------
|
||||
ALTERNATIVE B - Public Domain (www.unlicense.org)
|
||||
This is free and unencumbered software released into the public domain.
|
||||
Anyone is free to copy, modify, publish, use, compile, sell, or distribute this
|
||||
software, either in source code form or as a compiled binary, for any purpose,
|
||||
commercial or non-commercial, and by any means.
|
||||
In jurisdictions that recognize copyright laws, the author or authors of this
|
||||
software dedicate any and all copyright interest in the software to the public
|
||||
domain. We make this dedication for the benefit of the public at large and to
|
||||
the detriment of our heirs and successors. We intend this dedication to be an
|
||||
overt act of relinquishment in perpetuity of all present and future rights to
|
||||
this software under copyright law.
|
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
|
||||
ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
|
||||
WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
------------------------------------------------------------------------------
|
||||
*/
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
////
|
||||
//// INTERFACE
|
||||
////
|
||||
////
|
||||
|
||||
#ifndef __STB_INCLUDE_STB_TRUETYPE_HPP__
|
||||
#define __STB_INCLUDE_STB_TRUETYPE_HPP__
|
||||
|
||||
#if 0 //def STBTT_STATIC
|
||||
#define STBTT_DEF static
|
||||
#else
|
||||
#define STBTT_DEF extern
|
||||
#endif
|
||||
|
||||
#ifdef __cplusplus
|
||||
namespace cv {
|
||||
#endif
|
||||
|
||||
#define STBTT_FOURCC(a, b, c, d) \
|
||||
(unsigned)((((unsigned char)(a)) << 24) | \
|
||||
(((unsigned char)(b)) << 16) | \
|
||||
(((unsigned char)(c)) << 8) | \
|
||||
((unsigned char)(d)))
|
||||
|
||||
// private structure
|
||||
typedef struct
|
||||
{
|
||||
unsigned char *data;
|
||||
int cursor;
|
||||
int size;
|
||||
} stbtt__buf;
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// TEXTURE BAKING API
|
||||
//
|
||||
// If you use this API, you only have to call two functions ever.
|
||||
//
|
||||
|
||||
typedef struct
|
||||
{
|
||||
unsigned short x0,y0,x1,y1; // coordinates of bbox in bitmap
|
||||
float xoff,yoff,xadvance;
|
||||
} stbtt_bakedchar;
|
||||
|
||||
STBTT_DEF int stbtt_BakeFontBitmap(const unsigned char *data, int offset, // font location (use offset=0 for plain .ttf)
|
||||
float pixel_height, // height of font in pixels
|
||||
unsigned char *pixels, int pw, int ph, // bitmap to be filled in
|
||||
int first_char, int num_chars, // characters to bake
|
||||
stbtt_bakedchar *chardata); // you allocate this, it's num_chars long
|
||||
// if return is positive, the first unused row of the bitmap
|
||||
// if return is negative, returns the negative of the number of characters that fit
|
||||
// if return is 0, no characters fit and no rows were used
|
||||
// This uses a very crappy packing.
|
||||
|
||||
typedef struct
|
||||
{
|
||||
float x0,y0,s0,t0; // top-left
|
||||
float x1,y1,s1,t1; // bottom-right
|
||||
} stbtt_aligned_quad;
|
||||
|
||||
STBTT_DEF void stbtt_GetBakedQuad(const stbtt_bakedchar *chardata, int pw, int ph, // same data as above
|
||||
int char_index, // character to display
|
||||
float *xpos, float *ypos, // pointers to current position in screen pixel space
|
||||
stbtt_aligned_quad *q, // output: quad to draw
|
||||
int opengl_fillrule); // true if opengl fill rule; false if DX9 or earlier
|
||||
// Call GetBakedQuad with char_index = 'character - first_char', and it
|
||||
// creates the quad you need to draw and advances the current position.
|
||||
//
|
||||
// The coordinate system used assumes y increases downwards.
|
||||
//
|
||||
// Characters will extend both above and below the current position;
|
||||
// see discussion of "BASELINE" above.
|
||||
//
|
||||
// It's inefficient; you might want to c&p it and optimize it.
|
||||
|
||||
STBTT_DEF void stbtt_GetScaledFontVMetrics(const unsigned char *fontdata, int index, float size, float *ascent, float *descent, float *lineGap);
|
||||
// Query the font vertical metrics without having to create a font first.
|
||||
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// NEW TEXTURE BAKING API
|
||||
//
|
||||
// This provides options for packing multiple fonts into one atlas, not
|
||||
// perfectly but better than nothing.
|
||||
|
||||
typedef struct
|
||||
{
|
||||
unsigned short x0,y0,x1,y1; // coordinates of bbox in bitmap
|
||||
float xoff,yoff,xadvance;
|
||||
float xoff2,yoff2;
|
||||
} stbtt_packedchar;
|
||||
|
||||
typedef struct stbtt_pack_context stbtt_pack_context;
|
||||
typedef struct stbtt_fontinfo stbtt_fontinfo;
|
||||
#ifndef STB_RECT_PACK_VERSION
|
||||
typedef struct stbrp_rect stbrp_rect;
|
||||
#endif
|
||||
|
||||
STBTT_DEF int stbtt_PackBegin(stbtt_pack_context *spc, unsigned char *pixels, int width, int height, int stride_in_bytes, int padding, void *alloc_context);
|
||||
// Initializes a packing context stored in the passed-in stbtt_pack_context.
|
||||
// Future calls using this context will pack characters into the bitmap passed
|
||||
// in here: a 1-channel bitmap that is width * height. stride_in_bytes is
|
||||
// the distance from one row to the next (or 0 to mean they are packed tightly
|
||||
// together). "padding" is the amount of padding to leave between each
|
||||
// character (normally you want '1' for bitmaps you'll use as textures with
|
||||
// bilinear filtering).
|
||||
//
|
||||
// Returns 0 on failure, 1 on success.
|
||||
|
||||
STBTT_DEF void stbtt_PackEnd (stbtt_pack_context *spc);
|
||||
// Cleans up the packing context and frees all memory.
|
||||
|
||||
#define STBTT_POINT_SIZE(x) (-(x))
|
||||
|
||||
STBTT_DEF int stbtt_PackFontRange(stbtt_pack_context *spc, const unsigned char *fontdata, int font_index, float font_size,
|
||||
int first_unicode_char_in_range, int num_chars_in_range, stbtt_packedchar *chardata_for_range);
|
||||
// Creates character bitmaps from the font_index'th font found in fontdata (use
|
||||
// font_index=0 if you don't know what that is). It creates num_chars_in_range
|
||||
// bitmaps for characters with unicode values starting at first_unicode_char_in_range
|
||||
// and increasing. Data for how to render them is stored in chardata_for_range;
|
||||
// pass these to stbtt_GetPackedQuad to get back renderable quads.
|
||||
//
|
||||
// font_size is the full height of the character from ascender to descender,
|
||||
// as computed by stbtt_ScaleForPixelHeight. To use a point size as computed
|
||||
// by stbtt_ScaleForMappingEmToPixels, wrap the point size in STBTT_POINT_SIZE()
|
||||
// and pass that result as 'font_size':
|
||||
// ..., 20 , ... // font max minus min y is 20 pixels tall
|
||||
// ..., STBTT_POINT_SIZE(20), ... // 'M' is 20 pixels tall
|
||||
|
||||
typedef struct
|
||||
{
|
||||
float font_size;
|
||||
int first_unicode_codepoint_in_range; // if non-zero, then the chars are continuous, and this is the first codepoint
|
||||
int *array_of_unicode_codepoints; // if non-zero, then this is an array of unicode codepoints
|
||||
int num_chars;
|
||||
stbtt_packedchar *chardata_for_range; // output
|
||||
unsigned char h_oversample, v_oversample; // don't set these, they're used internally
|
||||
} stbtt_pack_range;
|
||||
|
||||
STBTT_DEF int stbtt_PackFontRanges(stbtt_pack_context *spc, const unsigned char *fontdata, int font_index, stbtt_pack_range *ranges, int num_ranges);
|
||||
// Creates character bitmaps from multiple ranges of characters stored in
|
||||
// ranges. This will usually create a better-packed bitmap than multiple
|
||||
// calls to stbtt_PackFontRange. Note that you can call this multiple
|
||||
// times within a single PackBegin/PackEnd.
|
||||
|
||||
STBTT_DEF void stbtt_PackSetOversampling(stbtt_pack_context *spc, unsigned int h_oversample, unsigned int v_oversample);
|
||||
// Oversampling a font increases the quality by allowing higher-quality subpixel
|
||||
// positioning, and is especially valuable at smaller text sizes.
|
||||
//
|
||||
// This function sets the amount of oversampling for all following calls to
|
||||
// stbtt_PackFontRange(s) or stbtt_PackFontRangesGatherRects for a given
|
||||
// pack context. The default (no oversampling) is achieved by h_oversample=1
|
||||
// and v_oversample=1. The total number of pixels required is
|
||||
// h_oversample*v_oversample larger than the default; for example, 2x2
|
||||
// oversampling requires 4x the storage of 1x1. For best results, render
|
||||
// oversampled textures with bilinear filtering. Look at the readme in
|
||||
// stb/tests/oversample for information about oversampled fonts
|
||||
//
|
||||
// To use with PackFontRangesGather etc., you must set it before calls
|
||||
// call to PackFontRangesGatherRects.
|
||||
|
||||
STBTT_DEF void stbtt_PackSetSkipMissingCodepoints(stbtt_pack_context *spc, int skip);
|
||||
// If skip != 0, this tells stb_truetype to skip any codepoints for which
|
||||
// there is no corresponding glyph. If skip=0, which is the default, then
|
||||
// codepoints without a glyph recived the font's "missing character" glyph,
|
||||
// typically an empty box by convention.
|
||||
|
||||
STBTT_DEF void stbtt_GetPackedQuad(const stbtt_packedchar *chardata, int pw, int ph, // same data as above
|
||||
int char_index, // character to display
|
||||
float *xpos, float *ypos, // pointers to current position in screen pixel space
|
||||
stbtt_aligned_quad *q, // output: quad to draw
|
||||
int align_to_integer);
|
||||
|
||||
STBTT_DEF int stbtt_PackFontRangesGatherRects(stbtt_pack_context *spc, const stbtt_fontinfo *info, stbtt_pack_range *ranges, int num_ranges, stbrp_rect *rects);
|
||||
STBTT_DEF void stbtt_PackFontRangesPackRects(stbtt_pack_context *spc, stbrp_rect *rects, int num_rects);
|
||||
STBTT_DEF int stbtt_PackFontRangesRenderIntoRects(stbtt_pack_context *spc, const stbtt_fontinfo *info, stbtt_pack_range *ranges, int num_ranges, stbrp_rect *rects);
|
||||
// Calling these functions in sequence is roughly equivalent to calling
|
||||
// stbtt_PackFontRanges(). If you more control over the packing of multiple
|
||||
// fonts, or if you want to pack custom data into a font texture, take a look
|
||||
// at the source to of stbtt_PackFontRanges() and create a custom version
|
||||
// using these functions, e.g. call GatherRects multiple times,
|
||||
// building up a single array of rects, then call PackRects once,
|
||||
// then call RenderIntoRects repeatedly. This may result in a
|
||||
// better packing than calling PackFontRanges multiple times
|
||||
// (or it may not).
|
||||
|
||||
// this is an opaque structure that you shouldn't mess with which holds
|
||||
// all the context needed from PackBegin to PackEnd.
|
||||
struct stbtt_pack_context {
|
||||
void *user_allocator_context;
|
||||
void *pack_info;
|
||||
int width;
|
||||
int height;
|
||||
int stride_in_bytes;
|
||||
int padding;
|
||||
int skip_missing;
|
||||
unsigned int h_oversample, v_oversample;
|
||||
unsigned char *pixels;
|
||||
void *nodes;
|
||||
};
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// FONT LOADING
|
||||
//
|
||||
//
|
||||
|
||||
STBTT_DEF int stbtt_GetNumberOfFonts(const unsigned char *data);
|
||||
// This function will determine the number of fonts in a font file. TrueType
|
||||
// collection (.ttc) files may contain multiple fonts, while TrueType font
|
||||
// (.ttf) files only contain one font. The number of fonts can be used for
|
||||
// indexing with the previous function where the index is between zero and one
|
||||
// less than the total fonts. If an error occurs, -1 is returned.
|
||||
|
||||
STBTT_DEF int stbtt_GetFontOffsetForIndex(const unsigned char *data, int index);
|
||||
// Each .ttf/.ttc file may have more than one font. Each font has a sequential
|
||||
// index number starting from 0. Call this function to get the font offset for
|
||||
// a given index; it returns -1 if the index is out of range. A regular .ttf
|
||||
// file will only define one font and it always be at offset 0, so it will
|
||||
// return '0' for index 0, and -1 for all other indices.
|
||||
|
||||
#ifndef STBTT_MAX_AXES
|
||||
#define STBTT_MAX_AXES 16
|
||||
#endif
|
||||
|
||||
typedef struct stbtt_axisinfo
|
||||
{
|
||||
int tag;
|
||||
int minval, defval, maxval;
|
||||
int currval;
|
||||
} stbtt_axisinfo;
|
||||
|
||||
// The following structure is defined publicly so you can declare one on
|
||||
// the stack or as a global or etc, but you should treat it as opaque.
|
||||
struct stbtt_fontinfo
|
||||
{
|
||||
void * userdata;
|
||||
unsigned char * data; // pointer to .ttf file
|
||||
unsigned char * dataend; // data + size
|
||||
int fontstart; // offset of start of font
|
||||
unsigned size; // the data buffer size
|
||||
|
||||
int numGlyphs; // number of glyphs, needed for range checking
|
||||
|
||||
int loca,head,glyf,hhea,hmtx,kern,gpos,svg,avar,fvar,gvar,hvar; // table locations as offset from start of .ttf
|
||||
int index_map; // a cmap mapping for our chosen character encoding
|
||||
int indexToLocFormat; // format needed to map from glyph index to glyph
|
||||
int axis_count; // the number of variable font axes
|
||||
stbtt_axisinfo axes[STBTT_MAX_AXES]; // information about each axis
|
||||
short axes_normvalues[STBTT_MAX_AXES]; // normalized (within [-1, 1]) coordinates of
|
||||
// the currently used variation. They are already transformed
|
||||
// using avar (if any)
|
||||
int gvar_shared_count; // the number of shared tuples, used by 'gvar'
|
||||
int gvar_shared_tuples; // offset of the shared tuples
|
||||
int gvar_glob_offset; // the global offset of glyph variations table
|
||||
int gvar_glyph_offsets; // the relative offsets of glyph variations
|
||||
int gvar_off_format; // true if offsets are 32-bit
|
||||
|
||||
stbtt__buf cff; // cff font data
|
||||
stbtt__buf charstrings; // the charstring index
|
||||
stbtt__buf gsubrs; // global charstring subroutines index
|
||||
stbtt__buf subrs; // private charstring subroutines index
|
||||
stbtt__buf fontdicts; // array of font dicts
|
||||
stbtt__buf fdselect; // map from glyph to fontdict
|
||||
};
|
||||
|
||||
|
||||
STBTT_DEF int stbtt_InitFont(stbtt_fontinfo *info, const unsigned char *data, int offset);
|
||||
// Given an offset into the file that defines a font, this function builds
|
||||
// the necessary cached info for the rest of the system. You must allocate
|
||||
// the stbtt_fontinfo yourself, and stbtt_InitFont will fill it out. You don't
|
||||
// need to do anything special to free it, because the contents are pure
|
||||
// value data with no additional data structures. Returns 0 on failure.
|
||||
|
||||
STBTT_DEF int stbtt_InitFont2(stbtt_fontinfo *info, const unsigned char *data, unsigned size, int offset);
|
||||
// Same as stbtt_InitFont, but also takes the size of "data" buffer,
|
||||
// in order to control and avoid out of range accesses.
|
||||
|
||||
STBTT_DEF stbtt_fontinfo* stbtt_CreateFont(const unsigned char *data, unsigned size, int offset);
|
||||
// Allocates font structure and initializes it. Returns 0 if there was an error.
|
||||
|
||||
STBTT_DEF void stbtt_ReleaseFont(stbtt_fontinfo **info);
|
||||
// Allocates font structure and initializes it. Returns 0 if there was an error.
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// CHARACTER TO GLYPH-INDEX CONVERSIOn
|
||||
|
||||
STBTT_DEF int stbtt_FindGlyphIndex(const stbtt_fontinfo *info, int unicode_codepoint);
|
||||
// If you're going to perform multiple operations on the same character
|
||||
// and you want a speed-up, call this function with the character you're
|
||||
// going to process, then use glyph-based functions instead of the
|
||||
// codepoint-based functions.
|
||||
// Returns 0 if the character codepoint is not defined in the font.
|
||||
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// CHARACTER PROPERTIES
|
||||
//
|
||||
|
||||
STBTT_DEF float stbtt_ScaleForPixelHeight(const stbtt_fontinfo *info, float pixels);
|
||||
// computes a scale factor to produce a font whose "height" is 'pixels' tall.
|
||||
// Height is measured as the distance from the highest ascender to the lowest
|
||||
// descender; in other words, it's equivalent to calling stbtt_GetFontVMetrics
|
||||
// and computing:
|
||||
// scale = pixels / (ascent - descent)
|
||||
// so if you prefer to measure height by the ascent only, use a similar calculation.
|
||||
|
||||
STBTT_DEF float stbtt_ScaleForPixelHeightNoDesc(const stbtt_fontinfo *info, float height);
|
||||
|
||||
STBTT_DEF float stbtt_ScaleForMappingEmToPixels(const stbtt_fontinfo *info, float pixels);
|
||||
// computes a scale factor to produce a font whose EM size is mapped to
|
||||
// 'pixels' tall. This is probably what traditional APIs compute, but
|
||||
// I'm not positive.
|
||||
|
||||
STBTT_DEF void stbtt_GetFontVMetrics(const stbtt_fontinfo *info, int *ascent, int *descent, int *lineGap);
|
||||
// ascent is the coordinate above the baseline the font extends; descent
|
||||
// is the coordinate below the baseline the font extends (i.e. it is typically negative)
|
||||
// lineGap is the spacing between one row's descent and the next row's ascent...
|
||||
// so you should advance the vertical position by "*ascent - *descent + *lineGap"
|
||||
// these are expressed in unscaled coordinates, so you must multiply by
|
||||
// the scale factor for a given size
|
||||
|
||||
STBTT_DEF int stbtt_GetFontVMetricsOS2(const stbtt_fontinfo *info, int *typoAscent, int *typoDescent, int *typoLineGap);
|
||||
// analogous to GetFontVMetrics, but returns the "typographic" values from the OS/2
|
||||
// table (specific to MS/Windows TTF files).
|
||||
//
|
||||
// Returns 1 on success (table present), 0 on failure.
|
||||
|
||||
STBTT_DEF void stbtt_GetFontBoundingBox(const stbtt_fontinfo *info, int *x0, int *y0, int *x1, int *y1);
|
||||
// the bounding box around all possible characters
|
||||
|
||||
STBTT_DEF void stbtt_GetCodepointHMetrics(const stbtt_fontinfo *info, int codepoint, int *advanceWidth, int *leftSideBearing);
|
||||
// leftSideBearing is the offset from the current horizontal position to the left edge of the character
|
||||
// advanceWidth is the offset from the current horizontal position to the next horizontal position
|
||||
// these are expressed in unscaled coordinates
|
||||
|
||||
STBTT_DEF int stbtt_GetCodepointKernAdvance(const stbtt_fontinfo *info, int ch1, int ch2);
|
||||
// an additional amount to add to the 'advance' value between ch1 and ch2
|
||||
|
||||
STBTT_DEF int stbtt_GetCodepointBox(const stbtt_fontinfo *info, int codepoint, int *x0, int *y0, int *x1, int *y1);
|
||||
// Gets the bounding box of the visible part of the glyph, in unscaled coordinates
|
||||
|
||||
STBTT_DEF void stbtt_GetGlyphHMetrics(const stbtt_fontinfo *info, int glyph_index, int *advanceWidth, int *leftSideBearing);
|
||||
STBTT_DEF int stbtt_GetGlyphKernAdvance(const stbtt_fontinfo *info, int glyph1, int glyph2);
|
||||
STBTT_DEF int stbtt_GetGlyphBox(const stbtt_fontinfo *info, int glyph_index, int *x0, int *y0, int *x1, int *y1);
|
||||
STBTT_DEF void stbtt__ScaleGlyphBox(int ix0, int iy0, int ix1, int iy1,
|
||||
float scale_x, float scale_y, float shift_x, float shift_y,
|
||||
int *out_ix0, int *out_iy0, int *out_ix1, int *out_iy1);
|
||||
// as above, but takes one or more glyph indices for greater efficiency
|
||||
|
||||
typedef struct stbtt_kerningentry
|
||||
{
|
||||
int glyph1; // use stbtt_FindGlyphIndex
|
||||
int glyph2;
|
||||
int advance;
|
||||
} stbtt_kerningentry;
|
||||
|
||||
STBTT_DEF int stbtt_GetKerningTableLength(const stbtt_fontinfo *info);
|
||||
STBTT_DEF int stbtt_GetKerningTable(const stbtt_fontinfo *info, stbtt_kerningentry* table, int table_length);
|
||||
// Retrieves a complete list of all of the kerning pairs provided by the font
|
||||
// stbtt_GetKerningTable never writes more than table_length entries and returns how many entries it did write.
|
||||
// The table will be sorted by (a.glyph1 == b.glyph1)?(a.glyph2 < b.glyph2):(a.glyph1 < b.glyph1)
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// GLYPH SHAPES (you probably don't need these, but they have to go before
|
||||
// the bitmaps for C declaration-order reasons)
|
||||
//
|
||||
|
||||
#ifndef STBTT_vmove // you can predefine these to use different values (but why?)
|
||||
enum {
|
||||
STBTT_vmove=1,
|
||||
STBTT_vline,
|
||||
STBTT_vcurve,
|
||||
STBTT_vcubic
|
||||
};
|
||||
#endif
|
||||
|
||||
#ifndef stbtt_vertex // you can predefine this to use different values
|
||||
// (we share this with other code at RAD)
|
||||
#define stbtt_vertex_type short // can't use stbtt_int16 because that's not visible in the header file
|
||||
typedef struct
|
||||
{
|
||||
stbtt_vertex_type x,y,cx,cy,cx1,cy1;
|
||||
unsigned char type,padding;
|
||||
} stbtt_vertex;
|
||||
#endif
|
||||
|
||||
STBTT_DEF int stbtt_IsGlyphEmpty(const stbtt_fontinfo *info, int glyph_index);
|
||||
// returns non-zero if nothing is drawn for this glyph
|
||||
|
||||
STBTT_DEF int stbtt_GetCodepointShape(const stbtt_fontinfo *info, int unicode_codepoint,
|
||||
stbtt_vertex **vertices, int* ix0, int* iy0, int* ix1, int* iy1);
|
||||
STBTT_DEF int stbtt_GetGlyphShape(const stbtt_fontinfo *info, int glyph_index, stbtt_vertex **vertices,
|
||||
int* ix0, int* iy0, int* ix1, int* iy1);
|
||||
// returns # of vertices and fills *vertices with the pointer to them
|
||||
// these are expressed in "unscaled" coordinates
|
||||
//
|
||||
// The shape is a series of contours. Each one starts with
|
||||
// a STBTT_moveto, then consists of a series of mixed
|
||||
// STBTT_lineto and STBTT_curveto segments. A lineto
|
||||
// draws a line from previous endpoint to its x,y; a curveto
|
||||
// draws a quadratic bezier from previous endpoint to
|
||||
// its x,y, using cx,cy as the bezier control point.
|
||||
|
||||
STBTT_DEF void stbtt_FreeShape(const stbtt_fontinfo *info, stbtt_vertex *vertices);
|
||||
// frees the data allocated above
|
||||
|
||||
STBTT_DEF int stbtt_GetCodepointSVG(const stbtt_fontinfo *info, int unicode_codepoint, const char **svg);
|
||||
STBTT_DEF int stbtt_GetGlyphSVG(const stbtt_fontinfo *info, int gl, const char **svg);
|
||||
// fills svg with the character's SVG data.
|
||||
// returns data size or 0 if SVG not found.
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// FONT VARIATIONS
|
||||
//
|
||||
STBTT_DEF int stbtt_GetWeight(const stbtt_fontinfo* info);
|
||||
STBTT_DEF int stbtt_GetInstance(const stbtt_fontinfo* info, stbtt_axisinfo* axes, int max_count);
|
||||
STBTT_DEF int stbtt_SetInstance(stbtt_fontinfo* info, const int* params, int count, int reset_to_defaults);
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// BITMAP RENDERING
|
||||
//
|
||||
|
||||
STBTT_DEF void stbtt_FreeBitmap(unsigned char *bitmap, void *userdata);
|
||||
// frees the bitmap allocated below
|
||||
|
||||
STBTT_DEF void stbtt_GetCodepointBitmapBox(const stbtt_fontinfo *font, int codepoint, float scale_x, float scale_y, int *ix0, int *iy0, int *ix1, int *iy1);
|
||||
// get the bbox of the bitmap centered around the glyph origin; so the
|
||||
// bitmap width is ix1-ix0, height is iy1-iy0, and location to place
|
||||
// the bitmap top left is (leftSideBearing*scale,iy0).
|
||||
// (Note that the bitmap uses y-increases-down, but the shape uses
|
||||
// y-increases-up, so CodepointBitmapBox and CodepointBox are inverted.)
|
||||
|
||||
STBTT_DEF void stbtt_GetCodepointBitmapBoxSubpixel(const stbtt_fontinfo *font, int codepoint, float scale_x, float scale_y, float shift_x, float shift_y, int *ix0, int *iy0, int *ix1, int *iy1);
|
||||
// same as stbtt_GetCodepointBitmapBox, but you can specify a subpixel
|
||||
// shift for the character
|
||||
|
||||
// the following functions are equivalent to the above functions, but operate
|
||||
// on glyph indices instead of Unicode codepoints (for efficiency)
|
||||
STBTT_DEF unsigned char *stbtt_GetGlyphBitmapSubpixelRealloc(const stbtt_fontinfo *info, float scale_x, float scale_y,
|
||||
float shift_x, float shift_y,
|
||||
int glyph, int *width, int *height, int* step,
|
||||
int *xoff, int *yoff, float* advx,
|
||||
unsigned char** buf, int* bufsize);
|
||||
STBTT_DEF void stbtt_MakeGlyphBitmap(const stbtt_fontinfo *info, unsigned char *output, int out_w, int out_h, int out_stride, float scale_x, float scale_y, int glyph);
|
||||
STBTT_DEF void stbtt_MakeGlyphBitmapSubpixel(const stbtt_fontinfo *info, unsigned char *output, int out_w, int out_h, int out_stride, float scale_x, float scale_y, float shift_x, float shift_y, int glyph);
|
||||
STBTT_DEF void stbtt_MakeGlyphBitmapSubpixelPrefilter(const stbtt_fontinfo *info, unsigned char *output, int out_w, int out_h, int out_stride, float scale_x, float scale_y, float shift_x, float shift_y, int oversample_x, int oversample_y, float *sub_x, float *sub_y, int glyph);
|
||||
STBTT_DEF void stbtt_GetGlyphBitmapBox(const stbtt_fontinfo *font, int glyph, float scale_x, float scale_y, int *ix0, int *iy0, int *ix1, int *iy1);
|
||||
STBTT_DEF void stbtt_GetGlyphBitmapBoxSubpixel(const stbtt_fontinfo *font, int glyph, float scale_x, float scale_y,float shift_x, float shift_y, int *ix0, int *iy0, int *ix1, int *iy1);
|
||||
|
||||
|
||||
// @TODO: don't expose this structure
|
||||
typedef struct
|
||||
{
|
||||
int w,h,stride;
|
||||
unsigned char *pixels;
|
||||
} stbtt__bitmap;
|
||||
|
||||
// rasterize a shape with quadratic beziers into a bitmap
|
||||
STBTT_DEF void stbtt_Rasterize(stbtt__bitmap *result, // 1-channel bitmap to draw into
|
||||
float flatness_in_pixels, // allowable error of curve in pixels
|
||||
stbtt_vertex *vertices, // array of vertices defining shape
|
||||
int num_verts, // number of vertices in above array
|
||||
float scale_x, float scale_y, // scale applied to input vertices
|
||||
float shift_x, float shift_y, // translation applied to input vertices
|
||||
int x_off, int y_off, // another translation applied to input
|
||||
int invert, // if non-zero, vertically flip shape
|
||||
void *userdata); // context for to STBTT_MALLOC
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// Signed Distance Function (or Field) rendering
|
||||
|
||||
STBTT_DEF void stbtt_FreeSDF(unsigned char *bitmap, void *userdata);
|
||||
// frees the SDF bitmap allocated below
|
||||
|
||||
STBTT_DEF unsigned char * stbtt_GetGlyphSDF(const stbtt_fontinfo *info, float scale, int glyph, int padding, unsigned char onedge_value, float pixel_dist_scale, int *width, int *height, int *xoff, int *yoff);
|
||||
STBTT_DEF unsigned char * stbtt_GetCodepointSDF(const stbtt_fontinfo *info, float scale, int codepoint, int padding, unsigned char onedge_value, float pixel_dist_scale, int *width, int *height, int *xoff, int *yoff);
|
||||
// These functions compute a discretized SDF field for a single character, suitable for storing
|
||||
// in a single-channel texture, sampling with bilinear filtering, and testing against
|
||||
// larger than some threshold to produce scalable fonts.
|
||||
// info -- the font
|
||||
// scale -- controls the size of the resulting SDF bitmap, same as it would be creating a regular bitmap
|
||||
// glyph/codepoint -- the character to generate the SDF for
|
||||
// padding -- extra "pixels" around the character which are filled with the distance to the character (not 0),
|
||||
// which allows effects like bit outlines
|
||||
// onedge_value -- value 0-255 to test the SDF against to reconstruct the character (i.e. the isocontour of the character)
|
||||
// pixel_dist_scale -- what value the SDF should increase by when moving one SDF "pixel" away from the edge (on the 0..255 scale)
|
||||
// if positive, > onedge_value is inside; if negative, < onedge_value is inside
|
||||
// width,height -- output height & width of the SDF bitmap (including padding)
|
||||
// xoff,yoff -- output origin of the character
|
||||
// return value -- a 2D array of bytes 0..255, width*height in size
|
||||
//
|
||||
// pixel_dist_scale & onedge_value are a scale & bias that allows you to make
|
||||
// optimal use of the limited 0..255 for your application, trading off precision
|
||||
// and special effects. SDF values outside the range 0..255 are clamped to 0..255.
|
||||
//
|
||||
// Example:
|
||||
// scale = stbtt_ScaleForPixelHeight(22)
|
||||
// padding = 5
|
||||
// onedge_value = 180
|
||||
// pixel_dist_scale = 180/5.0 = 36.0
|
||||
//
|
||||
// This will create an SDF bitmap in which the character is about 22 pixels
|
||||
// high but the whole bitmap is about 22+5+5=32 pixels high. To produce a filled
|
||||
// shape, sample the SDF at each pixel and fill the pixel if the SDF value
|
||||
// is greater than or equal to 180/255. (You'll actually want to antialias,
|
||||
// which is beyond the scope of this example.) Additionally, you can compute
|
||||
// offset outlines (e.g. to stroke the character border inside & outside,
|
||||
// or only outside). For example, to fill outside the character up to 3 SDF
|
||||
// pixels, you would compare against (180-36.0*3)/255 = 72/255. The above
|
||||
// choice of variables maps a range from 5 pixels outside the shape to
|
||||
// 2 pixels inside the shape to 0..255; this is intended primarily for apply
|
||||
// outside effects only (the interior range is needed to allow proper
|
||||
// antialiasing of the font at *smaller* sizes)
|
||||
//
|
||||
// The function computes the SDF analytically at each SDF pixel, not by e.g.
|
||||
// building a higher-res bitmap and approximating it. In theory the quality
|
||||
// should be as high as possible for an SDF of this size & representation, but
|
||||
// unclear if this is true in practice (perhaps building a higher-res bitmap
|
||||
// and computing from that can allow drop-out prevention).
|
||||
//
|
||||
// The algorithm has not been optimized at all, so expect it to be slow
|
||||
// if computing lots of characters or very large sizes.
|
||||
|
||||
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// Finding the right font...
|
||||
//
|
||||
// You should really just solve this offline, keep your own tables
|
||||
// of what font is what, and don't try to get it out of the .ttf file.
|
||||
// That's because getting it out of the .ttf file is really hard, because
|
||||
// the names in the file can appear in many possible encodings, in many
|
||||
// possible languages, and e.g. if you need a case-insensitive comparison,
|
||||
// the details of that depend on the encoding & language in a complex way
|
||||
// (actually underspecified in truetype, but also gigantic).
|
||||
//
|
||||
// But you can use the provided functions in two possible ways:
|
||||
// stbtt_FindMatchingFont() will use *case-sensitive* comparisons on
|
||||
// unicode-encoded names to try to find the font you want;
|
||||
// you can run this before calling stbtt_InitFont()
|
||||
//
|
||||
// stbtt_GetFontNameString() lets you get any of the various strings
|
||||
// from the file yourself and do your own comparisons on them.
|
||||
// You have to have called stbtt_InitFont() first.
|
||||
|
||||
|
||||
STBTT_DEF int stbtt_FindMatchingFont(const unsigned char *fontdata, const char *name, int flags);
|
||||
// returns the offset (not index) of the font that matches, or -1 if none
|
||||
// if you use STBTT_MACSTYLE_DONTCARE, use a font name like "Arial Bold".
|
||||
// if you use any other flag, use a font name like "Arial"; this checks
|
||||
// the 'macStyle' header field; i don't know if fonts set this consistently
|
||||
#define STBTT_MACSTYLE_DONTCARE 0
|
||||
#define STBTT_MACSTYLE_BOLD 1
|
||||
#define STBTT_MACSTYLE_ITALIC 2
|
||||
#define STBTT_MACSTYLE_UNDERSCORE 4
|
||||
#define STBTT_MACSTYLE_NONE 8 // <= not same as 0, this makes us check the bitfield is 0
|
||||
|
||||
STBTT_DEF int stbtt_CompareUTF8toUTF16_bigendian(const char *s1, int len1, const char *s2, int len2);
|
||||
// returns 1/0 whether the first string interpreted as utf8 is identical to
|
||||
// the second string interpreted as big-endian utf16... useful for strings from next func
|
||||
|
||||
STBTT_DEF const char *stbtt_GetFontNameString(const stbtt_fontinfo *font, int *length, int platformID, int encodingID, int languageID, int nameID);
|
||||
// returns the string (which may be big-endian double byte, e.g. for unicode)
|
||||
// and puts the length in bytes in *length.
|
||||
//
|
||||
// some of the values for the IDs are below; for more see the truetype spec:
|
||||
// http://developer.apple.com/textfonts/TTRefMan/RM06/Chap6name.html
|
||||
// http://www.microsoft.com/typography/otspec/name.htm
|
||||
|
||||
enum { // platformID
|
||||
STBTT_PLATFORM_ID_UNICODE =0,
|
||||
STBTT_PLATFORM_ID_MAC =1,
|
||||
STBTT_PLATFORM_ID_ISO =2,
|
||||
STBTT_PLATFORM_ID_MICROSOFT =3
|
||||
};
|
||||
|
||||
enum { // encodingID for STBTT_PLATFORM_ID_UNICODE
|
||||
STBTT_UNICODE_EID_UNICODE_1_0 =0,
|
||||
STBTT_UNICODE_EID_UNICODE_1_1 =1,
|
||||
STBTT_UNICODE_EID_ISO_10646 =2,
|
||||
STBTT_UNICODE_EID_UNICODE_2_0_BMP=3,
|
||||
STBTT_UNICODE_EID_UNICODE_2_0_FULL=4
|
||||
};
|
||||
|
||||
enum { // encodingID for STBTT_PLATFORM_ID_MICROSOFT
|
||||
STBTT_MS_EID_SYMBOL =0,
|
||||
STBTT_MS_EID_UNICODE_BMP =1,
|
||||
STBTT_MS_EID_SHIFTJIS =2,
|
||||
STBTT_MS_EID_UNICODE_FULL =10
|
||||
};
|
||||
|
||||
enum { // encodingID for STBTT_PLATFORM_ID_MAC; same as Script Manager codes
|
||||
STBTT_MAC_EID_ROMAN =0, STBTT_MAC_EID_ARABIC =4,
|
||||
STBTT_MAC_EID_JAPANESE =1, STBTT_MAC_EID_HEBREW =5,
|
||||
STBTT_MAC_EID_CHINESE_TRAD =2, STBTT_MAC_EID_GREEK =6,
|
||||
STBTT_MAC_EID_KOREAN =3, STBTT_MAC_EID_RUSSIAN =7
|
||||
};
|
||||
|
||||
enum { // languageID for STBTT_PLATFORM_ID_MICROSOFT; same as LCID...
|
||||
// problematic because there are e.g. 16 english LCIDs and 16 arabic LCIDs
|
||||
STBTT_MS_LANG_ENGLISH =0x0409, STBTT_MS_LANG_ITALIAN =0x0410,
|
||||
STBTT_MS_LANG_CHINESE =0x0804, STBTT_MS_LANG_JAPANESE =0x0411,
|
||||
STBTT_MS_LANG_DUTCH =0x0413, STBTT_MS_LANG_KOREAN =0x0412,
|
||||
STBTT_MS_LANG_FRENCH =0x040c, STBTT_MS_LANG_RUSSIAN =0x0419,
|
||||
STBTT_MS_LANG_GERMAN =0x0407, STBTT_MS_LANG_SPANISH =0x0409,
|
||||
STBTT_MS_LANG_HEBREW =0x040d, STBTT_MS_LANG_SWEDISH =0x041D
|
||||
};
|
||||
|
||||
enum { // languageID for STBTT_PLATFORM_ID_MAC
|
||||
STBTT_MAC_LANG_ENGLISH =0 , STBTT_MAC_LANG_JAPANESE =11,
|
||||
STBTT_MAC_LANG_ARABIC =12, STBTT_MAC_LANG_KOREAN =23,
|
||||
STBTT_MAC_LANG_DUTCH =4 , STBTT_MAC_LANG_RUSSIAN =32,
|
||||
STBTT_MAC_LANG_FRENCH =1 , STBTT_MAC_LANG_SPANISH =6 ,
|
||||
STBTT_MAC_LANG_GERMAN =2 , STBTT_MAC_LANG_SWEDISH =5 ,
|
||||
STBTT_MAC_LANG_HEBREW =10, STBTT_MAC_LANG_CHINESE_SIMPLIFIED =33,
|
||||
STBTT_MAC_LANG_ITALIAN =3 , STBTT_MAC_LANG_CHINESE_TRAD =19
|
||||
};
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif // __STB_INCLUDE_STB_TRUETYPE_H__
|
||||
Reference in New Issue
Block a user