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

Fordyp deg i grunnleggende geodataanalyse med Python. Dette mellomnivåkurset introduserer deg for kjernebegreper og praktiske anvendelser av geospatial analyse, med fokus på virkelige datasett og praktiske prosjekter. Du lærer å manipulere, visualisere og analysere romlige data ved hjelp av Python og populære biblioteker, med særlig vekt på geopandas. Kurset er utformet for å være engasjerende, med interaktive rutenett, videoer og quizer for å styrke læringen.

Utforsk det grunnleggende innen geodata, koordinatsystemer og de viktigste verktøyene for romlig analyse i Python. Denne delen legger grunnlaget for arbeid med romlige datasett og introduserer geopandas i detalj, inkludert dets kjerne datastrukturer, lese- og skrivefunksjoner, samt integrasjon med pandas og matplotlib.

Fordyp deg i sentrale romlige analyseteknikker, inkludert romlige sammenføyninger, overlegg og aggregeringer, ved bruk av geopandas og visualiseringsbiblioteker. Denne delen dekker avanserte geopandas-metoder for å kombinere, sammenligne og oppsummere romlige datasett, samt beste praksis for visualisering av romlige data.

Få en solid forståelse av geospatiale datasett og scenarier fra virkeligheten, med fokus på praktiske analyse- og visualiseringsutfordringer. Denne delen legger vekt på prosjektbasert læring og syntese av geospatiale analyseteknikker.

Challenge: Visualisering av Geografiske Data med Rutenett

Løsning