Traduct Processing code to OF code. Involve Particle system and blob detection

Hello people.
This post its bi lingual: English and below spanish.

Dear openFrameworkers:
I translated a code developed by me in Processing (attached as “perturbations_low_res.rar”) to OF 0.11 (“attached as Blobs Particles and cam II.rar”) in order to be able to generate a larger graphical window than in Processing code and have a good FPS rate so that the system flows well.
What the Processing code performs:
 It generates a system of particles using the library bring physic: http://murderandcreate.com/physics/
This system is a set of particles with forces of attraction / repulsion between them and vertical and horizontal springs between them as if it were an elastic fabric or a grid of balls joined together by these springs.
" createMalla"metodocalled online 55, developed in the pestaña “Crear_Malla”
The particles are arranged in a matrix.

 Capture image using the web cam built into my notebook.
Method"captureimage"called in line 73 and developed in the pestaña “Capturar_imagen”.

 Analyzes the image by performing a blob detection. Line 88
 In line 143 the code evaluates the distance between a blob the particle [x][y] of the matrix, if the distance is less than radius * 2 the circle representing the particles on the screen (line 153) takes the coordinates of the blob otherwise it takes the position of the particle{x}{y} of the matrix. In this way the system of particles inmotion.
 Each particle in the system takes the colors of the pixel corresponding to its position
Lines 106 and 108.

In short there is an interactivity between a particle system and real space sensed by the web cam,any movement in real space disturbs the particlesystem. Somehow, by the springs the system retains a certain uniqueness as if it were a fabric that twists but does not disintegrate.
I warn that in the Processing code there may be garbage, that is, some variables that are not used, etc.
Thetab “DrawBlob” and"Fast_Blur" does not performanytasks.

The goal of the OF code is the same, I want to get the same result as the Processing code. For the OF code I used the same particle system library as in Processing.
The results are not the same, the system does not behave in the same way, in OF the particle mesh loses its cohesion and the system does not flow. It is true that in the code of Of there are many more particles than in Processing, in OF the mesh is 2280 * 1720 while in Processing it is 800 * 800. The goal of translating code is to achieve fluency with a much larger particle system thinking about the power of the C++ language.

Possible solutions:
 Efficiently manage memory access in C++, a task that I do not know how to perform.
 Use another physics library. I have tried most of the physical libraries found in https://ofxaddons.com/ some examples have not worked for me I guess because they are very old, in others the efficiency of the performance is not optimal, one that uses shaders,replace the particle “mouse” with the x coordinates, y of a detected blob and the shaders stopped being generated. (I’m also going to publish a post to fix this problem.)

Of course I thank the community
Mi mail lozdanmultimedial@gmail.com
-------------------------------------------------------------------------- End English

-------------------------------------------------------------------------------- Post en Español --------
Estimados openFrameworkers:
Traduje un código desarrollado por mí en Processing (adjuntado como “perturbaciones_low_res.rar”) a OF 0.11 (“adjuntado como Blobs Partículas y cam II.rar”) con el fin de poder generar una ventana grafica mayor que en código de Processing y tener una buena tasa de FPS para que el sistema fluya bien.
Que realiza el código de Processing:
 Genera un sistema de partículas empleando la librería traer physic: http://murderandcreate.com/physics/
Este sistema es un conjunto de partículas con fuerzas de atracción/repulsión entre ellas y resortes verticales y horizontales entre ellas como si fuese una tela elástica o una grilla de bolitas unidas entre sí por dichos resortes.
método “crearMalla” llamado en línea 55, desarrollado en la pestaña “Crear_Malla”
Las partículas se ordenan en una matriz.

 Captura imagen mediante la web cam incorporada a mi notebook.
Método “capturarimagen” llamado en línea 73 y desarrollado en la pestaña “Capturar_imagen”.

 Analiza la imagen realizando un blob detection. Línea 88
 En la línea 143 el código evalúa la distancia entre un blob la partícula [x][y] de la matriz, si la distancia es menor a radio * 2, el circulo que representa a las partículas en pantalla (línea 153) toma las coordenadas del blob caso contrario toma la posición de la partícula{x}{y} de la matriz. De esta manera el sistema de partículas entra en movimiento.
 Cada partícula del sistema toma los colores del pixel correspondiente a su posición
Líneas 106 y 108.

En resumen hay una interactividad entre un sistema de partículas y el espacio real sensado por la web cam, cualquier movimiento en el espacio real perturba el sistema de partículas. De alguna manera, por los resortes el sistema conserva cierta unicidad como si fuese una tela que se retuerce pero que no se desintegra.
Advierto que en el código de Processing puede haber basura, es decir algunas variables que no son usadas, etc.
La pestaña “DibujarBlob” y “Fast_Blur” no realizan ninguna tarea.

El objetivo del código de OF es el mismo, deseo obtener el mismo resultado que el código de Processing. Para el código de OF he utilizado la misma librería de sistema de partículas que en Processing.
Los resultados no son los mismos, el sistema no se comporta de la misma manera, en OF la malla de partículas pierde su cohesión y el sistema no fluye. Es cierto que en el código de Of hay muchas más partículas que en Processing, en OF la malla es de 2280 * 1720 mientras que en Processing es de 800 * 800. El objetivo del traducir el código es lograr fluidez con un sistema de partículas mucho mayor pensando en la potencia del lenguaje C++ .

Posibles soluciones:
 Manejar en forma eficiente en C++ los accesos a memoria, tarea que no sé cómo realizar.
 Utilizar otra librería de física. He probado la mayoría de las librerías físicas que se encuentran en https://ofxaddons.com/ algunas los ejemplos no me han funcionado supongo porque son muy antiguos, en otras la eficiencia del rendimiento no es óptima, una que utiliza shaders, reemplaze la partícula “mouse” por las coordenadas x, y de un blob detectado y los shaders dejaron de generarse. (Voy a publicar también un post para solucionar este problema.)

Desde ya agradezco a la comunidad
Mi mail lozdanmultimedial@gmail.com

Code-Codigos:
OF Cofde: OF code.rar - Google Drive

Processing code: Processing code.rar - Google Drive

Any Images :
https://www.claudiolozdan.com/criptoarte-generativo
click in “Perturbations” - “Perturbaciones”

Thanks full.