INTRODUCCIÓN AL QT Y AL QT CREATOR 

UNIVERSIDAD DEL CAUCA 

Profesor: Oscar Andrés Vivas Albán 

El  framework Qt  vio  la  luz  pública  en  el  año  1995.  Fue  desarrollado  por  dos  ingenieros  noruegos, Haavard Nord  y  Eirik Chanble‐Eng,  como  respuesta  a  la necesidad de disponer de un GUI para una aplicación  C++ multiplataforma  orientado  a  objetos.  Estos  ingenieros  fundaron  la  compañía Quasar Technologies en 1994, nombre que fue evolucionando hasta convertirse en Trolltech.  Trolltech empezó a ofrecer Qt con  la  licencia GPL a partir del año 2000, siendo ésta gratuita para el desarrollo  de  software  libre,  pero  de  pago  para  el  desarrollo  de  software  privativo  (constituía  una fuente de ingresos para Trolltech). A partir de 2005 apareció la versión para Windows bajo licencia GPL. Actualmente, y a  raíz de  la compra de Trolltech por parte de Nokia a principios del año 2009, Qt se ofrece con licencia LGPL. En la última década, Qt ha pasado de ser un producto usado por unos pocos desarrolladores especializados, a un producto usado por miles de desarrolladores open source en todo el mundo, por lo que el futuro de esta tecnología es hoy día muy prometedor.  En la versión 1.0 y 2.2 de Qt, se creaban los diálogos (diseños de las ventanas) mediante QtDesigner, y éstos se convertían a código mediante  la utilidad UIC (User  Interface Compiler). En esta versión ya se daba soporte al mecanismo estrella de Qt (signals y slots): el UIC generaba los slots (virtuales) y estos se implementaban con código mediante herencia.  En la versión 3.0 de Qt, se incorporó el mecanismo del “archivo ui.h”, que permitía implementar slots sin necesidad de herencia, y que era incluido automáticamente por el código fuente generado por UIC. QtDesigner tenía un editor de código  integrado para poder editar el archivo ui.h, y una funcionalidad (llamada source) para añadir variables e  includes. También disponía de capacidad de carga de plugins para dar soporte a Custom Widgets (haciendo que fueran visibles en QtDesigner) e incluso un parser de archivos de proyecto  .pro. Adicionalmente,  se podían  realizar  conexiones  a Bases de Datos  y  ver el contenido de  sus  tablas. Por ello, era posible  construir una aplicación  completa usando únicamente QtDesigner.  Sin  embargo,  esta  aproximación  de  edición  “centralizada” mediante QtDesigner  tenía  una  serie  de carencias, y eran los siguientes:  

El editor de código de QtDesigner no disponía de funciones básicas (como por ejemplo, ir a una determinada línea). 

Existían problemas de sincronización al editar el archivo ui.h externamente a QtDesigner. 

No era posible su  integración con  IDEs existentes, por ello desarrolladores acostumbrados a otros IDEs debían utilizar a la fuerza QtDesigner para programar en Qt. 

 En la versión 4.0 de Qt se han corregido todas estas carencias. De hecho, el cambio más importante ha sido la posibilidad de integración de QtDesigner con IDEs existentes lo que derivó en la desaparición del editor de texto básico del que hacía gala QtDesigner en su versión 3.0. Además, QtDesigner genera el archivo  .ui  con  la  interfaz,  y  el  UIC  genera  el  código  para  ésta  (similar  al  comportamiento  de  las versiones 1.0 y 2.2, pero generando únicamente un archivo .h). Ahora,  la herencia se realiza de  la clase principal de  la  interfaz y de  la  interfaz de objetos de usuario, siendo todo este código generado automáticamente.  

