def nearby():
estimate = hulop.localize_image(
request.files['image'],
request.form['user'],
request.form['map']
)
if estimate:
loc = estimate['t']
results = []
radius = request.form['radius']
for h in database.query('select * from hotspots'):
h_loc = (h['x'],h['y'],h['z'])
if util.dist(loc[:2], h_loc[:2]) < radius:
direction = util.clockwise(estimate['t'], estimate['R'], h_loc)
results.append({'description': h['category'], 'direction': direction})
return json.dumps({'location':estimate, 'nearby':results})
else:
return json.dumps({'error': 'could not localize'}), 400
def nearby():
estimate = hulop.localize_image(request.files['image'],
request.form['user'], request.form['map'])
if estimate:
loc = estimate['t']
results = []
radius = request.form['radius']
for h in database.query('select * from hotspots'):
h_loc = (h['x'], h['y'], h['z'])
if util.dist(loc[:2], h_loc[:2]) < radius:
direction = util.clockwise(estimate['t'], estimate['R'], h_loc)
results.append({
'description': h['category'],
'direction': direction
})
return json.dumps({'location': estimate, 'nearby': results})
else:
return json.dumps({'error': 'could not localize'}), 400
def _process_rings(self,edges=None,faces=None,edge_si=None,face_si=None):
self._rings = list() # initialisation des périmètres du graphe
# facilité d'écriture pour la suite + travail fait une seule fois
if edges is None: edges = map(lambda e: e._geom,self._edges)
if faces is None: faces = map(lambda f: f._geom,self._faces)
# index spatiaux basés sur les arcs et les faces s'ils n'ont pas été fournis
if edge_si is None: edge_si = geometry_spatial_index(edges)
if face_si is None: face_si = geometry_spatial_index(faces)
# listes des périmètres extérieurs et de leur géométrie préparée
# les périmètres n'ont pas leur propre géométrie mais pointent vers les faces
rings = map(lambda f: f.exterior,faces)
preps = map(lambda r: prep(r), rings)
# boucle sur les faces/périmètres extérieurs (ils se correspondent !)
for f,(ring,pring) in enumerate(zip(rings,preps)):
# indices des arcs qui composent le périmètre courant
indexes = list(edge_si.intersection(ring.bounds))
indexes = filter(lambda i: pring.contains(edges[i]),indexes)
# séquence d'arcs orientés décrivant le périmètre courant
# orientation de l'arc (sens aiguilles d'une montre ou inverse)
content = build_ring(ring,map(lambda i: edges[i],indexes),indexes)
edge_clockwise = clockwise(ring)
# mise à jour des arcs composant le périmètre (_left_face ou _right_face)
for noedge, direct in content:
right_attrname = '_right_face' if edge_clockwise == direct else '_left_face'
setattr(self._edges[noedge],right_attrname,f)
# print getattr(self._edges[noedge],right_attrname)
# mise à jour de la face correspondante
self._faces[f]._extring = len(self._rings)
# ajout du périmètre (instance Ring) dans le graphe
self._rings.append(Ring(edge_clockwise,content))
for face_container, all_holes in enumerate(holes(faces,face_si)):
# quand un trou est bouché par PLUSIEURS faces, le ring n'existe
# pas déjà (il n'est pas LE ring extérieur d'UNE FACE).
for hole in all_holes:
if len(hole) == 1:
self._faces[face_container]._intrings.append(self._faces[hole[0]]._extring)
continue
# il va falloir créer un nouveau ring ...
# il faut prendre le périmètre extérieur de l'union des faces du trou
# et enlever, dans les arcs constituant les périmètre extérieurs
newring = unary_union(map(lambda h: self._faces[h]._geom,hole)).exterior
all_edges = set()
for h in hole:
for noedge, _ in self._rings[self._faces[h]._extring]._edges:
all_edges.add(noedge)
true_edges = filter(lambda e: newring.contains(self._edges[e]._geom),all_edges)
newring = Ring(clockwise(newring),build_ring(newring,map(lambda e: self._edges[e]._geom,true_edges),true_edges))
idring = len(self._rings)
self._rings.append(newring)
self._faces[face_container]._intrings.append(idring)
for included_faces in all_holes:
for noface in included_faces:
for noedge,_ in self._rings[self._faces[noface]._extring]._edges:
if self._edges[noedge]._left_face is None:
self._edges[noedge]._left_face = face_container
if self._edges[noedge]._right_face is None:
self._edges[noedge]._right_face = face_container
# il peut rester des arcs "flottants" au beau milieu d'une face
for edge in self._edges:
if (edge._left_face,edge._right_face) != (None,None):
continue
candidates = list(face_si.intersection(edge._geom.bounds))
if not candidates: continue
candidates = filter(lambda c: self._faces[c]._geom.contains(edge._geom),candidates)
assert len(candidates) in (0,1)
if len(candidates) == 1:
edge._left_face = edge._right_face = candidates[0]
