Module 3 - Coastal Flooding

 Coastal flooding is one of the most destructive hazards associated with hurricanes, making accurate flood modeling an important component of emergency planning and disaster response. In this lab, I used ArcGIS Pro and LiDAR-derived elevation data to evaluate the potential impacts of Hurricane Sandy and model storm surge flooding in coastal communities.

The project began by comparing pre- and post-Hurricane Sandy LiDAR data to identify changes in elevation caused by erosion and deposition. Elevation models were created from the LiDAR point clouds and compared to produce an elevation change raster. This provided a visual representation of how the coastline changed as a result of the storm and demonstrated the value of high-resolution elevation data for identifying subtle landscape changes.

The next phase focused on modeling a potential 2-meter storm surge. Using raster reclassification and polygon conversion tools, I identified low-lying areas that could potentially be inundated during a coastal storm. The results were clipped to Cape May County and analyzed to estimate the percentage of the county that could be affected by flooding. During this process, I also compared calculated areas with published county statistics, reinforcing the importance of understanding dataset sources, metadata, and how different boundary definitions can influence GIS results.

The final analysis compared building impacts using a LiDAR-derived DEM and a lower-resolution USGS DEM. The comparison clearly demonstrated that elevation data resolution has a significant effect on flood modeling results. The LiDAR model produced a more realistic estimate of impacted structures, while the lower-resolution DEM substantially overestimated flooding in several building categories.

Overall, this exercise demonstrated that GIS is much more than producing maps. Reliable hazard analysis depends on selecting appropriate datasets, understanding the assumptions built into analytical models, validating results, and recognizing the limitations of spatial data. These skills are essential for supporting informed decision-making before, during, and after coastal disasters.

 

Module 2 Blog: Exploring Forestry and LiDAR in ArcGIS Pro

This week's Forestry and LiDAR lab gave me a much better understanding of how LiDAR data can be transformed into meaningful information about a forest. Before this exercise, I understood that LiDAR produced millions of elevation points, but I had not fully appreciated how those points could be processed into different datasets that each answer a unique question about the landscape.

One of the most interesting parts of the lab was comparing the Digital Elevation Model (DEM) and the Digital Surface Model (DSM). Although they are created from the same LiDAR dataset, they represent two very different views of the landscape. The DEM shows the bare-earth terrain after vegetation has been removed, while the DSM represents the highest surfaces, including trees and other objects. Creating the Height raster by subtracting the DEM from the DSM made it much easier to visualize vegetation height across the entire study area.

Another valuable aspect of the lab was calculating canopy density. The workflow required separating ground and vegetation returns, converting them to raster datasets, and using several raster analysis tools to calculate the proportion of vegetation within each cell. This process demonstrated how relatively simple geoprocessing tools can be combined to produce a useful management product. The canopy density map clearly identified dense forest stands, roads, and open areas, illustrating how LiDAR can support forestry applications such as habitat assessment, forest inventory, and monitoring disturbance.

One challenge I encountered was learning how to present the results effectively. Choosing appropriate symbology required some experimentation because the default display settings did not always highlight the differences I wanted to emphasize. Adjusting color ramps, transparency, and stretch settings significantly improved the readability of the Height, DEM, and canopy density maps. This reinforced the importance of cartographic design, since even accurate analyses can be difficult to interpret if they are not displayed effectively.

Overall, this lab strengthened both my technical and analytical GIS skills. I gained experience working with LiDAR datasets, raster processing, and 3D visualization while also learning how to communicate results through professional map layouts. I can see how these techniques would be valuable in forestry, environmental management, emergency management, and natural resource planning, where understanding terrain and vegetation patterns is essential for informed decision-making.

 

Module 1 Blog Post: Crime Analysis and Hotspot Mapping in ArcGIS Pro

This week's lab provided an excellent opportunity to compare several commonly used crime mapping techniques while reinforcing many of the spatial analysis tools available in ArcGIS Pro. Although each exercise built on concepts introduced earlier in the course, this lab demonstrated how different analytical approaches can influence the way crime patterns are interpreted and how those results might be used to support decision-making.

