How I make science animations

over the past few months a lot of people have asked me about the creative process behind my videos like what software I use and how some particular animations were brought to life this is why I decided to make a dedicated video where I would share with you some of my secrets and use animations from my previous videos as illustrative examples just to walk you through how they were done if you're interested stay tuned before we dive deeper into the animations themselves let me address one of the most common questions I get and that is what software do I use here's the thing unfortunately there is no ultimate tool that will help you create a video from start to finish instead every software is made for specific purposes and thus has its own limitations that's why my workflow is almost always some combination of many programs and packages that I use depending on the problem at hand so I've prepared the whole list of software that I use in video production and when exactly I use each of them starting with Adobe After Effects this is my main Workhorse that I use for the majority of simple animations as well as for composing the results of other programs into the final video to me after effects offers an optimal balance between capabilities and usability I don't really need to create any realistic explosions key in fancy color correction 3D tracking or anything like that for this purpose there are other dedicated applications much more powerful than After Effects but using them for simpler stuff would be an Overkill like trying to cut a paper with a chainsaw for example I can create the text stylize it to globe with gradient make it appear on the screen add an image that would pop up wiggle around and gradually change its Hue and finally make a smooth transition out of the scene within just a few clicks number two python now this is where things get interesting unfortunately scripting in After Effects is not as powerful as convenient as compared to some other programs yes technically there is a JavaScript API but honestly I found it to be quite unusable and there is only so much you can do without scripting create a pair of circles that would wiggle around while always being connected by a line easy but creating a hundred of such circles and lines that would form a wiggling graph with specified properties optimally positioned in a two-dimensional space is pretty much impossible this is why when I need to create something that can't really be done by hand I have to rely on other tools that would allow me to make visualizations programmatically taking advantage of mathematical functions heavy numerical calculations variables Loops recursion stuff like that typically I do everything in Python since this is the programming language I'm most familiar with and it has a few great modules for creating visualizations but hey if you have a lot of experience in other languages like C plus or Julia and would strongly prefer to use them instead there are some really great solutions for them as well the choice of the exact tool doesn't really matter anyway in my work I mostly use two python packages the first one is called many it was originally developed by Grand Sanderson also known as three blue and brown who I'm sure most of you have heard about today there is a rapidly developing version of many maintained by the community I've used it extensively in my earlier videos for all sorts of mathematical animations but I just kept bumping into things that I couldn't Implement in manim for example drawing gradient lines colored by coordinate Plus at times I found the workflow to be tedious and not really intuitive this is why about 10 months ago I gradually began to switch to another visualization module called matplotlib I'm sure most of you probably recognized that name because it's like the most popular solution for plotting or data visualization in Python what is less known however is that method lip is not limited to simple static plots like the ones you would create for a research paper in fact it has some of the most amazing animation capabilities personally I find Matlock lip to be much more intuitive compared to manim and although it is more low level in a way so that the same animation takes up more lines of code it gives me much more control and much more freedom over manipulating individual elements on the screen on a frame by frame basis so nowadays whenever I need to create an animation of a plot being drawn or visualize some complex system beat an icing model or an artificial neural network I use Matlock lab further in the video we will take a look at a few examples of how exactly it is done one thing that I still invariably do in many however is these types of graph animations this would certainly be possible to recreate in matplotlib but manim just has got such an amazing out of the box solution for graph theory that I can't ignore it within just a few lines of code it is possible to draw a graph object from Network X and make it wiggle number three blender unfortunately both After Effects and python Solutions have very limited capabilities of working with all three dimensions so whenever I need to create something in 3D B neurons mice running in mazes or fancy surface plots I use blender it is completely free and open source but that doesn't make it less powerful additionally blender has got an amazing python API which means it is possible to create some 3D visualizations programmatically as well these three pieces of software After Effects Python and blender are the backbone of my animation workflow but there are a few other programs mostly from the Adobe suite that I use every now and then at different stages of video production for example Adobe Illustrator is my go-to Vector editor when I need to draw something like a simple asset or a diagram the good thing about it is that it works seamlessly with Adobe After Effects so I can use Illustrator files to drive some animations and whenever I need to change the source in illustrator things will automatically be updated in After Effects as well Photoshop is mostly for thumbnails and minor raster work like separating a subject from a background or color correcting by the way just like illustrator Photoshop integrates nicely with After Effects Adobe Premiere Pro now although After Effects is certainly good for animating it is virtually unusable for classic video editing you know like trimming Clips arranging them in time adding sounds background music stuff like that for this type of video editing and usually at the final stage and especially when I'm shooting with a face camera I use Premiere and finally Adobe Audition for all sorts of audio work removing background noise enhancing The Voice removing plosives and other nasty things like breaths and mouth sounds and that's pretty much it all the software I use to make my videos now let's be more specific and take a detailed look at how some of the animations were done here's the list of what I'm going to talk about along with time codes so you can easily find a particular animation you're looking for or you know just watch the whole thing that would be awesome as well [Music] were wondering how mad but lib can be used to create mathematical animations over the years I've developed a few tricks and strategies on how to use map.lib in Synergy with After Effects and this is actually the key takeaway no single mathematical animation you can find in my videos was created with mat.lib or manim alone there is always some After Effects involved to enhance the animations I've actually prepared a short animated clip to use as an example don't search for any deep meaning in it essentially the only purpose of this toy animation is to illustrate various approaches here it is consider an arrow rotating around a circle with variable speed if we trace the y-coordinate of the arrow tip we will get a sinusoid with time varying frequency let's say we want the amplitude of the sinusoid to change in time according to this function right here let's zoom into the resulting wave and make it wiggle for a while between the two states just for fun alright great now let's break it down piece by piece first I usually identify the core components the building blocks of the scene for this first portion right here these would be the arrow spinning around the Rainbow Circle the graph of a wave colored by the face being gradually drawn along with the field graph of frequency as a function of time these three elements should be synchronized to each other and be optimally arranged on the screen along with some texts once I've identified what exactly needs to be done it's time to determine the tool that I'm going to use for each of the jobs in this case either after effects or python now of course there is no right or wrong answer since it's the matter of personal preferences and experiences for me draw in such a wave from scratch in After Effects and synchronizing it to the spinning Arrow would be a pain so I'm better off creating something like that and inapt.lib on the other hand arranging everything on the screen and animating texts directly in Python would be tedious if not impossible so let's leave that to After Effects once individual jobs are allocated to their respective software it's time to get to work alright so in Python let's start off by creating an array of instantaneous frequencies that would tell the arrow how fast it should move at every point in time and the array containing the resulting sinusoid for visualization let's set up a method lib axis with high enough resolution make it completely black and add a nice thin grid to plot our array as a gradient line colored by face values we can use metal Clips align collection object specify the array of colors obtained from the array of phases by passing it through a color map stylize the line a little bit and finally add the resulting line collection object to the axis voila we got an image of a wave but we need it to be animated in for this purpose let's use the funk animation class available in the animation submodule of mat.lib essentially actually the way it works is you define a function that would be repeatedly called and would modify the plot at every frame of the animation this function let's call it animate wave we'll accept the parameter specifying the current frame for this case since we are creating a drawing animation let's call this parameter T current and we are going to animate it from the first value of our time array which is 0 to the last which in this case is 5. whenever the animate wave function is called it should hide the portion of the graph where time is greater than T current and show the portion where the time is less than or equal to T current the way we can do it is the following remember when creating the line collection object we specified the color for each point well in a similar fashion it is possible to specify the opacity of each point by the way in Python opacity is usually called Alpha so we can call line collection dot set Alpha the expression in the parenthesis will compare each element of the time array to the value of T current and return a binary mask of ones and zeros which we can use to set the opacity of individual line segments to create the animation let's create an instance of the funk animation class passing our figure object the animation function and the list of frames in this case we are going to animate the value of T current from T start to T end and let's make it 5000 frames to make the animation smooth let's tell python that the interval between consecutive frames should be around 30 milliseconds so the animation will be saved with 30 frames per second finally we need to call Dot save on the resulting animation object and a few moments later we got a nice animation of a wave being drawn I think it's a great point to pause and talk about the number of frames you probably noticed that the resulting video is extremely long two and a half minutes and the reason for that is because I need the animations to be synchronized with my voice I want to easily control the speed with which they play but here's the thing if the animation is long I can easily make it 5 times faster and it will look nice I can even tweak the rate and make it non-linear to achieve the easing effect but going the other way around making the fast animation 5 times slower although technically possible will give you a very choppy and ugly result in the first case the file contains a large number of frames let's say 5000 and to speed the animation up the video editing software simply takes every fifth frame change them together and the result looks good alternatively to slow a faster animation down it needs to somehow stretch the existing thousand frames into 5000 since it can't augment the pre-rendered video with any new frames the existing ones are simply repeated so that now you perceive the animation as if it is played with 6 frames per second instead of the normal 30. this is why when creating the animation building blocks in Python I intentionally save them as videos with humongous number of frames because I can always easily throw some of those out but to generate new ones would require rewriting the entire code similarly to how when you are buying wallpaper rolls it's certainly better to overestimate than to underestimate OK let's get back to matplotlib in exactly the same way we can animate the frequency graph the only difference is that it is completely white instead of the gradient and also includes a fill let's create the fill object using x.fill between method and modify our existing animation function a little bit now on every frame along with setting the opacity of the line segments it should also modify the fill as of right now matpatlib can't modify the existing polygon but we can easily just delete the old fill and recreate the new one with necessary limits on every frame specified by T current for the arrow let's set up a black figure with polar axes and specify how ticks and the grid should look like we can draw the colored Circle in exactly the same way we did with the way just generate an array of angle values linearly spaced from 0 to 2 pi along with the array of radii all the elements of which will be equal to 1. in order to add the circle to the axis we can use the code with a line collection from before only now for the case of polar axis segments will be specified with angle and radius values instead of X and Y to create an arrow let's define a function called get polar arrow that will take the value of the angle and add the arrow to the axis by calling x dot Arrow rotated and colored according to the angle to create the animation itself we need a very simple animation function that will remove the old arrow and create a new one on every frame as we gradually change the angle according to our array of phases and here we go next in the animation there is this graph of the amplitude being drawn together with the field and later the copy of the curve should detach from The Fill fly down and kind of Squish the sinusoid into the target shape this part is a bit tricky and there are always many ways you can achieve the same result what I suggest we do is the following in Python using similar approaches first animate only the amplitude curve without the fill you'll see why in a minute then by modifying the code slightly animate only the fill and save the result into its own video file unfortunately matplotlib can't really color these fields with gradient so we'll have to tackle this on post processing for now let's make the fill fully white finally before we can compose everything we need this last animation of one wave being gradually transformed into another took me a while to figure out how to do this but this solution turned out to be pretty straightforward first create the line collection corresponding to the initial stage as we did in the beginning the animation function should gradually interpolate between the curves the initial array wave and the wave times amplitude array to achieve this the function will take a single parameter called proportion which is a number between 0 and 1 specifying where we are in the interpolation process so on every frame the animation function will mix the two arrays accordingly and change the segments of the line collection object as you can see when the proportion is equal to zero this expression evaluates to just wave while when the proportion is 1 it equals to wave times amplitude and everything in between let's animate the proportion value from 0 to 1 say with 500 frames and boom smooth interpolation between the two functions pretty neat right believe it or not but now we have all the necessary building blocks we need to create the full animation let's put python aside for now and finally move to Adobe After Effects now I'm not going to explain every single thing just cover the key ideas in After Effects I usually scale and position the layers accordingly to compose the scene by the way notice that these video files have black background which looks kind of ugly if you want to put them on a nice dark but not completely black background in addition this prevents them from overlapping to solve this issue pretty much for every single asset I set the blending mode to screen I'm not going to explain the theory behind blending mounts if you're interested check out this great article on Wiki essentially everything that's black will be made transparent so that now not only can we see the background but it is also possible to arrange them however we want without one layer obstructing another we can now adjust the speed of the animations using the time remapping property and arrange them on the timeline for instance I want the amplitude animation to appear only after the first three animations relating to the arrow are Dawn plane now because the amplitude curve and the fill are two separate video files we can take advantage of that and do something about this horrible white fill in After Effects using the gradient ramp we will fill the layer with orange and red gradient according to the curve and set the layer mask to its own copy so that now only the pixels that were white in the original file will be shown while the other pixels that were black will be transparent now just lower the opacity and voila a nice gradient fill that is animated together with the Curve now to the squishing part notice how the last frame of the video with the wave being drawn is identical to the first frame of the video with the interpolation between the waves because of this we can seamlessly Stitch the two videos together as long as both layers in After Effects have the same position and scale foreign as a result the wave is first being drawn and then after a pause is being morphed into the amplitude modulated version of itself while the rate of both animations as well as the duration of the pause can be easily tweaked in After Effects by animating the time remapping property to match the voice as a nice touch we can make a copy of the amplitude curve layer and animate its position and opacity to achieve this effect as if the curve is kind of squished in the wave in order to zoom into the wave let's parent all the layers to the wave interpolation video so that they will inherit the Transformations and animate the scale and the position of the parent layer and maybe simultaneously animate the opacity of some of the child layers to make them Disappear Completely finally as you may have guessed already we are going to use the time remapping property to create this wiggling animation this is where the fact that the source video contains a large number of frames will come in handy and and that's pretty much it just add the texts maybe stylize the animations by adding a few effects to your liking and render the video all right so just a quick recap of how Python and after effects can be used in tandem matplotlib is used to create the mathematical building blocks of animations those building blocks like graphs or array images usually are then scaled arranged and composed together in After Effects which also helps with synchronizing the resulting animation to the voiceover and remember time remapping is your best friend well I hope this was helpful and with a major block of mathematical animations out of the way let's look at a few more tricky ones foreign what you see right here is the biophysically accurate description of how membrane voltage propagates through a pyramidal neuron during action potential let me tell you a short back story of how such animations were born in the first place while I Was preparing to make a video on dendritic computations this one right here I realized that I needed some way to animate realistic dynamics of membrane voltage in space and time since you know this was the central point of the video however after searching the internet for a solution I just couldn't really find anything that would work so I did what every rational person would do in this case I created my own tool the main idea was to run biophysical simulations using real neuron morphologies in the free neuron simulator environment and then somehow brain simulation data into blender along with geometry this task turned out to be not as straightforward as I hoped for and it took me a couple of weeks of experimenting and going through the blender API documentation before I could make it work realizing that I will probably need this for future videos and other people might find that helpful I went ahead and created an actual blender add-on called blender Spike which is now available on my GitHub along with the detailed instructions now you may be wondering why not name It Blend or neuron because that would be so much cooler turns out there already is an add-on called blender neuron developed in 2018 designed to do exactly that but unfortunately no matter how hard I tried I couldn't make it work anyway creating your own simulations from scratch in blender Spike requires knowledge of Python and the basics of neuron simulator to load the morphology set up the biophysics and run the simulation results are then exported into a blender friendly format with a little companion module called blender Spike Pi this resulting dot pickle file essentially contains all the data including the morphology of the branches and the frame by frame voltage data for each branch the good news is once you have the dot pickle file with the simulation results for example by downloading an existing one from my GitHub or asking your simulation proficient friends to create one for you you can simply dump that into blender and easily customize the appearance of the neuron the color map glow intensity to build your own unique animations to take it one step further it is possible to combine blender Spike with matplotlib animations which I discussed previously it is straightforward since blender updates the voltage by looking up values from the python array stored in the pickle so for example we can render the neuron in blender animate voltage graphs in matplotlib and compose and sync the two videos in After Effects for a more complex animation another animation a lot of people are interested in is this slicing through probability distribution from the video on cognitive maps not gonna lie this is one of my favorites as well this was created in blender with just a little bit of python by the way the exact method I'm about to describe was used for this animation from the wavelet transform video as well now the first step is to construct the three-dimensional surface inside the blender unfortunately there is no native way to just tell blender to plot a surface so we will have to use a workaround we will first use Python to generate a black and white image called the height map which means that white pixels correspond to more elevated areas this can be done with net.lib by calling the dot emcee function with a binary color map here is what the resultant image looks like in blender we can now create a grid object apply the displace modifier and specify the texture to be the displacement map we have just saved what this will do is extrude the vertices of the grid as specified by the brightness of the image and voila a nicely looking 3D visualization of the array one way to cover this would be to create a color image in matpatlab in a similar Manner and then apply that image as a texture to the object but in this particular example since the coloring is quite simple namely it's just a gradient along one axis we can create it right inside blender to specify materials we are going to use blenders node based Shader editor essentially it allows to create complex materials by routing basic computations and materials through a system of interconnected nodes for example we can modify the default green material by specifying that the base color should be taken from a gradient using a color map node and that the position along the gradient should depend on the y coordinate you can now manually create any gradient you want or use this tiny add-on called blender color maps to quickly bring gradients from MacBook lip color Maps into blender alright now to the slicing part the key idea behind this is that inside the node editor blender allows you to mix different shaders in different proportions which could be a function of variables including other objects sounds confusing but here's what I mean suppose I want to mix the gradient Shader with a fully transparent Shader well I can just add a mixed Shader node in blender and change the factor slider which is the proportion in which the two shaders are mixed so for zero only the gradient is visible for one the object is fully transparent 0.5 somewhere in the middle you get the idea the cool thing about it is that this factor is not restricted to being a constant value for example we can plug the Z coordinate of the object there to achieve this cool fading effect which depends on the height in order to slice the surface let's create another object an empty plane it will not be rendered and will use it only to drive the material namely let's take the y-coordinate of the empty object threshold it with some value and feed the output into the factor of the mixed Shader that way the vertices of our surface will have either one or the other Shader depending on the location of the empty object foreign to achieve this thin white line and the boundary the idea is similar we just create a third Shader that will be a pure white glow and mix the three shaders depending on the position of the cutting plane there is just this funny note set up to work around the limitation that the blender can't mix three shaders simultaneously so I first have to mix the two shaders together and then mix the result with the third now we can duplicate the surface object apply the wireframe modifier to one copy well to make it wireframe and simply reverse the order in which the shaders are mixed so that now the wireframe is visible when the original surface is transparent and vice versa and now what's left to do is the animate the movement of the cutting plane make the camera spin around and here we go foreign about the three-dimensional animations of brain structures the models themselves come from the existing brain atlases in particular the ones published by Alan Institute downloading them can be a bit of a challenge given that the interface is not really intuitive I found that the most convenient way to use brain atlases is through brain Globe API which provides a python interface to download and navigate the data then what's left to do is navigate to the folder where the atlas is stored locate the necessary.obj file since they are named by their IDs and bring the model into blender but this can be tedious especially when you want to bring multiple brain structures into a single scene to simplify the process I've put together a tiny blender add-on called blenderbrain very original name in I know which you can find on GitHub it allows you to import meshes from specified Atlas in one click simply by specifying their acronym which you can look up in the corresponding structures.csv file that the blender Globe downloads for example let's say I want to look at the ce3 region of the mouse keeper campus well I can just select the atlas and type in ca3 similarly I can bring the dented gyrus into the scene by typing DG notice how it automatically gets positioned into the anatomically correct place and suppose we want to look at where these two structures are located relative to the entire brain typing in Gray Imports the entire gray matter and since hippocampus and Dente gyrus are subcortical structures we can't really see them now let's change that make the gray matter almost transparent change the environment settings so that there is some backlight and color of the brain structures for instance let's make the dentage iris glow with blue and add this subtle gradient to the glow of the C3 region along the x-axis what's left to do is to animate the camera to spin around the brain render it with a black background and the footage is ready to be used in After Effects [Music] finally I have prepared something special for you namely let's explore how to build this animation of information transmission from the brain criticality video yes including this segment where the neurons are being rearranged now I realized that this section will be a bit more coding heavy and I will skip through some of the technical details so please be prepared for that by the way you can find all the code for this video on my GitHub as well okay so just to remind you we want to animate the simulation of a so-called branching model it consists of M layers and each layer has n neurons that can be in one of two states on or off layers are connected sequentially and each connection has a certain transmission probability associated with it so that information can spread from left to right this number Sigma which is equal to the average number of neurons activated by one Downstream neuron controls the the behavior of our Network additionally each neuron has a very small probability of being spontaneously activated even when it doesn't receive any input before animating the activity it's necessary to set up the simulation itself let's define a function that initializes the N by m array of zeros that is going to store the state of the network next we create a function called Network advance that will advance the network one step into the future and return the update state to advance a network we need to First randomly activate a small subset of neurons in order to model this stochastic input and model the propagation of information as specified by the value of Sigma once we have a function that advances one time step we can just call it sequentially a few hundred times to get the full simulation result great so now we have a stack of 2D arrays containing the entire evolution of the network now we just need to somehow animate this because each frame should depict one state of the network which in turn is given by a two-dimensional array a natural solution is to use methodly functions like IM show or P color mesh then on every frame we just need to change which of the arrays is being plotted so just like before set up the figure and axis plot the network state I'm going to use P color mesh here Define the animation function that would change the data depending on the current frame and call func animation to create a video however there are a couple of crucial problems with this animation first of all it is too fast so much that it is literally painful to look at it this is because we currently change the array on every single frame and the interval between the frames is short we can try to increase the interval but now the animation is awfully topic let's do something else instead consider the Dynamics of a single neuron in isolation right now if we plot its state as a function of time we will get something like this zeros interspersed by a few ones which makes sense we are going to cheat a little bit and kind of smooth out its activity in time so instead of instantaneously jumping to one and then back to zero the neuron State Should gradually increase and then decrease according to this shape right here which consists of two exponents so we need to replace every single sudden jump with this gradual rise and decay in mathematical terms we have to convolve the activity function with this exponential thingy called the kernel this operation can be easily done in Python using numpies can evolve 1D finally in P color mesh we can choose a nice color map and animate the smoothed States array instead just play around with the time spread and the kernel shape to achieve the optimal balance as a side note if you don't like the squares that the peak color mesh produces with just a little bit of After Effects they can be changed to pretty much any shape for example circles just create a shape layer on top of the video draw one circle of the necessary size add the repeater with a proper number of copies and tweak the spacing to ensure that all the circles in the row fall on top of the squares for a one-to-one mapping add another repeater and do the same for the vertical spacing now just change the track matte of the video to Alpha matte essentially the video with our colored squares will be now masked by the circles and also feel free to add the glow finally let's create this rearranging animation right here which by the way if you are into manim can be quite useful the code for running the simulations and smoothing is the same but this time instead of map.libs color mesh we are going to use the graph object inside of menu the main idea is to run the network simulation but during the animation initially Shuffle the position of individual neurons on the screen then animate how each neuron gradually returns to its original place in the multi-layered network I know it's a bit backwards and kind of looks like cheating but hey it gets the job done so let's create a network of 10 layers with 10 neurons in each layer and run it for a couple thousand iterations then use this function that I stole from Network X documentation which creates a multi-layered network X graph object from this specified layer sizes in our case that's 10 layers with 10 nodes each I've actually modified it at a little bit so that now not all the edges are shown only a random subset of them to make the animation not too crowded with the lines inside the definition of a Manning scene let's create two coordinate systems one for the square grid and the other one for the layered layout that will map the index of each neuron to its position on the screen then randomly Shuffle the positions of all individual neurons and create a mapping a kind of a lookup table specifying that the first neuron in the first layer should be located here second neuron here Etc we can now create the graph object and tell Magnum its layout the positions of individual nodes to animate the colors of the nodes according to the simulation data we are going to make use of the magnum's value tracker class let's create an updater function that will be called on every single frame this updater will change the colors of our graphs nodes according to a color map and the value that's been passed into the color map is obtained by taking the value of our value tracker on a given frame and interpolating the simulation array for every neuron finally we need to connect the updater function to the graph object and animate the value tracker to make it transverse a specified number of frames this will create the animation similar to the one we had in Matlab but with the positions of neurons being randomly shuffled but what if after playing for a few seconds of activity in this shuffled State we want to rearrange the neurons into the original layered structure without interrupting the activity animation well luckily manium is very clever about playing multiple animations together so all we need to do is create a list of animations that will move each node into its original position append this list with an animation for incrementing the value of the value tracker and play the resulting collection of animations lastly let's play a few seconds of activity in the layered configuration by incrementing the value tracker without moving the nodes by the way I hope you can appreciate how convenient it is to use manim's graph object since when we animated the positions of nodes all the edges were animated automatically as you can see pretty much every single animation we covered today involved python in one way or another indeed this programming language is quite powerful and has enormous applications if you'd like to get started with python and potentially create your own visualizations you are going to love our today's sponsor brilliant.org brilliant is an exceptional online platform that offers interactive courses in stem Fields what sets brilliant apart is their emphasis on Active Learning and problem solving approach enabling you to tackle real world challenges with confidence the courses are packed with interactivity and stunning visualizations that help you develop an intuitive understanding of even the most challenging Concepts while problems and quizzes further consolidate the knowledge brilliant offers over 90 courses on a variety of subjects for multiple levels of difficulty whether you are a complete beginner or a professional looking to expand your skills brilliant has got you covered for example if you are interested in implementing some of the visuals from this video you may want to check out their course called programming with python to get a firm grasp on the fundamentals such as variables loops and functions and from there you can move on to algorithm fundamentals to learn more complex algorithms like array sorting and stable matching don't hesitate to take curiosity to the next level and start learning at your own pace just by dedicating 15 minutes a day go to brilliant.org artem care sonoff to get a 30-day free trial of everything brieland has to offer and the first 200 people to use this link will get 20 off the premium subscription all right well I hope some of it was helpful if I left out a particular animation and you would like to know more about it let me know down in the comment section and who knows maybe I'll create a part too in the meantime if you enjoyed this video press the like button share it with your friends and colleagues And subscribe to the channel if you haven't already stay tuned for more interesting topics coming up goodbye and thank you for the interest in science visualization [Music]

Channel: Artem Kirsanov

Views: 688,297

Keywords: Python, Manim, After Effects, Animation, Blender, Neuroscience, Coding, Data vizualization, 3D modeling, Blender Python

Id: yaa13eehgzo

Length: 43min 39sec (2619 seconds)

Published: Mon Aug 07 2023