GeoPython 2023 Talk List

A look at the process of extracting and loading OpenStreetMap building footprints into PostGIS using OSMnx and Geopandas. This talk will cover our particular use case and the workflow we used.

At addresscloud we have used OpenStreetMap building data in our main application for the UK but we’ve recently found the need to get this data on a global basis. Our main goal was to extract the building outlines that have been captured in OSM and push these into our datastore to use in our applications. We didn’t want to do this for a whole country as the amount of data and time to upload could be costly. We looked at a few different solutions but wanted something that was easy to set up and use so went with the python library OSMnx. OSMnx is a Python package to retrieve, model, analyse, and visualise street networks and other geometries from OpenStreetMap. In a single line of code, OSMnx lets you download spatial geometries, place boundaries, buildings footprints, or points of interest as a GeoDataFrame. This talk will look at the different options available in terms of downloading the data .i.e by city name, polygon, bounding box, or point/address plus distance. It will then show how we added geopandas into the workflow to export the data for use in our wider ecosystem. Finally we will look at the whole workflow and show how easily you can use OSMnx and geopandas in real world applications. Example code snippets will be shown for people to get an idea of how they can make use of OSMnx.

Geospatial technologist who loves working with data and creating workflows with open source tools and scripting in python, nodejs and bash.

This project aims to measure NO2 and CO pollutants and detect the most polluted areas in Oman during 2018 and 2019.

My talk will be spelled into three parts The first 5mins will be about the location of Oman, and it's demographic than the next 10 mins will be about the air quality situation in Oman during 2018 and 2019 .at the end last 15mins will be about the most polluted areas in Oman, seasonal, weekly, and daily night time.

Zaher AL ruzaiqi is a GIS specialist who graduated from Sultan Qaboos University with a bachelor degree of GIS&RS i worked on several projects during my college years such as land suitability selection of landfill,spatial-temporal resolution of covid19 cases in gulf countries, risk assessment of wadi alkhound-oman.

The presentation talks about the possibilities how to use Python and OpenRouteService to compute Isozones for further GIS analysis. The contents of this presentation is very practical.

OpenRouteService is a freely available webservice that allows for the computation of many products in the context of routig: fastest routes, matrices, isozones etc. The service also offers a nice API that supports several programming languages, among others is Python. In this presentation the speaker presents how python can be used to take advantage of the service and its API and what the limits, some workarounds and chances are.

The talk presents AROSICS and SpecHomo, two open-source and easy-to-use Python packages for automated and robust geometric and spectral fusion of multi-sensor, multi-spectral satellite images.

Earth observation satellite data acquired in recent years and decades provide an ideal data basis for accurate long-term monitoring and mapping of the Earth's surface and atmosphere. However, the vast diversity of different sensor characteristics often prevents synergetic use. Hence, there is an urgent need to combine heterogeneous multi-sensor data to generate geometrically and spectrally harmonized time series of analysis-ready satellite data. In this context, we present two open-source Python algorithms for geometric and spectral harmonization of multi-sensor, multi-temporal satellite data. AROSICS, a novel algorithm for multi-sensor image co-registration and geometric harmonization, detects and corrects positional shifts between two input images and aligns the data to a common coordinate grid. At its core, the algorithm is based on phase correlation in the frequency domain, which makes it particularly robust to spectral differences. The Python package automatically calculates thousands of control points per image pair, that are efficiently filtered in a three-stage outlier detection process. The second algorithm, SpecHomo, was developed to unify differing spectral sensor characteristics. One particular innovation is the use of material-specific regressors, i.e., separate transformation functions, optimized for different land cover classes. These regressors not only allow higher accuracies in the transformation of the spectral information, but also enable the estimation of unilaterally missing spectral bands. For example, spectral bands in the red edge region can be estimated from Landsat-8 using the presented Python package. Such synthesized red edge information has proven valuable when retrieving vegetation-related parameters such as burn severity. The talk illustrates the effectiveness of the developed algorithms to reduce multi-sensor, multi-temporal data inconsistencies and demonstrates the added value of geometric and spectral harmonization for subsequent products. It shows that the combination of multi-sensor time series offers great potential for more accurate monitoring and mapping of quickly evolving environmental processes.

Automated management of the spraying / weeding of railway tracks and their surroundings by dedicated SNCF locomotives and wagons equipped with specialized geolocated equipment.

This project is part of a broader industrial computing project and focuses on the management of the spraying on SNCF trains for the weeding of railroads. To that end, arx iT has developed a cartographic module that guides the spraying automaton to authorize or prohibit spraying by calculating geometric intersections with NTZs (Non Treatment Zones) in real time based on the position of the train.

From a technical point of view, the cartographic module is composed of 2 parts:

Backend: - Developed in python (Fast API). - TCP communication with the PLC. - Calculation of geometric intersections with the ZNT (Geopandas library). - Calculation of the areas treated / sprayed by the train. - Sending the geometries of the treated areas to the Front via WebSocke

Frontend : - Display of ZNT in a buffer around the first GPS position of the train. - Real time display of the areas treated / sprayed by the train. - A set of tools that allow the operator to stop / continue a spraying session

GIS Specialist with 15 years experience in 10+ countries and across industries.

Mobile Mapping point cloud object detection is becoming vital and essential for many real-world applications when it comes to precisely measure and detect critical objects. The municipality of Rotterdam is responsible for road construction details and maintenances of streets in Rotterdam. For example, the municipality will try to take into account the slope of the street. In this way they ensure that the new street or newly installed elements do not cause any disruption to water drainage.

Mobile Mapping point cloud object detection is becoming vital and essential for many real-world applications when it comes to precisely measure and detect critical objects. The municipality of Rotterdam is responsible for road construction details and maintenances of streets in Rotterdam. For example, the municipality will try to take into account the slope of the street. In this way they ensure that the new street or newly installed elements do not cause any disruption to water drainage. One crucial object that needs to be detected and measured is sill heights. The method that is currently used contains large amount of manual work. We used mobile mapping point clouds data collected by LiDAR sensors mounted on a moving vehicle. We implemented a practical pipe line workflow of automatically extracting accurate representation of sill heights objects from large amount of point cloud data. In this way, we succesfully designed a verification system to classify detected sill heights objects to ensure that if the sill height on individual detected objects meets the criteria. We used advanced python libraries to automatically detect and classify sill height objects. Our workflow can be used for other type of objects from large amount of point clouds data for the city of Rotterdam and different asset management applications.

You've created a ground-breaking Python script which only you can run. Your colleagues don't know Python and cloud deployment isn't an option, but with a little digging we can still unearth approaches for script automation within a low-tech IT environment.

How can you move beyond python script.py to enable non-technical colleagues to use your tools? Even forward-thinking cloud-native organisations may not have the IT support or capability available to enable every engineer and analyst to start deploying their own web apps.

• Layer 0: This talk's foundation is the problem of converting geological and ground interpretation data into the AGSi standard schema, a file format designed to move the industry from PDFs and spreadsheets to a linked data format for interconnecting a much wider ecosystem of software. This problem is well solved by Python, but what can you do when non-technical colleagues are emailing you every few hours with an updated data file to convert?

• Layer 1: Training – the simplest answer to sharing Pythonic superpowers. We'll share some tips & advice, and the pitfalls that await.

• Layer 2: Streamlit – a Python library for creating web GUIs for simple scripts, providing a much friendlier interface than the command-line.

• Layer 3: Automation with GitHub Actions – scales to thousands of users without the need for either training or IT support.

• Layer 4: Event-Driven Workflow Automation – users simply have to drop a file into a shared directory and wait.

This talk will introduce CLIMADA [1], an open-source and -access modeling platform for climate risk assessments. Using state-of-the-art probabilistic modelling, CLIMADA allows to estimate multi-hazard socio-economic impacts as a measure of risk today, the incremental increase from socio-economic development and the further incremental increase due to climate change.

This talk will introduce CLIMADA [1], an open-source and -access modeling platform for climate risk assessments. Using state-of-the-art probabilistic modelling, CLIMADA allows to estimate multi-hazard socio-economic impacts as a measure of risk today, the incremental increase from socio-economic development and the further incremental increase due to climate change. As a risk calculation tool, CLIMADA requires substantial (geospatial) input data for hazards, exposures and vulnerabilities. CLIMADA’s core functionalities are hence written in a way that provides default hazards, exposures and vulnerabilities data layers. These layers are either seamlessly available from open-source providers (for instance population data from the WorldPop project [2], infrastructure data from OpenStreetMap [3], tropical cyclone data from IBTrACS [4]) or through a CLIMADA database created specifically for this purpose, available via a public API [5]. This enables risk assessments without extensive data collection and creates transparent, auditable and reproducible analyses. CLIMADA is spatially explicit and globally consistent and, as of today, it provides global coverage of major climate-​related extreme-​weather hazards at high resolution, namely (i) tropical cyclones, (ii) river flood, (iii) agro drought, (iv) European winter storms, and (v) wildfire, all at 4km spatial resolution globally. For all hazards, historic and probabilistic event sets exist, for some also under select climate forcing scenarios (RCPs) at distinct time horizons (e.g. 2040). All directly available via the CLIMADA data API. CLIMADA is freely available on GitHub under GNU GPL3 code [6] and CC BY 4.0 data licences, it is readily installable with a package manager (pip) and its functionalities are documented with a comprehensive manual and tutorials [7]. It is used and maintained by the Weather and Climate Risks (WCR) group at ETH Zurich and partner organisations with an active developer community of about 30 researchers. [1] https://github.com/CLIMADA-project [2] Tatem, A. J.: WorldPop, open data for spatial demography, Sci Data, 4, 170004, https://doi.org/10.1038/sdata.2017.4, 2017 [3] Haklay, M. and Weber, P.: OpenStreetMap: User-Generated Street Maps, IEEE Pervasive Computing, 7, 12–18, https://doi.org/10.1109/MPRV.2008.80, 2008. [4] Knapp, K. R., Kruk, M. C., Levinson, D. H., Diamond, H. J., and Neumann, C. J.: The International Best Track Archive for Climate Stewardship (IBTrACS): Unifying Tropical Cyclone Data, Bulletin of the American Meteorological Society, 91, 363–376, https://doi.org/10.1175/2009BAMS2755.1, 2010. [5] https://climada.ethz.ch/rest/docs#/ [6] https://github.com/CLIMADA-project/climada_python/blob/main/LICENSE [7] https://climada-python.readthedocs.io

Interested in handling your Cloud Infrastructure through code like you handle the application logic and software? Enter Pulumi, a universal Infrastructure as Code platform that helps you maintain your multi-cloud Infrastructure as Code using popular languages like Python, Java, Golang, .NET, Typescript, etc.

This session focuses on writing Pythonic Infrastructure as Code with Pulumi.

As more and more companies are moving majority of their workloads to the cloud, it is becoming important to maintain Cloud Infrastructure as Code. Terraform has been widely used in the past as an Infrastructure as Code tool, however, not all organizations have a dedicated DevOps / Platform team.

There are companies who have their developers maintain the infrastructure based on the team ownership. In such cases, developers have to learn Terraform and then go about maintaining IaC. This could be challenging for the developers as this comes with a learning curve. On top of this, many organizations may already be using Python for the majority of their Platform Engineering and Automation tasks. It should make sense to somehow manage Infrastructure through Python code.

This talk focuses on making the community aware of Code-Centric Infrastructure as Code (IaC) using Open Source Pulumi with Python. Since Pulumi even supports other languages like Java, Typescript, Golang, .NET, etc., developers from almost all backgrounds should be able to relate to the talk and apply principles in their respective domains.

Imagine, you could maintain classes, write unit and integration tests for Infrastructure, find code smells, integrate and maintain multi-cloud infrastructure using pure Python, cross-function with other modules, develop and maintain mature CI/CD pipelines, and do a lot more with power of Python when applied to Infrastructure as Code concept.

Considering that Infrastructure as Code is the need of the hour, the talk intends to empower the developer community with a strong foundation in IaC with Python.

Note: The content and the views presented during the sessions/workshops will be the author’s own and not of the organizations/companies they are associated with.

Anmol Krishan Sachdeva, aka greatdevaks, is an International Tech Speaker, a Distinguished Guest Lecturer, an Adjunct Professor, a Tech Panelist, and has represented India at several reputed International Hackathons. He is a Deep Learning Researcher and has about 8 publications in different domains.

He is an active conference organizer and previously has helped organize some of the most prestigious conferences like EuroPython, GeoPython & Python Machine Learning Conference, PyCon India, etc., and all of them were a huge success. He has done MSc in Advanced Computing (ML, AI, Robotics, Cloud Computing, Human Computer Interaction, and Computational Neuroscience) from University of Bristol, United Kingdom, and currently works at Google as a Hybrid Cloud Architect.

In the past, Anmol has spoken at renowned conferences and tech forums like KubeCon, PyCon, EuroPython, GeoPython, Google Cloud Next, and got invited as a Chief Guest / Guest of Honour at various events.

He likes innovating, keeping in touch with new technological trends, and mentoring people. Additionally, his interest lies in Cosmology and Neuroscience.

An overview of deep internal learning methods applied for satellite imagery with examples of open-source PyTorch implementations.

This talk provides an outline of the efforts to explore the use of Deep Internal Learning Methods for processing of satellite images. Internal learning allows to solve various computer vision tasks without the need of pre-training on wider datasets and without using any pre-trained models. The task, such as in image inpainting, is completely solved by using the information contained in the input sample.

The talk will briefly summarize the past work done in the field of computer vision, followed by an overview of the works applying the related techniques to satellite images. This allows for performing operations such as image completion, image super-resolution, or image denoising without the need of acquiring any datasets or extensive training of the network.

Finally, the talk will include a demonstration of several open source implementations of Deep Internal Learning techniques by running the examples in jupyter notebooks. Software used for the demonstration will be based in PyTorch, PyTorch Lightning, Numpy.

Mikolaj is a final-year PhD student at the University of Strathclyde in Glasgow. His work extends over a range of topics, including radar signal analysis, remote sensing and general computer vision problems; such as generative modelling, image inverse problems, and learning in low-data regimes.

This talk will present the results of the OMDENA challenge "Developing an AI assisted collaborative mapping tool for disaster management".

The Humanitarian OpenStreetMap Team (HOT) utilizes OpenStreetMap (OSM) for its humanitarian actions and community development. The spatial location of buildings is essential information in terms of disaster resilience. During the OMDENA challenge, 50 machine learning engineers developed an AI-assisted mapping tool supporting the HOT mappers in delineating building footprints based on aerial images from OpenAerialMap (OAM).

Based on the input data provided by HOT, the project team developed a workflow for preprocessing aerial images as well as the building footprints. Several architectures of Convolutional Neural Networks (CNN) were tested during the challenge. As the provided input data was limited, the final approach was to apply the pre-trained model from the RAMP project. This deep neural network was trained with large amounts of satellite images and was used for transfer learning.

One major outcome of the challenge was the development of the HOTLib library as a reference implementation of the planned workflow. This Python library supports HOT in the preprocessing of the input data, the inference step based on the RAMP model, and the post-processing of the prediction results.

Additional information: - https://omdena.com/projects/mapping-tool-for-disaster-management - https://omdena.com/blog/ai-assisted-collaborative-mapping-tool-with-humanitarian-openstreetmap - https://www.hotosm.org/tech-blog/hot-tech-talk-open-ai-challenge - https://www.hotosm.org/tech-blog/hot-tech-talks-fair

We present S2Portal, an open-source tool that enables efficient downloading of Sentinel-2 data specifically for custom areas of interest (AOIs) from the AWS Public Dataset Program. S2Portal respects user-specified criteria such as date range, spectral bands, and cloud cover, and only downloads the minimal amount of data needed to cover the AOI, reducing the time and cost of data acquisition.

The Copernicus Sentinel-2 mission provides high-resolution multispectral imagery with a revisit time of 5 days or less, making it a valuable resource for a wide range of applications including agriculture, environmental monitoring, and disaster response. However, acquiring Sentinel-2 data can be a time-consuming and complex process, particularly for users who need to cover very specific areas of interest (AOI) rather than entire scenes.

To address this challenge, we have developed S2Portal, a Python-based software package that allows users to efficiently download Sentinel-2 data from the AWS Public Dataset Program using the STAC (SpatioTemporal Asset Catalog) catalogue and the COG (Cloud Optimized GeoTIFF) format. S2Portal requires a custom polygon or multipolygon shapefile as input and only downloads the minimal amount of data needed to cover the AOI, reducing the time and cost of data acquisition.

Based on user-specified criteria set in the configuration file, S2Portal utilizes the STAC API to search for and retrieve the desired Sentinel-2 data, including options for date range, spectral bands, and cloud cover. It is made available open source by the Helmholtz Innovation Lab FERN.Lab, located at the GFZ German Research Centre for Geosciences, and is provided under a EULA v1.2 license, with the option for a non-copyleft EULA license.

In conclusion, S2Portal is a valuable tool for researchers and practitioners who need to efficiently acquire Sentinel-2 data for specific AOIs, allowing for more targeted and cost-effective data acquisition.

Altair is a powerful toolkit for creating interactive and engaging geovisualisations in Python. Lets talk about it.

Hi! This talk is about Altair and its capabilities for geovisualisations. I will start with discussing the background of Altair and and how it relates to the grammar of interactive graphics. Then, I will show you the capabilities of Altair, starting with simple geovisualizations and gradually moving on to more complex, interactive ones. It's going to be fun!

Altair is a python library that follows a declarative visualization grammar that allows users to create interactive graphics in a simple and intuitive way. We will touch upon Vega-Lite and show why this is a powerful toolkit for creating geovisualizations.

During my talk, I will show you how Altair integrates with the geospatial ecosystem in Python, but also in the wider ecosystem of web applications. I will present how to create a variety of geovisualisations. From simple maps to more complex. I will demonstrate the mapping of polygons, points, lines, choropleths classifications, small multiples, customisation of appearance and interactivity.

I hope you will join me for my talk on Altair and its capabilities for (geo)visualisations. I'm sure you'll come away with some new skills and ideas for creating interactive, engaging geovisualisations in Python. See you there!

Mattijn is a core contributor of Altair and author of Python topojson. He did a PhD on drought monitoring from space. Currently he works at HKV consultants in the Netherlands. HKV is specialised in creating customised, high-end solutions for the water sector to help specialists operate effectively.

This talk will present FLORIA, an innovative custom python pipeline for urban flood extraction. The implementation of the predefined workflow, ingesting most SAR sensors and extracting from U-Net convolutional network approach, will be highlighted. Thanks to open-source data, software and libraries, mapping and automatizing urban flood extraction from SAR imagery is now possible.

Mapping flood in urban areas with SAR imagery is not possible from a single imagery due to the dihedral backscattering effect of man-made structures. Scientific papers have shown that the backscattered double bounce of the signal is amplified by the water presence and the coherence between pairs of SAR - that is expected to be high in an urban area - is falling down.

This assumption, accompanied by several tests, made us lead to build a Python library called SarPair. It is an interferometric SAR oriented module, based on EOReader to simplify the data ingestion and SNAP for the SAR processing. On the other hand, we developed another Python module running U-Net convolutional network based on Tensorflow.

Both modules have then been linked together in a Docker to get a full pipeline from SAR images to the urban flood extraction. At the end we can now, thanks to open source SAR data and libraries, monitor any urban flood in the world with a simple click.

Remote sensing engineer, SAR specialist.

In this talk we will explore Tile38, Fast API briefly, and how to combine them to create quick APIs for delivering geospatial data.

Parkopedia is the world's leading parking services provider. It provides parking related data products to companies ranging from Apple to VW.

Parkopedia products and features require fast geospatial queries to function, such as, accessing information about parking spaces along routes, and within an area. While Redis provides fast geospatial queries, and has good scalability, only point geometries can be stored and can only perform relatively simple queries. Databases such as Postgres with PostGIS and MySQL allow for more complex geospatial queries, however, they are relatively slow and have trouble scaling.

Tile38 is an in-memory database that supports advanced geospatial queries. Complete geometries can be stored, and it has the capability to perform intersects and within queries, as well as many more features. The queries retrieve the geometries as well as ancillary information. The performance and scalability is on another level in comparison to traditional relational database solutions, and on par with Redis.

Fast API is a modern web framework for creating APIs with Python. It is fast in terms of both performance as well as development speed, is self documenting and in general is a pleasure to use.

In this talk we will explore these individual technologies, benchmark the performance against alternatives, and walkthrough creating a web API that wraps Tile38.

A run through a PyTorch-based tool for generating clouds in satellite images.

This talk will outline the key challenges associated with the presence of clouds in satellite imagery in the context of training and evaluating machine learning models.

As one part of the solution, the tool for efficient simulation of clouds and cloud shadows in satellite imagery is presented here. Specific features of the SatelliteCloudGenerator will be outlined and demonstrated, with tips on how to control the appearance of the generated clouds.

Finally examples of how simulated clouds can be used for both training and evaluating satellite image processing models will be shown.

⚙️ All code presented during the talk will be available publicly as Google Colab notebooks. Software used for the demonstration will be based in PyTorch, PyTorch Lightning, Numpy.

Mikolaj is a final-year PhD student at the University of Strathclyde in Glasgow. His work extends over a range of topics, including radar signal analysis, remote sensing and general computer vision problems; such as generative modelling, image inverse problems, and learning in low-data regimes.

An overview of Python libraries that produce Digital Surface Models (DSMs) from stereo satellite imagery

The NASA Ames Stereo Pipeline (ASP) is the canonical open source software to process stereo images captured by satellites into digital elevation models for terrain visualization and scientific analysis. In the last several years, individual researchers and teams have developed new Python libraries, such as S2P, to reconstruct 3D elevation data from stereo satellite imagery. Some tools are designed for massive scalability and built on top of modern libraries like xarray and dask, while other tools are focused on identifying and processing widely-available Planet imagery. This talk, inspired by a call for advice on generating digital elevation models from Planet data, focuses on approaches to processing openly-licensed Planet stereo imagery with various Python libraries.

Yoni Nachmany is a geospatial software developer experienced in building data pipelines to power maps and passionate about innovative storytelling with satellite data. As an R&D Engineer at The New York Times, Yoni scaled up the digitization of archival newspapers and explored experimental 3D mapping with photogrammetry and stereogrammetry. Previously, he processed and visualized satellite and aerial imagery as an engineer on Mapbox's Raster team. Yoni participated in the Data Science for Social Good Fellowship after graduating from the University of Pennsylvania with a Master's in Data Science.

Using geospatial analytics tools of geopython and ML , Earth Observations, we identify climate change risks on energy sources and effect on communities and urban smart cities development

Using geospatial analytics tools of geopython and ML , Earth Observations, we identify climate change risks on energy sources and effect on communities and urban smart cities development

Abdul Khaleq Al-Qasaily is a global Venture architect , global business mentor, serial entrepreneur with more than 22 years of experience in Geospatial Tech, GIS and Remote Sensing business strategy and management, project management and international business growth. He is a conceptual thinker with the vision to see issues strategically and has an experience of working in an international environment He has the following key expertise : - Spatial Data Science - Geospatial Analytics - AI , Machine Learning and Deep Learning - Business Strategy, - Geospatial Technology Specialist and GIS & Remote Sensing Consultant & Trainer - Serial Entrepreneur, Venture Builder - Certified International Entrepreneurial Coach and Mentor , ILM , UK - Accredited and Qualified Global Mentor for Startups, Scaleups and SME , WBAF - Creative, entrepreneurial, innovative, visionary leader with 21 years of experience in business management , focusing on DeepTech, big data, AI, GIS, Cybersecurity , IoT, and Renewable Energy . - Mentoring , Coaching and Training for many companies, entrepreneurs , startups , incubators and accelerators worldwide such as WBAF fundraising stage, ImagineTomorrow, TakeOff International, Seedstars, World leaders Startups Award, ..etc - Strong experiences on GIS Consultancy services and projects Management - Solid Experience on geospatial products (ESRI ArcGIS products, QGIS, PostgreSQL , PostGIS, ERDAS Imagine, ENVI,IDRISI, Python GIS,R , Carto, Altryx, Spatial SQL,....etc..) - Knowledge on Spatial Database Infrastructure (SDI) and Geospatial Database Management (GDM).

Do you use data visualization to understand data and tell stories? Do you need to visualize big geospatial datasets? Are you interested in leveling up your visualization skills with HoloViz? HoloViz is a high-level Python visualization ecosystem that gives you the superpower to help you understand your data at every stage needed.

In this talk, you will learn how to build visualizations easily even for big and multidimensional data, how to build visualizations for geospatial data, how to turn nearly any notebook into a deployable dashboard, and how to build interactive drill-down exploratory tools for your data and models without having to run a web-technology software development project. You will also learn how to turn your dashboard into WebAssembly and run your dashboard entirely in the browser with the magic of Pyodide and PyScript.

Sophia Yang is a Senior Data Scientist and a Developer Advocate at Anaconda. She is passionate about the data science community and the Python open-source community. She is the author of multiple Python open-source libraries such as condastats, cranlogs, PyPowerUp, intake-stripe, and intake-salesforce. She serves on the Steering Committee and the Code of Conduct Committee of the Python open-source visualization system HoloViz. She also volunteers at NumFOCUS, PyData, and SciPy conferences. She holds an M.S. in Computer Science, M.S. in Statistics, and Ph.D. in Educational Psychology from The University of Texas at Austin.

The Open Earth Engine Library (OEEL) is a collection of code goodies for Google Earth Engine (GEE) build on top of the JavaScript API. But recently a feature was added to "map" all this function and most other JavaScript functions in Python.

Since the start of GEE, users try to deal with the double language Python and JavaScript and port codes between them. If the syntax is relatively similar, the small variation make this task cumbersome. Over the years multiples attempt were done to try to automatically convert script between languages, with some but limited success. The Open Earth Engine Library (OEEL) is an open-source collection of code goodies for Google Earth Engine (GEE) build on top of the JavaScript API and used by thousands of practitioners. To allow the use of this library to transparently use this it from pythons, and interface with nodeJs in the background was created, resulting in an unexpected result. It allows to use almost any GEE-JS code in Python.

