msgid ""
msgstr ""
"Project-Id-Version: 031f65d9b7a2e83b265c23f1c4450271\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Plural-Forms: nplurals=2; plural=(n != 1);\n"
"X-Crowdin-Project: 031f65d9b7a2e83b265c23f1c4450271\n"
"X-Crowdin-Project-ID: 1\n"
"X-Crowdin-Language: sv\n"
"X-Crowdin-File: /[ManimCommunity.manim] main/docs/i18n/gettext/tutorials/building_blocks.pot\n"
"X-Crowdin-File-ID: 5839\n"
"Language-Team: Swedish\n"
"Language: sv_SE\n"
"PO-Revision-Date: 2021-11-06 12:29\n"

#: ../../source/tutorials/building_blocks.rst:3
msgid "Manim's building blocks"
msgstr "Manims byggstenar"

#: ../../source/tutorials/building_blocks.rst:5
msgid "This document explains the building blocks of manim and will give you all the necessary tools to start producing your own videos."
msgstr "Detta dokument går igenom Manims byggstenar och ger dig alla verktyg som behövs för att börja producera dina egna videor."

#: ../../source/tutorials/building_blocks.rst:8
msgid "Essentially, manim puts at your disposal three different concepts that you can orchestrate together to produce mathematical animations: the **mathematical object** (or **mobject** for short) the **animation**, and the **scene**.  As we will see in the following sections, each of these three concepts is implemented in manim as a separate class: the :class:`.Mobject`, :class:`.Animation`, and :class:`.Scene` classes."
msgstr "I huvudsak ställer Manim tre olika begrepp till ditt förfogande som du kan använda tillsammans med varandra för att producera matematiska animationer: det **matematiska objektet** (eller kortfattat **mobject**), **animationen** och **scenen**. Som vi kommer att se i följande avsnitt så implementeras var och ett av dessa i Manim som enskilda klasser: :class:`.Mobject`, :class:`.Animation`, och :class:`.Scene` klasserna."

#: ../../source/tutorials/building_blocks.rst:15
msgid "It is recommended that you read the tutorials :doc:`quickstart` and :doc:`a_deeper_look` before reading this page."
msgstr "Det rekommenderas att du först läser följande tutorials, :doc:`quickstart` och :doc:`a_deeper_look`, före du läser vidare på denna sidan."

#: ../../source/tutorials/building_blocks.rst:21
msgid "Mobjects"
msgstr "Mobjekt"

#: ../../source/tutorials/building_blocks.rst:23
msgid "Mobjects are the basic building block for all manim animations.  Each class that derives from :class:`.Mobject` represents an object that can be displayed on the screen.  For example, simple shapes such as :class:`.Circle`, :class:`.Arrow`, and :class:`.Rectangle` are all mobjects.  More complicated constructs such as :class:`.Axes`, :class:`.FunctionGraph`, or :class:`.BarChart` are mobjects as well."
msgstr "Mobject är den grundläggande byggstenen för alla animationer som görs i manim. Varje klass som ärver från :class:`.Mobject` representerar ett objekt som kan visas på skärmen. Som exempel är  :class:`.Circle`, :class:`.Arrow`, och :class:`.Rectangle` allihopa Mobjekt. Andra mer komplicerade exempel är exempelvis  :class:`.Axes`, :class:`.FunctionGraph`, och :class:`.BarChart`."

