Introducción - euler.mat.uson.mx

Introducción� ImageJ ofrece herramientas para la visualización y la manipulación

interactiva de imágenes.� ImageJ está implementado Java y, por lo tanto, es independiente de la

plataforma.� Se ejecuta sin modificaciones en Windows, MacOS o Linux.� También se puede ampliar escribiendo nuevos componentes de

software en Java.

Universidad de Sonora 2

Introducción� El modelo de ejecución dinámica de Java permite que los nuevos

módulos (”plugins") se escriban como piezas independientes de código Java.

� Estos plugins se pueden compilar, cargar y ejecutar "sobre la marcha" sin la necesidad de reiniciar ImageJ.

� ImageJ es software libre y open-source.� Website: http://rsb.info.nih.gov/ij/


http://rsb.info.nih.gov/ij/

Características� Un conjunto de herramientas interactivas para crear, visualizar, editar,

procesar, analizar, cargar y almacenar imágenes, con soporte para varios formatos de archivo comunes.

� Imágenes enteras de 16 bits, imágenes de punto flotante de 32 bits y secuencias de imágenes (“stacks” o “pilas”).

� Un mecanismo simple de plugins para extender la funcionalidad de ImageJ escribiendo fragmentos de código en Java.


Características� Un lenguaje de macros y el intérprete correspondiente, que facilitan la

implementación de bloques de procesamiento más grandes al combinar funciones existentes sin ningún conocimiento de Java.

� En este curso se verán algunos ejemplos de plugins.� En este curso no se estudia el lenguaje de macros.� Más información de macros:

https://imagej.nih.gov/ij/developer/macro/macros.html


https://imagej.nih.gov/ij/developer/macro/macros.html

Instalación de ImageJ� Entrar a https://imagej.nih.gov/ij/download.html


https://imagej.nih.gov/ij/download.html

Instalación de ImageJ


Instalación de ImageJ� Si se selecciona alguna de las opciones en bundle con Java 1.8, hay

que seguir las instrucciones.� Para Mac: https://imagej.nih.gov/ij/docs/install/osx.html� Para Linux: https://imagej.nih.gov/ij/docs/install/linux.html� Para Windows: https://imagej.nih.gov/ij/docs/install/windows.html� Si se selecciona la primera opción (plataforma independiente), se baja

el .zip y se descomprime en algún directorio.


https://imagej.nih.gov/ij/docs/install/osx.html

https://imagej.nih.gov/ij/docs/install/linux.html

https://imagej.nih.gov/ij/docs/install/windows.html

Instalación de ImageJ


Instalación de ImageJ� Contenido del archivo “run”:

java -Xmx512m -jar ij.jar


Ventana principal en Mac


Ventana principal en Windows


Plugins� Los plugins son pequeños módulos de Java para ampliar la

funcionalidad de ImageJ mediante el uso de una interface standard.� Los plugins se pueden crear, editar, compilar, invocar y organizar a

través del menú “Plugins” en la ventana principal de ImageJ.� Los plugins se pueden agrupar para mejorar la modularidad, y los

comandos de plugins se pueden colocar arbitrariamente dentro de la estructura del menú principal.


Tipos de plugins� Los plugins son clases en Java que implementan alguna interface en

particular de ImageJ.� Hay 2 tipos de plugins:1. PlugIn: no requiere que una imagen esté abierta para iniciar un plugin.2. PlugInFilter: la imagen activa se le pasa al plugin cuando comienza.� La mayoría de los plugins que se verán para procesar imágenes son

del tipo PlugInFilter.


Plugins tipo PlugInFilter� La interface PlugInFilter requiere que los plugins de este tipo

implementen al menos dos métodos: setup() y run().� int setup(String args, ImagePlus im)� El método setup() se invoca al comenzar el plugin.� Sirve para verificar que las capacidades de este plugin coincidan con la

imagen de destino.� Devuelve un entero de 32 bits que representa un vector de banderas

binarias que describen las propiedades del plugin.


Plugins tipo PlugInFilter� void run(ImageProcessor ip)� Este método hace el trabajo real para este plugin.� Recibe un único argumento, ip, de tipo ImageProcessor, que contiene la

imagen a procesar y toda la información relevante sobre la misma.� El método run no devuelve nada (es void) pero puede modificar la

imagen recibida y crear nuevas imágenes.


Ejemplo: invertir una imagen� Problema: obtener el negativo de una imagen de 8 bits.� Imagen positiva Imagen negativa


Solución� Las imágenes de 8 bits tienen pixeles con valores entre 0 (negro) y 255

(blanco).� Sean 𝑀 y 𝑁 el ancho y el alto de la imagen, respectivamente.� Para invertir la imagen, el valor de cada pixel 𝐼(𝑢, 𝑣) se reemplaza por:� 𝐼 𝑢, 𝑣 = 255 − 𝐼(𝑢, 𝑣)� Para todas las coordenadas (𝑢, 𝑣) con 𝑢 = 0, 1,… ,𝑀 − 1 y 𝑣 =0, 1,… ,𝑁 − 1.


Implementación� Crear una clase que implemente a PlugInFilter.� Se escoge PlugInFilter (la otra opción es PlugIn) porque se va a

procesar una imagen existente.� public class My_Inverter_A implements PlugInFilter {� El underscore (‘_’) en el nombre de la clase hace que ImageJ la

reconozca como un plugin y lo inserte en el menú de forma automática.


Método setup()� Cuando ImageJ ejecuta un plugin de tipo PlugInFilter, lo primero que

hace es invocar a setup() para obtener información del plugin.� En este ejemplo, setup() regresa el valor DOES_8G (una constante

entera definida en la interface PlugInFilter).� DOES_8G indica que es plugin maneja imágenes en tonos de grises de

8 bits.


Método setup()public int setup(String args, ImagePlus im){

return DOES_8G;}� En este caso, los argumentos args e im no se utilizan.


Método run()� El método run() de un plugin PlugInFilter recibe un objeto de tipo

ImageProcessor que contiene la imagen a procesar y toda la información relevante sobre la misma.

� Se usan los métodos getWidth() y getHeight(), definidos en la clase ImageProcessor, para consultar el tamaño de la imagen.

� Luego se usan dos ciclos for anidados para iterar sobre todos los pixeles de la imagen

� Para leer los valores de los pixeles se usa el método int getPixel (int u, int v)


Método run()� Para escribir los valores de los pixeles se usa el método void putPixel

(int u, int v, int a)


Método run()public void run(ImageProcessor ip){

int M = ip.getWidth();int N = ip.getHeight();// iterate over all image coordinates (u,v)for (int u = 0; u < M; u++) {

for (int v = 0; v < N; v++) {int p = ip.getPixel(u, v);ip.putPixel(u, v, 255 – p);

}}

}


Implementación alternativa� Crear una clase que implemente a PlugIn en lugar de PlugInFilter.� En este caso solo se necesita un método run().� La referencia a la imagen no es directa, hay que invocar al método

IJ.getImage().� Si no hay una imagen abierta, getImage() manda un mensaje de error y

aborta el plugin.� Hay que revisar de manera explícita que el tipo de la imagen sea el

correcto.


Implementación alternativa� run() recibe un parámetro de tipo String que puede ser usado para

pasar información arbitraria al plugin.


Parte 1public class My_Inverter_B implements PlugIn {

public void run(String args){

ImagePlus im = IJ.getImage();if (im.getType() != ImagePlus.GRAY8) {

IJ.error("8-bit grayscale image required");return;

}


Parte 2ImageProcessor ip = im.getProcessor();int M = ip.getWidth();int N = ip.getHeight(); for (int u = 0; u < M; u++) {

for (int v = 0; v < N; v++) {int p = ip.get(u, v);ip.set(u, v, 255 - p);

}}im.updateAndDraw(); // redraw the modified image

} // end run} // end class


¿PlugIn o PlugInFilter?� Es cuestión de gusto.� Los dos tienen ventajas y desventajas.� Como regla general, se utiliza el tipo PlugIn para tareas que no

requieren que se abra ninguna imagen.� Si se deben procesar una o más imágenes abiertas, PlugInFilter es la

opción preferida.


Editar, compilar y ejecutar plugins� El código fuente del plugin debe estar en <ij>/plugins/ o en un

subdirectorio debajo de plugins.� Se pueden crear nuevos plugins desde el menú Plugins/New.� Hay un editor de texto muy básico.� Se recomienda utilizar un IDE profesional como Eclipse o Netscape.� Para compilar y ejecutar un plugin se usa el menú Plugins/Compile and

Run.� Los errores de compilación se muestran en otra ventana.


Editar, compilar y ejecutar plugins� Una vez compilado el plugin, el archivo .class se carga

automáticamente y el plugin es aplicado a la imagen actual.� Se despliega un mensaje de error si no hay una imagen abierta o si la

imagen no es del tipo esperado por el plugin.� Al reiniciar ImageJ carga todos los plugins nombrados correctamente

que se encuentre en el directorio <ij>/plugins (o en algún subdirectorio) y los agrega el menú Plugins.

� Estos plugins se pueden ejecutar sin necesidad de recompilarlos.� Se pueden instalar plugins que estén en un directorio arbitrario desde

el menú Plugins/Install.Universidad de Sonora 31

Editar, compilar y ejecutar plugins� Se pueden grabar secuencias de plugins y otros comandos de ImageJ

como macros en el menú Plugins/Macros/Record.


Desplegar imágenes� Los dos ejemplos no crean una imagen nueva, sino que modifican la

imagen recibida.� Esto no tiene que ser así, un plugin puede crear imágenes nuevas.� No se necesitan comandos para desplegar la imagen modificada.� ImageJ lo hace de manera automática cuando la imagen recibida

cambia.� Además, ImageJ guarda una copia de la imagen al método run() en un

filtro de tipo PlugInFilter.� Se puede restaurar la imagen original con el menú Edit/Undo.


Depurar� Por default, System.out no está disponible en ImageJ.� Se puede usar otra ventana para escribir mensajes de texto usando el

método ij.IJ.log(String s).� ImageJ no ofrece mucho soporte para depurar código (breakpoints,

inspeccionar variables locales).� Los valores de los pixeles se pueden analizar mediante posicionando

el ratón sobre la imagen.


Depurar


Depurar� Otra opción es utilizar algún IDE tipo Eclipse o Netbeans.


Comandos de ImageJ� ImageJ tiene comandos predefinidos.� Estos comandos implementan distintas operaciones de procesamiento

de imágenes.� Un comando puede ser un plugin, una macro o un script (JavaScript,

BeanShell, Python).� Los comandos disponibles están listados en el menú

Plugins/Utilities/Find Commands.� Por ejemplo, invertir una imagen se puede hacer desde el menú

Edit/Invert o usando la clase ij.plugin.filter.Filters (con el argumento "invert").


Comandos de ImageJ� Un comando también se puede ejecutar desde un plugin con el método

IJ.run().� Hay que tener en cuenta que los plugins de tipo PlugInFilter le aplican

un candado (lock) a la imagen actual durante la ejecución para que ninguna otra operación se le pueda aplicar.

� Esto de resuelve llamando a los métodos unlock() y lock().


Comandos de ImageJ


Comandos de ImageJ� Se pueden grabar una serie de comandos mediante el Macro Recorder

disponible en Plugins/Macros/Record.� Los macros se guardan en un archivo de texto para su uso posterior.� Los comandos pueden ser plugins, macros o scripts.


Introducción - euler.mat.uson.mx

Documents

Transcript of Introducción - euler.mat.uson.mx