QT CREATOR  Qt Creator  es un  IDE  creado por  Trolltech para  el desarrollo de  aplicaciones  con  las bibliotecas Qt, requiriendo  su  versión  4.x.  Está  disponible  para  los  sistemas  operativos  Linux,  Max  y  Windows, permitiendo  al  desarrollador  crear  aplicaciones  para múltiples  sistemas  o  plataformas móviles.  La versión actual es la 2.3.0.    INSTALACIÓN DE QT Y QT CREATOR  En el siguiente directorio se encuentran los instaladores de estos dos programas:  www.unicauca.edu.co/deic/Documentos   Primero se instala QT, versión 4.7.4:  qt‐win‐opensource‐4.7.4‐vs2008.exe   Instalar por ejemplo en C:\Qt  Segundo  se deben añadir ciertas variables en el entorno. Para Windows 7 abrir el Panel de Control, Sistemas y Seguridad, Sistema y a  la  izquierda dar click en Configuración Avanzada del Sistema. En  la ventana  que  se  abre  dar  click  en Opciones  Avanzadas  /  Variables  de  Entorno.  Se  abre  una  nueva ventana dividida en dos partes. En  la parte  inferior, Variables del Sistema, click en  la variable Path y luego  en  Editar.  Añadir,  después  de  “;”,  la  variable …;C:\Qt\4.7.4\bin  (esto  depende  claro  está  de dónde se instaló Qt en su computador).  Una vez hecho esto se debe compilar Qt para que funcione con Microsoft Visual Studio. Para esto, una vez  se  tiene  instalado  Visual  Studio  2008,  se  abre  el  promt  desde  VS  (click  en  Inicio,  Todos  los Programas, Microsoft Visual  Studio  2008, Visual  Studio  Tools,  Símbolo  del  sistema  de Visual  Studio 2008). Se abre una nueva ventana en negro con la ubicación actual. Nos ubicamos en la carpeta donde se instaló Qt (para ir atrás en una carpeta se puede dar “cd ..”):  C:\Qt\4.7.4\   Escribir la siguiente configuración después de ubicarnos en el sitio anterior:  >configure –release –static –platform win32‐msvc2008    (luego Enter)  El proceso de configuración  tardará unos cinco minutos. Luego compilamos el programa para Visual Studio, escribimos:  >nmake    (luego Enter)  La compilación tardará entre dos y cuatro horas, podemos tomar una pausa larga.  Una vez compilado QT procedemos a instalar QT Creator. Del directorio anterior bajamos e instalamos el archivo:  qt‐creator‐win‐opensource‐2.3.0.exe  

Por ejemplo se instala en la ubicación C:\Qtcreator‐2.3.0   CREACIÓN DE UNA SENCILLA APLICACIÓN SOBRE QT CREATOR/QT (sin necesidad de escribir código!): 

 Abrir QT Creator y crear un nuevo proyecto:  Click en File, New File or Project.  Se abre una nueva ventana. En  la parte  izquierda escogemos “Qt Widget Project”, en  la parte de  la derecha escogemos “Qt Gui Application”. Click en Choose.  En la nueva ventana que se abre colocamos nombre al proyecto y su carpeta de ubicación (no pueden tener el mismo nombre). Para este ejemplo los nombres escogidos Ejemplo y Nuevo respectivamente. Luego click en Next, Next, Next y Finish.  Se abre  la ventana de Qt Creator. Observe que en  la parte  izquierda se crearon  las carpetas Headers, Sources y Forms. En éstas encontramos los archivos:  Headers: mainwindow.h Sources: main.cpp, mainwindow.cpp Forms: mainwindow.ui  Abrimos este último archivo, que contiene la interfaz gráfica a realizar (siempre que queramos volver a cargar  la  interfaz  que  estamos  construyendo  daremos  doble  click  sobre  este  archivo).  Aparece  un nuevo ambiente, con diversos botones a la izquierda y en la parte superior una ventana limpia donde se creará la interfaz necesaria.  A la nueva interfaz se le puede aumentar de tamaño dando click sostenido en alguno de los bordes.  Pasemos los siguientes widgets de la parte izquierda a la ventana en limpio, y organicémoslos tal como lo muestra la siguiente imagen:  

   

‐ Text Label (donde dando doble click colocaremos “Ventana de Prueba”). ‐ Horizontal Slider (barra de desplazamiento horizontal). 