#: ../../source/tutorials/building_blocks.rst:30
msgid "If you try to display an instance of :class:`.Mobject` on the screen, you will only see an empty frame.  The reason is that the :class:`.Mobject` class is an abstract base class of all other mobjects, i.e. it does not have any pre-determined visual shape that can be displayed on the screen.  It is only the skeleton of a thing that *could* be displayed.  Therefore, you will rarely need to use plain instances of :class:`.Mobject`; instead, you will most likely create instances of its derived classes.  One of these derived classes is :class:`.VMobject`.  The ``V`` stands for Vectorized Mobject.  In essence, a vmobject is a mobject that uses `vector graphics <https://en.wikipedia.org/wiki/Vector_graphics>`_ to be displayed.  Most of the time, you will be dealing with vmobjects, though we will continue to use the term \"mobject\" to refer to the class of shapes that can be displayed on the screen, as it is more general."
msgstr "Om du försöker visa en instans av :class:`.Mobject` på skärmen kommer du bara att se en tom ram. Anledningen är att klassen :class:`.Mobject` är en abstrakt basklass för alla andra mobjects, dvs den har inte någon förutbestämd visuell form som kan visas på skärmen. Den är bara en skelettstruktur av en sak som *kunde* ha visats. Därför behöver du sällan använda vanliga instanser av :class:`.Mobject`; istället kommer du sannolikt att skapa instanser av dess härledda klasser. En av dessa härledda klasser är :class:`.VMobject`. ``V`` står för Vectorized Mobject. I grund och botten är ett vmobject ett mobject som använder `vektorgrafik <https://en.wikipedia.org/wiki/Vector_graphics>`_ för att visas. För det mesta kommer du egentligen att hantera vmobjects men vi kommer att fortsätta att använda termen \"mobject\" för att hänvisa till klasser av former som kan visas på skärmen. Det gör vi eftersom \"mobject\" är mer allmänt."

#: ../../source/tutorials/building_blocks.rst:44
msgid "Any object that can be displayed on the screen is a ``mobject``, even if it is not necessarily *mathematical* in nature."
msgstr "Varje objekt som kan visas på skärmen är ett ``mobject`` även om det inte nödvändigtvis har en *matematisk* natur."

#: ../../source/tutorials/building_blocks.rst:47
msgid "To see examples of classes derived from :class:`.Mobject`, see the :mod:`.geometry` module.  Most of these are in fact derived from :class:`.VMobject` as well."
msgstr "För att se exempel på klasser härledda från :class:`.Mobject`, se :mod:`.geometry`-modulen. De flesta av dessa härrör i själva verket från :class:`.VMobject` också."

#: ../../source/tutorials/building_blocks.rst:53
msgid "Creating and displaying mobjects"
msgstr "Skapa och visa mobjects"

#: ../../source/tutorials/building_blocks.rst:55
msgid "As explained in :doc:`quickstart`, usually all of the code in a manim script is put inside the :meth:`.construct` method of a :class:`.Scene` class. To display a mobject on the screen, call the :meth:`~.Scene.add` method of the containing :class:`.Scene`.  This is the principal way of displaying a mobject on the screen when it is not being animated.  To remove a mobject from the screen, simply call the :meth:`~.Scene.remove` method from the containing :class:`.Scene`."
msgstr "Som det förklaras i :doc:`quickstart` brukar all kod i ett manim-skript placeras i :meth:`.construct` metoden av en :class:`.Scene` klass. För att visa ett mobject på skärmen, anropa :meth:`~.Scene.add` metoden som finns i klassen :class:`.Scene`. Detta är det huvudsakliga sättet att visa ett mobject på skärmen när det inte animeras. För att ta bort ett mobject från skärmen anropa helt enkelt :meth:`~.Scene.remove`-metoden från klassen :class:`.Scene`."

#: ../../source/tutorials/building_blocks.rst:75
msgid "Placing mobjects"
msgstr "Placering av mobject"

#: ../../source/tutorials/building_blocks.rst:77
msgid "Let's define a new :class:`.Scene` called ``Shapes`` and :meth:`~.Scene.add` some mobjects to it.  This script generates a static picture that displays a circle, a square, and a triangle:"
msgstr "Vi definierar nu en ny :class:`.Scene` som heter ``Shapes`` och lägger till några mobject till den med hjälp av metoden :meth:`~.Scene.add`. Detta skript genererar en orörlig bild som visar en cirkel, en kvadrat, och en triangel:"

