[Jde-dev] refactorizacion eldercare y carclassifier

[David Lobato]

Hola,

Respondo por partes:

2010/12/10 redouane kachach <redo.robot en gmail.com>

> Hola David,
>
> Del EldeCare no tengo mucha idea así que no puedo aportar mucho. Solo por
> curiosidad en los parámetros que has puesto que significan la (w,h)? Te
> refieres al bonding-box del objeto?
>
>
El último algoritmo de ElderCare hace el tracking de prismas que se definen
por el centro,largo,ancho y alto (este se me ha olvidado, lo apaño). Es una
descripción de alto nivel, pero permite ver que metemos y que sacamos. Con
el algoritmo que uses en el clasificador deberías hacer lo mismo. Empieza
por alto nivel, y si luego quieres describir algún otro algoritmo usado por
este hazlo a parte.



> Sobre el CarClassifier mi idea es re-escribirlo desde zero en C++
> utilizando los patrones de diseño que propones para la arquitectura y
> tirando de OpenCV cuando haga falta. Tengo que pensar
> un poco en como quedara la cosa ya que mi idea es separarlo en dos
> componentes tracker y classifier y así el primero podrá ser utilizado como
> componente por separado. Pero no tengo claro
> si esta separación va ser sencilla y en su caso el impacto que tendrá en el
> tiempo de ejecución total. Teniendo en cuenta que en este caso como en el
> CarSpeed las cosas tienen que correr en
> tiempo-real así que habrá que aplicar todas las optimizaciones posibles,
>
>
Me parece buena la idea de separarlo, será más fácil de probar luego y sobre
todo lo podremos reutilizar. En cuanto a la unidad funcional no la basaría
en componentes, si no en librerías (aunque luego hagas un componente si
quieres...). De esta manera tendremos software mas manejable y reutilizable.
Además es cierto lo que dices, necesitamos tiempo real o lo más parecido que
podamos y la comunicación via componentes nos va a limitar. Lo mejor será
meterlo todo en el mismo componente con llamadas locales de las de toda la
vida.

Importante que uses OpenCV y STL para todo lo que puedas. También te invito
a que eches un ojo a los punteros inteligentes incluidos en el TR1 de C++
(#include <tr1/memory> y std::tr1::shared_ptr) pueden ser útiles para
manejar memoria más efectivamente.

 Te propongo que analices los algoritmos que quieres refactorizar y plantees
un API basado en el patrón de diseño que comentábamos y lo repasamos juntos.

Un saludete,
David.



> Saludos,
> Redo.
>
> 2010/12/1 David Lobato <dav.lobato en gmail.com>
>
>> Hola,
>>
>> El análisis de alto nivel del algoritmo Eldercare sería el siguiente:
>>
>> https://jde.gsyc.es/index.php/Eldercare_Algorithm
>>
>> Sólo he tenido en cuenta las entradas y las salidas. Queda refinar el
>> apartado de parámetro de configuración.
>>
>> A partir de esto, podemos generar el API de alto nivel para usar el
>> algoritmo.
>>
>> ¿Comentarios?
>>
>> 2010/11/30 David Lobato <dav.lobato en gmail.com>
>>
>> Hola,
>>>
>>> Este mensaje va dirigido a los que estáis liados o vais a estarlo en
>>> breve con Eldercare y Carclassifier, aunque si alguien quiere añadir o
>>> comentar algo será bienvenido.
>>>
>>> Creo que el primer paso que debemos dar antes de añadir nueva
>>> funcionalidad a lo que ya existe es refactorizar los algoritmos de modo que
>>> los empaquetemos en sendas librerías que nos faciliten su uso/mantenimiento
>>> posteriormente.
>>>
>>> El estado actual de Eldercare (y supongo que también del classifier) es
>>> un conjunto de funciones, alguna clase y muchas variables globales, que
>>> hacen un poco complicado ver que está sucediendo y mucho más depurar los
>>> errores. Además de estar bastante cohesionado con la interfaz gráfica.
>>>
>>> La idea es sacar toda la funcionalidad del algoritmo y encapsularla,
>>> definiendo un API para su uso. En mi TFM [1] describía un patrón de diseño
>>> para algoritmos iterativos (derivado de patrón Strategy) que creo encaja en
>>> la mayoría de algoritmos que hacemos, y sin duda encaja en el de eldercare y
>>> carclassifier. Así que creo que puede ser un punto de partida para ir
>>> definiendo las clases que tendrá cada algoritmo.
>>>
>>> El método de trabajo para refactorizar un algoritmo de los que tenemos
>>> hasta la fecha es simple:
>>>
>>>    1. Analizar sus entradas, salidas y parámetros de configuración
>>>    2. Declarar las clases en función de lo encontrado anteriormente (.h)
>>>    3. Definir las clases usando el código que ya tenemos (.cpp)
>>>
>>> Los puntos 1 y 2 podemos ir tratándolos en común para llegar a una
>>> solución consensuada. Si os parece empiezo con el punto 1 de Eldercare y
>>> continuamos juntos.
>>>
>>> Comentarios??
>>>
>>> Un saludo,
>>> David.
>>>
>>>
>>> [1]
>>> http://svn.jderobot.org/users/dlobato/tfm/trunk/memoria/jderobot5_thesis.pdf
>>>
>>> --
>>> David Lobato Bravo
>>>
>>> Universidad Rey Juan Carlos
>>> c/Tulipan s/n
>>> 28933 Móstoles
>>> Madrid, Spain
>>> http://jderobot.org
>>> http://es.linkedin.com/in/davidlobato
>>>
>>>
>>
>>
>> --
>> David Lobato Bravo
>>
>> Universidad Rey Juan Carlos
>> c/Tulipan s/n
>> 28933 Móstoles
>> Madrid, Spain
>> http://jderobot.org
>> http://es.linkedin.com/in/davidlobato
>>
>>
>> _______________________________________________
>> Jde-developers mailing list
>> Jde-developers en gsyc.es
>> http://gsyc.escet.urjc.es/cgi-bin/mailman/listinfo/jde-developers
>>
>>
>


-- 
David Lobato Bravo

Universidad Rey Juan Carlos
c/Tulipan s/n
28933 Móstoles
Madrid, Spain
http://jderobot.org
http://es.linkedin.com/in/davidlobato
------------ próxima parte ------------
Se ha borrado un adjunto en formato HTML...
URL: http://gsyc.escet.urjc.es/pipermail/jde-developers/attachments/20101210/9807b271/attachment-0001.htm