The first part of the exercise focused on creating a choropleth map displaying burglary rates throughout Washington, DC. Rather than simply symbolizing raw crime counts, this map represented burglary rates by census tract, making it easier to compare areas of different population sizes. I spent time adjusting the classification method, color ramp, and map layout to create a product that was both accurate and visually balanced. Adding the required cartographic elements—including the title, legend, north arrow, scale bar, projection, author information, and data sources—reinforced the importance of creating maps that effectively communicate information to an audience instead of simply displaying data.

---

The second portion of the lab introduced Kernel Density analysis using assault incidents. This technique creates a continuous surface that estimates where crime events are most concentrated by assigning greater influence to incidents located near the center of the search radius. After generating the density raster, I experimented with several classification methods and color ramps before selecting a six-class Natural Breaks (Jenks) classification that clearly emphasized the highest-density areas. This process demonstrated how cartographic choices can significantly improve the readability and interpretation of a map.

---

The final portion of the lab compared three different hotspot analysis techniques using Chicago homicide data. While all three methods attempted to identify areas with elevated concentrations of crime, each approached the problem differently.

The Grid Overlay method divided the study area into uniform grid cells and identified the cells containing the highest number of incidents. This approach was straightforward and easy to understand, but it also highlighted one of its limitations: the location of the grid boundaries can influence the results. Even small changes in grid placement could potentially change which locations are identified as hotspots.

---

The Kernel Density hotspot method produced a smooth surface that highlighted general areas of concentrated homicides rather than individual hotspot polygons. During this portion of the lab, I encountered a few challenges while converting the raster output into polygons and distinguishing between raster and vector datasets. Working through these issues improved my understanding of raster workflows and reinforced the importance of carefully managing intermediate outputs during spatial analysis.

---

The Local Moran's I analysis was particularly interesting because it identified statistically significant High-High clusters instead of simply locating areas with many incidents. After selecting only the High-High clusters and dissolving the results into a single hotspot feature, I compared this method with the Grid Overlay and Kernel Density approaches. Although all three methods identified a similar proportion of the 2018 homicides, the hotspot areas differed considerably.

---

To compare the effectiveness of each hotspot technique, I calculated the total hotspot area, determined how many 2018 homicides occurred within each hotspot, calculated the percentage of all homicides captured, and computed homicide density. The Grid Overlay method produced the smallest hotspot area and the highest homicide density, while the Kernel Density method identified a larger hotspot area with a lower density. Local Moran's I produced results that balanced hotspot size with statistically significant clustering.

From a practical standpoint, I found Local Moran's I to be the most useful method for supporting law enforcement decision-making. Rather than simply identifying areas with many incidents, it identifies clusters that are statistically significant, making it a stronger analytical tool for directing limited enforcement resources. While Kernel Density remains an excellent visualization technique and Grid Overlay provides a simple summary of crime concentration, Local Moran's I offers the strongest foundation for strategic planning because it accounts for the spatial relationship between neighboring locations.

Overall, this lab strengthened both my technical skills and my understanding of spatial crime analysis. In addition to practicing raster analysis, polygon processing, spatial selection, and geometry calculations, I gained a better appreciation for how analytical methods influence the interpretation of crime patterns. It also reinforced that effective GIS work involves more than running tools—it requires understanding what each method measures, recognizing its limitations, and selecting the approach that best answers the question being asked.

Module 6 Blog: Working with Geometries and Search Cursors

 For Module 6, I created a Python script that uses geometry objects to extract vertex information from the rivers shapefile. The script uses a SearchCursor to access each river feature’s object ID, geometry, and name. From there, I used the getPart() method to access the vertices that make up each river line.

[Insert screenshot of completed rivers_.txt file here]

The screenshot above shows part of the TXT file created by my script. Each line includes the feature OID, vertex ID, X coordinate, Y coordinate, and river name. This confirmed that the script successfully wrote vertex information for the river features.

[Insert flowchart image or exported draw.io flowchart here]

The flowchart shows the basic logic of my script. The process begins by importing modules, setting the workspace, creating the SearchCursor, and opening the output TXT file. The script then loops through each river feature and each vertex within that feature. For every vertex, it writes the required information to the TXT file and prints the same information to show progress.

One important part of this assignment was understanding why SHAPE@ was needed instead of SHAPE@XY. SHAPE@ gives access to the full geometry object, while SHAPE@XY would only return one coordinate pair. Since the goal was to write all vertices, the full geometry object was necessary. Overall, this lab helped reinforce how nested loops are used to work through features, geometry arrays, and individual points.

 

