Esempio n. 1
0
    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
Esempio n. 2
0
 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
Esempio n. 3
0
 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
Esempio n. 4
0
 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