Social Icons

twitterfacebookgoogle plusemail

martes, 30 de abril de 2013

Manejo de congestión de datos

Después de haber leído sobre como se manejan las congestiones de tráfico en situaciones reales usando el protocolo TCP/IP y haber leído sobre como hacen un uso eficiente de energía por medio de un protocolo de enruteamiento, se me ocurrieron varias ideas para poder hacer una implementación de un diseño para el manejo de la congestión de datos.

Bueno la idea que plantearé no la eh revisado aún, posiblemente ya existe algo parecido. Se esta suponiendo que no importa por que nodo pase la información mientras llegué al destino. Y puede aplicar a cualquier tipo de topología existente.


Para comenzar, el nodo a enviar información comienza enviando un ping a cada vecino de su estado, después se compara  la latencia de cada vecino.

Después se busca la latencia más baja para que a este nodo sea enviada la información, una vez hecho el enlace de datos, se harán pings en cada cierto intervalo de tiempo según como haya sido configurado, esto con el fin de repetir el mismo procedimiento de estar verificando cual nodo tiene la menor latencia y a partir de ello estar comunicando la información al nodo.

Aquí se tiene que aclarar que la información enviada tendrá una cabecera en donde se aclara su indice y el total de indices, esto para obtener el paquete de una manera correcta y no se obtengan archivos corruptos.



Uso eficiente de energía en redes de la telecomunicación


Se eligió un paper sobre el consumo eficiente de energía en el area de
redes de la telecomunicación para realizar un resumen de el, y a continuación
veremos el tema y los autores:

An Energy Efficient Routing Mechanism for Wireless Sensor Networks
   by Ruay-Shiung Chang and Chia-Jou Kuo

Ahora hablaremos de lo que se habla en este paper. Se habla sobre la
propuesta de un nuevo protocolo de ruteo llamado MECH (Maximum Energy
Cluster Head) en el que tiene como propiedades autoconfiguración y
árbol jerarquico de ruteo, y en este protocolo que proponen se tiene
una gran ventaja en comparación con una existen que trata de
solucionar la misma problematica, se llama LEACH (Low Energy Adaptive
Clustering Hierarchy) en el que dicho protocolo esta basado clustering
en el cual los nodos no usados como cabezas del cluster son apagados
sus RF hasta un tiempo preajustado de tiempo, sin embargo tiene un
inconveniente de que el clúster no se distribuye de manera uniforme
debido a su rotación aleatoria de sus cabezas.

El enfoque principal del protocolo de ruteo esta dividido en rondas y
cada ronda consiste de 3 fases: fase de establecimiento, fase estable
y fase de expedición. Por cada ronda se crean clusters.


Inicialización de un cluster. Cada nodo hace una emisión a sus vecinos
con un mensaje de hola, el TTL de el mensaje hola se coloca en uno
cuando solamente se necesita reunir a los vecinos de una llamada.

El rango del radio de transmisión se coloca, en el cual esto hace que el
comportamiento de los clusters se limite. Cada nodo guarda el número
de sus vecinos. Se define un parámetro del sistema llamado número de
clúster (CN). Cuando el número de vecinos de un nodo alcanza el valor
dado CN, el nodo irá a difundir el mensaje "publicitario" a sus vecinos
principales. El anuncio es informar a todos los nodos que "yo soy una
cabeza del cluster".

Todos los nodos que reciban el mensaje "publicitario", lo guardan y comenzarán a
iniciar un temporizador de interrupción. Además, dichos nodos no emiten la
"publicidad", incluso si su número de vecinos alcanza al CN. Esto se debe a
que se establece que solamente hay una sola cabeza en el cluster en un cierto radio.

Después del tiempo de interrupción, cada nodo selecciona una cabeza en
el cluster acorde a la intensidad de la señal y envía devuelta un
mensaje a su cabeza en el cluster. Después de hacer eso, casa cabeza
en el cluster sabra su miembro en el cluster. Para sincronizar la
transmisión en la fase estable se necesita una proporción al número de
miembros del cluster. Para hacer la sincronización cada cabeza del
cluster cuenta el total de número de sus miembreos en el cluster y
cada transmisión de información a su estación base. La estación base
calcula el número máximo de intervalos de tiempo necesitados para
transmitir esta información a cada cabeza de cluster. Como se puede
apreciar en la parte de abajo las 3 fases de las que se hablan.


Fase de establecimiento. Porque el máximo número de miembros del
cluster es limitado por CN, la cabeza del cluster puede programar el
intervalo de tiempo TDMA para cada miembro del clúster en cada ronda.
Cada nodo se convertirá en el receptor, luego la cabeza del clúster
transmitirá un mensaje que contiene la información del intervalo de
tiempo del TDMA. Cada miembro del clúster mantendrá el transceptor
hasta que el intervalo de tiempo establecido. Además, también
transmite el valor de la energía restante. La cabeza del clúster
mantiene una tabla de cuales nodos tiene la máxima energía en la ronda
actual. Después de que se reenvía los datos de la estación base, se
selecciona un nodo que tiene el máximo poder y se coloca como la
cabeza del clúster en la siguiente ronda.

En la siguiente ronda en la misma fase, se transmitirá información
que contiene la nueva cabeza del clúster en la ronda actual.


Fase estable. Una vez que los clústers son creados y el TDMA se ha
programado, la transmisión de datos puede comenzar. Asumiendo que los
nodos siempre tienen datos a transmititr, ellos envían sus datos y
energía durante el intervalo de tiempo asignado a la cabeza del
clúster. Los nodos del clúster ajustan sus transmisión de energía de
manera dinámica dependiendo de la intensidad de la señal de las
transmisiones de la cabeza del clúster.

En la fase estable solamente la cabeza del clúster siempre estará como
transceptor. Los miembros del clúster solamente estarán como receptores
durante el intervalo de tiempo asignado.

Fase de expedición. MECH usa dos parámetros para establecer la
jerárquia que existe en relación en los clústers: hop_count (cuenta de
saltos) y energy level (el nivel de energía). Los pasos siguientes
describen como el MEC implementa la jerárquia.

Paso 1: La estación base transmite un mensaje de hola periodicamente.
El mensaje contiene 2 tipos de información: una es el hop_count desde
la estación base hacía la cabeza del clúster y el otro es el energy
level. El hop_count es asignado a 0 y el energy level es colocado de
manera inicial como infinito. Todo miembro del clústes que no sea la
cabeza ignora el mensaje. Cuando el mensaje se recibe, la cabeza del
clúster agrega un uno al contador de hop_count y lo compara con el
energy level en el mensaje, sí la cabeza del clúster actual esta más
abajo de energía el energy level es remplazado con aquel cabeza del
clúster actual.

Paso 2: Después de que la cabeza del clúster reciba el mensaje de
hola, la cabeza del clúster guardará la cabeza que transmite el
mensaje de hola. Por lo tanto, la cabeza del clúster que transmite
 se convertirá en el reenvío de la cabeza del clúster a la estación
 base para la cabeza de este clúster. Este mecanismo es similar a la
 de un enrutamiento a distancia de vectores.

Paso 3: Sí la cabeza del clúster recibe algún mensaje de hola, este
hara decisiones acorde a las siguientes reglas:

     Case 1: Sí hop_count_old < hop_count_new, no hacer nada;
     Case 2: Sí hop_count_old > hop_count_new, reemplazar el reenvío a
     la cabeza del clúster;
     Case 3: hop_count_old  = hop_count_new, entonces Sí energy_old >
     energy_new entonces se reemplaza la cabeza del clúster; Si no no
     sé hace nada;

Las características principales del MECH son las siguientes:


  • Reducen la disipación de energía.
  • Auto-configuración y coordinación.
  • Cabeza del clúster tiene su máxima energía.
  • Carga balanceada


A continuación vemos el rendimiento que tiene MECH vs LEACH, se muestran
como disipan la energía con 10, 15 y 20 clústers.