Map, Analyze, and Forecast your underground infrastructure using Subterra imaging solutions and our Terralytics™ Cloud Platform.

Join us as we delve into the exciting world of underground infrastructure mapping and digitization. Discover how Subterra's cutting-edge techniques and proprietary multimodal algorithms revolutionize how we understand and protect our underground assets. Learn how we use a combination of GIS data, images, point clouds, and unstructured data to gain valuable insights and prevent failures. This talk is a must-attend for anyone looking to stay ahead of the curve in underground infrastructure management and risk reduction.

I'm Adonaí Vera, a Machine Learning Engineer with five years of experience creating computer vision models and machine learning algorithms, testing and deploying models in production using tools like TensorFlow, Docker, OpenCV, Git, Kubernetes, and more. 🚀...

I have been a software developer, AI developer, AI Leader, and CTO in different companies, which has given me a vision of creating AI products with a customer focus 🌎 Besides, I’m one of the 10 TensorFlow certified Developers for Google in Colombia, author of courses as “Curso Profesional de Redes neuronal con TensorFlow”, and “Curso Profesional de computer vision con TensorFlow” in Platzi and winner of the hackathon Covid19 and Innovate2019 with Ecopetrol Colombia 🌟

Role: Machine Learning Engineer at Subterra AI

The field of GAN based generation of text has been extended to images with stable diffusion and even 3D with NVIDIA's GET3D. I'll present the newest findings and some possible applications in BIM and GEO-Visualisation

stable diffusion

I present an existing technique applied to relevant fields Stable diffusion is based on many recently developed techniques such as auto-encoders, generative-adversarial networks and natural language processing. Those fields have all recently made significant advances, allowing for application to many fields including 3D Models and maps. The pipeline consists of a text encoder using the CLIP tokenizer to understand the tokens in the text and generate a starting point of mostly noise for the later generators. The first generator and diffuser is a UNet and Scheduler, which inpaints the noise until a meaningful pile of data is formed. The Image decoder then decodes that information into actual pixel values.

Dream Textures

Using the stable-diffusion-2-depth model from huggingface, carson implemented a blender plugin, allowing depth based image generation on any 3D surface using a simple prompt. Here we use other techniques like in- and outpainting to stitch surfaces together, change existing textures and extend on already existing ones. This model has an additional input channel compared to stable-diffusion-2 for the depth-parameter. This uses the viewport distance of the surfaces in Blender. Alternatively from an existing image the depths can be extracted using MiDaS (dpt_hybrid). This is a first step towards photo-grammetry aka model generation from images.

Application

Some examples are shown displaying the workflow and possibilities for rapid prototyping and texturing of 3D (IFC) Models and Landscapes. The plugin also offers the ability to fine-tune existing or generated textures towards an input phrase. Strengths of this method include deployment speed, minimal effort, adaptability. As is customary with new AI art, the images might not fit the textures, have various artifact, need multiple generation attempts to find a satisfying image and do require quite some hardware resources. This adds to the resources already required by blender et al.

Disclaimer

All models/weights are for research purposes only

Machine-Learning and NLP Enthusiast Blender Beginner

In this talk, we will demonstrate our patented, learning-based technology (MapScale) for automated conversion of technical drawings to indoor maps.

MapScale is a learning-based patented technology (Pointr Inc.) which takes architectural floor plans and convert them into semantically classified indoor maps. With this talk, we want to share the interesting challenges we faced and how we overcome these challenges with the help of the geo-python community. We approach the problem of automated conversion of technical drawings as a computer vision problem combined with classical geospatial techniques. Our pipeline includes but not limited to state-of-the-art object detection, object segmentation and textual information processing algorithms. We will also explain how we managed to have scalable deployments of such geospatial pipelines. Finally, we will explain our solution to maintain the pipeline from a MLOps point-of-view.

How to measure the long-term evolution of urban landscapes? We present our ongoing work on geohistorical urban data to visualize and analyze the dynamics of urban settlements using Python-based tools.

With a steadily increasing proportion of the human population living in urban areas, a thorough understanding of urban systems and how they change is crucial to make our cities more sustainable, resilient, and efficient. For the implementation of such development goals, data-driven urban change monitoring and future predictions of land development, population growth, settlement, and urban expansion are important tools for urban and regional planners. Such prognostic tools are often informed by historical data measuring the evolution of urban systems, in order to infer future trends. However, historical geospatial data on the built environment prior to the 1980s is rare, which often limits the observational window on urbanization processes to the era of remote sensing-based earth observation. To account for this gap, we leverage increasingly available (open) cadastral parcel and property data including building construction dates, building footprint data, and road network data to create geospatial datasets measuring human settlement trends over long time periods, i.e., over 100 to 200 years. Specifically, we exploit vast amounts of building construction dates (available for over 200 million buildings in the U.S. and selected European countries) to generate gridded surfaces of historical built-up areas from 1900 to 2020, at unprecedented spatial and temporal granularity. In addition, while these datasets provide new insights into the long-term spatial development of cities, towns, and villages, they require novel statistical and visual-analytical approaches to fully exploit the potential of such data. In this talk, we will showcase our Python-based toolsets for efficient data aggregation and integration, innovative data modeling and analysis, as well as novel ways to visualize long-term urban development trajectories using static and animated (geo)visualization techniques.

This study provides the first analysis of the open source software ecosystem in the field of sustainability and climate technology. Thousands of actively developed open source projects and organizations were collected and systematically analyzed using qualitative and quantitative methods as part of the Open Sustainable Technology project.

The transition to a more sustainable future requires not only technological innovation, but also new opportunities for society to participate in the development and adoption of technologies. Open source culture has demonstrated how transparent and collaborative innovation can support modern digital services, data and infrastructure. Open Source Software accelerates the transition to a sustainable economy by supporting traceable decision-making, building capacity for localisation and customisation of climate technologies, and most importantly, helping to prevent greenwashing. Despite the transformative impact of open source culture, its potential for developing environmentally sustainable technologies is not well understood.

This study provides the first analysis of the open source software ecosystem in the field of sustainability and climate technology. Thousands of actively developed open source projects and organizations were collected and systematically analyzed using qualitative and quantitative methods as part of the Open Sustainable Technology project. The analysis covers multiple dimensions – including the technical, the social, and the organisational. It highlights key risks and challenges for users, developers, and decision-makers as well as opportunities for more systemic collaboration. Based on these unique insights, we were also able to define the Open Sustainability Principles that embody open source in sustainability.

This analysis indicates that open source still plays a minor role as a long-term transformation strategy in sustainability compared to other domains. Half of all identified projects are in data-rich fields such as climate science, biosphere, energy system modelling, transportation and buildings. Other topics, such as carbon offsets, battery technology, sustainable investment, emission observation and integrated assessment modelling, show few notable developments. Newly emerging topics such as green software were identified based on popularity growth. Most identified projects are relatively young, with a median age of 4.45 years. Moreover, programming languages Python and R dominate the ecosystem, and permissive licences such as MIT are preferred, followed by copyleft licence GPLv3.

Analysis of the distribution of knowledge, work, and project governance reveals that small open source communities lead most of the development. On average, Open Source Software projects rely heavily on a single developer responsible for ~70% of the contributions to a project. In addition, academia and several government agencies contribute significantly to open source, while the lack of for-profit organisations and start-ups with open source business models is remarkable. Finally, most Open Source Software projects are based largely in Europe and North America, with a small number of projects from the Global South. Larger development efforts by organisations based in India and China are underrepresented or nonexistent.

This report presents the first-of-its-kind analysis of open source technology in sustainability, providing the empirical backbone for guiding community building, policy development and future investment. Based on this analysis, we, therefore, propose recommendations for those interested in supporting Open Source Software in environmental sustainability more effectively via:

• Strengthening the interconnectivity and knowledge exchange of the identified open source communities.
• Building capacity and increasing potential for real-world impact by connecting projects to local use cases.
• Closing the knowledge gap on the environmental impact of companies through open source principles.
• Adapting and extending existing open source projects for underrepresented countries in the global south.
• Creating incubators and other support programmes for open source software in environmental sustainability as well as dedicated funds that provide core funding for development and maintenance.
• Developing better technical interfaces between platforms, data, models and open source tools across and within sectors to “stop reinventing the wheel”.
• Standardising environmental data exchange across different levels of government.
• Transforming financial institutions through transparent and scientific decision-making for sustainable investments.

In conclusion, we are convinced that digital and sustainable transformation must converge as a digital public good if we are to achieve agreed environmental goals and create a safe and equitable corridor for people and the planet. Open sustainability principles can help governments, research institutes, nongovernmental organizations, and businesses move quickly toward science-based decarbonization and conservation of natural resources and ecosystems by providing critical transparency, traceable decision-making, and collaboration on innovation.

Aerospace engineer working in the field of open environmental intelligence and earth observation

A Python-based data integration platform enables cross-border access to 3D buildings datasets, critical for renewable energy-related use cases.

Geospatially Enabled Ecosystem for Europe (GeoE3, geoe3.eu) project has developed a Python-based data integration platform. The platform provides a single point of access to geospatial content from five European countries. The datasets available via the platform are determined by the selected use cases that relate for example to buildings and renewable energy.

The GeoE3 integration platform provides access to content via services conforming to the OGC API family of service interface standards and works as a proxy for the national level legacy services. The technical implementation of the integration platform is based on Python programming. In the core of the platform is pygeoapi, a Python-based implementation of the OGC API standards. The user interface available on the platform is based on pygeoapi’s Jinja2 template engine and has been adapted to use the web mapping library OpenLayers.

The GeoE3 integration platform implements standards: OGC API Features, OGC API Coverages, OGC API Processes and OGC API Records. The OGC API Features standard has been adapted to follow the traditional zoomable map metaphor, with the help of a generic background map. The datasets accessed from the participating countries are treated as data collections inside a single OGC API Features or OGC API Coverages service instance. This arrangement creates a natural framework for cross-border data integration.

Due to the selected use cases, 3D modelled buildings are regarded as an important dataset for GeoE3. Some of the NMCAs in the participating countries already provide a nation-wide LOD2 buildings dataset. In some countries the production is ongoing. For the rest of the countries GeoE3 integration platform offers an on-the-fly OGC API Processes conformant processing service that dynamically generates LOD1 building models from 2D footprints and DTM- or attributes-based height information. With this arrangement, 3D representation of buildings is now available from all the participating countries, enabling cross-border 3D visualizations to be made.

The presentation details the use of various Python libraries on the integration platform. These include for instance rasterio, owslib, pyproj, Fiona, Matplotlib, NumPy etc.

Dr. (Tech) Lassi Lehto acts as a research manager at the Dept. of Geoinformatics and Cartography in the Finnish Geospatial Research Institute. His main research interests include geospatial network services and their interoperability, SDI architectures, and modelling of geographic information. He has been a member of the drafting team "Network Services" preparing implementing rules for the INSPIRE Directive of the European Union and has taken part in various EU-funded projects aimed at developing the Pan-European SDI.

Urban growth prediction in urban planning is a core parameter. In this talk, we present a way to predict the new urban boundary based on the prediction of the length of vectors and their rotational frequency using a neural network. The core idea is to take the boundary of the urban area as a Fourier series and therefore represent it as a sum of several rotating vector terms. The length of the vectors and the rotating frequency act as the training parameters for a neural network. The training parameters for the boundaries of years 2005, 2010, 2017, and 2022 are used to train the network. Then the trained network is used to predict the boundary of the year 2025.

The study area, Burewala, is situated in Punjab, Pakistan. Urban boundaries of the study area are available for 2005, 2010, 2017, and 2022. For master planning and urban planning, it is necessary to predict the urban boundary for the coming years. In this study, we consider the residential class only. Considering the spatial distribution and the expansion of the residential area in recent years, we predict its boundary.

The research methodology is based on the analysis of the Fourier series. We know that the Fourier series can be written as the sum of rotating vectors, with each vector having its length and rotation frequency. We consider the boundary polygon as a Fourier series; therefore, we transform it into rotating vectors. The tail of every vector is positioned at the head of the previous vector. The head of the last vector is tracing the boundary polygon. We train a neural network to compute the coordinates of the polygon using the length and frequency of the vectors. A trained network is able to predict the coordinates of the future boundary polygon.

Assistant professor at the Department of Space Science. The University of Punjab. Ph.D. from Uni-Stuttgart in Satellite Geodesy.

We discuss differences and correspondences between the R and Python spatial software ecosystems, upstream libraries, and efforts and opportunities to further mutually benefit each other.

R and Python are both used in spatial data science mostly for transient processing: data is read, results are computed, and numbers, tables or figures are created after which the process stops. Both benefit largely from the same set of upstream libraries for reading and writing (GDAL/OGR), geometric operations and spatial indexes (e.g. GEOS, s2geometry, h3), and coordinate conversion and transformation (PROJ), and this commonality creates a large amount of consensus across scientific and industry applications. Both also benefit from large but different sets of capacity that the respective language ecosystem brings. The ability to use both in an integrated setting, R in Python (r2py) or Python in R (reticulate) also increases, as do systems built to cater both languages e.g. for analysing satellite imagery archives (openEO) or scientific publishing (quarto). We will discuss the status quo, and future potential. A joint focus on emerging cloud-ready data formats (including Zarr, GeoParquet, GeoArrow) brings further synergies and might bring zero-copy data transfer between the languages.

I am a researcher in urban morphology and geographic data science focusing on quantitative analysis and classification of urban form, remote sensing, and AI. I am also the author of momepy, the open source urban morphology measuring toolkit for Python, and a member of the development teams of GeoPandas, the open source Python package for geographic data, and PySAL, the Python library for spatial analysis.

Edzer Pebesma is a spatial data scientist, and is professor at the Institute for Geoinformatics of the University of Muenster. He is author and maintainer of several R spatial packages since about 2 decades. He is an ordinary (elected) member of the R Foundation.

As businesses grow, many applications will at some point run into scaling issues — what works fine at low transaction, volumes don’t work well, or at all, at high volumes. Real-time technology solutions like the open-source Hazelcast Platform have helped many businesses overcome their scaling issues to provide high throughput and low latency at tremendous scale

As businesses grow, many applications will at some point run into scaling issues — what works fine at low transaction, volumes don’t work well, or at all, at high volumes. Real-time technology solutions like the open-source Hazelcast Platform have helped many businesses overcome their scaling issues to provide high throughput and low latency at tremendous scale. In this talk, we’ll focus on how Real-time compute APIs help leverage the processing capabilities of a distributed cluster, so you aren’t leaving large potential performance gains on the table. The combination of Real-time storage and computing provides a unique synergy that enables applications to address real-time use cases at any scale.

Fawaz Ghali is a Principal Developer Advocate at Hazelcast with 20+ years of experience in software development, machine learning and real-time intelligent applications. He holds a PhD in Computer Science and has worked in the private sector as well as Academia as a Researcher and Senior Lecturer. He has published over 46 scientific papers in the fields of machine learning and data science. His strengths and skills lie within the fields of low latency applications, IoT & Edge, distributed systems and cloud technologies.

Python and Artificial Intelligence techniques, including deep learning and convolutional neural networks, can be used to improve demographic modeling in times of crisis or rapid change. Using the crisis in Venezuela as a case study, I demonstrate the utility of this approach in informing response efforts and decision-making.

In this talk, I will present a case study on the use of Artificial Intelligence and Python to more accurately estimate population dynamics in crisis situations, using the situation in Venezuela as an example. Traditional methods of demography, such as statistical modeling and survey data, are often insufficient in situations of rapid change or crisis. However, by using AI and deep learning techniques, including convolutional neural networks (CNNs), to analyse satellite imagery, it is possible to gain a more nuanced and up-to-date understanding of population movements and demographics. I will demonstrate how this approach can be used to inform decision-making and aid in crisis response efforts, and discuss the potential for it to be applied in other contexts.

I am Lisah Khadiala Ligono, an Erasmus Mundus scholar currently studying the Copernicus Master in Digital Earth at Paris Lodron Universität Salzburg and Université Bretagne Sud. I am passionate about using artificial intelligence and data to understand and address complex problems, and I am excited to share my research and insights with the conference community.

Shapely 2.0 has finally arrived! Several years in the works, Shapely 2.0 is a major release, featuring a large refactor and fast, vectorized (element-wise) array operations along with many other improvements.

Shapely 2.0, recently released and several years in the works, is a major release featuring a complete refactor of the internals and new vectorized (element-wise) array operations providing considerable performance improvements, along with several breaking API changes and many feature improvements. As one of the fundamental geospatial libraries in Python, this is an important release for the geospatial ecosystem.

This presentation will highlight the main improvements of the release: the geometry objects (Point, LineString, Polygon, .. classes) are now immutable, hashable and non-iterable objects, making it a lot easier to work with numpy arrays of geometries. And now we can work with arrays of geometries, Shapely 2.0 provides vectorized (element-wise) versions of all spatial functions that: 1) give a considerable performance improvement , 2) release the GIL (allowing multithreading, e.g. in dask-geopandas), and 3) is simply easier than for loops. In addition, many new features from the latest GEOS versions are now exposed (fixed precision overlay functions, distance within, concave hull, ...).

Further, the presentation will provide some background about the release (and the integration of the PyGEOS package into Shapely) and give concrete upgrade tips.

I am a core contributor to Pandas and Apache Arrow, and maintainer of GeoPandas. I did a PhD at Ghent University and VITO in air quality research, worked at the Paris-Saclay Center for Data Science. Currently, I work at Voltron Data, contributing to Apache Arrow, and am a freelance teacher of python (pandas) at Ghent University.

