Interactive maps are a powerful tool for visualising geographical data and engaging users. Whether you're a beginner or an intermediate GIS (Geographic Information Systems) user, this guide will walk you through the process of creating dynamic, interactive maps that respond to user actions. We'll use a combination of PHP, JavaScript, CSS, HTML, GeoJSON and the Leaflet library to achieve this.

Prerequisites:
Before we begin creating interactive maps, make sure you have the following tools and knowledge:

1. Basic understanding of HTML, CSS, and JavaScript.
2. Familiarity with PHP for server-side scripting.
3. A code editor (e.g., Visual Studio Code, Sublime Text).
4. A web server (e.g., Apache, Nginx) for serving PHP files.

Setting Up Your Development Environment:

1. Install Leaflet: Start by downloading the Leaflet library and include it in your HTML file.

2. Create a New HTML File: Create an HTML file (e.g., `index.html`) where you'll build your interactive map.

Building the Interactive Map:

Let's create a simple interactive map with a few features:

1. Setting Up the Map:

​In your JavaScript file:

2. Adding Markers:

3. Adding PHP Data:

You can use PHP to make your map dynamic by fetching and displaying data from a server-side source. For example, you could use PHP to retrieve data from a database and display it as markers on the map.

4. Adding GeoJSON Data:

​Creating interactive maps that respond to user actions can be a rewarding experience for GIS enthusiasts. By combining PHP, JavaScript, CSS, HTML, and the Leaflet library, you can build powerful maps that engage your audience. This guide should serve as a starting point for both beginners and intermediate users of GIS. Explore further, experiment, and create maps that convey meaningful information and provide valuable user experiences.

Geographic Information Systems (GIS) have become an indispensable tool for professionals in various fields, from urban planning to environmental management. PHP, a versatile server-side scripting language, can be a valuable asset in building GIS applications. In this blog post, we'll explore the critical aspect of working with forms and user input in a GIS environment, focusing on the importance of validating and sanitizing user input for security. This guide is tailored for intermediate GIS users looking to enhance their PHP skills in this context.

Forms play a pivotal role in GIS applications, allowing users to input data, perform queries, and interact with maps. Whether you're creating a web-based GIS system or adding functionality to an existing one, PHP can help streamline the process of handling user input.

Form Validation: Ensuring Data Integrity
One of the primary responsibilities of a GIS application is to maintain data integrity. PHP's validation capabilities are invaluable in ensuring that users submit accurate and complete data. Here are some key considerations:

Client-side vs. Server-side Validation: While client-side validation can provide a smoother user experience, it's crucial to rely on server-side validation as the primary defence. Client-side validation can be bypassed, making server-side validation essential for security.

Data Type and Format Validation: Ensure that user input adheres to the expected data types and formats. For example, validate that latitude and longitude values are in the correct numerical format.

Range and Boundary Checks: Implement checks to ensure that input values fall within specified ranges. For instance, you can validate that a user-submitted coordinate lies within the geographic bounds of your map.

Input Sanitization: Guarding Against Security Threats
Beyond data integrity, security is a paramount concern when dealing with user input. Unsanitised user input can expose your GIS application to various vulnerabilities, including SQL injection and cross-site scripting (XSS) attacks. PHP offers several functions and techniques to mitigate these risks:

Escape User Input: Use functions like  mysqli_real_escape_string or prepared statements when interacting with a database. This prevents malicious SQL injection attempts.

HTML Entity Encoding: When displaying user input on web pages, encode it using htmlspecialchars to prevent XSS attacks. This ensures that any potential HTML or JavaScript within the input is treated as plain text.

File Upload Security: If your GIS application allows file uploads, enforce strict controls, such as limiting file types and performing server-side validation to check the uploaded files' integrity.

Regular Expressions: Employ regular expressions to validate and sanitize complex input, such as email addresses or URLs.

Best Practices for GIS Developers

Here are some best practices for GIS developers working with PHP and user input:

1. Modular Code: Break your code into modular functions or classes to handle different aspects of form processing, validation, and sanitization. This promotes code reusability and maintainability.

2. Error Handling: Implement robust error handling mechanisms to gracefully handle validation errors and provide meaningful feedback to users.

3. Logging: Maintain comprehensive logs of user input, especially when dealing with sensitive data or potentially malicious input. This can assist in troubleshooting and security audits.