Exploring and Manipulating Data with ArcPy– 

Module 5 Assignment Reflection

This week’s assignment focused on exploring and manipulating spatial data using ArcPy. The main objective was to create a Python script that automatically creates a file geodatabase, copies spatial data into it, and uses a Search Cursor to build a dictionary containing New Mexico county seat cities and their populations.

One of the most useful concepts I learned this week was how to use ArcPy's Describe, List, and Cursor functions together to automate repetitive GIS tasks. Instead of manually copying datasets and looking up attribute values, the script handled everything automatically.

Assignment Overview

The script completed the following tasks:

• Created a new file geodatabase in the Results folder
• Listed all feature classes in the Data folder
• Copied each feature class into the new geodatabase using a loop
• Used a Search Cursor to identify all cities classified as County Seats
• Created and populated a Python dictionary using city names as keys and population values as dictionary values
• Displayed progress messages throughout the process to make the output easier to follow

Script Results

Figure 1. Successful execution of the Module 5 script showing geodatabase creation, feature class copying, and population dictionary creation.

Script Flowchart

Figure 2. Flowchart illustrating the overall logic of the Module 5 script.

The flowchart was created to visualize the sequence of operations performed by the script. The process begins by importing ArcPy modules, setting the workspace, and enabling overwrite permissions. The script then creates a new file geodatabase and uses a loop to copy all feature classes from the Data folder into the new geodatabase. After the data is copied, the workspace is updated to the new geodatabase and a Search Cursor is used to retrieve the names and populations of cities classified as County Seats. These values are stored in a Python dictionary called county_seats, which is then printed to the output window. Creating the flowchart helped me organize the script logic and better understand how each step contributes to the final result.

What I Learned

This assignment helped reinforce several important ArcPy concepts:

• Using ListFeatureClasses() to automate batch processing.
• Using Describe() and the basename property when copying shapefiles into a geodatabase.
• Creating and populating Python dictionaries from GIS data.
• Using Data Access (arcpy.da) Search Cursors with ArcGIS Pro 3.6 syntax.
• Creating SQL expressions to filter records.
• Using flowcharts to plan and document script logic before and after coding.

The flowchart was especially useful because it provided a visual representation of the script structure and made it easier to follow the sequence of operations.

Challenges and Solutions

The most challenging part of this assignment was creating the Search Cursor and SQL query needed to retrieve only County Seat cities. I had to pay close attention to the required ArcGIS Pro 3.6 cursor syntax and ensure the correct field list was included in the cursor.

Another challenge involved understanding how the data moved through the script. Creating the flowchart helped clarify the workflow by breaking the script into logical steps, making it easier to troubleshoot and verify that each process was occurring in the correct order.

Geoprocessing with ModelBuilder and Python

Geoprocessing with ModelBuilder and Python

This week’s Module 4 assignment focused on geoprocessing in ArcGIS Pro using both ModelBuilder and Python. The assignment was a great way to see how visual workflows and scripting can accomplish many of the same tasks while offering different advantages. Through building a model and writing a Python script, I gained a better understanding of how geoprocessing tools work together and how GIS workflows can be automated.

---

Building the SoilErase Model

For the first part of the assignment, I created a ModelBuilder model called SoilErase. The goal was to identify areas within the basin that are suitable for farming by removing soils that are classified as "Not prime farmland."

The model completed three main steps:

• Clipped the soils layer to the basin boundary
• Selected soils classified as "Not prime farmland"
• Erased those areas from the basin polygon

One thing I enjoy about ModelBuilder is being able to see the entire workflow laid out visually. It makes it easier to follow the analysis process and verify that each output is connected correctly before running the model. Watching the model come together also helped me better understand how geoprocessing tools depend on one another.

Complete Model

 Clip Tool Settings

Select Tool Settings

Erase Tool Settings

Final Model Output

---

Writing the Python Script

The second part of the assignment involved creating a Python script using ArcPy. The script performed three geoprocessing tasks:

• Added XY coordinates to the hospitals shapefile
• Created a 1000-meter buffer around the hospitals
• Dissolved the buffer polygons into a single feature

I also used the GetMessages() function after each tool ran so the script would display the geoprocessing messages. This was helpful because it provided immediate feedback and confirmed that each step completed successfully.

