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

Sukella paikkatietoanalyysin perusteisiin Pythonilla. Tämä keskitason kurssi esittelee paikkatietoanalyysin ydinkäsitteet ja käytännön sovellukset, keskittyen todellisiin aineistoihin ja käytännön projekteihin. Opit käsittelemään, visualisoimaan ja analysoimaan paikkatietoa Pythonilla ja suosituilla kirjastoilla, erityisesti geopandasilla. Kurssi on suunniteltu mukaansatempaavaksi, sisältäen interaktiivisia taulukoita, videoita ja tietovisoja oppimisen tukemiseksi.

Tutustu paikkatietoaineistojen perusteisiin, koordinaattijärjestelmiin ja keskeisiin työkaluihin spatiaalisen analyysin toteuttamiseksi Pythonilla. Tämä osio luo perustan paikkatietoaineistojen käsittelylle ja esittelee geopandas-kirjaston yksityiskohtaisesti, mukaan lukien sen ydintietorakenteet, luku- ja kirjoitusominaisuudet sekä integraation pandas- ja matplotlib-kirjastojen kanssa.

Syvenny keskeisiin spatiaalisen analyysin tekniikoihin, kuten spatiaalisiin liitoksiin, päällekkäisyyksiin ja aggregointeihin, hyödyntäen geopandasia ja visualisointikirjastoja. Tässä osiossa käsitellään edistyneitä geopandas-menetelmiä spatiaalisten aineistojen yhdistämiseen, vertailuun ja tiivistämiseen sekä parhaisiin käytäntöihin spatiaalisen datan visualisoinnissa.

Hanki vankka ymmärrys todellisten paikkatietoaineistojen ja -tilanteiden käsittelystä, keskittyen käytännön analyysi- ja visualisointihaasteisiin. Tässä osiossa painotetaan projektipohjaista oppimista ja paikkatietoanalyyttisten menetelmien yhdistämistä.

Haaste: Spatiaalisen Datan Visualisointi Ruutukoilla

Ratkaisu