‐ Spin Box (lo ubicamos a la derecha del Horizontal Slider). ‐ Text Edit (lo ubicamos bajo los dos anteriores). ‐ Push Button y Text Browser (ubicados abajo). ‐ Combo Box (ubicado en la parte superior derecha). ‐ Text Browser (un segundo Text Browser debajo del Combo Box). ‐ Spin Box, Dial y Push Button en la parte inferior izquierda. 

  Los widgets pueden ser movidos por el formulario solo con dar click sostenido sobre ellos y desplazar el ratón. Se trabajará con los objetos anteriores de la siguiente manera:  Doble click en Text Label y colocar “Ventana de Prueba”. En la parte derecha aparecen las propiedades de cada widget. Cambiar el  tamaño de  la  letra en “Font”, colocar  tamaño 14 y ampliar el  respectivo marco para que aparezca todo el texto.  Remarcar el Horizontal Slider y el Spin Box, que debe estar a su derecha. Aparecerán los marcos sobre los dos widgets. Dar  luego  click  sobre  el botón  “Lay Out Horizontally”,  así quedarán unidos  los dos widgets (esto se puede hacer con cualquier otro par o grupo de botones, para una mejor presentación).  Para  conectar  diversas  señales  se  da  click  sobre  el  ícono  “Edit  Signal/Slots”  de  la  parte  superior izquierda (o pulsar F4). Para salir de esta edición dar click en el ícono “Edit Widgets” (o pulsar F3).  

Trabajar con Horizontal Slider y Spin Box.  Una vez pulsado F4 dar click sostenido sobre Horizontal Slider, aparece un cuadro rojo sobre el widget, y desplazar hasta el Spin Box, que queda en rojo también. Se abre una nueva ventana para definir el tipo de conexión entre los dos bloques. Para el primero se coloca “valueChanged(int)”, para el segundo “setValue(int)”, luego OK. La interfaz lograda se graba con CTRL + S.  En  la  parte  inferior  izquierda  aparece  un  botón  verde  de  “Play”.  Pulsamos  el  botón  y  la  aplicación compila el programa,  informando de errores si  los hay, como si estuviéramos compilando bajo Visual Studio. Aparece entonces  la ventana  resultante:  si desplazamos  la barra horizontal hacia  la derecha veremos avanzar el número en el Spin Box hasta el máximo que es 99 (este número puede variarse en las propiedades del Spin Box).  Obsérvese que en la carpeta Nuevo (dentro de la carpeta de Qt Creator o en la ubicación que se le haya dado)  aparecen  dos  carpetas  más.  Una  que  se  llama  ejemplo  y  aparecen  los  archivos  base  del programa, y otra llamada Ejemplo‐build‐desktop, donde aparece la carpeta Release y dentro de ésta el ejecutable  Ejemplo.exe.  Al  abrirlo  igualmente  aparece  la  pantalla  resultante  con  la  barra  que  se desplaza y el indicador de número.  Hagamos  ahora otra  conexión.  Pulsado  F4  conectamos  el  Spin Box  con  el  Text  Edit de  abajo.  En  la ventana  de  configuración  de  conexiones  escogemos  valueChanged(QString)  como  origen  y append(QString) como destino. Al compilar nuevamente veremos cómo al cambiar la barra deslizante también los valores del Spin Box aparecen en el cuadro de texto.  

Trabajar con el Combo Box  Dar click en el Combo Box, ir a la parte superior derecha donde aparecen los objetos y las clases. Click derecho sobre QComboBox y  luego sobre Edit Combo Box. Colocar “Buscar” en el botón, y adicionar 

tres más (dando click en el botón “+” de  la parte  inferior  izquierda): Arriba, Medio y Abajo. Bajo este botón se colocó un  segundo Text Browser. Vamos a  realizar  la conexión entre estos dos bloques de otra manera  (en  vez de Edit  Signals/Slots), esta  vez desde  la  ventana de edición de  señales  y  slots, ubicada  justo debajo de  la  interfaz que  se  está  creando.  En  la pestaña de  Signals &  Slots  Editor  se pueden ver la conexión que ya se ha realizado. Añadimos una más (click en el signo “+”) y llenamos los datos de  las columnas “Sender”, “Signal”, “Receiver” y “Slot”. Los datos escogidos de un menú serán respectivamente: Combo Box, Activated(QString), textBrowser_2, insertPlainText(QString). Esto lo que hace es que al abrir el menú del Combo Box se activa la edición de texto en el segundo Text Browser. Si compilamos veremos que cada vez que cambiamos de palabra en el menú, ésta aparece como texto en la pequeña ventana bajo el menú.    

