Trabajando con Sensores en Android. Parte V.

En esta quinta parte, vamos a explicar cómo desarrollar una app para android que utilice el sensor de proximidad. Para ello, es recomendable leer este tutorial a la par que visualizáis el código en GitHub.

Esta aplicación consiste en detectar un objeto acercarse al dispositivo, en este caso nuestra cara ya que se trata de una aplicación que nos va a ayudar a hacer flexiones. Por cada vez que hagamos una flexión y, estando el dispositivo en el suelo bajo nuestra cabeza, se incrementará un contador que nos informará de cuántas flexiones hemos hecho.

Para el funcionamiento de la aplicación hemos hecho uso de Sensor y SensorManager para administrar los eventos de los sensores, en este caso el de proximidad. También declaramos una variable contador, que incrementaremos cuando detectemos una aproximación al sensor.

Empezamos implementando la interfaz SensorEventListener en nuestra clase MainActivity que será la encargada de controlar los eventos del movimiento del dispositivo.

En el método onCreate inicializamos todos los objetos relacionados con el xml del layout y los sensores.

En el método onSensorChanged comprobamos si el evento registrado proviene del sensor de proximidad y si es así, comprobamos que que su valor sea el del máximo rango del sensor para que se actualice sólo cuando hemos realizado una flexión y nos alejamos del dispositivo. Cuando esto ocurre, incrementamos nuestro contador y lo actualizamos en el TextView.

Finalmente en el AndroidManifest ponemos la siguiente línea para que la aplicación sólo esté en vertical:

android:screenOrientation="portrait"

La referencia utilizada para el desarrollo de esta aplicación es:

http://developer.android.com/intl/es/reference/android/hardware/SensorEvent.html

Trabajando con los Sensores en Android. Parte IV.

En esta cuarta parte, vamos a explicar cómo desarrollar una app para android que utilice el acelerómetro. Para ello, es recomendable leer este tutorial a la par que visualizáis el código en GitHub.

Esta aplicación consiste en detectar un movimiento específico que detecten los sensores del dispositivo para el cual reproduciremos un sonido u otro. En concreto, los dos movimientos implementados son el gesto de dar un latigazo y el de agitar el dispositivo.

Para el funcionamiento de la aplicación hemos hecho uso del paquete SoundPool el cual nos permite reproducir archivos de sonido cortos de menos de 1 MB. Haremos uso de 3 variables para controlar el tiempo, las cuales comentaremos más adelante y de 2 variables para medir la gravedad en dos de los tres ejes espaciales.

Empezamos implementando la interfaz SensorEventListener en nuestra clase MainActivity que será la encargada de controlar los eventos del movimiento del dispositivo.

En el método onCreate inicializamos todos los objetos relacionados con el xml del layout y las variables para la reproducción de sonidos. Para cargar los sonidos, creamos una carpeta de tipo raw en nuestro proyecto y guardamos los sonidos ahí. De esta forma, podemos cargar los audios llamando al método load de la clase SoundPool con R.raw.nombre_sonido.

En el método onSensorChanged nos aseguramos de que todo esté sincronizado y obtenemos los valores x e y del acelerómetro (el valor z no lo hemos utilizado) y comprobamos el tipo de movimiento que se está realizando. Si el acelerómetro llega a -8 en la x y no se solapa con el tiempo del movimiento de agitar, activamos la variable primero y empezamos a contar el tiempo ya que este movimiento tiene dos fases. Si el dispositivo lo hemos llevado hasta una x mayor que 1 tras la primera fase y el tiempo es menor de 0.5 segundos (para que sea realista el movimiento debe hacerse rápido) entonces reproducimos el sonido del látigo donde la intensidad del sonido es inversamente proporcional al tiempo que tardamos en completar los dos pasos. Si el acelerómetro llega a valores superiores a 30 o inferiores a 30 y no estamos en proceso del movimiento del latigazo, entonces detectamos que se trata del movimiento de agitar el dispositivo por lo que reproducimos su sonido.

Los sonidos utilizados son totalmente libres y están extraídos de la página:

https://www.freesound.org/
 

Para el desarrollo de la aplicación hemos utilizado la siguiente referencia:

https://developer.android.com/intl/es/guide/topics/sensors/sensors_motion.html


Sigue leyendo en la siguiente entrada sobre el sensor de proximidad.

Trabajando con los Sensores en Android. Parte III.

En esta tercera parte, vamos a explicar cómo desarrollar una app para android que utilice los eventos táctiles de la pantalla. Para ello, es recomendable leer este tutorial a la par que visualizáis el código en GitHub.

Esta aplicación consiste en reconocer un patrón de gestos sobre la pantalla y una vez detectados, abrir la aplicación de la cámara si el patrón es el correcto. El patrón correcto escogido tiene forma de 'C', por lo que si no introducimos este patrón la aplicación nos dirá que es un gesto incorrecto y tendremos que repetir el proceso

Para el funcionamiento de la aplicación, declaramos un array cuadricula de tipo ImageView que representará la cuadrícula en la cual haremos el gesto. Así, haremos dos arrays más de tipo booleano, uno para guardar el patrón correcto y otro que se rellenará cuando el usuario toque las celdas de la cuadrícula.

Empezamos implementando las interfaces View.OnClickListener y View.OnTouchListener en nuestra clase MainActivity que serán las encargadas de recoger los eventos táctiles de la pantalla.

En el método onCreate inicializamos todos los objetos relacionados con el xml del layout e inicializamos el patrón correcto con la figura 'C' y el patrón del gesto a false.

Implementamos el método onTouch para recoger el evento del gesto que realice el usuario y comprobar si es correcto o no. Para ello, captamos la posición x e y donde estamos pulsando la pantalla y comprobamos si está en alguna casilla de la cuadrícula con la función estaEn, si es así establecemos esa posición del patrón del gesto a true y pintamos la casilla de amarillo. Cuando levantamos el dedo tras el gesto, comprobamos si el patrón de array es igual al que ya habíamos fijado con la figura 'C' y si es correcto pintamos las posiciones de verde y abrimos la cámara, de lo contrario pintaremos las posiciones de rojo durante 0.5 segundos y resetearemos todas las variables utilizadas para volver a intentarlo.

El método estaEn recibe una imagen del array de cuadrícula y una posición x e y de la pantalla. Lo que hace esta función es obtener la localización del punto x e y de la esquina superior izquierda de la primera celda de la cuadrícula y de la segunda para así restarlas y obtener lo que mide una celda. Sabiendo lo que mide la celda, es sencillo comprobar si la x e y que pasamos a la función se encuentra dentro del rango de posiciones de la celda de la cuadrícula.

Con respecto al xml, hemos utilizado un TableLayout de 3x3 con un background negro para que cuando introduzcamos un TableRow con sus tres ImageView, hagamos android:layout_margin="1dp" y deje una separación pequeña. Esto nos permite dibujar los bordes negros para diferenciar las celdas.

Finalmente en el AndroidManifest ponemos la siguiente línea para que la aplicación sólo esté en vertical y los permisos para utilizar la cámara y acceder al almacenamiento:

android:screenOrientation="portrait"
<uses-permission android:name="android.permission.CAMERA"/>
<uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"/>

Para el desarrollo de esta aplicación hemos hecho uso de la siguiente referencia:

http://developer.android.com/intl/es/guide/topics/media/camera.html

Sigue leyendo en la siguiente entrada sobre el reconocimiento de movimientos.

Trabajando con los Sensores en Android. Parte II.

En esta segunda parte, vamos a explicar cómo desarrollar una app para android que utilice el GPS, la lectura de códigos QR, la API de Google Maps y un poco de Android Wear. Para ello, es recomendable leer este tutorial a la par que visualizáis el código en GitHub y el siguiente tutorial para crear el proyecto.

Esta aplicación consiste en leer unas coordenadas GPS desde un código QR y establecer esa localización como un destino al que llegar. Para ello haremos uso de un mapa que nos proporciona Google y un lector de QR que deberemos tener instalado.

Para el funcionamiento de la aplicación, declaramos las variables de GoogleMap, CameraUpdate y Location para poder posicionar un destino en la vista de nuestro mapa, así como la longitud/latitud del destino.

