# Densitometría Cerebral

El problema está relacionado con pacientes que han sufrido traumatismo cerebral. Estos traumas son de mucha atención porque los pacientes se pueden sentir bien después del accidente y no mostrar síntomas postraumáticos, pero la presión intracraneal puede aumentar sin saberlo y causar la muerte. Otro problema sobre el que no hay mucha información, y es el tema central de esta investigación, está relacionado con una serie de casos en los que después de bajar la presión intracraneal gran cantidad de pacientes mueren también.
La hipótesis propuesta por los especialistas médicos está relacionada con cambios en la densidad del tejido cerebral después del trauma cerebral. Es decir, que de alguna manera la alta presión podría comprimir el tejido y así aumentar su densidad y simplemente cuando la presión vuelve a la normalidad el tejido no se recupera (Es la hipótesis que se desea confirmar con la herramienta de software).
La Tomografía Axial Computarizada permite medir esta densidad de los tejidos, pero los médicos solo ven la imagen y no pueden obtener valores cuantitativos que les permita comparar objetivamente.
La propuesta para nosotros entonces se divide en:
Desarrollar una herramienta que entregue un valor cuantitativo de la densidad (en unidades de radiodensidad u otras) de un pixel a partir de los datos entregados por el estándar DICOM sobre los parámetros de adquisición de la imagen médica.
Desarrollar una metodología que permita segmentar las imágenes de TAC en cerebro, hueso y posiblemente otras regiones. (Algoritmos de segmentación)
Cuantificar un valor promedio de la densidad en estas regiones segmentadas a partir de la intensidad de cada pixel de la imagen.

__________________________________________

## Herramientas Utilizadas

A continuación se explicarán las herramientas utilizadas en este proyecto y el proceso de instalación  de cada una de ellas.
El proceso de instalación se mostrará para los usuarios de Ubuntu y Debian, para otras distribuciones de Linux el proceso es similar.

**Dependencias**

* Python 3.5
* Nibabel 1.0 - 1.4
* NumPy 1.3 - 1.7
* Matplotlib
* Node.js
* Nipype (FSL)
* BET
* Vtk-dicom-tools
* Node.js
* Npm

Antes de instalar las herramientas es necesario actualizar el sistema.

Para actualizar el sistema en Ubuntu y Debian:

```
sudo apt-get update
sudo apt-get upgrade
```

### [Python](https://www.python.org/)

Python es un lenguaje de programación interpretado, de tipado dinámico y multiplataforma. Soporta los paradigmas de programación orientado a objetos, funcional, imperativo. Es un lenguaje sencillo de utilizar y que trae con sigo muchas herramientas necesarias para el desarrollo de este proyecto, como librerías para el tratamiento de neuro-imágenes y en general de neurología, que serán descritas más adelante.

Para este proyecto se utiliza la versión 3.4 o 3.5, que viene con funciones mejoradas respecto a su versión anterior (2.7), pero no son compatibles.

Para instalar Python en Debian y Ubuntu:

```
sudo apt-get install python3.5
```


### [Pip](https://pip.pypa.io/en/stable/)

Es un sistema de gestor de paquetes que viene instalado con versiones de Python por encima de 2.7.9 o Python mayores a 3.4.

Pip es utilizado para instalar y administrar paquetes de software escritos en Python.

**Para instalarlo en Linux:**

1. Ingresar a la página https://pip.pypa.io/en/stable/installing/

2. Descargar el archivo _get-pip.py_ que se encuentra en la sección _Installing with get-pip.py_

3. Desde un terminal, nos movemos a la ruta donde quedó descargado el archivo

4. Se ejecuta el siguiente comando:

```
sudo python3 get-pip.py
```

**Para atualizarlo:**

```
pip install -U pip
```

Con esta herramienta procederemos a hacer la instalación de forma más sencilla y general para cualquier usuario de Linux.

### [Nipy](http://nipy.org/)