Trabajar con el dial  La idea es que el dial varíe el número que muestra el Spin Box y que el Push Button asociado borre el último valor anotado. Esto se logra con la adición de las dos siguiente conexiones:  dial    sliderMoved(int)    spinBox_2    setValue(int) pushButton  clicked()      spinBox_2    clear()   Compilar y observar el resultado obtenido.  

Trabajar con el Push Button y el Text Browser  Primero que todo se cambia el nombre del Push Button en las propiedades (en Object Name y en text) por Boton1. Luego se editan las correspondientes señales:  Boton1    clicked()      textBrower    clear()  Debemos asegurarnos que en las propiedades de este Text Browser, bajo la propiedad de QTextEdit, no aparezca activada la casilla de Read Only, sino en la ventana de edición no aceptará ningún carácter. Al compilar se puede escribir cualquier texto en esta ventana (Text Browser) pero si se pulsa el botón el texto se borrará.  Ahora  haremos  que  además  de  lo  anterior,  al  pulsar  Boton1  aparezca  una  ventana  con  un  texto específico. Para esto damos click sobre Boton1 y con click derecho vamos hasta “Go to slot …”. Se abre una ventana nueva y seleccionamos clicked(). Se abre automáticamente el archivo mainwindow.cpp, en  el  sitio  que  define  la  acción  a  ejecutar  una  vez  se  de  click  en  el  botón  anotado.  En  ese  sitio escribimos:  QMessageBox::information(this, "Título del MessageBox","Botón pulsado", "Aceptar"); 

 Y en la cabecera del archivo escribimos:  #include <QMessageBox>  Al compilar de nuevo veremos el siguiente resultado: Si escribimos algún texto en el Text Browser, éste se  borra  al  pulsar  la  tecla  Boton1,  caso  en  el  cual  aparece  también  una  ventana  que  dice  “Botón pulsado” y un nuevo botón de “Aceptar”. Al pulsarse éste último dicha ventana desaparece.   

 Trabajar con el menú de la ventana 

 En  el  extremo  superior  izquierdo  de  la  ventana  aparece  la  frase  “Type  Here”.  Dando  doble  click podemos  introducir  la palabra “Menú” y  luego damos Enter. Aparece entonces nuestro nuevo menú. Damos tres veces “Type Here” bajo la palabra Menú y editamos los textos de manera que aparezcan las palabras: “Archivo”, “Guardar”, “Configurar”. Damos click sobre “Add Separator” y luego, bajo esa línea que me acaba de crear, doble click sobre “Type Here” y colocamos “Borrar”.  En la ventana de edición de señales y slots podemos agregar la siguiente configuración:  actionBorrar  triggered()      textEdit     clear()  Significa esto que una vez compilado, podemos escribir algo en el editor de  texto pero si abrimos el menú y damos click en la palabra Borrar, el texto escrito desaparece.  

