
English: 
Hi.
So this video that I'm
making is about a function
in p5.js called map.
So there's a very
common scenario
that comes up over and
over and over again
in programming graphics,
programming interaction,
working with data.
There's so many places that
this scenario comes up.
And so this particular
function, map,
is a nice resolution
to this problem.
And let me give you a simple
version of this problem.
So let's say we have a canvas.
And the canvas has
a background color.
And what you want is for
that background color
to sometimes be black
and sometimes be white.
So when it's black,
the color that you

Hindi: 
नमस्ते।
तो यह वीडियो जो मैं बना रहा हूं वह एक फंक्शन के बारे में है
p5.js में map कहा जाता है।
तो एक बहुत ही सामान्य परिदृश्य है
वह बार-बार ऊपर आता है
प्रोग्रामिंग ग्राफिक्स, प्रोग्रामिंग इंटरैक्शन में,
डेटा के साथ काम करना।
ऐसी बहुत सी जगहें हैं जो इस परिदृश्य में आती हैं।
और इसलिए यह विशेष कार्य, map,
इस समस्या का एक अच्छा समाधान है।
और मैं आपको इस समस्या का एक सरल संस्करण देता हूं।
तो चलिए बताते हैं हमारे पास एक कैनवास है।
और कैनवास पर पृष्ठभूमि का रंग होता है।
और जो आप चाहते हैं वह उस पृष्ठभूमि के रंग के लिए है
कभी काला होना और कभी सफेद होना।
तो जब यह काला होता है, तो रंग जो आप

French: 
Salut! Cette vidéo est à propos d'une 
fonction dans p5js appelée map().
Donc, il existe un scenario très courant
se répète encore et encore
dans la programmation graphique, dans 
la programmation interactive,
lorsqu'on travaille avec des données,
il y a tellement d'endroits où
ce scénario s'applique. Et donc
cette fonction particulière map()
est une belle solution à ce problème.
Laissez-moi vous donner une version
simplifiée de ce problème:
disons que nous avons un canvas (toile),
et que le canvas a une couleur de fond
et que ce que vous voulez est
que cette couleur de fond
soit parfois noire
et parfois blanche.
Donc quand elle est noire
la couleur que vous devriez donner
à la fonction background()

Spanish: 
¡Hola! Entonces, este video que estoy haciendo es sobre una función en p5.js llamado map()
Entonces, hay un escenario muy común que aparece una y otra vez
en gráficos de programación, interacción de programación,
trabajando con datos, hay tantos lugares donde
este escenario aparece y esta función map() en  particular
es una buena resolución para este problema
Déjame darte una versión simple de este problema:
así que digamos que tenemos un lienzo,
y el lienzo tiene un color de fondo
y lo que quieres es para este color de fondo
a veces sea negro y, a veces sea blanco.
Entonces cuando es negro
el color que debes poner en la función background

Hindi: 
पृष्ठभूमि समारोह में रखा जाना चाहिए 0 है।
जब यह सफेद होता है, तो आपको पृष्ठभूमि में रंग डालना चाहिए
फ़ंक्शन 255 है।
तो हम कह सकते हैं, एक साथ, पृष्ठभूमि के लिए सीमा
फ़ंक्शन जो मुझे इस विशेष कार्यक्रम में चाहिए
0 और 255 के बीच एक संख्या।
तो वास्तव में, एक चर यहाँ जा सकता है।
हम इसे COL कहेंगे। और COL चाहिए
0 और 255 के बीच की सीमा हो।
अब, मैं कैसे उस मूल्य को चुनना चाहता हूं?
यह कब काला होना चाहिए और कब सफेद होना चाहिए?
माउस पॉइंटर होने पर मुझे क्या पसंद आएगा
at this side of the screen, I want the background
काला होना।
और जब स्क्रीन के इस तरफ माउस पॉइंटर होता है,
मैं चाहता हूं कि पृष्ठभूमि सफेद हो।
इसलिए मैं एक परिदृश्य बनाना चाहूंगा जहां
मैं माउस को बाएँ और दाएँ, बाएँ और दाएँ घुमाता हूँ,
और मैं काले रंग की पृष्ठभूमि को हर तरफ से देखता हूं
सफेद करने के लिए, नीचे करने के लिए ग्रे, गहरे भूरे रंग, नीचे काले,
वगैरह, वगैरह।
यह वही है जिसे हम प्रोग्राम करना चाहते हैं।

English: 
should put in the
background function is 0.
When it is white, the color you
should put in the background
function is 255.
So we can say, together,
the range for the background
function that I want in
this particular program is
a number between 0 and 255.
So really, a variable
might go here.
We'll call it COL.
And COL should
have a range between 0 and 255.
Now, how do I want that
value to be chosen?
When should it be black and
when should it be white?
What I would like is
when the mouse pointer is
at this side of the screen,
I want the background
to be black.
And when the mouse pointer is
at this side of the screen,
I want the background
to be white.
So I would like to
create a scenario where
I move the mouse left and
right, left and right,
and I see the background
shift from black all the way
to white, down to gray,
darker gray, down to black,
et cetera, et cetera.
This is what we want to program.