Empezamos implementando la interfaz GoogleMap.OnMyLocationChangeListener en nuestra clase MainActivity para poder actualizar el mapa en cuanto nuestro GPS detecte que nos hemos movido.

En el método onCreate inicializamos todos los objetos relacionados con el xml (MapFragment para el mapa y Button para el botón de lectura del código QR).

El método getCoordenadas intentará lanzar la aplicación de lectura del cógido QR si existe una app en el dispositivo que realice tal fin, de lo contrario lanzará una excepción y nos informará mediante un Toast que necesitamos tener instalada una app de lectura de QR.

Una vez de vuelta a nuestra aplicación, el método onActivityResult recupera los datos de la lectura del código y traduce el String devuelto al formato que nos interesa, guardar la longitud y la latitud.

En el método onMapReady establecemos nuestra localización (en el caso de que hayamos dado permiso a la aplicación del uso de nuestra posición y tengamos el GPS encendido) y hacemos que el mapa se pueda actualizar cada vez que nuestra posición se cambia en el mapa con mMap.setOnMyLocationChangeListener(this). Creamos el destino de tipo Location para después poder calcular la distancia de nuestra posición al objetivo. Acto seguido, añadimos una marca del destino en el mapa y acercamos la cámara hasta él con un zoom de 15 para poder tener una vista más centrada en nuestro objetivo.

El método onMyLocationChange, se ejecuta cada vez que nuestra posición cambia por lo que aquí mandamos notificaciones cada 10 metros informando de a qué distancia nos encontramos del objetivo y cuando la distancia sea menor de 5 metros, mandamos una notificación avisando que ya hemos llegado al destino. Estas notificaciones las podremos ver en el Android Wear. Para ello debemos configurar Android Wear instalando la aplicación Android Wear App en nuestro teléfono y activar las opciones de desarrollo en el reloj. Tras esto, debemos irnos a donde tengamos el adb de android (generalmente la carpeta .Android de nuestra carpeta principal) y ejecutamos una terminal con los siguientes comandos:

adb forward tcp:4444 localabstract:/adb-hub
adb connect localhost:4444

Hecho esto ya tenemos conectado nuestro PC al android wear y podremos depurar la aplicación.

Para poder obtener una ruta desde nuestra posición hasta el objetivo, pinchamos en la marca y le damos al botón de Google Maps. De esta forma, se nos abrirá la aplicación de Google donde podremos hacer la ruta mientras recibimos las notificaciones en el android wear sobre la distancia, como podemos ver en la siguiente imagen:

 

Las referencias utilizadas para el uso de la API de Google Maps como de Android Wear son las siguientes:

https://desarrollandoandroid.wordpress.com/2014/06/18/google-maps-en-android/
http://www.androidauthority.com/develop-simple-android-wear-app-622043/
http://www.elandroidelibre.com/2015/01/como-instalar-cualquier-aplicacion-en-android-wear.html

Sigue leyendo en la siguiente entrada sobre el reconocimiento de gestos.

Trabajando con los Sensores en Android. Parte I.

En esta primera parte, vamos a explicar cómo desarrollar una app para android que utilice el magnetómetro y el reconocimiento de voz. Para ello, es recomendable leer este tutorial a la par que visualizáis el código en GitHub.

Esta aplicación consiste en utilizar nuestra voz para comunicar a nuestro dispositivo una dirección y un error medido en grados, la cual se encarga de reconocer e interpretar, indicándonos con una brújula y una flecha si la dirección a la que nos dirigimos es la correcta (dentro de error establecido).

Para ello, declaramos dentro de MainActivity una serie de variables que guarden la dirección establecida por el usuario (desde 0 hasta 3, representando las 4 direcciones en sentido horario respectivamente) y el error (un número que nos indica cuántos grados de desviación con respecto a esa dirección permitimos para seguir diciendo que es correcta), así como el resto de variables necesarias para el reconocimiento de la voz y los cálculos con los ángulos y orientación del dispositivo.

En el método onCreate declaramos la imagen de la brújula (que girará en función de la orientación del móvil) y una imagen flecha cuya posición será estática, pero cambiará de color para indicarnos si la dirección es la correcta. De la misma forma, inicializamos los sensores que vamos a utilizar. Finalmente, llamamos a la función setSpeakButton que se encargará de crear un botón para comenzar el reconocimiento de la voz del usuario.