#: ../../source/tutorials/building_blocks.rst:96
msgid "By default, mobjects are placed at the center of coordinates, or *origin*, when they are first created.  They are also given some default colors.  Further, the ``Shapes`` scene places the mobjects by using the :meth:`.shift` method.  The square is shifted one unit in the ``UP`` direction from the origin, while the circle and triangle are shifted one unit ``LEFT`` and ``RIGHT``, respectively."
msgstr "Som standard placeras mobjects i mitten av koordinatsystemet, eller *origin* (sv. origo), när de först skapas. De får också några standardfärger. Vidare placerar scenen ``Shapes`` mobject genom att använda :meth:`.shift` metoden. Kvadraten flyttas en enhet i ``UP`` riktningen från origo, medan cirkeln och triangeln respektive skiftas en enhet ``LEFT`` och ``RIGHT``."

#: ../../source/tutorials/building_blocks.rst:102
msgid "Unlike other graphics software, manim places the center of coordinates at the center of the screen.  The positive vertical direction is up, and the positive horizontal direction is right. See also the constants ``ORIGIN``, ``UP``, ``DOWN``, ``LEFT``, ``RIGHT``, and others, defined in the :mod:`.constants` module."
msgstr "Till skillnad från andra grafikprogram placerar manim centrum av koordinatsystemet i mitten av skärmen. Den positiva vertikala riktningen är uppåt, och den positiva horisontella riktningen är åt höger. Se även konstanterna ``ORIGIN``, ``UP``, ``DOWN``, ``LEFT``, ``RIGHT`` och andra konstanter som definieras i :mod:`.constants`-modulen."

#: ../../source/tutorials/building_blocks.rst:108
msgid "There are many other possible ways to place mobjects on the screen, for example :meth:`.move_to`, :meth:`.next_to`, and :meth:`.align_to`.  The next scene ``MobjectPlacement`` uses all three."
msgstr "Det finns många andra sätt att placera mobjekt på skärmen, till exempel genom metoderna :meth:`. move_to`, :meth:`.next_to` och :meth:`.align_to`. Nästa scen ``MobjectPlacement`` använder sig av alla tre."

#: ../../source/tutorials/building_blocks.rst:130
msgid "The :meth:`.move_to` method uses absolute units (measured relative to the ``ORIGIN``), while :meth:`.next_to` uses relative units (measured from the mobject passed as the first argument).  :meth:`align_to` uses ``LEFT`` not as measuring units but as a way to determine the border to use for alignment.  The coordinates of the borders of a mobject are determined using an imaginary bounding box around it."
msgstr "Metoden :meth:`.move_to` använder sig av absoluta enheter (alltså, givet i förhållande till ``ORIGIN``), medan :meth:`.next_to` använder sig av relativa enheter (alltså, givet i förhållande till det mobject som ges i första argumentet).  :meth:`align_to` använder ``LEFT`` inte som en mätenhet utan som ett sätt att bestämma vilket gränssnitt som mobjectet ska justeras till. Koordinaterna för ett mobjects gränser bestäms med hjälp av en icke-visuell begränsningsruta runt den."

#: ../../source/tutorials/building_blocks.rst:137
msgid "Many methods in manim can be chained together.  For example the two lines"
msgstr "Många metoder i manim kan kedjas ihop. Till exempel de två raderna"

#: ../../source/tutorials/building_blocks.rst:145
msgid "can be replaced by"
msgstr "kan ersättas med"

#: ../../source/tutorials/building_blocks.rst:151
msgid "Technically, this is possible because most methods calls return the modified mobject."
msgstr "Tekniskt sett är detta möjligt eftersom de flesta metodanrop returnerar det modifierade mobjectet."

#: ../../source/tutorials/building_blocks.rst:155
msgid "Styling mobjects"
msgstr "Styla mobject"

#: ../../source/tutorials/building_blocks.rst:157
msgid "The following scene changes the default aesthetics of the mobjects."
msgstr "Följande scen ändrar mobjektens standardutseende."

