views.py

Go to the documentation of this file.

import roslib; roslib.load_manifest('semantic_model_web_interface')

from . import app, site_root, DB_NAME
import db
import flask as f
import semanticmodel.diff_generation as dg
import logging
from logging import config
from os import path
import datetime
import time

config.fileConfig(path.join(site_root, 'logging.conf'))
log = logging.getLogger('semantic_model_web.views')

COLORS = ['black', 'grey', 'white', 'red', 'yellow', 'green', 'blue']

@app.route('/')
def redirect_list_runs():
    return f.redirect('/runs')

def extract_run_id(r):
    return int(r[0][3:])

@app.route('/runs/')
def list_runs():
    return f.render_template('runs.html', runs=sorted(db.list_runs(),
                                                      key=extract_run_id))

@app.route('/runs/<run>/')
def clusters(run):
    global colors
    coll = db.get_cluster_collection(run)
    other_runs = sorted([r for r in db.list_runs() if r[0] != run],
                        key=extract_run_id)
    ids = sorted([m['id'] for m in coll.query(db.filter_query({}), True)])
    return f.render_template('run.html', 
                             run=run, 
                             ids=ids,
                             other_runs=other_runs, 
                             info=db.run_info(run),
                             colors=COLORS)

@app.route('/runs/<run>/clusters/<int:cluster_id>/')
def cluster(cluster_id, run):
    path = db.image_file_loc(cluster_id, run)
    coll = db.get_cluster_collection(run)
    meta = coll.find_one({'id': cluster_id}, True)
    return f.render_template('cluster.html', img_path=path, meta=meta,
                             next=db.next_id(coll.coll, cluster_id),
                             prev=db.prev_id(coll.coll, cluster_id))

@app.route('/runs/<run>/clusters/<int:cluster_id>/matches/')
def matches(cluster_id, run):
  path = db.image_file_loc(cluster_id, run)
  coll = db.get_cluster_collection(run)
  image_coll = db.get_image_collection(run)
  (cluster, meta) = coll.find_one({'id': cluster_id})
  dt = time.localtime(meta['creation_time'])
  other_runs = sorted([r for r in db.list_runs() if r[0] != run],
                      key=extract_run_id)
                      
  # We need to check every cluster of every (other) run; unless we've done a
  # very poor job indeed, there should be at most one match per run, and
  # possibly zero.
  matches = []
  for (other_run, other_bagfile) in other_runs:
      other_coll = db.get_cluster_collection(other_run)
      other_image_coll = db.get_image_collection(other_run)
      other_cluster = dg.find_matching_cluster(cluster, meta, other_coll)
      if other_cluster:
          other_path = db.image_file_loc(other_cluster[1]['id'], other_run)
          T = time.localtime(other_cluster[1]['creation_time'])
          matches.append((other_run, 
                          other_cluster[1]['id'], 
                          True, 
                          other_path,
                          T.tm_year, 
                          T.tm_mon,
                          T.tm_mday,
                          T.tm_hour,
                          T.tm_min,
                          T.tm_sec))
      else:
          nonmatch = dg.nearest_nonmatch(meta, other_image_coll)
          if nonmatch:
              other_id = nonmatch['cluster_id']
              other_path = db.image_file_loc(other_id, other_run)
              matches.append((other_run, other_id, False, other_path, None))
          else:
              matches.append((other_run, 'None', False, None, None)) 

  return f.render_template('matches.html', 
                           meta=meta, 
                           info=db.run_info(run),
                           run=run,
                           dt=dt,
                           matches=matches,
                           path=path,
                           next=db.next_id(coll.coll, cluster_id),
                           prev=db.prev_id(coll.coll, cluster_id))

@app.route('/runs/<run>/diffs/<other_run>/')
def diffs(run, other_run):
    diffs = dg.generate_diffs(run, other_run, DB_NAME)
    matches = [(x, db.image_file_loc(x, run), 
                y, db.image_file_loc(y, other_run)) 
                for x, y in diffs['matches']]
    nonmatches = [(x, db.image_file_loc(x, run), 
                   y, db.image_file_loc(y, other_run)) 
                   for x, y in diffs['nonmatches']]
    return f.render_template('diffs.html', 
                             matches=matches,
                             nonmatches=nonmatches)

@app.route('/runs/<run>/query_results/')
def query_results(run):
    q = db.semantic_query(f.request.args)
    coll = db.get_cluster_collection(run)
    cluster_ids = [d['id'] for d in coll.query(db.filter_query(q), True)]
    clusters = [(id, db.image_file_loc(id, run)) for id in cluster_ids]
    if 'query_only' in f.request.args:
        return "Query: {0}".format(q)
    else:
        return f.render_template('query_results.html',
             run=run, clusters=clusters)
        
@app.route('/runs/<run>/query_form/')
def query_form(run):
    return f.render_template('query_form.html', run=run)


@app.route('/runs/<run>/colors/<color>/')
def colors(run, color):
    coll = db.get_cluster_collection(run)
    blobs = coll.query(db.filter_query({'color' : color}), True)
    pairs = []
    for blob in blobs:
      path = db.image_file_loc(blob['id'], run)
      pairs.append((blob['id'], path))
    return f.render_template('color.html',
                             run=run,
                             color=color,
                             pairs=pairs)