Es una [comunidad de práctica](https://es.wikipedia.org/wiki/Comunidades_de_pr%C3%A1ctica) dedicados al análisis de neuro-imágenes en python. Esta comunidad desarrolla diferentes proyectos como nipype, nibabel, Nilearn, sipy, entre otras muchas.

De los proyectos desarrollados por esta comunidad, utilizaremos nipype y nibabel.

**Dependencias:**

* Python 2.6 en adelante.
* NumPy 1.6 o en adelante.
* SciPy 0.9 o en adelante.
* Sympy 0.7.0 o en adelante.
* Nibabel 1.2.0 o en adelante.

**Para instalarlo en Linux:**

```
pip install nipy
```

### [Nipype](http://nipy.org/packages/nipype/index.html)

Nipype es una herramienta que proporciona una interfaz para el software de neuro-imágenes y facilita la interacción entre paquetes con el uso de workflow.

Existen diferentes interfaces en nipype: SPM, FSL, FreeSufer.

En este proyecto utilizaremos FSL, ya que provee la herramienta BET (Brain Extraction Tool), el cual se encargará de eliminar partes de la imagen que no corresponda a las del cerebro.

Otras funcionalidades que ofrece nipype son:

* Interactuar facilmente con otros paquetes de software.
* Combinar procesos de diferentes paquetes de software.
* Desarrollo rápido de nuevos workflows utilizando pasos de los viejos.
* Ejecución en paralelo de procesos.

Entre otros.

**Para instalarlo en Linux:**

```
sudo pip install nipype
```

La instalación en Debian y en Ubuntu se hace de una manera simple a través del repositorio [NeuroDebian](http://neuro.debian.net/).

Si se usa Ubuntu 15.10 se debe hacer lo siguiente desde la consola de comandos:

```
wget -O- http://neuro.debian.net/lists/wily.us-tn.full | sudo tee /etc/apt/sources.list.d/neurodebian.sources.list
sudo apt-key adv --recv-keys --keyserver hkp://pgp.mit.edu:80 0xA5D32F012649A5A9

wget -O- http://neuro.debian.net/lists/wily.us-tn.full | sudo tee /etc/apt/sources.list.d/neurodebian.sources.list
sudo apt-key adv --recv-keys --keyserver hkp://pgp.mit.edu:80 0xA5D32F012649A5A9
```

Una vez esto se ha realizado se puede proceder a actualizar la lista de paquetes usando:

```
sudo apt-get update
```

Ejecutar el siguiente comando para terminar la instalación del paquete:

```
sudo apt-get install python-nipype
```

También puede visitar el [repositorio de nipype](https://github.com/nipy/nipype/tree/f9c98baa0a968451f4f8c78a74249c41e61d1966) e instalarlo desde allí.


### [FSL](http://fsl.fmrib.ox.ac.uk/fsl/fslwiki/BET)

**Brain Extraction Tool (BET)** es una herramienta que trae la interfaz **FSL** de nipype, para la extracción de todo lo que no sea tejido cerebral de las imágenes. También permite estimar las superficies internas y externas de hueso, siempre que se tengan imágenes T1 y T2 de buena calidad.

Es utilizada en este proyecto para el análisis de las imágenes con la información únicamente del cerebro.

Se debe instalar la interfaz [FSL](http://nipy.org/nipype/interfaces/generated/nipype.interfaces.fsl.preprocess.html) que contiene a BET.

**Para instalarlo en Ubuntu:**

```
sudo aptitude install fsl-complete
```

Una vez instalado, ejecutar el siguiente comando:

```
export FSLDIR=/usr/share/fsl/5.0
. $FSLDIR/etc/fslconf/fsl.sh
export PATH=$FSLDIR/bin:$PATH
```

**Para instalarlo en Debian:**

1. Se debe ingresar a la página:
http://neuro.debian.net/install_pkg.html?p=fsl-complete+

2. Se selecciona el sistema operativo que se está usando y el servidor más cercano.

3. Se selecciona la opción “all software”

4. Se ejecutan los comandos que se especifican en la página.

5. Finalmente, se vuelve a actualizar el sistema:

```
sudo apt-get install update
```

Para asegurarnos de la correcta instalación y configuración, escribir los siguientes comandos:

```
whereis fsl
```

Debe mostrar donde se encuentren los archivos que han sido instalados. Si este no es el caso, se debe volver a intentar la instalación desde un principio.

```
echo $FSLDIR
```

Esto debe mostrar el nombre del directorio donde se instaló FSL. Si no lo hace, se debe configurar manualmente su shell para que encuentre los paquetes instalados. Esto depende de cuál sea la shell que esté utilizando. Para esto, siga los pasos que aparecen en la documentación [FSLInstalation](http://fsl.fmrib.ox.ac.uk/fsl/fslwiki/FslInstallation/ShellSetup) .

De nuevo, cuando haga la configuración manual, vuelva a escribir el comando anterior.

Por último, ejecute el comando:

```
flirt -version
```

Debe mostrar algo como esto:

```
FLIRT version 6.0
```

Si todos los pasos anteriormente descritos funcionaron, significa que FSL está correctamente instalado y ya puede comenzar a utilizar sus módulos.
Para más información acerca de la instalación, visite la documentación de la [página oficial de FSL](http://fsl.fmrib.ox.ac.uk/fsl/fslwiki/FslInstallation).


### [Nibabel](http://nipy.org/nibabel/)

Es una librería de python que permite la lectura/escritura de diferentes formatos de neuro-imágenes, tales como GIFTI, NIfTI1, NIfTI2, MINC1, MINC2, MGH y ECAT.
Además, el formato NIfTI está pensado para ser el nuevo estándar de formatos para imágenes médicas, y puede ser utilizada con las interfaces que provee nipype (FSL, AFNI, SPM,Freesurfer).
En este proyecto será utilizado para convertir las imágenes DICOM a NifTI, ya que en el segundo es un formato que tiene información adicional sobre la orientación espacial de la imágen.

**Para instalarlo en Linux:**

```
sudo pip install nibabel
```


### [MatplotLib](http://matplotlib.org/)

Es una librería que permite la construcción de gráficos, histogramas, gráficos de barras, diagramas de dispersión, entre otros, en una variedad de formatos y entornos interactivos.

Puede ser usada en scripts de Python, en el shell de Python y en ipython, también en aplicaciones web.

Para este proyecto se utilizará en la verificación visual de la salida de los algoritmos de segmentación.

**Para instalarlo en Ubuntu:**

```
sudo apt-get install python-matplotlib
```

**Para instalarlo en Linux:**

```
sudo pip install matplotlib
```

### [NumPy](http://www.numpy.org/)

Numeric Python (Numpy) es el paquete base para realizar computación científica con Python. Contiene un potente objeto para trabajar con arreglos multi-dimensionales, funciones sofisticadas, herramientas para integrar código en C/C++ y código en Fortran, capacidad para usar algebra lineal, Transformadas de Fourier y manejo de números aleatorios, entre otras herramientas de utilidad.

En este proyecto, NumPy permitirá acceder a los objetos que contienen la información de las imágenes para realizar operaciones sobre ellas.

**Para instalarlo en Linux:**

```
sudo pip install numpy
```

**Para actualizarlo:**

```
sudo pip install numpy --upgrade
```


### [VTK-Tools](https://github.com/dgobbi/vtk-dicom)

[Visualization toolkit (VTK)](http://www.vtk.org/) es un software para gráficos 3D por computador, procesamiento de imágenes y visualización. Esta herramienta posee variedad de algoritmos de visualización y técnicas de modelado avanzadas; permite también visualización de una imágen por cortes (capas), particularmente utilizado para imágenes médicas.

En este proyecto es utilizado el paquete _vtk-dicom-tools_, el cual permite realizar el proceso de conversión de imágenes [dicom a nifti](https://github.com/dgobbi/vtk-dicom/wiki/dicomtonifti), además de ser una poderosa herramienta para la comprobación y análisis visual de los resultados obtenidos.

**Para instalarlo en Debian y Ubuntu:**

```
sudo aptitude install vtk-dicom-tools
```

Si se tiene otra distribución de Linux, se puede instalar de la siguiente manera:

1. Descargar los archivos del [repositorio](https://github.com/dgobbi/vtk-dicom/)
2. Abrir un terminal
3. Moverse a la carpeta donde se descargó el archivo
4. Crear una carpeta con el nombre _build_
5. Moverse a la carpeta build.
6. Ejecutar los siguientes comandos:
```
	cmake ..
	make
	sudo make install
```

**Nota:** Se debe tener instalado [CMake](https://cmake.org/).


### [Node.js](https://nodejs.org/en/)

Node.js es una solución para el desarrollo de aplicaciones web al lado del servidor, está diseñado para construir aplicaciones de red escalables y para manejar miles de conexiones simultáneas.
Node.js utiliza el lenguaje de programación Javascript pero del lado del servidor; es programación orientada a eventos, trabaja sobre el intérprete de JavaScript creado por Google _([V8](https://en.wikipedia.org/wiki/V8_%28JavaScript_engine%29))_.

Con Node.js se construye el servidor web, herramienta con la que un usuario cualquiera puede ingresar las imágenes de los TAC y obtener el resultado de la densidad cerebral y la gráfica de densidad por cortes; el usuario puede también ver información acerca de los desarrolladores del proyecto, y cuenta con la posibilidad de enviar un correo electrónico para contactarse con ellos.

**Para instalarlo en Ubuntu:**

```
sudo apt-get install nodejs
```

Para estar seguros de que se instaló correctamente, ejecute el siguiente comando:

```
node -v
```

El cual le mostrará la versión que ha sido instalada. Si muestra un error, significa que se debe volver a instalar.


### [NPM](https://www.npmjs.com/)

Node Package Module (NPM) es el manejador de paquetes de node, se usa para la instalación, compartimiento y distribución de código.

En este proyecto se utiliza para la descarga de las dependencias del programa. Estos son algunos de ellos:

* body-parser
* browserify
* chart.js
* express
* ejs
* shortid
* socket.io

Entre otros.

**Para instalarlo en Debian y Ubuntu:**

```
sudo apt-get install npm
```

Para ver la versión de NPM instalada puede ejecutar el siguiente comando:

```
npm -v
```

Para actualizar npm ejecute la siguiente instrucción:

```
sudo npm install npm -g
```

Ahora, cada vez que queramos instalar las dependencias que esté utilizando nuestro programa en node, se debe ejecturar:

```
npm install
```

Y aparecerá una carpeta llamada _node_modules_, donde se encuentran todos los paquetes necesarios para la funcionalidad del programa.

Antes de poder ejecutar node en ambientes basados en Ubuntu, es necesario crear el siguiente enlace simbólico:

```
sudo ln -s /usr/bin/nodejs /usr/bin/node
```

______________________________________

### Ejecución del programa

Para instalar todos los módulos que están siendo utilizados en el proyecto, primero debe moverse desde una terminal en la dirección:

```
“DireccionDelProyecto/brain-densitometry/web/app”
```

Donde _DireccionDelProyecto_ es la ruta donde se descargó el proyecto.

Ahora, ejecutar:

```
npm install
npm run build-js
npm start
```

Y ya está corriendo nuestro servidor.

Para hacer pruebas directamente con el archivo __nipypeTest.py__ que se encuentra en la carpeta __source__, nos movemos a dicha carpeta, y ejecutamos lo siguiente:

```
python3 nipypeTest.py ../data/nombreArchivoPruebas Identificador
```

Donde _nombreArchivoPruebas_ es la carpeta que contiene los archivos .DCM, e _Identificador_ es necesario para no sobreescribir archivos dentro del servidor.