#: ../../source/tutorials/building_blocks.rst:174
msgid "This scene uses two of the main functions that change the visual style of a mobject: :meth:`.set_stroke` and :meth:`.set_fill`.  The former changes the visual style of the mobject's border while the latter changes the style of the interior.  By default, most mobjects have a fully transparent interior so you must specify the ``opacity`` parameter to display the color.  An opacity of ``1.0`` means fully opaque, while ``0.0`` means fully transparent."
msgstr "Denna scen använder två huvudfunktioner som ändrar den visuella stilen på ett mobject: :meth:`.set_stroke` och :meth:`.set_fill`. Den första ändrar den visuella stilen på mobjectets rand medan den andra ändrar stilen på interiören. Som standard har de flesta mobjects en helt genomskinlig interiör så du måste ange parametern ``opacity`` för att visa färgen. Ett opacitetsvärde på ``1.0`` betyder helt ogenomskinlig, medan ``0.0`` betyder helt genomskinlig."

#: ../../source/tutorials/building_blocks.rst:181
msgid "Only instances of :class:`.VMobject` implement :meth:`.set_stroke` and :meth:`.set_fill`.  Instances of :class:`.Mobject` implement :meth:`.~Mobject.set_color` instead.  The vast majority of pre-defined classes are derived from :class:`.VMobject` so it is usually safe to assume that you have access to :meth:`.set_stroke` and :meth:`.set_fill`."
msgstr "Endast instanser av :class:`.VMobject` implementerar :meth:`.set_stroke` och :meth:`.set_fill`. Instanser av :class:`.Mobject` implementerar :meth:`.~Mobject.set_color` istället. De allra flesta fördefinierade klasser härstammar från :class:`.VMobject` så det är vanligtvis säkert att anta att du har tillgång till :meth:`.set_stroke` och :meth:`.set_fill`."

#: ../../source/tutorials/building_blocks.rst:189
msgid "Mobject on-screen order"
msgstr "Ordningen av Mobject på skärmen"

#: ../../source/tutorials/building_blocks.rst:191
msgid "The next scene is exactly the same as the ``MobjectStyling`` scene from the previous section, except for exactly one line."
msgstr "Nästa scen är exakt samma som ``MobjectStyling`` scenen från föregående avsnitt, med undantag för exakt en rad."

#: ../../source/tutorials/building_blocks.rst:209
msgid "The only difference here (besides the scene name) is the order in which the mobjects are added to the scene.  In ``MobjectStyling``, we added them as ``add(circle, square, triangle)``, whereas in ``MobjectZOrder`` we add them as ``add(triangle, square, circle)``."
msgstr "Den enda skillnaden här (förutom scennamnet) är den ordning i vilken mobjects läggs till i scenen. I ``MobjectStyling``, lade vi till dem som ``add(circle, square, triangle)``, medan vi i ``MobjectZOrder`` lägger till dem som ``add(triangle, square, circle)``."

#: ../../source/tutorials/building_blocks.rst:214
msgid "As you can see, the order of the arguments of :meth:`~.Scene.add` determines the order that the mobjects are displayed on the screen, with the left-most arguments being put in the back."
msgstr "Som du kan se så bestämmer ordningen på argumenten i :meth:`~.Scene.add` den ordning som mobjects visas på skärmen, så att argumentet längst till vänster hamnar längst bak."

#: ../../source/tutorials/building_blocks.rst:221
msgid "Animations"
msgstr "Animationer"

#: ../../source/tutorials/building_blocks.rst:223
msgid "At the heart of manim is animation.  Generally, you can add an animation to your scene by calling the :meth:`~.Scene.play` method."
msgstr "Manims största syfte är att animera. Allmänt så kan du lägga till en animation till din scen genom att anropa :meth:`~.Scene.play`-metoden."

