QUTLINE: SEGMENTACIÓN DE LÍNEAS A PARTIR DE...
Transcript of QUTLINE: SEGMENTACIÓN DE LÍNEAS A PARTIR DE...
“QUTLINE: SEGMENTACIÓN DE LÍNEAS A PARTIR DE DISTANCIAS O
PARTES EQUIVALENTES”
AUTORES
Alisson Viviana Barreto Nieto
20151094003
Gloria Esperanza Suarez Poveda
20151094023
Cristian Mora Cortés
20151094023
TRABAJO DE GRADO PARA OPTAR POR EL TÍTULO DE ESPECIALISTA EN
SISTEMAS DE INFORMACIÓN GEOGRÁFICA.
UNIVERSIDAD DISTRITAL FRANCISCO JOSÉ DE CALDAS
FACULTAD DE INGENIERÍA
ESPECIALIZACIÓN EN SISTEMAS DE INFORMACIÓN GEOGRÁFICA
BOGOTÁ
2015
2
“QUTLINE: SEGMENTACIÓN DE LÍNEAS A PARTIR DE DISTANCIAS O
PARTES EQUIVALENTES”
AUTORES
Alisson Viviana Barreto Nieto
20151094003
Gloria Esperanza Suarez Poveda
20151094023
Cristian Mora Cortés
20151094023
PROYECTO DE APLICACIÓN
DIRECTOR
SALOMÓN RAMÍREZ
UNIVERSIDAD DISTRITAL FRANCISCO JOSÉ DE CALDAS
FACULTAD DE INGENIERÍA
ESPECIALIZACIÓN EN SISTEMAS DE INFORMACIÓN GEOGRÁFICA
BOGOTÁ
2015
3
Nota de aceptación
________________________
________________________
________________________
Jurado
GERMAN CIFUENTES
Bogotá, 09 de Noviembre de 2015
4
TABLA DE CONTENIDO
RESUMEN ....................................................................................................................... 8
INTRODUCCIÓN ........................................................................................................... 9
OBJETIVOS ...................................................................................................................11
OBJETIVO GENERAL ...................................................................................................... 11
OBJETIVOS ESPECÍFICOS ................................................................................................ 11
1. MARCO DE REFERENCIA ...................................................................................12
1.1 MARCO TEÓRICO ................................................................................................ 12
2. METODOLOGÍA ....................................................................................................14
2.1 ANÁLISIS Y DISEÑO .................................................................................................. 14
2.2 IMPLEMENTACIÓN Y PROTOTIPADO .......................................................................... 18
2.3 EVALUACIÓN ........................................................................................................... 19
3. RESULTADOS ........................................................................................................22
3.1 CÓDIGO DE QUTLINE ............................................................................................... 22
3.2 FUNCIONALIDAD DEL PLUGIN PROPUESTO ................................................................. 22
3.3 EVALUACIÓN DE USABILIDAD DE QUTLINE ............................................................... 25
CONCLUSIONES...........................................................................................................30
BIBLIOGRAFIA ............................................................................................................31
5
LISTA DE TABLAS
Tabla 1. Encuesta de usabilidad de Qutline. ..................................................................... 26
Tabla 2. Resumen encuestas de usabilidad de Qutline - Facilidad de aprendizaje.............. 27
Tabla 3. Resumen estadístico modelo de usabilidad para Qutline – Ayuda. ...................... 28
Tabla 4. Resumen encuestas de usabilidad de Qutline – Recuerdo en el tiempo. ............... 28
Tabla 5. Resumen encuestas de usabilidad de Qutline – Entendibilidad. ........................... 29
Tabla 6. Resumen encuestas de usabilidad de Qutline – Atractivo. ................................... 29
6
LISTA DE FIGURAS
Figura. 1. Metodología Qutline ........................................................................................ 14
Figura. 2. Diagrama de casos de uso................................................................................. 15
Figura. 3. Diagrama de secuencias Segmentación a una distancia definida ....................... 16
Figura. 4. Diagrama de secuencias corte por segmentos iguales ........................................ 17
Figura. 5. Diagrama de componentes ............................................................................... 18
Figura. 6. Mockup Qutline ............................................................................................... 19
Figura. 7. Modelo de Medición basada en jerarquía de tres niveles ................................... 20
Figura. 8. Funcionamiento Qutline por el método de distancia ingresada por el usuario .... 23
Figura. 9. Funcionamiento Qutline por el método de segmentación en partes equivalentes 24
Figura. 10. No hay selección del objeto tipo línea ............................................................ 24
Figura. 11. No se ingresa el número de segmentos o la distancia en que se quiere segmentar
........................................................................................................................................ 25
8
RESUMEN
Este documento muestra las actividades de análisis y diseño, prototipado,
implementación y resultados de Qutline, plugin para el software QGis desarrollado
en lenguaje Python, que tiene por funcionalidad la segmentación de líneas, facilitando
las tareas de ejecución que se generan en temas de manejo y clasificación vial en general,
con el objetivo de reducir la cantidad de tiempo, clics o pasos para el proceso de corte de
líneas, garantizando la dimensión, dirección y vértices creados por la aplicación para el
adecuado manejo de la información del usuario.
Palabras claves: segmentación, python, QGis.
ABSTRACT
This document shows the activities of analysis and design, prototyping, implementation
and results of Qutline, plugin developed in Python QGis software, whose functionality
segmentation lines, facilitating implementation tasks generated in management issues
and road classification in general, with the aim of reducing the amount of time, clicks or
steps to the process of cutting lines, guaranteeing the size, direction and vertices created
by the application to the appropriate management of user information
Keywords: segmentation, python, QGis.
9
INTRODUCCIÓN
Dentro del ámbito de aplicación de los SIG se puede observar que la utilidad del
procesamiento de los elementos espaciales ha sido la principal herramienta para el estudio de
gran cantidad de temáticas que implican la espacialización de datos y pone en evidencia
estructuras y formas de organización espacial recurrentes. En los procesos que se desarrollan,
el análisis espacial ha contado con dos marcadas líneas de definición. Por una lado está la
que considera a todo tipo de procesamiento de datos espaciales (O´Sullivan y Unwin, 2003)
y por el otro las que consideran únicamente los aspectos geométricos de las entidades
espaciales considerando que el espacio geográfico siempre interviene en el resultado (Berry,
1996). De esta manera se contempla que esta última clasificación ha sido relevante en
diversas aplicaciones como en la red vial de un territorio la cual se representa mediante líneas
segmentadas, conectadas entre sí, con integralidad, consistencia y continuidad, que permiten
clasificar, visualizar, interpretar y analizar los atributos inherentes a las calzadas (Zapata
Jaime, 2012), así mismo, el estudio de líneas férreas, oleoductos, redes y otros requieren de
cortes de líneas a distancias determinadas para generar tramos específicos en la aplicación
del proceso. Gamir, et al. (1995), argumenta que la mayor dificultad en la utilización de los
métodos de análisis espacial está en creer que el análisis espacial tiene un fin en sí mismo.
Para salvar esta dificultad los autores sugieren entender el análisis espacial “como un soporte
técnico a la toma de decisiones”, de este modo se evidencia la necesidad de crear una
herramienta que facilite el trabajo en temas de manejo y clasificación vial en general, que
permita generar la segmentación de líneas de una manera fácil y rápida, funcionalidad que
no ha sido creada para el software QGIS, que permita la segmentación de líneas a distancias
requeridas por el usuario, sólo se cuenta con la opción de corte de líneas a través del uso de
la herramienta dividir objetos espaciales en la opción de edición, dando clic en los puntos
donde se quiere segmentar y en el caso del software Arcgis para el corte de líneas, se dispone
del comando dividir, el cual se utiliza activando la opción editar, ejecutando la opción dividir
y allí se especifica la opción de partes iguales, como resultado se divide la línea, en donde la
opción dividir, actualiza la forma de la entidad existente y crea una o más entidades nuevas
con los valores de atributos predeterminados para la clase de entidad, así mismo se puede
10
dividir una línea manualmente, con distancias, también se encuentra la opción de dividir una
línea en un porcentaje específico (web Arcgis Resource Center,2015). Con el fin de
solucionar este requerimiento, se considera que la mejor forma es el desarrollo de un plugin
que permite el corte de líneas de manera ágil y que garantice la distancia requerida.
En efecto se desarrolla Qutline como una herramienta que permitirá generar dos métodos
nuevos los cuales permiten segmentar líneas de manera rápida, con el fin de obtener el corte
de una línea en el número de segmentos o en la distancia que desee, facilitando las tareas de
ejecución común, ya que su objetivo se basa en la reducción de la cantidad de tiempo, clics
o pasos para el proceso de corte de líneas, garantizando la dimensión, dirección y vértices
creados por la aplicación para el adecuado manejo de la información del usuario, lo anterior
a partir de una interfaz clara, intuitiva y la interacción directa con la ventana del mapa pues
resulta más sencillo interactuar con las geometrías de manera gráfica a través de selecciones.
Por último se considera que verán beneficiados todos los usuarios que para sus labores
trabajen con análisis de tipologías de líneas y requieran de la segmentación de las mismas
para el desarrollo y análisis que comprende un conjunto de procedimientos utilizados para
abordar el estudio de la estructura y las relaciones territoriales a partir del conocimiento de
la posición y las características de las entidades geográficas de las variables involucradas. En
efecto, las aplicaciones más usuales tienden a responder a necesidades más sencillas
(Goodchild y Haining 2005), pero que en el desarrollo de estudios y análisis espaciales
permiten generar soluciones óptimas para las actividades concernientes con localizaciones
espaciales.
11
OBJETIVOS
Objetivo General
Crear un plugin para segmentación de líneas a distancias determinadas y en una cantidad de
partes iguales.
Objetivos Específicos
Generar el código en lenguaje Python de Qutline.
Desarrollar la funcionalidad del plugin propuesto.
Realizar la evaluación de usabilidad de Qutline a través del modelo de medición de
usabilidad.
12
1. MARCO DE REFERENCIA
1.1 Marco Teórico
Interfaz gráfica de usuario: son todos los elementos gráfico que permiten al usuario
comunicarse con un sistema. (Gonzalez, 2004)
Pluging: es un módulo de software que añade una característica o un servicio específico a
un programa principal.
Python: es un lenguaje de programación de alto nivel, interpretado, orientado a objetos y
multipropósito, fue creado por Guido van Rossum a principios de los años 90.
QGIS: es un Sistema de Información Geográfica (SIG) de Código Abierto licenciado bajo
GNU - General Public License . QGIS es un proyecto oficial de Open Source Geospatial
Foundation (OSGeo). Corre sobre Linux, Unix, Mac OSX, Windows y Android y soporta
numerosos formatos y funcionalidades de datos vector, datos ráster y bases de datos.
(QGIS.org, 2015)
Software libre: es aquel que una vez obtenido, puede ser usado, copiado, estudiado,
modificado y redistribuido libremente.
13
Usabilidad: es la medida de la calidad de la experiencia que tiene un usuario cuando
interactúa con un producto o sistema, debe ser entendida siempre en relación con la forma y
condiciones de uso por parte de sus usuarios, así como con las características y necesidades
propias de estos usuarios.
14
2. METODOLOGÍA
Para el desarrollo de Qutline se ejecutaron 4 etapas que se muestran en la figura 1, las cuales
permitieron establecer el ciclo de vida del plugin y obtener los resultados esperados.
Figura. 1. Metodología Qutline
Fuente: Elaboración propia
2.1 Análisis y diseño
Qutline, se crea como una nueva funcionalidad para el software Qgis, el cual ha convertido
en el SIG de escritorio de referencia, debido a que permite manejar formatos de datos ráster
y vectoriales a través de bibliotecas y bases de datos donde radican sus potencialidades, se
caracteriza por tener una interfaz flexible, multiplataforma (GNU/Linux, BSD, Unix, Mac
OSX, Windows y Android), que permite la automatización de tareas con PyQGIS para
manipulación a través de lenguaje Python y la posibilidad de crear aplicaciones
independientes, con la posibilidad de crear tú mismo nuevos plugins. (Morales, 2014). Por
lo cual, el código generado para la lógica de este plugin se basa en el lenguaje Python, ya que
15
este es un lenguaje de alto nivel, simplificado a diferencia de otros lenguajes como C++,
cuenta con gran cantidad de bibliotecas, la sintaxis es sencilla y cercana al lenguaje natural,
cabe destacar que el código en Python tiene un tamaño mucho más pequeño que el que se
debe desarrollar en C++ o Java, es multiplataforma lo que permite desarrollar interfaces
gráficas portables como PyQT, TKinter, wxPython, PyGTK (Milton Mazzarri, 2011).
Luego de haber determinado el lenguaje para este plugin, se procede a plantar los casos de
uso que serán la base para la creación de Qutline, en donde se establece que se puede acceder
a dos métodos como se muestra en la figura 2 que cumplen con la misma funcionalidad,
segmentación de líneas, que se diferencian en generar el corte a partes iguales, o a una
distancia requerida por el usuario.
Figura. 2. Diagrama de casos de uso
Fuente: Elaboración propia
El flujo de trabajo de este plugin es sencillo: en Qgis, el usuario debe cargar la capa tipo línea
siendo esta una precondición del sistema, posteriormente debe seleccionar la línea a la cual
quiere realizar el corte a través de un clic, se procede a introducir el valor de la distancia
requerida correspondiente a la figura 3 o el número de segmentos deseados ver figura 4 y clic
en el botón cortar, información que el sistema reconoce y con la cual procede a generar el
16
corte de la línea seleccionada, colocando un punto encima de la segmentación con el fin de
facilitar su visualización y finalmente genera el nuevo shape con la correspondiente longitud
deseada.
Figura. 3. Diagrama de secuencias Segmentación a una distancia definida
Fuente: Elaboración propia
17
Figura. 4. Diagrama de secuencias corte por segmentos iguales
Fuente: Elaboración propia
Los componentes usados para Qutline se muestran en la figura 3, el diagrama de componentes
obedece a dos características básicas la presentación o front-end y la parte lógica o back-
end. Qgis ha desarrollado dentro de su software varios componentes, no componentes y
librerías que permiten la ejecución de diferentes funciones orientadas al desarrollo de estas
características (Presentación y Lógica) para la creación de herramientas (Plugins) en este
caso la lógica es desarrollada por Qgis Core componente que contiene todas las funciones
fundamentales del SIG, la presentación es realizada QGIS GUI que añade los widgets a la
interfaz gráfica permitiendo su interacción, QGIS Canvas permite trabajar directamente con
la ventana del mapa, en este caso para la selección directa de la línea permitiendo la
18
funcionalidad adecuada del plugin, el componente Qt4 permite la programación de la interfaz
gráficas a través de código utilizando la libreria PyQt4 que aplica lenguaje Python.
Figura. 5. Diagrama de componentes
Fuente: Elaboración propia
2.2 Implementación y Prototipado
Se define que la plataforma desktop es la más adecuada para el desarrollo de Qutline,
generando de tal manera la estructuración del código en lenguaje Python y su respectivo
mockup figura 6, el cual permitirá el flujo de comunicación entre el usuario y la interfaz, y
tener una primera aproximación de cómo será el manejo de este plugin.
19
Figura. 6. Mockup Qutline
Fuente: Elaboración propia
2.3 Evaluación
En la evaluación de usabilidad del plugin es importante considerar la facilidad con la que el
usuario va a interactuar con la aplicación propuesta, lo que permite identificar los elementos
y sus niveles de compromiso con el cumplimiento de los requisitos de efectividad, eficiencia
y satisfacción para el contexto de un uso determinado.
El estándar ISO 9241 define la Usabilidad como “el grado en el que un producto puede ser
utilizado por usuarios específicos para conseguir objetivos específicos con efectividad,
eficiencia y satisfacción en un determinado contexto de uso” (ISO 9241-11, 1998).
La evaluación de la usabilidad asegura que los productos sean fáciles de usar, eficientes,
eficaces y satisfactorios para los usuarios (Hwang, Salvendy; 2010). Existen diversos
20
métodos para la evaluación de usabilidad (Nielsen, Molich; 1990) (Wixon, Wilson; 1997)
(Hix, Hartson; 1993).
Por lo cual, para Qutline se adoptó el modelo de medición de usabilidad Figura 7, basado en
jerarquías, que permite definir la usabilidad de un sitio web a través del establecimiento de
criterios, métricas y atributos, con el fin de generar niveles de abstracción adecuados durante
la evaluación (Claros, 2006). Como proceso parcial de validación para el modelo se realizó
una encuesta para un total de 15 potenciales usuarios de Qutline, la cual tuvo como propósito,
determinar si este plugin cumple con la perspectiva del usuario, evaluando su usabilidad y
accesibilidad y de tal forma poder establecer un proceso de mejora continua.
Figura. 7. Modelo de Medición basada en jerarquía de tres niveles
Fuente: Propuesta Metodológica para la Evaluación de la Usabilidad en Sitios Web:
Experiencia Colombiana, Claros Iván
Dentro de los ítems definidos en los niveles propuestos, se encuentra el aprendizaje, en donde
se pretende identificar si Qutline es un plugin fácil de entender, dado el manejo de la interfaz
gráfica implementada, en donde lo único que requiere el usuario es realizar una selección e
insertar el número de partes o distancia en la que desea segmentar la línea. Así mismo se
21
recolectó y analizó las conductas y necesidades que presentan los usuarios frente al sistema
y el tiempo de retorno de información.
La encuesta se desarrolla paralelamente junto a una prueba del plugin y de esta forma se
garantiza que se midan todas las funcionalidades del mismo, para lo cual el usuario califica
los siguientes criterios:
Aprendizaje
Satisfacción
Contenido
Eficiencia
Eficacia
Criterios que describen a partir de ítems el funcionamiento detallado de un Plugin o una
aplicación, los usuarios finales con sus inconformidades y opiniones dadas a través de una
calificación numérica darán un punto de vista de la aplicación claro, detallado y conciso
respecto a las bondades y falencias del funcionamiento de nuestro plugin Qutline.
22
3. RESULTADOS
3.1 Código de Qutline
Luego de determinas la funcionalidad y los componentes para la creación de Qutline, se
procede a generar su código en lenguaje Python como se muestra en el Anexo 1, el cual tiene
9 funciones que permiten generar la segmentación de líneas por los dos métodos establecidos,
adicionalmente crea una capa de puntos virtuales que se establecen en la intersección de cada
corte y que permiten al usuario visualizar la segmentación de una forma más clara, así mismo
en la tabla de propiedades del objeto tipo línea que fue cortado, contiene la longitud de los
nuevos segmentos verificando que la medida corresponde a la deseada.
3.2 funcionalidad del plugin propuesto
Qutline cumple con la misma funcionalidad a partir de dos métodos, segmentación de líneas
a partes iguales, o a una distancia requerida por el usuario, para el funcionamiento de este
plugin es necesario que se halla instalado de forma correcta en el software Qgis y se tenga en
cuenta que únicamente funciona para objetos tipo línea.
En la figura 8 se muestra la secuencia lógica del funcionamiento de Qutline por el método de
corte por una distancia que el usuario digite, para lo cual es necesario realizar 4 pasos:
a. Seleccionar un objeto tipo línea
b. Seleccionar el método de corte por una distancia definida
c. Ingresar la distancia, teniendo en cuenta que será tomada en unidades de metros
d. Clic en el botón cortar y Qutline genera los nuevos segmentos con la distancia
estipulada, que puede ser observada en la tabla de atributos del objeto seleccionado.
23
Figura. 8. Funcionamiento Qutline por el método de distancia ingresada por el usuario
Fuente: Elaboración propia
En la figura 9 se muestra la secuencia lógica del funcionamiento de Qutline por el método de
partes equivalentes, que para su funcionamiento es necesario realizar 4, que difieren del
método de corte por una distancia específica ya que el usuario indica en cuantas partes quiere
hacer el corte y el sistema calcula la longitud en que debe ser dividido el objeto seleccionado
de acuerdo a los segmentos deseados.
a. Seleccionar un objeto tipo línea
b. Seleccionar el método de corte por segmentos
c. Ingresar el número de segmentos en que se quiere dividir el objeto seleccionado
d. Clic en el botón cortar y Qutline el número de segmentos estipulados su longitud
resultante puede observarse en la tabla de atributos del objeto.
24
Figura. 9. Funcionamiento Qutline por el método de segmentación en partes equivalentes
Fuente: Elaboración propia
Para corroborar que el plugin únicamente funciona para objetos tipo línea, que deben haberse
seleccionado con anterioridad y que se debe especificar los atributos según el método de
corte, se hicieron pruebas de verificación Figuras 10 y 11, en donde Qutline genera mensajes
de error que avisan al usuario que hace falta un paso para su correcto desarrollo.
Figura. 10. No hay selección del objeto tipo línea
Fuente: Elaboración propia
25
Figura. 11. No se ingresa el número de segmentos o la distancia en que se quiere
segmentar
Fuente: Elaboración propia
3.3 Evaluación de usabilidad de Qutline
La encuesta que permite evaluar la usabilidad de Qutline Tabla 1, fue desarrollada por 25
posibles usuarios de Qutline, en donde se establece el criterio, luego las métricas y por último
los atributos a evaluar, con el objetivo de que cada evaluador calificara en dos escalas según
el tipo de pregunta como se muestra en la Tabla 1: de 1 a 5 en donde, 5 Excelente, 4 Muy
Bueno, 3 Bueno, 2 Regula, 1 Deficiente. La otra escala es 1 para SI y 0 para NO.
26
CRITERIOS DE USABILIDAD
CALIFICACIÓN
1 FACILIDAD DE APRENDIZAJE
1.1 Facilidad para entender los cambios producidos en las operaciones 1 A 5
1.2 Facilidad para entender que datos ingresar y los resultados proporcionados 1 A 5
1.3 Desde cualquier punto un usuario puede salir de la herramienta SI: 1 NO: 0
1.4 En caso que el proceso requiera varios pasos es posible volver a los anteriores para
modificar los datos SI: 1 NO: 0
1.5 La terminología es constante en toda la herramienta SI: 1 NO: 0
1.6 Se dan indicaciones para completar campos problemáticos SI: 1 NO: 0
1.7 Se identifican fácilmente las figuras, las tablas, las zonas activas y el tipo de acción
que se debe ejecutar SI: 1 NO: 0
1.8 La herramienta no requiere volver a escribir la información solicitada anteriormente SI: 1 NO: 0
1.9 La herramienta soporta el aprendizaje colaborativo SI: 1 NO: 0
2 AYUDA
2.1 ¿La Herramienta requiere iper tipo de ayuda? SI: 1 NO: 0
2.2 El acceso a la ayuda está en una zona visible y reconocible SI: 1 NO: 0
2.3 La herramienta está diseñada para necesitar el mínimo de ayuda y de instrucciones SI: 1 NO: 0
3 RECUERDO EN EL TIEMPO
3.1 Se necesita recurrir a la ayuda en caso de no recordar el uso de la herramienta SI: 1 NO: 0
3.2 Es fácil de recordar como ejecutar una tarea en la herramienta SI: 1 NO: 0
4 ENTENDIBILIDAD
4.1 Los mensajes emitidos son fáciles de entender 1 a 5
4.2 El mensaje de error propone una solución SI 1 NO 0
4.3 Los tipos y tamaños de letra son legibles y distinguibles SI 1 NO 0
4.4 El tamaño de las imágenes e iconos es adecuado para saber qué representan 1 a 5
4.5 El lenguaje está más cercano al utilizado por el usuario que al informático o técnico 1 a 5
5 ATRACTIVO
5.1 Los títulos son descriptivos y distintivos 1 a 5
5.2 Despliega excesiva información en la interfaz de la herramienta. 1 a 5
5.3 Se utilizan las ventanas emergentes para mostrar información importante SI: 1 NO: 0
5.4 En los menús desplegables, los elementos de las listas son suficientemente
explicativos y se visualizan todos a la vez 1 a 5
5.5 La apariencia de la herramienta es agradable y sencilla 1 a 5
Tabla 1. Encuesta de usabilidad de Qutline.
Fuente: Elaboración propia
27
La tabla 2 muestra la calificación que tuvo el criterio facilidad de aprendizaje, donde se
verifica que el funcionamiento de una aplicación debe ser completamente intuitivo y por ende
el aprendizaje de su funcionamiento debe ser muy sencillo para el usuario, el análisis
estadístico de los resultados de las encuestas indica que para los casos en los cuales la
calificación era de 1 a 5, los usuarios valoraron la aplicación entre 4 y 5 mientras que en el
caso de la clasificación binaria 1 (SI) 0 (No) se presenta una respuesta a favor del 1 (Sí), sin
embargo es importante tener en cuenta, los casos o funciones de impacto o que tienen
relevancia en el desarrollo de la aplicación y que pueden ser mejorados en futuras versiones.
Dado lo anterior se determina que la aplicación es de fácil aprendizaje para el usuario,
tratándose de una herramienta intuitiva.
FACILIDAD DE
APRENDIZAJE MODA MEDIANA
1.1 4 4
1.2 5 5
1.3 0 0
1.4 0 0
1.5 1 1
1.6 1 1
1.7 1 1
1.8 1 1
1.9 0 0
Tabla 2. Resumen encuestas de usabilidad de Qutline - Facilidad de aprendizaje.
Fuente: Elaboración propia
La evaluación del criterio ayuda tabla 3, permite inferir que para el caso de los momentos o
funciones en los que el usuario necesita ayuda según los resultados estadísticos de las
encuestas, se determina que la aplicación no requiere ningún tipo de ayuda y que los
28
mensajes de validación o error son suficientes para el completo entendimiento de las
funcionalidad, lo anterior debido que la mediana y la moda calculada para el primer literal
de la función Ayuda o 2.1 ¿La herramienta requiere cualquier tipo de ayuda? los encuestados
responden en su mayoría 0(No).
AYUDA MODA MEDIANA
2.1 0 0
2.2 0 0
2.3 1 1
Tabla 3. Resumen estadístico modelo de usabilidad para Qutline – Ayuda.
Fuente: Elaboración propia
La tabla 4, hace referencia de la evaluación del criterio recuerdo en el tiempo, y evidencia
que para el caso en los que el usuario no requiere el uso constante o continuo de la
herramienta se evalúa la capacidad de recordar el funcionamiento de la misma. Según los
resultados estadísticos obtenidos en este ítem, se determina que es fácil recordar el
funcionamiento de la aplicación dado que los usuarios respondieron de manera afirmativa
con 1 (Si) en el literal 3.2
RECUERDO EN EL
TIEMPO MODA MEDIANA
3.1 0 0
3.2 1 1
Tabla 4. Resumen encuestas de usabilidad de Qutline – Recuerdo en el tiempo
Fuente: Elaboración propia
La entendibilidad tabla5, muestra que al momento de evaluar los elementos gráficos y lógicos
de la herramienta se realizaron diferentes tipos de preguntas, cuya respuesta podría ser una
calificación de 1 a 5 o de Tipo 1 (SI) 0 (No) según sea el caso. Los resultados estadísticos en
29
este segmento de la encuesta son netamente positivos las calificaciones de rango están de 3
a 5 y las calificaciones binarias son totalmente afirmativas es decir 1 (Si) en cada caso
ENTENDIBILIDAD MODA MEDIANA
4.1 5 5
4.2 1 1
4.3 1 1
4.4 3 3
4.5 4 4
Tabla 5. Resumen encuestas de usabilidad de Qutline – Entendibilidad
Fuente: Elaboración propia
En el caso de evaluar el atractivo de nuestra aplicación tabla 6, para el usuario, los resultados
estadísticos nos muestran que la moda en la mayoría de los ítems es 4, esto significa que tiene
aspectos muy positivos probablemente ligados a la funcionalidad. Sin embargo el usuario no
manifiesta una completa satisfacción que puede ser resultado de la sencillez de la herramienta
en cuanto a menús, pestañas, ventanas, o exportación de datos
ATRACTIVO MODA MEDIANA
5.1 3 3
5.2 4 4
5.3 0 0
5.4 4 4
5.5 4 4
Tabla 6. Resumen encuestas de usabilidad de Qutline – Atractivo
Fuente: Elaboración propia
30
CONCLUSIONES
Python se caracteriza por ser un lenguaje muy completo y de comprensión sencilla, pero que
requiere conocimientos previos que garantizan que se aprovechan todas sus características,
y permitan obedecer las reglas de estilo que son esenciales en la programación de cualquier
tipo de aplicación como los plugin.
La evaluación de la usabilidad de Qutline obtenida por la implementación de las encuestas
permite determinar que Qutline cumple con el fin por el cual ha sido creado, se evidencia
que se realizó un aplicativo fácilmente entendible para el usuario, pero que requiere de la
implementación de una ayuda dentro del plugin para generar mayor claridad en la
herramienta generada.
El plugin implementado es útil para el desarrollo de múltiples tareas que requieren de
segmentación de líneas en un corto proceso, teniendo como principal ventaja la facilidad con
que el usuario puede utilizarlo de una manera eficiente y eficaz.
Al finalizar el presente estudio, puede decirse que el modelo propuesto para este trabajo es
adaptable a las necesidades específicas exclusivas de los usuarios, ya que para elaborar los
elementos del sistema que lo componen se han considerado factores de usabilidad de los
posibles usuarios, de igual manera es una propuesta que puede ser mejorable y
complementada aplicándola para otras tipologías diferentes.
Por último se evalúo que el costo para la realización de estos procesos es relativamente bajo,
considerando que el software QGIS y Python son libres y no generan gastos de adquisición
de licencias para el usuario.
31
BIBLIOGRAFIA
Berry, J.K. 1996. The Unique Character of Spatial Analysis. GIS World. April:29-30.
Castro, J. F. (7 de Septiembre de 2010). Sig y Educación. Obtenido de
http://sigyeducacion.blogspot.com.co/2010/09/la-importancia-de-los-sig.html
Cervantes-Macías, A; López-Galindo, V. (2010) Minería de datos. Ingeniería Mecánica y
Eléctrica de la Facultad de Ingeniería BUAP.
Claros, I. D. (2006). Propuesta metodológica para la evaluaciónde la usabilida en sitios web:
Experiencia Colombiana. Recuperado el 3 de Noviembre de 2015, de
http://artemisa.unicauca.edu.co/~iclaros/usabilidad/descargas/paperInteraccion2006.pdf
Cohen, S.; Chechile, R.; Smith, G.; Tsai, F.; Burns, G. (1994). A method for evaluating the
effectiveness of educational software. Behavior Research Methods, Instruments &
Computers, (26) 236 – 241.
Díaz-Antón, G. (2002) Uso de software educativo de calidad como herramientas de apoyo
para el aprendizaje. Jornadas educativas: “La escuela como instrumento de cambio”, IEA,
Abril, Caracas.
Ferré-Grau, X. (2001). Principios básicos de usabilidad para ingenieros software.
Ferreras-Beltré, H. J. (2008). Aplicación de la usabilidad al proceso de desarrollo de páginas
web. Facultad de informática universidad politécnica de Madrid.
Fritz, C.A. (2007). RapidMiner (YALE).
González-Castañón, M. A. (2010). Evaluación de software educativo: Orientaciones para su
uso pedagógico.
32
Gonzalez, Lizbeth. (2004), El diseño de interfaz gráfica de usuario para publicaciones
digitales.
Goodchild, M. F., Haining, R.P. (2005). «SIG y análisis espacial de datos: perspectivas
convergentes». En Investigaciones Regionales. Número 006. Asociación española de Ciencia
Regional, Alcalá de Henares, España. Pp. 175-201.
Hix, D.; Hartson, H. (1993): Developing user interface: Ensuring usability through product
y process. New York, John Wiley and Sons.
Hwang, W; Salvendy, G. (2010).Number of People Required for Usability Evaluation: the
10±2 rule. Communications of the ACM, 53 (5), 130-133.
ISO 14598-1. (1998). Information Technology – Evaluation of Software Products – General
Guide. ISO,
ISO 9241-11. (1998). Ergonomic requirements for office work with visual display terminals.
ISO.
Jaime A. Zapata Duque Alcaldía de Medellín, Colombia [email protected]
Gabriel J. Cardona Londoño Alcaldía de Medellín, Colombia
[email protected]. Aplicación de los sistemas de información geográfica
para la gestión de la malla vial de la ciudad de Medellín
Liu, M., Reed, W. (1995). The effect of 32ipermedia-assisted instruction on second language
learning. Journal of Educational computing Research. 12, 159 –175.
Lorenzo-Montero, J. M. (2008) Minería de datos. Técnicas y procedimientos. ISBN: 978-84-
9732492-2.
33
Mayer, R., Shustack, M. Blanton, W. (1997) What do children learn from using computers
in an informal, collaborative setting? Educational Technology, March – April, 39 (2) 27 –
31.
Morales, A. (19 de Diciembre de 2014). Arcgis, gvSIG o Qgis. Obtenido de
http://mappinggis.com/2013/05/arcgis-gvsig-o-quantum-gis-no-elijas/
O´Sullivan, D.; Unwin, D. 2003. Geographic Information Analysis. John Wiley & Sons. New
Jersey.
Nielsen, J.; Molich, R. (1990): Heuristic evaluation of user interfaces, Proceedings of the
CHI’90. ACM 0-89791-345 0/90/0004-0249. New York, pp.349-256
Obeso-Alva, M. E. (2005). Metodología de Medición y Evaluación de la Usabilidad en Sitios
Web Educativos. Universidad De Oviedo. Departamento de Informática.
Tomlinson, R. (9 de Enero de 2012). Pensando en SIG. Obtenido de
http://ingeosolutions.blogspot.com.co/2012/01/los-componentes-de-un-sig.html
Qgis.org, (2015). Descubre QGIS. [online] Available at:
http://qgis.org/es/site/about/index.html [Accessed 9 Nov. 2015].
Vera Del Campo, I.S. (2008). Análisis de Usabilidad del Sistema de Gestión de Contenidos
de la Web de la Facultad. Universidad politécnica de Madrid. Facultad de informática.
Villena-Román, J.; Crespo-García, R. M.; García-Rueda, J. J. (2011). Inteligencia en redes
de comunicaciones.
Wixon D.; Wilson C. (1997). The usability-engineering framework for product design and
evaluation. Handbook of HCI, 2nd edition, Elsevier Science, p653-688
34
Yildirim, Z.; Yasar, M.; Asku, M. (2001). Comparison of Hypermedia Learning and
traditional instruction on knowledge acquisition. The Journal of Educational Research.
March- April, 94 (4), 207 – 214.
35
ANEXOS
Anexo 1. Código en lenguaje Python para Qutline
import resources
# Import the code for the dialog
from Qutline_dialog import QutlineDialog
import os.path
from qgis._core import *
from qgis.gui import *
import numpy
import math
class Qutline:
def __init__(self, iface):
self.iface = iface
self.map = self.iface.mapCanvas()
self.clickTool = QgsMapToolEmitPoint(self.map)
# initialize plugin directory
self.plugin_dir = os.path.dirname(__file__)
# initialize locale
locale = QSettings().value('locale/userLocale')[0:2]
locale_path = os.path.join(
self.plugin_dir,
'i18n',
'Qutline_{}.qm'.format(locale))
if os.path.exists(locale_path):
self.translator = QTranslator()
self.translator.load(locale_path)
if qVersion() > '4.3.3':
QCoreApplication.installTranslator(self.translator)
self.dlg = QutlineDialog()
# Declare instance attributes
36
self.actions = []
self.menu = self.tr(u'&Qutline')
# TODO: We are going to let the user set this up in a future iteration
self.toolbar = self.iface.addToolBar(u'Qutline')
self.toolbar.setObjectName(u'Qutline')
# asigna los valores de los metodos de corte
metodos =['Por segmentos','Por distancia']
self.dlg.cB_Metodo.addItems(metodos)
# revela los elementos correspondientes al metodo de
self.dlg.lEDistancia.hide()
self.dlg.sBnumsegmentos.show()
self.dlg.label_metodo.setText('Seleccione el numero de segmentos')
self.dlg.label_uni.hide()
#conecta la función que oculta y revela los elementos dependiendo del metodo de corte seleccionado
self.dlg.cB_Metodo.currentIndexChanged.connect(self.select_metodo)
#conecta el boton de ejecutar corte
self.dlg.pBEjecutar.clicked.connect(self.ejecutar_corte)
def tr(self, message):
return QCoreApplication.translate('Qutline', message)
def add_action(
self,
icon_path,
text,
callback,
enabled_flag=True,
add_to_menu=True,
add_to_toolbar=True,
status_tip=None,
whats_this=None,
parent=None):
icon = QIcon(icon_path)
action = QAction(icon, text, parent)
37
action.triggered.connect(callback)
action.setEnabled(enabled_flag)
if status_tip is not None:
action.setStatusTip(status_tip)
if whats_this is not None:
action.setWhatsThis(whats_this)
if add_to_toolbar:
self.toolbar.addAction(action)
if add_to_menu:
self.iface.addPluginToMenu(
self.menu,
action)
self.actions.append(action)
return action
def initGui(self):
"""Create the menu entries and toolbar icons inside the QGIS GUI."""
self.clickTool.canvasClicked.connect(self.selecciona)
self.dlg.mMapLayerComboBox.setFilters(QgsMapLayerProxyModel.LineLayer)
icon_path = ':/plugins/Qutline/icon.png'
self.add_action(
icon_path,
text=self.tr(u'Outline'),
callback=self.run,
parent=self.iface.mainWindow())
def unload(self):
"""Removes the plugin menu item and icon from QGIS GUI."""
for action in self.actions:
self.iface.removePluginMenu(
self.tr(u'&Qutline'),
action)
self.iface.removeToolBarIcon(action)
# remove the toolbar
38
del self.toolbar
def run(self):
"""Run method that performs all the real work"""
self.map.setMapTool(self.clickTool)
# show the dialog
self.dlg.show()
# Run the dialog event loop
result = self.dlg.exec_()
# See if OK was pressed
if result:
# Do something useful here - delete the line containing pass and
# substitute with your code.
pass
def select_metodo(self):
if self.dlg.cB_Metodo.currentText() == 'Por segmentos':
self.dlg.lEDistancia.hide()
self.dlg.sBnumsegmentos.show()
self.dlg.label_metodo.setText('Seleccione el numero de segmentos:')
self.dlg.label_uni.hide()
else:
self.dlg.lEDistancia.show()
self.dlg.sBnumsegmentos.hide()
self.dlg.label_metodo.setText('Digite la distancia:')
self.dlg.label_uni.show()
def selecciona(self, point):
# cada ves que seleccione una nueva capa se borra la selección
mc = self.iface.mapCanvas()
for layer in mc.layers():
if layer.type() == layer.VectorLayer:
layer.removeSelection()
mc.refresh()
pntGeom=QgsGeometry.fromPoint(point)
pntBuffer = pntGeom.buffer((self.map.mapUnitsPerPixel()*2),0)
rectan = pntBuffer.boundingBox()
#cLayer = self.map.currentLayer()
cLayer = self.dlg.mMapLayerComboBox.currentLayer()
cLayer.removeSelection()
39
cLayer.select(rectan,False)
selFeatures=cLayer.selectedFeatures()
def ejecutar_corte(self):
cLayer = self.dlg.mMapLayerComboBox.currentLayer()
selFeatures=cLayer.selectedFeatures()
pr = cLayer.dataProvider()
if len(selFeatures)==0:
QMessageBox.information(self.dlg, "Validar datos", "Debe seleccionar un objeto")
else:
geom = selFeatures[0].geometry()
longitud= geom.length()
d = QgsDistanceArea() # crea el objeto de medicion
longitud = d.convertMeasurement(longitud, 2, 0, False) # la convierte en metros a partir de grados decimales
longitud = longitud[0] # obtiene solo el valor de la distancia porque viene así (4545,0)
if self.dlg.lEDistancia.value()<longitud and self.dlg.lEDistancia.value()!= 0.00 and self.dlg.cB_Metodo.currentText() == 'Por distancia':
selFeatures=cLayer.selectedFeatures()
geom = selFeatures[0].geometry()
longitud= geom.length()
#Inicializamos las variabales para recorrer la geometria vertice a vertice
lon_segmento=self.dlg.lEDistancia.value()
lon_segmento =d.convertMeasurement(lon_segmento, QGis.Meters, QGis.Degrees, False)
lon_segmento = lon_segmento[0]
lendivisiones = lon_segmento
indice_vertice = 0
vertice = geom.vertexAt(0)
anterior = vertice
distancia_recorrida = 0
puntos=[]
lineas=[]
corte = lendivisiones
40
while vertice != QgsPoint(0,0):
distancia_recorrida = distancia_recorrida + math.sqrt(vertice.sqrDist(anterior))
if (distancia_recorrida<corte):
puntos.append(vertice)
else:
vertice_corte = geom.interpolate(corte).asPoint()
puntos.append(vertice_corte)
lineas.append(puntos)
puntos=[]
puntos.append(vertice_corte)
indice_vertice -= 1
corte += lendivisiones
anterior = vertice
indice_vertice += 1
vertice = geom.vertexAt(indice_vertice)
#Agregamos los segmentos al layer
pr = cLayer.dataProvider()
seg = QgsFeature()
for plinea in lineas:
line_start = plinea[0]
line_end = plinea[len(plinea)-1]
new_geom = QgsGeometry.fromPolyline([line_start, line_end])
for lpunto in range(1, len(plinea)-1):
new_geom.insertVertex(plinea[lpunto].x(),plinea[lpunto].y(),lpunto)
seg.setGeometry(new_geom)
pr.addFeatures( [ seg ] )
cLayer.updateExtents()
cLayer.startEditing()
features=cLayer.getFeatures()
for feature_c in features:
longitudf= feature_c.geometry().length()
d = QgsDistanceArea() # crea el objeto de medicion
longitudf = d.convertMeasurement(longitudf, 2, 0, False) # la convierte en metros a partir de grados decimales
longitudf = longitudf[0] # obtiene solo el valor de la distancia porque viene así (4545,0)
feature_c['Longitud'] = longitudf
feature_c['FID'] = feature_c.id()
cLayer.updateFeature(feature_c)
cLayer.commitChanges()
41
cLayer.updateFields()
cLayer.updateExtents()
self.puntos_corte(cLayer,"Por distancia")
QMessageBox.information(self.dlg, "Fin del Proceso", "Segmentacion finalizada")
elif self.dlg.lEDistancia.value()== 0.00 and self.dlg.cB_Metodo.currentText() == 'Por distancia':
QMessageBox.information(self.dlg, "Validar datos", "digite un valor de distancia")
elif self.dlg.lEDistancia.value()>longitud and self.dlg.cB_Metodo.currentText() == 'Por distancia':
QMessageBox.information(self.dlg, "Validar datos", "digite un valor de distancia inferior a: "+ str(longitud))
if self.dlg.sBnumsegmentos.value()!= 0 and self.dlg.sBnumsegmentos.value()> 1 and self.dlg.cB_Metodo.currentText() == 'Por segmentos':
geom = selFeatures[0].geometry()
#Parametros
ndivisiones = self.dlg.sBnumsegmentos.value()
#Inicializamos las variabales para recorrer la geometria vertice a vertice
lendivisiones = geom.length()/ndivisiones
indice_vertice = 0
vertice = geom.vertexAt(0)
anterior = vertice
distancia_recorrida = 0
puntos=[]
lineas=[]
corte = lendivisiones
while vertice != QgsPoint(0,0):
distancia_recorrida = distancia_recorrida + math.sqrt(vertice.sqrDist(anterior))
if (distancia_recorrida<corte):
puntos.append(vertice)
else:
vertice_corte = geom.interpolate(corte).asPoint()
puntos.append(vertice_corte)
lineas.append(puntos)
puntos=[]
puntos.append(vertice_corte)
indice_vertice -= 1
42
corte += lendivisiones
anterior = vertice
indice_vertice += 1
vertice = geom.vertexAt(indice_vertice)
#Agregamos los segmentos al layer
pr = cLayer.dataProvider()
seg = QgsFeature()
for plinea in lineas:
line_start = plinea[0]
line_end = plinea[len(plinea)-1]
new_geom = QgsGeometry.fromPolyline([line_start, line_end])
for lpunto in range(1, len(plinea)-1):
new_geom.insertVertex(plinea[lpunto].x(),plinea[lpunto].y(),lpunto)
seg.setGeometry(new_geom)
pr.addFeatures( [ seg ] )
cLayer.updateExtents()
cLayer.startEditing()
features=cLayer.getFeatures()
for feature_c in features:
longitudfd= feature_c.geometry().length()
d = QgsDistanceArea() # crea el objeto de medicion
longitudfd = d.convertMeasurement(longitudfd, 2, 0, False)
longitudfd = longitudfd[0] # obtiene solo el valor de la distancia porque viene así (4545,0)
feature_c['Longitud'] = longitudfd
feature_c['FID'] = feature_c.id()
cLayer.updateFeature(feature_c)
cLayer.commitChanges()
cLayer.updateFields()
cLayer.updateExtents()
self.puntos_corte(cLayer,"Por segmentos")
QMessageBox.information(self.dlg, "Fin del Proceso", "Segmentacion finalizada")
elif self.dlg.sBnumsegmentos.value()== 0 and self.dlg.cB_Metodo.currentText() == 'Por segmentos':
QMessageBox.information(self.dlg, "Validar datos", "digite un valor de segmentos")
elif self.dlg.sBnumsegmentos.value()<= 1 and self.dlg.cB_Metodo.currentText() == 'Por segmentos':
QMessageBox.information(self.dlg, "Validar datos", "digite un valor de segmentos superior a 1")
43
def puntos_corte(self,cLayer,metodo):
m_puntos=[]
layer_puntos = QgsVectorLayer('Point?crs=epsg:4326&field=id:string(3)', 'Puntos_corte' ,"memory")
#uncion que calcula la longitud de la linea
selFeatures=cLayer.selectedFeatures()
geom = selFeatures[0].geometry()
longitud= geom.length()
d = QgsDistanceArea() # crea el objeto de medicion
if metodo=="Por distancia":
lon_segmento=self.dlg.lEDistancia.value()
lon_segmento =d.convertMeasurement(lon_segmento, QGis.Meters, QGis.Degrees, False)
lon_segmento = lon_segmento[0]
else:
ndivisiones = self.dlg.sBnumsegmentos.value()
lon_segmento = longitud/ndivisiones
dist_acumulada=0
while dist_acumulada <= longitud:
vertice_corte =geom.interpolate(dist_acumulada).asPoint()
m_puntos.append(vertice_corte)
dist_acumulada = dist_acumulada + lon_segmento
vertice_corte =geom.interpolate(longitud).asPoint()#añade el ultimo punto
m_puntos.append(vertice_corte)
for j in range(len(m_puntos)):
vpr = layer_puntos.dataProvider()
f = QgsFeature()
f.setGeometry(QgsGeometry.fromPoint(m_puntos[j]))
vpr.addFeatures([f])
QgsMapLayerRegistry.instance().addMapLayers([layer_puntos])
layer_puntos.updateExtents()