311 lines
17 KiB
Swift
311 lines
17 KiB
Swift
//
|
|
// MathTable.swift
|
|
//
|
|
//
|
|
// Created by Peter Tang on 11/9/2023.
|
|
//
|
|
|
|
import Foundation
|
|
import CoreText
|
|
|
|
/** This class represents the Math table of an open type font.
|
|
|
|
The math table is documented here: https://www.microsoft.com/typography/otspec/math.htm
|
|
|
|
How the constants in this class affect the display is documented here:
|
|
http://www.tug.org/TUGboat/tb30-1/tb94vieth.pdf
|
|
|
|
Note: We don't parse the math table from the open type font. Rather we parse it
|
|
in python and convert it to a .plist file which is easily consumed by this class.
|
|
This approach is preferable to spending an inordinate amount of time figuring out
|
|
how to parse the returned NSData object using the open type rules.
|
|
|
|
Remark: This class is not meant to be used outside of this library.
|
|
*/
|
|
internal struct MathTable {
|
|
let kConstants = "constants"
|
|
|
|
let font: MathFont
|
|
let unitsPerEm: UInt
|
|
let fontSize: CGFloat
|
|
weak var fontMathTable: NSDictionary?
|
|
|
|
init(withFont font: MathFont, fontSize: CGFloat, unitsPerEm: UInt) {
|
|
self.font = font
|
|
self.unitsPerEm = unitsPerEm
|
|
self.fontSize = fontSize
|
|
self.fontMathTable = font.mathTable()
|
|
}
|
|
func fontUnitsToPt(_ fontUnits: Int) -> CGFloat {
|
|
CGFloat(fontUnits) * fontSize / CGFloat(unitsPerEm)
|
|
}
|
|
func constantFromTable(_ constName: String) -> CGFloat {
|
|
guard let consts = fontMathTable?[kConstants] as? NSDictionary, let val = consts[constName] as? NSNumber else {
|
|
fatalError("\(#function) unable to extract \(constName) from plist")
|
|
}
|
|
return fontUnitsToPt(val.intValue)
|
|
}
|
|
func percentFromTable(_ percentName: String) -> CGFloat {
|
|
guard let consts = fontMathTable?[kConstants] as? NSDictionary, let val = consts[percentName] as? NSNumber else {
|
|
fatalError("\(#function) unable to extract \(percentName) from plist")
|
|
}
|
|
return CGFloat(val.floatValue) / 100
|
|
}
|
|
/// Math Font Metrics from the opentype specification
|
|
// MARK: - Fractions
|
|
var fractionNumeratorDisplayStyleShiftUp:CGFloat { constantFromTable("FractionNumeratorDisplayStyleShiftUp") } // \sigma_8 in TeX
|
|
var fractionNumeratorShiftUp:CGFloat { constantFromTable("FractionNumeratorShiftUp") } // \sigma_9 in TeX
|
|
var fractionDenominatorDisplayStyleShiftDown:CGFloat { constantFromTable("FractionDenominatorDisplayStyleShiftDown") } // \sigma_11 in TeX
|
|
var fractionDenominatorShiftDown:CGFloat { constantFromTable("FractionDenominatorShiftDown") } // \sigma_12 in TeX
|
|
var fractionNumeratorDisplayStyleGapMin:CGFloat { constantFromTable("FractionNumDisplayStyleGapMin") } // 3 * \xi_8 in TeX
|
|
var fractionNumeratorGapMin:CGFloat { constantFromTable("FractionNumeratorGapMin") } // \xi_8 in TeX
|
|
var fractionDenominatorDisplayStyleGapMin:CGFloat { constantFromTable("FractionDenomDisplayStyleGapMin") } // 3 * \xi_8 in TeX
|
|
var fractionDenominatorGapMin:CGFloat { constantFromTable("FractionDenominatorGapMin") } // \xi_8 in TeX
|
|
var fractionRuleThickness:CGFloat { constantFromTable("FractionRuleThickness") } // \xi_8 in TeX
|
|
var skewedFractionHorizonalGap:CGFloat { constantFromTable("SkewedFractionHorizontalGap") } // \sigma_20 in TeX
|
|
var skewedFractionVerticalGap:CGFloat { constantFromTable("SkewedFractionVerticalGap") } // \sigma_21 in TeX
|
|
|
|
// MARK: - Non-standard
|
|
/// FractionDelimiterSize and FractionDelimiterDisplayStyleSize are not constants
|
|
/// specified in the OpenType Math specification. Rather these are proposed LuaTeX extensions
|
|
/// for the TeX parameters \sigma_20 (delim1) and \sigma_21 (delim2). Since these do not
|
|
/// exist in the fonts that we have, we use the same approach as LuaTeX and use the fontSize
|
|
/// to determine these values. The constants used are the same as LuaTeX and KaTeX and match the
|
|
/// metrics values of the original TeX fonts.
|
|
/// Note: An alternative approach is to use DelimitedSubFormulaMinHeight for \sigma21 and use a factor
|
|
/// of 2 to get \sigma 20 as proposed in Vieth paper.
|
|
/// The XeTeX implementation sets \sigma21 = fontSize and \sigma20 = DelimitedSubFormulaMinHeight which
|
|
/// will produce smaller delimiters.
|
|
/// Of all the approaches we've implemented LuaTeX's approach since it mimics LaTeX most accurately.
|
|
var fractionDelimiterSize: CGFloat { 1.01 * fontSize }
|
|
|
|
/// Modified constant from 2.4 to 2.39, it matches KaTeX and looks better.
|
|
var fractionDelimiterDisplayStyleSize: CGFloat { 2.39 * fontSize }
|
|
|
|
// MARK: - Stacks
|
|
var stackTopDisplayStyleShiftUp:CGFloat { constantFromTable("StackTopDisplayStyleShiftUp") } // \sigma_8 in TeX
|
|
var stackTopShiftUp:CGFloat { constantFromTable("StackTopShiftUp") } // \sigma_10 in TeX
|
|
var stackDisplayStyleGapMin:CGFloat { constantFromTable("StackDisplayStyleGapMin") } // 7 \xi_8 in TeX
|
|
var stackGapMin:CGFloat { constantFromTable("StackGapMin") } // 3 \xi_8 in TeX
|
|
var stackBottomDisplayStyleShiftDown:CGFloat { constantFromTable("StackBottomDisplayStyleShiftDown") } // \sigma_11 in TeX
|
|
var stackBottomShiftDown:CGFloat { constantFromTable("StackBottomShiftDown") } // \sigma_12 in TeX
|
|
|
|
var stretchStackBottomShiftDown:CGFloat { constantFromTable("StretchStackBottomShiftDown") }
|
|
var stretchStackGapAboveMin:CGFloat { constantFromTable("StretchStackGapAboveMin") }
|
|
var stretchStackGapBelowMin:CGFloat { constantFromTable("StretchStackGapBelowMin") }
|
|
var stretchStackTopShiftUp:CGFloat { constantFromTable("StretchStackTopShiftUp") }
|
|
|
|
// MARK: - super/sub scripts
|
|
|
|
var superscriptShiftUp:CGFloat { constantFromTable("SuperscriptShiftUp") } // \sigma_13, \sigma_14 in TeX
|
|
var superscriptShiftUpCramped:CGFloat { constantFromTable("SuperscriptShiftUpCramped") } // \sigma_15 in TeX
|
|
var subscriptShiftDown:CGFloat { constantFromTable("SubscriptShiftDown") } // \sigma_16, \sigma_17 in TeX
|
|
var superscriptBaselineDropMax:CGFloat { constantFromTable("SuperscriptBaselineDropMax") } // \sigma_18 in TeX
|
|
var subscriptBaselineDropMin:CGFloat { constantFromTable("SubscriptBaselineDropMin") } // \sigma_19 in TeX
|
|
var superscriptBottomMin:CGFloat { constantFromTable("SuperscriptBottomMin") } // 1/4 \sigma_5 in TeX
|
|
var subscriptTopMax:CGFloat { constantFromTable("SubscriptTopMax") } // 4/5 \sigma_5 in TeX
|
|
var subSuperscriptGapMin:CGFloat { constantFromTable("SubSuperscriptGapMin") } // 4 \xi_8 in TeX
|
|
var superscriptBottomMaxWithSubscript:CGFloat { constantFromTable("SuperscriptBottomMaxWithSubscript") } // 4/5 \sigma_5 in TeX
|
|
|
|
var spaceAfterScript:CGFloat { constantFromTable("SpaceAfterScript") }
|
|
|
|
// MARK: - radicals
|
|
var radicalExtraAscender:CGFloat { constantFromTable("RadicalExtraAscender") } // \xi_8 in Tex
|
|
var radicalRuleThickness:CGFloat { constantFromTable("RadicalRuleThickness") } // \xi_8 in Tex
|
|
var radicalDisplayStyleVerticalGap:CGFloat { constantFromTable("RadicalDisplayStyleVerticalGap") } // \xi_8 + 1/4 \sigma_5 in Tex
|
|
var radicalVerticalGap:CGFloat { constantFromTable("RadicalVerticalGap") } // 5/4 \xi_8 in Tex
|
|
var radicalKernBeforeDegree:CGFloat { constantFromTable("RadicalKernBeforeDegree") } // 5 mu in Tex
|
|
var radicalKernAfterDegree:CGFloat { constantFromTable("RadicalKernAfterDegree") } // -10 mu in Tex
|
|
var radicalDegreeBottomRaisePercent:CGFloat { percentFromTable("RadicalDegreeBottomRaisePercent") } // 60% in Tex
|
|
|
|
// MARK: - Limits
|
|
var upperLimitBaselineRiseMin:CGFloat { constantFromTable("UpperLimitBaselineRiseMin") } // \xi_11 in TeX
|
|
var upperLimitGapMin:CGFloat { constantFromTable("UpperLimitGapMin") } // \xi_9 in TeX
|
|
var lowerLimitGapMin:CGFloat { constantFromTable("LowerLimitGapMin") } // \xi_10 in TeX
|
|
var lowerLimitBaselineDropMin:CGFloat { constantFromTable("LowerLimitBaselineDropMin") } // \xi_12 in TeX
|
|
var limitExtraAscenderDescender:CGFloat { 0 } // \xi_13 in TeX, not present in OpenType so we always set it to 0.
|
|
|
|
// MARK: - Underline
|
|
var underbarVerticalGap:CGFloat { constantFromTable("UnderbarVerticalGap") } // 3 \xi_8 in TeX
|
|
var underbarRuleThickness:CGFloat { constantFromTable("UnderbarRuleThickness") } // \xi_8 in TeX
|
|
var underbarExtraDescender:CGFloat { constantFromTable("UnderbarExtraDescender") } // \xi_8 in TeX
|
|
|
|
// MARK: - Overline
|
|
var overbarVerticalGap:CGFloat { constantFromTable("OverbarVerticalGap") } // 3 \xi_8 in TeX
|
|
var overbarRuleThickness:CGFloat { constantFromTable("OverbarRuleThickness") } // \xi_8 in TeX
|
|
var overbarExtraAscender:CGFloat { constantFromTable("OverbarExtraAscender") } // \xi_8 in TeX
|
|
|
|
// MARK: - Constants
|
|
|
|
var axisHeight:CGFloat { constantFromTable("AxisHeight") } // \sigma_22 in TeX
|
|
var scriptScaleDown:CGFloat { percentFromTable("ScriptPercentScaleDown") }
|
|
var scriptScriptScaleDown:CGFloat { percentFromTable("ScriptScriptPercentScaleDown") }
|
|
var mathLeading:CGFloat { constantFromTable("MathLeading") }
|
|
var delimitedSubFormulaMinHeight:CGFloat { constantFromTable("DelimitedSubFormulaMinHeight") }
|
|
|
|
// MARK: - Accent
|
|
|
|
var accentBaseHeight:CGFloat { constantFromTable("AccentBaseHeight") } // \fontdimen5 in TeX (x-height)
|
|
var flattenedAccentBaseHeight:CGFloat { constantFromTable("FlattenedAccentBaseHeight") }
|
|
|
|
|
|
// MARK: - Variants
|
|
|
|
let kVertVariants = "v_variants"
|
|
let kHorizVariants = "h_variants"
|
|
|
|
/** Returns an Array of all the vertical variants of the glyph if any. If
|
|
there are no variants for the glyph, the array contains the given glyph. */
|
|
func getVerticalVariantsForGlyph( _ glyph: CGGlyph) -> [NSNumber?] {
|
|
guard let variants = fontMathTable?[kVertVariants] as? NSDictionary else {
|
|
fatalError("\(#function) unable to extract \(glyph) from plist")
|
|
}
|
|
return self.getVariantsForGlyph(glyph, inDictionary: variants)
|
|
}
|
|
|
|
/** Returns an Array of all the horizontal variants of the glyph if any. If
|
|
there are no variants for the glyph, the array contains the given glyph. */
|
|
func getHorizontalVariantsForGlyph( _ glyph: CGGlyph) -> [NSNumber?] {
|
|
guard let variants = fontMathTable?[kHorizVariants] as? NSDictionary else {
|
|
fatalError("\(#function) unable to extract \(glyph) from plist")
|
|
}
|
|
return self.getVariantsForGlyph(glyph, inDictionary:variants)
|
|
}
|
|
|
|
func getVariantsForGlyph(_ glyph: CGGlyph, inDictionary variants: NSDictionary) -> [NSNumber?] {
|
|
let glyphName = font.get(nameForGlyph: glyph)
|
|
let variantGlyphs = variants[glyphName] as? NSArray
|
|
var glyphArray = [NSNumber]()
|
|
if variantGlyphs == nil || variantGlyphs?.count == 0 {
|
|
// There are no extra variants, so just add the current glyph to it.
|
|
let glyph = font.get(glyphWithName: glyphName)
|
|
glyphArray.append(NSNumber(value:glyph))
|
|
return glyphArray
|
|
} else if let variantGlyphs = variantGlyphs {
|
|
for gvn in variantGlyphs {
|
|
if let glyphVariantName = gvn as? String {
|
|
let variantGlyph = font.get(glyphWithName: glyphVariantName)
|
|
glyphArray.append(NSNumber(value:variantGlyph))
|
|
}
|
|
}
|
|
}
|
|
return glyphArray
|
|
}
|
|
|
|
/** Returns a larger vertical variant of the given glyph if any.
|
|
If there is no larger version, this returns the current glyph.
|
|
*/
|
|
func getLargerGlyph(_ glyph:CGGlyph) -> CGGlyph {
|
|
let variants = fontMathTable?[kVertVariants] as? NSDictionary
|
|
let glyphName = font.get(nameForGlyph: glyph)
|
|
let variantGlyphs = variants![glyphName] as? NSArray
|
|
if variantGlyphs == nil || variantGlyphs?.count == 0 {
|
|
// There are no extra variants, so just returnt the current glyph.
|
|
return glyph
|
|
}
|
|
// Find the first variant with a different name.
|
|
for gvn in variantGlyphs! {
|
|
if let glyphVariantName = gvn as? String,
|
|
glyphVariantName != glyphName {
|
|
return font.get(glyphWithName: glyphVariantName)
|
|
}
|
|
}
|
|
// We did not find any variants of this glyph so return it.
|
|
return glyph;
|
|
}
|
|
|
|
// MARK: - Italic Correction
|
|
|
|
let kItalic = "italic"
|
|
|
|
/** Returns the italic correction for the given glyph if any. If there
|
|
isn't any this returns 0. */
|
|
func getItalicCorrection(_ glyph: CGGlyph) -> CGFloat {
|
|
let italics = fontMathTable?[kItalic] as? NSDictionary
|
|
let glyphName = font.get(nameForGlyph: glyph)
|
|
let val = italics![glyphName] as? NSNumber
|
|
// if val is nil, this returns 0.
|
|
return fontUnitsToPt(val?.intValue ?? 0)
|
|
}
|
|
|
|
// MARK: - Accents
|
|
|
|
let kAccents = "accents"
|
|
|
|
/** Returns the adjustment to the top accent for the given glyph if any.
|
|
If there isn't any this returns -1. */
|
|
func getTopAccentAdjustment(_ glyph: CGGlyph) -> CGFloat {
|
|
var glyph = glyph
|
|
let accents = fontMathTable?[kAccents] as? NSDictionary
|
|
let glyphName = font.get(nameForGlyph: glyph)
|
|
let val = accents![glyphName] as? NSNumber
|
|
if let val = val {
|
|
return self.fontUnitsToPt(val.intValue)
|
|
} else {
|
|
// If no top accent is defined then it is the center of the advance width.
|
|
var advances = CGSize.zero
|
|
let ctFont = font.ctFont(withSize: fontSize)
|
|
CTFontGetAdvancesForGlyphs(ctFont, .horizontal, &glyph, &advances, 1)
|
|
return advances.width/2
|
|
}
|
|
}
|
|
|
|
// MARK: - Glyph Construction
|
|
|
|
/** Minimum overlap of connecting glyphs during glyph construction */
|
|
var minConnectorOverlap:CGFloat { constantFromTable("MinConnectorOverlap") }
|
|
|
|
let kVertAssembly = "v_assembly"
|
|
let kAssemblyParts = "parts"
|
|
|
|
/** Returns an array of the glyph parts to be used for constructing vertical variants
|
|
of this glyph. If there is no glyph assembly defined, returns an empty array. */
|
|
func getVerticalGlyphAssembly(forGlyph glyph:CGGlyph) -> [GlyphPart] {
|
|
let assemblyTable = fontMathTable?[kVertAssembly] as? NSDictionary
|
|
let glyphName = font.get(nameForGlyph: glyph)
|
|
guard let assemblyInfo = assemblyTable?[glyphName] as? NSDictionary,
|
|
let parts = assemblyInfo[kAssemblyParts] as? NSArray else {
|
|
// No vertical assembly defined for glyph
|
|
// parts should always have been defined, but if it isn't return nil
|
|
return []
|
|
}
|
|
var rv = [GlyphPart]()
|
|
for part in parts {
|
|
guard let partInfo = part as? NSDictionary else { continue }
|
|
let glyph = font.get(glyphWithName: glyphName)
|
|
var part = GlyphPart(glyph: glyph)
|
|
if let adv = partInfo["advance"] as? NSNumber,
|
|
let end = partInfo["endConnector"] as? NSNumber,
|
|
let start = partInfo["startConnector"] as? NSNumber,
|
|
let ext = partInfo["extender"] as? NSNumber,
|
|
let partInfoGlyphName = partInfo["glyph"] as? String, partInfoGlyphName == glyphName {
|
|
part.fullAdvance = fontUnitsToPt(adv.intValue)
|
|
part.endConnectorLength = fontUnitsToPt(end.intValue)
|
|
part.startConnectorLength = fontUnitsToPt(start.intValue)
|
|
part.isExtender = ext.boolValue
|
|
rv.append(part)
|
|
}
|
|
}
|
|
return rv
|
|
}
|
|
|
|
}
|
|
extension MathTable {
|
|
struct GlyphPart {
|
|
/// The glyph that represents this part
|
|
var glyph: CGGlyph
|
|
|
|
/// Full advance width/height for this part, in the direction of the extension in points.
|
|
var fullAdvance: CGFloat = 0
|
|
|
|
/// Advance width/ height of the straight bar connector material at the beginning of the glyph in points.
|
|
var startConnectorLength: CGFloat = 0
|
|
|
|
/// Advance width/ height of the straight bar connector material at the end of the glyph in points.
|
|
var endConnectorLength: CGFloat = 0
|
|
|
|
/// If this part is an extender. If set, the part can be skipped or repeated.
|
|
var isExtender: Bool = false
|
|
}
|
|
}
|