#: ../../source/tutorials/building_blocks.rst:244
msgid "Put simply, animations are procedures that interpolate between two mobjects. For example, :code:`FadeIn(square)` starts with a fully transparent version of :code:`square` and ends with a fully opaque version, interpolating between them by gradually increasing the opacity.  :class:`.FadeOut` works in the opposite way: it interpolates from fully opaque to fully transparent.  As another example, :class:`.Rotate` starts with the mobject passed to it as argument, and ends with the same object but rotated by a certain amount, this time interpolating the mobject's angle instead of its opacity."
msgstr "Enkelt uttryckt är animationer procedurer som interpolerar mellan två mobjects. Till exempel börjar :code:`FadeIn(square)` med en helt genomskinlig version av :code:`square` och avslutas med en helt ogenomskinlig version, och detta sker genom att interpolera mellan dem genom att gradvis öka opaciteten.  :class:`.FadeOut` fungerar på motsatt sätt: den interpolerar från helt ogenomskinlig till helt genomskinlig. Som ett annat exempel :class:`.Rotate` börjar med mobjectet som skickats till det som argument, och slutar med samma objekt men roterat med ett visst belopp, genom att denna gångenn interpolera mobjektets vinkel istället för dess opacitet."

#: ../../source/tutorials/building_blocks.rst:255
msgid "Animating methods"
msgstr "Animeringsmetoder"

#: ../../source/tutorials/building_blocks.rst:257
msgid "Any property of a mobject that can be changed can be animated.  In fact, any method that changes a mobject's property can be used as an animation, through the use of :meth:`.animate`."
msgstr "Varje egenskap hos ett mobject som kan ändras kan även animeras. Faktum är att alla metoder som ändrar ett mobjects egenskaper kan användas som en animation genom att använda :meth:`.animate`."

#: ../../source/tutorials/building_blocks.rst:277
msgid ":meth:`.animate` is a property of all mobjects that animates the methods that come afterward. For example, :code:`square.set_fill(WHITE)` sets the fill color of the square, while :code:`sqaure.animate.set_fill(WHITE)` animates this action."
msgstr ":meth:`.animate` är en egenskap hos alla mobjekt som animerar metoderna som kommer efteråt. Till exempel anger :code:`square.set_fill(WHITE)` fyllnadsfärgen på fyrkanten, medan :code:`square.animate.set_fill(WHITE)` animerar detta."

#: ../../source/tutorials/building_blocks.rst:282
msgid "Animation run time"
msgstr "Animationens körtid"

#: ../../source/tutorials/building_blocks.rst:284
msgid "By default, any animation passed to :meth:`play` lasts for exactly one second. Use the :code:`run_time` argument to control the duration."
msgstr "Som standard varar varje animation som skickats till :meth:`play` i exakt en sekund. Använd argumentet :code:`run_time` för att kontrollera varaktigheten."

#: ../../source/tutorials/building_blocks.rst:297
msgid "Creating a custom animation"
msgstr "Skapa en egen animation"

#: ../../source/tutorials/building_blocks.rst:299
msgid "Even though Manim has many built-in animations, you will find times when you need to smoothly animate from one state of a :class:`~.Mobject` to another. If you find yourself in that situation, then you can define your own custom animation. You start by extending the :class:`~.Animation` class and overriding its :meth:`~.Animation.interpolate_mobject`. The :meth:`~.Animation.interpolate_mobject` method receives alpha as a parameter that starts at 0 and changes throughout the animation. So, you just have to manipulate self.mobject inside Animation according to the alpha value in its interpolate_mobject method. Then you get all the benefits of :class:`~.Animation` such as playing it for different run times or using different rate functions."
msgstr "Även om Manim har många inbyggda animationer, kommer det vara stunder när du behöver animera smidigt från ett tillstånd av ett :class:`~.Mobject` till ett annat. Om du befinner dig i den situationen kan du definiera en egen animation. Du börjar med att utöka :class:`~.Animation`-klassen och åsidosätter dess :meth:`~.Animation.interpolate_mobject`. :meth:`~.Animation.interpolate_mobject` -metoden får alfa som en parameter som startar vid 0 och ändras under hela animationen. Så du behöver bara manipulera self.mobject inuti Animation enligt alfa värdet i dess interpolate_mobject-metod. Då får du alla fördelar med :class:`~.Animation` såsom att spela det under olika körtider eller använda olika hastighetsfunktioner."