10 clústers


15 clústers

20 clústers


Referencia:
An Energy Efficient Routing Mechanism for Wireless Sensor Networks
   by Ruay-Shiung Chang and Chia-Jou Kuo

URL: http://ieeexplore.ieee.org/stamp/stamp.jsp?tp=&arnumber=1620396

Críticas de evaluaciones de usabilidad


Proyecto Garage Inteligente

Hubiera sido importante poder haber hecho pruebas de interfaz de la
aplicación porque a como tengo entendido se manejarán aplicación móvil
y página web para poder abrir el garage, aquí lo ideal es que se
hubiera hecho un recorrido cognitivo a través de la aplicación para
encontrar algún diseño mal implementado en la aplicación.


Proyecto CarFxP

Hubiera sido bueno poder haber hecho la simulación del panel ya dentro
del carro para ver como el usuario se comporta ya dentro del carro ya
sea estacionado o en movimiento, aquí una de las cosas pudieran entrar
serían los casos o escenarios en el que el usuario cambia de
comportamiento al estar expuesto al tráfico.


Proyecto Casa Inteligente

Aquí yo creo que hicieron un error al decirle al usuario de como
funcionaba la aplicación, aquí el tema evaluación de usabilidad parte
de como el usuario se comporta usando la aplicación, osea si el
usuario necesita ayuda este te la pedirá y te preguntará sobre como
funciona la aplicación y ahí en ese momento es cuando le haces la
pregunta ¿ Te pareció intuitiva ?, ¿ Tuviste algún problema al
reconocer el botón ?, pero en fin.


Proyecto Despertador Inteligente

En estas pruebas se pudieron haber agregado algún tipo de evaluación al
momento de colocar los sensores, ya que la gente en general tiende a
usar una almohada o incluso dormir a lado de ella, aunque también
sería díficil realizarlo pero es una de las cosas que más afectaría al
desarrollo del proyecto.


Proyecto Galería Inteligente

Creo que faltaron mas tipos de interacciones con el usuario porque no
nadamas harán que prendan unos leds en cada lugar, sino que tendrán
varios tipos de interacciones a como se vayan presentando las
secciones en la galería. Aquí lo ideal hubiera sido hacer las pruebas
con los usuarios y que los mismos usuarios comienzen a realizar las
funcionalidades.


Proyecto Computadora Inteligente

Yo creo que se salieron un poco del tema, ya que en un principio había
entendido que el proyecto trataba sobre hacer un bloqueo de la
computadora para que ninguna persona ajena a ella entre. Por lo que ví
hicieron pruebas con un prototipo que hace algo parecido pero yo creo
que lo ideal hubiera sido hacer un bloqueo de la pantalla poniendo
alguna imagen y algún cierto color y diciendo "Identificate" o algo
así ahí es donde ustedes podrían incluir alguna situación de
usabilidad ya que ahorita puede detenerte un video, pero ya cuando lo
apliquen no tendrá mucho que ver la evaluación que les realizaron y
comenzarán de nuevo porque lo único que veo reciclable es lo de los tiempos.


Proyecto Alarma Inteligente para Automóvil

En el resultado de las respuestas hubiera sido muy importante haber
graficado los resultados ya que resulta muy incómodo y díficil poder
realizar un ánalisis si realmente hay mas usuarios que les gustó algo
o sí realmente odiaron algo, para este tipo de resultados se pueden
usar algún pie chart.


Proyecto de Oficina Inteligente

Hubiera sido interesante poderle presentar al usuario una cajita de un
color enlugar del circuito para saber como reacciona a dicho artículo,
aunque pudieron haber sido unas simples replicas y por medio de un
hombre trás cortina, yo creo que hubiera salido bien.


ACTUALIZADO
-Corrección de ortografía de "aver" a "haber".

jueves, 25 de abril de 2013

Extra Points: Dictionary Method's


Dado un valor de entrada "abbacc", a continuación de hará una
sustitución de datos apartir del dictionary definido en la parte de
abajo. Suponiendo que los valores del diccionario son valores
binarios.

                             Dictionary
                        Keys         Values        
                         a             0
                         b             1
                         c            010
                         d            011

