Progreso noviembre 2023

SEMANA 28 (30/10/2023-05/11/2023)

SEMANA 29 (06/10/2023-12/11/2023)

SEMANA 30 (13/10/2023-19/11/2023)

Semana 28 (30/10/2023-05/11/2023)

Detección de objetos por python

Debido a que a tras la detección de las posiciones de las frutas mediante el programa de Jupyter Notebook, no se puede trabajar directamente con ellas y enviarlas al robot, ya que Jupyter Notebook está basado en web, por lo que haría falta un servidor web intermediario, como por ejemplo Django, se intentó llevar a cabo la detección mediante python, para que de este modo, se pudieran enviar al brazo robótico directamente las coordenadas, al estar trabajando en local, y tener todo el código unificado.

Para ello se tomó como referencia y ayuda los repositorios Real Time Emotion Detection for Low Cost Robot in ROS y Detección de objetos en vídeo.

Para tener en orden nuestras paqueterias de python creamos el ambiente "deteccionobj" el cual tiene la version 3.6 de python.
```
conda create -n deteccionobj python=3.6
```
Activamos el ambiente deteccionobj para asegurarnos que estemos en el ambiente correcto al momento de hacer la instalación de todas las paqueterias necesarias.
```
conda activate deteccionobj
```
Estando dentro de nuestro ambiente y habiendo clonado el repositorio Detección de objetos en vídeo se instalarán todas las paqueterías necesarias para correr nuestro detector de objetos en vídeo, la lista de los paquetes y versiones a instalar están dentro del archivo requirements.txt por lo cual instalaremos haciendo referencia a ese archivo.
```
pip install -r requirements.txt
```
Al instalar este archivo, apareció el siguiente error:

No pudiendo desinstalar la versión de certifi para poder instalar una más reciente, por lo que se solucionó con el comando:
```
pip install --ignore-installed certifi
```
Se volvió a intentar ejecutar el programa deteccion_video.py varias veces, obteniendo problemas ModuleNotFoundError, por lo que se tuvieron que instalar varios módulos:
```
pip install torch torchvision torchaudio
```
```
pip install matplotlib
```
```
pip install opencv-python
```
Sin embargo, al volver a ejecutar el programa tras instalar estos módulos, se obtuvo lo siguiente:
Pruebas de uso de la cámara Kinect en Ubuntu

Paralelamente a las pruebas para la detección de objetos mediante python, se llevó a cabo la instalación de la cámara Kinect en Linux.

Para ello, primero se instalaron las siguientes librerías:
- git-core
- cmake
- libglut3-dev
- pkg-config
- build-essential
- libxmu-dev
- libxi-dev
- libusb-1.0-0-dev
- gcc
- g++
Después de haber instalado estas librerías, es necesario clonar el repositorio libfreenect de OpenKinect.
```
git clone https://github.com/OpenKinect/libfreenect.git
```
Después de haber clonado este repositorio, accederemos a la carpeta que se creó "libfreenect" donde se encuentra el paquete freenect.
```
cd libfreenect
```
En esta carpeta, se creará otra carpeta llamada "build", para posteriormente dirigirse a ella.
```
mkdir build
cd build
```
Para compilar todos los archivos que contiene el paquete, se utilizará el comando CMake:
```
cmake ..
make
```
Finalmente, se ejecutarán las siguientes instrucciones para finalizar la instalación del paquete:
```
sudo make install
sudo ldconfig /usr/local/lib64/
```
Para ejecutar los ejemplos que contiene el paquete, se tendrá que acceder a la carpeta "examples".

Una vez allí, se probará a ejecutar el glview, ejemplo en el que podremos obtener la imagen a color y en otro cuadro el diagrama de profundidad, además en este ejemplo se puede mover el motor hacia arriba y hacia abajo con las teclas w y x respectivamente; con la tecla s podemos centrar el motor en la posición normal. Ademas con las números del 0 al 6 podemos variar el color del LED del Kinect.
```
cd examples
./glview.c
```
Al ejecutar esto, se obtiene el mensaje "Permiso denegado", este error se debe a que se está intentando ejecutar un archivo fuente (en este caso, glview.c), en lugar de un archivo ejecutable.

Para compilar y ejecutar un programa C, se debe compilar el código fuente en un archivo ejecutable antes de ejecutarlo:

1. Compilar el programa: Primero, se debe compilar el archivo fuente glview.c en un archivo ejecutable. Se puede hacer utilizando el compilador de C, por ejemplo, GCC.
```
gcc -o glview glview.c -lfreenect
```
Sin embargo, al ejecutar este comando se obtuvo el siguiente fallo:

Este error indica que la constante FREENECT_AUTO_FLICKER no está definida en el programa glview.c. En su lugar, sugiere FREENECT_AUTO_EXPOSURE como una opción similar. Esto puede deberse a diferencias en las versiones de libfreenect o a cambios en la API de libfreenect, por lo que, en un editor de texto se busca la línea que contiene la referencia a FREENECT_AUTO_FLICKER y se reemplaza esa constante con FREENECT_AUTO_EXPOSURE.

Tras este cambio, se intentó ejecutar de nuevo el comando anteriormente mencionado, obteniendo el error:

Esto es debido a la falta de definiciones de funciones y bibliotecas relacionadas con OpenGL. Para compilar un programa que utiliza OpenGL, se debe enlazar adecuadamente con las bibliotecas de OpenGL. Esto se hace agregando las opciones de enlace correctas al comando gcc.