4. Regular Updates: Keep your PHP version and libraries up to date to benefit from the latest security patches and enhancements.

​PHP can be a powerful ally for GIS developers when it comes to handling forms and user input. By mastering form validation and input sanitization techniques, you can not only ensure data integrity but also fortify your GIS application against security threats. Remember that security is an ongoing process, so stay vigilant and continuously update your knowledge to protect your GIS environment effectively.

In previous blog posts, we discussed the integration of PHP and JavaScript to create a Geographic Information System (GIS) form for entering latitude and longitude coordinates and displaying them on a map. Now, let's take it a step further by adding CSS (Cascading Style Sheets) to enhance the visual appeal and layout of our GIS form and map.

Code Example: Enhancing the GIS Form and Map

In this section, we'll provide you with a code example that demonstrates how to enhance your GIS form and map with CSS styling.

HTML Structure

With these CSS enhancements, our GIS form now looks polished and professional, offering an improved user experience. Users will find it easier to input latitude and longitude coordinates, and the submit button is visually appealing.

Geographic Information Systems (GIS) play a crucial role in various fields such as urban planning, environmental management, and location-based services. One common task in GIS is collecting and processing user input through web forms. In this beginner's guide, we will explore how to process form data with PHP, a server-side scripting language widely used for web development.

Understanding the Basics

Before we dive into the code, let's clarify a few fundamental concepts:

HTML Forms
HTML forms are a way for users to input data on a webpage. They consist of various input elements like text fields, checkboxes, radio buttons, and submit buttons. Users fill out these forms, and when they submit the data, it is sent to a server for processing.

PHP
PHP is a server-side scripting language that can handle form data, process it, and interact with databases. It is often used in conjunction with HTML to create dynamic web applications.

POST and GET Methods
HTML forms can use two primary methods to send data to the server: POST and GET. In this guide, we'll focus on the POST method, which is more secure and appropriate for handling sensitive information like user passwords.

Setting Up the HTML Form

Let's start by creating a simple HTML form that collects geographic data. For example, we'll create a form to collect a location name and coordinates (latitude and longitude):

In this code, we have created a simple HTML form with fields for name, latitude, and longitude. The action attribute specifies the PHP script that will process the data (in this case, `process_data.php`), and we've set the method attribute to "post" to use the POST method.

Processing Form Data with PHP

Now, let's create the PHP script `process_data.php` to handle the form data:

​In this PHP script, we first check if the request method is POST, which ensures that the form data is being submitted. We then use the `$_POST` superglobal to retrieve the values entered in the form fields and store them in variables.

Now, you can use this collected data for various GIS-related tasks, such as storing it in a database, performing spatial analysis, or displaying it on a map. In the following images we show the name, latitude and longitude fields completed.  Once the Submit button is pressed the process_data.php code displays the results in a new page.  Of course in a real application we would save this information to a relational database rather than just displaying the results.

​Processing form data with PHP is an essential skill for GIS beginners, as it allows you to gather user input and manipulate geographic information effectively.

​​

With this guide, you should have a solid foundation for creating HTML forms, collecting data, and using PHP to process and work with that data in your GIS applications. As you continue to explore GIS development, you'll find countless opportunities to leverage these skills to build powerful and interactive web-based geographic applications. Happy coding!

 If you are a complete beginner in the world of Geographic Information Systems (GIS) and looking to collect user input through web forms then this guide will take you through the basics of using PHP to create HTML forms for collecting user data. Whether you're building a GIS application, a survey tool, or any other web-based project, understanding how to create forms is an essential skill.

Why Use HTML Forms with PHP for GIS?

Before we dive into the nitty-gritty of building HTML forms with PHP, let's understand why this combination is so useful in the context of GIS applications.

1. User Interaction: GIS applications often require users to input location data, addresses, or other spatial information. HTML forms provide an interactive way for users to input this data.

2. Data Validation: PHP can be used to validate user input, ensuring that the data collected is accurate and adheres to predefined rules. This is crucial for maintaining data quality in GIS.

3. Data Processing: Once the user submits the form, PHP can process the data, perform calculations, or interact with GIS databases to generate relevant maps, reports, or visualisations.

4. Customisation: Using PHP, you can customise the form's appearance and behaviour to suit your specific GIS project's needs.