Ahora realizamos la sustitución.

                          Output
     
                        0,1,1,0,010

Para obtener los datos simplemente vamos por cada valor separado por
comas y obtenemos las letras de cada uno de ellos.

Detección de Hoyos

Se creó un programa para hacer la detección de agujeros en Python lo que se realizó fue hacer sumatorias del arreglo de la imagen en las filas y las columnas, y se crea un vector para la sumatoría de los mismos. Una vez hecho eso se busca el mínimo peso en el vector donde ese será tomado como el agujero,a partir del valor mínimo podemos estar iterando los vectores para buscar los indices en el cual se encuentra el mismo valor anteriormente mencionado. A continuación presento el código el cual se hace todo el proceso mencionado dentro de la función llamada "deteccionHoyos".




Ahora probamos el código y podemos ver las siguientes pruebas.






Como vemos solamente hace la detección de solamente un agujero en algunos caso, esto se hace porque se tiene un filtro a escalas de grises y no filtro binario, además de que nomina como posible agujero el valor mínimo existente en el vector, aunque de todos modos hice una pequeña modificación que toma el promedio de los valores del vector y lo toma como umbral para hacer la selección de posibles agujeros.






T4: Adaptive coding

The goal of this homework is to invent, implement and evaluate an adaptative code that compress ASCII text. The requirements is that we're not allow to based on an existent algorithm. As you may know, we use an income letter and that letter must be coded and saved to make a kind of dictionary to make a compression.

 The principal idea it's just save the letter as it comes and keep it in a dictionary of generated symbol and the frequency gave it, and of course I have a rule to make it adaptative but first I need to explain how it works.

Sequence    Letter            Symbol    Frequency  Current Output

-----------------------------------------------------------------------------------------------------------------------

        1                         A       ->    [a:0]         [a:1]               [a:0]

-----------------------------------------------------------------------------------------------------------------------
        2                         A       ->    [a:0]         [a:2]               [a:0]0
-----------------------------------------------------------------------------------------------------------------------
        3                         B       ->    [b:1]         [b:1]            [a:0]0[b:1]
-----------------------------------------------------------------------------------------------------------------------
        4                         C       ->    [c:01]       [c:1]            [a:0]0[b:1][c:01]
-----------------------------------------------------------------------------------------------------------------------
        5                         A       ->    [a:0]         [a:3]          [a:0]0[b:1][c:01]0

-----------------------------------------------------------------------------------------------------------------------
        6                         C       ->    [c:01]       [c:2]         [a:0]0[b:1][c:01]0,01

-----------------------------------------------------------------------------------------------------------------------


As you can see this is a way to compress ASCII text just using a dictionary and putting his own values in the compression, but here comes a question "Where is the adaptative?", well the adaptative form comes with this rule, when I have a letter with a certain percentage of the total of frequencies, then I switched the letter with minimum large of symbol and the minium frequency. Let's explain it.

Sequence    Letter            Symbol    Frequency  Current Output

-----------------------------------------------------------------------------------------------------------------------

        7                         C       ->    [c:01]         [c:3]      [a:0]0[b:1][c:01]0,01,01

-----------------------------------------------------------------------------------------------------------------------
        8                         C       ->    [c:01]         [c:4]   [a:0]0[b:1][c:01]0,01,01,01
-----------------------------------------------------------------------------------------------------------------------
        9                         C       ->    [c:01]         [c:5]  [a:0]0[b:1][c:01]0,01,01,01,01
-----------------------------------------------------------------------------------------------------------------------
      10                       C       ->    [c:1]            [c:6]    [a:0]0[b:1][c:01]0,01,01,01,01[c:1]
-----------------------------------------------------------------------------------------------------------------------
      11                       B       ->    [b:01]         [b:2]   [a:0]0[b:1][c:01]0,01,01,01,01[c:1]b[:2]
-----------------------------------------------------------------------------------------------------------------------