Spanish: 
es 0.
Cuando es blanco, el color que debe poner en la función background
es 255.
Entonces podemos decir,  que el rango para la función background
que quiero en este programa en particular es un número entre 0 y 255.
Entonces, realmente una variable podría ir aquí
como, uh, lo llamaremos 'col'
y 'col' debe tener un rango
entre 0 y 255.
Ahora bien, ¿qué quiero que
valor que se ha elegido?
¿Cuándo debe ser de color negro
y cuando debe ser de color blanco?
Lo que me gustaría es:
cuando el puntero del ratón está
en este lado de la pantalla
Quiero que el fondo sea negro,
y cuando el puntero del ratón está
en este lado de la pantalla
Quiero que el fondo sea blanco.
Así que me gustaría crear un escenario
cuando muevo el ratón
izquierda y derecha, izquierda y derecha,
y veo el fondo
pasar de negro todo el camino a blanco,
hasta gris, gris oscuro,
hasta negro, etc, etc.
Así que esto es lo que se quiere programar.

French: 
est 0.
Quand c'est blanc, la couleur que
vous devriez donner à la fonction background()
est 255.
Donc, nous pouvons dire, ensemble,
la gamme de valeurs pour la fonction background()
que je veux pour ce programme spécifique
est un nombre entre 0 et 255.
Donc, en fait une variable pourrait
venir ici
comme... Appelons-là 'col' (couleur)
et 'col' devrait avoir une game de
valeurs entre 0 et 255.
Maintenant, comment vais-je choisir
cette valeur?
Quand devrait-elle être noire et 
quand devrait-elle être blanche?
Ce que je voudrais est:
quand le pointeur de la souris est
de ce côté de l'écran
je voudrais que la couleur de fond
soit noire
et quand le pointeur de la souris est
de ce côté de l'écran
je voudrais que la couleur de fond
soit blanche.
Donc, je voudrais crer un scenario
où je déplace la souris
de gauche à droite, et je vois
la couleur de fond
changer de noir et progressivement vers
blanc, en passant par du gris,
de retour vers noir, etc.
Donc, c'est ce que nous voulons 
programmer.

Hindi: 
अब, मान लें कि इस कैनवास में 600 बाई 400 के आयाम हैं।
तो माउस x एक चर है।
यदि आप इन वीडियो को क्रम से देख रहे हैं, जो
आपको इस विशेष वीडियो को देखने की आवश्यकता नहीं है,
माउस x हाल की नई घटना का एक प्रकार है
कि मैंने अभी पिछले वीडियो में बात की है।
तो अगर ये कैनवास के आयाम हैं,
हम जानते हैं कि माउस x की एक सीमा होती है जो 0 और 600 के बीच जाती है।
इसलिए हम अब पृष्ठभूमि का रंग चाहते हैं
एक दर है - ओह, क्षमा करें।
मैंने अपने विचार की ट्रेन को वहीं खो दिया।
माउस में 0 और 600 के बीच की सीमा होती है
और पृष्ठभूमि रंग हम चाहते हैं
0 और 255 के बीच की एक सीमा।
इसलिए हमें इस रेंज के साथ इस मूल्य को लेने की आवश्यकता है
और हम क्या करना चाहते हैं?
इसे इस श्रेणी में मैप करें।
जब माउस x 0 के बराबर होता है, तो पृष्ठभूमि रंग 0 के बराबर होता है।
जब माउस x 600 के बराबर होता है, तो पृष्ठभूमि का रंग 255 के बराबर होता है।

French: 
Maintenant, disons que ce canvas a des
dimensions de 600x400.
Donc, mouseX est une variable, si vous avez
regardé mes vidées en séquence
[...]
Donc, si ce sont les dimensions du
canvas,
nous savons que mouseX aura une gamme
de valeurs de 0 à 600.
[...]
et nous voulons que la couleur de fond aie
une gamme de 0 à 255.
Donc nous devons prendre cette valeur,
avec cette gamme, et ce que nous voulons faire
est de la reporter sur cette gamme.
Lorsque mouseX = 0,
la couleur de fond = 0
Lorsque mouseX = 600,
la couleur de fond = 255.

English: 
Now, let's say this canvas
has dimensions of 600 by 400.
So mouse x is a variable.
If you've been watching these
videos in sequence, which
you don't need to have been to
watch this particular video,
mouse x is a sort of
recent new phenomenon
that I just talked about
in a previous video.
So if these are the
dimensions of the canvas,
we know that mouse x has a range
that goes between 0 and 600.
So we now want the
background color
to have a rate-- oh, sorry.
I lost my train
of thought there.
The mouse has a range
between 0 and 600
and the background
color we want to have
a range between 0 and 255.
So we need to take this
value with this range
and what do we want to do?
Map it to this range.
When mouse x equals 0,
background color equals 0.
When mouse x equals 600,
background color equals 255.