Now that we understand the importance of using PHP and HTML forms in GIS, let's look at the step-by-step process of creating one.

Step 1: Setting Up Your Development Environment

Before you start building your HTML form with PHP, make sure you have a development environment set up. You'll need a web server (like Apache), PHP installed, and a text editor for coding (e.g., Visual Studio Code, Sublime Text).

Step 2: Creating the HTML Form

Begin by creating an HTML file (e.g., index.html) and add the following code to create a simple form:

 Step 3: Creating the PHP Script

Create a new PHP file (e.g., process_form.php) to handle the form submission and data processing:

In this script, you can access the data submitted from the form using the `$_POST` superglobal. You can then perform any necessary validation or processing.

 Step 4: Testing Your Form

Start your web server and open your HTML form in a web browser (e.g., http://localhost/Location/index.html). Submit some data through the form to test it.

The user enters latitude and longitude to take the map from the default landing page to Blackpool!

By clicking on the Show on Map button the user is taken to the Blackpool map.

Clicking on the Store in Database button will save the latitude and longitude to a database.

 Step 5: Further Enhancements

As you become more comfortable with PHP and HTML forms, you can enhance your GIS application by adding features like data storage, user authentication, and more advanced form elements.

These are your first steps toward collecting user input for your GIS project using PHP and HTML forms. With practice, you'll be able to build more sophisticated forms and create powerful GIS applications that efficiently gather and process spatial data.

​Geographic Information Systems (GIS) play a crucial role in modern decision-making processes by allowing us to visualize, analyse, and interpret spatial data. QGIS (Quantum GIS) is a popular open-source GIS software that empowers users to create and manage spatial data easily. In this beginner-friendly guide, we'll explore how to query and filter spatial data from QGIS projects using PHP, a server-side scripting language. 

Prerequisites

Before we begin, you'll need to have the following in place:
1. QGIS Installed: Make sure you have QGIS installed on your computer. You can download it from the QGIS website.

2. PHP Installed: PHP should be installed on your server. You can download PHP from the PHP official website.

3. Spatial Data: You should have a QGIS project (.qgs) with spatial data layers that you want to query and filter.

Setting Up QGIS Project
1. Create or Open a QGIS Project: Launch QGIS and create a new project or open an existing one containing your spatial data layers.

2. Add Spatial Layers: Import or add the spatial data layers you want to work with into your project.

3.Save the Project: Save your QGIS project to ensure you don't lose any changes.

Writing PHP Code
Now, let's write some PHP code to query and filter the spatial data from your QGIS project. We'll use the OGR PHP library, which provides functions to work with geospatial data.

In this PHP code, we utilize the QGIS Server's Web Map Service (WMS) capabilities to request a map image. You should customize the parameters such as layer name, coordinate system (CRS), bounding box (BBOX), image dimensions (WIDTH and HEIGHT), and others to match your specific requirements.

Running the PHP Script

1. Save the code above in a .php file (e.g., query_spatial_data.php).
2. Upload the PHP file to your OSGeo4W apache web server.
3. Access the PHP script through a web browser or execute it via the command line.
4. You will see the map image saved in the current directory or receive a message if there's an issue

Conclusion
With this beginner's guide, you've learned how to query and filter spatial data from QGIS projects using PHP. GIS can be a powerful tool for various applications, including environmental analysis, urban planning, and more. As you become more comfortable with GIS and PHP, you can explore advanced techniques and further customize your spatial data workflows to suit your specific needs. ​

​Geographic Information Systems (GIS) have revolutionised the way we analyse and visualise spatial data. QGIS, an open-source GIS software, is a powerful tool for creating maps and conducting spatial analysis. One of the exciting features of QGIS is the ability to display your map layers on a web page, making your GIS projects accessible to a wider audience. In this beginner-friendly guide, we'll walk you through the process of displaying QGIS map layers on a web page.

What You'll Need
Before we dive into the step-by-step process, here's what you'll need:

1. QGIS Software: Make sure you have QGIS installed on your computer. You can download it for free from the official website.

2. GIS Data You'll need spatial data to create your map. QGIS supports a wide range of data formats, including shapefiles, GeoJSON, and more.

3. Web Hosting  You'll need a web hosting service to publish your map online. Many options are available, from free services like GitHub Pages to paid hosting platforms.

4. Basic HTML/CSS Knowledge: While not mandatory, some familiarity with HTML and CSS will be helpful for customizing the appearance of your web map.

Step 1: Prepare Your Data

1. Open QGIS and load the data layers you want to display on your web map.

2. Ensure that your data is projected correctly. Web maps typically use the WGS 84 (EPSG: 4326) or Web Mercator (EPSG: 3857) coordinate systems.

Step 2: Install and Configure the QGIS2Web Plugin

1. In QGIS, go to the 'Plugins' menu and select 'Manage and Install Plugins.'

2. Search for 'QGIS2Web' and click 'Install.' This plugin will help you export your map for the web.

3. Once installed, you can find the QGIS2Web plugin in the 'Web' menu.

Step 3: Customize Your Web Map

1. In the QGIS2Web plugin, you can customize various aspects of your web map, such as the base map, layer styling, and pop-up information.

2. Adjust the settings according to your preferences and project requirements.

Step 4: Export Your Web Map

1. After customizing your web map, click the 'Create a web map' button in the QGIS2Web plugin.

2. Choose the export format, such as Leaflet or OpenLayers. Both are popular JavaScript libraries for web mapping.

3. Specify the output folder where your web map files will be saved.

Step 5: Publish Your Web Map

1. Upload the contents of the output folder to your web hosting service. This typically involves using an FTP client or an online file manager provided by your hosting provider.

2. Ensure that your main HTML file (e.g., index.html) is in the root directory of your hosting space.

Step 6: Share Your Web Map

1. Once your files are uploaded, access your web map by visiting the URL of your hosted HTML file.

2. Share this URL with others to showcase your interactive QGIS map on the web.

Step 7: Additional Customization (Optional)

1. If you want to further customize the appearance and behaviour of your web map, you can edit the HTML and CSS files generated by QGIS2Web.

2. You can also explore additional JavaScript libraries, such as Mapbox or Leaflet plugins, to enhance your web map's functionality.

Conclusion

Displaying QGIS map layers on a web page is an excellent way to share your geographic data and insights with a broader audience. With the help of the QGIS2Web plugin and some basic web hosting knowledge, you can create interactive and informative web maps that engage your viewers. As you gain more experience, you can explore advanced features and expand your GIS capabilities.

Geographic Information Systems (GIS) have become an integral part of modern-day decision-making processes, aiding in understanding, analysing, and presenting spatial data. One of the powerful tools in the GIS realm is QGIS Server, which allows you to serve maps and spatial data over the web. If you're new to the subject of communicating with QGIS Server using PHP, fear not, as this blog will provide you with a beginner-friendly introduction.

Understanding QGIS Server:
QGIS Server is an open-source software that enables you to publish your QGIS projects as web services. This means you can create interactive maps and provide access to your spatial data through web applications. It is built on top of the QGIS desktop application, allowing you to utilize your existing QGIS projects and share them online.

Why Use PHP with QGIS Server:
PHP (Hypertext Preprocessor) is a widely-used scripting language that's especially suited for web development. When combined with QGIS Server, PHP can be used to create dynamic web applications that interact with and display maps and spatial data. It acts as a bridge between the user interface and the QGIS Server backend.

Setting Up the Environment:
Before you start communicating with QGIS Server using PHP, you need to ensure you have the right environment set up. This involves having QGIS Server installed on a server along with PHP support. You can choose to install these components separately or use a pre-packaged solution like OSGeo4W, which bundles both QGIS Server and PHP.

Making Your First PHP and QGIS Server Interaction:
Let's take a simple example of how you can use PHP to communicate with QGIS Server and display a basic map on a web page.

Step 1: Connecting to QGIS Server:
In your PHP file, you need to establish a connection to your QGIS Server using its REST API. This API allows you to request map images and other information. Use the `file_get_contents` function to make a request to the appropriate QGIS Server endpoint, like this:

Step 2: Displaying the Map:

After getting the response from QGIS Server, you can display the map image on your web page. You can use the `<img>` HTML tag and set the `src` attribute to the data you received from QGIS Server:

Step 3: Enhancing Interaction:
To create a more interactive experience, you can add parameters to your QGIS Server requests. For example, you can change the extent of the map, add layers, or change the output format.

Conclusion:
Communicating with QGIS Server using PHP opens up a world of possibilities for sharing and interacting with spatial data over the web. Whether you're creating simple map displays or building complex web GIS applications, understanding the basics of PHP-QGIS Server communication is a valuable skill. With this introductory knowledge, you're now equipped to explore more advanced features and create meaningful web-based GIS solutions.

In the realm of Geographic Information Systems (GIS), the fusion of spatial data and web technologies has given rise to dynamic geospatial web mapping. At the forefront of this revolution is the QGIS Server—an open-source solution that empowers GIS professionals and enthusiasts to share, publish, and interact with geospatial data through web applications. This blog serves as an introduction to the QGIS Server, shedding light on its capabilities and the endless possibilities it offers for geospatial data dissemination.

What is the QGIS Server?
The QGIS Server is a robust component of the QGIS suite—an open-source desktop GIS software. Unlike the QGIS desktop application, which focuses on creating, editing, and analysing geographic data, the QGIS Server specializes in serving this data to web clients. It allows users to access maps, perform spatial queries, and visualize data using a web browser interface.

Key Capabilities of the QGIS Server:
1. Web Map Publishing: The QGIS Server enables you to publish your QGIS projects as web maps that users can access remotely. This means you can share your geospatial insights with a global audience through a simple web interface.

2. Spatial Data Dissemination: The server offers a streamlined way to disseminate your spatial data to a broader audience. Whether you're presenting environmental data, city planning maps, or resource distribution, the QGIS Server simplifies access.

3. Customizable Web Maps: QGIS Server facilitates the creation of interactive and customizable web maps. You can enable users to toggle layers, zoom in on specific areas, and perform spatial analyses—all within the browser.

4. Geoprocessing Services: Beyond data visualization, the QGIS Server supports geoprocessing capabilities. Users can execute spatial analyses like buffering, clipping, and distance calculations directly through the web interface.

5. Open Standards: The server adheres to open web standards like OGC (Open Geospatial Consortium) protocols. This means compatibility with a wide range of web mapping clients and applications.

Getting Started with QGIS Server:
1. Install and Configure: Begin by setting up the QGIS Server on your chosen server environment. Configuration involves defining project paths, map layers, and access settings.

2. Publish Projects: Using QGIS Desktop, create your map projects with layers, styling, and symbology. Once prepared, you can publish these projects to the QGIS Server.

3. Access Web Maps: Users can access the published maps via a web browser. They can interact with the maps, query data, and explore geographic features.

QGIS Server: A Gateway to Geospatial Web Mapping:
In a world driven by data accessibility and visualization, the QGIS Server serves as a gateway to bring your geospatial insights to life. Whether you're an environmental scientist sharing climate data, a urban planner showcasing city development, or a GIS enthusiast conveying your geospatial discoveries, the QGIS Server empowers you to bridge the gap between your GIS projects and the online realm. As you explore its capabilities, you'll unlock a dynamic platform that transforms your spatial data into interactive, informative, and accessible web maps, opening new avenues for collaboration, engagement, and decision-making in the geospatial domain.

​In the dynamic landscape of Geographic Information Systems (GIS), where data is at the heart of informed decisions and spatial insights, mastering data management techniques is paramount. Enter arrays and associative arrays—powerful tools in the PHP toolkit that empower GIS enthusiasts to efficiently organize, manipulate, and visualize geospatial information. In this blog, we'll explore how arrays and associative arrays play a crucial role in GIS applications, enhancing data handling and paving the way for seamless spatial exploration.

Arrays: Organizing Spatial Information
Arrays are like digital containers that hold multiple values. In the GIS realm, where datasets can be vast and complex, arrays serve as invaluable assets. Imagine a scenario where you need to store the names of cities for a map visualization. An array can efficiently manage this data:

Here, the `$cities` array holds the names of cities, offering a structured and organized approach to data management.
​

​Associative arrays take array functionality to the next level by allowing you to associate values (attributes) with specific keys (identifiers). In a GIS environment, where attributes like population, elevation, and area are essential, associative arrays shine. Let's consider a scenario where you're working with geographic features and their attributes:

In this example, the `$cityData` associative array pairs city names with arrays containing population and elevation data. This approach allows for intuitive retrieval of attributes based on the city name.

Enhancing GIS Workflows
Arrays and associative arrays seamlessly integrate with common GIS workflows:

1. Data Storage: Arrays provide structured storage for geographic data, making it easier to manage and manipulate.

2. Spatial Queries: Associative arrays enable quick attribute retrieval for spatial queries and analyses.

3. Visualization: Arrays facilitate efficient data visualization by ensuring organized and accessible attribute information.

4. Dynamic Content: Arrays can dynamically populate maps with features, labels, and attribute-driven details.

Fostering Collaboration and Efficiency
In collaborative GIS projects, arrays are invaluable. Team members can contribute by creating and populating arrays with specific geographic data and attributes. This division of labour streamlines teamwork and ensures that the dataset remains coherent.

Conclusion: Empowering Geospatial Exploration
Arrays and associative arrays are pivotal instruments in the GIS toolkit, aiding in the organization, retrieval, and visualization of geospatial data. Whether you're managing lists of coordinates, populating maps with feature data, or associating attributes with geographic entities, arrays offer a structured approach to data handling. As a GIS enthusiast diving into PHP, remember that harnessing the potential of arrays and associative arrays is akin to creating an organized map for your code, enabling you to navigate the world of geospatial data with precision, efficiency, and enhanced insights.

In the realm of Geographic Information Systems (GIS), where data manipulation and spatial analysis reign supreme, harnessing the capabilities of PHP functions can be a game-changer. These functions serve as organized blocks of code that perform specific tasks, allowing GIS enthusiasts to create efficient and reusable scripts. In this article, we'll delve into the world of PHP functions and explore their significance in enhancing GIS applications.

What Are Functions and Why Do They Matter?
Functions in PHP act as modular units of code that encapsulate a specific set of actions. Just like GIS tools help dissect complex geospatial processes, functions simplify complex programming tasks. This modularity enhances code readability, reusability, and maintainability—essential attributes when dealing with intricate GIS data and operations.

Solving GIS Challenges with Custom Functions
Creating custom functions tailored to GIS needs unlocks a realm of possibilities. Imagine you frequently calculate distances between geographic points. Instead of writing the same code every time, you can create a function to handle this task:

This function encapsulates the distance calculation logic, making it easier to integrate into different parts of your GIS application without redundancy. This example PHP code snippet calculates the distance between two geographic points using the Haversine formula. This formula provides a relatively accurate calculation for distances between points on a sphere, like the Earth. Remember to replace the latitude and longitude values with the actual coordinates of the points you're calculating the distance for.
In the above code:
The `calculateDistance()` function takes four parameters: the latitude and longitude of the first point, and the latitude and longitude of the second point.
The function uses the Haversine formula to calculate the distance between the two points in kilometers.
The calculated distance is then displayed using the `echo` statement, rounded to two decimal places for a cleaner output.

Reusing Code for Enhanced Efficiency
When working with GIS data, tasks like data validation, coordinate transformations, and spatial queries are recurrent. Functions allow you to write these procedures once and reuse them throughout your application. For example, a function to validate geographic coordinates can ensure data integrity across different parts of your GIS project.

Fostering Collaborative Development
In collaborative GIS projects, functions streamline teamwork. Team members can contribute by creating functions to handle specific aspects of the application. This division of labour improves efficiency, as team members can focus on their specialized tasks while relying on others' functions.

Optimising Web Applications
Web-based GIS applications thrive on dynamic content and interactivity. Functions play a pivotal role here. For instance, a function that generates dynamic map markers based on attribute values can enhance data visualization and user engagement. A function can also facilitate dynamic SQL queries to retrieve relevant spatial data for display.

Maximizing Code Readability and Maintainability
GIS applications often involve intricate spatial algorithms and data processing. Functions provide a way to compartmentalize these complexities, leading to more readable code. If you encounter a bug or need to make changes, you can focus on the relevant function without disrupting the entire application.

Conclusion: Empowering GIS Applications with Functions
In the dynamic world of Geographic Information Systems, where data-driven decisions and spatial insights drive progress, PHP functions offer a gateway to efficient and effective coding. By creating custom functions tailored to GIS tasks, you elevate your application's efficiency, reusability, and collaborative potential. Whether you're calculating distances, transforming coordinates, or visualizing geospatial data, functions provide the building blocks to elevate your GIS application from concept to reality. As a GIS enthusiast venturing into PHP, remember that harnessing the power of functions is a step toward crafting dynamic, interactive, and impactful geospatial web experiences.