Module 6 - Working Geometries

Module 6 consisted of turning river data into a neat TXT file. The mission was simple—grab the coordinates and IDs for vertices in a shapefile. First, I set up my workspace, ready for action. With ArcPy as my trusty tool, I created a search cursor to fetch the OID, geometry (SHAPE@), and NAME fields. It felt like being a digital detective, diving into the shapefile to uncover hidden data gems.

With my search cursor ready, I opened the TXT file in write mode, eager to fill it with vertex data. Each feature got its own vertex ID counter, ensuring no vertex was left behind. As I looped through the features and their vertices, I felt like an explorer mapping out new territory. Extracting X and Y coordinates from each vertex was like finding coordinates on a treasure map. I wrote down the details OID, vertex ID, X coordinate, Y coordinate, and river name while also printing them to the console to keep tabs on my progress.

Finally, after capturing all the vertex data, I closed the TXT file and did a quick verification dance. The file looked great, filled with well-organized data ready for use. This exercise showed me that even technical tasks can be fun and rewarding. It was a great mix of learning and coding, proving that GIS programming can be productive and enjoyable.

Module 5 - Exploring & Manipulating Data

 This week's assignment focused on manipulating spatial data using ArcGIS Pro. The tasks involved creating a new file geodatabase, copying feature classes into this geodatabase, and using search cursors to extract data. One key challenge was handling the ExecuteError when creating the geodatabase, which was resolved by ensuring no other instances of ArcGIS Pro were accessing it and adding a check to delete the existing geodatabase if it already existed. Another challenge was correctly populating a dictionary with city names and populations, which required careful use of search cursors and print statements for debugging. 

The process highlighted the importance of error handling, proper cursor management, and the use of print statements for tracking progress. These techniques ensured smooth execution of the script and accurate results. By completing these tasks, we gained practical experience in working with geodatabases and manipulating spatial data using Python and ArcPy, essential skills for GIS programming.

Module 4 - Geoprocessing

In Module 4, I was reacclimated into the ArcGIS geoprocessing framework, exploring its significance and utility in spatial data analysis. Geoprocessing involves a series of actions that manipulate geographic data to produce desired results. Within ArcGIS, geoprocessing enables spatial analysis, modeling, and task automation using various tools. These tools are categorized into five types, System Tools, Built-in Tools, Custom Tools, Model Tools, and Script Tools. During the lab assignment, I had hands-on experience with different geoprocessing tools, which proved to be immensely valuable. I utilized ModelBuilder to create a step-by-step process where the model aimed to clip soil data to a basin extent, filter unsuitable farming areas, and generate a final output displaying suitable farming zones. Additionally,  I created a Python script to work with hospital data. First, I added XY coordinates to a shapefile called "hospitals" from my student drive. Then, I made a 1,000-meter buffer around each hospital. Finally, I combined all the buffers into one feature using the Dissolve tool. This script helps organize and analyze hospital data more effectively.

Module 3 - Debugging and Error Handling

 Script 1

For Part 1 of the assignment, the script had two errors that needed fixing to ensure it could run smoothly. After identifying and correcting these errors, the script successfully printed out the names of all fields on the parks.shp attribute table. I made sure to examine the attribute table in ArcGIS Pro beforehand to understand the expected output. 

Script 2

Moving on to Part 2. This script contained several errors and exceptions that needed addressing for it to run properly. Before running the script, I ensured that the required shapefiles were added to the ArcGIS Project TravisCountyAustinTX.aprx. After identifying and fixing the errors, the script successfully printed out the names of all layers in the project

Script 3

 Part 3 of the assignment had a script that intentionally contained an error that prevented part of it from running. Instead of fixing the error, I modified the script by adding try-except statements to catch any exceptions and print relevant error messages. The script had two parts: Part A, which encountered the error and printed an error statement stating the problem, and Part B, which ran successfully and printed out the name, data source, and spatial reference of each layer. 

Module 2- Python Fundamentals

In this week's module, we delved into Python programming basics. We got hands-on experience with string variables and practiced creating loops and conditional statements. Along the way, I encountered errors that required me to backtrack and revisit the material to pinpoint the root cause. Despite the challenges, I was able to get through each process. 

Module 1

The Zen of Python, by Tim Peters

Beautiful is better than ugly.
Explicit is better than implicit.
Simple is better than complex.
Complex is better than complicated.
Flat is better than nested.
Sparse is better than dense.
Readability counts.
Special cases aren't special enough to break the rules.
Although practicality beats purity.
Errors should never pass silently.
Unless explicitly silenced.
In the face of ambiguity, refuse the temptation to guess.
Namespaces are one honking great idea -- let's do more of those!
There should be one-- and preferably only one --obvious way to do it.
Now is better than never.
Although that way may not be obvious at first unless you're Dutch.
If the implementation is hard to explain, it's a bad idea.
Although never is often better than *right* now.
If the implementation is easy to explain, it may be a good idea.

Tim Peters created a clever outline of key principles for writing Python code, emphasizing simplicity, clarity, and practicality. It helps to encourage programmers to prioritize readability and simplified solutions, avoiding overly complex approaches.

I began the process with 01E Environments Flowcharts pdf.  I familiarized myself with different Python environments, including IDLE and ArcGIS Notebooks. I followed the instructions to interact with the Python interpreter using IDLE, running simple Python commands and scripts. Then, I opened ArcGIS Notebooks within ArcGIS Pro, and relearned how to create and execute Python code within the GIS environment. There was a learning curve with this section as I have not touched Python within ArcGIS Pro.

Then I jumped to Algorithmic Thinking with Flowcharting to create a flow chart for "degrees = radians * 180 / pi" using Untitled Diagram - draw.io (diagrams.net). After completing that, I accessed The Zen of Python within ArcGIS Pro.

I ran into several challenges in understanding some of the concepts, but was able to go back and reread instructions to help clarify my questions.

Bivariate Choropleth Mapping

Bivariate choropleth mapping offers a dynamic approach to visualizing the relationship between two variables across geographical regions. Unlike traditional choropleth maps, which depict only one variable, bivariate maps use two color ramps to simultaneously represent two variables, revealing spatial patterns and correlations in a visually intuitive manner. By overlaying data sets, bivariate maps enable users to identify regions with similar trends, disparities, or inverse relationships, empowering researchers, policymakers, and data enthusiasts to gain deeper insights into complex phenomena.

 These maps find applications across diverse fields, including public health, environmental science, urban planning, and social economics. From illustrating the impact of pollution on respiratory illness rates to highlighting disparities in access to transportation infrastructure and socioeconomic status, bivariate choropleth maps facilitate informed decision-making by providing a comprehensive view of spatial data relationships. By following best practices in map design, users can effectively communicate their findings and engage audiences in meaningful discussions, unlocking valuable insights and driving positive changes.