Spanish: 
Ahora vamos a decir que este lienzo tiene
dimensiones de 600x400.
Así mouseX es una variable, si tienes
estado viendo estos videos en secuencia
[divagar]
por lo que si estas son las dimensiones 
del lienzo
sabemos que tiene un rango mouseX
que va entre 0 y 600.
[divagar]
Y el color de fondo que queremos
tener un rango entre 0 y 255.
Así que tenemos que tomar este valor, la 
este rango, y lo que queremos hacer
es el mapa que a este intervalo.
Cuando mouseX = 0, 
color de fondo = 0.
Cuando mouseX = 600,
color de fondo = 255.

English: 
Let's kind of like start
doing that a little bit
for a moment without
the map function at all.
OK, so here's the program.
I'm going to actually
simplify this for a second.
Var color equals 0.
I'm going to say
background color.
And you can see this.
So we can see here, here
I'm running this program.
This ellipse is being
drawn where the mouse is,
so we can see.
And the background
is being colored
according to that variable.
But the background
color is not changing
because I set it equal to
0 and I never changed it.
So now I could try
to do some math.
Like I could just say
color equals mouse x.
Why not?
That's pretty good.
Whatever the value
of mouse x is,
set the background
color to that.
So let's see what happens.
I'm going to run this.
Look, it's working,
it's changing.
But it's already white.
Why?
Because as soon
as I get to pixel
255, that's the full whiteness.
So I'm not getting
this perfect mapping.
It's kind of working, but
it's not exactly right.

French: 
Essayons de faire ça pour un instant
sans la fonction map().
Ok, voici le programme ... Je vais en fait
le simplifier pour un instant
var col = 0;
Je vais dire: couleur de fond contient
'col'.
et vous pouvez voir ça!
Donc, vous pouvez voir, je fais tourner
ce programme, et cette ellipse
est dessinée où la souris se trouve,
et la couleur de fond
est dessinée suivant la valeur
de la variable 'col'.
La couleur de fond ne change pas
parce qu'elle est mise à 0.
et je ne la change jamais.
Donc, je pourrais essayer de faire
un peu de math,
donc, je pourrais dire:
col = mouseX;
pourquoi pas? c'est plutôt pas mal.
Mettons la valeur de background à mouseX
peu importe sa valeur
Donc, voyons ce qu'il se passe.
Je vais faire tourner ça.
Regardez, ça marche ...
Ca change mais c'est déjà blanc!
Pourquoi? Parce ce dès que j'arrive au
pixel 255
C'est tout à fait blanc!
Donc, je n'obtiens pas ce report parfait.
Ca marche presque mais pas 
tout à fait correct.

Spanish: 
Eso es un poco como, vamos a empezar a hacer
que un poco por un momento
sin la función de mapa en absoluto.
Ok, así que aquí está el programa ... En realidad soy
va a simplificar esto por un segundo.
var col = 0;
Voy a decir: color de fondo
contiene 'col',
y se puede ver esto!
Así podemos ver aquí estoy corriendo
este programa, esta elipse
se está elaborando en el que el ratón es,
por lo que podemos ver, y el fondo
es ser de color de acuerdo a esa variable (col).
El color de fondo no está cambiando
porque lo fijo igual a 0,
y nunca he cambiado.
Así que ahora yo podría tratar de hacer algunos cálculos,
como si pudiera decir simplemente: 
col = mouseX;
¿Por qué no? eso es bastante bueno.
Cualquiera que sea el valor de mouseX es 
establecer el color de fondo a eso!
Así que vamos a ver qué pasa.
Voy a correr esto.
Mira que está funcionando ...
está cambiando pero es ya blanco!
¿Por qué? Porque tan pronto como llegue 
al píxel 255
esa es la blancura completa!
Así que no estoy recibiendo este mapeo perfecto,
es un poco como trabajar pero es
no es exactamente correcto.

Hindi: 
तरह तरह के शुरू करते हैं कि थोड़ा सा
एक क्षण के लिए बिना map कार्य के।
ठीक है, तो यहाँ program है।
मैं वास्तव में एक सेकंड के लिए इसे सरल बनाने जा रहा हूं।
वर रंग = ०।
मैं बैकग्राउंड कलर कहने जा रहा हूं।
और आप इसे देख सकते हैं।
इसलिए हम यहां देख सकते हैं, यहां मैं यह program चला रहा हूं।
यह दीर्घवृत्त खींचा जा रहा है जहां माउस है,
तो हम देख सकते हैं।
और पृष्ठभूमि रंगीन की जा रही है
उस चर के अनुसार।
लेकिन पृष्ठभूमि का रंग नहीं बदल रहा है
क्योंकि मैंने इसे 0 के बराबर सेट किया था और मैंने इसे कभी नहीं बदला।
इसलिए अब मैं कुछ गणित करने की कोशिश कर सकता था।
जैसे मैं कह सकता हूँ कि रंग माउस x के बराबर है।
क्यों नहीं?
वह बहुत बढिया है।
माउस x का मान जो भी हो,
उस पर पृष्ठभूमि रंग सेट करें।
तो चलिए देखते हैं क्या होता है।
मैं इसे चलाने जा रहा हूं।
देखो, यह काम कर रहा है, यह बदल रहा है।
लेकिन यह पहले से ही सफेद है।
क्यूं?
क्योंकि जैसे ही मैं पिक्सेल के लिए मिलता है
255, वह पूर्ण सफेदी है।
इसलिए मुझे यह परफेक्ट मैपिंग नहीं मिल रही है।
यह काम करने की तरह है, लेकिन यह बिल्कुल सही नहीं है।