Trabajar con imágenes  Para  trabajar  con  imágenes  se  debe  primero  que  todo  crear  los  recursos  necesarios.  Para  esto supongamos que tenemos una  imagen en  formato *.bmp  (o en cualquier otro  formato gráfico) en  la misma carpeta donde está el proyecto, esta imagen se llamará logo_grupo.bmp. En QT Creator, dando click en el ícono Edit de la parte izquierda, aparecerá el árbol de carpetas que forma el proyecto, cuyo nombre es Ejemplo. Si damos click derecho sobre el nombre del proyecto, aparecerá un nuevo menú. Damos  click  sobre  “Add New”. En  la nueva ventana que aparece damos  click en Qt a  la  izquierda y sobre  Qt  Resource  File  a  la  derecha.  En  la  ventana  siguiente  le  colocamos  nombre,  por  ejemplo Recursos, colocándole el programa la extensión *.qrc. Click en Next y después en Finish.  Observamos que en el  árbol del proyecto  aparece  ahora  la  carpeta  “Resources”  y dentro de ella el archivo  “Recursos.qrc”. Damos doble  click  sobre éste último, apareciendo abajo una ventana  con el botón “Add”. Damos click sobre él y adicionamos un nuevo prefijo (“Add Prefix”). Una vez establecido el prefijo, de nuevo click sobre “Add” y esta vez añadiremos un archivo (“Add Files”). Este archivo será la  imagen  que  tenemos  en  la  misma  carpeta  (logo_grupo.bmp).  Luego  grabamos  este  archivo “Recursos.qrc”.  Vamos ahora a la interfaz que estamos construyendo.  Pasamos de la izquierda a la derecha un “Label”. Agrandamos el cuadro que acabamos de pasar, borramos la palabra “Text Label” que aparecía y damos click derecho. Una de las formas de incluir la figura es dar click sobre “Change rich text” en el menú que acaba de aparecer. Aparece una  ventana a  la derecha de  la  cual hay un  ícono que  se  llama  “Insert image”. Damos click sobre él y aparece una ventana que se  llama “Select Resource”. Escribimos a  la derecha “Recurso.qrc” y Enter. En  la ventana de  la  izquierda aparece “prefix1”, damos click sobre él apareciendo a  la  izquierda  la  figura asociada. Damos OK y ya tendremos en nuestra  interfaz  la  figura deseada, la cual podemos cambiar de tamaño y ubicación.   CREAR UN PROJECTO PARA VISUAL STUDIO  QT/QT Creator permite diseñar la interfaz gráfica de la aplicación. Sin embargo el acceso a puertos para conectar hardware  externo, por  ejemplo, debe  seguir haciéndose  a partir de C++.  Esto  implica que nuestra  interfaz  debe  poder  abrirse  en  Visual  Studio  como  un  proyecto.  La  herramienta  que me permite esto es CMake, diseñada para generar código en diversas plataformas. 

 La última versión de CMake es  la 2.8.5  (www.cmake.org  ). La bajamos del sitio y  la  instalamos. En el ejemplo  anterior  de  QT  Creator  supongamos  que  hemos  creado  nuestra  interfaz  en  la  carpeta C:\Qtcreator‐2.3.0\Nuevo.   CMake  trabaja  con  un  archivo  de  configuración  que  debe  estar  ubicado  en  la misma  carpeta  del proyecto,  en  nuestro  caso  en  la  carpeta  C:\Qtcreator‐2.3.0\Nuevo\Ejemplo.  Este  archivo  se  llamará CMakeLists.txt.  El  archivo  genérico  es  el  siguiente,  copiarlo  en  un  bloc  de  notas  y  grabarlo  con  el nombre anotado anteriormente:  cmake_minimum_required(VERSION 2.8)  PROJECT(Ejemplo)  FIND_PACKAGE(Qt4 REQUIRED) INCLUDE(${QT_USE_FILE})  INCLUDE_DIRECTORIES(${CMAKE_CURRENT_BINARY_DIR}) # Es donde la cabecera del ui se genera  FILE(GLOB fuente_SRCS "*.cpp") FILE(GLOB UIs_SRCS "*.ui") FILE(GLOB cabecera_SRCS "*.h")  SET(cabecera_Gui_SRCS mainwindow.h)  QT4_WRAP_UI(UisCabecera_SRCS ${UIs_SRCS}) QT4_WRAP_CPP(MOC_SRCS ${cabecera_Gui_SRCS})  ADD_EXECUTABLE(Ejemplo ${fuente_SRCS} ${UisCabecera_SRCS} ${MOC_SRCS} ${cabecera_SRCS}) TARGET_LINK_LIBRARIES(Ejemplo ${QT_LIBRARIES}) 

 Luego  se  abre  la  ventana  de  CMake  (Inicio,  CMake2.8,  CMake  (cmake‐gui)).  Aquí  debemos  dar  la ubicación de las fuentes a compilar y la ubicación de la compilación:  Where is the source code: C:\Qtcreator‐2.3.0\Nuevo\Ejemplo Where to build the binaries: C:\Ejemplo_buil  Damos clic en “Configure”. Una vez termine la configuración damos click sobre “Generate”, con lo cual se habrá generado el código para compilar en  la carpeta  indicada (C:\Ejemplo_build). En esta carpeta abrimos el archivo Ejemplo.sln con Visual Studio.  En  el  “Explorador  de  soluciones”  dar  clic  en ALL_BUILD,  luego  clic  en  el menú  “Generar”,  y  clic  en “Generar  ALL_BUILD”,  compilándose  el  programa.  Tener  en  cuenta  antes  de  realizar  esto  que  el configurador de soluciones de Visual Studio debe estar en modo “Release”  (y no en “Debug”). El VS creará entonces un ejecutable en la carpeta Release de este proyecto. Ya podemos añadir al proyecto todas  las  librerías y utilidades necesarias, conservando  la  interfaz gráfica creada anteriormente en QT Creator.  

     

