def generate_chart():
input_values = RequestValues(request.values, app.config)
print(input_values)
title = {"text": 'Kollokationsanalyse für: ' + str(input_values['keywords'])}
y_axis = {}
series = []
if len(input_values['keywords']) == 1:
labels, data, database_result = create_single_analysis(input_values, app.config)
y_axis['type'] = "logarithmic"
elif len(input_values['keywords']) == 2:
labels, data, database_result = create_contrastive_analysis(input_values, app.config)
else:
print('error unknown len of keywords')
for keyword, d in zip(input_values['keywords'], data):
series.append({"name": keyword, "data": d})
measure = list(map(lambda k: k['y'], chain(*data)))
y_axis['min'] = minimum(measure)
y_axis['max'] = maximum(measure)
if all(not d for d in database_result):
return jsonify(series=[], title={"text": 'Keine Daten'}, xAxis={}, yAxis={}, labels=[], context_list=[],
info={}, exclude=[])
return jsonify(series=series, title=title, yAxis=y_axis, labels=labels,
info={key: value for (key, value) in zip(input_values['keywords'], database_result)},
exclude=True if input_values['exclude_list'] else False)
def create_contrastive_analysis(input_values, config):
keywords = list(map(lambda value: clean_keyword(value), input_values['keywords']))
used_measure = input_values['measure']
overlap_limit = int(input_values['overlap_limit'] / 100 * input_values['limit'])
overlap_query = create_overlap_query(keywords[0], keywords[1], input_values)
overlap = execute_contrastive_analysis_query(overlap_query, config, used_measure)
global_limit = (input_values['limit'] - min(overlap_limit, len(overlap))) // 2
results = []
for k in keywords:
single_query = create_single_query(k, input_values, global_limit, list(overlap.keys()))
term = execute_single_analysis_query(single_query, config, used_measure)
results.append(term)
overlap = remove_overlap_excess(overlap, overlap_limit)
labels = list(results[0].keys()) + list(overlap.keys()) + list(results[1].keys())[::-1]
results = append_overlap(results, overlap)
measure = list(map(lambda k: k[1]['measure'], chain(results[0].values(), results[1].values())))
max_value = maximum(measure)
min_value = minimum(measure)
data = transform_to_logistic_curve(results, labels, min_value, max_value)
measure = list(map(lambda k: k['y'], chain(data[0], data[1])))
max_value_new = maximum(measure)
min_value_new = minimum(measure)
offset = int((max_value - abs(min_value)) * 0.03)
data = rescale(data, min_value, max_value, min_value_new, max_value_new, offset)
return labels, data, results