French: 
Donc, je pourrais être approximatif,
je peux dire:
ok, le canvas est 600 pixels de large,
pourquoi ne pas diviser par 2?
C'est plutôt pas mal ...
600, ou quoique mouseX soit,
diviser par 2, ça serait
plus ou moins proche
ça semble marcher pas mal
et nous avons plus ou moins résolu
le problème, mais néanmoins:
ce problème que nous avons juste 
à peine résolu ici
c'en est une vue très simpliste.
Mais il y a un nombre de fois où vous
avez un senseur, des données arrivent
d'une sorte de senseur et les valeurs
vont de 321 à 1057,
et si vous voulez reporter ces valeurs
sur une autre ensemble de valeurs
et que cet autre ensemble de valeurs va
de 20 à 35
le calcul est un peu plus complexe.
Ou peut-être vous voulez prendre une
valeur qui va de 0 à 200
et inverser ces valeurs et les reporter
vers 200 à 0.
Donc, il y a plein d'autres scénarios plus
complexes.
La fonction map() est une fonction 
générale qui prend un gamme de valeurs

English: 
So I can be approximate
and I can say,
OK, the canvas is
600 pixels wide.
Why don't I divide by 2?
That's pretty good.
Whatever the mouse
x is divided by 2.
That's getting me pretty close.
It actually kind of
looks like it's working
and, you know, we kind
of solved the problem.
But here's the thing.
This problem that we have
just sort of barely solved
over there, this is a very
simplistic view of it.
But there's lots of times where
you have a sensor, like data
coming in from some
sensor and the range
is between 321 and 1057.
And then you want
to map that range
to some other set of values.
And actually, that
other set of values
has a range between 20 and 35.
And the math is a
little bit trickier.
Or perhaps you want
to take a value that
goes between 0 and
200 and invert that
and map that between
200 down to 0.
So there's lots of
more complex scenarios.
The map function is
a general function

Spanish: 
Así que podría ser aproximada, 
Puedo decir: ok, vamos,
la tela es de 600 píxeles de ancho, 
¿por qué no divido por 2?
Eso es bastante bueno ... 
600, o lo que el mouseX es,
dividirlo por 2, eso es 
conseguirme muy cerca
En realidad se ve un poco como que está funcionando
y que tipo de resuelto el problema
pero aquí está la cosa:
este problema que acabamos de
Apenas resuelto por allí
esta es una visión muy simplista de la misma.
Pero hay un montón de momentos en los que
tener un sensor, como datos que entran
de algún sensor y el rango es entre,
usted sabe, 321 y 1057,
y luego quieres mapear ese rango 
a algún otro conjunto de valores
y en realidad ese otro conjunto de valores
tiene un rango entre 20 y 35
y la matemática es un poco más complicado.
O tal vez usted quiere tomar un valor
que va entre 0 y 200
e invertir eso y que entre el mapa 
200 a 0.
Así que hay una gran cantidad de escenarios más complejos.
La función de mapa es una función general
que se llevará a cualquier rango y el mapa

Hindi: 
तो मैं लगभग हो सकता है और मैं कह सकता हूं,
ठीक है, कैनवास 600 पिक्सल चौड़ा है।
मैं 2 से विभाजित क्यों नहीं करता?
वह बहुत बढिया है।
जो भी माउस एक्स 2 से विभाजित होता है।
वह मुझे बहुत करीब आ रही है।
यह वास्तव में एक तरह का दिखता है जैसे यह काम कर रहा है
और, आप जानते हैं, हमने समस्या को हल कर दिया है।
लेकिन यहाँ बात है।
यह समस्या है कि हमारे पास बस मुश्किल से हल है
वहाँ पर, यह इसका एक बहुत ही सरल दृष्टिकोण है।
लेकिन कई बार आपके पास एक सेंसर होता है, जैसे डेटा
कुछ सेंसर और रेंज से आ रहा है
321 और 1057 के बीच है।
और फिर आप उस रेंज को मैप करना चाहते हैं
मूल्यों के कुछ अन्य सेट के लिए।
और वास्तव में, मूल्यों के अन्य सेट
20 और 35 के बीच की सीमा है।
और गणित थोड़ा पेचीदा है।
या शायद आप एक ऐसा मूल्य लेना चाहते हैं जो
0 और 200 के बीच जाता है और उलटा करता है
और map जो 200 से नीचे 0 के बीच है।
इसलिए बहुत अधिक जटिल परिदृश्य हैं।
map फ़ंक्शन एक सामान्य फ़ंक्शन है

English: 
that will take any range and
map a value inside that range
to a new value in
any other range.
So let's take a look at how
that works in this context.
So first of all, what
do I mean by function?
So already, hopefully you know
about calling functions in p5.
Right?
You might have done this.
Line is a function that
takes four arguments.
One, two, three, four.
And what does it do?
It draws a line from
point 100, 100 to 50, 50.
Done.
So map is the same thing.
It's a function that takes
some amount of arguments.
It's actually going
to be five arguments.
I better give myself
more room here.
I can see that you're not
going to be able to see this.
Map, it takes five arguments.
One, two, three, four, five.
Can you see all those?
Yes.

Hindi: 
जो किसी भी सीमा को ले जाएगा और उस सीमा के अंदर एक मान को मैप करेगा
किसी अन्य श्रेणी में एक नए मूल्य के लिए।
तो आइए एक नज़र डालते हैं कि इस संदर्भ में कैसे काम करता है।
तो सबसे पहले, मुझे फ़ंक्शन से क्या मतलब है?
तो पहले से ही, उम्मीद है कि आप पी 5 में कॉलिंग फ़ंक्शन के बारे में जानते हैं।
सही?
आपने ऐसा किया होगा।
लाइन एक फ़ंक्शन है जो चार तर्क लेता है।
एक दो तीन चार।
और यह क्या करता है?
यह बिंदु 100, 100 से 50, 50 तक एक रेखा खींचता है।
किया हुआ।
तो map एक ही बात है।
यह एक ऐसा कार्य है जो कुछ राशि लेता है।
यह वास्तव में पाँच तर्क हैं।
मैं अपने आप को यहां और बेहतर जगह देता हूं।
मैं देख सकता हूं कि आप इसे देखने में सक्षम नहीं होंगे।
Map, यह पाँच तर्क लेता है।
एक दो तीन चार पांच।
क्या आप उन सभी को देख सकते हैं?
हाँ।

French: 
et reporte une valeur dans cette gamme
vers une autre valeur dans une autre gamme.
Donc, voyons ça...
... comment ceci fonctionne 
dans ce contexte.
Donc, en premier, qu'est-ce que je veux 
dire par fonction?
Donc, vous savez déjà, espérons,
appeler des fonctions dans p5, d'accord?
Vous avez pu faire ceci:
line() est une fonction qui prend 4 arguments.
1, 2, 3, 4 ... et qu'est-ce qu'elle fait?
Elle dessine une ligne depuis un point 100, 100
vers un point 50,50. Fini.
Donc, map() c'est la même chose:
c'est une fonction qui prend
une quantité d'arguments.
En fait, 5 arguments.
Je ferais mieux de me donner un peu
plus de place ici
map() prend 5 arguments:
1, 2, 3, 4, 5.
Pouvez-vous les voir tous? 
Oui.

Spanish: 
un valor dentro de ese rango para
un nuevo valor en cualquier otro rango.
Por lo tanto, vamos a echar un vistazo ...
... cómo funciona en este contexto.
Así, en primer lugar, ¿qué quiero decir por la función?
Así que ya sabes, con suerte,
en llamar a funciones en p5, ¿verdad?
Es posible que haya hecho esto:
línea () es una función que toma 4 argumentos.
1, 2, 3, 4 ... y qué hace?
Se dibuja una línea desde el punto 100,100
a un punto 50,50. Hecho.
Así mapa () es la misma cosa:
es una función que toma
una cierta cantidad de argumentos.
De hecho, es que va a ser 5 argumentos.
[divagar]
Mapa () se tarda 5 argumentos: 1.2.3.4.5.
¿Puede usted ver todos los? Sí.

English: 
OK, so this seems like,
oh, boy, five arguments.
That's terrifying.
But actually, it's not so bad.
So remember, I have a range
that goes between 0 and 600.
This is the range we
know that mouse x is.
And I want to map this range
to a range between 0 and 255,
which is what I want to
assign to my variable color.
So the arguments that map
requires are the following.
What is the minimum and
maximum of my current range?
0 to 600.
What is the minimum and
maximum of my new range?
0 to 255.
And what is the value
that has this range which
I want to map to the new range?
Well, in this
case, it's mouse x.
So I want to map
mouse x, which I
know has this range,
that's the x values.

Spanish: 
Ok, esto parece como: Oh, muchacho, 
5 argumentos! eso es aterrador!
Pero en realidad no es tan malo.
Así, recuerda: Tengo una gama
que va entre 0 y 600,
este es el rango sabemos que
mouseX es, y quiero mapa
este rango para un rango entre 0 y 255,
que es lo que desea asignar
a mi 'col' variable.
Por lo que los argumentos que map () requiere
son los siguientes:
lo que es el mínimo y máximo 
de mi rango actual? 0 a 600.
¿Cuál es el mínimo y el máximo
de mi nueva gama? 0 a 255.
Y lo que es el valor que tiene esta gama,
que quiero asignar a la nueva gama?
Bueno, en este caso se trata de mouseX.
Así que quiero para mapear mouseX, que sé
tiene este rango, eso es los valores de x,