CREACIÓN DE HERRAMIENTAS 3D CON VTK   Aunque  QT  permite  trabajar  con  diferentes  archivos  gráficos,  básicamente  solo  se  pueden desplegar en pantalla  sin  funcionalidades adicionales. Sin embargo el  software VTK,  creado por Kitware, permite la realización y visualización avanzada de gráficos en 3D. Estas librerías de código abierto pueden descargarse de www.vtk.org o de  la página del DEIC  indicada arriba (archivo vtk‐5.8.0.zip).  Descargar y descomprimir dicho archivo, por ejemplo en C:\VTK. Se crea luego una carpeta donde se  ubicarán  las  fuentes  del  programa,  por  ejemplo  en  C:\VTK_build.  Abrimos  CMake  (Inicio  ‐> Programas ‐> CMake ‐> Cmake (cmake‐gui)).  Se  abre  la  ventana  de  CMake,  donde  debemos  dar  la  ubicación  de  las  fuentes  a  compilar  y  la ubicación de la compilación:  Where is the source code: C:\VTK5 Where to build the binaries: C:\VTK5_build  Damos clic en “Configure”. Le damos como opción la instalación de VTK para Visual Studio 9 2008. Veremos  la  barra  verde  trabajando,  mostrando  al  finalizar  en  rojo  las  líneas  que  deben  ser definidas. Dar clic en “Advanced View” para poder acceder a más opciones para escoger. En éstas marcar:  BUILD_EXAMPLES: ON  VTK_USE_GUISUPPORT: ON USE_QT: ON DESIRED_QT_VERSION: 4  Dar de nuevo clic en “Configure” hasta que todas las líneas aparezcan en gris. Estas líneas pueden aparecer en diferentes pantallas, cada vez que se da la orden “Configure”. Cuando todo aparezca en gris podemos dar clic en “Generate”, con lo cual se habrá generado el código para compilar en la carpeta indicada (C:\VTK5_build). En esta carpeta abrir el archivo VTK.sln con Visual Studio.  En el “Explorador de soluciones” dar clic en ALL_BUILD, luego clic en el menú “Generar”, y clic en “Generar ALL_BUILD”, compilándose el programa. Por último para instalarlo, en el “Explorador de soluciones”, clic en INSTALL, luego en “Generar”, y en “Generar INSTALL”. Por defecto lo instalará en C:\Archivos de programa\VTK.  Las respectivas librerías de VTK deben ser incluidas en Visual Studio. Para hacer esto abrir el Visual y  dar  clic  en  “Herramientas”,  luego  en  “Opciones”,  “Proyectos  y  soluciones”,  finalmente  en “Directorios de VC++”. Aquí en “Archivos de inclusión” agregar una línea para:  C:\Archivos de programa\VTK\include\vtk‐5.8\  Y en “Archivos de biblioteca” agregar una línea para:  C:\Archivos de programa\VTK\lib\vtk‐5.8\ 

