关于 LaTeX 的 TTS 朗读这件事

背景

业务最近有朗读LaTex公式的需求,而TTS引擎目前并不支持对LaTeX语法的理解,如果直接把LaTeX文本输入给TTS引擎,会出现较多的朗读错误。

经过调研,目前市面上已有的方案有:

这两种方案虽然开源,但是不支持中文,组装规则和中文差异比较大;均为非 Native 方案,性能比较差; 因此决定将LaTeX文本投喂给TTS引擎之前做一层转换:解析LaTeX语法,构建语法树,将LaTeX的原始文本转换为可供TTS引擎朗读的自然语言文本,最后将自然语言文本输入给TTS引擎。由于 LaTeX 渲染引擎已经做了语法解析的工作,语法树是现成的,那么所要做的工作就是基于已有的语法树,在树上面的各个节点中按照规则进行组装。由于 LaTeX涉及命令和符号众多,所以工作量会比较大,本文将结合数学和化学两个学科描述其实现原理,以及在实践过程中碰到的一些难点。

本文涉及到的所有的 LaTeX 朗读逻辑只针对中文

目前效果

视频中有语音朗读

实现原理

架构图

熟悉LaTeX的同学会了解到:LaTeX原始文本经过解析会生成一个 Atom 多叉树,然后基于 Atom 多叉树会递归生成 Box 多叉树,而 Box 会根据坐标位置,使用平台无关接口 Graphics2D 进行绘制。由于 TTS 朗读不涉及渲染逻辑,所以只需要在 Atom 多叉树的节点上进行组装,生成 TTS 朗读所需的自然语言文本,在这个生成过程中,可能需要构建一些生成规则,也需要构建一些数据表。由于 TTS 文本的整个生成逻辑都是平台无关的,所以这部分逻辑是跨端的,可以同时为多端复用。

语法树节点

由于Atom节点也是可以递归嵌套的,那么组装过程也是递归嵌套的。这意味着每个Atom的子类都需要去实现这个接口。

接口定义

1
2
3
4
class Atom : public std::enable_shared_from_this<Atom> {
public:
virtual std::wstring getSpeechText() = 0;
};

接口实现

以 \sqrt[3]{(x-y)^3}=x-y 为例,其生成的 Atom 多叉树如下所示:

关于 LaTeX 的 TTS 朗读这件事:接口实现(图 1)

那么这里面涉及到 5 种 Atom 子类都需要去实现getSpeechText接口,下面的示例将看到一些简单的组装规则。

  • NthRootAtom
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
std::wstring NthRootAtom::getSpeechText() {
std::wstring result = L"";
std::wstring baseSpeech = base->getSpeechText();
if (root != nullptr) {
std::wstring rootSpeech = root->getSpeechText();
if (rootSpeech == L"3") {
result = baseSpeech + L"的立方根";
} else {
result = rootSpeech + L"次根号下" + baseSpeech;
}
} else {
result = baseSpeech.size() > 1 ? L"根号下" + baseSpeech : L"根号" + baseSpeech;
}
return L" " + result + L" ";
}
  • ScriptsAtom
1
2
3
4
5
6
7
8
9
10
11
std::wstring ScriptsAtom::getSpeechText() {
std::wstring baseText = base != nullptr ? base->getSpeechText() : L"";
if (superscript->getSpeechText() == L"2") {
return baseText+ subscript->getSpeechText() + L"的平方";
} else if (superscript->getSpeechText() == L"3") {
return baseText + subscript->getSpeechText() + L"的立方";
} else {
std::wstring superscriptStr = superscript->getSpeechText();
return baseText + subscript->getSpeechText() + L"的" + superscriptStr + L"次方";
}
}
  • CharAtom
1
2
3
std::wstring CharAtom::getSpeechText() {
return StringHelper::toString(c);
}
  • SymbolAtom
1
2
3
4
5
6
7
8
std::wstring SymbolAtom::getSpeechText() {
std::wstring speechText = Configuration::Instance().getSpeechText(unicode);
if (speechText.length() > 0) {
return speechText + L" ";
}
std::wstring symbleStr = StringHelper::toString(unicode);
return symbleStr;
}
  • RowAtom
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
std::wstring RowAtom::getSpeechText()  {
std::wstring result = L"";

// 如果RowAtom本身有对应的名字,则优先取名字
if (name.length() > 0) {
return Configuration::Instance().getSpeechText(name);
}

// 绝对值识别提取
auto newElements = getElementsByAggregatingABSSymbols();

std::wstring s;
int index = 0;
for (auto& e : newElements) {
std::shared_ptr<Atom> previousAtomPtr = nullptr;
std::shared_ptr<Atom> nexAtomPtr = nullptr;

if (index > 0) {
previousAtomPtr = newElements[index -1];
}
if (index < newElements.size() - 1) {
nexAtomPtr = newElements[index + 1];
}

s += Configuration::Instance().rectifySpeechText(
e,
previousAtomPtr,
nexAtomPtr);
++index;
}
return s;
}

