import unittest
import user_code
import ast
import re   
import importlib
import csv
import matplotlib
matplotlib.use('Agg')
import matplotlib.pyplot as plt
import geopandas as gpd
import numpy as np

class TestTask(unittest.TestCase):
    def setUp(self):
        from shapely.geometry import Polygon
        poly1 = Polygon([(0,0),(1,0),(1,1),(0,1)])
        poly2 = Polygon([(2,2),(3,2),(3,3),(2,3)])
        self.gdf1 = gpd.GeoDataFrame({'attr':[10, 20], 'geometry':[poly1, poly2]})
        self.gdf2 = gpd.GeoDataFrame({'attr':[30, 40], 'geometry':[poly1, poly2]})
        self.attribute = 'attr'
        self.title1 = 'Test1'
        self.title2 = 'Test2'

    def test_two_subplots_in_grid(self):
        import user_code
        importlib.reload(user_code)
        plt.close('all')
        user_code.plot_comparison_grid(self.gdf1, self.gdf2, self.attribute, self.title1, self.title2)
        figs = list(map(plt.figure, plt.get_fignums()))
        _dynamic_test(
            self,
            len(figs) > 0,
            'At least one figure is created.',
            'No figure was created.'
        )
        fig = figs[-1]
        axes = fig.get_axes()
        
        # The first two axes created are always the main geographic subplots
        main_axes = axes[:2]
        _dynamic_test(
            self,
            len(main_axes) == 2,
            'Figure has two subplots (axes) as required.',
            f'Expected 2 main subplots, got {len(main_axes)}.'
        )

    def test_each_subplot_visualizes_attribute(self):
        import user_code
        importlib.reload(user_code)
        plt.close('all')
        user_code.plot_comparison_grid(self.gdf1, self.gdf2, self.attribute, self.title1, self.title2)
        fig = plt.gcf()
        axes = fig.get_axes()
        main_axes = axes[:2]
        
        for ax in main_axes:
            found = False
            for c in ax.collections:
                if hasattr(c, 'cmap'):
                    found = True
            _dynamic_test(
                self,
                found,
                'Each subplot visualizes the attribute with a colored collection.',
                'No colored collection found on subplot.'
            )

    def test_same_colormap_and_legend(self):
        import user_code
        importlib.reload(user_code)
        plt.close('all')
        user_code.plot_comparison_grid(self.gdf1, self.gdf2, self.attribute, self.title1, self.title2)
        fig = plt.gcf()
        axes = fig.get_axes()
        
        main_axes = axes[:2]
        cmaps = [c.cmap.name for ax in main_axes for c in ax.collections if hasattr(c, 'cmap')]
        _dynamic_test(
            self,
            len(cmaps) >= 2 and cmaps[0] == cmaps[1],
            'Both subplots use the same color map.',
            f'Colormaps used: {cmaps}'
        )
        
        # When legend=True, GeoPandas appends extra colorbar axes to the figure container
        colorbar_found = len(axes) > 2
        _dynamic_test(
            self,
            colorbar_found,
            'At least one legend (colorbar) is present.',
            'No legend (colorbar) found.'
        )

    def test_axes_removed(self):
        import user_code
        importlib.reload(user_code)
        plt.close('all')
        user_code.plot_comparison_grid(self.gdf1, self.gdf2, self.attribute, self.title1, self.title2)
        fig = plt.gcf()
        axes = fig.get_axes()
        
        # Only check the main map axes for visibility removal (colorbars require visible ticks)
        main_axes = axes[:2]
        for ax in main_axes:
            _dynamic_test(
                self,
                not ax.axison or (not ax.get_xaxis().get_visible() and not ax.get_yaxis().get_visible()),
                'Axes are removed from subplot.',
                'Axes are visible on subplot.'
            )

    def test_titles_present(self):
        import user_code
        importlib.reload(user_code)
        plt.close('all')
        user_code.plot_comparison_grid(self.gdf1, self.gdf2, self.attribute, self.title1, self.title2)
        fig = plt.gcf()
        axes = fig.get_axes()
        titles = [ax.get_title() for ax in axes]
        _dynamic_test(
            self,
            self.title1 in titles and self.title2 in titles,
            'Each subplot is labeled with the provided title.',
            f'Titles found: {titles}'
        )

    def test_color_scale_consistency(self):
        import user_code
        importlib.reload(user_code)
        plt.close('all')
        min1 = self.gdf1[self.attribute].min()
        max1 = self.gdf1[self.attribute].max()
        min2 = self.gdf2[self.attribute].min()
        max2 = self.gdf2[self.attribute].max()
        vmin = min(min1, min2)
        vmax = max(max1, max2)
        
        # Patch the absolute base rendering function of the geopandas library
        import geopandas.plotting as gplotting
        orig_plot_dataframe = gplotting.plot_dataframe
        vmin_used = []
        vmax_used = []
        
        def patched_plot_dataframe(df, *args, **kwargs):
            vmin_used.append(kwargs.get('vmin', None))
            vmax_used.append(kwargs.get('vmax', None))
            return orig_plot_dataframe(df, *args, **kwargs)
            
        gplotting.plot_dataframe = patched_plot_dataframe
        try:
            user_code.plot_comparison_grid(self.gdf1, self.gdf2, self.attribute, self.title1, self.title2)
        finally:
            gplotting.plot_dataframe = orig_plot_dataframe
            
        _dynamic_test(
            self,
            len(vmin_used) == 2 and len(vmax_used) == 2 and all(v == vmin for v in vmin_used) and all(v == vmax for v in vmax_used),
            'Both plots use the same color scale (vmin/vmax) for the attribute.',
            f'vmin used: {vmin_used}, vmax used: {vmax_used}, expected vmin={vmin}, vmax={vmax}'
        )

def _dynamic_test(test_case, condition, success_message, failure_message):
    if condition:
        test_case._testMethodName = success_message
        test_case.assertTrue(True, success_message)
    else:
        test_case._testMethodName = failure_message
        test_case.fail(failure_message)

if __name__ == "__main__":
    unittest.main()

test_main.py

Dyk ned i grundlæggende geospatiel dataanalyse med Python. Dette mellemniveaukursus introducerer dig til kernekoncepter og praktiske anvendelser af geospatiel analyse med fokus på virkelige datasæt og praktiske projekter. Du lærer at manipulere, visualisere og analysere spatiale data ved hjælp af Python og populære biblioteker, med særlig vægt på geopandas. Kurset er designet til at være engagerende og indeholder interaktive gittere, videoer og quizzer for at styrke din læring.

Udforsk det grundlæggende inden for geospatiale data, koordinatsystemer og de væsentlige værktøjer til rumlig analyse i Python. Dette afsnit danner grundlaget for at arbejde med spatiale datasæt og introducerer geopandas i detaljer, herunder dets kerne-datastrukturer, læse-/skrivefunktioner og integration med pandas og matplotlib.

Dyk ned i centrale rumlige analyseteknikker, herunder rumlige joins, overlays og aggregeringer, ved brug af geopandas og visualiseringsbiblioteker. Dette afsnit dækker avancerede geopandas-metoder til at kombinere, sammenligne og opsummere rumlige datasæt samt bedste praksis for visualisering af rumlige data.

Opnå en solid forståelse af geospatiale datasæt og scenarier fra den virkelige verden med fokus på praktiske analyse- og visualiseringsudfordringer. Dette afsnit lægger vægt på projektbaseret læring og syntese af geospatiale analyseteknikker.

Udfordring: Visualisering af rumlige data med gitter

Løsning