Realizaremos a continuación un ejemplo para la carga de un archivo gráfico con extensión *.obj:  Abrimos QT Creator y creamos un proyecto llamado Lectura, con sus archivos por defecto con los nombres de  leer.cpp,  leer.h,  leer.ui y main.cpp. Creamos entonces una ventana con el siguiente menú en la parte superior izquierda (Archivo y de él sale Importar).  

   En el menú de QT Creator, bajo la rúbrica de “Containers”, tomamos el “Widget” y lo ubicamos en nuestra ventana del proyecto, dándole un tamaño deseado (como se muestra arriba con el cuadro dibujado).  En la parte superior derecha, donde aparecen los Objetos y sus Clases, veremos la clase “QWidget” y colocamos en el nombre del objeto (haciendo doble click) la palabra “principal”. Abajo veremos otra  clase QWidget,  correspondiente  a  la  ventana Widget que  acabamos de  colocar en el paso anterior. Le colocamos como nombre “renderizado”, y damos click derecho sobre el nombre del objeto (QWidget). En el menú que se despliega damos click en “Promote to”. En la nueva ventana que se abre damos nombre a la clase promovida (“Promoted class name”) como QVTKWidget (lo cual  incluye  las  librerías de VTK para  trabajar con  los widgets definidos en QT Creator). Aparece automáticamente el nombre del archivo qvtkwidget.h. Click en “Promote” y se cierra  la ventana. Quedaría algo como lo siguiente:  

 Guardamos el proyecto y cerramos QT Creator. 

Generaremos ahora el correspondiente proyecto para Visual Studio. Copiamos el siguiente código en el bloc de notas y le colocamos como nombre CMakeLists.txt.  

cmake_minimum_required(VERSION 2.8)  PROJECT(Lectura)  FIND_PACKAGE(VTK REQUIRED) INCLUDE(${VTK_USE_FILE})  FIND_PACKAGE(Qt4 REQUIRED) INCLUDE(${QT_USE_FILE})  INCLUDE_DIRECTORIES(${CMAKE_CURRENT_BINARY_DIR})   FILE(GLOB fuente_SRCS "*.cpp") FILE(GLOB UIs_SRCS "*.ui") FILE(GLOB cabecera_SRCS "*.h")  SET(cabecera_Gui_SRCS Leer.h)  QT4_WRAP_UI(UisCabecera_SRCS ${UIs_SRCS}) QT4_WRAP_CPP(MOC_SRCS ${cabecera_Gui_SRCS})  ADD_EXECUTABLE(Lectura ${fuente_SRCS} ${UisCabecera_SRCS} ${MOC_SRCS} ${cabecera_SRCS}) TARGET_LINK_LIBRARIES(Lectura QVTK vtkHybrid vtkWidgets) 

 Tendremos entonces en una carpeta (por ejemplo la carpeta “Lectura”) el archivo CMakeLists.txt, más los archivos creados por QT Creator, es decir leer.cpp, leer.h, main.cpp y leer.ui.  Se  crea una  carpeta donde  se  construirá  el proyecto  (por  ejemplo  Lectura_buil)  y  se  genera  el mismo  con  la ayuda de CMake  (como  fuente  la  carpeta  Lectura;  como destino  la  carpeta vacía llamada Lectura_build). Una vez finalizada  la tarea con CMake (configure y generate), abrimos el archivo Lectura.snl que aparece en la carpeta Lectura_build. Se abre automáticamente con Visual Studio, viéndose en  la parte  izquierda el menú con  los archivos de cabecera (leer.h y ui_leer.h) y los archivos fuente (leer.cpp y main.cpp).  En el archivo leer.cpp borramos todo lo que tiene (muchas líneas se conservan pero mejor borrar todo) y copiamos el siguiente código:  #include "leer.h" #include "ui_leer.h"  #include <vtkRenderWindow.h> #include <vtksys/SystemTools.hxx> #include <vtkCamera.h>  #include <QFileDialog> #include <QString>  Leer::Leer(QWidget *parent) :     QMainWindow(parent),     ui(new Ui::Leer) {     ui‐>setupUi(this); 

   renderer = vtkRenderer::New();   obj = vtkOBJReader::New();   polyData = vtkPolyData::New();   mapper = vtkPolyDataMapper::New();   mapperC = vtkPolyDataMapper::New();   actor = vtkActor::New();   actorC = vtkActor::New();   estilo = vtkInteractorStyleTrackballCamera::New();   iren = vtkRenderWindowInteractor::New();   matriz1 = vtkMatrix4x4::New();   matriz2 = vtkMatrix4x4::New();        renderer‐>SetBackground(0.2, 0.3, 0.5);   iren‐>SetInteractorStyle(estilo);      ui‐>renderizado‐>GetRenderWindow()‐>AddRenderer(renderer);   ui‐>renderizado‐>GetRenderWindow()‐>SetInteractor(iren);   ui‐>renderizado‐>GetRenderWindow()‐>Render();    connect(ui‐>actionImportar, SIGNAL(triggered()), this, SLOT(importar()));  }  Leer::~Leer() {     delete ui;    renderer‐>Delete();   obj‐>Delete();   polyData‐>Delete();   mapper‐>Delete();   actor‐>Delete();   estilo‐>Delete();  }  void Leer::importar() { QString archivo = QFileDialog::getOpenFileName(this, tr("Abrir archivo"), "", tr("Archivos (*.obj)"));      archivoAbierto = true;  std::string extension = vtksys::SystemTools::GetFilenameLastExtension(archivo.toStdString());              obj‐>SetFileName(archivo.toAscii());       obj‐>Update();       polyData = obj‐>GetOutput();        mapper‐>SetInput(polyData);       actor‐>SetMapper(mapper);        renderer‐>AddActor(actor);       renderer‐>ResetCamera();        ui‐>renderizado‐>GetRenderWindow()‐>Render();  } 