I didn't the code but I complete my design, that's all.

martes, 23 de abril de 2013

Control de Congestión en TCP

A continuación daré un resumen sobre "El Control de la Congestión en TCP" ( TCP Congestion Control) por M. Allman, V. Paxson, et al. .

Se hablan de 4 algorítmos que son usados para evitar la congestión en TCP, los algorítmos son los siguientes: comienzo lento (slow start), evitación de congestión (congestion avoidance), retransmición rápida (fast retransmit) y recurperación rápida (fast recovery).

Comienzo Lento (Slow Start) / Evitación de Congestión (Congestion Avoidance).

Para los algorítmos de comienzo lento (slow start) y evitación de congestión (congestion avoidance) estos deben ser usados por un emisor de TCP para controlar la cantidad de datos son enviados por la red, se crean dos variables por cada transmisión creada al enviar datos, dichas variables son las siguientes congestion window (cwnd) y advertised window (rwnd), el cwnd es el que marca un limite a la cantidad a enviar de datos por medio de la red en el lado del emisor de datos, mientras que en el rwnd es un receptor que marca como limite la cantidad de datos que se reciben.

Existe otra variable en el algorítmo de comienzo lento (slow start) llamada the slow start threshold (ssthresh), el cual es usado para determinar si se esta usando el algorítmo slow start o congestion avoidance para hacer control de la transmisión de datos. Para comenzar la transmisión en la red con condiciones desconocidas esta requiere hacer una prueba usando la red con transmisiones lentas de datos para determinar la disponibilidad de transmisión de datos, esto con el fin de evitar una congestión en la red.

El algorítmo de slow start es usado con el propósito de comenzar una transferencia de datos o después de haber reparado una pérdida de datos y hacer una retransmisión de datos.

Rápida retransmisión (Fast Retransmit) / Rápida recuperación (Fast Recovery).

Al momento de recibir algún dato y hacer un ACK de confirmación este debe hacer un duplicado del mismo ACK cuando hay una falla en la transmisión cuando el segmento llega, el propósito del ACK es para informar al receptor que el segmente enviado ha sido roto y que número de secuencia es esperada, desde la prespectica del receptor el duplicado puede ser causado por un número de problemas en la red.

Estos pueden ser causados por un segmento roto, en dicho caso todos los segmentes después de haber pérdido el segmente de datos este hará un duplicado de ACK's hasta que la pérdida haya sido reparada. También el duplicado de los ACK's puede ser causado por una replicación de ACK o de segmentos de datos en la red. Adicionalmente un emisor TCP debe enviar un ACK inmediatamente cuando el segmento se encuentra lleno.

 El TCP emisor debe usar el algorítmo de fast retransmit para detectar y reparar datos perdidos, todo en base a los ACK's duplicados. El algorítmo de fast retransmit usa la llegada del duplicado de 3 ACK's como indicación de que un segmento ha sido pérdido. Después de recibir 3 duplicados ACK's, TCP realiza una retransmisión de lo que parece ser el segmento faltante, sin tener un timeout.

Después el algorítmo de fast retransmit envía lo que parece ser el segmento faltante, el algorítmo de fast recovery es el que hace las decisiones de la transmisión de nuevos datos hasta que ningún dúplicado de ACK llegue.

La razón por la que no se usa el algorítmo de slow start es que el receptor de los dúplicados de los ACK's no solamente indica que el segmente de datos ha sido pérdido si no que también el segmentos de datos ha quedado fuera de la red.

En otras palabras desde que se reciben datos solo se pueden generar un dúplicado de ACK's cuando el segmento de datos ha sido recibido, el segmento se ha salido de la red y se ha quedado en el receptor del buffer, y ahora no consume datos de la red.

Referencia:

TitleTCP Congestion Control
AuthorM. Allman, V. Paxson, E. Blanton
DateSeptember 2009
                  URL http://www.hjp.at/doc/rfc/rfc5681.html

Evaluación de usabilidad

