2018-06-02 08:59:26 -04:00
|
|
|
from __future__ import absolute_import
|
2018-03-30 18:19:23 -07:00
|
|
|
from constants import *
|
2017-06-06 16:03:53 -07:00
|
|
|
|
2018-06-02 08:59:26 -04:00
|
|
|
from .svg_mobject import SVGMobject
|
|
|
|
from .svg_mobject import VMobjectFromSVGPathstring
|
2018-03-30 18:19:23 -07:00
|
|
|
from utils.config_ops import digest_config
|
2018-05-05 20:16:20 -07:00
|
|
|
from utils.strings import split_string_list_to_isolate_substring
|
2018-05-08 16:15:28 -07:00
|
|
|
from utils.tex_file_writing import tex_to_svg_file
|
2018-05-09 14:05:32 -07:00
|
|
|
from mobject.geometry import Line
|
2018-03-31 18:05:02 -07:00
|
|
|
from mobject.types.vectorized_mobject import VGroup
|
|
|
|
from mobject.types.vectorized_mobject import VectorizedPoint
|
2017-06-06 16:03:53 -07:00
|
|
|
|
2018-03-30 18:42:32 -07:00
|
|
|
import operator as op
|
2018-06-02 08:59:26 -04:00
|
|
|
from functools import reduce
|
2015-10-28 17:18:50 -07:00
|
|
|
|
2018-05-05 19:41:08 -07:00
|
|
|
TEX_MOB_SCALE_FACTOR = 0.05
|
2018-04-06 13:58:59 -07:00
|
|
|
|
2018-05-05 20:16:20 -07:00
|
|
|
|
2016-04-20 19:24:54 -07:00
|
|
|
class TexSymbol(VMobjectFromSVGPathstring):
|
2016-07-19 11:08:31 -07:00
|
|
|
def pointwise_become_partial(self, mobject, a, b):
|
2018-04-06 13:58:59 -07:00
|
|
|
# TODO, this assumes a = 0
|
2016-04-20 19:24:54 -07:00
|
|
|
if b < 0.5:
|
2018-04-06 13:58:59 -07:00
|
|
|
b = 2 * b
|
2017-06-21 22:55:10 -07:00
|
|
|
added_width = 1
|
2016-04-20 19:24:54 -07:00
|
|
|
opacity = 0
|
|
|
|
else:
|
2018-04-06 13:58:59 -07:00
|
|
|
added_width = 2 - 2 * b
|
|
|
|
opacity = 2 * b - 1
|
2016-04-20 19:24:54 -07:00
|
|
|
b = 1
|
2016-07-19 11:08:31 -07:00
|
|
|
VMobjectFromSVGPathstring.pointwise_become_partial(
|
2016-04-20 19:24:54 -07:00
|
|
|
self, mobject, 0, b
|
|
|
|
)
|
2018-04-06 13:58:59 -07:00
|
|
|
self.set_stroke(width=added_width + mobject.get_stroke_width())
|
|
|
|
self.set_fill(opacity=opacity)
|
|
|
|
|
2016-04-20 19:24:54 -07:00
|
|
|
|
2018-05-05 19:41:08 -07:00
|
|
|
class SingleStringTexMobject(SVGMobject):
|
2016-02-27 16:32:53 -08:00
|
|
|
CONFIG = {
|
2018-04-06 13:58:59 -07:00
|
|
|
"template_tex_file": TEMPLATE_TEX_FILE,
|
|
|
|
"stroke_width": 0,
|
|
|
|
"fill_opacity": 1.0,
|
|
|
|
"should_center": True,
|
|
|
|
"height": None,
|
|
|
|
"organize_left_to_right": False,
|
|
|
|
"propagate_style_to_family": True,
|
|
|
|
"alignment": "",
|
2015-10-28 17:18:50 -07:00
|
|
|
}
|
2018-04-06 13:58:59 -07:00
|
|
|
|
2018-05-05 19:41:08 -07:00
|
|
|
def __init__(self, tex_string, **kwargs):
|
|
|
|
digest_config(self, kwargs)
|
|
|
|
assert(isinstance(tex_string, str))
|
2018-05-05 19:49:25 -07:00
|
|
|
self.tex_string = tex_string
|
2016-11-07 11:05:41 -08:00
|
|
|
file_name = tex_to_svg_file(
|
2018-05-05 19:49:25 -07:00
|
|
|
self.get_modified_expression(tex_string),
|
2016-11-07 11:05:41 -08:00
|
|
|
self.template_tex_file
|
|
|
|
)
|
2018-04-06 13:58:59 -07:00
|
|
|
SVGMobject.__init__(self, file_name=file_name, **kwargs)
|
2018-05-05 19:41:08 -07:00
|
|
|
if self.height is None:
|
|
|
|
self.scale(TEX_MOB_SCALE_FACTOR)
|
2016-07-12 10:34:35 -07:00
|
|
|
if self.organize_left_to_right:
|
|
|
|
self.organize_submobjects_left_to_right()
|
2016-04-17 12:59:53 -07:00
|
|
|
|
2018-05-05 19:41:08 -07:00
|
|
|
def get_modified_expression(self, tex_string):
|
|
|
|
result = self.alignment + " " + tex_string
|
2016-09-10 17:35:15 -07:00
|
|
|
result = result.strip()
|
2017-04-20 13:30:51 -07:00
|
|
|
result = self.modify_special_strings(result)
|
2016-07-21 15:16:49 -07:00
|
|
|
return result
|
2016-07-21 11:00:45 -07:00
|
|
|
|
2017-04-20 13:30:51 -07:00
|
|
|
def modify_special_strings(self, tex):
|
|
|
|
tex = self.remove_stray_braces(tex)
|
2018-05-08 16:15:28 -07:00
|
|
|
should_add_filler = reduce(op.or_, [
|
|
|
|
# Fraction line needs something to be over
|
|
|
|
tex == "\\over",
|
|
|
|
tex == "\\overline",
|
|
|
|
# Makesure sqrt has overbar
|
|
|
|
tex == "\\sqrt",
|
|
|
|
# Need to add blank subscript or superscript
|
|
|
|
tex.endswith("_"),
|
|
|
|
tex.endswith("^"),
|
|
|
|
])
|
|
|
|
if should_add_filler:
|
|
|
|
filler = "{\\quad}"
|
|
|
|
tex += filler
|
|
|
|
|
2017-08-25 17:56:55 -07:00
|
|
|
if tex == "\\substack":
|
2018-05-19 11:09:59 -07:00
|
|
|
tex = "\\quad"
|
|
|
|
|
2017-08-29 00:04:25 -07:00
|
|
|
if tex == "":
|
|
|
|
tex = "\\quad"
|
2018-05-19 11:09:59 -07:00
|
|
|
|
|
|
|
# Handle imbalanced \left and \right
|
|
|
|
num_lefts, num_rights = [
|
|
|
|
len(filter(
|
|
|
|
lambda s: s[0] in "(){}[]|.\\",
|
|
|
|
tex.split(substr)[1:]
|
|
|
|
))
|
2018-06-02 08:59:26 -04:00
|
|
|
for substr in ("\\left", "\\right")
|
2018-05-19 11:09:59 -07:00
|
|
|
]
|
|
|
|
if num_lefts != num_rights:
|
|
|
|
tex = tex.replace("\\left", "\\big")
|
|
|
|
tex = tex.replace("\\right", "\\big")
|
2018-08-06 10:45:27 -07:00
|
|
|
|
|
|
|
for context in ["array"]:
|
|
|
|
begin_in = ("\\begin{%s}" % context) in tex
|
|
|
|
end_in = ("\\end{%s}" % context) in tex
|
|
|
|
if begin_in ^ end_in:
|
|
|
|
# Just turn this into a blank string,
|
|
|
|
# which means caller should leave a
|
|
|
|
# stray \\begin{...} with other symbols
|
|
|
|
tex = ""
|
2017-04-20 13:30:51 -07:00
|
|
|
return tex
|
|
|
|
|
2017-02-16 13:03:26 -08:00
|
|
|
def remove_stray_braces(self, tex):
|
|
|
|
"""
|
|
|
|
Makes TexMobject resiliant to unmatched { at start
|
|
|
|
"""
|
|
|
|
num_lefts, num_rights = [
|
|
|
|
tex.count(char)
|
|
|
|
for char in "{}"
|
|
|
|
]
|
2018-05-16 11:59:49 -07:00
|
|
|
while num_rights > num_lefts:
|
2018-05-08 16:15:28 -07:00
|
|
|
tex = "{" + tex
|
2018-05-16 11:59:49 -07:00
|
|
|
num_lefts += 1
|
|
|
|
while num_lefts > num_rights:
|
2018-05-08 16:15:28 -07:00
|
|
|
tex = tex + "}"
|
2018-05-16 11:59:49 -07:00
|
|
|
num_rights += 1
|
2017-02-16 13:03:26 -08:00
|
|
|
return tex
|
|
|
|
|
2016-08-23 13:38:33 -07:00
|
|
|
def get_tex_string(self):
|
|
|
|
return self.tex_string
|
|
|
|
|
2018-05-05 19:41:08 -07:00
|
|
|
def path_string_to_mobject(self, path_string):
|
|
|
|
# Overwrite superclass default to use
|
|
|
|
# specialized path_string mobject
|
|
|
|
return TexSymbol(path_string)
|
|
|
|
|
|
|
|
def organize_submobjects_left_to_right(self):
|
|
|
|
self.sort_submobjects(lambda p: p[0])
|
|
|
|
return self
|
|
|
|
|
|
|
|
|
|
|
|
class TexMobject(SingleStringTexMobject):
|
|
|
|
CONFIG = {
|
|
|
|
"arg_separator": " ",
|
2018-05-05 20:16:20 -07:00
|
|
|
"substrings_to_isolate": [],
|
2018-05-05 20:19:33 -07:00
|
|
|
"tex_to_color_map": {},
|
2018-05-05 19:41:08 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
def __init__(self, *tex_strings, **kwargs):
|
|
|
|
digest_config(self, kwargs)
|
2018-05-05 20:16:20 -07:00
|
|
|
tex_strings = self.break_up_tex_strings(tex_strings)
|
2018-05-05 19:41:08 -07:00
|
|
|
self.tex_strings = tex_strings
|
|
|
|
SingleStringTexMobject.__init__(
|
|
|
|
self, self.arg_separator.join(tex_strings), **kwargs
|
|
|
|
)
|
|
|
|
self.break_up_by_substrings()
|
2018-05-05 20:19:33 -07:00
|
|
|
self.set_color_by_tex_to_color_map(self.tex_to_color_map)
|
2018-05-05 19:41:08 -07:00
|
|
|
|
|
|
|
if self.organize_left_to_right:
|
|
|
|
self.organize_submobjects_left_to_right()
|
|
|
|
|
2018-05-05 20:16:20 -07:00
|
|
|
def break_up_tex_strings(self, tex_strings):
|
2018-05-05 20:19:33 -07:00
|
|
|
substrings_to_isolate = op.add(
|
|
|
|
self.substrings_to_isolate,
|
|
|
|
self.tex_to_color_map.keys()
|
|
|
|
)
|
2018-05-05 20:16:20 -07:00
|
|
|
split_list = split_string_list_to_isolate_substring(
|
2018-05-05 20:19:33 -07:00
|
|
|
tex_strings, *substrings_to_isolate
|
2018-05-05 20:16:20 -07:00
|
|
|
)
|
|
|
|
split_list = map(str.strip, split_list)
|
|
|
|
split_list = filter(lambda s: s != '', split_list)
|
|
|
|
return split_list
|
|
|
|
|
2018-05-05 19:41:08 -07:00
|
|
|
def break_up_by_substrings(self):
|
2017-06-06 16:03:53 -07:00
|
|
|
"""
|
2017-10-05 21:03:30 -05:00
|
|
|
Reorganize existing submojects one layer
|
2018-05-05 19:41:08 -07:00
|
|
|
deeper based on the structure of tex_strings (as a list
|
|
|
|
of tex_strings)
|
2017-06-06 16:03:53 -07:00
|
|
|
"""
|
2016-07-21 11:00:45 -07:00
|
|
|
new_submobjects = []
|
|
|
|
curr_index = 0
|
2018-05-05 19:49:25 -07:00
|
|
|
for tex_string in self.tex_strings:
|
|
|
|
sub_tex_mob = SingleStringTexMobject(tex_string, **self.CONFIG)
|
2017-06-06 16:03:53 -07:00
|
|
|
num_submobs = len(sub_tex_mob.submobjects)
|
|
|
|
new_index = curr_index + num_submobs
|
|
|
|
if num_submobs == 0:
|
2018-05-05 19:41:08 -07:00
|
|
|
# For cases like empty tex_strings, we want the corresponing
|
|
|
|
# part of the whole TexMobject to be a VectorizedPoint
|
|
|
|
# positioned in the right part of the TexMobject
|
|
|
|
sub_tex_mob.submobjects = [VectorizedPoint()]
|
|
|
|
last_submob_index = min(curr_index, len(self.submobjects) - 1)
|
|
|
|
sub_tex_mob.move_to(self.submobjects[last_submob_index], RIGHT)
|
2017-06-06 16:03:53 -07:00
|
|
|
else:
|
|
|
|
sub_tex_mob.submobjects = self.submobjects[curr_index:new_index]
|
2017-03-28 11:12:02 -07:00
|
|
|
new_submobjects.append(sub_tex_mob)
|
2016-07-21 11:00:45 -07:00
|
|
|
curr_index = new_index
|
|
|
|
self.submobjects = new_submobjects
|
2016-04-17 12:59:53 -07:00
|
|
|
return self
|
|
|
|
|
2018-04-06 13:58:59 -07:00
|
|
|
def get_parts_by_tex(self, tex, substring=True, case_sensitive=True):
|
2017-03-10 16:55:23 -08:00
|
|
|
def test(tex1, tex2):
|
2018-02-14 12:32:58 -08:00
|
|
|
if not case_sensitive:
|
|
|
|
tex1 = tex1.lower()
|
|
|
|
tex2 = tex2.lower()
|
|
|
|
if substring:
|
|
|
|
return tex1 in tex2
|
|
|
|
else:
|
|
|
|
return tex1 == tex2
|
2017-03-22 15:06:17 -07:00
|
|
|
|
2017-04-21 17:40:49 -07:00
|
|
|
return VGroup(*filter(
|
2018-04-06 13:58:59 -07:00
|
|
|
lambda m: test(tex, m.get_tex_string()),
|
2018-05-05 19:41:08 -07:00
|
|
|
self.submobjects
|
2017-04-21 17:40:49 -07:00
|
|
|
))
|
2017-03-25 12:18:33 -07:00
|
|
|
|
2017-03-22 15:06:17 -07:00
|
|
|
def get_part_by_tex(self, tex, **kwargs):
|
|
|
|
all_parts = self.get_parts_by_tex(tex, **kwargs)
|
|
|
|
return all_parts[0] if all_parts else None
|
2017-03-10 16:55:23 -08:00
|
|
|
|
2018-03-30 11:51:31 -07:00
|
|
|
def set_color_by_tex(self, tex, color, **kwargs):
|
2017-03-10 16:55:23 -08:00
|
|
|
parts_to_color = self.get_parts_by_tex(tex, **kwargs)
|
|
|
|
for part in parts_to_color:
|
2018-03-30 11:51:31 -07:00
|
|
|
part.set_color(color)
|
2016-08-18 12:54:04 -07:00
|
|
|
return self
|
|
|
|
|
2018-03-30 11:51:31 -07:00
|
|
|
def set_color_by_tex_to_color_map(self, texs_to_color_map, **kwargs):
|
2018-01-23 02:14:18 +08:00
|
|
|
for texs, color in texs_to_color_map.items():
|
|
|
|
try:
|
2018-05-05 19:41:08 -07:00
|
|
|
# If the given key behaves like tex_strings
|
2018-01-23 02:14:18 +08:00
|
|
|
texs + ''
|
2018-03-30 11:51:31 -07:00
|
|
|
self.set_color_by_tex(texs, color, **kwargs)
|
2018-01-23 02:14:18 +08:00
|
|
|
except TypeError:
|
|
|
|
# If the given key is a tuple
|
|
|
|
for tex in texs:
|
2018-03-30 11:51:31 -07:00
|
|
|
self.set_color_by_tex(tex, color, **kwargs)
|
2017-07-20 13:37:12 -07:00
|
|
|
return self
|
|
|
|
|
2017-05-05 11:19:10 -07:00
|
|
|
def index_of_part(self, part):
|
|
|
|
split_self = self.split()
|
|
|
|
if part not in split_self:
|
|
|
|
raise Exception("Trying to get index of part not in TexMobject")
|
2018-04-11 17:14:02 -07:00
|
|
|
return split_self.index(part)
|
2017-05-05 11:19:10 -07:00
|
|
|
|
|
|
|
def index_of_part_by_tex(self, tex, **kwargs):
|
|
|
|
part = self.get_part_by_tex(tex, **kwargs)
|
|
|
|
return self.index_of_part(part)
|
|
|
|
|
2018-05-07 13:32:47 -07:00
|
|
|
def split(self):
|
|
|
|
# Many old scenes assume that when you pass in a single string
|
|
|
|
# to TexMobject, it indexes across the characters.
|
|
|
|
if len(self.submobjects) == 1:
|
|
|
|
return self.submobjects[0].split()
|
|
|
|
else:
|
|
|
|
return super(TexMobject, self).split()
|
2018-04-11 17:14:02 -07:00
|
|
|
|
2018-04-06 13:58:59 -07:00
|
|
|
|
2015-10-28 17:18:50 -07:00
|
|
|
class TextMobject(TexMobject):
|
2016-02-27 16:32:53 -08:00
|
|
|
CONFIG = {
|
2018-04-06 13:58:59 -07:00
|
|
|
"template_tex_file": TEMPLATE_TEXT_FILE,
|
|
|
|
"alignment": "\\centering",
|
2015-10-28 17:18:50 -07:00
|
|
|
}
|
|
|
|
|
2018-04-06 13:58:59 -07:00
|
|
|
|
2017-10-19 14:31:55 -07:00
|
|
|
class BulletedList(TextMobject):
|
|
|
|
CONFIG = {
|
2018-04-06 13:58:59 -07:00
|
|
|
"buff": MED_LARGE_BUFF,
|
|
|
|
"dot_scale_factor": 2,
|
|
|
|
# Have to include because of handle_multiple_args implementation
|
|
|
|
"template_tex_file": TEMPLATE_TEXT_FILE,
|
|
|
|
"alignment": "",
|
2017-10-19 14:31:55 -07:00
|
|
|
}
|
2018-04-06 13:58:59 -07:00
|
|
|
|
2017-10-19 14:31:55 -07:00
|
|
|
def __init__(self, *items, **kwargs):
|
|
|
|
line_separated_items = [s + "\\\\" for s in items]
|
|
|
|
TextMobject.__init__(self, *line_separated_items, **kwargs)
|
|
|
|
for part in self:
|
|
|
|
dot = TexMobject("\\cdot").scale(self.dot_scale_factor)
|
|
|
|
dot.next_to(part[0], LEFT, SMALL_BUFF)
|
|
|
|
part.add_to_back(dot)
|
|
|
|
self.arrange_submobjects(
|
2018-04-06 13:58:59 -07:00
|
|
|
DOWN,
|
|
|
|
aligned_edge=LEFT,
|
|
|
|
buff=self.buff
|
2017-10-19 14:31:55 -07:00
|
|
|
)
|
|
|
|
|
2018-04-06 13:58:59 -07:00
|
|
|
def fade_all_but(self, index_or_string, opacity=0.5):
|
2017-10-19 14:31:55 -07:00
|
|
|
arg = index_or_string
|
|
|
|
if isinstance(arg, str):
|
|
|
|
part = self.get_part_by_tex(arg)
|
|
|
|
elif isinstance(arg, int):
|
|
|
|
part = self.submobjects[arg]
|
|
|
|
else:
|
|
|
|
raise Exception("Expected int or string, got {0}".format(arg))
|
|
|
|
for other_part in self.submobjects:
|
|
|
|
if other_part is part:
|
2018-04-06 13:58:59 -07:00
|
|
|
other_part.set_fill(opacity=1)
|
2017-10-19 14:31:55 -07:00
|
|
|
else:
|
2018-04-06 13:58:59 -07:00
|
|
|
other_part.set_fill(opacity=opacity)
|
2017-10-19 14:31:55 -07:00
|
|
|
|
2018-05-02 17:17:34 +02:00
|
|
|
|
|
|
|
class TexMobjectFromPresetString(TexMobject):
|
2018-05-08 16:15:28 -07:00
|
|
|
CONFIG = {
|
|
|
|
# To be filled by subclasses
|
|
|
|
"tex": None,
|
|
|
|
"color": None,
|
|
|
|
}
|
2018-05-02 17:17:34 +02:00
|
|
|
|
|
|
|
def __init__(self, **kwargs):
|
|
|
|
digest_config(self, kwargs)
|
|
|
|
TexMobject.__init__(self, self.tex, **kwargs)
|
|
|
|
self.set_color(self.color)
|
|
|
|
|
2018-05-09 14:05:32 -07:00
|
|
|
|
|
|
|
class Title(TextMobject):
|
|
|
|
CONFIG = {
|
|
|
|
"scale_factor": 1,
|
|
|
|
"include_underline": True,
|
|
|
|
"underline_width": FRAME_WIDTH - 2,
|
|
|
|
# This will override underline_width
|
|
|
|
"match_underline_width_to_text": False,
|
|
|
|
"underline_buff": MED_SMALL_BUFF,
|
|
|
|
}
|
|
|
|
|
|
|
|
def __init__(self, text, **kwargs):
|
|
|
|
TextMobject.__init__(self, text, **kwargs)
|
|
|
|
self.scale(self.scale_factor)
|
|
|
|
self.to_edge(UP)
|
|
|
|
if self.include_underline:
|
|
|
|
underline = Line(LEFT, RIGHT)
|
|
|
|
underline.next_to(self, DOWN, buff=self.underline_buff)
|
|
|
|
if self.match_underline_width_to_text:
|
|
|
|
underline.match_width(self)
|
|
|
|
else:
|
2018-08-08 10:30:52 -07:00
|
|
|
underline.set_width(self.underline_width)
|
2018-05-09 14:05:32 -07:00
|
|
|
self.add(underline)
|
|
|
|
self.underline = underline
|