在这些节点都实现了getSpeechText接口的基础上,就可以按照先序遍历的方式遍历节点树,组装出最终的TTS文本:

1
括号 x减 y括号 的立方的立方根 等于 x减 y

数学规则

Unicode

LaTeX中有大量表达数学符号的unicode符号,其中有很多TTS引擎是无法识别的,因此可以维护一张专用的哈希表来翻译unicode值的读法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
static std::unordered_map<wchar_t, std::wstring> unicodeMap = {
// 图形
{L'▱', L"平行四边形"},
{L'⊙', L"圆"},
{L'\u25B3', L"三角形"},
{L'\u25B5', L"三角形"},
{L'\u2220', L"角"},
{L'\u22A5', L"垂直于"},
{L'\u2225', L"平行于"},
{L'\u22D5', L"等于和平行于"},
{L'\ue363', L"垂直于"},

// 集合
{L'\u222A', L"并集"}, // ∪
{L'\u2229', L"交集"}, // ∩
{L'\u2282', L"真包含于"}, // ⊂
{L'\u2286', L"包含于"}, // ⊆
{L'\u2284', L"非真包含于"}, // ⊄
{L'\u2288', L"非包含于"}, // ⊈
{L'\ue2ae', L"非包含于"}, // ⊈

......
}

专用符号

LaTeX中有大量表达数学符号的专用表达,TTS引擎也是无法识别的或者说可以识别但是发音不准确的,同样维护了一张专用的哈希表来翻译这些专用符号的读法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
static std::unordered_map<std::wstring, std::wstring> speechMap = {
// 三角函数
{L"sin", L"sine"},
{L"cos", L"cosine"},
{L"tan", L"tangent"},
{L"cot", L"cotangent"},
{L"sec", L"secant"},
{L"csc", L"cosecant"},
{L"arcsin", L"arc sine"},
{L"arccos", L"arc cosine"},
{L"arctan", L"arc tangent"},
{L"arccot", L"arc cotangent"},
{L"sinh", L"shine"},
{L"cosh", L"cosh"},
{L"tanh", L"tanch"},
{L"coth", L"coth"},
{L"sech", L"setch"},
{L"csch", L"cosetch"},

// 单位
{L"km" , L"千米"},
{L"m" , L"米"},
{L"dm" , L"分米"},
{L"cm" , L"厘米"},
{L"mm" , L"毫米"},
{L"μm" , L"微米"},
{L"nm" , L"纳米"},
......
}

命令组合

有的时候会出现这样的情况,需要结合前后两个命令,才能绘制出正确的结果和获取到正确的TTS文本,例如

1
\root{A} \of{B}

最后的渲染结果为

其TTS文本为 “B的A次方跟”。

在解析root的时候,并不知道后面还有of,所以根据解析规则,会前后生成2个命令:CommandRoot和CommandOf,并且各自有对应的参数。然而因为这是一个组合命令,二者结合才能渲染出正确的结果。此时就需要CommandOf在初始化的时候,试探性地检测上一个命令,如果是CommandRoot,那么就需要窃取CommandRoot的参数,并忽略掉CommandRoot命令。最后CommandOf会根据最后获取到的所有参数正确地生成NthRootAtom。

1
2
3
4
5
6
7
bool CommandOf::init(const std::shared_ptr<TeXParser>& tp) {
std::shared_ptr<RowAtom> at = tp->steal();
std::shared_ptr<NthRootAtom> root = std::dynamic_pointer_cast<NthRootAtom>(at->getLastAtom());
this->root = root != nullptr ? root->getTrueBase() : EmptyAtom::get();
base = std::make_shared<RowAtom>();
return true;
}

同时,也可以很便捷地组合出其TTS文本。

推理提前截断

有些符号看起来很简单,例如 \equalparallel 这个命令,其渲染效果如图所示

关于 LaTeX 的 TTS 朗读这件事:推理提前截断(图 2)

但是其渲染逻辑对应的Atom节点比较复杂:

1
2
3
4
5
6
7
8
shared_ptr<Atom> Commands::CommandEqualParallel::newI(const std::shared_ptr<TeXParser> &tp) {
std::shared_ptr<RowAtom> ra = make_shared_from_list<RowAtom>({std::make_shared<SpaceAtom>(Unit::MU, 8.0, 0.0, 0.0), SymbolAtom::get(L"shortparallel")});
auto raiseAtom = std::make_shared<RaiseAtom>(ra, std::make_shared<TeXLength>(Unit::MU, 3.0), nullptr, nullptr);
auto lapAtom = std::make_shared<LapedAtom>(raiseAtom, L'r');
auto raiseAtom2 = std::make_shared<RaiseAtom>(SymbolAtom::get(L"equals"), std::make_shared<TeXLength>(Unit::MU, -3.0), nullptr, nullptr);
auto ra2 = make_shared_from_list<RowAtom>({lapAtom, raiseAtom2});
auto result = std::make_shared<TypedAtom>(TYPE_RELATION, ra2);
return result;

如代码所示,如果从最后的结果TypedAtom节点上推断出它的TTS文本为“平行且等于”,十分困难。针对这个问题,引擎定义了一个特殊的节点,ContainAtom,从命令开始就截取到名字,同时它不会影响原先的渲染逻辑。在getSpeechText方法中直接返回名字即可,无需推断过程。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
class ContainerAtom : public Atom {
private:
std::shared_ptr<Atom> base;
std::wstring description;
public:
ContainerAtom(const std::shared_ptr<Atom>& atom, const std::wstring& desctiption = L"");
virtual std::wstring getSpeechText() override;
......
}

std::wstring ContainerAtom::getSpeechText() {
std::wstring speechText = Configuration::Instance().getSpeechText(description);
return speechText;
}

那么上述代码可以改造为:

1
2
3
4
5
6
7
8
9
shared_ptr<Atom> Commands::CommandEqualParallel::newI(const std::shared_ptr<TeXParser> &tp) {
std::shared_ptr<RowAtom> ra = make_shared_from_list<RowAtom>({std::make_shared<SpaceAtom>(Unit::MU, 8.0, 0.0, 0.0), SymbolAtom::get(L"shortparallel")});
auto raiseAtom = std::make_shared<RaiseAtom>(ra, std::make_shared<TeXLength>(Unit::MU, 3.0), nullptr, nullptr);
auto lapAtom = std::make_shared<LapedAtom>(raiseAtom, L'r');
auto raiseAtom2 = std::make_shared<RaiseAtom>(SymbolAtom::get(L"equals"), std::make_shared<TeXLength>(Unit::MU, -3.0), nullptr, nullptr);
auto ra2 = make_shared_from_list<RowAtom>({lapAtom, raiseAtom2});
auto result = std::make_shared<TypedAtom>(TYPE_RELATION, ra2);
return std::make_shared<ContainerAtom>(std::make_shared<TypedAtom>(TYPE_RELATION, result), L"平行且等于");
}

参数窃取的艺术

1
37^\circ\rm{C}

这个latex文本的最终渲染效果是:,而语音文本应该为“37摄氏度”。

对于渲染逻辑来说,实际上非常简单,挨着绘制3个节点即可(如栈所示),然而要推理TTS文本却比较麻烦,问题在于他们不在一颗节点上。如图所示,在LaTeX文本解析的过程中,实际上会生成一个“命令栈”,正常情况下这些命令正常出栈即可,然而此时由于命令和命令之间有一些关联关系,需要做一些特殊处理:

关于 LaTeX 的 TTS 朗读这件事:参数窃取的艺术(图 3)

在CommandRm进行闭合的时候,做一些判定。

  1. 先把栈顶的CommandRm出栈,同时要判定当前的CommandRm的内容为C;
  2. 继续判定当前栈顶的命令类型是否为SubSupCom,并且其sub为空,sup为°;
  3. 1和2都满足的前提下,将SubSupCom的sup窃取过来,并结合当前的内容C,一起生成一个新的SubSupCom,并将其放置于ContainerAtom中,命名为“摄氏度”;
  4. 如果1或者2不满足,走正常的出栈逻辑
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
bool CommandRm::close(const std::shared_ptr<TeXParser>& tp) {
auto a = size->simplify();
tp->pop();

auto secondTop = tp->peek();
if (std::dynamic_pointer_cast<CharAtom>(a) != nullptr &&
std::static_pointer_cast<CharAtom>(a)->getCharacter() == L'C' &&
std::dynamic_pointer_cast<SubSupCom>(secondTop) &&
std::static_pointer_cast<SubSupCom>(secondTop)->getSup()) {
auto sup = std::static_pointer_cast<SubSupCom>(secondTop)->getSup();
if (std::dynamic_pointer_cast<SymbolAtom>(sup) != nullptr && std::static_pointer_cast<SymbolAtom>(sup)->getUnicode() == L'∘') {
std::static_pointer_cast<SubSupCom>(secondTop)->setSup(nullptr);
auto subsupAtom = SubSupCom::get(EmptyAtom::get(), nullptr, sup);
std::vector<std::shared_ptr<Atom>> atoms{subsupAtom, std::make_shared<RomanAtom>(a)};
auto ra = std::make_shared<RowAtom>(atoms);
auto result = std::make_shared<ContainerAtom>(ra, L"摄氏度");
tp->addToConsumer(result);
}
return true;
}

std::shared_ptr<Atom> at = newI(tp, a);
auto last = tp->getLastAtom();
tp->closeConsumer(at);
return true;
}

入栈出栈规则

标准的绝对值表示方式是这样的,因为很容易判断左右,所以生成一个绝对值的节点也比较简单

1
\lvert xxx \rvert

然而有的情况下,Latex会直接用“|”来表达绝对值

1
|a-1|=0

由于无法区分左右,因此需要通过入栈出栈的方式来判定是否是绝对值,并将绝对值里面的内容进行聚合,最终生成一个FencedAtom节点

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
std::vector<std::shared_ptr<Atom>> RowAtom::getElementsByAggregatingABSSymbols() {
// extract abs
std::stack<std::shared_ptr<Atom>> stack;
std::vector<std::shared_ptr<Atom>> atoms;
std::vector<std::shared_ptr<Atom>> newElements;
for (auto& e : elements) {
if (std::dynamic_pointer_cast<SymbolAtom>(e) != nullptr && std::static_pointer_cast<SymbolAtom>(e)->getUnicode() == L'|') {
if (stack.empty()) {
// push sentinel
stack.push(e);
} else {
// make a FencedAtom
std::shared_ptr<RowAtom> ra = std::make_shared<RowAtom>(atoms);
auto fenceAtom = std::make_shared<FencedAtom>(ra->simplify(), std::static_pointer_cast<SymbolAtom>(e), std::static_pointer_cast<SymbolAtom>(e));
atoms.clear();
newElements.push_back(fenceAtom);

// pop sentinel
stack.pop();
}
} else {
if (stack.empty()) {
newElements.push_back(e);
} else {
atoms.push_back(e);
}
}
}

if (!stack.empty()) {
newElements.push_back(stack.top());
for (auto& ele : atoms) {
newElements.push_back(ele);
}
}
return newElements;
}

而FencedAtom节点TTS文本的生成逻辑如下所示:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
std::wstring FencedAtom::getSpeechText() {
std::wstring speechText = L"";
std::wstring leftSpeechText = left ? left->getSpeechText() : L"";
std::wstring rightSpeechText = right ? right->getSpeechText() : L"";
std::wstring baseSpeechText = base->getSpeechText();

bool isArrayAtom = std::dynamic_pointer_cast<ArrayAtom>(base) != nullptr;

if (leftSpeechText == L"|" && rightSpeechText == L"|") {
if (isArrayAtom) {
return L"行列式 " + baseSpeechText;
} else {
if (std::dynamic_pointer_cast<UnderOverArrowAtom>(base) != nullptr) {
return baseSpeechText + L"的模";
} else {
return baseSpeechText + L"的绝对值";
}
}
}
......
}

从中也可以看出,|xxx|除了表达绝对值,还可以表达“模”和“行列式”

二义性读法

有些符号在不同的场景下有不同的读法,因此需要做一些判定。

负 or 减?

-,在-b中应该读作“负”,(-b)中也应该读“负”,而在a-b中应该读作“减”,规则如下:

  1. 如果前一个符号为空,读“负”;
  2. 如果前一个符号的类型为SymbolAtom
    1. 如果其内容为(、[,读“负”;
    2. 否则读“减”;
  3. 剩下的读“减”;

和 - 类似的符号还有如下符号,就不再详细展开:

  1. ±,也存在加减和正负的歧义读法
  2. +,存在正和加的歧义读法

点 or 乘以 or 点乘

·,有的情况下应该读“点”,有的情况下应该读“乘以”,还有的情况都“点乘”,规则如下:

  1. 如果前面的符号或者后面的符号为空,读“点”;
  2. 如果前后的符号同时为向量,读“点乘”;
  3. 剩下的读“乘以”;

实际上·还可以组合,形成不同的读法,例如···表达省略号或者余数。

隐形符号

有的情况下,有些符号是缺失的,但是TTS文本还必须把它们包含进来。 以乘号为例,例如(a+b)(c+d),或者2(a+b)中间必须加一个“乘以”,才符合朗读习惯。规则如下:

  1. 如果当前符号是FencedAtom,且内容为(xxx)的形式
    1. 如果上一个符号是CharAtom,补充“乘以”;
    2. 如果前一个符号是FencedAtom,且内容为(xxxhe)的形式,补充“乘以”;
    3. 不做处理;
  2. 不做处理;

假分数

有些符号,虽然逻辑上应该是一个整体,但是渲染上是可以独立的,例如假分数:,它的latex 文本为“3\frac{1}{2}”。渲染引擎会解析成前后两个Atom,一个CharAtom,表示3,另一个FracAtom,表示1/2,对于渲染来说,他们之间无需有什么瓜葛,只需要依次绘制即可,因为渲染只需要表形。而对于TTS文本,他们之间是有语义关联的,因此如果当前Atom为FracAtom,需要结合前一个Atom进行结合判定是否有可能组成假分数。

发音不准

在测试过程中,会有一些发音不准的情况,那么此时可以借助 TTS 引擎的 SSML技术 来纠正发音

1
2
3
4
5
6
7
8
// a和A
<phoneme alphabet=\"ipa\" ph=\"eɪ\">a</phoneme>g

// x和X
<phoneme alphabet=\"ipa\" ph=\"eɪks\">x</phoneme>

// 2
经常被读为“两”,可以直接翻译为“二”

化学规则

化学的TTS读法和数学完全不同,这是因为化学涉及到一些化学式学名、化学方程式、离子等的识别,基本上无法复用已有的树形遍历规则。这意味着为了实现化学的TTS能力,需要构建一套完全不同于数学的框架。

树结构局部打平

考虑下面的化学式:

1
\ce{H2SO4}
关于 LaTeX 的 TTS 朗读这件事:树结构局部打平(图 4)

其生成的节点树如图所示,如果还是按照前文的树形遍历方法来读,很难将其与“硫酸”这个名字关联起来,这个矛盾也主要来自于树形结构和线性拆分查找之间的天然冲突。考虑到大部分化学的结构都比较扁平,大部分分子式的层次并不会特别深(这里面以ScriptsAtom居多,用于表达化学式的右下角标),所以可以考虑局部打平树结构,即在读ScriptsAtom的时候,不再去遍历其子节点,而是按照某种规则将其抹平为一层。

具体规则如下,由于ScriptsAtom有base、subscript和superscript 3个元素,其打平规则如下:将每个元素转成字符串,然后下角标前面添加_,上角标前面添加^,最后拼接到一起

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
class ScriptsAtom : public Atom, public HasTrueBase {
protected:
std::shared_ptr<Atom> base;
std::shared_ptr<Atom> subscript;
std::shared_ptr<Atom> superscript;
......
}

std::wstring ScriptsAtom::toString() {
std::wstring key = L"";
if (base != nullptr) key += base->toString();
if (subscript != nullptr) key += L"_" + subscript->toString();
if (superscript != nullptr) key += L"^" + superscript->toString();
return key;
}

在这样的规则下,前面的树结构被打平为如下图所示:

关于 LaTeX 的 TTS 朗读这件事:树结构局部打平(图 5)

化学式的识别

在打平的基础上,遍历上述化学式的TTS文本结果依次为H_2、S、O_4,如何将这几个散装的文本转换为化学式的学名呢?字典映射可能是一种方式,但是仔细考虑会发现有很多问题无法解决:

  1. 在遍历的时候,如何确定H_2SO_4就是一个组呢?
  2. 又如何来确定H_2SO_4就有对应的化学学名呢?
  3. 如果没有学名,又如何回退呢?(毕竟H_2S也有对应的学名硫化氢)

如果再仔细考虑下,会发现这里的问题和搜索引擎高度相似:当你输入某些字符的时候,搜索引擎就能展示一系列的联想词语。

关于 LaTeX 的 TTS 朗读这件事:化学式的识别(图 6)

因此可以参考搜索引擎的做法,引入Trie树,来解决化学式学名的识别问题

关于 LaTeX 的 TTS 朗读这件事:化学式的识别(图 7)

如图所示,这是构建的化学式学名的Trie树,每个节点都存储着一个名字(如果有的话),用来表达从根节点到当前节点的路径代表的化学式。而搜索过程采用贪婪的搜索算法:

  1. 当输入H_2,来到了红色节点,因为有学名,记录下学名“氢气”;
  2. 当继续输入S,来到了绿色节点,同样有学名,覆盖学名为“硫化氢”;
  3. 当继续输入O_4,来到了蓝色节点,同样有学名,覆盖学名为“硫酸”;

至此搜索完毕,最后获取到的化学式学名为“硫酸”,核心代码如下所示

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
std::wstring ChemTTSEngine::getSpeechText(const std::shared_ptr<RowAtom> &atom) {
std::wstring result;
TrieNode *root = Trie::Instance().root;
for (int i = 0; i < elements.size(); ++i) {
while (root != NULL && i + step < elements.size()) {
......
std::wstring key = elements[i + step]->toString();
root = root->find(key);
step++;
if(root != NULL && root->name != NULL) {
validStep = step;
temp = *root->name;
}
}

root = Trie::Instance().root;
step = 0;
}
......
}

化学式数据表的构建

由于涉及到化学式学名的识别逻辑,所以自然需要建设一套化学式学名数据库。

参考 Wikipedia 构建了一些数据表,预计最终的规模应该在3000~4000,甚至更多。

  1. 无机化合物列表
  2. 有机化合物列表

数据表中的Key值有一些构建规则:

  1. 字符和字符之间用 # 隔开;
  2. 数字和数字之间保持连续;
  3. 对于ScriptsAtom,下角标添加_前缀,上角标添加^前缀,并且保持一个整体
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
std::unordered_map<std::wstring, std::wstring>& ChemTTSDatabase::getChemicalNameMap() {
static std::unordered_map<std::wstring, std::wstring> nameMap = {
// 元素
{L"H", L"氢"},
{L"H#e", L"氦"},
{L"L#i", L"锂"},
{L"B#e", L"铍"},
{L"B", L"硼"},
{L"C", L"碳"},
......

// 单质
{L"H_2", L"氢气"},
{L"N_2", L"氮气"},
{L"O_2", L"氧气"},
{L"O_3", L"臭氧"},
{L"F_2", L"氟气"},
{L"C#l_2", L"氯气"},
{L"B#r_2", L"溴单质"},
{L"I_2", L"碘单质"},
{L"P_4", L"白磷"},
......

// 化合物
{L"K#F" , L"氟化钾"},
{L"K#C#l" , L"氯化钾"},
{L"K#B#r" , L"溴化钾"},
{L"K#I" , L"碘化钾"},
{L"K#O#H" , L"氢氧化钾"},
{L"K#H#C#O_3" , L"碳酸氢钾"},
......

// 离子
{L"H^+", L"氢离子"},
{L"L#i^+", L"锂离子"},
{L"O^2-", L"氧离子"},
{L"F^-", L"氟离子"},
{L"N#a^+", L"钠离子"},
{L"M#g^2+", L"镁离子"},
{L"A#l^3+", L"铝离子"},
......

// 有机物
{L"C#H_4" , L"甲烷"},
{L"C_6#H_12#O_6" , L"葡萄糖"},
{L"C_12#H_22#O_11" , L"蔗糖"},
{L"(#C_6#H_10#O_5#)_n" , L"淀粉"},
{L"C_3#H_6#O_3" , L"乳酸"},
{L"N_2#H_4" , L"肼"},
{L"N#H_3" , L"氨气"},
......

// 核素读法 isotope
{L"_6^12#C", L"碳6 12"},
{L"_6^13#C", L"碳6 13"},
{L"_8^18#O", L"氧8 18"},
{L"^12#C", L"碳12"},
{L"^206#P#b", L"铅206"},
{L"^37#C#l", L"氯37"},

......
}

这个体力活可以交给ChatGPT,教给它一些规则,帮忙构建数据库

化学式数据表的加载

如何构建化学式的Trie树呢?实际上这个构建过程和搜索过程是高度相似的,是Trie树节点的插入生成过程:依次寻找节点,如果没有就创建对应的节点。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
struct TrieNode {
std::wstring *name;
std::unordered_map<std::wstring, TrieNode *> children;

TrieNode();
void insert(const std::wstring& s, const std::wstring& name);
TrieNode *find(const std::wstring& s);
};

struct Trie {
TrieNode *root;
Trie();
static Trie& Instance();
};


Trie::Trie() {
root = new TrieNode();
auto& map = ChemTTSDatabase::getChemicalNameMap();
for (auto& kv : map) {
root->insert(kv.first, kv.second);
}
}

void TrieNode::insert(const std::wstring& s, const std::wstring& name) {
TrieNode *cur = this;
std::vector<std::wstring> elements = StringHelper::split(s, L'#');
for (auto& e : elements) {
auto& children = cur->children;
if (children.find(e) == children.end()) {
children[e] = new TrieNode();
}
cur = children[e];
}
cur->name = new std::wstring(name);
}

化学方程式的识别

在已经识别化学式的基础上,来进一步来识别化学方程式。相比于化学式,化学方程式包含了以下概念:

关于 LaTeX 的 TTS 朗读这件事:化学方程式的识别(图 8)

因此定义了以下数据结构,并且把是否有Equation作为是否是化学方程式最根本的判断。

1
2
3
4
5
6
7
8
9
enum class ChemElementType {
Molecular, // 化学式
Coefficient, // 系数
StateOfMatter, // 物质状态
Combine, // +
Equation, // =、->
Condition, // 加热、高温、催化剂等
Undefined,
};

一般情况下将遍历出来的元素入栈,如果碰到XArrowAtom或者XLongequalAtom等,会认为当前是一个化学方程式,那么在出栈的时候,会给没有系数的化学式(默认为1)添加系数。如果不是化学方程式,显然没有必要去添加系数。

核心代码如下所示:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
for (int i = 0; i < elements.size(); ++i) {
// 识别化学式逻辑
......

// 识别化学方程式的元素
auto& e = elements[start];
if (std::dynamic_pointer_cast<SymbolAtom>(e)) {
std::shared_ptr<SymbolAtom> sa = std::static_pointer_cast<SymbolAtom>(e);
switch (sa->getUnicode()) {
case L'+' :
stack.push(std::make_shared<ChemElement>(L"和", ChemElementType::Combine));
break;
case L'-':
stack.push(std::make_shared<ChemElement>(L"失去", ChemElementType::Combine));
break;
case L'↑':
stack.push(std::make_shared<ChemElement>(L"气体", ChemElementType::StateOfMatter));
break;
case L'↓':
stack.push(std::make_shared<ChemElement>(L"沉淀", ChemElementType::StateOfMatter));
break;
default:
stack.push(std::make_shared<ChemElement>(e->getSpeechText(), ChemElementType::Undefined));
break;
}
} else if (std::dynamic_pointer_cast<XArrowAtom>(e) || std::dynamic_pointer_cast<XLongequalAtom>(e)) {
// 判断是否是化学方程式**
stack.push(std::make_shared<ChemElement>(e->getSpeechText(), ChemElementType::Equation));
isChemEquation = true;
} else {
std::wstring text = e->getSpeechText();
if (text.length() > 0) {
if (std::all_of(text.begin(), text.end(), ::isdigit)) {
// 判断是否是化学式的系数**
stack.push(std::make_shared<ChemElement>(text, ChemElementType::Coefficient));
} else {
stack.push(std::make_shared<ChemElement>(text, ChemElementType::Undefined));
}
}
}
}

// 系数添加逻辑
std::shared_ptr<ChemElement> top = nullptr;
while (!stack.empty()) {
top = stack.top();
stack.pop();
if (isChemEquation && top->type == ChemElementType::Molecular && !stack.empty() && stack.top()->type != ChemElementType::Coefficient) {
if (stack.top()->name.find(L"分之") != std::wstring::npos) {
result = L"个" + top->name + result;
} else {
result = L"1个" + top->name + result;
}
} else if (isChemEquation && top->type == ChemElementType::Coefficient) {
std::wstring temp = top->name;
while (!stack.empty() && stack.top()->type == ChemElementType::Coefficient) {
temp = stack.top()->name + temp;
stack.pop();
}
result = temp + L"个" + result;
} else {
result = top->name + result;
}
}
if (isChemEquation && top->type == ChemElementType::Molecular) {
result = L"1个" + result;
}

上述化学方程式最后的TTS文本输出如下:

1
2个过氧化钠和2个水在加热的条件下反应生成4个氢氧化钠和1个氧气气体

浓度的读法

关于 LaTeX 的 TTS 朗读这件事:浓度的读法(图 9)

离子浓度的读法不同于化学方程式,中间的等号就是表达等于的意思,所以只需要识别浓度c(xxx)即可,还是采用类似于绝对值的进栈出栈的方式,来判定是否在表达浓度,核心代码如下所示:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
std::vector<std::shared_ptr<Atom>> ChemTTSEngine::getElementsByAggregatingMolaritySymbols(const std::vector<std::shared_ptr<Atom>>& elements) {
// extract c(xxx)
std::stack<std::shared_ptr<Atom>> stack;
std::vector<std::shared_ptr<Atom>> atoms;
std::vector<std::shared_ptr<Atom>> newElements;
for (int i = 0; i < elements.size(); ++i) {
auto& e = elements[i];
if (std::dynamic_pointer_cast<CharAtom>(e) != nullptr &&
std::static_pointer_cast<CharAtom>(e)->getCharacter() == L'c' &&
i + 1 < elements.size() &&
std::dynamic_pointer_cast<SymbolAtom>(elements[i+1]) != nullptr &&
std::static_pointer_cast<SymbolAtom>(elements[i+1])->getUnicode() == L'(') {
stack.push(elements[i+1]);
stack.push(elements[i]);
i += 1;
} else if(std::dynamic_pointer_cast<SymbolAtom>(e) != nullptr && std::static_pointer_cast<SymbolAtom>(e)->getUnicode() == L')') {
if (!stack.empty()) {
stack.pop();
stack.pop();

std::shared_ptr<RowAtom> ra = std::make_shared<RowAtom>(atoms);
ra->setMathMode(false);
newElements.push_back(std::make_shared<ContainerAtom>(ra->simplify(), ra->simplify()->getSpeechText() + L"的浓度"));
atoms.clear();
} else {
newElements.push_back(e);
}
} else {
if (stack.empty()) {
newElements.push_back(e);
} else {
atoms.push_back(e);
}
}
}

if (!stack.empty()) {
while (!stack.empty()) {
newElements.push_back(stack.top());
stack.pop();
}
for (auto& ele : atoms) {
newElements.push_back(ele);
}
}
return newElements;
}

读法如下:

1
次氯酸的浓度 加 次氯酸根离子的浓度 等于  碳酸氢根离子的浓度 加 碳酸的浓度

结晶水合物

化学里面有许多物质在水溶液里析出,形成晶体时常结合一定数目的水分子,这样的水分子叫结晶水合物。他们的读法都是“x 水合 y“,x指水的个数,y指·前面的化合物名称,例如:

  • CuSO4·5H2O :五水合硫酸铜
  • Na2CO3·10H2O :十水合碳酸钠

如果将这些结晶水都存储到表中,会有 2 个问题

  1. 一个是无法穷举,会产生遗漏;
  2. 另一个是存在着极大的浪费

如果能提取到结晶水合物里水的个数,那么可以一举两得:只要在数据表中查询出前面的名称,最后的化学名称即可确定。具体思路如下:

遍历 Trie 树的过程中,如果碰到“·”符号,确认后面的物质是否是数字和H2O,或者是H2O,则跳出循环,结合前面遍历出来的化学符号y,组成最终的名称: x 水合 y

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
for (int i = 0; i < elements.size(); ++i) {
while (root != NULL && i + step < elements.size()) {

// 如果碰到·
if (std::dynamic_pointer_cast<SymbolAtom>(elements[i+step]) && std::static_pointer_cast<SymbolAtom>(elements[i+step])->getUnicode() == L'·' && temp.length() > 0) {
j = i + step + 1;

// 确定·后面数字
while (j < elements.size() && std::dynamic_pointer_cast<CharAtom>(elements[j]) && std::isdigit( std::static_pointer_cast<CharAtom>(elements[j])->getCharacter())) {
unit += std::static_pointer_cast<CharAtom>(elements[j])->getCharacter();
j++;
}
// 以及数字后面的化学式学名
root = Trie::Instance().root;
while (root != NULL && j < elements.size()) {
std::wstring key = elements[j]->toString();
root = root->find(key);
if (root != NULL) {
j++;
if( root->name != NULL) postName = *root->name;
} else {
break;
}
}
// 跳出循环
break;
}

// 常规查找化学分子式的学名
std::wstring key = elements[i + step]->toString();
root = root->find(key);
step++;
if(root != NULL && root->name != NULL) {
validStep = step;
temp = *root->name;
}
}

......

if (validStep != 0) {
if (postName.length() > 0 && postName == L"水") {
// 如果·后面为数字+水的形式,表示是结晶水合物,需要根据“x 水合 y”重新命名
i = j - 1;
temp = (unit.length() > 0 ? unit : L"一") + "水合" + temp;
postName = L"";
unit = L"";
} else {
i = start + validStep - 1;
}
if (temp.length() > 0) {
stack.push(std::make_shared<ChemElement>(temp));
}
}

......

但是也有一些水土不服的情况,例如 NH3·H2O,如果按照上述规则,最后的名称为“一水合氨气”,会有一些别扭,正确的名称应该是“一水合氨”,针对这种情况,可以考虑加一些白名单来解决:遇到·的时候先查表,查表失败的情况下才走上述逻辑。

1
{L"N#H_3#·#H_2#O" , L"一水合氨"},

总结

冰冻三尺非一日之寒,LaTeX的TTS文本能力绝非一蹴而就,仍然需要较长的人力和时间投入进行持续的打磨

-------------本文结束 感谢您的阅读-------------
坚持原创技术分享,您的支持将鼓励我继续创作!

本文标题:关于 LaTeX 的 TTS 朗读这件事

文章作者:lingyun

发布时间:2024年02月02日 - 23:02

最后更新:2026年10月08日 - 00:10

原始链接:https://tsuijunxi.github.io/2024/02/02/%E5%85%B3%E4%BA%8E%20LaTeX%20%E7%9A%84%20TTS%20%E6%9C%97%E8%AF%BB%E8%BF%99%E4%BB%B6%E4%BA%8B/

许可协议: 署名-非商业性使用-禁止演绎 4.0 国际 转载请保留原文链接及作者。