Curvas por trigonometría y funciones matemáticas

La trigonometría es una rama de las matemáticas cuyo significado etimológico es «la medición de los triángulos» y sirve para definir relaciones entre sus lados y ángulos como extensión del Teorema de Pitágoras. Las funciones trigonométricas que más se utilizan son las del seno y coseno, con ellas se generan números repetitivos que pueden ser utilizados para dibujar ondas, círculos, arcos y espirales.

La unidad de medida angular propia de la trigonometría es el radian, en una circunferencia completa hay 2π radianes.

Esta unidad puede traducirse a Grado sexagesimal: unidad angular que divide una circunferencia en 360 grados; o al Grado centesimal: divide la circunferencia en 400 grados centesimales.

Lua tiene la constante math.pi como valor π para trabajar con radianes.

Para convertir grados a radianes y viceversa, pueden utilizarse las funciones de Lua math.deg() y math.rad() y también las funciones de openFrameworks of.degToRad() y of.radTodeg().

Las funciones math.sin(x) y math.cos(x) se utilizan para determinar el valor del seno y coseno de un ángulo en radianes. Ambas funciones requieren como parámetro el ángulo.  El siguiente gráfico orienta los valores del seno (curva amarilla) y coseno (curva azul) en función de los ángulos.

Otras funciones matemáticas para convertir los datos obtenidos en números positivos o transformar datos con decimales en integrales (números enteros) son:

math.abs()  -- Devuelve el valor absoluto (no negativo) de un dato dado

     math.abs(-100)    -- devuelve    100

     math.abs(25.67)   -- devuelve    25.67

math.ceil() -- si el parámetro es un número decimal, devuelve el número entero superior

     math.ceil(0.5)    -- devuelve    1

math.floor -- si el parámetro es un número  decimal, devuelve el número entero inferior

     math.floor(0.5)     -- devuelve    0

math.modf()   -- devuelve dos valores, uno entero y otro la fracción

     math.modf(5)       --  devuelve     5       0

     math.modf(5.3)     -- devuelve      5       0.3

     math.modf(-5.3)    --  devuelve     -5      -0.3

math.pow()  -- Tiene dos parámetros y eleva el primero a la potencia del segundo

     math.pow(7, 2)    -- devuelve       49 [7 elevado a 2 ]      

     math.pow(3, 2.7)   -- devuelve      19.419023519771 [3 elevado a 2.7 ]

Para ver cómo funciona  math.sin(), retomamos un ejemplo de Ben Fry y Casey Reas (2007, 119-120), traducido al lenguaje de programación de Lua-Mosaic, porque permite observar qué parámetros controlan la amplitud y frecuencia de las curvas utilizándola en una estructura for.

--[[

 Lua-Mosaic        E-4-10
 -------------------------
 Onda sinusoidal

]]

_angle = 0.0
pos = OUTPUT_HEIGHT/2	-- posición Y
amplitude = 40.0	-- altura de la onda
inc = PI/30.0    	-- incremento del ángulo	

function draw()
    -- draw background first 
    mosaicBackground(255,255,255,255) -- fondo blanco sin transparencia
    of.setColor(0)

    for i = 0, OUTPUT_WIDTH, 5 do
        j = pos + (math.sin(_angle)*amplitude)
        of.drawRectangle(i, j, 2, 4)
        _angle = _angle + inc
    end
   _angle = 0.0

end

Siguiendo el ejemplo de Ben Fry y Casey Reas, si se modifican los valores asignados a las variables se puede observar los cambios en la frecuencia de la onda, teniendo en cuenta que la variable pos define la coordenada Y de la onda,amplitude controla la altura, e inc el incremento del ángulo.

Las siguientes imágenes muestran los cambios de frecuencia al modificar esos valores y el ángulo.

pos = 25

pos = 75

amplitud = 5.0

amplitud = 45.0

inc = PI/12.0

inc = PI/90.0

angle=HALF_PI

angle = PI

En el siguiente ejemplo se utilizan los datos que devuelven las funciones math.sin(x)  y math.cos(x) para calcular los centros de una espiral de círculos, haciendo una conversión de grados a radianes con la función math.rad()

--[[
 Lua-Mosaic                E-4-11
 ---------------------------------
 Trigonometría espiral

]]

radio = 30     --variable global

function setup()

end

function draw()
    -- draw background first 
    mosaicBackground(255,255,255,255) -- fondo blanco sin transparencia

    of.setColor(0)	
    radio = 30
    for grade = 0, 360*4, 10 do
        _angle = math.rad(grade) 		 --variable local
        posx = OUTPUT_WIDTH/2+ (math.cos(_angle) * radio) 
        posy = OUTPUT_HEIGHT/2+ (math.sin(_angle) * radio)
        of.drawCircle(posx, posy, 4)
        radio = radio + 1                      -- incremento del radio
  end
end

La espiral se genera por pequeños círculos cuyo centro se va alejando progresivamente del centro de la pantalla a la vez que giran alrededor de él.

Para calcular la posición de esos centros se utiliza una estructura for que recorre cuatro veces los 360º de un círculo de 10 en 10 grados. El resultado de los grados que se obtienen (10, 20, 30, 40,…) se pasa a radianes mediante la función de Lua math.rad(), por ejemplo math.rad(180) = 3.1415926535898, es decir PI.

El alejamiento progresivo del centro se produce al incrementar la variableradio, si se comentara radio=radio+1, el código dibujaría un círculo de círculos.

La repetición del valor inicial de la variable, radio = 30, en el bloque draw() y fuera del for, sirve para detener el crecimiento en loop de su valor en cada frame.

Una variación del este ejemplo nos lleva a la configuración de obra Rotating Disc (1925) de Marcel Duchamp. Más adelante volveremos a ella para aplicarle la rotación, de momento analizamos el código para generar la imagen fija.

--[[ 
 Lua-Mosaic           E-4-12
 ---------------------------
  Artists/Duchamp - Rotoreliefs
  creado por n3m3da && mj

]]

radio = 15
spiralFactor = 15
numCircles = 23

function setup()
    of.enableSmoothing()
    of.setCircleResolution(50)
end

function update()
    
end

function draw()
  -- draw background first 
  mosaicBackground(255,255,255,255) -- fondo blanco sin transparencia
  of.setColor(0)
  of.noFill()
  of.setLineWidth(3)
  radio = 15
  for i = 0, numCircles do
    _angle = i* math.rad(360)/((numCircles/2) +1)
    posx = (OUTPUT_WIDTH/2) + (math.cos(_angle) * spiralFactor) 
    posy = (OUTPUT_HEIGHT/2) + (math.sin(_angle) * spiralFactor)
    of.drawCircle(posx, posy, radio)
    radio = radio + spiralFactor	
   end
end

En este caso no se utilizan los grados del círculo en la estructura for, sino el número de repeticiones (círculos a dibujar).

El centro de todos los círculos está situado en el perímetro de un círculo no dibujado, cada uno de ellos separado por 45º. La diferencia de sus radios, spiralFactor, se corresponde al valor de ese mismo círculo invisible que distribuye la tangencia de los otros, es esa tangencia lo que produce la percepción de una espiral.