Tracking Video

Los sistemas de tracking video están vinculados al campo de computer vision, su aplicación en el ámbito del arte proporciona una información importante para explorar nuevos modos de conexión e interactividad entre el cuerpo físico del espectador y la representación del mundo digital. A través del ojo de la cámara, el sistema puede reconocer posiciones, movimientos, colores, gestos o rostros, dentro de su campo visual, siempre que las condiciones de iluminación sean  favorables.

Conociendo esos datos, se pueden programar aplicaciones ante las que el espectador puede interactuar de forma más intuitiva, denominándose por ello interfaces gestuales, es decir, se interactúa con la pieza sin tocar botones u otros interfaces físicos. En el arte interactivo y electrónico son numerosos los ejemplos de este tipo de aplicaciones, que también ha incrementado su presencia en las artes escénicas.

Existen distintos algoritmos para la detección, uno de los más utilizados es Background Subtraction. El sistema almacena un frame de video que se considera como fondo (una matriz de pixels con unas cualidades concretas de posición y color) que se considera como referencia para ir comparándola con  los siguientes frames.  Cuando se detectan cambios en un grupo de pixels que están bastante juntos entre sí, al reconocimiento de ese área se le denomina blob y se representa mediante una superficie rectangular.

En Mosaic, el objeto para aplicar esta técnica lleva su mismo nombre: Background subtraction. Consta de dos inlets:

• Input. Es una entrada de tipo textura (VP_LINK_TEXTURE) y permite conectar una señal de video grabado o en directo
• Reset. Entrada de tipo numérico (VP_LINK_NUMERIC) y permite resetear la imagen de referencia del fondo, generando una nueva, puede activarse mediante los objetos Bang o LoadBang

Y un outlet de tipo textura (VP_LINK_TEXTURE)

Al desplegar su configuración se pueden ver las siguientes opciones:

• Reset Background. Al presionarlo captura el frame de referencia como imagen fondo. La misma acción puede hacerse desde el inlet Reset.
• ADAPTIVE: adapt speed. Controla la velocidad de adaptación al entorno. Si el fondo cambia significativamente (se aclara u oscurece) se requiere una mayor velocidad de adaptación.
• Subtraction algorithm. Hay 3 opciones:
  • B&W ABS, Blanco y negro absoluto.
  • Lighter than,  las formas a detectar son más claras que el fondo.
  • Darker than,  las formas a detectar son más oscuras que el fondo
• Threshold Regular el umbral de sensibilidad del algoritmo, cuanto menor es su valor, más sensible es, por lo que detecta más cambios.
• Brigth. Regula el brillo en la imagen detectada.
• Contrast. Regula su contraste
• Blur. Desenfoca.
• Erode. Reduce en un pixel el perímetro de las zonas detectadas.
• Dilate. Las amplía un pixel.

En la imagen puede verse el objeto Background subtraction en un patch en el que también se utiliza el objeto Contour Tracking.

El objeto Contour Tracking tiene un solo inlet de tipo textura (VP_LINK_TEXTURE), por el que recibe la señal de video del objeto Background subtraction escalada, y cuatro outlets:

• El primero de tipo textura (VP_LINK_TEXTURE)
• El segundo outlet pasa los datos de los blobs detectados en formato vector<float> (VP_LINK_ARRAY). Si se comunica esta salida con un objeto Lua Script, estos datos pueden ser recogidos por la tabla _mosaic_data_inlet. Recordad que en Lua las tablas empiezan por 1, no por 0;  siendo el orden de los valores de este outlet para _mosaic_data_inlet:
  • [1] -> número de blobs activos
  • [2] -> blob ID —> accesible como _mosaic_data_inlet[2 + 16*N] siendo N el número de blobs activos
  • [3] -> tiempo del blob (en milliseconds)
  • [4] -> blob centroid X     —> accesible como _mosaic_data_inlet[4 + 16*N]
  • [5] -> blob centroid Y     —> accesible como _mosaic_data_inlet[5 + 16*N]
  • [6] -> blob average X      —> accesible como _mosaic_data_inlet[6 + 16*N]
  • [7] -> blob average Y       —> accesible como _mosaic_data_inlet[7 + 16*N]
  • [8] -> blob center X         —> accesible como _mosaic_data_inlet[8 + 16*N]
  • [9] -> blob center Y          —> accesible como _mosaic_data_inlet[9 + 16*N]
  • [10] -> blob velocidad X —> accesible como _mosaic_data_inlet[10 + 16*N]
  • [11] -> blob velocidad Y  —> accesible como _mosaic_data_inlet[11 + 16*N]
  • [12] -> blob area               —> accesible como _mosaic_data_inlet[12 + 16*N]
  • [13] -> blob perímetro     —> accesible como _mosaic_data_inlet[13 + 16*N]
  • [14] -> coordenada X  del blob —> accessible como _mosaic_data_inlet[14 + 16*N]
  • [15] -> coordenada Y blob —> accessible como _mosaic_data_inlet[15 + 16*N]
  • [16] -> Anchura del blob   —> accessible como _mosaic_data_inlet[16 + 16*N]
