def obtenerPuntos(self, request):
punto1 = Punto()
punto2 = Punto()
puntosFiltrados = []
puntosOrdenadosPorTipo = []
try:
# Se obtiene la ubicacion del cliente
latitudOrigen = float(request.get('latitudOrigen'))
longitudOrigen = float(request.get('longitudOrigen'))
# se asigna la informacion al punto
punto1.latitud = latitudOrigen
punto1.longitud = longitudOrigen
#Se obtiene el punto al que el cliente desea llegar
latitudDestino = float(request.get('latitudDestino'))
longitudDestino = float(request.get('longitudDestino'))
#se asigna la informacion al punto
punto2.latitud = latitudDestino
punto2.longitud = longitudDestino
#Se calculan las latitudes maximas y minimas llamando al metodo generado previamente
rangos = self.obtenerAreaDeBusqueda(punto1, punto2)
#Se ejecuta la consulta con los parametros obtenidos, primero se filtra la latitud
puntosFiltro1 = PuntoClave.query(PuntoClave.latitud <= rangos['latitudMaxima'],
PuntoClave.latitud >= rangos['latitudMinima']).fetch(100)
#Se aplica un segundo filtro, limitantes de Datastore (NoSQL) por razones de indices.
puntosFiltrados = filter(
lambda punto: punto.longitud <= rangos['longitudMaxima'] and punto.longitud >= rangos['longitudMinima'],
puntosFiltro1)
puntosOrdenadosPorTipo = sorted(puntosFiltrados, key=attrgetter('tipo', 'valoracion'), reverse=True)
return puntosOrdenadosPorTipo
except Exception as e:
logger.error("No se pudieron obtener los puntos")
logger.error(e)
return puntosOrdenadosPorTipo
def obtenerPuntosArea(self,request,radio):
punto1 = Punto()
puntosFiltrados = []
try:
# Se obtiene la ubicacion del cliente
latitudOrigen = float(request.get('latitudOrigen'))
longitudOrigen = float(request.get('longitudOrigen'))
# se asigna la informacion al punto
punto1.latitud = latitudOrigen
punto1.longitud = longitudOrigen
#Se ejecuta la consulta con los parametros obtenidos, primero se filtra la latitud
latitudMaxima = latitudOrigen + radio
longitudMaxima = longitudOrigen + radio
#
latitudMinima = latitudOrigen - radio
longitudMinima = longitudOrigen - radio
puntosFiltro1 = PuntoClave.query(PuntoClave.latitud <= latitudMaxima,
PuntoClave.latitud >= latitudMinima).fetch(100)
#Se aplica un segundo filtro, limitantes de Datastore (NoSQL) por razones de indices.
puntosFiltrados = filter(
lambda punto: punto.longitud <= longitudMaxima and punto.longitud >= longitudMinima,
puntosFiltro1)
return puntosFiltrados
except Exception as e:
logger.error("No se pudieron obtener los puntos")
logger.error(e)
return puntosFiltrados
def obtenerPuntos(self, request):
# se generan instancias de los puntos
logger.debug("------->")
logger.debug(request)
puntoOrigen = None
puntoDestino = None
try:
puntoOrigen = Punto()
puntoDestino = Punto()
# Se asignan los valores de request
# Origen
puntoOrigen.latitud = float(request.get("latitudOrigen"))
puntoOrigen.longitud = float(request.get("longitudOrigen"))
# Destino
puntoDestino.latitud = float(request.get("latitudDestino"))
puntoDestino.longitud = float(request.get("longitudDestino"))
except Exception as e:
logger.error("No se pudieron convertir los parametros de la peticion a puntos geograficos.")
logger.error(e)
# Se imprime el error en caso de existir, y se regresan los objetos
return puntoOrigen, puntoDestino
def porVecinosIntercalados(self, listaDePuntos, origen, destino):
#Se obtienen todos los vecinos con las respectivas distancias
listaPuntosConDistancias = []
for punto in listaDePuntos:
puntoAux = Punto()
puntoAux.latitud = punto.latitud
puntoAux.longitud = punto.longitud
puntoAux.distanciaOrigen = self.distanciaEuclidiana(puntoAux, origen)
puntoAux.distanciaDestino = self.distanciaEuclidiana(puntoAux, destino)
puntoAux.tipo = punto.tipo
listaPuntosConDistancias.append(puntoAux)
listaOrdenadaOrigen = sorted(listaPuntosConDistancias, key=attrgetter('distanciaOrigen'), reverse=True)
listaOrdenadaDestino = sorted(listaPuntosConDistancias, key=attrgetter('distanciaDestino'), reverse=True)
listaFinal = []
valorPrevio = 0
while True:
listaOrdenadaOrigen = self.recortarPares(listaOrdenadaOrigen)
listaOrdenadaDestino = self.recortarPares(listaOrdenadaDestino)
listaFinal = list((set(listaOrdenadaOrigen + listaOrdenadaDestino)))
if (len(listaFinal) <= MAX_WAYPOINTS) or (len(listaFinal) is valorPrevio):
break
else:
valorPrevio = len(listaFinal)
logger.error(len(listaFinal))
logger.info("--------------------------------")
logger.info("--------------------------------")
logger.info("--------------------------------")
logger.info("--------------------------------")
for elemento in listaFinal:
logger.info(elemento)
logger.info("--------------------------------")
logger.info("--------------------------------")
logger.info("--------------------------------")
#Se eliminan los que son de tipo 1 (rojo)
listaFinal = filter(lambda punto: punto.tipo <> 1,listaFinal)
logger.warn("--------------------PUNTOS FILTRADOS POR TIPO--------------------")
for elemento in listaFinal:
logger.info(elemento)
logger.warn("--------------------PUNTOS FILTRADOS POR TIPO--------------------")
#Se procede a ordenar por el tipo y luego por el valor del mismo
return listaFinal