Se eligió un paper para encontrar alguna una evaluación de usabilidad existente; El paper que eligí fue sobre Usabilidad Social en Cómputo Ubicuo por Pirkka Hartikainen de la Universidad de Helsinki.

Se evalúan muchos puntos muy interesantes pero en el que me voy a enfocar es sobre La inteligencia social.  

La inteligencia social es una parte muy importante del sistema ubicuo en el que el sistema hace de alguna una señalización de su estado actual, uno de los ejemplos que muestran en el paper es sobre una inteligencia artificial llamada iCat en el cual dicho sistema ayuda a realizar algunas tareas, como realizar algunos recordatorios de usuario o password, o realizar algún tipo de ayuda al momento de intentar varias veces ingresar alguna contraseña, esto es muy parecido a la inteligencia artificial ofrecido por Apple en sus dispositivos iOS en que sirve como asistente personal.

Además se hizo una observación sobre las reacciones que realizaba la inteligencia artificial que explicaban en el ejemplo, dichas reacciones te hacían sentir que tan grave la situación esta de alguna tarea que pides.

Por ejemplo: Tú: "Buscame la carnicería más cerca  Tototlán." IA: "Lo siento, no existe ninguna carnicería en el area. ( Cara triste del sistema )".


En el mismo tema se conversó sobre otro ejemplo que hacen referencia a un sistema que captaba las emociones de las personas el que apartir de presionar un botón en un bracalete, este reaccionaba encendiendo algún LED dentro del bracalete, en el que cada uno tenía algún simbolo que mostraba algún estado de ánimo. Esto fue usado en algún hospital para prestar mayor atención a los hospitalizados.


Referencia:

jueves, 18 de abril de 2013

Relleno de elipses

En esta tarea intenté realizar un programa que realiza el BFS para rellenar los elipses, pero no funcionó como lo esperaba.


Así que opté por hacer un TODO list para saber que es lo que me falta por hacer:

Primero tengo que determinar bien los elipses obteniendo dos tangentes que crucen de los puntos obtenidos en el borde luego se obtiene el punto medio donde por medio de ellos obtenemos votos donde dichos votos nos ayudarán determinar si realmente estamos tratando con un elipse o no ya que si obtenemos gran cantidad de votos podemos obtener el centro de masa del elipse y aplicar un BFS.

Extra points: Exercise from the book Introduction to Information Theory and Data Compression

The exercise is the next one:


5.3.1. (a)Answer: First we need to make a tree to represent the data provided, next we get the expected value of the original word length and the huffman word length, then we divide the original word length  and huffman word length and we get the compression ratio.  


To explain my answer I use a good tool online in this page http://huffmandemo.appspot.com/ that's made by Cecilia Urbina.

First I made a Huffman's tree in a notebook by handmade, next I produce a table with the data provided in the problem vs the coded data. To get a length of the word we get the LCM (Least Common Multiple) of the frequency, then  we demuestrate using a word with that length. Once we got the information with the word we can get the expected value using the next formulas.



The first one is for expected value of the coded value (that value that's made with the huffman's tree) and the original that's the word provided in the problem.

Huffman's Tree. 
Table.

Then we do the same procedure in the problem (b).

Huffman's Tree.


Table.


Source:
    
      Introduction to Information Theory and Data Compression by Hankerson et al.

martes, 16 de abril de 2013

Generación de tráfico en topología

Para la generación de tráfico en una topología simplemente se genero una función llamada "generaTrafico" la cual comienza ha hacer asignación de IP's a cada nodo existente en la topología y comienza a generar tráfico en la misma. Aquí esta el código:


Esto es una animación de ejemplo de la topología generada en el código:

Técnicas de localización en interiores y/o exteriores

El paper que voy a resumir  esta hecho por la empresa de Microsoft Research en donde los autores son Paramvir Bahl and Venkata N. Padmanabhan. Se habla de una tecnología desarrollada llamada RADAR que es un sistema basado en radio frecuencia para localizar usuarios dentro de edificios. Este opera por medio de una red de estaciones distribuidas dentro de la construccion que miden la intensidad de la radio frecuencia.