Hindi: 
ठीक है, तो ऐसा लगता है, ओह, पांच तर्क।
यह भयानक है।
लेकिन वास्तव में, यह इतना बुरा नहीं है।
तो याद रखें, मेरे पास एक सीमा है जो 0 और 600 के बीच जाती है।
यह वह सीमा है जिसे हम जानते हैं कि माउस x है।
और मैं इस सीमा को 0 और 255 के बीच की श्रेणी में मैप करना चाहता हूं,
जो मैं अपने चर रंग को असाइन करना चाहता हूं।
तो जिन तर्कों के लिए मानचित्र की आवश्यकता होती है, वे निम्नलिखित हैं।
मेरी वर्तमान सीमा का न्यूनतम और अधिकतम क्या है?
0 से 600।
मेरी नई श्रेणी की न्यूनतम और अधिकतम सीमा क्या है?
0 से 255 ।
और वह मान क्या है जिसकी यह सीमा है
मैं नई रेंज में मैप करना चाहता हूं?
खैर, इस मामले में, यह माउस एक्स है।
इसलिए मैं माउस x को मैप करना चाहता हूं, जो मैं
पता है कि यह सीमा है, यह x मान है।

French: 
Ok, ça ressemble à... dis donc!
5 arguments! ça fait peur!
Mais, en réalité, 
c'est pas si mal.
Donc, rappelez-vous: j'ai une gamme de
valeurs de 0 à 600,
il s'agit de la gamme de valeurs de
mouseX, et je voudrais reporter
ces valeurs vers un ensemble de 
valeurs de 0 à 255,
que je voudrais assigner à ma
variable 'col'.
Donc, les arguments que map() demande
sont les suivants:
Quel sont les minimum et le maximum
de valeurs courantes? 0 à 600.
Quel sont les minimum et maximum
des nouvelles valeurs? 0 à 255.
Et quel est la valeur qui a cette 
étendue,
qui ce que je veux reporter vers ce nouvel
ensemble de valeur? Dans ce cas, mouseX.
Donc, je veux reporter mouseX, dont je
sais qu'il a cette gamme, les valeurs de x,

English: 
And I want to map it to
this range between 0 and 255
for the purpose of color.
And then when I map it,
what do I do with it?
I want to take the result of
that mapping and set it equal.
Assign the result to
my variable color.
So this is actually
something quite new
about this map function.
The line function doesn't do--
it performs a task.
Line.
It draws a line in the canvas.
Well, whatever.
The computer draws a
line on the canvas.
The map function actually
performs a calculation
and answers a question.
It resolves to a single number.
So I can use that number
and assign it back
to this variable.
OK?
So this is kind
of a new concept.
Let's go try to do
it in this program.
So instead of my
goofy math here,
mouse x divided by 2,
what I want to do now
is use that map function.
So I'm going to go over
here, I'm going to say map,

Spanish: 
y quiero hacer un mapa de
este rango de entre 0 y 255
a los efectos de color.
Y luego, cuando me Localizar en un mapa,
¿que hago con esto?
Quiero aprovechar el resultado de que la cartografía
y asignar el resultado a mi 'col' variable.
Así que esto es lo que en realidad es algo
bastante nuevo acerca de esta función de mapa ().
La función de línea () realiza una tarea:
¡línea! dibuja una línea en el lienzo.
La función de mapa () realiza realidad
un cálculo y responde a una pregunta,
se resuelve a un solo número,
así que puedo utilizar ese número
y asignar de nuevo a esta variable, de acuerdo?
Así que esto es una especie de un nuevo concepto.
Vamos a tratar de hacerlo en este programa.
Así que en lugar de mis matemáticas goofy como aquí, 
mouseX / 2,
lo que quiero hacer ahora 
es utilizar esa función de mapa ().
Así que voy a ir de aquí 
y que voy a decir:

Hindi: 
और मैं इसे 0 से 255 के बीच इस श्रेणी में मैप करना चाहता हूं
रंग के उद्देश्य से।
और फिर जब मैं इसे मैप करता हूं, तो मैं इसके साथ क्या करता हूं?
मैं उस मैपिंग का परिणाम लेना चाहता हूं और इसे बराबर करना चाहता हूं।
मेरे परिवर्तनशील रंग को परिणाम निर्दिष्ट करें।
तो यह वास्तव में काफी कुछ नया है
इस map फ़ंक्शन के बारे में।
लाइन फ़ंक्शन नहीं करता है--
यह एक कार्य करता है।
लाइन।
यह कैनवास में एक रेखा खींचता है।
खैर जो भी हो।
कंप्यूटर कैनवास पर एक रेखा खींचता है।
map फ़ंक्शन वास्तव में गणना करता है
और एक सवाल का जवाब देता है।
यह एकल संख्या में हल होता है।
इसलिए मैं उस नंबर का उपयोग कर सकता हूं और उसे वापस सौंप सकता हूं
इस चर के लिए।
ठीक?
तो यह एक नई अवधारणा की तरह है।
आइए इस कार्यक्रम में इसे करने की कोशिश करते हैं।
इसलिए यहाँ मेरे नासमझ गणित के बजाय,
माउस x 2 से विभाजित, मैं अब क्या करना चाहता हूं
map कार्य का उपयोग करता है।
तो मैं यहाँ पर जा रहा हूँ, मैं कहने जा रहा हूँ map,

