feat: add a world map with legs of trips

Antoine Goutenoir
1 parent d014ea17
Showing 2 changed files with 244 additions and 29 deletions Show diff stats
flaskr/controllers/main_controller.py
flaskr/templates/estimation.html
-import traceback
+import csv
+import re
+# from io import StringIO
+from cStringIO import StringIO
 from copy import deepcopy
+from os import unlink
+from os.path import join
  
-import re
 import geopy
+import pandas
 import sqlalchemy
-
-from os.path import join
-from os import unlink, getenv
-
 from flask import (
     Blueprint,
     Response,
     render_template,
     flash,
-    request,
     redirect,
     url_for,
     abort,
     send_from_directory,
 )
-from flaskr.extensions import cache, basic_auth, mail, send_email
-from flaskr.forms import LoginForm, EstimateForm
-from flaskr.models import db, User, Estimation, StatusEnum, ScenarioEnum
-from flaskr.geocoder import CachedGeocoder
+from pandas.compat import StringIO as PandasStringIO
+from wtforms import validators
+from yaml import safe_dump as yaml_dump
  
+from flaskr.content import content, base_url
 from flaskr.core import (
-    generate_unique_id,
     get_emission_models,
     increment_hit_counter,
 )
-from flaskr.content import content, base_url
-
-from wtforms import validators
-
-from yaml import safe_dump as yaml_dump
-
-import csv
-# from io import StringIO
-from cStringIO import StringIO
-
-import pandas
-from pandas.compat import StringIO as PandasStringIO
+from flaskr.extensions import cache, send_email
+from flaskr.forms import EstimateForm
+from flaskr.geocoder import CachedGeocoder
+from flaskr.models import db, Estimation, StatusEnum, ScenarioEnum
  
 main = Blueprint('main', __name__)
  
@@ -708,6 +699,9 @@ def compute():  # process the queue of estimation requests
         return _respond(errmsg)
  
  
+unavailable_statuses = [StatusEnum.pending, StatusEnum.working]
+
+
 @main.route("/estimation/<public_id>.<extension>")
 def consult_estimation(public_id, extension):
     try:
@@ -724,8 +718,6 @@ def consult_estimation(public_id, extension):
     # if format not in allowed_formats:
     #     abort(404)
  
-    unavailable_statuses = [StatusEnum.pending, StatusEnum.working]
-
     if extension in ['xhtml', 'html', 'htm']:
  
         if estimation.status in unavailable_statuses:
@@ -795,6 +787,132 @@ def consult_estimation(public_id, extension):
         abort(404)
  
  