• El tercer outlet pasa los datos del contorno de las formas detectadas también en formato vector<float> (VP_LINK_ARRAY). El orden de los valores de este outlet en el array para ser recogidos por _mosaic_data_inlet es:
  • [1] -> número de blobs activos
  • [2] -> número de vértices del contorno
  • [3] -> blob ID —> accesible como _mosaic_data_inlet[3 + 5*N] siendo N el número de blobs activos
  • [4] -> tiempo del blob (en milliseconds)
  • [5 – 5+(_mosaic_data_inlet[2] * 2)] -> vértices del contorno del blob
• El cuarto outlet pasa los datos del contorno geométrico que envuelve las formas detectadas (convex hulls). El orden de los valores de este outlet es el mismo que los del anterior outlet

Al desplegar el menú de configuración se ven las siguientes opciones:

• Invert. Invierte la detección de la figura por el fondo
• Threshold. Regular el umbral de sensibilidad del algoritmo, cuanto menor es su valor, más sensible es.
• Min. Area. Desestima las zonas detectadas con un área menor a lo que regule.
• Max. Area. Desestima las zonas detectadas con un área mayor a lo que regule.

En la imagen se pueden ver los tres tipos de contorno de la zona detectada. El contorno rectangular que enmarca la forma corresponde al blob, cuyos datos se trasladan por el segundo outlet. Por el tercer outlet salen los datos del contorno detallado próximo a los bordes de la forma. Y por el cuarto outlet, los datos de la forma geométrica que rodea la forma.

En el siguiente ejemplo se detectan los blobs y su interacción con una tabla de strings que al colisionar, invierten el sentido de su movimiento. Para ello, a nivel de tracking,  se necesita saber el número de blobs, y los parámetros x, y, ancho y alto de cada uno de ellos.

--	----------------------------------------------------------
--	Mosaic | OF Visual Patching Developer Platform
--
--	Copyright (c) 2020 Emanuele Mazza aka n3m3da
--
--	Mosaic is distributed under the MIT License.
--	This gives everyone the freedoms to use Mosaic in any context:
--	commercial or non-commercial, public or private,
--	open or closed source.
--
--  See https://github.com/d3cod3/Mosaic for documentation
--	----------------------------------------------------------
--
--
--	empty.lua: A Lua script template for Mosaic,
--	mimicking the standard OF app structure

---------------------------------- MOSAIC SPECIFIC CODING INFO

-- Mosaic system variable for loading external resources (files)
-- Example:
-- img = of.Image()
-- img:load(SCRIPT_PATH .. "/data/test.jpg")

---------------------------------- MOSAIC SPECIFIC CODING INFO


----------------------------------- MOSAIC VARS (DO NOT TOUCH)

-- variables for mouse interaction
mouseX = 0
mouseY = 0

-- variable for storing _mosaic_data_inlet size
mosaic_data_inlet_size = 0
----------------------------------- MOSAIC VARS (DO NOT TOUCH)
-- blobs variables
-- blobs vector from "contour tracking" Mosaic object is constructed as follows:
--
-- REMEMBER, A LUA TABLE START INDEX IS 1, NOT 0 !!!
--
-- [1] -> number of active blobs
-- [2] -> blob ID            ---> accessible as _mosaic_data_inlet[2 + 16*N] for N blobs
-- [3] -> blob age (milliseconds)
-- [4] -> blob centroid X
-- [5] -> blob centroid Y
-- [6] -> blob average X
-- [7] -> blob average Y
-- [8] -> blob center X
-- [9] -> blob center Y
-- [10] -> blob velocity X
-- [11] -> blob velocity Y
-- [12] -> blob area
-- [13] -> blob perimeter
-- [14] -> blob bounding rect X        ---> accessible as _mosaic_data_inlet[14 + 16*N] for N blobs
-- [15] -> blob bounding rect Y
-- [16] -> blob bounding rect Width
-- [17] -> blob bounding rect Height
--