El método setSpeakButton ha sido añadido a partir del código proporcionado por el seminario de reconocimiento de voz impartido por Zoraida Callejas, de tal forma que al presionar el botón se reconoce el habla de la persona y se devuelve un array de Strings conteniendo posibles traducciones de la voz reconocida. Tanto esta función como todo aquel código relacionado con el reconocimiento de voz ha sido obtenido del mismo seminario.

Implementamos una función leerParametrosParaBrujula en la cual recorremos el array de respuestas obtenidas por el reconocimiento de voz en busca de un String que podamos interpretar como una dirección y un número (ej. norte 10). Con ello, dividimos el String en 2 y guardamos qué dirección y número se han reconocido.

En el método setRecognitionParams establecemos el número máximo de resultados a obtener por el reconocimiento de voz (10) así como el modelo de lenguaje.

Utilizamos el método onActivityResult para llamar al método leerParametrosParaBrujula y obtener los datos del reconocimiento de voz, con los que finalmente realizaremos las operaciones necesarias en el método onSensorChanged.

En esta función onSensorChanged nos encargamos de girar la imagen de la brújula en función de los datos obtenidos por los sensores (magnetómetro y acelerómetro). Por otro lado, comprobamos que si la dirección en la que apunta el móvil está en el intervalo definido por la dirección reconocida más y menos el error reconocido (en grados), dicha flecha cambiará a color verde. De no ser así, la flecha permanecerá roja.

Finalmente en el AndroidManifest ponemos la siguiente línea para que la aplicación sólo esté en vertical:

android:screenOrientation="portrait"

 

Para la realización de esta aplicación hemos seguido y utilizado código del seminario mencionado anteriormente, así como de la página:

http://agamboadev.esy.es/como-crear-un-brujula-en-android/

Sigue leyendo en la siguiente entrada sobre la API de Google Maps.

Análisis Político de Twitter con Gephi

Esta vez voy a publicar una entrada de lo que ha sido mi última práctica para la asignatura de Redes y Sistemas Complejos donde aprendemos a analizar la estructura de cualquier red de interacción, en este caso de twitter.

El objetivo de este estudio es entender un poco mejor cómo se mueven y qué influencias tienen los partidos políticos por twitter. Tenemos una red creada a partir de 18.000 tweets donde los nodos representan usuarios de twitter, los enlaces las relaciones entre ellos, ya sea por respuestas, menciones o retweets y el peso es el número de relaciones. Para ello, hemos hecho uso de la herramienta NodeXL la cual cambió a ser de pago a finales de octubre. Por suerte, saqué una red sobre el hashtag #20D el 11 de octubre.

El contexto político en el que fue extraída esa red fue que Metroscopia sacaba una encuesta en el diario El País donde Ciudadanos estaba a sólo dos puntos del PP. Por otra parte, PP empezaba la “precampaña del miedo” explicando una supuesta política de pactos entre PSOE y Ciudadanos, tratando así de diferenciarse de ellos. También Podemos hablaba de cultura, corrupción, relaciones con Ada Colau y la aparición de Pablo Iglesias en La Sexta Noche. PSOE mantenía su discurso contra los recortes del PP y hablaba también un poco sobre renovación de las instituciones.

Vamos a intentar dar respuesta a las siguientes preguntas:

• ¿Cuáles son los influencers menos conocidos de cada partido?
• ¿Cuáles son los usuarios más activos?
• ¿Cuáles son los usuarios con una actividad de intermediación más fuertes?
• Si quiero transmitir un mensaje que tenga éxito, ¿a quién me tengo que arrimar?
• ¿Existen usuarios que hablen del partido opuesto en lugar del suyo?
• ¿Cómo son los ejércitos de cibervoluntarios de cada partido?

Primero me dedicaré a hacer un análisis de las métricas y tipo de red para más tarde centrarme en hacer un análisis más profundo. Utilizaré el término “cibervoluntarios” para referirme a personas que dedican su actividad de twitter a hablar de política y en especial de su partido.

Análisis Completo de la Red