Y en el archivo leer.h borramos todo y copiamos lo siguiente: 

 #ifndef Leer_H #define Leer_H  #include <QMainWindow>  #include <vtkRenderer.h> #include <vtkPolyData.h> #include <vtkActor.h> #include <vtkPolyDataMapper.h> #include <vtkPolyDataReader.h> #include <vtkXMLPolyDataReader.h> #include <vtkPLYReader.h> #include <vtkOBJReader.h> #include <vtkRenderWindowInteractor.h> #include <vtkInteractorStyleTrackballCamera.h> #include <vtkMatrix4x4.h>   namespace Ui {     class Leer; }  class Leer : public QMainWindow {     Q_OBJECT  public:     explicit Leer(QWidget *parent = 0);     ~Leer();  public slots:   void importar();  private:     Ui::Leer *ui;    vtkRenderer *renderer;   vtkPolyData *polyData;   vtkActor *actor, *actorC;   vtkPolyDataMapper *mapper, *mapperC;   vtkOBJReader *obj;   vtkRenderWindowInteractor *iren;   vtkInteractorStyleTrackballCamera *estilo;   vtkMatrix4x4 *matriz1, *matriz2;      bool archivoAbierto; };  #endif // Leer_H 

 Asegurándonos  que  la  configuración  de  soluciones  se  halle  en  modo  “Release”,  compilamos “ALL_BUILD”. Esto generará un ejecutable llamado Lectura.exe en la carpeta Release, dentro de la carpeta Lectura_build. En esta carpeta Release copiar el archivo Higado_BajaRes.obj (o el archivo obj que se desee), el cual se encuentra en la dirección www.unicauca.edu.co/deic/Documentos. Al dar  doble  click  sobre  Lectura.exe  se  abre  la  ventana  diseñada  en QT  Creator,  con  el menú  de “Archivo” en la parte superior izquierda. Damos click en ese menú, aparece la opción “Importar” y 

al dar click en ella escogemos el archivo Higado_BajaRes.obj (o en cualquier archivo *.obj que se encuentre  en  otra  ubicación  del  PC).  La  imagen  que  se  carga  en  pantalla  puede  cambiarse  de orientación dando click sostenido. Una imagen del archivo cargado se aprecia a continuación: