begin geocode client

1 files changed, 0 insertions, 300 deletions

diff --git a/old/server/app/main/views.py b/old/server/app/main/views.py
deleted file mode 100644
index 11a8ca53..00000000
--- a/old/server/app/main/views.py
+++ /dev/null
@@ -1,300 +0,0 @@
-import os
-import uuid
-import json
-from flask import render_template, redirect, url_for, send_from_directory
-from flask import request, make_response, jsonify
-from . import main, utils
-from .tasks import task_lookup, make_task_json
-from PIL import Image, ImageOps
-import cv2 as cv
-
-from .paths import get_paths
-
-from flask import current_app as app
-from werkzeug.utils import secure_filename
-import imutils
-
-# ------------------------------------------------------------
-# Temp: run mask rcnn outside celery
-# ------------------------------------------------------------
-
-# init image processors
-import sys
-from .img_proc_config import ImgProcConfig
-sys.path.append('/dulldream/src/')
-from image_processors.mask_rcnn import MaskRCNN
-from utils import imx
-from utils import fiox
-
-img_proc_congif = ImgProcConfig()
-mask_rcnn = MaskRCNN(img_proc_congif.mask_rcnn_class_config,
-    model_path=img_proc_congif.mask_rcnn_model)
-
-# ------------------------------------------------------------
-# Tasks
-# ------------------------------------------------------------
-
-@main.route('/status/<task_name>/<task_id>')
-def task_status(task_name, task_id):
-    """Return celery image processing status"""
-    if task_name in task_lookup:
-        task = task_lookup[task_name]['task'].AsyncResult(task_id)
-    else:
-        return jsonify({
-            'state': 'error',
-            'percent': 100,
-            'message': 'Unknown task'
-        })
-
-    app.logger.info('task state: {}'.format(task.state))
-    if task.state == 'PENDING':
-        response = {
-            'state': task.state,
-            'percent': 0,
-            'message': 'Pending...'
-        }
-    elif task.state != 'FAILURE':
-        response = {
-            'state': task.state,
-            'percent': task.info.get('percent', 0),
-            'uuid': task.info.get('uuid', 0),
-            'message': task.info.get('message', '')
-        }
-        if 'result' in task.info:
-            response['result'] = task.info['result']
-    else:
-        # something went wrong in the background job
-        response = {
-            'state': task.state,
-            'percent': 100,
-            'message': str(task.info),  # this is the exception raised
-        }
-    return jsonify(response)
-
-# ------------------------------------------------------------
-# POST Routes
-# ------------------------------------------------------------
-
-@main.route('/upload/sleep', methods=['GET', 'POST'])
-def sleep_test():
-    async_task = task_lookup['sleep']['task'].apply_async(args=['sleep_test'])
-    task_url = url_for('main.task_status', task_name='sleep', task_id=async_task.id)
-    return jsonify({
-        'result': True,
-        'task_url': task_url,
-    })
-
-@main.route('/upload', methods=['POST'])
-def upload():
-
-    style = request.form['style']
-    print('style',style)
-    if style in task_lookup:
-        task = task_lookup[style]['task']
-        print('task',task)
-    else:
-        return jsonify({
-            'result': False,
-            'error': 'Unknown task',
-        })
-
-    file = request.files['user_image']
-    agree = bool(request.form['agree'])
-    ext = request.form['ext']
-    if ext is None:
-        ext = request.files['ext']
-
-    uuid_name = str(uuid.uuid4())
-
-    app.logger.info('[+] style: {}'.format(style))
-    app.logger.info('[+] ext: {}'.format(ext))
-    app.logger.info('[+] uuid_name: {}'.format(uuid_name))
-    app.logger.info('[+] agreed: {}'.format(agree))
-
-    # convert PNG to JPG
-    print('[+] Resizing image')
-
-    # LOL MaskRCNN needs to be run outside of the Celery Task    
-    im = Image.open(file.stream).convert('RGB')
-    im = ImageOps.fit(im,(512,512))
-    if agree:
-        upload_folder = app.config['UPLOADS']
-    else:
-        upload_folder = app.config['UPLOADS_PRIVATE']
-
-    fpath = os.path.join(upload_folder, uuid_name + '.jpg')
-
-    # Save image to disk
-    print('[+] Save image to {}'.format(fpath))
-    im.save(fpath, 'JPEG', quality=100)
-    im_pil_256 = im.resize((256,256))
-
-    print('[+] ensure_np...')
-    im_np = imx.ensure_np(im_pil_256)
-    #print('[+] resize np...')
-    #im_np = imutils.resize(im_np,width=256)
-
-    upload_dir, render_dir, json_dir, upload_uri, render_uri = get_paths(agree)
-
-    print('[+] Run mrcnn...')
-    try:
-        result = mask_rcnn.create_segmentations(im_np,concat=True)
-    except:
-        print('[-] Error. Could not run mask_rcnn')
-        result = []
-
-    if len(result) > 0:
-        result = result[0]
-
-        # save data, then pass to celery task
-        print('[+] Save masks')
-        seg_mask = result['seg_mask']
-        fpath_seg_mask = os.path.join(render_dir, uuid_name + '_seg_mask.jpg')
-        #cv.imwrite(fpath_seg_mask,cv.cvtColor(seg_mask,cv.COLOR_BGR2RGB))
-        #seg_mask = seg_mask[:,:,::-1]
-        seg_mask_pil = imx.ensure_pil(seg_mask)
-        seg_mask_pil.save(fpath_seg_mask, 'JPEG', quality=100)
-
-        im_mask = result['im_mask']
-        fpath_im_mask = os.path.join(render_dir, uuid_name + '_im_mask.jpg')
-        #im_mask = im_mask[:,:,::-1]
-        im_mask_pil = imx.ensure_pil(im_mask)
-        im_mask_pil.save(fpath_im_mask, 'JPEG',quality=100)
-        #cv.imwrite(fpath_im_mask,cv.cvtColor(im_mask,cv.COLOR_BGR2RGB))
-
-        celery_result = {
-            'score':str(result['score']),
-            'name':str(result['name']),
-            'class_index':str(result['class_index']),
-            'color':str(result['color']),
-            'fp_im_mask':fpath_im_mask,
-            'fp_seg_mask':fpath_seg_mask,
-            'valid':True
-        }
-    else:
-        print('[-] no reults. process background only')
-        celery_result = {
-            'score':None,
-            'name':None,
-            'class_index':None,
-            'color':None,
-            'fp_im_mask':None,
-            'fp_seg_mask':None,
-            'valid':False
-        }
-
-    print('[+] Start celery')
-    async_task = task.apply_async(args=[uuid_name, agree, celery_result])
-    task_url = url_for('main.task_status', task_name=style, task_id=async_task.id)
-
-    return jsonify({
-        'result': True,
-        'task_url': task_url,
-        'uuid': uuid_name
-    })
-
-        
-
-# ----------------------------------------------------
-# Fileserver, temp solution
-# ----------------------------------------------------
-
-@main.route('/img/<string:imtype>/<string:uuid_name>')
-def get_image(imtype,uuid_name):
-    """Return image files from render or uploads"""
-    if imtype == 'uploads':
-        d = app.config['UPLOADS']
-        suffix = ''
-    elif imtype == 'renders':
-        d = app.config['RENDERS']
-        suffix = ''
-    elif imtype == 'fcn':
-        d = app.config['RENDERS']
-        suffix = '_fcn8'
-    
-    fname = uuid_name + suffix + '.jpg'
-    fpath = os.path.join(d, fname)
-
-    if os.path.isfile(fpath):
-        return send_from_directory(d,fname)
-    else:
-        return send_from_directory('static', 'img/404.jpg')
-
-# ----------------------------------------------------
-# Deleting images
-# ----------------------------------------------------
-
-def destroy_data(uuid_name, is_public):
-    uri_base = app.config['URI_BASE']
-    upload_dir, render_dir, json_dir, upload_uri, render_uri = get_paths(is_public)
-    
-    json_path = os.path.join(json_dir, uuid_name + '.json')
-    with open(json_path) as json_file:
-        data = json.load(json_file)
-        for f in data['files']:
-            path = os.path.join(uri_base, f['fn'][1:])
-            if os.path.exists(path):
-                os.remove(path)
-    os.remove(json_path)
-
-@main.route('/d/<uuid_name>/destroy', strict_slashes=False) # public
-def route_public_destroy(uuid_name):
-    destroy_data(uuid_name, True)
-    return redirect("/", code=302)
-
-@main.route('/p/<uuid_name>/destroy', strict_slashes=False) # private
-def route_private_destroy(uuid_name):
-    destroy_data(uuid_name, False)
-    return redirect("/", code=302)
-
-# ----------------------------------------------------
-# Static routes
-# ----------------------------------------------------
-
-# Most of the pages are served with the single page app in index.html:
-
-task_json = make_task_json()
-
-@main.route('/', strict_slashes=False)
-def index():
-    return render_template('index.html', task_json=task_json)
-
-@main.route('/about', strict_slashes=False)
-def about():
-    return render_template('index.html', task_json=task_json)
-
-@main.route('/d/<uuid_name>', strict_slashes=False) # public
-def route_public(uuid_name):
-    return render_template('index.html', task_json=task_json)
-
-@main.route('/p/<uuid_name>', strict_slashes=False) # private
-def route_private(uuid_name):
-    return render_template('index.html', task_json=task_json)
-
-@main.route('/privacy', strict_slashes=False)
-def privacy():
-    return render_template('index.html', task_json=task_json)
-
-# Some of the pages have their own static file:
-
-@main.route('/gallery', strict_slashes = False)
-def gallery():
-    app.logger.info('access gallery')
-    uploads, renders, urls = utils.get_recent_uploads(limit=50)
-    uuids = [os.path.splitext(os.path.basename(f))[0] for f in uploads]
-    images = [{'upload':u,'render':r, 'url':url} for u,r,url in zip(uploads,renders,urls)]
-    return render_template('gallery.html',images=images)
-
-@main.route('/zkm', strict_slashes=False)
-def zkm():
-    app.logger.info('access ZkM')
-    return render_template('zkm.html')
-
-@main.route('/celery', strict_slashes=False)
-def celery_route():
-    return render_template('celery.html')
-
-@main.route('/projector', strict_slashes=False)
-def projector():
-    uploads, renders,urls = utils.get_recent_uploads()
-    return render_template('projector.html', uploads=uploads, renders=renders)