La red a analizar es una red dirigida con 10665 nodos, 20684 enlaces y 792 componentes conexas. Antes de nada vamos a aplicar un filtro para detectar la Componente Gigante y quedarnos con ella, por lo que pasamos a tener 9201 nodos (86.27%) y 19138 enlaces (92.53%).

Valores de las Medidas de Análisis

Los parámetros de la componente conexa son:

• Grado medio: 2.08
• Diámetro: 5
• Distancia media: 5.62
• Densidad: 0
• Modularidad: 0.761
• Número de comunidades: 468
• Coeficiente de clustering: 0.147

Debido a que tenemos muchos nodos que interactúan poco, vamos a filtrarlos para quedarnos con los nodos que son relevantes dado que lo que estamos estudiando es una conversación de Twitter. Para ello aplicaremos el filtro k-core para quedarnos con los nodos que al menos tengan grado 4, por lo que pasamos a tener 1807 nodos (16.94%) y 8639 enlaces (41.77%). Estos son los parámetros que nos quedan:

• Grado medio: 4.781
• Diámetro: 18
• Distancia media: 5.39
• Densidad: 0.003
• Modularidad: 0.647
• Número de comunidades: 7
• Coeficiente de clustering: 0.293

Obviamente observamos que el grado medio aumenta ya que sólo nos quedamos con los nodos de grado mayor que 3, el diámetro aumenta ya que el filtrado de nodos ha dificultado las comunicaciones entre nodos lejanos, la distancia media es parecida, la modularidad baja un poco al haber filtrado nodos clave, el número de comunidades detectadas es 7 que es algo más asequible para lo que vamos a estudiar y el coeficiente de clustering es mayor.

Propiedades de la Red

Una red aleatoria con este número de nodos tendría una diámetro de

Y un coeficiente de clustering de

Podemos ver que estos valores no se parecen a los de nuestra red ya que son muy distantes a ellos, por lo tanto nuestra red no es una red aleatoria.

Podemos ver que la distribución de grados de la red forma la característica larga cola, es decir, hay unos pocos nodos fuertemente conectados y muchos nodos poco conectados por lo que esta red es libre de escala. Además, si ajustamos un modelo de regresión a la distribución de grados podemos obtener una expresión de la forma y = A*x^-B donde B se corresponde con 2.489 que está en el intervalo [2,3], lo cual es típico de las redes libres de escala.

La red es un mundo pequeño ya que la distancia media (5.386) se asemeja (harían falta muchos más nodos para que fuera casi igual) al resultado de

Nuestra red no es una red regular ya que si lo fuera, la distancia media tendría que ser

Detección de Comunidades

Hemos utilizado el método de Lovaina de Gephi para detectar las comunidades y con él obtenemos 7 comunidades, las cuales representan a: Podemos, Ciudadanos, PSOE, PP, PSOE de Canarias, Ciudadanos de Murcia y los Independentistas Catalanes. La red tiene modulariad 0.647, lo que está bastante bien. En la imagen podemos ver las relaciones entre las 7 comunidades de la red (agrupamos los nodos en Gephi).

Interacción entre Comunidades

Se observa que prácticamente se comunican todas con todas. El tamaño de la comunidad representa su centralidad de vector propio donde vemos que PP y Podemos, Independentistas, PSOE y Ciudadanos tienen una influencia parecida. Esto nos dice que todos se conectan con todos excepto el PSOE de Canarias y Ciudadanos de Murcia que forman comunidades más independientes y por eso tienen menos influencia.

Claro está que no todo es perfecto, ya que hay usuarios que no pertenecen a una comunidad pero Lovaina los ha detectado ahí. Esto es debido a que hay usuarios que son de un partido pero se dedican a citar, retwittear o responder a usuarios pertenecientes a otras comunidades o al revés. Este problema es debido a la red tan limitada que tenemos y lo podemos ver reflejado en varios casos.

Por ejemplo, Manuela Carmena aparece en la comunidad de los Independentistas en lugar de en la de Podemos debido a su vinculación con Ada Colau o a la vinculación que los demás usuarios hayan hecho citándola y relacionándola con usuarios independentistas. Esto ocurre también con Alberto Garzón e Izquierda Unida que aparecen en la comunidad del PP debido a menciones de usuarios de esa comunidad y a que no tienen (en esta ocasión) la fuerza en twitter necesaria para que se detecte una comunidad de izquierdas que no sea fagocitada por Podemos.

La comunidad con más “errores” de este tipo es la del PP ya que como vemos en la imagen se encuentra muy entremezclada con las demás comunidades y no tiene una estructura muy definida.

Comunidades de la Red

En la imagen también se observa un rifirrafe entre PP y PSOE ya que el nodo PP tiene relaciones con muchos nodos Socialistas aunque PSOE sólo tiene relación con sus votantes. Incluso el nodo de Mariano Rajoy (el cual es influyente) es catalogado como Socialista. Este rifirrafe nos hace pensar que esos nodos mal catalogados ocurren en un PP sin fuerza en twitter con sus votantes, ya que todas las comunidades menos PP tienen mucha relación entre sí. Esto nos dice también que los cibervoluntarios de Podemos, Ciudadanos y PSOE se dedican más a promocionar su propio partido (en esta ocasión) que a criticar o compararse con los demás.

Medidas de Red Social

Empezaremos detectando quiénes son los influencers de la red, para ello calculamos la centralidad de vector propio de la red (eigenvector value) y ordenamos los nodos de mayor a menor centralidad. Los 10 usuarios de la red más influyentes son: @el_pais, @ciudadanoscs, @albert_rivera, @metroscopia, @psoe, @sanchezcastejon, @ppopular, @ahorapodemos, @ignacioaguado y @marianorajoy. Pero también es importante analizar cuáles son los 3 usuarios más influyentes de cada comunidad.

• Ciudadanos: @el_pais, @ciudadanoscs y @albert_rivera
• Murcia: @mgfigal, @cs_murcia y @csregionmurcia
• Canarias: @psoecanarias, @patriciahdezgut y @equipoclavijo
• PSOE: @psoe, @sanchezcastejon y @marianorajoy
• Podemos: @ahorapodemos, @pablo_iglesias_ y @podemoscultura
• PP: @ppopular, @rafa_hernando y @asierantona
• Independentistas: @quicosalles, @cupnacional y @juntpelsi

Tras ello vamos a ver quiénes son más activos (quienes hablan más) mirando el grado de salida: @jmrubenjm, @nachoanon, @marahersa, @isaranjuez, @vientosorihuela, @alcantarasanta1 y @ridermarina. Todos ellos con un grado de salida mayor que 30, es decir, hablan mucho sin embargo no son influyentes. Los usuarios que son más retwitteados o mencionados son: @ciudadanoscs, @el_pais, @albert_rivera, @metroscopia, @psoe, @sanchezcastejon, @ppopular, @ahorapodemos, @ignacioaguado, @marianorajoy y @pablo_iglesias_. Todos ellos muy conocidos entre los usuarios y los principales actores y formaciones políticas, es por eso que son tan citados.

Los usuarios que más intermediación producen son los siguientes: @jmrubenjm, @isaranjuez, @nalalop, esahora2015, @ensata, @blogsostenible, @solabria, @ceciliocastro, @jlazaro, @antgalan y @bobestropajo. Estos usuarios, como podemos ver, no son los perfiles corporativos sino microliderazgos internos que, analizando sus perfiles de twitter, son cibervoluntarios todos ellos de Podemos o del PSOE.

Con respecto a la cercanía y excentricidad podemos decir que hay muchos usuarios que están cerca del centro de la red, excluyendo a la comunidad de Ciudadanos, ya entenderemos porqué cuando veamos las visualizaciones de la red en el siguiente apartado.

Visualizaciones de la Red

 

Visualización por Centralidad de Vector Propio

Observamos gráficamente la influencia de algunos nodos con la medida de centralidad de vector propio, como ya decíamos la encuesta de Metroscopia donde anuncia que Ciudadanos estaba a 2 puntos del PP es lo más hablado en la comunidad de Ciudadanos, mientras que vemos a un PSOE con fuerza. Podemos también tiene una gran comunidad de usuarios ya que los perfiles oficiales no tienen demasiada influencia sino sus votantes y están bastante relacionados con los Independentistas Catalanes.

Visualización por Grado de Salida

