Reconfigure NumberLine, the whole interface felt very weird

manimlib/mobject/number_line.py

@@ -1,5 +1,3 @@
-import operator as op
-
 from manimlib.constants import *
 from manimlib.mobject.geometry import Line
 from manimlib.mobject.numbers import DecimalNumber
@@ -14,71 +12,72 @@ from manimlib.utils.space_ops import normalize
 class NumberLine(Line):
     CONFIG = {
         "color": LIGHT_GREY,
-        "stroke_width": 2,
+        "stroke_width": 3,
-        "x_min": -FRAME_X_RADIUS,
+        # List of 2 or 3 elements, x_min, x_max, step_size
-        "x_max": FRAME_X_RADIUS,
+        "x_range": [-8, 8, 1],
+        # How big is one one unit of this number line in terms of absolute spacial distance
         "unit_size": 1,
         "include_ticks": True,
         "tick_size": 0.1,
-        "tick_frequency": 1,
+        "longer_tick_multiple": 1.5,
-        # Defaults to value near x_min s.t. 0 is a tick
+        "tick_offset": 0,
-        # TODO, rename this
-        "leftmost_tick": None,
         # Change name
-        "numbers_with_elongated_ticks": [0],
+        "numbers_with_elongated_ticks": [],
         "include_numbers": False,
-        "numbers_to_show": None,
+        "line_to_number_direction": DOWN,
-        "longer_tick_multiple": 2,
-        "number_at_center": 0,
-        "number_scale_val": 0.75,
-        "label_direction": DOWN,
         "line_to_number_buff": MED_SMALL_BUFF,
         "include_tip": False,
-        "tip_width": 0.25,
+        "tip_config": {},  # TODO
-        "tip_height": 0.25,
         "decimal_number_config": {
             "num_decimal_places": 0,
+            "height": 0.25,
         },
         "exclude_zero_from_default_numbers": False,
     }
 
-    def __init__(self, **kwargs):
+    def __init__(self, x_range=None, **kwargs):
         digest_config(self, kwargs)
-        start = self.unit_size * self.x_min * RIGHT
+        if x_range is not None:
-        end = self.unit_size * self.x_max * RIGHT
+            self.x_range = x_range
-        Line.__init__(self, start, end, **kwargs)
+        if len(self.x_range) == 2:
-        self.shift(-self.number_to_point(self.number_at_center))
+            self.x_range.append(1)
+
+        x_min, x_max, x_step = self.x_range
+        # A lot of old scenes pass in x_min or x_max explicitly,
+        # so this is just here to keep those workin
+        self.x_min = kwargs.get("x_min", x_min)
+        self.x_max = kwargs.get("x_max", x_max)
+        self.x_step = kwargs.get("x_step", x_step)
+
+        super().__init__(self.x_min * RIGHT, self.x_max * RIGHT, **kwargs)
+        self.scale(self.unit_size)
+        self.center()
 
-        self.init_leftmost_tick()
         if self.include_tip:
             self.add_tip()
         if self.include_ticks:
-            self.add_tick_marks()
+            self.add_ticks()
         if self.include_numbers:
             self.add_numbers()
 
-    def init_leftmost_tick(self):
+    def get_tick_range(self):
-        if self.leftmost_tick is None:
+        if self.include_tip:
-            self.leftmost_tick = op.mul(
+            x_max = self.x_max
-                self.tick_frequency,
+        else:
-                np.ceil(self.x_min / self.tick_frequency)
+            x_max = self.x_max + self.x_step
-            )
+        return np.arange(self.x_min, x_max, self.x_step)
 
-    def add_tick_marks(self):
+    def add_ticks(self):
-        tick_size = self.tick_size
+        ticks = VGroup()
-        self.tick_marks = VGroup(*[
+        for x in self.get_tick_range():
-            self.get_tick(x, tick_size)
+            size = self.tick_size
-            for x in self.get_tick_numbers()
+            if x in self.numbers_with_elongated_ticks:
-        ])
+                size *= self.longer_tick_multiple
-        big_tick_size = tick_size * self.longer_tick_multiple
+            ticks.add(self.get_tick(x, size))
-        self.big_tick_marks = VGroup(*[
+        if self.include_tip:
-            self.get_tick(x, big_tick_size)
+            ticks.remove(ticks[-1])
-            for x in self.numbers_with_elongated_ticks
+        self.add(ticks)
-        ])
+        self.ticks = ticks
-        self.add(
-            self.tick_marks,
-            self.big_tick_marks,
-        )
 
     def get_tick(self, x, size=None):
         if size is None:
