PROCESAMIENTO DE LAS IMÁGENES CON VTK

VTK tiene un extenso número de métodos para el procesamiento de imágenes y renderización de volúmenes. Los datos de imágenes 2D y 3D vienen dados por la clase vtkImageData. En un dataset de imagen los datos son ordenados en un vector regular alineado con los ejes. Mapas de bits y mapas de píxeles son ejemplos de datasets de imágenes 2D, y volúmenes (pilas de imágenes 2D) lo son de datasets de imágenes 3D.

Los process objects en un pipeline de imagen siempre tienen como entradas y salidas data objects de imagen. Debido a la naturaleza regular y simple de los datos, el pipeline de imagen tiene otros rasgos importantes. La renderización de volumen se usa para visualizar objetos 3D de la clase vtkImageData, y visores especiales de imágenes se usan para ver objetos 2D. La mayoría de los process objets en el pipeline de imagen están multiensamblados y son capaces de hacer fluir los datos por partes (para hacer un uso satisfactorio del límite de memoria).

Los filtros detectan de forma automática el número disponible de procesos en el sistema y crean el mismo número de uniones durante la ejecución; igualmente separan automáticamente los datos en partes que fluyen a través del pipeline.

4.7

CREACIÓN DE UNA APLICACIÓN GRÁFICA CON VTK

Crear aplicaciones gráficas con VTK es un proceso que consiste en dos partes básicas:

1. Construcción de un pipeline de datos para procesar los datos: es decir, conectar fuentes (crear datos), filtros (procesar datos) y mappers (transformar datos en gráficos). Están disponibles muchos tipos distintos de fuentes, filtros y mappers, en función del tipo de datos que se estén procesando y de la funcionalidad que se desee.

2. Creación de los objetos gráficos necesarios para interpretar esos datos. Para crear objetos gráficos los pasos típicos pueden ser:

1. Crear una ventada de renderización para trabajar en ella.

2. Crear un render.

3. Crear un interactor (que permite interactuar con los datos).

4. Crear uno o más actores (cada uno de los cuales es unido a un mapper).

5. Renderizar.

4.8

GENERACIÓN DE PROYECTOS MEDIANTE VTK

Los pasos a seguir para llevar a cabo la generación de proyectos con VTK serán los siguientes:

1. Debemos instalar la herramienta Cmake, que podremos encontrar en www.CMake.org.

2. A continuación debemos instalar también el conjunto de librerías VTK que podremos encontrar en www.vtk.org. En las opciones de instalación, seleccionaremos la compatibilidad para Python, Java y Tcl.

3. Copiamos la carpeta VTK-SRC-WINDOWS desde el CD de la aplicación hasta el directorio del disco duro donde hallamos instalado las librerías VTK.

4. Creamos una nueva carpeta en el directorio del disco duro donde se encuentre VTK con el nombre de DEBUGBUILD, en donde almacenaremos la configuración de VTK.

5. Iniciamos la aplicación Cmake, ejecutando CmakeSetup.exe. a continuación debemos configurar VTK.

6. En el directorio del código fuente, establecemos el path en donde se encuentre el source de VTK.

7. En el directorio de destino, donde se crearán las dll´s y los build de VTK, establecemos lo siguiente:

8. Seleccionamos el compilador a utilizar.

9. Pinchamos en CONFIGURE. En el GUI se nos resaltan unas opciones en rojo. Activamos la casilla VTK_USE_PARALLEL.

11. Pinchamos en CONFIGURE. Nos informará de que no encuentra el lugar donde se encuentra el ejecutable de MPI, el include y sus librerías; añadimos la información requerida:

MPIRUN.exe: ….\MPICH\MPD\BIN\MPIRUN.exe INCLUDE PATH: ….\MPICH\SDK\INCLUDE LIBRARY PATH: ….\MPICH\SDK\|LIB\MPICH.lib

4.9

EJECUCIÓN DE LAS APLICACIONES VTK

1. Lanzamos el compilador con el que estemos trabajando (en nuestro caso, Microsoft Visual Studio C++ 6.0).

2. Generamos un nuevo archivo *.cpp a través de la pestaña NEW → FILES → C++ SOURCE FILE.

3. Escribimos el programa a ejecutar y lo guardamos.

4. A continuación tenemos que crear el archivo de configuración CMakeLists.txt. Este archivo suele tener la siguiente estructura:

PROJECT (nombre del proyecto)

INCLUDE (${CMAKE_ROOT}/Modules/FindVTK.cmake) IF (USE_VTK_FILE) INCLUDE (${USE_VTK_FILE}) ENDIF (USE_VTK_FILE) LINK_LIBRARIES ( vtkRendering vtkGraphics vtkImaging vtkFiltering vtkCommon … … … )

5. Guardamos el archivo *.txt con el nombre de CMakeLists. Tanto el archivo *.cpp como el *.txt han de estar localizados en una misma carpeta.

6. Lanzamos la aplicación Cmake. En el código fuente, incluimos el path del directorio donde se encuentren los archivos *.cpp y *.txt. En el destino, la carpeta donde queremos que se genere la aplicación:

7. Pinchamos en CONFIGURE. Nos informa de que no encuentra el path de VTK_DIR. Ponemos el path donde se encuentra ese directorio, que será ….\VTK\DEBUGBUILD. Pinchamos en CONFIGURE y después en OK.