Observamos los nodos que más hablan, que no necesariamente como podemos comprobar, son los que tienen más influencia en la red. Estos se encuentran en su mayoría en el PSOE, Podemos y los Independentistas Catalanes.

Visualización por Intermediación

Aquí observamos los usuarios con más actividad de intermediación donde observamos varios claros hiperactivistas en Podemos y PSOE. Esos usuarios son nodos donde potencialmente puede pasar un gran número de conversaciones y son los encargados de comunicarse con otras comunidades.
 

Visualización por Coeficiente de Clustering

Esta es la red donde los nodos más grandes son los que tienen más coeficiente de clustering, por lo tanto son nodos cuyos vecinos están muy conectados entre sí. Se puede observar en la comunidad de Ciudadanos que hay una gran cantidad de nodos conectados entre sí (la zona blanca generada por las etiquetas de los nodos). Esto es debido a que hay un grupo de usuarios que sólo retwittearon el tweet de El Pais que mencionaba a Metroscopia y a Ciudadanos.

Visualización con el algoritmo de Fruchterman Reingold

Esta es la representación de la red con el algoritmo Fruchterman Reingold, con una representación más circular donde los nodos más influyentes están en el centro y los menos influyentes en la periferia. Es una representación también bonita donde se puede visualizar también todo lo citado anteriormente.

Conclusiones y Resultados

A todo lo que ya hemos explicado en los diferentes apartados, vamos a añadir algo más.

Hemos detectado a los influencers de la red y de cada comunidad, los principales nos lo esperábamos porque son perfiles corporativos muy conocidos pero también hay gente menos famosa con influencia. Estos influencers son: @mgfigal (de Ciudadanos de Murcia), @PatriciaHdezGut (vicepresidenta del Gobierno de Canarias), @QuicoSalles (un periodista de @elnacionalcat), @rafa_hernando (portavoz del PP), @equipodecambio (twitter del PSOE más cercano a la calle), @davidsernagil (cibervoluntario del PSOE), @piglesiassimon (encargado del círculo de Podemos Cultura), @javierjuantur (“revolucionario antisistema” de Podemos) y @jrspsdjrrubio89 (cibervoluntario de Podemos).

Hay muchos usuarios que son activos, estos son: @elmurciano1 (concejal de Ciudadanos en Murcia), @alcantarasanta1 (cibervoluntario del PSOE de Canarias), @wittgenstein_jm (cibervoluntario Independentista muy activo), @ajrs_noticias (empresa de comercio exterior), @jmrubenjm (cibervoluntario del PSOE), @isaranjuez (cibervoluntaria muy activa de Podemos) y @fraviven (cibervoluntaria de Ciudadanos).

Hay algunos usuarios que tienen una alta actividad de intermediación, lo cuales intermedian muchas conversaciones, estos son: @miguelgaraulet (candidato al congreso por Ciudadanos Murcia), @ndiazperea (enfermera cibervoluntaria de Canarias), @elnacionalcat (periódico Independentista), @edulorengarcia (periodista), @jmrubenjm (cibervoluntario del PSOE), @isaranjuez (cibervoluntaria muy activa de Podemos) y @ciudadanoscs (partido Ciudadanos).

Si queremos transmitir un mensaje que tenga éxito, tal vez deberíamos acercarnos a los influencers de la red y también a los intermediadores que ya hemos comentado quiénes son, para que nuestro mensaje sea leído por mucha gente.

Como hemos visto con anterioridad, al ser la red pequeña e incompleta en el tiempo de campaña/precampaña electoral, hay usuarios que hemos visto que sólo se dedican a hablar de los partidos opuestos, por ejemplo en forma de crítica o ironía.

También hemos visto que hay ejércitos de cibervoluntarios en Podemos y PSOE muy fuertes que interactúan mucho con los demás usuarios tanto de su comunidad como de las demás.

Cabe destacar que la red está sacada de un corto periodo de tiempo, por lo que estas conclusiones pueden no ser acertadas para comprender mejor la política española en su totalidad, aunque sí podemos hacernos una idea de cómo es cada partido en twitter. Habría sido más interesante analizar la totalidad de los tweets que ha habido en la campaña, con las correspondientes podas de red, pero no ha podido ser.