ZoomedScene improvements

scene/zoomed_scene.py

@@ -2,6 +2,7 @@ import numpy as np
 
 from scene import Scene
 from mobject import Mobject
+from topics.geometry import Rectangle
 from camera import MovingCamera, Camera
 
 from helpers import *
@@ -9,50 +10,76 @@ from helpers import *
 class ZoomedScene(Scene):
     CONFIG = {
         "zoomed_canvas_space_shape" : (3, 3),
-        "zoomed_canvas_center" : None,
+        "zoomed_canvas_center"      : None,
-        "zoomed_canvas_corner" : UP+RIGHT,
+        "zoomed_canvas_corner"      : UP+RIGHT,
-        "zoomed_camera_background" : None
+        "zoomed_camera_background"  : None,
+        "zoom_factor"               : 6,
+        "square_color"              : WHITE,
+        "zoom_activated"            : False,
     }
-    def init_zooming(self, moving_camera_mobject):
+    def activate_zooming(self):
+        self.generate_big_rectangle()
         self.setup_zoomed_canvas()
+        self.setup_zoomed_camera()
+        self.zoom_activated = True
+
+    def disactivate_zooming(self):
+        self.remove(self.big_rectangle, self.little_rectangle)
+        self.zoom_activated = False
+
+    def get_zoomed_camera_mobject(self):
+        return self.little_rectangle
+
+    def generate_big_rectangle(self):
+        height, width = self.zoomed_canvas_space_shape
+        self.big_rectangle = Rectangle(
+            height = height,
+            width = width,
+            color = self.square_color
+        )
+        if self.zoomed_canvas_center is not None:
+            self.big_rectangle.shift(self.zoomed_canvas_center)
+        elif self.zoomed_canvas_corner is not None:
+            self.big_rectangle.to_corner(self.zoomed_canvas_corner)
+        self.add(self.big_rectangle)
+
+
+    def setup_zoomed_canvas(self):
+        upper_left = self.big_rectangle.get_corner(UP+LEFT)
+        lower_right = self.big_rectangle.get_corner(DOWN+RIGHT)
+        pixel_coords = self.camera.points_to_pixel_coords(
+            np.array([upper_left, lower_right])
+        )
+        self.zoomed_canvas_pixel_indices = pixel_coords
+        (up, left), (down, right) = pixel_coords
+        self.zoomed_canvas_pixel_shape = (
+            down-up,
+            right-left
+        )
+
+    def setup_zoomed_camera(self):
+        self.little_rectangle = self.big_rectangle.copy()
+        self.little_rectangle.scale(1./self.zoom_factor)
+        self.little_rectangle.center()
         self.zoomed_camera = MovingCamera(
-            moving_camera_mobject,
+            self.little_rectangle,
             pixel_shape = self.zoomed_canvas_pixel_shape,
             background = self.zoomed_camera_background
         )
-        self.add(moving_camera_mobject)
+        self.add(self.little_rectangle)
-
-    def setup_zoomed_canvas(self):
-        height, width = self.zoomed_canvas_space_shape
-        canvas_corners = Mobject().add_points([
-            ORIGIN, DOWN+RIGHT
-        ])
-        canvas_corners.stretch_to_fit_height(height)
-        canvas_corners.stretch_to_fit_width(width)
-        canvas_corners.center()        
-        if self.zoomed_canvas_center is not None:
-            canvas_corners.shift(self.zoomed_canvas_center)
-        elif self.zoomed_canvas_corner is not None:
-            canvas_corners.to_corner(self.zoomed_canvas_corner)
-
-        pixel_coords = self.camera.points_to_pixel_coords(canvas_corners.points)
-        upper_left, lower_right = pixel_coords
-        self.zoomed_canvas_pixel_indices = pixel_coords
-        self.zoomed_canvas_pixel_shape = (
-            lower_right[0] - upper_left[0],
-            lower_right[1] - upper_left[1]
-        )
 
     def get_frame(self):
         frame = Scene.get_frame(self)
-        (up, left), (down, right) = self.zoomed_canvas_pixel_indices
+        if self.zoom_activated:
-        frame[left:right, up:down, :] = self.zoomed_camera.get_image()
+            (up, left), (down, right) = self.zoomed_canvas_pixel_indices
+            frame[left:right, up:down, :] = self.zoomed_camera.get_image()
         return frame
 
     def update_frame(self, *args, **kwargs):
         Scene.update_frame(self, *args, **kwargs)        
-        self.zoomed_camera.reset()
+        if self.zoom_activated:
-        self.zoomed_camera.capture_mobjects(self.mobjects)
+            self.zoomed_camera.reset()
+            self.zoomed_camera.capture_mobjects(self.mobjects)
 
 
 

topics/geometry.py

@@ -233,12 +233,12 @@ class Rectangle(Grid):
         Grid.__init__(self, 1, 1, **kwargs)
 
     def generate_points(self):
-        wh = [self.width/2.0, self.height/2.0]
+        hw = [self.width/2.0, self.height/2.0]
         self.add_points([
-            (x, u, 0) if dim==0 else (u, x, 0)
+            (x, u, 0) if dim==1 else (u, x, 0)
             for dim in 0, 1
-            for u in wh[1-dim], -wh[1-dim]
+            for u in hw[1-dim], -hw[1-dim]
-            for x in np.arange(-wh[dim], wh[dim], self.epsilon)
+            for x in np.arange(-hw[dim], hw[dim], self.epsilon)
         ])
 
 class Square(Rectangle):