updated after review

1 files changed, 314 insertions, 0 deletions

diff --git a/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/double-integrals/file2_volume_under_surface.py b/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/double-integrals/file2_volume_under_surface.py
new file mode 100644
index 0000000..cd4060b
--- /dev/null
+++ b/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/double-integrals/file2_volume_under_surface.py
@@ -0,0 +1,314 @@
+from manimlib.imports import *
+
+class SurfacesAnimation(ThreeDScene):
+
+    CONFIG = {
+        "axes_config": {
+            "x_min": 0,
+            "x_max": 7,
+            "y_min": 0,
+            "y_max": 7,
+            "z_min": 0,
+            "z_max": 5,
+            "a":1 ,"b": 6, "c":2 , "d":6,
+            "axes_shift":-3*OUT + 5*LEFT,
+            "x_axis_config": {
+                "tick_frequency": 1,
+               # "include_tip": False,
+            },
+            "y_axis_config": {
+                "tick_frequency": 1,
+             #   "include_tip": False,
+            },
+            "z_axis_config": {
+                "tick_frequency": 1,
+             #   "include_tip": False,
+            },
+            "num_axis_pieces": 1,
+        },
+        "default_graph_style": {
+            "stroke_width": 2,
+            "stroke_color": WHITE,
+        },
+        "default_surface_config": {
+            "fill_opacity": 0.5,
+            "checkerboard_colors": [LIGHT_GREY],
+            "stroke_width": 0.5,
+            "stroke_color": WHITE,
+            "stroke_opacity": 0.5,
+        },
+    "Func": lambda x,y: 2+y/4+np.sin(x)
+    }
+
+
+    def construct(self):
+
+        self.setup_axes()
+        self.set_camera_orientation(distance=35,
+            phi=80 * DEGREES,
+            theta=-100 * DEGREES,
+        )
+        
+        fn_text=TextMobject("$z=f(x,y)$").set_color(PINK)
+        self.add_fixed_in_frame_mobjects(fn_text) 
+        fn_text.to_edge(TOP,buff=MED_SMALL_BUFF)
+        
+        riemann_sum_text=TextMobject(r"The volume approximated as\\ sum of cuboids",color=BLUE)
+        riemann_sum_text.to_corner(UR,buff=.2)
+        
+        R=TextMobject("R").set_color(BLACK).scale(3)
+        R.move_to(self.axes.input_plane,IN)
+        self.add(R)
+        
+        #get the surface
+        surface= self.get_surface(
+            self.axes, lambda x , y: 
+            self.Func(x,y)
+        )
+        surface.set_style(
+            fill_opacity=0.8,
+            fill_color=PINK,
+            stroke_width=0.8,
+            stroke_color=WHITE,
+        )
+        
+        
+        self.begin_ambient_camera_rotation(rate=0.08)
+        self.play(Write(surface))
+     #   self.add(surface)
+        
+        self.get_lines()
+        self.wait(1)
+        self.add_fixed_in_frame_mobjects(riemann_sum_text)
+        self.play(Write(riemann_sum_text))
+        self.show_the_riemmann_sum(
+            lambda x,y : np.array([x,y,self.Func(x,y)]),
+            fill_opacity=1,
+            dl=.5,
+            start_color=BLUE,
+            end_color=BLUE_E,
+        )
+        self.play(FadeOut(surface))
+        self.wait(3)
+        
+        
+        
+      
+    def get_surface(self,axes, func, **kwargs):
+        config = {
+            "u_min": axes.a,
+            "u_max": axes.b,
+            "v_min": axes.c,
+            "v_max": axes.d,
+            "resolution": (
+                (axes.y_max - axes.y_min) // axes.y_axis.tick_frequency,
+                (axes.x_max - axes.x_min) // axes.x_axis.tick_frequency,
+            ),
+        }
+        
+        config.update(self.default_surface_config)
+        config.update(kwargs)
+        return ParametricSurface(
+            lambda  x,y : axes.c2p(
+                x, y, func(x, y)
+            ),
+            **config
+        )
+        
+    def get_lines(self):
+        axes = self.axes
+        
+        surface_corners=[]
+        for x,y,z in self.region_corners:
+            surface_corners.append([x,y,self.Func(x,y)])
+            
+        lines=VGroup()
+        for start , end in zip(surface_corners,
+        self.region_corners):
+            lines.add(self.draw_lines(start,end,"#9CDCEB"))
+        
+        labels=[
+            (axes.a,0,0), 
+            (axes.b,0,0), 
+            (0,axes.d,0), 
+            (0,axes.c,0)
+        ]  
+        self.region_corners[-1]=self.region_corners[0]
+        for start , end in zip(labels,self.region_corners):
+            lines.add(self.draw_lines(start,end,"WHITE"))
+            
+       # self.add(lines)
+        self.play(ShowCreation(lines))
+        
+              
+    def draw_lines(self,start,end,color):
+        start=self.axes.c2p(*start)
+        end=self.axes.c2p(*end)
+        line=DashedLine(start,end,color=color)
+        
+        return line
+        
+        
+    def show_the_riemmann_sum(
+        self,
+        surface,
+        x_min=None,
+        x_max=None,
+        y_min=None,
+        y_max=None,
+        dl=.5,
+        stroke_width=.5,
+        stroke_color=BLACK,
+        fill_opacity=1,
+        start_color=None,
+        end_color=None,
+        ):
+            x_min = x_min if x_min is not None else self.axes.a
+            x_max = x_max if x_max is not None else self.axes.b
+            y_min = y_min if y_min is not None else self.axes.c
+            y_max = y_max if y_max is not None else self.axes.d
+            
+            if start_color is None:
+                start_color = BLUE
+            if end_color is None:
+                end_color = BLUE
+                
+            cuboids = VGroup()
+            x_range = np.arange(x_min, x_max, dl)
+            y_range = np.arange(y_min, y_max, dl)
+            colors = color_gradient([start_color, end_color], len(x_range))
+            for x, color in zip(x_range, colors):
+              for y in y_range:
+                  sample_base = np.array([x ,y ,0])
+                  sample_base_dl = np.array([x + dl, y + dl,0])
+                  sample_input = np.array([x +0.5*dl, y +0.5*dl,0])
+                  
+                  base_point = self.axes.c2p(*sample_base)
+                  base_dx_point = self.axes.c2p(*sample_base_dl) 
+                  
+                  surface_val= surface(*sample_input[:2])
+                  surface_point = self.axes.c2p(*surface_val)
+               
+                  points = VGroup(*list(map(VectorizedPoint, [
+                      base_point,
+                      surface_point,
+                      base_dx_point
+                  ])))
+                    
+                #  self.add(points)
+                  cuboid = Prism(dimensions=[dl,dl,surface_val[-1]])
+                  cuboid.replace(points, stretch=True)
+             
+                  cuboid.set_fill(color, opacity=fill_opacity)
+                  cuboid.set_stroke(stroke_color, width=stroke_width)
+                  cuboids.add(cuboid)
+            
+            self.play(ShowCreation(cuboids),run_time=6)
+           # self.add(cuboids)
+            
+  
+#-------------------------------------------------------  
+    #customize 3d axes       
+    def get_three_d_axes(self, include_labels=True, include_numbers=True, **kwargs):
+        config = dict(self.axes_config)
+        config.update(kwargs)
+        axes = ThreeDAxes(**config)
+        axes.set_stroke(width=2)
+
+        if include_numbers:
+            self.add_axes_numbers(axes)
+
+        if include_labels:
+            self.add_axes_labels(axes)
+
+        # Adjust axis orientation
+        axes.x_axis.rotate(
+            90 * DEGREES, RIGHT,
+            about_point=axes.c2p(0, 0, 0),
+        )
+        axes.y_axis.rotate(
+            90 * DEGREES, UP,
+            about_point=axes.c2p(0, 0, 0),
+        )
+
+        # Add xy-plane
+        input_plane = self.get_surface(
+            axes, lambda x, t: 0
+        )
+        input_plane.set_style(
+            fill_opacity=0.5,
+            fill_color=TEAL,
+            stroke_width=0,
+            stroke_color=WHITE,
+        )
+
+        axes.input_plane = input_plane
+
+        self.region_corners=[ 
+        input_plane.get_corner(pos) for pos in (DL,DR,UL,UR)]
+        
+        return axes
+        
+        
+    def setup_axes(self):
+        axes = self.get_three_d_axes(include_labels=True)
+        axes.add(axes.input_plane)
+        axes.scale(1)
+     #   axes.center()
+        axes.shift(axes.axes_shift)
+
+        self.add(axes)
+        self.axes = axes
+        
+    def add_axes_numbers(self, axes):
+        x_axis = axes.x_axis
+        y_axis = axes.y_axis
+        tex_vals_x = [
+            ("a", axes.a),
+            ("b", axes.b),
+        ]
+        tex_vals_y=[
+            ("c", axes.c),
+            ("d", axes.d)
+        ]
+        x_labels = VGroup()
+        y_labels = VGroup()
+        for tex, val in tex_vals_x:
+            label = TexMobject(tex)
+            label.scale(1)
+            label.next_to(x_axis.n2p(val), DOWN)
+            x_labels.add(label)
+        x_axis.add(x_labels)
+        x_axis.numbers = x_labels
+
+        for tex, val in tex_vals_y:
+            label = TexMobject(tex)
+            label.scale(1.5)
+            label.next_to(y_axis.n2p(val), LEFT)
+            label.rotate(90 * DEGREES)
+            y_labels.add(label)
+            
+        y_axis.add(y_labels)
+        y_axis.numbers = y_labels
+        
+        return axes
+    
+    def add_axes_labels(self, axes):
+        x_label = TexMobject("x")
+        x_label.next_to(axes.x_axis.get_end(), RIGHT)
+        axes.x_axis.label = x_label
+
+        y_label = TextMobject("y")
+        y_label.rotate(90 * DEGREES, OUT)
+        y_label.next_to(axes.y_axis.get_end(), UP)
+        axes.y_axis.label = y_label
+
+        z_label = TextMobject("z")
+        z_label.rotate(90 * DEGREES, RIGHT)
+        z_label.next_to(axes.z_axis.get_zenith(), RIGHT)
+        axes.z_axis.label = z_label
+        for axis in axes:
+            axis.add(axis.label)
+        return axes    
+        
+