↧
Interactive map shows the global refugee crisis like you've never seen it before
↧
Amazon’s New Customer
↧
↧
Europe plans to have drone rules in place by 2019
↧
Innovative Postage Stamp Celebrates Upcoming Total Solar Eclipse
↧
Log In or Sign Up to View
NoticeYou must log in to continue.Log into FacebookCreate New Account
↧
↧
Best Practices for Creating Bilingual Apps
↧
July18-22 2017
Wed 19th
Thu 20th
Fri 21st
09:30
10:30
11:30
12:30
13:30
14:30
15:30
16:30
17:30
Caquot
Opening plenary
Keynote 1
Keynote 2
Coffee break
Lunch break
Coffee break
Cauchy
Coffee break
GDAL 2.2: what's new?
Advanced geospatial technologies: The new powerful GRASS GIS 7.2 release
What's new in Orfeo ToolBox 6.0?
Lunch break
Assessment of the digital openness of the geospatial dimension of the world
Inspiring European data providers through open source geospatial software
Assess the OSM data quality starting from contribution history
Coffee break
Serving earth observation data with GeoServer: addressing real world requirements
A cloudfree Europe with Sentinel-2
Standardized access and processing of Earth Observation data within a regional data middleware system
Navier
Coffee break
Four-letter word
Remonterletemps.ign.fr : the geospatial time machine built upon open-source components
Adressing referencing issues with new standards, and introduction to Apache Spatial Information System (SIS)
Lunch break
State of the art of WebGL map viewers
CARTO 2017
EOxC – a modern web catalog client
Coffee break
A series of unfortunate maps
Magrit : a new thematic cartography application
Make It Rain with Mapbox GL
Picard
Coffee break
Understanding the Flexibility of Open Source
Examining The Spatial Dynamics of Economic Globalisation: A Tale of using Open Source Technologies
Struggling with the Open Community
Lunch break
Serving successfully millions of 3D objects in a browser
Melown 3D mapping stack
Let's integrate BIM and 3D GIS on top of FOSS4G!
Coffee break
Mobile application for 3D real-time visualization for Outdoor sports competitions (LIS3D)
Albion : Geological modelling Software
Mapping Learning: when geography meets machine learning
Bienvenüe
Coffee break
Urban data collection using a bike mobile system with a foss architecture
High resolution global gridded data for use in population studies
Building a geographic data repository for urban research with free software – learning from observatorio.cedeus.cl
Lunch break
The extraction of indoor building information from BIM to OGC IndoorGML
Can reconstructed landsurface temperature data from space predict a west nile virus outbreak ?
Processing big remote sensing data for fast flood detection in a distributed computing environmen
Coffee break
An integrated approach for linked data browsing
GEOYASGUI: the geosparql query editor and result set visualizer
A WebGIS for the knowledge and conservation of the historical buildings in Sardinia (Italy)
09:30
10:30
11:30
12:30
13:30
14:30
15:30
16:30
17:30
Caquot
Keynote 3
Keynote 4
Coffee break
Lunch break
Coffee break
Cauchy
Coffee break
The importance of user communities in the uptake of open Copernicus data and information
CTEP: satellite data exploitation platform developed entirely with FOSS software
pyroSAR – a Python framework for large-scale SAR satellite data processing
Lunch break
INSPIRE and Open Source Geospatial Solutions: adding missing pieces to the puzzle?
Implementing INSPIRE view and download services – transition to FOSS4G
OGC/INSPIRE versus OpenData/LinkedData
Coffee break
What's up with diversity?
WebWorldWind: status and perspective 2 years after its introduction at FOSS4G in Como
The theory of Space Syntax and its application using open source tools and libraries
Navier
Coffee break
Creating semantic graphs on top of geospatial databases
D3.js in postgis
OpenMapTiles: ready to use OpenStreetMap vector tiles
Lunch break
QGIS Server 3: refactoring and enhancement
Let’s share GIS much quicker
an SLD+OWSContext extension for GeoPackage to migrate between GIS platforms
Coffee break
Making geospatial resources web-ready: improving the discovery, access and use of SDIs
IGEO geospatial platform
MapStore 2, modern mashups with OL3, Leaflet and React
Picard
Coffee break
10 years of OSGeo @ GsoC: what's next?
OSGeo Branding and Website Reboot
Open Geoscience and OSGeo
Lunch break
Introducing hex-utils: an hexagonal raster tool-kit
In the service of democracy: allocating expat voters to polling stations using FOSS GIS
Estimating public transit "real-time" locations based on time-table data
Coffee break
New ASIG Geoportal – central place for spatial data and services in Albania
Introducing the vehicle routing open-source optimization machine (VROOM)
Shortest Path search in your Database and more with pgRouting
Bienvenüe
Coffee break
Concept and implementation of an architecture for the immediate provision of geodata in disaster management
Screening of environmental impact of pollution with the qgis plugin envifate
Online analysis of meteorological and climate geospatial datasets for northern eurasia environmental studies
Lunch break
FOSS4G as a key building block for case-based learning in geographic information education
UN Open GIS capacity building
Migrate: a foss web mapping application for educating and raising awareness about migration flows in europe
Coffee break
A new digital image correlation software for displacements field measurement in structural applications
Extending the scalability of istsos within the 4onse project
Extension of rtklib for the calculation and validation of protection levels
09:30
10:30
11:30
12:30
13:30
14:30
15:30
16:30
17:30
Caquot
Keynote 5
Keynote 6
Coffee break
Lunch break
Coffee break
Closing plenary
Cauchy
Coffee break
State of GeoServer
GeoNetwork: State of the Art
GeoNode, the Open Source geospatial CMS
Lunch break
Advanced features in PyWPS 4.0.0
Mapbender3 Presentation and Status Report
ZOO-Project 1.7.0: What 's new on the Open WPS Platform
Coffee break
GeoMapFish, an Open Source WebGIS Project Status Report
Lizmap Feature Frenzy
Introducing mappyfile: a Python library for MapServer
Navier
Coffee break
Hotspot Analysis: an experimental Python plugin to enable LISA mapping into QGIS
LiDAR analysis for hazard mapping and forestry management using JGrassTools and gvSIG
Data Processing with QGIS 3
Lunch break
Angular2 Geo-Apps with YAGA
Pirate Maps: Experiments with portable maps on the Raspberry Pi
Taking advantage of OGC and HTML5: offline web editing
Coffee break
Open Data and FOSS4G to improve resilience for Comoros
A digital approach for forest and land use planning build on WMS, WPS and WRSm
Query support for GMZ
Picard
Coffee break
Public Transport in GraphHopper
The Geopaparazzi project: state of the art
QViz: An open source tool for interactive stakeholder participation using large scale tangible user interfaces
Lunch break
Mobile application for 3D real-time visualization for Outdoor sports competitions (LIS3D)
Aquadrone : geo-tracking and collecting environmental data from an underwater remotely operated vehicle
FREEWAT platform for integrated water management
Coffee break
Fentrol.hu, experiences of the open aerial photo archive
geoportal.xyz multi-infrastructures, multi-customers)
Building a Table Joining Like Service with Web Processing Services
Bienvenüe
Coffee break
Integrating MCDM methods to gis through a dedicated FOSS application
Multi-modal remote sensing data fusion framework
Spatial inequality in the accessibility to hospitals in Greece
Lunch break
Application of a pattern recognition algorithm for single tree detection from lidar data
Comparative analysis of 3d point clouds generated from a freeware and terrestrial laser scanner
3D model generation using oblique images acquired by UAV
Coffee break
A new strategy for dsm generation from satellite imagery with a foss4g: “date” results analysis on the isprs benchmark
Detecting stressed and pest-affected trees in aerial photos through machine learning: a proof of concept
↧
7-year mapping project adds Indigenous communities to Google Earth
↧
🌟 Introducing Dash 🌟
Dash is a Open Source Python library for creating reactive, Web-based applications. Dash started as a public proof-of-concept on GitHub 2 years ago. We kept this prototype online, but subsequent work on Dash occurred behind closed doors. We used feedback from private trials at banks, labs, and data science teams to guide the product forward. Today, we’re excited to announce the first public release of Dash that is both enterprise-ready and a first-class member of Plotly’s open-source tools. Dash can be downloaded today from Python’s package manager with pip install dash — it’s entirely open-source and MIT licensed. You’ll find a getting started guide here and the Dash code on GitHub here.
Dash is a user interface library for creating analytical web applications. Those who use Python for data analysis, data exploration, visualization, modelling, instrument control, and reporting will find immediate use for Dash.
Dash makes it dead-simple to build a GUI around your data analysis code. Here’s a 43-line example of a Dash App that ties a Dropdown to a D3.js Plotly Graph. As the user selects a value in the Dropdown, the application code dynamically exports data from Google Finance into a Pandas DataFrame. This app was written in just 43 lines of code (view the source). Simple.
Dash app code is declarative and reactive, which makes it easy to build complex apps that contain many interactive elements. Here’s an example with 5 inputs, 3 outputs, and cross filtering. This app was composed in just 160 lines of code, all of which were Python.
Every aesthetic element of the app is customizable: The sizing, the positioning, the colors, the fonts. Dash apps are built and published in the Web, so the full power of CSS is available. Here’s an example of a highly customized, interactive Dash report app, in the brand and style of a Goldman Sachs report.
While Dash apps are viewed in the web browser, you don’t have to write any Javascript or HTML. Dash provides a Python interface to a rich set of interactive web-based components.
import dash_core_components as dccdcc.Slider(value=4, min=-10, max=20, step=0.5, labels={-5: '-5 Degrees', 0: '0', 10: '10 Degrees'})Dash provides a simple reactive decorator for binding your custom data analysis code to your Dash user interface.
@dash_app.callback(Output('graph-id', 'figure'), [Input('slider-id', 'value')])def your_data_analysis_function(new_slider_value): new_figure = your_compute_figure_function(new_slider_value) return new_figureWhen an input element changes (e.g. when you select an item in the dropdown or drag a slider), Dash’s decorator provides your Python code with the new value of the input.
Your Python function can do anything that it wants with this input new value: It could filter a Pandas DataFrame, make a SQL query, run a simulation, perform a calculation, or start an experiment. Dash expects that your function will return a new property of some element in the UI, whether that’s a new graph,a new table, or a new text element.
For example, here’s a simple Dash application that updates a text box as you interact with the Graph element. The application code filters data in a Pandas DataFrame based off of the currently selected point.
This Dash application displays meta information about drugs as you hover over points in the Graph component. The application code also appends rows to the Table component when elements are added to the multi Dropdown component.
component.
Through these two abstractions — Python components and reactive functional decorators — Dash abstracts away all of the technologies and protocols that are required to build an interactive web-based application. Dash is simple enough that you can bind a user interface around your Python code in an afternoon.
Flask and React
Dash applications are web servers running Flask and communicating JSON packets over HTTP requests. Dash’s frontend renders components using React.js, the Javascript user-interface library written and maintained by Facebook.
Flask is great. It’s widely adopted by the Python community and deployed in production environments everywhere. The underlying instance of Flask and all of its configurable properties is accessible to Dash app developers. For advanced developers, Dash apps can be extended through the rich set of Flask Plugins as well.
React is fantastic too. At Plotly, we’ve rewritten our entire web-platform and our online chart editor with React. One of the incredible things about React is how prolific and talented the community is. The open source React community has published thousands of high quality interactive components, from Dropdowns to Sliders to Calendar Pickers to Interactive Tables.
Dash leverages the power of Flask and React, putting them to work for Python data scientists who may not be expert Web programmers.
From React.js to Python Dash Components
Dash components are Python classes that encode the properties and values of a specific React component and that serialize as JSON. Dash provides a toolset to easily package React components (written in Javascript) as components that can be used in Dash. This toolset uses dynamic programming to automatically generate standard Python classes from annotated React propTypes. The resulting Python classes that represent Dash components are user friendly: They come with automatic argument validation, docstrings, and more.
Here’s an example of the dynamically generated argument validation:
>>> import dash_core_components as dcc>>> dcc.Dropdown(valu=3)Exception: Unexpected keyword argument `valu`Allowed arguments: id, className, disabled, multi, options, placeholder, valueand an example of the dynamically generated component docstrings:
>>> help(dcc.Dropdown)class Dropdown(dash.development.base_component.Component) | A Dropdown component. | Dropdown is an interactive dropdown element for selecting one or more | items. | The values and labels of the dropdown items are specified in the `options` | property and the selected item(s) are specified with the `value` property. | | Use a dropdown when you have many options (more than 5) or when you are | constrained for space. Otherwise, you can use RadioItems or a Checklist, | which have the benefit of showing the users all of the items at once. | | Keyword arguments: | - id (string; optional) | - className (string; optional) | - disabled (boolean; optional): If true, the option is disabled | - multi (boolean; optional): If true, the user can select multiple values | - options (list; optional) | - placeholder (string; optional): The grey, default text shown when no option is selected | - value (string | list; optional): The value of the input. If `multi` is false (the default) | then value is just a string that corresponds to the values | provided in the `options` property. If `multi` is true, then | multiple values can be selected at once, and `value` is an | array of items with values corresponding to those in the | `options` prop. | | Available events: 'changeThe full set of HTML tags, like <div/>, <img/>, <table/> are also rendered dynamically with React and their Python classes are available through the dash_html_component library. A core set of interactive components like Dropdown, Graph, Slider will be maintained by the Dash core team through the dash_core_components library. Both of these libraries use the standard open-source React-to-Dash toolchain that you could use if you were to write your own component library.
You’re not tied to using the standard Dash component library. The Dash component libraries are imported separately from the core Dash library. With the React-to-Dash toolchain, you can easily write or port a React.js component into a Python class that can be used in your Dash application. Here’s the tutorial on building your own components. Or, the Dash core team can build one for you.
Concurrency — Multi-User Applications
The state of a Dash application is stored in the front-end (i.e. the web browser). This allows Dash apps to be used in a multitenant setting: Multiple users can have independent sessions while interacting with a Dash app at the same time. Dash application code is functional: Your application code can read values from the global Python state but it can’t modify them. This functional approach is easy to reason about and easy to test: It’s just inputs and outputs with no side-effects or state.
CSS and Default Styles
CSS and default styles are kept out of the core library for modularity, independent versioning, and to encourage Dash App developers to customize the look-and-feel of their apps. The Dash core team maintains a core style guide here.
Data Visualization
Dash ships with a Graph component that renders charts with plotly.js. Plotly.js is a great fit for Dash: it’s declarative, open source, fast, and supports a complete range of scientific, financial, and business charts. Plotly.js is built on top of D3.js (for publication-quality, vectorized image export) and WebGL (for high performance visualization).
Dash’s Graph element shares the same syntax as the open-source plotly.py library, so you can easily to switch between the two. Dash’s Graph component hooks into the plotly.js event system, allowing Dash app authors to write applications that respond to hovering, clicking, or selecting points on a Plotly graph.
Open Source Repositories
You can check out the code yourself across a few repositories:
Dash backend: https://github.com/plotly/dash Dash frontend: https://github.com/plotly/dash-renderer Dash core component library: https://github.com/plotly/dash-core-components Dash HTML component library: https://github.com/plotly/dash-html-components Dash component archetype (React-to-Dash toolchain): https://github.com/plotly/dash-components-archetype Dash docs and user guide: https://github.com/plotly/dash-docs, hosted at https://plot.ly/dash Plotly.js — the graphing library used by Dash: https://github.com/plotly/plotly.js Dash is new in the Python ecosystem but the concepts and motivation behind Dash have existed for decades in a variety of different languages and applications.
If you’re coming from Excel, then your head is in the right place. Both Dash and Excel use a “reactive” programming model. In Excel, output cells update automatically when input cells change. Any cell can be an output, an input, or both. Input cells aren’t aware of which output cells depend on them, making it easy to add new output cells or chain together a series of cells. Here’s an example Excel “application”:
There’s an Excel analogy for Dash. Instead of cells, we have rich web based components like sliders, inputs, dropdowns, and graphs. Instead of writing Excel or VBA script, we’re writing Python code. Here is that same spreadsheet application, rewritten in Dash:
app.layout = html.Div([ html.Label('Hours per Day'), dcc.Slider(id='hours', value=5, min=0, max=24, step=1),html.Label('Rate'), dcc.Input(id='rate', value=2, type='number'),html.Label('Amount per Day'), html.Div(id='amount'),html.Label('Amount per Week'), html.Div(id='amount-per-week')])@app.callback(Output('amount', 'children'), [Input('hours', 'value'), Input('rate', 'value')])def compute_amount(hours, rate): return float(hours) * float(rate)@app.callback(Output('amount-per-week', 'children'), [Input('amount', 'children')])def compute_amount(amount): return float(amount) * 7I like this example a lot because Excel still reigns supreme, even in technical computing and quantitative finance. I don’t think that Excel’s dominance is just a matter of technical ability. After all, there are legions of spreadsheet programmers who have learned the nuances of Excel, VBA, and even SQL.
It’s more that Excel spreadsheets are frequently easier to share than Python programs, and Excel cells are easier to edit than command line arguments.
Yet modelling in Excel has well-known limits: These spreadsheets often outgrow themselves. They become too large or fragile to migrate into a production environment, peer review, test, and maintain. Remember the 2013 pro-austerity Excel typo?
I hope that Dash makes it easier for developers to use Python for their data projects. By sharing the same functional and reactive principles, it’s almost as easy to write a Dash app as it is to write an analytical spreadsheet. It’s certainly more powerful and presentable.
If you develop in the R programming language, you’re in luck. Shiny is a reactive programming framework for generating web applications in pure R. It’s great! You can even create interactive graphics with Shiny and Plotly’s R library. Dash and Shiny are similar but Dash does not aim to be a replica of Shiny. The idioms and philosophies between Python and R are different enough to warrant a different syntax. The front-ends of Shiny and Dash are written in different libraries from different times.
If you program in MATLAB then you may be familiar with MATLAB’s user interface library “GUIDE”. Mathworks was one of the true original innovators in technical computing — GUIDE was written in 2004, 13 years ago!
If your data is structured in a database, then you may be using Tableau or one of the other BI tools. Tableau is incredible. They’ve set a new expectation in the industry that end-users should have the autonomy and the tools to be able to explore their organization’s data. They’ve also helped popularize the concepts of “drilling down” and cross-filtering.
Dash is complementary to BI tools like these. These tools work great for structured data. But when it comes to data transformation and analytics, it’s hard to beat the breadth and flexibility of programming languages and communities like Python. Dash abstracts away a lot of the complexities in building user interfaces, enabling you to build a beautiful front-end for your your custom data analytics backend.
Finally, I’d like to give a shout out to Jupyter widgets. Jupyter provide a really nice widget framework inside their notebook interface. You can add sliders to your graphs in the Jupyter notebooks that you run locally.
The widgets in Dash are similar to the widgets in Jupyter. In Jupyter Notebooks, you can add widgets directly alongside your code. In Dash, your controls and application are kept separately from your code. Dash is aimed more towards sharable apps than it is to sharable code and notebooks. You can always mix-and-match the tools, and write your Dash apps in the Jupyter Notebook environment.
We’re also big fans of the nteract project, which is really lowering the barrier to entry of Python and Jupyter Notebooks by wrapping up Jupyter Notebook as a desktop application.
Plotly is a VC-backed startup. We founded in 2013 and we open sourced our core technology, plotly.js, in 2015 (MIT license). We maintain open source libraries in Python, R, and MATLAB that interface with plotly.js and a web app for creating these charts and connecting them to databases (the connectors are also open source).
We provide subscriptions to our our chart hosting and sharing platform and to our chart editing and database querying app. This platform is available on the web (plot.ly) and on-premise.
We’re applying a similar model to Dash. Dash is MIT licensed. It’s free to use and to modify. For companies, we’re offering Dash Enterprise, a deployment server for easily publishing and provisioning Dash Apps behind your firewall.
Our goal with Dash Enterprise is to make sharing a Dash app internally as easy and secure as possible. No dev-ops required. Dash Enterprise handles the URL routing, the monitoring, the failure handling, the deployment, the versioning, and the package management. Dash Apps deployed with Dash Enterprise can be provisioned through your company’s Active Directory or LDAP user accounts.
If you’re using the open source version locally, there are no restrictions. You can manage deployment of Dash apps yourself through platforms like Heroku or Digital Ocean. If you have the resources, consider purchasing a support plan to get one-on-one help from a Plotly engineer. If you need more specialized help or would like to fund specific feature development, reach out to our advanced development program.
Open source is still a new idea for product companies, yet at the end of the day, we’re able to dedicate more than half of our staff towards open source products. Huge thanks to everyone who has supported us so far ❤️
Thanks for checking out Dash. I’ll be giving a talk about Dash at SciPy this summer in Austin and in next fall at Plotcon NYC. If you’ll be at either of those events, please say hi! Otherwise, I’ll see you on GitHub ✌️🏼
Our Dash documentation is hosted at https://plot.ly/dash All of our open source work is in our GitHub organization at https://github.com/plotly If you’d like to fund specialized features, reach out to our Advanced Development team: plot.ly/products/consulting-and-oem/ You can find us on Twitter at @plotlygraphs. If you’re looking for inspiration in user interfaces for technical computing, I highly recommend Bret Victor’s essay on What Can A Technologist Do About Climate Change? In particular, the sections on Technical computing and Media for understanding situations Related, if you find the intersect between technical computing and interface interesting, you might like Explorable Explanations You can reach out to me directly at chris@plot.ly or on twitter at @chriddyp
↧
↧
Luxury flat residents complain rehousing Grenfell families 'unfair'
↧
New GeoPlanner Course – It’s Free!
↧
Geography Increasingly a Priority for Schools, Employers
↧
Design and publish beautiful maps
↧
↧
Spotify
↧
The CIA Is Celebrating Its Cartography Division’s 75th Anniversary by Sharing Declassified Maps
↧
EU Migration to and from the UK
↧
2017 National Geospatial Preparedness Summit
↧
↧
15 years of migration in 15 mesmerizing maps
↧
Map Analytics: using Mango + Maptiks
↧
Giant ringed planet likely cause of mysterious eclipses
↧