@@ -90,36 +89,18 @@ class NumberLine(Line):
         return result
 
     def get_tick_marks(self):
-        return VGroup(
+        return self.tick_marks
-            *self.tick_marks,
-            *self.big_tick_marks,
-        )
-
-    def get_tick_numbers(self):
-        u = -1 if self.include_tip else 1
-        return np.arange(
-            self.leftmost_tick,
-            self.x_max + u * self.tick_frequency / 2,
-            self.tick_frequency
-        )
 
     def number_to_point(self, number):
         alpha = float(number - self.x_min) / (self.x_max - self.x_min)
-        return interpolate(
+        return interpolate(self.get_start(), self.get_end(), alpha)
-            self.get_start(), self.get_end(), alpha
-        )
 
     def point_to_number(self, point):
-        start_point, end_point = self.get_start_and_end()
+        start, end = self.get_start_and_end()
-        full_vect = end_point - start_point
+        unit_vect = normalize(end - start)
-        unit_vect = normalize(full_vect)
-
-        def distance_from_start(p):
-            return np.dot(p - start_point, unit_vect)
-
         proportion = fdiv(
-            distance_from_start(point),
+            np.dot(point - start, unit_vect),
-            distance_from_start(end_point)
+            np.dot(end - start, unit_vect),
         )
         return interpolate(self.x_min, self.x_max, proportion)
 
@@ -134,68 +115,47 @@ class NumberLine(Line):
     def get_unit_size(self):
         return (self.x_max - self.x_min) / self.get_length()
 
-    def default_numbers_to_display(self):
+    def get_number_mobject(self, x,
-        if self.numbers_to_show is not None:
-            return self.numbers_to_show
-        numbers = np.arange(
-            np.floor(self.leftmost_tick),
-            np.ceil(self.x_max),
-        )
-        if self.exclude_zero_from_default_numbers:
-            numbers = numbers[numbers != 0]
-        return numbers
-
-    def get_number_mobject(self, number,
                            number_config=None,
-                           scale_val=None,
                            direction=None,
                            buff=None):
+        if number_config is None:
+            number_config = {}
         number_config = merge_dicts_recursively(
-            self.decimal_number_config,
+            self.decimal_number_config, number_config
-            number_config or {},
         )
-        if scale_val is None:
-            scale_val = self.number_scale_val
         if direction is None:
-            direction = self.label_direction
+            direction = self.line_to_number_direction
-        buff = buff or self.line_to_number_buff
+        if buff is None:
+            buff = self.line_to_number_buff
 
-        num_mob = DecimalNumber(number, **number_config)
+        num_mob = DecimalNumber(x, **number_config)
-        num_mob.scale(scale_val)
         num_mob.next_to(
-            self.number_to_point(number),
+            self.number_to_point(x),
             direction=direction,
             buff=buff
         )
+        if x < 0:
+            # Align without the minus sign
+            num_mob.shift(num_mob[0].get_width() * LEFT / 2)
         return num_mob
 
-    def get_number_mobjects(self, *numbers, **kwargs):
+    def add_numbers(self, *x_values, **kwargs):
-        if len(numbers) == 0:
+        if len(x_values) == 0:
-            numbers = self.default_numbers_to_display()
+            x_values = self.get_tick_range()
-        return VGroup(*[
-            self.get_number_mobject(number, **kwargs)
-            for number in numbers
-        ])
 
-    def get_labels(self):
+        self.numbers = VGroup()
-        return self.get_number_mobjects()
+        for x in x_values:
-
+            self.numbers.add(self.get_number_mobject(x, **kwargs))
-    def add_numbers(self, *numbers, **kwargs):
-        self.numbers = self.get_number_mobjects(
-            *numbers, **kwargs
-        )
         self.add(self.numbers)
         return self
 
 
 class UnitInterval(NumberLine):
     CONFIG = {
-        "x_min": 0,
+        "x_range": [0, 1, 0.1],
-        "x_max": 1,
+        "unit_size": 10,
-        "unit_size": 6,
-        "tick_frequency": 0.1,
         "numbers_with_elongated_ticks": [0, 1],
-        "number_at_center": 0.5,
         "decimal_number_config": {
             "num_decimal_places": 1,
         }