French: 
et je veux le reporter vers cet
ensemble de valeurs de 0 à 255
pour l'utiliser comme couleur.
Et lorsque je fais le report,
qu'est-ce que je voudrais en faire?
Je veux prendre le résultat de ce report
et l'assigner à ma variable 'col'.
Donc, ce qui est en fait relativement 
nouveau à propos de cette fonction map().
Cette fonction line() réalise une tâche:
Elle dessine une ligne sur le canvas.
Cette fonction map() réalise en fait 
un calcul et répond à une question,
elle se résout vers un simple nombre,
de telle sort que je puisse utiliser ce nombre
et l'assigner à cette variable, ok?
Donc, c'est une sorte de nouveau concept.
Essayons de faire ça dans ce programme.
Donc, au lieu de mes calculs maladroits, 
mouseX/2,
Ce que je faire maintenant
Est utiliser la fonction map()
Je vais venir ici
Et je vais dire :

French: 
map(mouseX, 0, 600, ...)
(oops, je vais dézoomer)
Et me donner une nouvelle valeur dans
Dans une nouvelle gamme de 0 à 255.
Donc ici: mouseX va de 0 à 600
Donne-moi une gamme de valeur
de 0 à 255
Et assigne cette valeur à la 
variable 'col'.
Que je vais utiliser pour background().
Regarder ça…
Nous pouvons voir tout le long,
Parfaitement blanc au pixel 600,
Parfaitement noir au pixel zéro.
Amusons-nous petit peu ça !
L'amusement est tout relatif, bien sûr.
Donnons-nous deux variables 
supplémentaires,
Donc je vais créer les variables 'r' et 'b',
r pour rouge (red), b pour bleu (blue),
Et ce que je vais faire est
Je vais mettre la valeur rouge
Égale à ce report,
Donc vous pouvez voir maintenant...
Bleu état de 255, rouge est à 0,
Et air devient ce rapport avec mouseX,

English: 
mouse x, which has a
range between 0 and 600.
Oops, I guess I
better zoom back out.
And give me a new value within
a new range between 0 and 255.
So here, mouse x
between 0 and 600
give me a range from 0
and 255 and assign that
to this variable
color, which I'm then
going to use in background.
And watch this.
You can see all the way
perfectly white at pixel 600,
perfectly black at pixel 0.
Let's have a little
more fun with this.
Fun is all relative, of course.
Let's give ourselves
two more variables.
So I'm going to make a variable
r and b, r for red, b for blue.
And what I'm going
to do is I'm going
to set the red value
equal to that mapping.
So you can see now blue
is at 255, red is at 0.
And red, r, is getting
that mapping with mouse x.