+def get_locations(addresses):
+    geocoder = CachedGeocoder()
+
+    warnings = []
+    addresses_count = len(addresses)
+    failed_addresses = []
+    locations = []
+
+    for i in range(addresses_count):
+
+        address = addresses[i].strip()
+        unicode_address = address.encode('utf-8')
+
+        if not address:
+            continue
+
+        if address in failed_addresses:
+            continue
+
+        try:
+            location = geocoder.geocode(unicode_address)
+        except geopy.exc.GeopyError as e:
+            warning = u"Ignoring address `%s` " \
+                      u"since we failed to geocode it.\n%s\n" % (
+                          address, e,
+                      )
+            warnings.append(warning)
+            failed_addresses.append(address)
+            continue
+
+        if location is None:
+            warning = u"Ignoring address `%s` " \
+                      u"since we failed to geocode it.\n" % (
+                          address,
+                      )
+            warnings.append(warning)
+            failed_addresses.append(address)
+            failed_addresses.append(address)
+            continue
+
+        print("Geocoded Location:\n", repr(location.raw))
+        locations.append(location)
+
+        # response += u"Location `%s` geocoded to `%s` (%f, %f).\n" % (
+        #     location_address, location.address,
+        #     location.latitude, location.longitude,
+        # )
+
+    return locations, warnings
+
+
+@main.route("/estimation/<public_id>/trips_to_destination_<destination_index>.csv")
+def get_trips_csv(public_id, destination_index=0):
+    destination_index = int(destination_index)
+    try:
+        estimation = Estimation.query \
+            .filter_by(public_id=public_id) \
+            .one()
+    except sqlalchemy.orm.exc.NoResultFound:
+        return abort(404)
+    except Exception as e:
+        return abort(500)
+
+    if estimation.status in unavailable_statuses:
+        abort(404)
+
+    si = StringIO()
+    cw = csv.writer(si, quoting=csv.QUOTE_ALL)
+    cw.writerow([
+        u"origin_lon",
+        u"origin_lat",
+        u"destination_lon",
+        u"destination_lat",
+    ])
+    results = estimation.get_output_dict()
+
+    if not 'cities' in results:
+        abort(500)
+
+    cities_length = len(results['cities'])
+
+    if 0 == cities_length:
+        abort(500, Response("No cities in results."))
+
+    destination_index = min(destination_index, cities_length - 1)
+    destination_index = max(destination_index, 0)
+
+    city = results['cities'][destination_index]
+    # >>> yaml_dump(city)
+    # address: Paris, Ile - de - France, Metropolitan
+    # France, France
+    # city: Paris
+    # country: ' France'
+    # distance: 1752.7481921181325
+    # footprint: 824.9628320703453
+    # plane_trips: 1
+    # train_trips: 0
+
+    geocoder = CachedGeocoder()
+    try:
+        city_location = geocoder.geocode(city['address'].encode('utf-8'))
+    except geopy.exc.GeopyError as e:
+        return Response(
+            response=si.getvalue().strip('\r\n'),
+        )
+
+    other_locations, _warnings = get_locations(estimation.origin_addresses.split("\n"))
+    # destination_locations = get_locations(estimation.destination_addresses.split("\n"))
+    for other_location in other_locations:
+        cw.writerow([
+            u"%.8f" % city_location.longitude,
+            u"%.8f" % city_location.latitude,
+            u"%.8f" % other_location.longitude,
+            u"%.8f" % other_location.latitude,
+        ])
+
+    filename = "trips_to_destination_%d.csv" % destination_index
+    return Response(
+        response=si.getvalue().strip('\r\n'),
+        headers={
+            'Content-type': 'text/csv',
+            'Content-disposition': 'attachment; filename=%s' % filename,
+        },
+    )
+
+
 @main.route("/scaling_laws.csv")
 def get_scaling_laws_csv():
     distances = content.laws_plot.distances
@@ -824,8 +942,6 @@ def get_scaling_laws_csv():
 @main.route("/test")
 # @basic_auth.required
 def dev_test():
-    import os
-
     # email_content = render_template(
     #     'email/run_completed.html',
     #     # run=run,
@@ -144,6 +144,7 @@
         {{ content.estimation.lolliplot.many_to_many | markdown | safe }}
         {{ render_cities(estimation_output.cities) }}
     {% endif %}
+
     </div>
  
     <div class="col-md-6">
@@ -185,6 +186,11 @@
 {#                </a>#}
 {#            </li>#}
         </ul>
+
+        <hr>
+
+        <div id="d3viz_travels" class="plot-container-noborder"></div>
+
     </div>
  
 </div>
@@ -206,7 +212,7 @@
     {{ content.estimation.footer | markdown | safe }}
 </div>
  
-{# Buffer to drop the PNG image into to hack firefox into downloading the PNG #}
+{# Buffer to drop the PNG image into to trick firefox into downloading the PNG #}
 <div id="png_buffer"></div>
  
 {% endif %}{# not estimation.has_failed() #}
@@ -220,6 +226,8 @@
  
 <script src="/static/js/vendor/d3.v4.js"></script>
 <script src="/static/js/vendor/d3-legend.js"></script>
+<script src="/static/js/vendor/d3-scale-chromatic.v1.min.js"></script>
+<script src="/static/js/vendor/d3-geo-projection.v2.min.js"></script>
 {#<script src="https://d3js.org/d3.v4.js"></script>#}
 {#<script src="https://cdnjs.cloudflare.com/ajax/libs/d3-legend/2.25.6/d3-legend.js"></script>#}
  
@@ -580,6 +588,97 @@ jQuery(document).ready(function($){
  
 });
  
+
+jQuery(document).ready(function($) {
+    var vizid = "#d3viz_travels";
+    var worldDataUrl = "/static/public/data/world.geojson";
+    {#var travelsDataUrl = "/static/public/data/data_connectionmap_test.csv";#}
+    var travelsDataUrl = "/estimation/{{ estimation.public_id }}/trips_to_destination_0.csv";
+
+    {#var margin = {top: 40, right: 40, bottom: 150, left: 180},#}
+    var margin = {top: 0, right: 0, bottom: 0, left: 0};
+    var width = $(vizid).parent().width();
+    var height = width - margin.top - margin.bottom;
+    height *= 1.0;
+    {#var height = Math.max(300, 600) - margin.top - margin.bottom;#}
+    {#var width = Math.max(880, $(vizid).parent().width());#}
+    width = width - margin.left - margin.right;
+
+    var size_ratio = 0.85;
+    width = 629.0 * size_ratio;
+    height = 604.0 * size_ratio;
+    {#width = 500.0;#}
+    {#height = 400.0;#}
+
+    var offset_x = 0.0;
+    var offset_y = 0.0;
+
+    var svg = d3.select(vizid)
+        .append("svg")
+        .attr("width", width + margin.left + margin.right)
+        .attr("height", height + margin.top + margin.bottom);
+
+    var projection = d3.geoMercator()
+        .scale(85)
+        .translate([width / 2.0 + offset_x, height / 2.0 + offset_y]);
+
+    {#var projection = d3.geoMercator()#}
+    {#    .scale(85)#}
+    {#    .translate([width / 2, height / 2 * 1.3]);#}
+
+    // A path generator
+    var geopath = d3.geoPath().projection(projection);
+
+    // Load world shape AND list of connection
+    d3.queue()
+        .defer(d3.json, worldDataUrl)
+        {#.defer(d3.json, "https://raw.githubusercontent.com/holtzy/D3-graph-gallery/master/DATA/world.geojson")  // World shape#}
+        .defer(d3.csv, travelsDataUrl)
+        {#.defer(d3.csv, "https://raw.githubusercontent.com/holtzy/D3-graph-gallery/master/DATA/data_connectionmap.csv") // Position of circles#}
+        .await(on_map_ready);
+
+    function on_map_ready(error, dataGeo, data) {
+
+        // Reformat the list of link. Note that columns in csv file are called long1, long2, lat1, lat2
+        var link = [];
+        data.forEach(function (row) {
+            source = [+row.origin_lon, +row.origin_lat];
+            target = [+row.destination_lon, +row.destination_lat];
+            topush = {type: "LineString", coordinates: [source, target]};
+            link.push(topush);
+        });
+
+        // Draw the map
+        svg.append("g")
+            .selectAll("path")
+            .data(dataGeo.features)
+            .enter()
+            .append("path")
+            .attr("fill", "#b8b8b8")
+            .attr("d", geopath)
+            .style("stroke", "#fff")
+            .style("stroke-width", 0);
+
+        // Add the path
+        svg.selectAll("myPath")
+            .data(link)
+            .enter()
+            .append("path")
+            .attr("d", geopath)
+//            .attr("d", function (d) {
+//                return geopath(d);
+ //           })
+            .style("fill", "none")
+            .style("stroke", "#69b3a2")
+            .style("stroke-width", 2);
+
+    }
+
+});
+
+
+
+
 </script>
  
 {% endif %}