lunes, 13 de mayo de 2013

Tarea 6

Tarea 6 - Geolocalización

Hola a todos mis compañeros y toda gente que regularmente visita mi blog, esta entrada corresponde a la actividad número 6 de la materia de Redes de Telecomunicaciones. La actividad consiste en simular, construyendo un sistema de por lo menos 3 transmisores el algoritmo básico de geolocalización a través de triangulación de fuerzas de señal. 

Geolocalización

La geolocalización se usa para determinar la posición de un receptor de señal en un plano (mapa). Existen diversas técnicas para localizar una posición, la técnica que usé se llama trilateración que consiste en el uso de localizaciones conocidas (en este caso son las coordenadas de mis 3 transmisores) y la distancia medida en entre el receptor y cada punto de referencia (cada uno de los 3 transmisores). 


Para determinar la localización precisa relativa de un punto en un plano bidimensional usando trilateración, se necesitan generalmente al menos 3 puntos de referencia.

Bueno, dicho esto, yo usé las coordenadas de mis 3 transmisores (posicionados aleatoriamente), seguido de esto calculé las distancias desde cada uno de los transmisores hasta el receptor también posicionado aleatoriamente (fuera de las simulaciones, en la realidad la distancia la calculan mediante un valor llamado RTT, que es el tiempo que tarda un paquete de datos en volver desde un emisor hacia si mismo, pasando por el objeto receptor), estas distancias las denominé d1, d2, d3 y las obtuve mediante la siguiente ecuación:

Bien, luego sabiendo la ecuación del círculo:


donde h, k son los valores de x, y del círculo, mientras que los valores x, y de la ecuación son las coordenadas que nos interesan, las coordenadas de la instersección. El valor de r es el correspondiente al radio.

Seguido a esto, despejamos los valores que nos interesan (x, y) para obtener las coordenadas de nuestra intersección. Para x: 

x = ((((d1**2 - d2**2) + (i2**2 - i1**2) + (j2**2 - j1**2)) * (2*j3-2*j2)) - (((d2**2 - d3**2) + (i3**2 - i2**2) + (j3**2 - j2**2)) * (2*j2-2*j1))) / (((2*i2-2*i3)*(2*j2-2*j1))-((2*i1 - 2*i2) * (2*j3-2*j2))) 
Para  y:
y = ((d1**2 - d2**2) + (i2**2 - i1**2) + (j2**2 - j1**2) + (x*(2*i1-2*i2))) / (2*j2 - 2*j1)


Donde :

i1 = Valor de la coordenada "x" del punto P1(transmisor uno)

i2 = Valor de la coordenada "x" del punto P2(transmisor dos)
i3 = Valor de la coordenada "x" del punto P3(transmisor tres)

j1, j2 y j3: Valores de las coordenadas "y" de los puntos P1, P2 y P3 respectivamente.


A continuación les dejo con el resto del código que realicé en python:
def main():   
 dibujar()

def transmisor(): #Esto se puede hacer con una sola funcion de transmisor, lo hice con la intencion de mayor claridad
 rx, ry = random.randint(180, 250), random.randint(180, 250)
 cx, cy = random.randint(200, 400), random.randint(200, 400)
 return rx, ry, cx, cy

def receptor():
 cx, cy = random.randint(200, 400), random.randint(200, 400)
 return cx, cy