Spherely provides Python/Numpy vectorized bindings to the S2Geometry library for the manipulation and analysis of spherical geometric objects. Complementary to Shapely 2.0, it may be used as a backend geometry engine for Python geospatial libraries like GeoPandas.

Not all geospatial data are best represented using a projected coordinate system. Unfortunately, the Python geospatial ecosystem is still lacking a general purpose library for efficient manipulation of geometric objects on the sphere. We introduce Spherely: a new Python library that fills this gap by providing bindings to S2Geometry, a mature and performant C++ library for spherical geometry that is widely used for indexing and processing geographic data, notably in popular database systems. Unlike S2Geometry’s SWIG wrappers or S2Sphere (pure-Python implementation), Spherely exposes its functionality via “universal” functions operating on n-dimensional Numpy arrays, therefore greatly reducing the overhead of the Python interpreter.

Spherely is still at an early stage of development. It aims at replicating the API of the Shapely (2.0) library that is used to manipulate planar geometric objects. This is done via S2Geography, a C++ library that has emerged from the R-spatial ecosystem and that provides a GEOS compatibility layer on top of S2Geometry. This API compatibility will allow seamless integration between Spherely and libraries that already rely on Shapely for performing geometric operations (like GeoPandas), hence extending their functionality to more robust and accurate manipulation of geographic data (i.e., using latitude and longitude coordinates).

Code repository: https://github.com/benbovy/s2shapely

Benoît Bovy is a freelance scientific software developer. He has a background in geoscience (geography, geology), is the maintainer of Fastscape (software tools for landscape evolution modelling) and is a regular contributor to the Python scientific / PyData stack (Xarray core developer).

Color plays a crucial role in visualizations in the sciences and a well-designed color map is important for inclusivity, effectiveness, and clear communication of information. While many software packages nowadays provide adequate pre-defined color maps and defaults, we will discuss strategies and introduce software for designing and evaluating customized color maps that are suitable for a wide range of tasks and applications.

Color is a fundamental aspect of many (geo-)data visualizations including topographic maps, choropleth maps, heat maps, as well as bar plots, scatter plots, and time series displays. The careful selection of colors can greatly enhance the appeal and communication of information in these graphics. Conversely, poor color choices can impede effective communication and lead to misunderstandings or confusion.

Recently, many software packages have begun providing a range of pre-defined color palettes and reasonable defaults for various data types and visualizations. Nevertheless, the principles for choosing better alternatives are not always well understood and poor palettes (such as the infamous "rainbow" or "jet") are still encountered in many situations.

Therefore, we will first discuss a set of strategies for selecting robust and inclusive color maps for different plot types. Subsequently, we will present a new Python package colorspace that enables the creation of robust custom color maps using the Hue-Chroma-Luminance (HCL) color model. Additionally, the package provides graphical tools for evaluating color maps regarding their effectiveness across a variety of applications and their suitability for viewers with color vision deficiencies.

About Achim Zeileis

Professor of Statistics at the Faculty of Economics and Statistics at Universität Innsbruck, Austria. He is co-author and maintainer of various R software packages, especially for flexible modeling and data visualization. He is co-editor-in-chief of the open-access Journal of Statistical Software and an ordinary member of the R Foundation.

About Reto Stauffer

Assistant Professor at the Department of Statistics and the Digital Science Center (DiSC) at Universität Innsbruck, Austria. His research is on the intersection of (geo/spatial) data science and atmospheric science, ranging from probabilistic modeling to data management, visualization, and applications, especially in weather forecasting. He is technical editor of the open-access Journal of Statistical Software.

Assistant Professor at the Department of Statistics and the Digital Science Center (DiSC) at Universität Innsbruck, Austria. His research is on the intersection of (geo/spatial) data science and atmospheric science, ranging from probabilistic modeling to data management, visualization, and applications, especially in weather forecasting. He is technical editor of the open-access Journal of Statistical Software.

A fully OpenSource Project-controlling Dashboard unifying GIS, IFC, construction schedule and object-level information

Current software/services only allow incoherent overlapping of information. We provide a datamodel detailing the needed connections for integration and management of the various data sources to achieve actual connections and meaningful relations. This allows management and coordinators a complete overview over the construction process. This includes comparing different sources to check the current progress and having all available information in one place. Having a local instance also allows them to establish a single-source of truth, be able to compare and merge new information for any part of the project.

We’re showing a first proof of concept of a website. It consists of multiple individual components which are modular as to be able to be replaced with a different view, a different library or another API endpoint. The backend consists of multiple modules. We utilize a PostGIS Database to serve both the GIS Data and additional object-level information, linked by each elements unique ID. The IFC files would be stored in a graph-database, enabling a good overview over inter-model relations and their attachment to different elements, overlapping models and child/parent models. Building schedule would also consist of tabular data, defining start and end dates, task names and any additional information such as hierarchy, dependency etc. For presentation we use Leaflet for GIS-Data, syncing markers and line-styles with the database. As a backdrop any opensource WMTS Server can be used (e.g. SwissTopo) The 3D Model is rendered in IFC.js, allowing for highlighting and interactivity. The building schedule will be presented as Gantt-Chart, with each timeframe having linked the IDs of the afflicted objects and the type of action: Build, teardown, move, modify, … The final product would allow a full overview over the planned 3D and 2D lifecycle of the object, possibly including interactions with other sites via an exposed REST API.

Machine-Learning and NLP Enthusiast Blender Beginner

New trends in the geospatial sector have motivated a restructuring of the UNIGIS Girona MSc GIS programme, and since 2020 we’ve been working hard on the design of new contents and subjects. In this talk we’ll show how new trends in the geospatial sector have motivated the redesign of our programme as well as Python’s role in this new approach.

SIGTE, the GIS and remote sensing Service of the University of Girona (https://udg.edu/en/sigte) is organizing the UNIGIS Girona MSc GIS distance learning programme.  

New trends in the geospatial sector have motivated a restructuring of the programme, and since 2020 when we presented the ‘Geoinformatics specialization’ in the GeoPython conference, we’ve been working hard on the design of new contents and subjects.  

The renovated programme will have a single itinerary, created to offer students the necessary competences to develop a career as geospatial data scientists.  

In this new approach, programming skills will play an important role. And Python will be clearly taught as the main language for data manipulation and processing.  

In this talk, we’ll focus on two subjects where Python will be fundamental: ‘GIS programming ’ and ‘Analysis and visualization of data for Earth Observation’.  

The first one is designed to introduce students to the use of Python for geospatial analysis, working with libraries as pygdal, fiona, shapely and pyproj, but also to create scrips on QGIS using PyQGIS.  

The second one, related to Earth Observation, has as purpose to work with Python libraries such as sentinelhub to search images on catalogs, but also with other Python libraries like PIL, NumPy, GEE o raster to analyse, visualize and process multispectral images.  

In conclusion, during the talk, we’ll show how new trends in the geospatial sector have motivated the redesign of our MSc GIS programme as well as Python’s role in this new approach.

Full Stack web developer and GIS Analyst at SIGTE (University of Girona). Working with open source technologies and co-organizer of 'Jornadas de SIG Libre', a Spanish FOSS4G event.

Urbantrips is an open-source library that takes information from a public transportation smart card payment system and produces origin-destination matrices and some KPIs for bus routes. Work behind this involves inferring destinations, creating chain trips and several spatial transformations using H3, and Pandas optimization and parallelization processes to make it more performant.

Public transportation was heavily affected by COVID, financially and in terms of ridership. Also, travel patterns shifted, with telecommuting and office relocations. Unlike rail and subway, bus networks can adapt to these changes. Urbantrips is an open-source tool that transportation agencies can use to measure how their bus system is performing in these stressful times. It may also suggest ways the network and its users can be better served by changes in the network.

We’ll use publicly available data from the Buenos Aires urban area (~17 million people), served by heavy rail, subway, and one of the largest bus systems in the world (19k buses). We’ll show a step-by-step of the alighting and drop-off estimation. Also, we’ll display how we use pandas optimization and parallelization processes, combined with H3 schema that allows us to conduct spatial processes like buffers and distances in a more efficient way. Finally, we’ll show our results and how these KPIs can be used to optimize the bus network in Buenos Aires, and can be also used in other cities.

In this talk, we present our journey in creating automated pipelines for data preparation and training GeoAI models.

Besides being responsible for land administration, the Dutch Cadaster is also the national mapping agency of The Netherlands. To address challenges related to topographic mapping like decreasing budgets and lack of trained experts in the future, automating as many processes as possible is a solution we are exploring.

In recent years, advances in GeoAI have made it possible to automate, or support, many of the manual processes involved in creating and maintaining topographic maps. In this talk, we present our journey in creating automated pipelines for data preparation and training GeoAI models. These models aim to improve the accuracy and efficiency of an otherwise labor-intensive process.

We will share how our deep learning models are trained with high resolution aerial photography and how we efficiently scale our (open source and Python based) pipelines to automatically detect features of interest nationwide. Specifically, we use GeoAI to perform object detection and instance segmentation. Examples of detected features are storage tanks, green houses, recreational housing, and forest trails.

These innovations allow our topographic experts to spend their time more efficiently. This enables us as the national mapping agency to achieve operational excellence and keep producing topographic maps more efficiently.

The aim of this talk is to showcase how one could using Python and QGIS to access and visualize Temporal geo data using the QGIS Temporal Controller Python API. The session will also provide guide on PyQGIS Temporal API, python scripting inside QGIS, how to build standalone python applications that uses and how to create QGIS python plugins that can help in access and visualization of the temporal geo-data.

QGIS is a freely downloadable open source GIS software suite that contains a desktop option, mobile, and web component. QGIS is free to download and use, it is released with a GPL v3 license which is a non commercial license allowing users to download and use it without concerns compared to other commercial GIS software.

Up to QGIS version 3.12 there was no core support for temporal data, users were required to install a plugin called TimeManager in order to visualize temporal data inside QGIS. Through a collaboration between the Canadian Government, Kartoza and North Road, efforts were made to add core support for temporal data inside QGIS. As a result the QGIS version 3.14 was released with a Temporal Controller feature which was now responsible for handling all the temporal layers inside QGIS.

QGIS has in core scripting support for the Python language, it also allows enhancement to its functionality through plugins that are written using Python language. Usage of the Python language in QGIS (PyQgis bindings) is achieved by using SIP and PyQt. Through the bindings QGIS has exposed it core functionality via PyQgis API that can be used create standalone python applications that can use QGIS features in making maps.

Using the new Temporal Controller API and the QGIS support for Python language users can add, access and analyze temporal geo-data inside QGIS.

This talk introduces the concept of vector data cubes - multi-dimensional arrays where at least one dimension is composed of vector geometries - and its implementation in Python within a new library Xvec, built on top of Xarray, Shapely 2.0 and GeoPandas.

Vector geospatial data, such as points, lines and polygons, are primarily stored in one-dimensional arrays; in Python, typically as a GeoPandas' GeoSeries column within a data frame. At the same time, raster data representing, among others, satellite imagery or digital terrain models (DTM) are multi-dimensional arrays with a number of dimensions being anywhere from 2 (e.g. DTM) to N (e.g. multi-spectral time series from Sentinel 2), in Python mostly captured as Xarray objects. The two, raster and vector, rarely meet, and if so, we either transform one to the other using rasterisation or vectorisation or link vector geometries to a raster index via a unique identifier. However, there is a space in between that would benefit from multi-dimensional arrays with support for vector geometry.

This talk presents a concept of vector data cubes - multi-dimensional arrays where at least one dimension is composed of vector geometries - and its implementation in Python using Xarray, Shapely 2.0 and GeoPandas under the hood. Using the new Xvec package extending Xarray's abilities, we can assign an array of vector geometries as dimension coordinates and use the geospatial capabilities within the Xarray object. A typical use case can be a time series of a land cover proportion per region, where one dimension is composed of vector region boundaries, other as land use classes and a third one capturing time. While the same can be stored as a long-form data frame, it is not an efficient format due to a large amount of data replication. Using the vector data cube instead brings both efficiency and convenience as the included vector dimension can be directly used for indexing, plotting, and other operations that depend on the vector data and for which we would need to switch between Xarray and GeoPandas.

I am a researcher in urban morphology and geographic data science focusing on quantitative analysis and classification of urban form, remote sensing, and AI. I am also the author of momepy, the open source urban morphology measuring toolkit for Python, and a member of the development teams of GeoPandas, the open source Python package for geographic data, and PySAL, the Python library for spatial analysis.

This workshop will explore the engineering aspects of machine learning, including best practices for designing and building machine learning systems. We will discuss the architecture of well-known machine learning platforms like Michelangelo at Uber, Bighead at Airbnb, and FB Learner at Facebook, and use MLFlow, Feast, Ray, Iceberg and Python to create an open-source version of these systems that can be used by tech startups. The complete process of training, deploying, monitoring, and testing machine learning models will be covered, as well as strategies for avoiding technical debt.

In this workshop, we will explore the key considerations for building and maintaining a successful machine-learning system. We will begin by discussing how to frame the problem and identify the appropriate machine-learning approach. Next, we will cover the importance of setting up a strong team with the necessary skills and resources. We will then delve into the infrastructure required for developing and training machine learning models, including the tools and platforms needed. Finally, we will discuss how to production and deploy the machine learning system, and the ongoing monitoring and maintenance required to ensure its continued success. By the end of this talk, attendees will have a roadmap for building and maintaining a machine-learning system that is reliable, accurate, and scalable.

Problem Framing in Machine Learning: Before diving into building a machine learning system, it is important to carefully consider how to frame the problem at hand. This includes identifying the appropriate machine learning approach (e.g. supervised, unsupervised, reinforcement learning), as well as defining the goals and metrics for success. It may also involve understanding the available data and determining whether it is sufficient and appropriate for the task. Careful problem framing is crucial for ensuring that the machine learning system is set up for success and can effectively solve the intended problem.

Setting up your Machine Learning Team: A machine learning project requires a diverse set of skills and resources, and it is important to assemble a team that can effectively collaborate and contributes to the project. This may include data scientists, engineers, and domain experts, as well as appropriate hardware and software resources. It is also important to establish clear roles and responsibilities within the team, as well as effective communication and collaboration processes.

Model Development Infrastructure: Training machine learning models requires access to appropriate data, computing resources, and tools. This may include setting up a data pipeline to access and prepare the data, as well as choosing a platform for training the models (e.g. cloud-based, on-premises). It is also important to consider the scalability of the infrastructure, as the model may need to be trained on larger datasets or deployed to serve a larger number of users.

Productionizing your Machine Learning System: Once the machine learning model has been developed and trained, it must be deployed in a production environment. This involves building the necessary infrastructure to serve the model (e.g. API servers, load balancers), as well as establishing processes for ongoing maintenance and updates. It is also important to consider issues such as latency, reliability, and security in the production environment.

Monitoring and Maintenance of your System: Deploying a machine learning system is not the end of the journey - ongoing monitoring and maintenance is crucial for ensuring its continued success. This may involve monitoring the system's performance and accuracy, as well as implementing regular updates and improvements. It is also important to establish processes for handling errors and failures and to have a plan in place for handling data drift or concept drift (changes in the distribution or characteristics of the data).

I enjoy coding and setting up Distributed/Data/ML systems with cool/motivated people rallying around a challenging effort that makes the world a better place. "It always seems impossible until it is done" & "You may say I'm a dreamer, but I'm not the only one" are catchphrases that I aspire to live by in the endeavors that I take part in.

In the last 8 years, I have worked with SW/Data/ML engineering teams distributed across multiple cities, countries, and continents and coordinating work over remote and asynchronous channels. I have been a flexible key technical player in multiple roles sometimes as a solo engineer/developer and in other cases coordinating the work of teams varying from 5 to up to 40+ engineers.

I had the privilege of working in diverse industries ranging from biomedical/pharma/vaccine research to cloud, fintech, and e-commerce/mobile. Along the way I had the opportunity to be awarded a patent(co-inventor) in distributed systems while working at Amazon / AWS, publish in a top academic journal and contribute to open-source software. I have recently also been very active as a speaker in ML/Tech conferences and meetups. I co-founded and bootstrapped (4+ years) successfully a startup (Afrisis) while in college, that developed software for data and survey management and sold software outsourcing services worldwide in fintech and m-health.

More recently I have authored a book on Machine Learning Engineering published by Packt.

Currently, I am the kind of CTO, that tries hard to write code every day. I enjoy traveling regularly between the main tech hubs where we have tech teams in Africa and feel the pulse of the innovation in the continent.

Links : Github: https://github.com/nlauchande Google Scholar: https://scholar.google.co.za/citations?user=VfFNjzkAAAAJ Patent : https://patents.justia.com/inventor/natu-lauchande Book : https://tinyurl.com/yr2c2tmp Blog: https://nlauchande.github.io/ Medium: https://medium.com/@nlauchande

In this workshop, you will learn about the various Python modules for processing geospatial data, including GDAL, Rasterio, Pyproj, Shapely, Folium, Fiona, OSMnx, Libpysal, Geopandas, Pydeck, Whitebox, ESDA, and Leaflet. You will gain hands-on experience working with real-world geospatial data and learn how to perform tasks such as reading and writing spatial data, reprojecting data, performing spatial analyses, and creating interactive maps. This tutorial is suitable for beginners as well as intermediate Python users who want to expand their knowledge in the field of geospatial data processing

Geospatial data, which refers to data that has a geographic component, is a crucial part of many fields, including geography, geography, urban planning, and environmental science. In this tutorial, you will learn about the various Python modules that are available for working with geospatial data.

We will start by introducing the GDAL (Geospatial Data Abstraction Library) and Rasterio modules, which are used for reading and writing raster data (data stored in a grid of cells, where each cell has a value). You will learn how to read and write common raster formats such as GeoTIFF and ESRI ASCII, as well as how to perform common raster operations such as resampling and reprojecting.

Next, we will cover the Pyproj module, which is used for performing coordinate system transformations. You will learn how to convert between different coordinate systems and how to perform common tasks such as converting latitude and longitude coordinates to UTM (Universal Transverse Mercator) coordinates.

After that, we will introduce the Shapely module, which is used for working with geometric objects in Python. You will learn how to create and manipulate points, lines, and polygons, as well as how to perform spatial operations such as intersection and union.

Then, we will cover the Folium module, which is used for creating interactive maps in Python. You will learn how to create simple maps, add markers and popups, and customize the appearance of your maps.

Next, we will introduce the Fiona module, which is used for reading and writing vector data (data stored as individual features, each with its own geometry and attributes). You will learn how to read and write common vector formats such as ESRI Shapefile and GeoJSON, as well as how to access and manipulate the attributes of vector features.

After that, we will cover the OSMnx module, which is used for working with OpenStreetMap data in Python. You will learn how to download and manipulate street networks, buildings, and other geospatial data from OpenStreetMap.

Next, we will introduce the Libpysal module, which is used for performing spatial statistics and econometrics in Python. You will learn how to calculate spatial weights, perform spatial autocorrelation tests, and estimate spatial econometric models.

Then, we will cover the Geopandas module, which is used for working with geospatial data in a Pandas DataFrame. You will learn how to load and manipulate vector data, perform spatial joins, and create choropleth maps.

After that, we will introduce the Pydeck module, which is used for creating interactive 3D maps in Python. You will learn how to create 3D point clouds, 3D building models, and other 3D geospatial visualizations.

Next, we will cover the Whitebox module, which is a powerful open-source GIS toolkit for performing geospatial data processing and analysis. You will learn how to use Whitebox to perform tasks such as raster reclassification, terrain analysis, and hydrological modeling.

Finally, we will introduce the ESDA (Exploratory Spatial Data Analysis) and LeafMap modules, which are used for exploring and visualizing spatial patterns and relationships in data. You will learn how to calculate spatial statistics such as Moran's I and local spatial autocorrelation statistics, and how to create interactive choropleth maps.

By the end of this tutorial, you will have a solid understanding of the various Python modules that are available for working with geospatial data and will have hands-on experience applying these tools to real-world data. This tutorial is suitable for beginners as well as intermediate Python users who want to expand their knowledge in the field of geospatial data processing.

With the help of current semi-supervised learning algorithms, we can classify aerial scenes using 4, 20, or 40 labeled examples per class and still obtain similar accuracies as training with numerous labeled examples. With this workshop, we want to show the semi-supervised learning algorithms currently available and how to use the repositories available for scene classification.

In recent years, Deep learning (DL) algorithms applications have acquired notability in the geoscience and Remote Sensing (RS) community for big data analysis. Likewise, scene classification is increasing in interest among researchers due to the applications of DL to RS. Three DL classifiers are predominant in scene classification, these are Autoencoders, Convolutional Neural Networks (CNN) based, and Generative Adversarial Networks (GAN) based. Yet, CNNs require numerous annotated samples for either pre-trained, fine-tuned, or trained from scratch.

To tackle this issue, we use semi-supervised learning (SSL) algorithms that are designed to use both labeled and unlabeled data. The main idea is that training on small yet well-chosen samples can perform as efficiently as a predictor trained on a larger number chosen at random. We used two datasets based on aerial imagery, the UCM dataset (Yang, Y., 2010) which contains 21 classes with a total of 100 images of 256x256 pixels for each class, and the AID dataset (Xia, G., 2016) with 30 classes of about 200 to 400 samples per class with a size of 600x600 pixels in each class.

For the experiments, we adopted the CVPR2022 PyTorch implementation of the Class Aware Contrastive Semi-Supervised Learning (Yang, F., et al., 2022). We adapted the configuration files available with the selected datasets, backbone, augmentations, and other hyperparameters. We executed the following experiments: fully supervised with 50% of the training data and supervised and semi-supervised models (fixmatch, comatch, and fixmatch+CCSSL) for 4 / 25 / 40 samples for both UCM and AID.

During the workshop, we’ll go through the strategic use of git to get the repository, an explanation of the usage of the code, setting up the anaconda environment, and the training of the algorithm. We’ll finalize the workshop with the implementation of the best model for scene classification with semi-supervised learning.

Itzá Hernández-Sequeira (@itzahs) is a specialist in applications of geospatial technologies for early warning systems such as drought and hurricane monitoring. She has combined her experience in Geographic Information Systems (GIS) and Remote Sensing with Agriculture by classifying types of crops from satellite images and Artificial Intelligence algorithms. Itzá is currently a Ph.D. candidate in Computer Science at the Institute of New Imaging Technologies (INIT) from Jaume I University.

This workshop will introduce the basics of EOmaps, a package that aims to simplify geographical data-analysis. You will learn how to create basic maps (plotting data, add features etc.) , and how you can directly use the maps as interactive data-analysis widgets.

EOmaps is a python-package built on top of matplotlib/cartopy that aims to speed-up and simplify visualization and analysis of geographical datasets.

During the workshop you will learn how to use EOmaps to achieve the following tasks:

🌍 Create maps from geographical datasets

• Work with small datasets (some data points) as well as large datasets (millions of data points)
• Structured (2D raster, GeoTIFF, NetCDF...) or unstructured data (lists of values and coordinates)
• Customize the map with features
• Use background-layers from a variety of Open-access WebMap services
• Add features from NaturalEarth
• Add Markers / Annotations / Lines / Scalebars / North-Arrows etc.
• Use inset-maps to highlight specific areas
• Arrange multiple maps/plots in one figure
• ...
• Export images

🌐 Use the maps as interactive data-analysis widgets

• Compare multiple map-layers
• Attach custom and pre-defined callbacks to interactively analyze your data

⚙ Prerequisites

• Basic python knowledge should be sufficient to participate in the workshop.

• We will use the (free and open-source) Spyder IDE for coding.
  (any other IDE that gives you an interactive IPython console should be fine as well!)

Here is a quick-guide to set-up all you need for the Workshop using the conda package-manager.

1. install miniconda (only if you don't have a working conda-installation)
2. open a terminal (on windows use Anaconda Prompt!) (see starting conda for help)
3. execute the following commands:
   • create a new environment named eomaps_workshop and install mamba conda create -n eomaps_workshop -c conda-forge python=3.9 mamba --yes
   • activate the environment conda activate eomaps_workshop
   • install eomaps, spyder and all required dependencies mamba install -c conda-forge eomaps spyder matplotlib netcdf4 rioxarray --yes

NOTE: EOmaps and its dependencies (matplotlib, pyqt, pyproj, cartopy, geopandas etc.) require several large open-source libraries (GDAL, PROJ, Qt5 etc.) so the installation might take a few minutes!

With the release of Shapely 2.0, the GeoPandas-based code that have been optimised years ago may no longer provide the best performance. This workshop will show you how to change that and write efficient and convenient GeoPandas code that uses the benefits of the latest developments in the Python geospatial ecosystem.

The Python geospatial ecosystem is constantly evolving, rushing towards better usability, new features, fewer bugs and increasing performance. As a result, the code that might have been optimised a few years ago may not provide the ideal experience today. Such a shift has recently happened in the GeoPandas world. After years of development, Shapely 2.0, a major refactoring of the famous Python wrapper of GEOS, came out in December 2022, switching the way how we think about vector geometry handling. From former scalar geometries requiring for-loops to go through, we can now interact with arrays of them in a performant vectorised manner. These developments directly affect how GeoPandas shall be used, which are the good practices and which are no longer up to speed.

This workshop will walk you through some more and some less common cases of GeoPandas-based code that was efficient prior to the Shapely 2.0 release but is behind today. We will explain what was happening under the hood before vs what is going on now, show you how to refactor your code to use the benefits of Shapely 2.0 and explain the best practices of working with GeoPandas in a way that is both convenient and performant. You can expect solutions for the easy tasks as well as deeper dives into advanced topics all the way to tips on how to write custom code that may be faster than GeoPandas itself.

I am a researcher in urban morphology and geographic data science focusing on quantitative analysis and classification of urban form, remote sensing, and AI. I am also the author of momepy, the open source urban morphology measuring toolkit for Python, and a member of the development teams of GeoPandas, the open source Python package for geographic data, and PySAL, the Python library for spatial analysis.