Spanish: 
Mapa (mouseX, 0, 600, ...
(Vaya, voy a salir del zoom)
y dame un nuevo valor dentro 
una nueva gama entre 0 y 255.
Así que aquí: mouseX entre 0 y 600
dame un rango entre 0 y 255,
y asignar a que esta variable 'col',
lo cual estoy a continuación, el uso va en el fondo ().
y ver esto ...
podemos ver todo el camino, 
perfectamente blanca en el píxel 600,
perfectamente negro en el pixel 0.
Vamos a tener un poco más divertido con esto!
Uh, diversión es relativo, por supuesto.
Vamos a darnos dos variables más,
así que voy a hacer una 'r' variable y 'b',
r para el rojo, b para el azul,
y lo que voy a hacer es
Voy a establecer el valor de rojo
igual a la cartografía, 
por lo que se puede ver ahora ...
azul es en el 255, el rojo está en 0,
yr es conseguir que el mapeo con mouseX

Hindi: 
माउस x, जिसकी सीमा 0 से 600 के बीच है।
ओह, मुझे लगता है कि मैं बेहतर तरीके से वापस ज़ूम आउट करता हूं।
और मुझे 0 और 255 के बीच एक नई सीमा के भीतर एक नया मूल्य दें।
तो यहाँ, 0 और 600 के बीच माउस x
मुझे 0 और 255 से एक सीमा दें और असाइन करें
इस चर रंग के लिए, जो तब मैं हूं
पृष्ठभूमि में उपयोग करने के लिए जा रहा है।
और ये देखो।
आप पिक्सेल 600 पर सभी तरह से सफेद देख सकते हैं,
पिक्सेल 0 पर पूरी तरह से काला।
चलिए इसके साथ थोड़ी और मस्ती करते हैं।
मज़ा सभी रिश्तेदार है, ज़ाहिर है।
आइए अपने आप को दो और चर दें।
तो मैं एक चर आर और बी बनाने जा रहा हूं, लाल के लिए आर, नीला के लिए बी।
और जो मैं करने जा रहा हूं वह मैं हूं
उस मैपिंग के बराबर लाल मान सेट करने के लिए।
तो आप देख सकते हैं अब नीला 255 पर है, लाल 0 पर है।
और लाल, आर, माउस x के साथ उस mapping को प्राप्त कर रहा है।

English: 
So as I move to the right,
I get more pink and purple,
all the way back more blue.
And here's something
interesting I could do with map.
Let's also map the blue value.
But instead of saying
when the mouse is at 0,
the blue is at 0.
When the mouse is at
600, the blue is at 255.
Let's do the reverse.
Let's say when the mouse
is at 0, we have 255 blue,
and when the mouse is all
the way on the other side,
we have 0 blue.
So we can also invert
that range, which is great
that map will do that for us.
And all the way, we can
see I get all the way red,
all the way blue,
and in the middle,
I've got red and blue together.
And also, by the way,
if you're thinking
of-- so you might
take this exercise,
maybe add mouse y to
it, try to map mouse y.
There's all sorts of possible
things you can do with this.
So hopefully that gives you
a bit of a sense of the map
function and that you found
that useful, possibly.

Spanish: 
de manera que me muevo a la derecha
Consigo más rosa y púrpura,
todo el camino de vuelta más azul,
y aquí hay algo interesante
que podía hacer con el mapa ()
vamos también el mapa del valor azul
pero en lugar de decir: cuando el ratón está en 0, 
el azul es a 0,
cuando el ratón está en 600, 
el azul es en el 255, vamos a hacerlo a la inversa!
Digamos que cuando el ratón es a 0
tenemos 255 azul,
y cuando el ratón hasta el final
Por otro lado tenemos 0 azul.
Así también podemos invertir ese rango,
que es grande ese mapa va a hacer eso por nosotros.
Y ... todo el camino podemos ver 
Me sale todo el camino rojo,
todo el camino azul, y en el centro 
Tengo rojo y azul juntos.
Por lo tanto, y también por la forma, 
usted podría tomar este ejercicio
tal vez añadir mouseY a ella, 
tratar de asignar mouseY,
hay todo tipo de cosas posibles
se puede hacer con esto.
Así que espero que le da un poco 
de un sentido de la función map ()
y que ha encontrado que útil, posiblemente.
Ok, voy a parar esto.

Hindi: 
इसलिए जैसे-जैसे मैं दाईं ओर बढ़ता हूं, मुझे और अधिक गुलाबी और बैंगनी रंग के होते हैं,
सभी तरह से अधिक नीला।
और यहाँ कुछ दिलचस्प है जो मैं map के साथ कर सकता था।
आइए नीले रंग का मान भी लें।
लेकिन कहने के बजाय जब माउस 0 पर हो,
नीला 0 पर है।
जब माउस 600 पर होता है, तो नीला 255 पर होता है।
चलो उल्टा करते हैं।
मान लीजिए कि जब माउस 0 पर है, तो हमारे पास 255 नीले हैं
और जब माउस दूसरी तरफ है,
हमारे पास 0 नीला है।
तो हम उस सीमा को उल्टा भी कर सकते हैं, जो महान है
वह map हमारे लिए ऐसा करेगा।
और सभी तरह से, हम देख सकते हैं कि मुझे लाल रास्ता मिल गया है,
सभी तरह से नीले, और बीच में
मैं एक साथ लाल और नीला हो गया हूं।
और यह भी, वैसे, अगर आप सोच रहे हैं
- तो आप इस अभ्यास को ले सकते हैं,
शायद इसमें माउस y जोड़ें, माउस y को मैप करने का प्रयास करें।
इस के साथ आप कर सकते हैं सभी प्रकार की संभव चीजें हैं।
तो उम्मीद है कि आप map की एक बिट देता है
फ़ंक्शन और आपने पाया कि उपयोगी, संभवतः।

French: 
Donc comme je me déplace vers la droite,
J'obtiens plus de rose et pourpre
Et tout de l'autre côté, plus de bleu
Et voici une chose intéressante
Que je pourrais faire avec map()
Qui serait aussi reporter
la valeur de bleu
Mais au lieu de dire: lorsque la souris 
est à zéro, bleu est à 0,
Lorsque la souris est à 600,
bleu est à 255, faisons l'inverse!
Disons que quand la souris est à 0,
On a bleu à 255,
Et lorsque la souris et toute 
de l'autre côté, on a 0 de bleu.
Donc, avec map(), nous pouvons 
aussi inverser ses valeurs
Et tout le long nous pouvons voir
j'obtiens du rouge
Et tout du long du bleu, au milieu,
J'ai du rouge et du bleu mélangés.
Donc, aussi, à propos,
vous pourriez reprendre cet exercice
Y ajouter mouseY éventuellement,
essayer de reporter mouseY,
Il y a plein de choses que
que vous pourriez faire avec ça.
Donc espérons, que ceci vous donne
une bonne impression de ce que
la fonction map() peut faire.
Et que votre vieux ça utile.
Ok, je vais arrêter ici

Hindi: 
ठीक है, मैं इसे रोकने जा रहा हूं।
उफ़।

Spanish: 
Subtítulos por la comunidad Amara.org

English: 
OK, I'm going to stop this.
Oops.

French: 
Sous-titres réalisés par la communauté d’Amara.org