def dibujar():
 #nelipses = int(argv[1])
 
 imagen = Image.open("white.png") #Lienzo en blanco
 fuente = ImageFont.truetype('/usr/share/fonts/truetype/ubuntu-font-family/Ubuntu-C.ttf',15)
 x, y = imagen.size
 total = x * y
 pixels1 = imagen.load()
 draw = ImageDraw.Draw(imagen) 
 #Primer transmisor *************************************************************************************
 radiox, radioy, centrox, centroy = transmisor()

 P1 = []
 P1.append(centrox)
 P1.append(centroy)

 box = (centrox - radiox/2, centroy - radioy/2, centrox + radiox/2, centroy + radioy/2) 
 draw.ellipse(box, fill=None, outline= (255,0,0))
 del draw 
 
 #Segundo transmisor ************************************************************************************
 draw = ImageDraw.Draw(imagen) 
 radiox, radioy, centrox, centroy = transmisor()

 P2 = []
 P2.append(centrox)
 P2.append(centroy)
 
 box = (centrox - radiox/2, centroy - radioy/2, centrox + radiox/2, centroy + radioy/2)
 draw.ellipse(box, fill=None, outline= (0,255,0))
 del draw

 #Tercer transmisor *************************************************************************************
 draw = ImageDraw.Draw(imagen) 
 radiox, radioy, centrox, centroy = transmisor()
 
 P3 = []
 P3.append(centrox)
 P3.append(centroy)  
 
 box = (centrox - radiox/2, centroy - radioy/2, centrox + radiox/2, centroy + radioy/2)
 draw.ellipse(box, fill=None, outline= (0,0,255))
 del draw 

 #receptor *********************************************************************************************
 cx, cy = receptor()
 
 R = []
 R.append(cx)
 R.append(cy)

 draw = ImageDraw.Draw(imagen) 
 draw.text((cx, cy), 'receptor ', fill=(0,0,255), font=fuente) #Para pintar el ID de cada figura
 pixels1[cx, cy] = (0,0,0)
 '''
 for i in range(nelipses):
  draw = ImageDraw.Draw(imagen) 
  radiox, radioy, centrox, centroy = origenes()
  box = (centrox - radiox/2, centroy - radioy/2, centrox + radiox/2, centroy + radioy/2)
  r, g, b = random.randint(0, 255), random.randint(0, 255), random.randint(0, 255)  #Asignando pixeles random 
  draw.ellipse(box, fill=None, outline= (r,g,b))
  del draw
 '''   
 d1 = math.sqrt(((R[0] - P1[0])**2) + ((R[1] - P1[1])**2)) #Distancias desde el receptor hasta cada uno de los puntos transmisores
 d2 = math.sqrt(((R[0] - P2[0])**2) + ((R[1] - P2[1])**2))
 d3 = math.sqrt(((R[0] - P3[0])**2) + ((R[1] - P3[1])**2))

 i1 = P1[0] #Solo para aclarar el algoritmo, pero no es lo mas optimo
 i2 = P2[0]
 i3 = P3[0]

 j1 = P1[1] #Solo para aclarar el algoritmo, pero no es lo mas optimo
 j2 = P2[1]
 j3 = P3[1]

 x = ((((d1**2 - d2**2) + (i2**2 - i1**2) + (j2**2 - j1**2)) * (2*j3-2*j2)) - (((d2**2 - d3**2) + (i3**2 - i2**2) + (j3**2 - j2**2)) * (2*j2-2*j1))) / (((2*i2-2*i3)*(2*j2-2*j1))-((2*i1 - 2*i2) * (2*j3-2*j2))) 
 
 y = ((d1**2 - d2**2) + (i2**2 - i1**2) + (j2**2 - j1**2) + (x*(2*i1-2*i2))) / (2*j2 - 2*j1)

 newx = int(x)
 newy = int(y)
 print "Coordenadas del receptor = ", x, y
 print "Coordenadas del receptor filtradas = ", newx, newy 

 #d1, d2, d3 = distancia entre puntos P1,2,3 hasta el objetivo
 #i1, i2, i3 = P1.x, P2.x, P3.x respectivamente
 #j1, j2, j3 = P1.y, P3.y, P3.y respectivamente
 #x = coordenadas del objetivo x 
 #y = coordenadas del objetivo y

 #PARA X
 #{ ( [ (d1^2-d2^2) + (i2^2-i1^2) + (j2^2-j1^2) ] * (2*j3-2*j2) - [ (d2^2-d3^2) + (i3^2-i2^2) + (j3^2-j2^2) ] *(2*j2-2*j1) ) /
        #[ (2*i2-2*i3)(2*j2-2*j1)-(2*i1-2*i2)(2*j3-2*j2 ] }

 #PARA Y
  #y = [ (d1^2-d2^2) + (i2^2-i1^2) + (j2^2-j1^2) + x*(2*i1-2*i2)] / (2*j2-2*j1)

 imagen.save('out.png') #Salida de la imagen con los transmisores y el receptor

if __name__ == "__main__":
 main()

 

El resultado es el siguiente, pinto en el lienzo la coordenada donde se encuentra el receptor encontrado (con un pixel negro), además de que le pongo una etiqueta con la leyenda "receptor encontrado":


Y la impresión en la terminal es la siguiente:




Bibliografía
Cualquier duda o aclaración pueden dejarla en la caja de comentarios. 

Saludos a todos!

1 comentario: