4c3f7d1290
Adds multi-channel SDF font texture generation and rendering support. Adds per-font oversampling support. Adds FontData import plugins (for dynamic fonts, BMFonts and monospaced image fonts), font texture cache pre-generation and loading. Adds BMFont binary format and outline support.
496 lines
25 KiB
C++
496 lines
25 KiB
C++
|
|
#include "MSDFErrorCorrection.h"
|
|
|
|
#include <cstring>
|
|
#include "arithmetics.hpp"
|
|
#include "equation-solver.h"
|
|
#include "EdgeColor.h"
|
|
#include "bitmap-interpolation.hpp"
|
|
#include "edge-selectors.h"
|
|
#include "contour-combiners.h"
|
|
#include "ShapeDistanceFinder.h"
|
|
#include "generator-config.h"
|
|
|
|
namespace msdfgen {
|
|
|
|
#define ARTIFACT_T_EPSILON .01
|
|
#define PROTECTION_RADIUS_TOLERANCE 1.001
|
|
|
|
#define CLASSIFIER_FLAG_CANDIDATE 0x01
|
|
#define CLASSIFIER_FLAG_ARTIFACT 0x02
|
|
|
|
const double ErrorCorrectionConfig::defaultMinDeviationRatio = 1.11111111111111111;
|
|
const double ErrorCorrectionConfig::defaultMinImproveRatio = 1.11111111111111111;
|
|
|
|
/// The base artifact classifier recognizes artifacts based on the contents of the SDF alone.
|
|
class BaseArtifactClassifier {
|
|
public:
|
|
inline BaseArtifactClassifier(double span, bool protectedFlag) : span(span), protectedFlag(protectedFlag) { }
|
|
/// Evaluates if the median value xm interpolated at xt in the range between am at at and bm at bt indicates an artifact.
|
|
inline int rangeTest(double at, double bt, double xt, float am, float bm, float xm) const {
|
|
// For protected texels, only consider inversion artifacts (interpolated median has different sign than boundaries). For the rest, it is sufficient that the interpolated median is outside its boundaries.
|
|
if ((am > .5f && bm > .5f && xm <= .5f) || (am < .5f && bm < .5f && xm >= .5f) || (!protectedFlag && median(am, bm, xm) != xm)) {
|
|
double axSpan = (xt-at)*span, bxSpan = (bt-xt)*span;
|
|
// Check if the interpolated median's value is in the expected range based on its distance (span) from boundaries a, b.
|
|
if (!(xm >= am-axSpan && xm <= am+axSpan && xm >= bm-bxSpan && xm <= bm+bxSpan))
|
|
return CLASSIFIER_FLAG_CANDIDATE|CLASSIFIER_FLAG_ARTIFACT;
|
|
return CLASSIFIER_FLAG_CANDIDATE;
|
|
}
|
|
return 0;
|
|
}
|
|
/// Returns true if the combined results of the tests performed on the median value m interpolated at t indicate an artifact.
|
|
inline bool evaluate(double t, float m, int flags) const {
|
|
return (flags&2) != 0;
|
|
}
|
|
private:
|
|
double span;
|
|
bool protectedFlag;
|
|
};
|
|
|
|
/// The shape distance checker evaluates the exact shape distance to find additional artifacts at a significant performance cost.
|
|
template <template <typename> class ContourCombiner, int N>
|
|
class ShapeDistanceChecker {
|
|
public:
|
|
class ArtifactClassifier : public BaseArtifactClassifier {
|
|
public:
|
|
inline ArtifactClassifier(ShapeDistanceChecker *parent, const Vector2 &direction, double span) : BaseArtifactClassifier(span, parent->protectedFlag), parent(parent), direction(direction) { }
|
|
/// Returns true if the combined results of the tests performed on the median value m interpolated at t indicate an artifact.
|
|
inline bool evaluate(double t, float m, int flags) const {
|
|
if (flags&CLASSIFIER_FLAG_CANDIDATE) {
|
|
// Skip expensive distance evaluation if the point has already been classified as an artifact by the base classifier.
|
|
if (flags&CLASSIFIER_FLAG_ARTIFACT)
|
|
return true;
|
|
Vector2 tVector = t*direction;
|
|
float oldMSD[N], newMSD[3];
|
|
// Compute the color that would be currently interpolated at the artifact candidate's position.
|
|
Point2 sdfCoord = parent->sdfCoord+tVector;
|
|
interpolate(oldMSD, parent->sdf, sdfCoord);
|
|
// Compute the color that would be interpolated at the artifact candidate's position if error correction was applied on the current texel.
|
|
double aWeight = (1-fabs(tVector.x))*(1-fabs(tVector.y));
|
|
float aPSD = median(parent->msd[0], parent->msd[1], parent->msd[2]);
|
|
newMSD[0] = float(oldMSD[0]+aWeight*(aPSD-parent->msd[0]));
|
|
newMSD[1] = float(oldMSD[1]+aWeight*(aPSD-parent->msd[1]));
|
|
newMSD[2] = float(oldMSD[2]+aWeight*(aPSD-parent->msd[2]));
|
|
// Compute the evaluated distance (interpolated median) before and after error correction, as well as the exact shape distance.
|
|
float oldPSD = median(oldMSD[0], oldMSD[1], oldMSD[2]);
|
|
float newPSD = median(newMSD[0], newMSD[1], newMSD[2]);
|
|
float refPSD = float(parent->invRange*parent->distanceFinder.distance(parent->shapeCoord+tVector*parent->texelSize)+.5);
|
|
// Compare the differences of the exact distance and the before and after distances.
|
|
return parent->minImproveRatio*fabsf(newPSD-refPSD) < double(fabsf(oldPSD-refPSD));
|
|
}
|
|
return false;
|
|
}
|
|
private:
|
|
ShapeDistanceChecker *parent;
|
|
Vector2 direction;
|
|
};
|
|
Point2 shapeCoord, sdfCoord;
|
|
const float *msd;
|
|
bool protectedFlag;
|
|
inline ShapeDistanceChecker(const BitmapConstRef<float, N> &sdf, const Shape &shape, const Projection &projection, double invRange, double minImproveRatio) : distanceFinder(shape), sdf(sdf), invRange(invRange), minImproveRatio(minImproveRatio) {
|
|
texelSize = projection.unprojectVector(Vector2(1));
|
|
}
|
|
inline ArtifactClassifier classifier(const Vector2 &direction, double span) {
|
|
return ArtifactClassifier(this, direction, span);
|
|
}
|
|
private:
|
|
ShapeDistanceFinder<ContourCombiner<PseudoDistanceSelector> > distanceFinder;
|
|
BitmapConstRef<float, N> sdf;
|
|
double invRange;
|
|
Vector2 texelSize;
|
|
double minImproveRatio;
|
|
};
|
|
|
|
MSDFErrorCorrection::MSDFErrorCorrection() { }
|
|
|
|
MSDFErrorCorrection::MSDFErrorCorrection(const BitmapRef<byte, 1> &stencil, const Projection &projection, double range) : stencil(stencil), projection(projection) {
|
|
invRange = 1/range;
|
|
minDeviationRatio = ErrorCorrectionConfig::defaultMinDeviationRatio;
|
|
minImproveRatio = ErrorCorrectionConfig::defaultMinImproveRatio;
|
|
memset(stencil.pixels, 0, sizeof(byte)*stencil.width*stencil.height);
|
|
}
|
|
|
|
void MSDFErrorCorrection::setMinDeviationRatio(double minDeviationRatio) {
|
|
this->minDeviationRatio = minDeviationRatio;
|
|
}
|
|
|
|
void MSDFErrorCorrection::setMinImproveRatio(double minImproveRatio) {
|
|
this->minImproveRatio = minImproveRatio;
|
|
}
|
|
|
|
void MSDFErrorCorrection::protectCorners(const Shape &shape) {
|
|
for (std::vector<Contour>::const_iterator contour = shape.contours.begin(); contour != shape.contours.end(); ++contour)
|
|
if (!contour->edges.empty()) {
|
|
const EdgeSegment *prevEdge = contour->edges.back();
|
|
for (std::vector<EdgeHolder>::const_iterator edge = contour->edges.begin(); edge != contour->edges.end(); ++edge) {
|
|
int commonColor = prevEdge->color&(*edge)->color;
|
|
// If the color changes from prevEdge to edge, this is a corner.
|
|
if (!(commonColor&(commonColor-1))) {
|
|
// Find the four texels that envelop the corner and mark them as protected.
|
|
Point2 p = projection.project((*edge)->point(0));
|
|
if (shape.inverseYAxis)
|
|
p.y = stencil.height-p.y;
|
|
int l = (int) floor(p.x-.5);
|
|
int b = (int) floor(p.y-.5);
|
|
int r = l+1;
|
|
int t = b+1;
|
|
// Check that the positions are within bounds.
|
|
if (l < stencil.width && b < stencil.height && r >= 0 && t >= 0) {
|
|
if (l >= 0 && b >= 0)
|
|
*stencil(l, b) |= (byte) PROTECTED;
|
|
if (r < stencil.width && b >= 0)
|
|
*stencil(r, b) |= (byte) PROTECTED;
|
|
if (l >= 0 && t < stencil.height)
|
|
*stencil(l, t) |= (byte) PROTECTED;
|
|
if (r < stencil.width && t < stencil.height)
|
|
*stencil(r, t) |= (byte) PROTECTED;
|
|
}
|
|
}
|
|
prevEdge = *edge;
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Determines if the channel contributes to an edge between the two texels a, b.
|
|
static bool edgeBetweenTexelsChannel(const float *a, const float *b, int channel) {
|
|
// Find interpolation ratio t (0 < t < 1) where an edge is expected (mix(a[channel], b[channel], t) == 0.5).
|
|
double t = (a[channel]-.5)/(a[channel]-b[channel]);
|
|
if (t > 0 && t < 1) {
|
|
// Interpolate channel values at t.
|
|
float c[3] = {
|
|
mix(a[0], b[0], t),
|
|
mix(a[1], b[1], t),
|
|
mix(a[2], b[2], t)
|
|
};
|
|
// This is only an edge if the zero-distance channel is the median.
|
|
return median(c[0], c[1], c[2]) == c[channel];
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/// Returns a bit mask of which channels contribute to an edge between the two texels a, b.
|
|
static int edgeBetweenTexels(const float *a, const float *b) {
|
|
return (
|
|
RED*edgeBetweenTexelsChannel(a, b, 0)+
|
|
GREEN*edgeBetweenTexelsChannel(a, b, 1)+
|
|
BLUE*edgeBetweenTexelsChannel(a, b, 2)
|
|
);
|
|
}
|
|
|
|
/// Marks texel as protected if one of its non-median channels is present in the channel mask.
|
|
static void protectExtremeChannels(byte *stencil, const float *msd, float m, int mask) {
|
|
if (
|
|
(mask&RED && msd[0] != m) ||
|
|
(mask&GREEN && msd[1] != m) ||
|
|
(mask&BLUE && msd[2] != m)
|
|
)
|
|
*stencil |= (byte) MSDFErrorCorrection::PROTECTED;
|
|
}
|
|
|
|
template <int N>
|
|
void MSDFErrorCorrection::protectEdges(const BitmapConstRef<float, N> &sdf) {
|
|
float radius;
|
|
// Horizontal texel pairs
|
|
radius = float(PROTECTION_RADIUS_TOLERANCE*projection.unprojectVector(Vector2(invRange, 0)).length());
|
|
for (int y = 0; y < sdf.height; ++y) {
|
|
const float *left = sdf(0, y);
|
|
const float *right = sdf(1, y);
|
|
for (int x = 0; x < sdf.width-1; ++x) {
|
|
float lm = median(left[0], left[1], left[2]);
|
|
float rm = median(right[0], right[1], right[2]);
|
|
if (fabsf(lm-.5f)+fabsf(rm-.5f) < radius) {
|
|
int mask = edgeBetweenTexels(left, right);
|
|
protectExtremeChannels(stencil(x, y), left, lm, mask);
|
|
protectExtremeChannels(stencil(x+1, y), right, rm, mask);
|
|
}
|
|
left += N, right += N;
|
|
}
|
|
}
|
|
// Vertical texel pairs
|
|
radius = float(PROTECTION_RADIUS_TOLERANCE*projection.unprojectVector(Vector2(0, invRange)).length());
|
|
for (int y = 0; y < sdf.height-1; ++y) {
|
|
const float *bottom = sdf(0, y);
|
|
const float *top = sdf(0, y+1);
|
|
for (int x = 0; x < sdf.width; ++x) {
|
|
float bm = median(bottom[0], bottom[1], bottom[2]);
|
|
float tm = median(top[0], top[1], top[2]);
|
|
if (fabsf(bm-.5f)+fabsf(tm-.5f) < radius) {
|
|
int mask = edgeBetweenTexels(bottom, top);
|
|
protectExtremeChannels(stencil(x, y), bottom, bm, mask);
|
|
protectExtremeChannels(stencil(x, y+1), top, tm, mask);
|
|
}
|
|
bottom += N, top += N;
|
|
}
|
|
}
|
|
// Diagonal texel pairs
|
|
radius = float(PROTECTION_RADIUS_TOLERANCE*projection.unprojectVector(Vector2(invRange)).length());
|
|
for (int y = 0; y < sdf.height-1; ++y) {
|
|
const float *lb = sdf(0, y);
|
|
const float *rb = sdf(1, y);
|
|
const float *lt = sdf(0, y+1);
|
|
const float *rt = sdf(1, y+1);
|
|
for (int x = 0; x < sdf.width-1; ++x) {
|
|
float mlb = median(lb[0], lb[1], lb[2]);
|
|
float mrb = median(rb[0], rb[1], rb[2]);
|
|
float mlt = median(lt[0], lt[1], lt[2]);
|
|
float mrt = median(rt[0], rt[1], rt[2]);
|
|
if (fabsf(mlb-.5f)+fabsf(mrt-.5f) < radius) {
|
|
int mask = edgeBetweenTexels(lb, rt);
|
|
protectExtremeChannels(stencil(x, y), lb, mlb, mask);
|
|
protectExtremeChannels(stencil(x+1, y+1), rt, mrt, mask);
|
|
}
|
|
if (fabsf(mrb-.5f)+fabsf(mlt-.5f) < radius) {
|
|
int mask = edgeBetweenTexels(rb, lt);
|
|
protectExtremeChannels(stencil(x+1, y), rb, mrb, mask);
|
|
protectExtremeChannels(stencil(x, y+1), lt, mlt, mask);
|
|
}
|
|
lb += N, rb += N, lt += N, rt += N;
|
|
}
|
|
}
|
|
}
|
|
|
|
void MSDFErrorCorrection::protectAll() {
|
|
byte *end = stencil.pixels+stencil.width*stencil.height;
|
|
for (byte *mask = stencil.pixels; mask < end; ++mask)
|
|
*mask |= (byte) PROTECTED;
|
|
}
|
|
|
|
/// Returns the median of the linear interpolation of texels a, b at t.
|
|
static float interpolatedMedian(const float *a, const float *b, double t) {
|
|
return median(
|
|
mix(a[0], b[0], t),
|
|
mix(a[1], b[1], t),
|
|
mix(a[2], b[2], t)
|
|
);
|
|
}
|
|
/// Returns the median of the bilinear interpolation with the given constant, linear, and quadratic terms at t.
|
|
static float interpolatedMedian(const float *a, const float *l, const float *q, double t) {
|
|
return float(median(
|
|
t*(t*q[0]+l[0])+a[0],
|
|
t*(t*q[1]+l[1])+a[1],
|
|
t*(t*q[2]+l[2])+a[2]
|
|
));
|
|
}
|
|
|
|
/// Determines if the interpolated median xm is an artifact.
|
|
static bool isArtifact(bool isProtected, double axSpan, double bxSpan, float am, float bm, float xm) {
|
|
return (
|
|
// For protected texels, only report an artifact if it would cause fill inversion (change between positive and negative distance).
|
|
(!isProtected || (am > .5f && bm > .5f && xm <= .5f) || (am < .5f && bm < .5f && xm >= .5f)) &&
|
|
// This is an artifact if the interpolated median is outside the range of possible values based on its distance from a, b.
|
|
!(xm >= am-axSpan && xm <= am+axSpan && xm >= bm-bxSpan && xm <= bm+bxSpan)
|
|
);
|
|
}
|
|
|
|
/// Checks if a linear interpolation artifact will occur at a point where two specific color channels are equal - such points have extreme median values.
|
|
template <class ArtifactClassifier>
|
|
static bool hasLinearArtifactInner(const ArtifactClassifier &artifactClassifier, float am, float bm, const float *a, const float *b, float dA, float dB) {
|
|
// Find interpolation ratio t (0 < t < 1) where two color channels are equal (mix(dA, dB, t) == 0).
|
|
double t = (double) dA/(dA-dB);
|
|
if (t > ARTIFACT_T_EPSILON && t < 1-ARTIFACT_T_EPSILON) {
|
|
// Interpolate median at t and let the classifier decide if its value indicates an artifact.
|
|
float xm = interpolatedMedian(a, b, t);
|
|
return artifactClassifier.evaluate(t, xm, artifactClassifier.rangeTest(0, 1, t, am, bm, xm));
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/// Checks if a bilinear interpolation artifact will occur at a point where two specific color channels are equal - such points have extreme median values.
|
|
template <class ArtifactClassifier>
|
|
static bool hasDiagonalArtifactInner(const ArtifactClassifier &artifactClassifier, float am, float dm, const float *a, const float *l, const float *q, float dA, float dBC, float dD, double tEx0, double tEx1) {
|
|
// Find interpolation ratios t (0 < t[i] < 1) where two color channels are equal.
|
|
double t[2];
|
|
int solutions = solveQuadratic(t, dD-dBC+dA, dBC-dA-dA, dA);
|
|
for (int i = 0; i < solutions; ++i) {
|
|
// Solutions t[i] == 0 and t[i] == 1 are singularities and occur very often because two channels are usually equal at texels.
|
|
if (t[i] > ARTIFACT_T_EPSILON && t[i] < 1-ARTIFACT_T_EPSILON) {
|
|
// Interpolate median xm at t.
|
|
float xm = interpolatedMedian(a, l, q, t[i]);
|
|
// Determine if xm deviates too much from medians of a, d.
|
|
int rangeFlags = artifactClassifier.rangeTest(0, 1, t[i], am, dm, xm);
|
|
// Additionally, check xm against the interpolated medians at the local extremes tEx0, tEx1.
|
|
double tEnd[2];
|
|
float em[2];
|
|
// tEx0
|
|
if (tEx0 > 0 && tEx0 < 1) {
|
|
tEnd[0] = 0, tEnd[1] = 1;
|
|
em[0] = am, em[1] = dm;
|
|
tEnd[tEx0 > t[i]] = tEx0;
|
|
em[tEx0 > t[i]] = interpolatedMedian(a, l, q, tEx0);
|
|
rangeFlags |= artifactClassifier.rangeTest(tEnd[0], tEnd[1], t[i], am, dm, xm);
|
|
}
|
|
// tEx1
|
|
if (tEx1 > 0 && tEx1 < 1) {
|
|
tEnd[0] = 0, tEnd[1] = 1;
|
|
em[0] = am, em[1] = dm;
|
|
tEnd[tEx1 > t[i]] = tEx1;
|
|
em[tEx1 > t[i]] = interpolatedMedian(a, l, q, tEx1);
|
|
rangeFlags |= artifactClassifier.rangeTest(tEnd[0], tEnd[1], t[i], am, dm, xm);
|
|
}
|
|
if (artifactClassifier.evaluate(t[i], xm, rangeFlags))
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/// Checks if a linear interpolation artifact will occur inbetween two horizontally or vertically adjacent texels a, b.
|
|
template <class ArtifactClassifier>
|
|
static bool hasLinearArtifact(const ArtifactClassifier &artifactClassifier, float am, const float *a, const float *b) {
|
|
float bm = median(b[0], b[1], b[2]);
|
|
return (
|
|
// Out of the pair, only report artifacts for the texel further from the edge to minimize side effects.
|
|
fabsf(am-.5f) >= fabsf(bm-.5f) && (
|
|
// Check points where each pair of color channels meets.
|
|
hasLinearArtifactInner(artifactClassifier, am, bm, a, b, a[1]-a[0], b[1]-b[0]) ||
|
|
hasLinearArtifactInner(artifactClassifier, am, bm, a, b, a[2]-a[1], b[2]-b[1]) ||
|
|
hasLinearArtifactInner(artifactClassifier, am, bm, a, b, a[0]-a[2], b[0]-b[2])
|
|
)
|
|
);
|
|
}
|
|
|
|
/// Checks if a bilinear interpolation artifact will occur inbetween two diagonally adjacent texels a, d (with b, c forming the other diagonal).
|
|
template <class ArtifactClassifier>
|
|
static bool hasDiagonalArtifact(const ArtifactClassifier &artifactClassifier, float am, const float *a, const float *b, const float *c, const float *d) {
|
|
float dm = median(d[0], d[1], d[2]);
|
|
// Out of the pair, only report artifacts for the texel further from the edge to minimize side effects.
|
|
if (fabsf(am-.5f) >= fabsf(dm-.5f)) {
|
|
float abc[3] = {
|
|
a[0]-b[0]-c[0],
|
|
a[1]-b[1]-c[1],
|
|
a[2]-b[2]-c[2]
|
|
};
|
|
// Compute the linear terms for bilinear interpolation.
|
|
float l[3] = {
|
|
-a[0]-abc[0],
|
|
-a[1]-abc[1],
|
|
-a[2]-abc[2]
|
|
};
|
|
// Compute the quadratic terms for bilinear interpolation.
|
|
float q[3] = {
|
|
d[0]+abc[0],
|
|
d[1]+abc[1],
|
|
d[2]+abc[2]
|
|
};
|
|
// Compute interpolation ratios tEx (0 < tEx[i] < 1) for the local extremes of each color channel (the derivative 2*q[i]*tEx[i]+l[i] == 0).
|
|
double tEx[3] = {
|
|
-.5*l[0]/q[0],
|
|
-.5*l[1]/q[1],
|
|
-.5*l[2]/q[2]
|
|
};
|
|
// Check points where each pair of color channels meets.
|
|
return (
|
|
hasDiagonalArtifactInner(artifactClassifier, am, dm, a, l, q, a[1]-a[0], b[1]-b[0]+c[1]-c[0], d[1]-d[0], tEx[0], tEx[1]) ||
|
|
hasDiagonalArtifactInner(artifactClassifier, am, dm, a, l, q, a[2]-a[1], b[2]-b[1]+c[2]-c[1], d[2]-d[1], tEx[1], tEx[2]) ||
|
|
hasDiagonalArtifactInner(artifactClassifier, am, dm, a, l, q, a[0]-a[2], b[0]-b[2]+c[0]-c[2], d[0]-d[2], tEx[2], tEx[0])
|
|
);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
template <int N>
|
|
void MSDFErrorCorrection::findErrors(const BitmapConstRef<float, N> &sdf) {
|
|
// Compute the expected deltas between values of horizontally, vertically, and diagonally adjacent texels.
|
|
double hSpan = minDeviationRatio*projection.unprojectVector(Vector2(invRange, 0)).length();
|
|
double vSpan = minDeviationRatio*projection.unprojectVector(Vector2(0, invRange)).length();
|
|
double dSpan = minDeviationRatio*projection.unprojectVector(Vector2(invRange)).length();
|
|
// Inspect all texels.
|
|
for (int y = 0; y < sdf.height; ++y) {
|
|
for (int x = 0; x < sdf.width; ++x) {
|
|
const float *c = sdf(x, y);
|
|
float cm = median(c[0], c[1], c[2]);
|
|
bool protectedFlag = (*stencil(x, y)&PROTECTED) != 0;
|
|
const float *l = NULL, *b = NULL, *r = NULL, *t = NULL;
|
|
// Mark current texel c with the error flag if an artifact occurs when it's interpolated with any of its 8 neighbors.
|
|
*stencil(x, y) |= (byte) (ERROR*(
|
|
(x > 0 && ((l = sdf(x-1, y)), hasLinearArtifact(BaseArtifactClassifier(hSpan, protectedFlag), cm, c, l))) ||
|
|
(y > 0 && ((b = sdf(x, y-1)), hasLinearArtifact(BaseArtifactClassifier(vSpan, protectedFlag), cm, c, b))) ||
|
|
(x < sdf.width-1 && ((r = sdf(x+1, y)), hasLinearArtifact(BaseArtifactClassifier(hSpan, protectedFlag), cm, c, r))) ||
|
|
(y < sdf.height-1 && ((t = sdf(x, y+1)), hasLinearArtifact(BaseArtifactClassifier(vSpan, protectedFlag), cm, c, t))) ||
|
|
(x > 0 && y > 0 && hasDiagonalArtifact(BaseArtifactClassifier(dSpan, protectedFlag), cm, c, l, b, sdf(x-1, y-1))) ||
|
|
(x < sdf.width-1 && y > 0 && hasDiagonalArtifact(BaseArtifactClassifier(dSpan, protectedFlag), cm, c, r, b, sdf(x+1, y-1))) ||
|
|
(x > 0 && y < sdf.height-1 && hasDiagonalArtifact(BaseArtifactClassifier(dSpan, protectedFlag), cm, c, l, t, sdf(x-1, y+1))) ||
|
|
(x < sdf.width-1 && y < sdf.height-1 && hasDiagonalArtifact(BaseArtifactClassifier(dSpan, protectedFlag), cm, c, r, t, sdf(x+1, y+1)))
|
|
));
|
|
}
|
|
}
|
|
}
|
|
|
|
template <template <typename> class ContourCombiner, int N>
|
|
void MSDFErrorCorrection::findErrors(const BitmapConstRef<float, N> &sdf, const Shape &shape) {
|
|
// Compute the expected deltas between values of horizontally, vertically, and diagonally adjacent texels.
|
|
double hSpan = minDeviationRatio*projection.unprojectVector(Vector2(invRange, 0)).length();
|
|
double vSpan = minDeviationRatio*projection.unprojectVector(Vector2(0, invRange)).length();
|
|
double dSpan = minDeviationRatio*projection.unprojectVector(Vector2(invRange)).length();
|
|
#ifdef MSDFGEN_USE_OPENMP
|
|
#pragma omp parallel
|
|
#endif
|
|
{
|
|
ShapeDistanceChecker<ContourCombiner, N> shapeDistanceChecker(sdf, shape, projection, invRange, minImproveRatio);
|
|
bool rightToLeft = false;
|
|
// Inspect all texels.
|
|
#ifdef MSDFGEN_USE_OPENMP
|
|
#pragma omp for
|
|
#endif
|
|
for (int y = 0; y < sdf.height; ++y) {
|
|
int row = shape.inverseYAxis ? sdf.height-y-1 : y;
|
|
for (int col = 0; col < sdf.width; ++col) {
|
|
int x = rightToLeft ? sdf.width-col-1 : col;
|
|
if ((*stencil(x, row)&ERROR))
|
|
continue;
|
|
const float *c = sdf(x, row);
|
|
shapeDistanceChecker.shapeCoord = projection.unproject(Point2(x+.5, y+.5));
|
|
shapeDistanceChecker.sdfCoord = Point2(x+.5, row+.5);
|
|
shapeDistanceChecker.msd = c;
|
|
shapeDistanceChecker.protectedFlag = (*stencil(x, row)&PROTECTED) != 0;
|
|
float cm = median(c[0], c[1], c[2]);
|
|
const float *l = NULL, *b = NULL, *r = NULL, *t = NULL;
|
|
// Mark current texel c with the error flag if an artifact occurs when it's interpolated with any of its 8 neighbors.
|
|
*stencil(x, row) |= (byte) (ERROR*(
|
|
(x > 0 && ((l = sdf(x-1, row)), hasLinearArtifact(shapeDistanceChecker.classifier(Vector2(-1, 0), hSpan), cm, c, l))) ||
|
|
(row > 0 && ((b = sdf(x, row-1)), hasLinearArtifact(shapeDistanceChecker.classifier(Vector2(0, -1), vSpan), cm, c, b))) ||
|
|
(x < sdf.width-1 && ((r = sdf(x+1, row)), hasLinearArtifact(shapeDistanceChecker.classifier(Vector2(+1, 0), hSpan), cm, c, r))) ||
|
|
(row < sdf.height-1 && ((t = sdf(x, row+1)), hasLinearArtifact(shapeDistanceChecker.classifier(Vector2(0, +1), vSpan), cm, c, t))) ||
|
|
(x > 0 && row > 0 && hasDiagonalArtifact(shapeDistanceChecker.classifier(Vector2(-1, -1), dSpan), cm, c, l, b, sdf(x-1, row-1))) ||
|
|
(x < sdf.width-1 && row > 0 && hasDiagonalArtifact(shapeDistanceChecker.classifier(Vector2(+1, -1), dSpan), cm, c, r, b, sdf(x+1, row-1))) ||
|
|
(x > 0 && row < sdf.height-1 && hasDiagonalArtifact(shapeDistanceChecker.classifier(Vector2(-1, +1), dSpan), cm, c, l, t, sdf(x-1, row+1))) ||
|
|
(x < sdf.width-1 && row < sdf.height-1 && hasDiagonalArtifact(shapeDistanceChecker.classifier(Vector2(+1, +1), dSpan), cm, c, r, t, sdf(x+1, row+1)))
|
|
));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
template <int N>
|
|
void MSDFErrorCorrection::apply(const BitmapRef<float, N> &sdf) const {
|
|
int texelCount = sdf.width*sdf.height;
|
|
const byte *mask = stencil.pixels;
|
|
float *texel = sdf.pixels;
|
|
for (int i = 0; i < texelCount; ++i) {
|
|
if (*mask&ERROR) {
|
|
// Set all color channels to the median.
|
|
float m = median(texel[0], texel[1], texel[2]);
|
|
texel[0] = m, texel[1] = m, texel[2] = m;
|
|
}
|
|
++mask;
|
|
texel += N;
|
|
}
|
|
}
|
|
|
|
BitmapConstRef<byte, 1> MSDFErrorCorrection::getStencil() const {
|
|
return stencil;
|
|
}
|
|
|
|
template void MSDFErrorCorrection::protectEdges(const BitmapConstRef<float, 3> &sdf);
|
|
template void MSDFErrorCorrection::protectEdges(const BitmapConstRef<float, 4> &sdf);
|
|
template void MSDFErrorCorrection::findErrors(const BitmapConstRef<float, 3> &sdf);
|
|
template void MSDFErrorCorrection::findErrors(const BitmapConstRef<float, 4> &sdf);
|
|
template void MSDFErrorCorrection::findErrors<SimpleContourCombiner>(const BitmapConstRef<float, 3> &sdf, const Shape &shape);
|
|
template void MSDFErrorCorrection::findErrors<SimpleContourCombiner>(const BitmapConstRef<float, 4> &sdf, const Shape &shape);
|
|
template void MSDFErrorCorrection::findErrors<OverlappingContourCombiner>(const BitmapConstRef<float, 3> &sdf, const Shape &shape);
|
|
template void MSDFErrorCorrection::findErrors<OverlappingContourCombiner>(const BitmapConstRef<float, 4> &sdf, const Shape &shape);
|
|
template void MSDFErrorCorrection::apply(const BitmapRef<float, 3> &sdf) const;
|
|
template void MSDFErrorCorrection::apply(const BitmapRef<float, 4> &sdf) const;
|
|
|
|
}
|