numBlobs = 0
-------- text variables
text = {}
textTableSize = 0
font = {}
actualWord = 0
wait = 500


----------------------------------------------------
function setup()

    text = {"Time", "present", "and", "time", "past", "Are", "both", "perhaps", "present", "in", "time", "future", "And", "time", "future", "contained", "in", "time", "past"}

    for k,v in pairs(text) do
        textTableSize = textTableSize + 1  -- to now table length
    end
 -- of.log(of.LOG_NOTICE,textTableSize) -- delete the comment signs to see the length table in the Logger

    for i = 1, textTableSize do     -- Properties of the elements of the tables text and font
        font[i] = {}
        font[i].t = of.TrueTypeFont()
        font[i].t:load(SCRIPT_PATH .. "/Anonymous_Pro_B.ttf", 16)
        if i>1 then
            font[i].x = font[i-1].t:stringWidth(text[i-1])+font[i-1].x + 12
        else
            font[i].x = 20
        end

        font[i].y = of.random(12, OUTPUT_HEIGHT/10)
        font[i].speedy = of.random(1,2)
    end


end

----------------------------------------------------
function update()

	------------------------------------------------ MOSAIC CODE
	mosaic_data_inlet_size = getMosaicDataInletSize()

	-- send data to _mosaic_data_outlet if needed
	-- we are using here just the first position of the table
	-- but you can expand it with numerical data as you need it
	-- _mosaic_data_outlet[1] = of.random(10)
	------------------------------------------------ MOSAIC CODE


	----------------------------------------- For Text Table
	if numBlobs > 0 then
	    if of.getElapsedTimeMillis() > wait then
	        if actualWord < textTableSize then 
                    actualWord = actualWord + 1 
                else 
                    actualWord = textTableSize 
                end 
               of.resetElapsedTimeCounter() 
           end 
      end 
end 
---------------------------------------------------- 
function draw() 
     ------------------------------------------------ MOSAIC CODE 
     checkMosaicDataInlet() 
     ------------------------------------------------ MOSAIC CODE 
     -- draw background first 
     mosaicBackground(0,0,0,255) 
     ----------------------------------------- Drawing blobs 
     of.setLineWidth(3) 
     of.noFill() 

     numBlobs = _mosaic_data_inlet[1] 

     if numBlobs > 0 then
          for j=0, numBlobs-1 do
               x = _mosaic_data_inlet[14 + 16*j] -- parameter Blobs -- x
               y = _mosaic_data_inlet[15 + 16*j] -- parameter y
               w = _mosaic_data_inlet[16 + 16*j] -- width
               h = _mosaic_data_inlet[17 + 16*j] -- height

               of.setColor(31,165,210)
               of.drawRectangle(x,y,w,h)         -- Draw Blobs

               of.setColor(255)
               -----------------------------------------  Drawing letters
               for i = 1, actualWord do
                    font[i].y = font[i].y + font[i].speedy
                    if font[i].y > OUTPUT_HEIGHT then 
                       -- if letter arrives at the end of the screen, it returns to the top
                       font[i].y = 0
                    end

                    if font[i].y < 0 then 
                       -- When it reappears, it recovers the fall speed 
                       font[i].speedy = of.random(1,2) 
                       font[i].y = font[i].y + font[i].speedy 
                   end 
                   -- if parameters x, y, width, and height of the letters collide with the blobs, 
                   -- the direction of their velocity is reversed 
                   if font[i].y +font[i].t:stringHeight(text[i]) > y and font[i].x+font[i].t:stringWidth(text[i])> x and font[i].x < x+w then
                       font[i].speedy = font[i].speedy *-1
                       font[i].y = font[i].y + font[i].speedy
                   end
                   font[i].t:drawString(text[i], font[i].x, font[i].y)
            end
        end
    end
end

----------------------------------------------------
function exit()

end

----------------------------------------------------