LineSmooth/flask_main.py at master · USFDataVisualization/LineSmooth · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
import json
import os
import webbrowser

from flask import Flask
from flask import request
from flask import send_file
from flask import send_from_directory

import experiments as exp
import lcsmooth.ranks as ranks

app = Flask(__name__)

webbrowser.open_new_tab("http://localhost:5250")


def cache_file(cmd, params):
    file = cmd
    for key in sorted(params.keys()):
        file += "_" + str(params[key])
    file = file.replace('.','_').replace(' ','_').replace('/','_').replace('\\','_')
    return 'pages/json/cache/' + file + '.json'


def check_cache(_cache_file):
    return os.path.exists( _cache_file )


def get_cache( _cache_file ):
    return send_file(_cache_file)


def save_cache( _cache_file, str ):
    f = open(_cache_file, "w")
    f.write( str )
    f.close()
    return str


@app.route('/')
@app.route('/index.html')
def render_index():
    return send_file('pages/index.html')


@app.route('/<path:path>')
def send_static_html(path):
    return send_from_directory('pages/', path)


@app.route('/images/<path:path>')
def send_static_images(path):
    return send_from_directory('pages/images', path)


@app.route('/javascript/<path:path>')
def send_static_javascript(path):
    return send_from_directory('pages/javascript', path)


@app.route('/style/<path:path>')
def send_static_style(path):
    return send_from_directory('pages/style', path)


@app.errorhandler(404)
def page_not_found(error_msg):
    print("Error: " + str(error_msg))
    return 'This page does not exist', 404


@app.route('/datasets', methods=['GET', 'POST'])
def get_datasets():
    return json.dumps(exp.data_sets)


@app.route('/metric', methods=['GET', 'POST'])
def get_metric_data():
    ds = request.args.get("dataset")
    df = request.args.get("datafile")

    _cache_file = cache_file('metric', {'dataset':ds, 'datafile':df})
    if check_cache( _cache_file ):
        return get_cache( _cache_file )

    if not exp.valid_dataset(exp.data_sets, ds, df):
        print("unknown dataset: " + ds + " or data file: " + df)
        return "{}"

    metric_data = exp.generate_metric_data(ds, df)
    metric_reg = []

    for f in exp.measures:
        metric_reg.append(ranks.metric_ranks(metric_data, exp.filter_list, 'approx entropy', f)),

    return save_cache( _cache_file, json.dumps({'metric': metric_data, 'rank': metric_reg}) )


@app.route('/all_ranks', methods=['GET', 'POST'])
def get_all_rank_data():
    _cache_file = "pages/json/get_all_rank_data.json"
    if not os.path.exists(_cache_file):
        with open(_cache_file, 'w') as outfile:
            json.dump( exp.get_all_ranks(exp.data_sets), outfile, indent=1)

    return send_file(_cache_file)


@app.route('/data', methods=['GET', 'POST'])
def get_data():
    ds = request.args.get("dataset")
    df = request.args.get("datafile")

    if not exp.valid_dataset(exp.data_sets, ds, df):
        print("unknown dataset: " + ds + " or data file: " + df)
        return "{}"

    _cache_file = cache_file('data', {'dataset': ds, 'datafile': df, 'filter':request.args.get("filter"),
                                        'level': float(request.args.get("level"))})
    if check_cache(_cache_file):
        return get_cache(_cache_file)

    input_signal = exp.load_dataset(ds, df)
    res = exp.process_smoothing(input_signal, request.args.get("filter"), float(request.args.get("level")))

    return save_cache( _cache_file, json.dumps(res))