Para explicar de una manera más fácil explicaré el experimento que realizaron del cual se habla en el paper. Se tiene una construcción de 50 cuartos, en donde tienen 3 bases de radio frecuencias distintas distribuidas en todo el piso, ademas de que se cuenta con un usuario prueba que tiene un dispositivo con RF que emite cierta información como orientación del usuario. Aquí debajo son presentadas como BS1, BS2, ...,BS-n.


Crearon pruebas y tomaron como parámetro la intensidad del la señal para que así puedan hacer una triángulacion para poder identificar una localización apróximaada.

Intensidad de Señal


 Triángulacion




En el paper explican qué escogieron la tecnología de RF porque tiene un costo menor, es escalable y puede transferir datos, y esto lo compraron con tecnologías como Infrarrojo y GPS. No tomaron en cuenta la tecnología del GPS debido a su exactitud ya que tiene un gran rango de error en interiores, y esto funciona al revés en exteriores, mientras en el infrarrojo este tiene la desventaja de que no provee la característica de transferir datos.

Fuente del paper:

http://research.microsoft.com/en-us/um/people/padmanab/papers/infocom2000.pdf

lunes, 15 de abril de 2013

Tarea 5: Detección de elipses

En esta tarea se trabajo para hacer la detección de elipses, aunque realmente se tuvieron unos problemas en el procedimiento. Los pasos principales que se realizaron fueron los siguientes:

  1. Hacer detección de borde.
  2. Elegir pares antiparalelos.
  3. Generar votos a tomando como frontera el borde y las rectas de pares antiparalelos.
  4. Determinar a partir de porcentaje de votos sí realmente es un elipse (Por agregar).
Lo primero es necesario para saber en que area vamos a trabajar, después de saber el area en la que trabajamos, se empiezan a tomar pares de puntos aleatorios para luego sacar su punto medio y tomarlo como voto. A partir del porcentaje de votos se podrá determinar sí es un elipse.

Ahora lo que se implementó, tuve grandes problemas donde dichos problemas eran de herencia de tareas anteriores con los indices en donde estaban en algunos invertidos en otros no. En fin lo que se implementaron solamente fue la realización de los votos y la creación de las rectas antiparalelas con puntos aleatorios seleccionados. Esto fue lo que obtuve.

 


jueves, 11 de abril de 2013

T3: Text compression

Para la actividad de esta clase se creo un programa que usa el algorítmo de Huffman para hacer compresión de texto. El algorítmo de Huffman es fácil simplemente por cada letra del texto se guarda un nodo en el árbol, dicho árbol contiene todas las letras que contiene el texto, si la letra se repite en conjunto con otras letras este se le crea un nodo padre junto con la letra que se repite; Esto se hace con el propósito de que se usen de una manera casi igual a los diferentes nodos.



Para correr el programa hacemos los siguiente y nos mostrará las siguientes instrucciones:


Realmente los archivos creados al momento de comprimir fueron muy pesados porque utilice un formato de strings y esta manera se incrementa el valor de cada variable en promedio del peso de la variable de string es de 24 bytes y el de una representación binaria consta de un peso de 12 bytes esto probandoló en Python.

Ahora viendo esto si vemos los siguientes pesos de los textos comprimidos podemos ver que hay una gran diferencia de pesos pero si supones que el peso es de la mitad podemos decir que en el peor caso se encuentra el archivo pequeño ya que el archivo original pesa 1KB pero si examinamos el comprimido podremos ver que nos genera uno de 5KB luego de ver lo anterior podemos casi asegurar que su peso usando el formato binario sería de 2.5KB.



Según lo que confirme experimentando con compresiones tipos zip es que a como vaya creciendo el texto la compresión va ir reduciendo su tamaño ya que si haces una compresión con un archivo pequeño no se verá gran diferencia y al contrario de esto pasa con archivos de tamaño considerable. Aquí podemos ver un ejemplo comparativo.




martes, 9 de abril de 2013