One of the first things I did was set the workspace and enable output overwriting. These settings made testing much easier because I could rerun the script multiple times without having to manually delete previous outputs. It also kept the code cleaner since I didn't need to repeatedly type full file paths.

Screenshot Placeholder – Script Results

Insert screenshot of the successful script output messages here

---

Challenges and Lessons Learned

The biggest takeaway from this assignment was seeing how ModelBuilder and Python complement each other. ModelBuilder is excellent for visualizing workflows and quickly testing processes, while Python provides more flexibility and automation for tasks that may need to be repeated.

I also gained a better appreciation for the ArcGIS Pro Help documentation. Reviewing the syntax and code examples before running a tool saved time and helped prevent errors. When something didn't work as expected, the geoprocessing messages were extremely useful for figuring out what needed to be fixed.

Another lesson was the importance of environment settings. Simple settings like defining a workspace and allowing outputs to be overwritten can make scripts much easier to develop and troubleshoot.

---

Final Thoughts

Overall, this assignment provided valuable hands-on experience with geoprocessing in ArcGIS Pro. Building the SoilErase model helped reinforce the logic behind spatial analysis workflows, while the Python script demonstrated how those same processes can be automated through code. By the end of the assignment, I felt much more comfortable working with both ModelBuilder and ArcPy, and I can see how these skills will be useful in future GIS projects and professional applications.

 

Debugging, Learning, and Small Wins: Today’s GIS Programming Lab

Today’s GIS programming lab turned into one of those assignments where every error message actually taught me something useful. What started as a frustrating debugging session became a solid lesson in Python syntax, ArcGIS scripting, and troubleshooting strategies. By the end of the lab, I felt much more confident reading errors, fixing scripts, and understanding how small details can completely change how code runs.

The Biggest Lesson: Tiny Errors Matter

One of the biggest things I learned today is that Python is extremely precise. A single misplaced capital letter, missing parenthesis, or incorrect variable name can stop the entire script from running.

Some of the errors I encountered included:

• Incorrect capitalization in variable names
• Misspelled ArcPy functions
• Invalid file paths
• Missing punctuation
• Incorrect object references

At first, the errors looked overwhelming, but once I slowed down and carefully read each message, the fixes became much easier to identify.

Tricks That Helped Me Debug Faster

1. Read the Error Message Carefully

Instead of immediately guessing what was wrong, I started reading the Python shell output line by line. The error messages usually pointed directly to the problem area and even showed the exact line number causing the issue.

That saved a lot of time compared to randomly changing code.

2. Compare Variable Names Exactly

One issue came from using:

filepath

in one location and:

Filepath

in another.

Python treated those as completely different variables because it is case-sensitive. After fixing the capitalization so everything matched, the script worked correctly.

3. Watch for ArcPy Spelling Errors

ArcPy functions have very specific names. I accidentally typed:

arcp.Describe

instead of:

arcpy.Describe

and also misspelled:

spatialReference

as:

spatialRefernce

Once corrected, the script successfully accessed the dataset properties.

4. Check File Paths Closely

I learned that file paths are another common source of problems. Missing slashes, mixed slash directions, or incorrect filenames can prevent scripts from finding data.

Carefully reviewing every folder and filename helped eliminate several issues quickly.

Learning About Try-Except Statements

One of the most useful parts of today’s lab was learning how to use a try-except statement.

Before today, if an error occurred, the entire script stopped running immediately. After adding a try-except block, the script could continue running even if part of the code failed.

That felt like a major upgrade in understanding how professional scripts handle unexpected problems.

Example structure:

try:
    # code that may fail
except:
    # what to do if an error occurs

This approach makes scripts much more reliable and user-friendly.

What I Improved Today

By the end of the lab, I became more comfortable with:

• Reading Python error messages
• Identifying syntax versus runtime errors
• Troubleshooting ArcPy scripts
• Fixing variable and spelling issues
• Understanding object references
• Using try-except statements
• Debugging more systematically instead of guessing

Final Thoughts

Even though debugging can feel frustrating in the moment, today showed me that errors are actually one of the fastest ways to learn programming. Every mistake forced me to slow down, analyze the problem, and better understand how Python and ArcGIS work together.

The best part was seeing the scripts finally run correctly after making the fixes. That feeling made all the troubleshooting worth it.

Today’s lab definitely improved both my confidence and problem-solving skills as I continue learning GIS programming.