8. Lanzamos el compilador que hallamos seleccionado (en nuestro caso, Visual Studio C++ 7.0). Seleccionamos OPENWORKSPACE y abrimos el archivo *.dsw que se encontrará en el directorio de resultados.

9. Ejecutamos la aplicación y, si no se encuentran errores, nos pedirá que le proporcionemos la ruta del ejecutable a utilizar, que en nuestro caso será VTK.exe:

….\VTK\BIN\VTK.exe

10. Vamos al directorio de resultamos, y ejecutamos la aplicación obtenida.

A continuación vamos a ver un ejemplo sencillo de la utilización de VTK. En este ejemplo vamos a desarrollar una simple ventana de ejecución de VTK en donde incluiremos un cubo con el que podremos obtener sus diferentes vistas:

#include "vtkCubeSource.h" #include "vtkPolyDataMapper.h" #include "vtkRenderWindow.h"

#include "vtkRenderWindowInteractor.h" #include "vtkRenderer.h"

Static HANDLE hinst;

long FAR PASCAL WndProc(HWND, UINT, UINT, LONG); class myVTKApp { public: myVTKApp (HWND parent); ~myVTKApp (); private: vtkRenderWindow *renWin; vtkRenderer *renderer; vtkRenderWindowInteractor *iren; vtkCubeSource *cube; vtkPolyDataMapper *cubeMapper; vtkActor *cubeActor; };

int PASCAL WinMain (HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpszCmdParam, int nCmdShow)

{

static char szAppName[] = "Win32Cube"; HWND hwnd ;

MSG msg ;

WNDCLASS wndclass ; if (!hPrevInstance) {

wndclass.style = CS_HREDRAW | CS_VREDRAW | CS_OWNDC; wndclass.lpfnWndProc = WndProc ;

wndclass.cbClsExtra = 0 ; wndclass.cbWndExtra = 0 ; wndclass.hInstance = hInstance;

wndclass.hIcon = LoadIcon (NULL, IDI_APPLICATION); wndclass.hCursor = LoadCursor (NULL, IDC_ARROW); wndclass.lpszMenuName = NULL;

wndclass.hbrBackground = (HBRUSH) GetStockObject (BLACK_BRUSH); wndclass.lpszClassName = szAppName;

RegisterClass (&wndclass); }

hinst = hInstance; hwnd = CreateWindow ( szAppName, "Draw Window", WS_OVERLAPPEDWINDOW, CW_USEDEFAULT, CW_USEDEFAULT, 400, 480, NULL, NULL, hInstance, NULL); ShowWindow (hwnd, nCmdShow); UpdateWindow (hwnd);

while (GetMessage (&msg, NULL, 0, 0)) { TranslateMessage (&msg); DispatchMessage (&msg); } return msg.wParam; }

long FAR PASCAL WndProc (HWND hwnd, UINT message, UINT wParam, LONG lParam)

{

static HWND ewin;

static myVTKApp *theVTKApp; switch (message)

{

case WM_CREATE: {

ewin = CreateWindow("button","Exit",

WS_CHILD | WS_VISIBLE | SS_CENTER, 0,400,400,60,

hwnd,(HMENU)2,

(HINSTANCE)GetWindowLong(hwnd,GWL_HINSTANCE), NULL);

theVTKApp = new myVTKApp(hwnd); return 0; } case WM_COMMAND: switch (wParam) { case 2: PostQuitMessage (0); if (theVTKApp) { delete theVTKApp; theVTKApp = NULL; } break; } return 0; case WM_DESTROY: PostQuitMessage (0); if (theVTKApp) { delete theVTKApp; theVTKApp = NULL; } return 0; }

return DefWindowProc (hwnd, message, wParam, lParam); } myVTKApp::myVTKApp(HWND hwnd) { this->renderer = vtkRenderer::New(); this->renWin = vtkRenderWindow::New(); this->renWin->AddRenderer(this->renderer); this->renWin->SetParentId(hwnd); this->iren = vtkRenderWindowInteractor::New(); this->iren->SetRenderWindow(this->renWin); this->cube = vtkCubeSource::New();

this->cube->SetXLength( 5 ); this->cube->SetYLength( 5 ); this->cube->SetZLength( 5 ); this->cubeMapper = vtkPolyDataMapper::New(); this->cubeMapper->SetInput(this->cube->GetOutput()); this->cubeActor = vtkActor::New(); this->cubeActor->SetMapper(this->cubeMapper); this->renderer->AddActor(this->cubeActor); this->renderer->SetBackground(0.2,0.4,0.3); this->renWin->SetSize(400,400); this->renWin->Render(); } myVTKApp::~myVTKApp() { renWin->Delete(); renderer->Delete(); iren->Delete(); cube->Delete(); cubeMapper->Delete(); cubeActor->Delete(); }

A continuación el fichero Cmake.lists que necesitaremos generar será el siguiente: PROJECT (Win32Cube) INCLUDE (${CMAKE_ROOT}/Modules/FindVTK.cmake) IF (USE_VTK_FILE) INCLUDE(${USE_VTK_FILE}) ENDIF (USE_VTK_FILE) LINK_LIBRARIES( vtkRendering vtkGraphics vtkImaging vtkIO

vtkFiltering vtkCommon )

ADD_EXECUTABLE(Win32Cube WIN32 Win32Cube.cxx)