Para solucionar este problema, puedes usar el siguiente comando de compilación:
```
gcc -o glview glview.c -lfreenect -lGL -lGLU -lglut -lm
```
Este comando agrega las siguientes opciones de enlace:
- lGL: Enlaza con la biblioteca principal de OpenGL.
- lGLU: Enlaza con la biblioteca OpenGL Utility (GLU) que proporciona funciones útiles para OpenGL.
- lglut: Enlaza con la biblioteca GLUT, que es una biblioteca para crear ventanas y gestionar eventos de teclado y ratón en aplicaciones gráficas.
- lm: Enlaza con la biblioteca matemática, que proporciona funciones matemáticas como sqrt y atan2.
2. Otorgar permisos de ejecución: Una vez teniendo el archivo ejecutable, hay que otorgar permisos para ejecutarlo. Se puede hacer con el siguiente comando:
```
chmod +x glview
```
3. Ejecutar el programa:
```
./glview
```
El vídeo de la prueba se puede encontra en Prueba Kinect.mp4
Elaboración de la memoria

De manera paralela a la consecución de pruebas, se inició la elaboración de la memoria del trabajo.

Semana 29 (06/10/2023-12/11/2023)

Detección de objetos por python

Para solucionar el cv2.error, se modificó el programa deteccion_video.py, más concretamente la iteración a través de las detecciones encontradas en la variable detections, siendo cada detection un objeto detectado en la imagen, en la que se declararon como enteros las coordenadas x1, y1, x2, y2.

Además, se añadieron varias líneas más para calcular y mostrar por pantalla las coordenadas centrales de la detección.

Finalmente, se ejecutó el programa, siendo el resultado el se muestra en el vídeo Prueba deteccionobj.mp4.
Elaboración de la memoria

De manera paralela a la consecución de pruebas, se inició la elaboración de la memoria del trabajo.

Semana 30 (13/10/2023-19/11/2023)

Variaciones en programa para la detección de objetos por python

Después de conseguir ejecutar el programa de detección de objetos basado en el proyecto PyTorch-YOLOv3 para correr detección de objetos sobre video, y que utiliza YOLO(You Only Look Once) como modelo para generar detecciones, debido a que este modelo se encuentra por defecto pre entrenado para detectar 80 objetos distintos, los cuales se encuentran recogidos en la lista data/coco.names, se intentó variar el programa deteccion_video_webcam.py para que las coordenadas centrales de los recuadros de los objetos detectados por el modelo, se guardasen en una lista dinámica, para poder guardar todas las posiciones que se detecten en el momento, para el posterior envío de estas al robot.

Para ello, se inicializó una lista l_pos para que posteriormente, tras el cálculo dentral de las coordenadas del recuadro, se añadieran estas coordendas a la lista, tal y como se muestra en el fragmento del código siguiente:

El resultado una vez ejecutado el programa, es el siguiente:
Detección de objetos por python

Para entrenamiento de un modelo con la clase "Fresa" y no utilizar las 80 clases que vienen por defecto, se siguieron los siguientes pasos:

Se etiquetaron algunas imágenes de fresas con el formato VOC mediante el programa labelImg, guardando las imágenes etiquetadas en el directorio **data/custom/images ** mientras que las etiquetas/metadata de las imágenes se guardaron en data/custom/labels, existiendo por cada imagen.jpg un imagen.txt tras guardar la imagen etiquetada a través de labelImg.

Desde la carpeta config correremos el archivo create_custom_model para generar un archivo .cfg el cual contiene información sobre la red neuronal para correr las detecciones.
```
cd config
bash create_custom_model.sh <Numero_de_clases_a_detectar>
cd ..
```
Descargamos la estructura de pesos de YOLO para poder hacer transfer learning sobre esos pesos:
```
cd weights
bash download_darknet.sh
cd ..
```
El archivo data/custom/classes.names debe contener el nombre de las clases, como fueron etiquetadas, un renglon por clase.

Los archivos data/custom/valid.txt y data/custom/train.txt deben contener la dirección donde se encuentran cada una de las imágenes. Estos se pueden generar con el siguiente comando (estando las imagenes ya dentro de data/custom/images)
```
python split_train_val.py
```
Finalmente se probó a llevar a cabo el entrenamiento:
```
python train.py --model_def config/yolov3-custom.cfg --data_config config/custom.data --pretrained_weights weights/darknet53.conv.74 --batch_size 2
```
Una vez ejecutado el comando para entrenar el modelo, se obtuvieron los siguientes problemas:

El error indicaba que el módulo tensorflow no estaba instalado en el entorno de Python, siendo esta una biblioteca de aprendizaje automático necesaria para el script train.py, por lo que se instaló TensorFlow utilizando el comando:
```
pip install tensorflow
```
Tras esto se volvió a intentar entrenar el modelo, obteniendo de nuevo varios mensajes de error:

Siendo este error debido a que el módulo terminaltables no estaba instalado en el entorno de Python. Este módulo se utiliza para la presentación de tablas en la salida de la terminal. Puedes instalar terminaltables se ejecutó el siguiente comando:
```
pip install terminaltables
```
El error indicaba que había un problema con la importación de tf.summary.FileWriter en el script que podría deberse a cambios en la API de TensorFlow, ya que la forma correcta de crear un FileWriter ha cambiado en versiones más recientes. Para solucionar este problema, se modificó la línea en el script logger.py que crea el objeto FileWriter. En lugar de utilizar tf.summary.FileWriter, se utilizó tf.summary.create_file_writer.

Este error se dió, ya que, al crear los archivos data/custom/valid.txt y data/custom/train.txt, no se crearon con ese nombre, si no que se añadió un 2, incurriendo en este tipo de error.

Tras cambiar el nombre de los archivos generados, se intentó volver a ejecutar el archivo de python para entrenar el modelo, obteniendo múltiples mensajes de errores, tal y como se puede ver en el vídeo Errores al ejecutar train.mp4, pero principalmente se obtuvo el error IndexError: index 15 is out of bounds for dimension 4 with size 1 .