#: ../../source/tutorials/building_blocks.rst:306
msgid "Let's say you start with a number and want to create a :class:`~.Transform` animation that transforms it to a target number. You can do it using :class:`~.FadeTransform`, which will fade out the starting number and fade in the target number. But when we think about transforming a number from one to another, an intuitive way of doing it is by incrementing or decrementing it smoothly. Manim has a feature that allows you to customize this behavior by defining your own custom animation."
msgstr "Låt oss säga att du börjar med ett tal och vill skapa en :class:`~.Transform`-animation som omvandlar talet till ett annat givet tal. Du kan göra det med :class:`~.FadeTransform`, vilket kommer att tona bort det första talet och tona in det andra talet. Men när vi tänker på att omvandla ett tal till ett annat, är ett intuitivt sätt att göra det genom att inkrementera eller dekrementera det på ett smidigt sätt. Manim har en funktion som gör att du kan anpassa detta beteende genom att definiera din egen animation."

#: ../../source/tutorials/building_blocks.rst:311
msgid "You can start by creating your own ``Count`` class that extends :class:`~.Animation`. The class can have a constructor with three arguments, a :class:`~.DecimalNumber` Mobject, start, and end. The constructor will pass the :class:`~.DecimalNumber` Mobject to the super constructor (in this case, the :class:`~.Animation` constructor) and will set start and end."
msgstr "Du kan börja med att skapa din egen ``Count`` klass som utökar klassen :class:`~.Animation`. Klassen kan ha en konstruktor med tre argument, ett :class:`~.DecimalNumber` Mobject, start and end. Konstruktorn kommer att skicka :class:`~.DecimalNumber` Mobject till superkonstruktorn (i detta fall konstruktorn i :class:`~.Animation`) och kommer att ställa in start och slut."

#: ../../source/tutorials/building_blocks.rst:315
msgid "The only thing that you need to do is to define how you want it to look at every step of the animation. Manim provides you with the alpha value in the :meth:`~.Animation.interpolate_mobject` method based on frame rate of video, rate function, and run time of animation played. The alpha parameter holds a value between 0 and 1 representing the step of the currently playing animation. For example, 0 means the beginning of the animation, 0.5 means halfway through the animation, and 1 means the end of the animation."
msgstr "Det enda du behöver göra är att definiera hur du vill att det ska se ut för varje steg i animationen. Manim ger dig alfavärdet i :meth:`~. nimation.interpolate_mobject' metoden baserat på bildhastigheten av videon, hastighetsfunktionen och körtiden för den animation som spelas. Alfaparametern har ett värde mellan 0 och 1 som representerar steget i den aktuella animationen. Till exempel betyder 0 början av animationen, 0,5 betyder halvvägs genom animationen och 1 betyder slutet av animationen."

#: ../../source/tutorials/building_blocks.rst:320
msgid "In the case of the ``Count`` animation, you just have to figure out a way to determine the number to display at the given alpha value and then set that value in the :meth:`~.Animation.interpolate_mobject` method of the ``Count`` animation. Suppose you are starting at 50 and incrementing until the :class:`~.DecimalNumber` reaches 100 at the end of the animation."
msgstr "I fallet med ``Count`` animationen, behöver du bara hitta ett sätt att bestämma talet som ska visas för det givna alfavärdet och sedan ange det värdet i :meth:`~.Animation.interpolate_mobject` -metoden för ``Count``-animationen. Antag att du börjar med 50 och inkrementerar värdet tills :class:`~.DecimalNumber` når 100 i slutet av animationen."