Generación de topologías

Como práctica de laboratorio realice una topología estrella usando el simulador ns-3. Aquí una muestra de lo que es una topología estrella que consiste en un conjunto de nodos al cual se comunican a tráves de un nodo para comunicar a otro nodo en el otro extremo.


El código que hace la simulación fue realizado en C++ como se puede apreciar en la parte de abajo.


Esta es la animación presentada:
Video.

Foto.


GIF:

Críticas de retroalimentación

Garage Inteligente.

       En este proyecto yo le agregaría un autentificador ya que a la
       mayoría de la gente se le suele perder el teléfono ó cosas, en
       mi opinión yo le encuentro necesario hacer algún tipo de
       pregunta ó código de 4 dígitos para así autentificar que es el
       usuario.

Carro Inteligente.

      No quisiera repetir lo mismo que en garage inteligente sobre la
      crítica de seguridad sin embargo se podría agregar un
      autentificador que sea hacía la persona con el simple hecho de
      observar una seña en particular o algun sonido del habla podría
      servir para poder abrir la puerta de tu carro, porque si nos
      vamos al peor de los casos en el que perdemos nuestro smartphone
      cualquier persona podría abrir nuestro carro y sacar cosas,
      debería de haber almenos algún sistema de bajas de teléfonos
      usados o perdidos por el usuarios que no den servicio a ellos
      para sí evitar robos de pertenencias en el vehículo.

Casa Inteligente.

     Esta muy interesante la idea pero creo que no hay un enfoque
     claro sobre hacía donde va el proyecto, por lo que veo se ven
     muchas harías en las que se quieren incluir en este proyecto más
     sin embargo yo no veo alguna característica en específico en la
     cual se quieren enfocar. Mi recomendación es enfocarse en un area
     en especifico del proyecto ya que es muy pesado contar con tanto
     material y areas a programar para cada específicación.

Cama Inteligente.

     Me parece son muy pocas las medidas que se realizan para poder
     determinar un perfil muy completo de un usuario de la manera en
     la que duerme, estaría en favor de agregar algunas medidas como
     sensores de temperatura y si se puede sensor vital de como
     circula la sangre, hoy en día las medidas que son mayormente
     tomadas en los hospitales son esos para poder determinar si el
     paciente tiene algún sintoma extraño probalemente con la pura
     medida de la presión podrías detectar alguna enfermedad pero
     agregando más medidas podrías detectar más enfermedades de manera
     temprana.

Galería inteligente.

        Me parece bien lo que plantean a la hora de que una persona se
        acerque este reaccione a ellas, pero creo que estaría bien
        agregar otra funcionalidad al momento de que la persona se
        acerque demasiado a la obra, sería bueno lanzar unas
        advertencias de que detenga la interaccion y mencione no se
        acerquen demasiado para luego continuar con la interacción.

Oficina Inteligente.

        Esta interesante el proyecto, pero me da una cierta inquietud
        si en el trabajo se va la luz, se deberían presentar algunas
        opciones de manera manual para desbloquear cosas como la
        puerta a la hora de estar usando el sistema.

Computadora Inteligente.

        En este proyecto lo que veo más primordial es saber
        distinguir entre una pantalla y una escena real, esto para
        evitar que un tercero pueda entrar y hacer uso de la
        computadora.

Alarma Inteligente.

       En este proyecto yo creo que deberían saber que apartir del mes
       de abril la policia estará multando personas que hacen falsas
       alarmas, yo creo que deberían de estar concientes a la hora de
       estar desarrollando este proyecto que pueden ocasiones en el
       pueda fallar el dispositivo y causar falsas alarmas. Yo les
       recomiendo estar probando llamadas a un telefono en específico
       de algún familiar ya que hablar a la policía es una medida muy
       drástica y rápida. Para mas info chequen esto.
    
http://www.publimetro.com.mx/noticias/papas-pagaran-las-bromas-telefonicas-en-nl/mmdc!hE7dGZAg3eIts/

Presentación de proyecto: Visión Computacional