#: ../../source/tutorials/building_blocks.rst:323
msgid "If alpha is 0, you want the value to be 50."
msgstr "Om alfa är 0, vill du att värdet ska vara 50."

#: ../../source/tutorials/building_blocks.rst:324
msgid "If alpha is 0.5, you want the value to be 75."
msgstr "Om alfa är 0,5, vill du att värdet ska vara 75."

#: ../../source/tutorials/building_blocks.rst:325
msgid "If alpha is 1, you want the value to be 100."
msgstr "Om alfa är 1, vill du att värdet ska vara 100."

#: ../../source/tutorials/building_blocks.rst:327
msgid "Generally, you start with the starting number and add only some part of the value to be increment according to the alpha value. So, the logic of calculating the number to display at each step will be - 50 + alpha * (100 - 50). Once you set the calculated value for the :class:`~.DecimalNumber`, you are done."
msgstr "Allmänt så börjar du med startnumret och adderar bara en del av värdet som ska inkrementeras enligt vad alfavärdet är. Så den programlogik som behövs för att beräkna talet som ska visas vid varje steg kommer att vara - 50 + alfa * (100 - 50). När du satt det beräknade värdet för :class:`~.DecimalNumber`-klassen är du klar."

#: ../../source/tutorials/building_blocks.rst:331
msgid "Once you have defined your ``Count`` animation, you can play it in your :class:`~.Scene` for any duration you want for any :class:`~.DecimalNumber` with any rate function."
msgstr "När du väl har definierat din ``Count`` animation kan du spela upp den i din :class:`~.Scene` med given varaktighet för vilken klass :class:`~.DecimalNumber` som helst, med valfri hastighetsfunktion."

#: ../../source/tutorials/building_blocks.rst:368
msgid "Using coordinates of a mobject"
msgstr "Använda ett mobjects koordinater"

#: ../../source/tutorials/building_blocks.rst:370
msgid "Mobjects contain points that define their boundaries. These points can be used to add other mobjects respectively to each other, e.g. by methods like :meth:`~.Mobject.get_center` , :meth:`~.Mobject.get_top` and :meth:`~.Mobject.get_start`. Here is an example of some important coordinates:"
msgstr "Mobject innehåller punkter som definierar objektets rand. Dessa punkter kan användas för att lägga till andra mobjects gentemot varandra, t.ex. genom metoder som :meth:`~.Mobject.get_center` , :meth:`~.Mobject.get_top` och :meth:`~.Mobject.get_start`. Här är ett exempel på några viktiga koordinater:"

#: ../../source/tutorials/building_blocks.rst:402
msgid "Transforming mobjects into other mobjects"
msgstr "Omvandla mobjects till andra mobjects"

#: ../../source/tutorials/building_blocks.rst:403
msgid "It is also possible to transform a mobject into another mobject like this:"
msgstr "Det är också möjligt att förvandla ett mobject till ett annat mobject på detta vis:"

#: ../../source/tutorials/building_blocks.rst:414
msgid "The Transform function maps points of the previous mobject to the points of the next mobject. This might result in strange behaviour, e.g. when the dots of one mobject are arranged clockwise and the other points are arranged counterclockwise. Here it might help to use the `flip` function and reposition the points via the `roll <https://numpy.org/doc/stable/reference/generated/numpy.roll.html>`_ function of numpy:"
msgstr "Transform-funktionen avbildar punkter hos det tidigare mobjectet till punkterna i nästa mobject. Detta kan resultera i konstigt beteende, t.ex. när punkter av ett mobject arrangeras medsols och det andra mobjectets punkter arrangeras motsols. Här kan det hjälpa att använda `flip`-funktionen och flytta punkterna via `roll <https://numpy.org/doc/stable/reference/generated/numpy.roll.html>`_ funktionen i numpy:"

#: ../../source/tutorials/building_blocks.rst:440
msgid "Scenes"
msgstr "Scener"

