diff --git a/.github/ISSUE_TEMPLATE/bug_report.md b/.github/ISSUE_TEMPLATE/bug_report.md new file mode 100644 index 0000000..1b91ccf --- /dev/null +++ b/.github/ISSUE_TEMPLATE/bug_report.md @@ -0,0 +1,39 @@ +--- + +name: Bug Report +about: Create a bug report to help us improve geopandas +title: "BUG:" +labels: "bug, needs triage" + +--- + +- [ ] I have checked that this issue has not already been reported. + +- [ ] I have confirmed this bug exists on the latest version of geopandas. + +- [ ] (optional) I have confirmed this bug exists on the main branch of geopandas. + +--- + +**Note**: Please read [this guide](https://matthewrocklin.com/blog/work/2018/02/28/minimal-bug-reports) detailing how to provide the necessary information for us to reproduce your bug. + +#### Code Sample, a copy-pastable example + +```python +# Your code here + +``` + +#### Problem description + +[this should explain **why** the current behaviour is a problem and why the expected output is a better solution] + +#### Expected Output + +#### Output of ``geopandas.show_versions()`` + +
+ +[paste the output of ``geopandas.show_versions()`` here leaving a blank line after the details tag] + +
diff --git a/.github/ISSUE_TEMPLATE/feature_request.md b/.github/ISSUE_TEMPLATE/feature_request.md new file mode 100644 index 0000000..cdb5ba0 --- /dev/null +++ b/.github/ISSUE_TEMPLATE/feature_request.md @@ -0,0 +1,34 @@ +--- + +name: Feature Request +about: Suggest an idea for geopandas +title: "ENH:" +labels: "enhancement" + +--- + +#### Is your feature request related to a problem? + +[this should provide a description of what the problem is, e.g. "I wish I could use geopandas to do [...]"] + +#### Describe the solution you'd like + +[this should provide a description of the feature request, e.g. "`GeoDataFrame.foo` should get a new parameter `bar` that [...]", try to write a docstring for the desired feature] + +#### API breaking implications + +[this should provide a description of how this feature will affect the API] + +#### Describe alternatives you've considered + +[this should provide a description of any alternative solutions or features you've considered] + +#### Additional context + +[add any other context, code examples, or references to existing implementations about the feature request here] + +```python +# Your code here, if applicable + +``` + diff --git a/.github/ISSUE_TEMPLATE/installation_issue.md b/.github/ISSUE_TEMPLATE/installation_issue.md new file mode 100644 index 0000000..6e588b9 --- /dev/null +++ b/.github/ISSUE_TEMPLATE/installation_issue.md @@ -0,0 +1,31 @@ +--- + +name: Installation Issue +about: Ask about installing geopandas +title: "" +labels: "installation" + +--- + +- [ ] I have read the [documentation on installation](https://geopandas.org/install.html) and followed the instructions provided. + +- [ ] I have looked through [issues labeled "installation"](https://github.com/geopandas/geopandas/labels/installation) in the geopandas repo. + +- If your issue is related to installation using the `conda-forge` channel, please open an issue in [geopandas-feedstock repository](https://github.com/conda-forge/geopandas-feedstock) instead. + +--- + +#### System information + +[what operating system do you have and what package management system are you +using] + +#### Environment details + +
+ +[if using conda, paste the output of `conda info` and `conda list`; if using +pip, `pip freeze`] + +
+ diff --git a/.github/ISSUE_TEMPLATE/submit_question.md b/.github/ISSUE_TEMPLATE/submit_question.md new file mode 100644 index 0000000..c118c3d --- /dev/null +++ b/.github/ISSUE_TEMPLATE/submit_question.md @@ -0,0 +1,24 @@ +--- + +name: Submit Question +about: Ask a general question about geopandas +title: "QST:" +labels: "question" + +--- + +- [ ] I have searched the [geopandas] tag on [StackOverflow](https://stackoverflow.com/questions/tagged/geopandas) and [GIS StackExchange](https://gis.stackexchange.com/questions/tagged/geopandas) for similar questions. + +- [ ] I have asked my usage related question on [StackOverflow](https://stackoverflow.com) or [GIS StackExhange](https://gis.stackexchange.com). + +--- + +#### Question about geopandas + +**Note**: If you'd still like to submit a question, please read [this guide]( +https://matthewrocklin.com/blog/work/2018/02/28/minimal-bug-reports) detailing how to provide the necessary information for us to reproduce your question. + +```python +# Your code here, if applicable + +``` diff --git a/.github/workflows/release_to_pypi.yml b/.github/workflows/release_to_pypi.yml new file mode 100644 index 0000000..92b4773 --- /dev/null +++ b/.github/workflows/release_to_pypi.yml @@ -0,0 +1,60 @@ +name: Publish geopandas to PyPI / GitHub + +on: + push: + tags: + - "v*" + +jobs: + build-n-publish: + name: Build and publish geopandas to PyPI + runs-on: ubuntu-latest + + steps: + - name: Checkout source + uses: actions/checkout@v2 + + - name: Set up Python + uses: actions/setup-python@v2 + with: + python-version: "3.x" + + - name: Build a binary wheel and a source tarball + run: | + python -m pip install --upgrade pip + pip install setuptools wheel + python setup.py sdist bdist_wheel + + - name: Publish distribution to PyPI + uses: pypa/gh-action-pypi-publish@master + with: + user: __token__ + password: ${{ secrets.PYPI_API_TOKEN }} + + - name: Create GitHub Release + id: create_release + uses: actions/create-release@v1 + env: + GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} # This token is provided by Actions, you do not need to create your own token + with: + tag_name: ${{ github.ref }} + release_name: ${{ github.ref }} + draft: false + prerelease: false + + - name: Get Asset name + run: | + export PKG=$(ls dist/ | grep tar) + set -- $PKG + echo "name=$1" >> $GITHUB_ENV + + - name: Upload Release Asset (sdist) to GitHub + id: upload-release-asset + uses: actions/upload-release-asset@v1 + env: + GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} + with: + upload_url: ${{ steps.create_release.outputs.upload_url }} + asset_path: dist/${{ env.name }} + asset_name: ${{ env.name }} + asset_content_type: application/zip diff --git a/.github/workflows/tests.yaml b/.github/workflows/tests.yaml new file mode 100644 index 0000000..f2b72c7 --- /dev/null +++ b/.github/workflows/tests.yaml @@ -0,0 +1,127 @@ +name: Tests + +on: + push: + branches: [main, 0.**] + pull_request: + branches: [main, 0.**] + schedule: + - cron: "0 0 * * *" + +concurrency: + group: ${{ github.workflow }}-${{ github.ref }} + cancel-in-progress: true + +jobs: + Linting: + runs-on: ubuntu-latest + + steps: + - uses: actions/checkout@v2 + - uses: actions/setup-python@v2 + - uses: pre-commit/action@v2.0.3 + + Test: + needs: Linting + name: ${{ matrix.os }}, ${{ matrix.env }} + runs-on: ${{ matrix.os }} + defaults: + run: + shell: bash -l {0} + strategy: + fail-fast: false + matrix: + os: [ubuntu-latest] + postgis: [false] + dev: [false] + env: + - ci/envs/37-minimal.yaml + - ci/envs/38-no-optional-deps.yaml + - ci/envs/37-pd10.yaml + - ci/envs/37-latest-defaults.yaml + - ci/envs/37-latest-conda-forge.yaml + - ci/envs/38-latest-conda-forge.yaml + - ci/envs/39-latest-conda-forge.yaml + - ci/envs/310-latest-conda-forge.yaml + include: + - env: ci/envs/37-latest-conda-forge.yaml + os: macos-latest + postgis: false + dev: false + - env: ci/envs/38-latest-conda-forge.yaml + os: macos-latest + postgis: false + dev: false + - env: ci/envs/37-latest-conda-forge.yaml + os: windows-latest + postgis: false + dev: false + - env: ci/envs/38-latest-conda-forge.yaml + os: windows-latest + postgis: false + dev: false + - env: ci/envs/310-dev.yaml + os: ubuntu-latest + dev: true + + steps: + - uses: actions/checkout@v2 + + - name: Setup Conda + uses: conda-incubator/setup-miniconda@v2 + with: + environment-file: ${{ matrix.env }} + miniforge-version: latest + miniforge-variant: Mambaforge + use-mamba: true + + - name: Check and Log Environment + run: | + python -V + python -c "import geopandas; geopandas.show_versions();" + conda info + # save conda list to file and print out + # so that we can do the HAS_PYGEOS check without calling conda again + conda list 2>&1 | tee conda.txt + if ( cat conda.txt | grep -q pygeos ) + then + echo "Setting HAS_PYGEOS=1" + echo "HAS_PYGEOS=1" >> $GITHUB_ENV + else + echo "Setting HAS_PYGEOS=0" + echo "HAS_PYGEOS=0" >> $GITHUB_ENV + fi + + - name: Test without PyGEOS + env: + USE_PYGEOS: 0 + run: | + pytest -v -r s -n auto --color=yes --cov=geopandas --cov-append --cov-report term-missing --cov-report xml geopandas/ + + - name: Test with PyGEOS + if: env.HAS_PYGEOS == 1 + env: + USE_PYGEOS: 1 + run: | + pytest -v -r s -n auto --color=yes --cov=geopandas --cov-append --cov-report term-missing --cov-report xml geopandas/ + + - name: Test with PostGIS + if: contains(matrix.env, '38-latest-conda-forge.yaml') && contains(matrix.os, 'ubuntu') + env: + PGUSER: postgres + PGPASSWORD: postgres + PGHOST: "127.0.0.1" + PGPORT: 5432 + run: | + conda install postgis -c conda-forge + sh ci/scripts/setup_postgres.sh + pytest -v -r s --color=yes --cov=geopandas --cov-append --cov-report term-missing --cov-report xml geopandas/io/tests/test_sql.py | tee /dev/stderr | if grep SKIPPED >/dev/null;then echo "TESTS SKIPPED, FAILING" && exit 1;fi + + - name: Test docstrings + if: contains(matrix.env, '38-latest-conda-forge.yaml') && contains(matrix.os, 'ubuntu') + env: + USE_PYGEOS: 1 + run: | + pytest -v --color=yes --doctest-only geopandas --ignore=geopandas/datasets + + - uses: codecov/codecov-action@v2 diff --git a/.gitignore b/.gitignore index 5d7cabe..5e9c00e 100644 --- a/.gitignore +++ b/.gitignore @@ -34,6 +34,7 @@ nosetests.xml coverage.xml *.cover .hypothesis/ +result_images # Sphinx documentation doc/_build/ @@ -59,11 +60,12 @@ doc/_build/ examples/nybb_*.zip -doc/source/gallery doc/source/savefig doc/source/reference +doc/source/docs/reference/api/*.rst geopandas.egg-info geopandas/version.py .asv +doc/source/getting_started/my_file.geojson diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml index c257986..0ec4099 100644 --- a/.pre-commit-config.yaml +++ b/.pre-commit-config.yaml @@ -1,11 +1,12 @@ +files: 'geopandas\/' repos: - repo: https://github.com/python/black - rev: stable + rev: 20.8b1 hooks: - id: black - language_version: python3.7 + language_version: python3 - repo: https://gitlab.com/pycqa/flake8 - rev: 3.7.7 + rev: 3.8.3 hooks: - id: flake8 language: python_venv diff --git a/.travis.yml b/.travis.yml deleted file mode 100644 index c74bb5c..0000000 --- a/.travis.yml +++ /dev/null @@ -1,69 +0,0 @@ -language: python - -sudo: false - -matrix: - include: - # One build with minimum versions of dependencies - - env: ENV_FILE="ci/travis/35-minimal.yaml" - - # one build with no optional dependencies - - env: ENV_FILE="ci/travis/38-no-optional-deps.yaml" - - # Python 3.6 test all supported Pandas versions - - env: ENV_FILE="ci/travis/36-pd023.yaml" PYGEOS=true - - env: ENV_FILE="ci/travis/36-pd024.yaml" PYGEOS=true - - - env: ENV_FILE="ci/travis/37-latest-defaults.yaml" STYLE=true PYGEOS=true - - env: ENV_FILE="ci/travis/37-latest-conda-forge.yaml" PYGEOS=true - - - env: ENV_FILE="ci/travis/38-latest-conda-forge.yaml" PYGEOS=true POSTGIS=true PGUSER=postgres PGPASSWORD=postgres - - - env: ENV_FILE="ci/travis/37-dev.yaml" DEV=true PYGEOS=true - - allow_failures: - - env: ENV_FILE="ci/travis/37-dev.yaml" DEV=true PYGEOS=true - -before_install: - - chmod +x ci/travis/setup_postgres.sh - -install: - # Install conda - - wget https://repo.continuum.io/miniconda/Miniconda3-latest-Linux-x86_64.sh -O miniconda.sh - - bash miniconda.sh -b -p $HOME/miniconda - - export PATH="$HOME/miniconda/bin:$PATH" - - conda config --set always_yes yes --set changeps1 no - - conda update conda - - conda info - - # free channel needed for older envs (< py37), see - # https://github.com/conda/conda/issues/8849 - - conda config --set restore_free_channel true - - # Install dependencies - - conda env create --file="${ENV_FILE}" - - source activate test - - if [ "$DEV" ]; then pip install git+https://github.com/pydata/pandas.git; fi - - if [ "$DEV" ]; then pip install git+https://github.com/matplotlib/matplotlib.git; fi - - if [ "$DEV" ]; then pip install git+https://github.com/Toblerity/Shapely.git; fi - - if [ "$STYLE" ]; then pip install black flake8; fi - - if [ "$POSTGIS" ]; then conda install postgis -c conda-forge; fi - - pip install -e . - - # List environment - - conda list - - python -c "import geopandas; geopandas.show_versions();" - - # Set-up database - - if [ "$POSTGIS" ]; then ci/travis/setup_postgres.sh; fi - -script: - - echo "Testing without PyGEOS" - - USE_PYGEOS=0 pytest geopandas -v -r s --cov geopandas --cov-report term-missing - - if [ "$PYGEOS" ]; then echo "Testing with PyGEOS"; fi - - if [ "$PYGEOS" ]; then USE_PYGEOS=1 pytest geopandas -v -r s --cov-append --cov geopandas --cov-report term-missing; fi - - if [ "$STYLE" ]; then black --check geopandas; fi - - if [ "$STYLE" ]; then flake8 geopandas; fi - -after_success: - - codecov diff --git a/CHANGELOG.md b/CHANGELOG.md index eabe5d5..f7322a2 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,6 +1,356 @@ Changelog ========= +Version 0.10.2 (October 16, 2021) +--------------------------------- + +Small bug-fix release: + +- Fix regression in `overlay()` in case no geometries are intersecting (but + have overlapping total bounds) (#2172). +- Fix regression in `overlay()` with `keep_geom_type=True` in case the + overlay of two geometries in a GeometryCollection with other geometry types + (#2177). +- Fix `overlay()` to honor the `keep_geom_type` keyword for the + `op="differnce"` case (#2164). +- Fix regression in `plot()` with a mapclassify `scheme` in case the + formatted legend labels have duplicates (#2166). +- Fix a bug in the `explore()` method ignoring the `vmin` and `vmax` keywords + in case they are set to 0 (#2175). +- Fix `unary_union` to correctly handle a GeoSeries with missing values (#2181). +- Avoid internal deprecation warning in `clip()` (#2179). + + +Version 0.10.1 (October 8, 2021) +-------------------------------- + +Small bug-fix release: + +- Fix regression in `overlay()` with non-overlapping geometries and a + non-default `how` (i.e. not "intersection") (#2157). + + +Version 0.10.0 (October 3, 2021) +-------------------------------- + +Highlights of this release: + +- A new `sjoin_nearest()` method to join based on proximity, with the + ability to set a maximum search radius (#1865). In addition, the `sindex` + attribute gained a new method for a "nearest" spatial index query (#1865, + #2053). +- A new `explore()` method on GeoDataFrame and GeoSeries with native support + for interactive visualization based on folium / leaflet.js (#1953) +- The `geopandas.sjoin()`/`overlay()`/`clip()` functions are now also + available as methods on the GeoDataFrame (#2141, #1984, #2150). + +New features and improvements: + +- Add support for pandas' `value_counts()` method for geometry dtype (#2047). +- The `explode()` method has a new `ignore_index` keyword (consistent with + pandas' explode method) to reset the index in the result, and a new + `index_parts` keywords to control whether a cumulative count indexing the + parts of the exploded multi-geometries should be added (#1871). +- `points_from_xy()` is now available as a GeoSeries method `from_xy` (#1936). +- The `to_file()` method will now attempt to detect the driver (if not + specified) based on the extension of the provided filename, instead of + defaulting to ESRI Shapefile (#1609). +- Support for the `storage_options` keyword in `read_parquet()` for + specifying filesystem-specific options (e.g. for S3) based on fsspec (#2107). +- The read/write functions now support `~` (user home directory) expansion (#1876). +- Support the `convert_dtypes()` method from pandas to preserve the + GeoDataFrame class (#2115). +- Support WKB values in the hex format in `GeoSeries.from_wkb()` (#2106). +- Update the `estimate_utm_crs()` method to handle crossing the antimeridian + with pyproj 3.1+ (#2049). +- Improved heuristic to decide how many decimals to show in the repr based on + whether the CRS is projected or geographic (#1895). +- Switched the default for `geocode()` from GeoCode.Farm to the Photon + geocoding API (https://photon.komoot.io) (#2007). + +Deprecations and compatibility notes: + +- The `op=` keyword of `sjoin()` to indicate which spatial predicate to use + for joining is being deprecated and renamed in favor of a new `predicate=` + keyword (#1626). +- The `cascaded_union` attribute is deprecated, use `unary_union` instead (#2074). +- Constructing a GeoDataFrame with a duplicated "geometry" column is now + disallowed. This can also raise an error in the `pd.concat(.., axis=1)` + function if this results in duplicated active geometry columns (#2046). +- The `explode()` method currently returns a GeoSeries/GeoDataFrame with a + MultiIndex, with an additional level with indices of the parts of the + exploded multi-geometries. For consistency with pandas, this will change in + the future and the new `index_parts` keyword is added to control this. + +Bug fixes: + +- Fix in the `clip()` function to correctly clip MultiPoints instead of + leaving them intact when partly outside of the clip bounds (#2148). +- Fix `GeoSeries.isna()` to correctly return a boolean Series in case of an + empty GeoSeries (#2073). +- Fix the GeoDataFrame constructor to preserve the geometry name when the + argument is already a GeoDataFrame object (i.e. `GeoDataFrame(gdf)`) (#2138). +- Fix loss of the values' CRS when setting those values as a column + (`GeoDataFrame.__setitem__`) (#1963) +- Fix in `GeoDataFrame.apply()` to preserve the active geometry column name + (#1955). +- Fix in `sjoin()` to not ignore the suffixes in case of a right-join + (`how="right`) (#2065). +- Fix `GeoDataFrame.explode()` with a MultiIndex (#1945). +- Fix the handling of missing values in `to/from_wkb` and `to_from_wkt` (#1891). +- Fix `to_file()` and `to_json()` when DataFrame has duplicate columns to + raise an error (#1900). +- Fix bug in the colors shown with user-defined classification scheme (#2019). +- Fix handling of the `path_effects` keyword in `plot()` (#2127). +- Fix `GeoDataFrame.explode()` to preserve `attrs` (#1935) + +Notes on (optional) dependencies: + +- GeoPandas 0.10.0 dropped support for Python 3.6 and pandas 0.24. Further, + the minimum required versions are numpy 1.18, shapely 1.6, fiona 1.8, + matplotlib 3.1 and pyproj 2.2. +- Plotting with a classification schema now requires mapclassify version >= + 2.4 (#1737). +- Compatibility fixes for the latest numpy in combination with Shapely 1.7 (#2072) +- Compatibility fixes for the upcoming Shapely 1.8 (#2087). +- Compatibility fixes for the latest PyGEOS (#1872, #2014) and matplotlib + (colorbar issue, #2066). + + +Version 0.9.0 (February 28, 2021) +--------------------------------- + +Many documentation improvements and a restyled and restructured website with +a new logo (#1564, #1579, #1617, #1668, #1731, #1750, #1757, #1759). + +New features and improvements: + +- The `geopandas.read_file` function now accepts more general + file-like objects (e.g. `fsspec` open file objects). It will now also + automatically recognize zipped files (#1535). +- The `GeoDataFrame.plot()` method now provides access to the pandas plotting + functionality for the non-geometry columns, either using the `kind` keyword + or the accessor method (e.g. `gdf.plot(kind="bar")` or `gdf.plot.bar()`) + (#1465). +- New `from_wkt()`, `from_wkb()`, `to_wkt()`, `to_wkb()` methods for + GeoSeries to construct a GeoSeries from geometries in WKT or WKB + representation, or to convert a GeoSeries to a pandas Seriew with WKT or WKB + values (#1710). +- New `GeoSeries.z` attribute to access the z-coordinates of Point geometries + (similar to the existing `.x` and `.y` attributes) (#1773). +- The `to_crs()` method now handles missing values (#1618). +- Support for pandas' new `.attrs` functionality (#1658). +- The `dissolve()` method now allows dissolving by no column (`by=None`) to + create a union of all geometries (single-row GeoDataFrame) (#1568). +- New `estimate_utm_crs()` method on GeoSeries/GeoDataFrame to determine the + UTM CRS based on the bounds (#1646). +- `GeoDataFrame.from_dict()` now accepts `geometry` and `crs` keywords + (#1619). +- `GeoDataFrame.to_postgis()` and `geopandas.read_postgis()` now supports + both sqlalchemy engine and connection objects (#1638). +- The `GeoDataFrame.explode()` method now allows exploding based on a + non-geometry column, using the pandas implementation (#1720). +- Performance improvement in `GeoDataFrame/GeoSeries.explode()` when using + the PyGEOS backend (#1693). +- The binary operation and predicate methods (eg `intersection()`, + `intersects()`) have a new `align` keyword which allows optionally not + aligning on the index before performing the operation with `align=False` + (#1668). +- The `GeoDataFrame.dissolve()` method now supports all relevant keywords of + `groupby()`, i.e. the `level`, `sort`, `observed` and `dropna` keywords + (#1845). +- The `geopandas.overlay()` function now accepts `make_valid=False` to skip + the step to ensure the input geometries are valid using `buffer(0)` (#1802). +- The `GeoDataFrame.to_json()` method gained a `drop_id` keyword to + optionally not write the GeoDataFrame's index as the "id" field in the + resulting JSON (#1637). +- A new `aspect` keyword in the plotting methods to optionally allow retaining + the original aspect (#1512) +- A new `interval` keyword in the `legend_kwds` group of the `plot()` method + to control the appearance of the legend labels when using a classification + scheme (#1605). +- The spatial index of a GeoSeries (accessed with the `sindex` attribute) is + now stored on the underlying array. This ensures that the spatial index is + preserved in more operations where possible, and that multiple geometry + columns of a GeoDataFrame can each have a spatial index (#1444). +- Addition of a `has_sindex` attribute on the GeoSeries/GeoDataFrame to check + if a spatial index has already been initialized (#1627). +- The `geopandas.testing.assert_geoseries_equal()` and `assert_geodataframe_equal()` + testing utilities now have a `normalize` keyword (False by default) to + normalize geometries before comparing for equality (#1826). Those functions + now also give a more informative error message when failing (#1808). + +Deprecations and compatibility notes: + +- The `is_ring` attribute currently returns True for Polygons. In the future, + this will be False (#1631). In addition, start to check it for LineStrings + and LinearRings (instead of always returning False). +- The deprecated `objects` keyword in the `intersection()` method of the + `GeoDataFrame/GeoSeries.sindex` spatial index object has been removed + (#1444). + +Bug fixes: + +- Fix regression in the `plot()` method raising an error with empty + geometries (#1702, #1828). +- Fix `geopandas.overlay()` to preserve geometries of the correct type which + are nested within a GeometryCollection as a result of the overlay + operation (#1582). In addition, a warning will now be raised if geometries + of different type are dropped from the result (#1554). +- Fix the repr of an empty GeoSeries to not show spurious warnings (#1673). +- Fix the `.crs` for empty GeoDataFrames (#1560). +- Fix `geopandas.clip` to preserve the correct geometry column name (#1566). +- Fix bug in `plot()` method when using `legend_kwds` with multiple subplots + (#1583) +- Fix spurious warning with `missing_kwds` keyword of the `plot()` method + when there are no areas with missing data (#1600). +- Fix the `plot()` method to correctly align values passed to the `column` + keyword as a pandas Series (#1670). +- Fix bug in plotting MultiPoints when passing values to determine the color + (#1694) +- The `rename_geometry()` method now raises a more informative error message + when a duplicate column name is used (#1602). +- Fix `explode()` method to preserve the CRS (#1655) +- Fix the `GeoSeries.apply()` method to again accept the `convert_dtype` + keyword to be consistent with pandas (#1636). +- Fix `GeoDataFrame.apply()` to preserve the CRS when possible (#1848). +- Fix bug in containment test as `geom in geoseries` (#1753). +- The `shift()` method of a GeoSeries/GeoDataFrame now preserves the CRS + (#1744). +- The PostGIS IO functionality now quotes table names to ensure it works with + case-sensitive names (#1825). +- Fix the `GeoSeries` constructor without passing data but only an index (#1798). + +Notes on (optional) dependencies: + +- GeoPandas 0.9.0 dropped support for Python 3.5. Further, the minimum + required versions are pandas 0.24, numpy 1.15 and shapely 1.6 and fiona 1.8. +- The `descartes` package is no longer required for plotting polygons. This + functionality is now included by default in GeoPandas itself, when + matplotlib is available (#1677). +- Fiona is now only imported when used in `read_file`/`to_file`. This means + you can now force geopandas to install without fiona installed (although it + is still a default requirement) (#1775). +- Compatibility with the upcoming Shapely 1.8 (#1659, #1662, #1819). + + +Version 0.8.2 (January 25, 2021) +-------------------------------- + +Small bug-fix release for compatibility with PyGEOS 0.9. + + +Version 0.8.1 (July 15, 2020) +----------------------------- + +Small bug-fix release: + +- Fix a regression in the `plot()` method when visualizing with a + JenksCaspallSampled or FisherJenksSampled scheme (#1486). +- Fix spurious warning in `GeoDataFrame.to_postgis` (#1497). +- Fix the un-pickling with `pd.read_pickle` of files written with older + GeoPandas versions (#1511). + + +Version 0.8.0 (June 24, 2020) +----------------------------- + +**Experimental**: optional use of PyGEOS to speed up spatial operations (#1155). +PyGEOS is a faster alternative for Shapely (being contributed back to a future +version of Shapely), and is used in element-wise spatial operations and for +spatial index in e.g. `sjoin` (#1343, #1401, #1421, #1427, #1428). See the +[installation docs](https://geopandas.readthedocs.io/en/latest/install.html#using-the-optional-pygeos-dependency) +for more info and how to enable it. + +New features and improvements: + +- IO enhancements: + + - New `GeoDataFrame.to_postgis()` method to write to PostGIS database (#1248). + - New Apache Parquet and Feather file format support (#1180, #1435) + - Allow appending to files with `GeoDataFrame.to_file` (#1229). + - Add support for the `ignore_geometry` keyword in `read_file` to only read + the attribute data. If set to True, a pandas DataFrame without geometry is + returned (#1383). + - `geopandas.read_file` now supports reading from file-like objects (#1329). + - `GeoDataFrame.to_file` now supports specifying the CRS to write to the file + (#802). By default it still uses the CRS of the GeoDataFrame. + - New `chunksize` keyword in `geopandas.read_postgis` to read a query in + chunks (#1123). + +- Improvements related to geometry columns and CRS: + + - Any column of the GeoDataFrame that has a "geometry" dtype is now returned + as a GeoSeries. This means that when having multiple geometry columns, not + only the "active" geometry column is returned as a GeoSeries, but also + accessing another geometry column (`gdf["other_geom_column"]`) gives a + GeoSeries (#1336). + - Multiple geometry columns in a GeoDataFrame can now each have a different + CRS. The global `gdf.crs` attribute continues to returns the CRS of the + "active" geometry column. The CRS of other geometry columns can be accessed + from the column itself (eg `gdf["other_geom_column"].crs`) (#1339). + - New `set_crs()` method on GeoDataFrame/GeoSeries to set the CRS of naive + geometries (#747). + +- Improvements related to plotting: + + - The y-axis is now scaled depending on the center of the plot when using a + geographic CRS, instead of using an equal aspect ratio (#1290). + - When passing a column of categorical dtype to the `column=` keyword of the + GeoDataFrame `plot()`, we now honor all categories and its order (#1483). + In addition, a new `categories` keyword allows to specify all categories + and their order otherwise (#1173). + - For choropleths using a classification scheme (using `scheme=`), the + `legend_kwds` accept two new keywords to control the formatting of the + legend: `fmt` with a format string for the bin edges (#1253), and `labels` + to pass fully custom class labels (#1302). + +- New `covers()` and `covered_by()` methods on GeoSeries/GeoDataframe for the + equivalent spatial predicates (#1460, #1462). +- GeoPandas now warns when using distance-based methods with data in a + geographic projection (#1378). + +Deprecations: + +- When constructing a GeoSeries or GeoDataFrame from data that already has a + CRS, a deprecation warning is raised when both CRS don't match, and in the + future an error will be raised in such a case. You can use the new `set_crs` + method to override an existing CRS. See + [the docs](https://geopandas.readthedocs.io/en/latest/projections.html#projection-for-multiple-geometry-columns). +- The helper functions in the `geopandas.plotting` module are deprecated for + public usage (#656). +- The `geopandas.io` functions are deprecated, use the top-level `read_file` and + `to_file` instead (#1407). +- The set operators (`&`, `|`, `^`, `-`) are deprecated, use the + `intersection()`, `union()`, `symmetric_difference()`, `difference()` methods + instead (#1255). +- The `sindex` for empty dataframe will in the future return an empty spatial + index instead of `None` (#1438). +- The `objects` keyword in the `intersection` method of the spatial index + returned by the `sindex` attribute is deprecated and will be removed in the + future (#1440). + +Bug fixes: + +- Fix the `total_bounds()` method to ignore missing and empty geometries (#1312). +- Fix `geopandas.clip` when masking with non-overlapping area resulting in an + empty GeoDataFrame (#1309, #1365). +- Fix error in `geopandas.sjoin` when joining on an empty geometry column (#1318). +- CRS related fixes: `pandas.concat` preserves CRS when concatenating GeoSeries + objects (#1340), preserve the CRS in `geopandas.clip` (#1362) and in + `GeoDataFrame.astype` (#1366). +- Fix bug in `GeoDataFrame.explode()` when 'level_1' is one of the column names + (#1445). +- Better error message when rtree is not installed (#1425). +- Fix bug in `GeoSeries.equals()` (#1451). +- Fix plotting of multi-part geometries with additional style keywords (#1385). + +And we now have a [Code of Conduct](https://github.com/geopandas/geopandas/blob/main/CODE_OF_CONDUCT.md)! + +GeoPandas 0.8.0 is the last release to support Python 3.5. The next release +will require Python 3.6, pandas 0.24, numpy 1.15 and shapely 1.6 or higher. + + Version 0.7.0 (February 16, 2020) --------------------------------- @@ -87,10 +437,13 @@ Important note! This will be the last release to support Python 2.7 (#1031) API changes: - A refactor of the internals based on the pandas ExtensionArray interface (#1000). The main user visible changes are: + - The `.dtype` of a GeoSeries is now a `'geometry'` dtype (and no longer a numpy `object` dtype). - The `.values` of a GeoSeries now returns a custom `GeometryArray`, and no longer a numpy array. To get back a numpy array of Shapely scalars, you can convert explicitly using `np.asarray(..)`. + - The `GeoSeries` constructor now raises a warning when passed non-geometry data. Currently the constructor falls back to return a pandas `Series`, but in the future this will raise an error (#1085). - The missing value handling has been changed to now separate the concepts of missing geometries and empty geometries (#601, 1062). In practice this means that (see [the docs](https://geopandas.readthedocs.io/en/v0.6.0/missing_empty.html) for more details): + - `GeoSeries.isna` now considers only missing values, and if you want to check for empty geometries, you can use `GeoSeries.is_empty` (`GeoDataFrame.isna` already only looked at missing values). - `GeoSeries.dropna` now actually drops missing values (before it didn't drop either missing or empty geometries) - `GeoSeries.fillna` only fills missing values (behaviour unchanged). @@ -133,16 +486,20 @@ Improvements: * Significant performance improvement (around 10x) for `GeoDataFrame.iterfeatures`, which also improves `GeoDataFrame.to_file` (#864). * File IO enhancements based on Fiona 1.8: + * Support for writing bool dtype (#855) and datetime dtype, if the file format supports it (#728). * Support for writing dataframes with multiple geometry types, if the file format allows it (e.g. GeoJSON for all types, or ESRI Shapefile for Polygon+MultiPolygon) (#827, #867, #870). + * Compatibility with pyproj >= 2 (#962). * A new `geopandas.points_from_xy()` helper function to convert x and y coordinates to Point objects (#896). -* The `buffer` and `interpolate` methods now accept an array-like to specify a variable distance for each geometry (#781). +* The `buffer` and `interpolate` methods now accept an array-like to specify a variable distance for each geometry (#781). * Addition of a `relate` method, corresponding to the shapely method that returns the DE-9IM matrix (#853). * Plotting improvements: + * Performance improvement in plotting by only flattening the geometries if there are actually 'Multi' geometries (#785). * Choropleths: access to all `mapclassify` classification schemes and addition of the `classification_kwds` keyword in the `plot` method to specify options for the scheme (#876). * Ability to specify a matplotlib axes object on which to plot the color bar with the `cax` keyword, in order to have more control over the color bar placement (#894). + * Changed the default provider in ``geopandas.tools.geocode`` from Google (now requires an API key) to Geocode.Farm (#907, #975). Bug fixes: @@ -186,7 +543,7 @@ Improvements: * Permit setting markersize for Point GeoSeries plots with column values (#633) * Started an example gallery (#463, #690, #717) * Support for plotting MultiPoints (#683) -* Testing functionalty (e.g. `assert_geodataframe_equal`) is now publicly exposed (#707) +* Testing functionality (e.g. `assert_geodataframe_equal`) is now publicly exposed (#707) * Add `explode` method to GeoDataFrame (similar to the GeoSeries method) (#671) * Set equal aspect on active axis on multi-axis figures (#718) * Pass array of values to column argument in `plot` (#770) diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md index 383103a..40fecd6 100644 --- a/CONTRIBUTING.md +++ b/CONTRIBUTING.md @@ -10,8 +10,8 @@ readable code. Performance matters, but not at the expense of those goals. In general, GeoPandas follows the conventions of the pandas project -where applicable. Please read the [pandas contributing -guidelines](http://pandas.pydata.org/pandas-docs/stable/contributing.html). +where applicable. Please read the [contributing +guidelines](https://geopandas.readthedocs.io/en/latest/community/contributing.html). In particular, when submitting a pull request: @@ -19,14 +19,12 @@ In particular, when submitting a pull request: - Install the requirements for the development environment (one can do this with either conda, and the environment.yml file, or pip, and the requirements-dev.txt file, and can use the pandas contributing guidelines - as a guide). + as a guide). - All existing tests should pass. Please make sure that the test suite passes, both locally and on - [Travis CI](https://travis-ci.org/geopandas/geopandas). Status on - Travis will be visible on a pull request. If you want to enable - Travis CI on your own fork, please read the pandas guidelines link - above or the - [getting started docs](http://about.travis-ci.org/docs/user/getting-started/). + [GitHub Actions](https://github.com/geopandas/geopandas/actions). Status on + GHA will be visible on a pull request. GHA are automatically enabled + on your own fork as well. To trigger a check, make a PR to your own fork. - New functionality should include tests. Please write reasonable tests for your code and make sure that they pass on your pull request. @@ -41,7 +39,7 @@ is a great way to get started if you'd like to make a contribution. Style ----- -- GeoPandas supports Python 3.5+ only. The last version of GeoPandas +- GeoPandas supports Python 3.7+ only. The last version of GeoPandas supporting Python 2 is 0.6. - GeoPandas follows [the PEP 8 diff --git a/README.md b/README.md index 61dcbc0..b66c11f 100644 --- a/README.md +++ b/README.md @@ -1,4 +1,4 @@ -GeoPandas [![build status](https://secure.travis-ci.org/geopandas/geopandas.png?branch=master)](https://travis-ci.org/geopandas/geopandas) [![Coverage Status](https://codecov.io/gh/geopandas/geopandas/branch/master/graph/badge.svg)](https://codecov.io/gh/geopandas/geopandas) [![Join the chat at https://gitter.im/geopandas/geopandas](https://badges.gitter.im/Join%20Chat.svg)](https://gitter.im/geopandas/geopandas?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge) [![Binder](https://mybinder.org/badge.svg)](https://mybinder.org/v2/gh/geopandas/geopandas/master) [![DOI](https://zenodo.org/badge/11002815.svg)](https://zenodo.org/badge/latestdoi/11002815) +GeoPandas [![Actions Status](https://github.com/geopandas/geopandas/workflows/Tests/badge.svg)](https://github.com/geopandas/geopandas/actions?query=workflow%3ATests) [![Coverage Status](https://codecov.io/gh/geopandas/geopandas/branch/main/graph/badge.svg)](https://codecov.io/gh/geopandas/geopandas) [![Join the chat at https://gitter.im/geopandas/geopandas](https://badges.gitter.im/Join%20Chat.svg)](https://gitter.im/geopandas/geopandas?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge) [![Binder](https://mybinder.org/badge.svg)](https://mybinder.org/v2/gh/geopandas/geopandas/main) [![DOI](https://zenodo.org/badge/11002815.svg)](https://zenodo.org/badge/latestdoi/11002815) ========= Python tools for geographic data @@ -35,8 +35,9 @@ for all details. GeoPandas depends on the following packages: - ``shapely`` - ``fiona`` - ``pyproj`` +- ``packaging`` -Further, ``descartes`` and ``matplotlib`` are optional dependencies, required +Further, ``matplotlib`` is an optional dependency, required for plotting, and [``rtree``](https://github.com/Toblerity/rtree) is an optional dependency, required for spatial joins. ``rtree`` requires the C library [``libspatialindex``](https://github.com/libspatialindex/libspatialindex). @@ -67,7 +68,7 @@ Examples 2 POLYGON ((2 0, 3 0, 3 1, 2 1, 2 0)) dtype: geometry -![Example 1](examples/test.png) +![Example 1](doc/source/gallery/test.png) Some geographic operations return normal pandas object. The `area` property of a `GeoSeries` will return a `pandas.Series` containing the area of each item in the `GeoSeries`: @@ -85,9 +86,11 @@ Other operations return GeoPandas objects: 2 POLYGON ((1.5 0, 1.5 1, 1.502407636663901 1.04... dtype: geometry -![Example 2](examples/test_buffer.png) +![Example 2](doc/source/gallery/test_buffer.png) -GeoPandas objects also know how to plot themselves. GeoPandas uses [descartes](https://pypi.python.org/pypi/descartes) to generate a [matplotlib](http://matplotlib.org) plot. To generate a plot of our GeoSeries, use: +GeoPandas objects also know how to plot themselves. GeoPandas uses +[matplotlib](http://matplotlib.org) for plotting. To generate a plot of our +GeoSeries, use: >>> g.plot() @@ -99,22 +102,22 @@ GeoPandas also implements alternate constructors that can read any data format r >>> boros.sort_index(inplace=True) >>> boros BoroName Shape_Leng Shape_Area \ - BoroCode - 1 Manhattan 359299.096471 6.364715e+08 - 2 Bronx 464392.991824 1.186925e+09 - 3 Brooklyn 741080.523166 1.937479e+09 - 4 Queens 896344.047763 3.045213e+09 - 5 Staten Island 330470.010332 1.623820e+09 - - geometry - BoroCode - 1 MULTIPOLYGON (((981219.0557861328 188655.31579... - 2 MULTIPOLYGON (((1012821.805786133 229228.26458... - 3 MULTIPOLYGON (((1021176.479003906 151374.79699... - 4 MULTIPOLYGON (((1029606.076599121 156073.81420... - 5 MULTIPOLYGON (((970217.0223999023 145643.33221... + BoroCode + 1 Manhattan 359299.096471 6.364715e+08 + 2 Bronx 464392.991824 1.186925e+09 + 3 Brooklyn 741080.523166 1.937479e+09 + 4 Queens 896344.047763 3.045213e+09 + 5 Staten Island 330470.010332 1.623820e+09 -![New York City boroughs](examples/nyc.png) + geometry + BoroCode + 1 MULTIPOLYGON (((981219.0557861328 188655.31579... + 2 MULTIPOLYGON (((1012821.805786133 229228.26458... + 3 MULTIPOLYGON (((1021176.479003906 151374.79699... + 4 MULTIPOLYGON (((1029606.076599121 156073.81420... + 5 MULTIPOLYGON (((970217.0223999023 145643.33221... + +![New York City boroughs](doc/source/gallery/nyc.png) >>> boros['geometry'].convex_hull BoroCode @@ -125,4 +128,4 @@ GeoPandas also implements alternate constructors that can read any data format r 5 POLYGON ((915517.6877458114 120121.8812543372,... dtype: geometry -![Convex hulls of New York City boroughs](examples/nyc_hull.png) +![Convex hulls of New York City boroughs](doc/source/gallery/nyc_hull.png) diff --git a/appveyor.yml b/appveyor.yml deleted file mode 100644 index 19d20d9..0000000 --- a/appveyor.yml +++ /dev/null @@ -1,46 +0,0 @@ -# With infos from -# http://tjelvarolsson.com/blog/how-to-continuously-test-your-python-code-on-windows-using-appveyor/ -# https://packaging.python.org/en/latest/appveyor/ -# https://github.com/rmcgibbo/python-appveyor-conda-example - -environment: - matrix: - - PYTHON_VERSION: "3.7" - MINICONDA: C:\Miniconda37-x64 - ENV_FILE: "ci/travis/37-latest-conda-forge.yaml" - - - PYTHON_VERSION: "3.8" - MINICONDA: C:\Miniconda37-x64 - ENV_FILE: "ci/travis/38-latest-conda-forge.yaml" - -# all our python builds have to happen in tests_script... -build: false - -init: - - "ECHO %PYTHON_VERSION% %MINICONDA%" - -install: - # cancel older builds for the same PR - - ps: if ($env:APPVEYOR_PULL_REQUEST_NUMBER -and $env:APPVEYOR_BUILD_NUMBER -ne ((Invoke-RestMethod ` - https://ci.appveyor.com/api/projects/$env:APPVEYOR_ACCOUNT_NAME/$env:APPVEYOR_PROJECT_SLUG/history?recordsNumber=50).builds | ` - Where-Object pullRequestId -eq $env:APPVEYOR_PULL_REQUEST_NUMBER)[0].buildNumber) { ` - throw "There are newer queued builds for this pull request, failing early." } - - # set up environment - - CALL "%MINICONDA%\\Scripts\\activate.bat" - - conda config --set always_yes yes --set show_channel_urls true --set changeps1 no - - conda update conda - # this is basically equivalent to what conda init does. It changes the "conda" to - # be a .bat script that sets appropriate PATH entries before conda hits problems. - # This PATH modification only works with conda 4.6+, but it won't hurt other versions. - - set "PATH=%MINICONDA%\condabin:%PATH%" - - conda info -a - - conda config --add channels conda-forge - - conda config --set channel_priority strict - - conda env create --file="${ENV_FILE}" - -test_script: - # this uses condabin/conda.bat because of our PATH modification above - - conda activate test - - conda list - - pytest geopandas -v diff --git a/benchmarks/geom_methods.py b/benchmarks/geom_methods.py index ab6ac61..0da8b4c 100644 --- a/benchmarks/geom_methods.py +++ b/benchmarks/geom_methods.py @@ -2,7 +2,7 @@ import random import numpy as np from geopandas import GeoSeries -from shapely.geometry import Point, LineString, Polygon +from shapely.geometry import Point, Polygon, MultiPolygon def with_attributes(**attrs): @@ -25,10 +25,15 @@ class Bench: triangles3 = GeoSeries([Polygon([(random.random(), random.random()) for _ in range(3)]) for _ in range(10000)]) + triangles4 = GeoSeries([ + MultiPolygon([ + Polygon([(random.random(), random.random()) for _ in range(3)]) + ]) for _ in range(10000)]) triangle = Polygon([(random.random(), random.random()) for _ in range(3)]) self.triangles, self.triangles2 = triangles, triangles2 self.triangles_big = triangles3 + self.multi_triangles = triangles4 self.triangle = triangle @with_attributes(param_names=['op'], @@ -98,7 +103,10 @@ class Bench: def time_buffer(self, *args): self.points.buffer(2) + def time_explode(self, *args): + self.multi_triangles.explode() + # TODO -# project, interpolate, affine_transform, translate, rotate, scale, skew, explode +# project, interpolate, affine_transform, translate, rotate, scale, skew # cx indexer diff --git a/benchmarks/overlay.py b/benchmarks/overlay.py index 7f1620a..c9cddef 100644 --- a/benchmarks/overlay.py +++ b/benchmarks/overlay.py @@ -1,10 +1,11 @@ from geopandas import GeoDataFrame, GeoSeries, read_file, datasets, overlay -from shapely.geometry import Polygon +import numpy as np +from shapely.geometry import Point, Polygon class Countries: - param_names = ['op'] + param_names = ['how'] params = [('intersection', 'union', 'identity', 'symmetric_difference', 'difference')] @@ -20,13 +21,13 @@ class Countries: self.countries = countries self.capitals = capitals - def time_overlay(self, op): - overlay(self.countries, self.capitals, how=op) + def time_overlay(self, how): + overlay(self.countries, self.capitals, how=how) class Small: - param_names = ['op'] + param_names = ['how'] params = [('intersection', 'union', 'identity', 'symmetric_difference', 'difference')] @@ -41,5 +42,24 @@ class Small: self.df1, self.df2 = df1, df2 - def time_overlay(self, op): - overlay(self.df1, self.df2, how=op) + def time_overlay(self, how): + overlay(self.df1, self.df2, how=how) + + +class ManyPoints: + + param_names = ['how'] + params = [('intersection', 'union', 'identity', 'symmetric_difference', + 'difference')] + + def setup(self, *args): + + points = GeoDataFrame(geometry=[Point(i, i) for i in range(1000)]) + base = np.array([[0, 0], [0, 100], [100, 100], [100, 0]]) + polys = GeoDataFrame( + geometry=[Polygon(base + i * 100) for i in range(10)]) + + self.df1, self.df2 = points, polys + + def time_overlay(self, how): + overlay(self.df1, self.df2, how=how) diff --git a/benchmarks/plotting.py b/benchmarks/plotting.py index 3b4132e..5731bdb 100644 --- a/benchmarks/plotting.py +++ b/benchmarks/plotting.py @@ -7,44 +7,63 @@ import numpy as np class Bench: - param_names = ['geom_type'] - params = [('Point', 'LineString', 'Polygon', 'MultiPolygon', 'mixed')] + param_names = ["geom_type"] + params = [("Point", "LineString", "Polygon", "MultiPolygon", "mixed")] def setup(self, geom_type): - if geom_type == 'Point': + if geom_type == "Point": geoms = GeoSeries([Point(i, i) for i in range(1000)]) - elif geom_type == 'LineString': - geoms = GeoSeries([LineString([(random.random(), random.random()) - for _ in range(5)]) - for _ in range(100)]) - elif geom_type == 'Polygon': - geoms = GeoSeries([Polygon([(random.random(), random.random()) - for _ in range(3)]) - for _ in range(100)]) - elif geom_type == 'MultiPolygon': + elif geom_type == "LineString": geoms = GeoSeries( - [MultiPolygon([Polygon([(random.random(), random.random()) - for _ in range(3)]) - for _ in range(3)]) - for _ in range(20)]) - elif geom_type == 'mixed': + [ + LineString([(random.random(), random.random()) for _ in range(5)]) + for _ in range(100) + ] + ) + elif geom_type == "Polygon": + geoms = GeoSeries( + [ + Polygon([(random.random(), random.random()) for _ in range(3)]) + for _ in range(100) + ] + ) + elif geom_type == "MultiPolygon": + geoms = GeoSeries( + [ + MultiPolygon( + [ + Polygon( + [(random.random(), random.random()) for _ in range(3)] + ) + for _ in range(3) + ] + ) + for _ in range(20) + ] + ) + elif geom_type == "mixed": g1 = GeoSeries([Point(i, i) for i in range(100)]) - g2 = GeoSeries([LineString([(random.random(), random.random()) - for _ in range(5)]) - for _ in range(100)]) - g3 = GeoSeries([Polygon([(random.random(), random.random()) - for _ in range(3)]) - for _ in range(100)]) + g2 = GeoSeries( + [ + LineString([(random.random(), random.random()) for _ in range(5)]) + for _ in range(100) + ] + ) + g3 = GeoSeries( + [ + Polygon([(random.random(), random.random()) for _ in range(3)]) + for _ in range(100) + ] + ) geoms = g1 - geoms.iloc[np.random.randint(0, 100, 50)] = g2 - geoms.iloc[np.random.randint(0, 100, 33)] = g3 + geoms.iloc[np.random.randint(0, 100, 50)] = g2.iloc[:50] + geoms.iloc[np.random.randint(0, 100, 33)] = g3.iloc[:33] print(geoms.geom_type.value_counts()) - df = GeoDataFrame({'geometry': geoms, - 'values': np.random.randn(len(geoms))}) + df = GeoDataFrame({"geometry": geoms, "values": np.random.randn(len(geoms))}) self.geoms = geoms self.df = df @@ -53,5 +72,4 @@ class Bench: self.geoms.plot() def time_plot_values(self, *args): - self.df.plot(column='values') - + self.df.plot(column="values") diff --git a/benchmarks/sindex.py b/benchmarks/sindex.py index 9aeba80..d48bd29 100644 --- a/benchmarks/sindex.py +++ b/benchmarks/sindex.py @@ -1,5 +1,14 @@ -from geopandas import read_file, datasets -from geopandas.sindex import VALID_QUERY_PREDICATES +from shapely.geometry import Point + +from geopandas import read_file, datasets, GeoSeries + + +# Derive list of valid query predicates based on underlying index backend; +# we have to create a non-empty instance of the index to get these +index = GeoSeries([Point(0, 0)]).sindex +predicates = sorted(p for p in index.valid_query_predicates if p is not None) + +geom_types = ("mixed", "points", "polygons") def generate_test_df(): @@ -16,44 +25,70 @@ def generate_test_df(): "points": points[points.is_valid], "polygons": polygons[polygons.is_valid], } + # ensure index is pre-generated + for data_type in data.keys(): + data[data_type].sindex.query(data[data_type].geometry.values.data[0]) return data -class Bench: +class BenchIntersection: - param_names = ["tree_geom_type"] - params = [["mixed", "points", "polygons"]] + param_names = ["input_geom_type", "tree_geom_type"] + params = [ + geom_types, + geom_types, + ] def setup(self, *args): self.data = generate_test_df() # cache bounds so that bound creation is not counted in benchmarks - self.bounds = [g.bounds for g in self.data["mixed"].geometry] + self.bounds = { + data_type: [g.bounds for g in self.data[data_type].geometry] + for data_type in self.data.keys() + } + + def time_intersects(self, input_geom_type, tree_geom_type): + tree = self.data[tree_geom_type].sindex + for bounds in self.bounds[input_geom_type]: + tree.intersection(bounds) + + +class BenchIndexCreation: + + param_names = ["tree_geom_type"] + params = [ + geom_types, + ] + + def setup(self, *args): + self.data = generate_test_df() def time_index_creation(self, tree_geom_type): """Time creation of spatial index. - Note: pygeos will only create the index once; this benchmark - is not intended to be used to compare rtree and pygeos. + Note: requires running a single query to ensure that + lazy-building indexes are actually built. """ - self.data[tree_geom_type]._invalidate_sindex() - self.data[tree_geom_type]._generate_sindex() - - def time_intersects(self, tree_geom_type): - for bounds in self.bounds: - self.data[tree_geom_type].sindex.intersection(bounds) - - def time_intersects_objects(self, tree_geom_type): - for bounds in self.bounds: - self.data[tree_geom_type].sindex.intersection(bounds, objects=True) + # Note: the GeoDataFram._sindex_generated attribute will + # be removed by GH#1444 but is kept here (in the benchmarks + # so that we can compare pre GH#1444 to post GH#1444 if needed + self.data[tree_geom_type]._sindex_generated = None + self.data[tree_geom_type].geometry.values._sindex = None + tree = self.data[tree_geom_type].sindex + # also do a single query to ensure the index is actually + # generated and used + tree.query( + self.data[tree_geom_type].geometry.values.data[0] + ) class BenchQuery: param_names = ["predicate", "input_geom_type", "tree_geom_type"] params = [ - [*VALID_QUERY_PREDICATES], - ["mixed", "points", "polygons"], - ["mixed", "points", "polygons"], + predicates, + geom_types, + geom_types, ] def setup(self, *args): @@ -61,9 +96,14 @@ class BenchQuery: def time_query_bulk(self, predicate, input_geom_type, tree_geom_type): self.data[tree_geom_type].sindex.query_bulk( - self.data[input_geom_type].geometry, predicate=predicate + self.data[input_geom_type].geometry.values.data, + predicate=predicate, ) def time_query(self, predicate, input_geom_type, tree_geom_type): - for geo in self.data[input_geom_type].geometry.sample(10, random_state=0): - self.data[tree_geom_type].sindex.query(geo, predicate=predicate) + tree = self.data[tree_geom_type].sindex + for geom in self.data[input_geom_type].geometry.values.data: + tree.query( + geom, + predicate=predicate + ) diff --git a/benchmarks/sjoin.py b/benchmarks/sjoin.py index 0d06391..81dbacf 100644 --- a/benchmarks/sjoin.py +++ b/benchmarks/sjoin.py @@ -26,5 +26,5 @@ class Bench: self.df1, self.df2 = df1, df2 - def time_sjoin(self, op): - sjoin(self.df1, self.df2, op=op) + def time_sjoin(self, predicate): + sjoin(self.df1, self.df2, predicate=predicate) diff --git a/ci/envs/310-dev.yaml b/ci/envs/310-dev.yaml new file mode 100644 index 0000000..4274d67 --- /dev/null +++ b/ci/envs/310-dev.yaml @@ -0,0 +1,36 @@ +name: test +channels: + - conda-forge +dependencies: + - python=3.10 + - cython + # required + - shapely + - fiona + - pyproj + - geos + - packaging + # testing + - pytest + - pytest-cov + - pytest-xdist + - fsspec + # optional + - rtree + #- geopy + - SQLalchemy + - libspatialite + - pyarrow + - pip + - pip: + - geopy + - mapclassify>=2.4.0 + # dev versions of packages + - --pre --extra-index https://pypi.anaconda.org/scipy-wheels-nightly/simple + - numpy + - pandas + - git+https://github.com/matplotlib/matplotlib.git@main + # - git+https://github.com/Toblerity/Shapely.git@main + - git+https://github.com/pygeos/pygeos.git@master + - git+https://github.com/python-visualization/folium.git@main + - git+https://github.com/geopandas/xyzservices.git@main diff --git a/ci/envs/310-latest-conda-forge.yaml b/ci/envs/310-latest-conda-forge.yaml new file mode 100644 index 0000000..eb4fe0c --- /dev/null +++ b/ci/envs/310-latest-conda-forge.yaml @@ -0,0 +1,34 @@ +name: test +channels: + - conda-forge +dependencies: + - python=3.10 + # required + - pandas + - shapely + - fiona + - pyproj + - pygeos + - packaging + # testing + - pytest + - pytest-cov + - pytest-xdist + - fsspec + # optional + - rtree + - matplotlib-base + - mapclassify + - folium + - xyzservices + - scipy + - geopy + # installed in tests.yaml, because not available on windows + # - postgis + - SQLalchemy + - psycopg2 + - libspatialite + - geoalchemy2 + - pyarrow + # doctest testing + - pytest-doctestplus diff --git a/ci/travis/37-latest-conda-forge.yaml b/ci/envs/37-latest-conda-forge.yaml similarity index 78% rename from ci/travis/37-latest-conda-forge.yaml rename to ci/envs/37-latest-conda-forge.yaml index 80ff961..dadd2c4 100644 --- a/ci/travis/37-latest-conda-forge.yaml +++ b/ci/envs/37-latest-conda-forge.yaml @@ -9,15 +9,19 @@ dependencies: - fiona - pyproj - pygeos + - packaging # testing - pytest - pytest-cov - - codecov + - pytest-xdist + - fsspec # optional - rtree - matplotlib - - descartes - mapclassify + - folium + - xyzservices + - scipy - geopy - SQLalchemy - libspatialite diff --git a/ci/travis/37-latest-defaults.yaml b/ci/envs/37-latest-defaults.yaml similarity index 61% rename from ci/travis/37-latest-defaults.yaml rename to ci/envs/37-latest-defaults.yaml index 5a8839a..071d3ea 100644 --- a/ci/travis/37-latest-defaults.yaml +++ b/ci/envs/37-latest-defaults.yaml @@ -2,27 +2,29 @@ name: test channels: - defaults dependencies: - - python=3.7.3 + - python=3.7 # required - pandas - shapely - fiona - pyproj - geos + - packaging # testing - pytest - pytest-cov - #- codecov + - pytest-xdist + - fsspec # optional - rtree - matplotlib - - descartes #- geopy - SQLalchemy - libspatialite - - pyarrow + - pip - pip: - - codecov - - geopy - - mapclassify - - git+https://github.com/pygeos/pygeos.git + - geopy + - mapclassify + - pyarrow + - folium + - xyzservices diff --git a/ci/travis/35-minimal.yaml b/ci/envs/37-minimal.yaml similarity index 50% rename from ci/travis/35-minimal.yaml rename to ci/envs/37-minimal.yaml index ab18a3e..5fd0714 100644 --- a/ci/travis/35-minimal.yaml +++ b/ci/envs/37-minimal.yaml @@ -3,26 +3,28 @@ channels: - defaults - conda-forge dependencies: - - python=3.5 + - python=3.7 # required - - numpy=1.12 - - pandas==0.23.4 - - shapely=1.5 - - fiona=1.7 + - numpy=1.18 + - pandas==0.25 + - shapely=1.6 + - fiona=1.8.13 + - packaging #- pyproj # testing - pytest - pytest-cov - - codecov + - pytest-xdist + - fsspec # optional - rtree - matplotlib - - descartes - - matplotlib=2.0 - - mapclassify>=2.2.0 + - matplotlib=3.1 + # - mapclassify=2.4.0 - doesn't build due to conflicts - geopy - SQLalchemy - libspatialite - pyarrow + - pip - pip: - - pyproj==2.2.2 + - pyproj==2.2.2 diff --git a/ci/travis/37-dev.yaml b/ci/envs/37-pd10.yaml similarity index 54% rename from ci/travis/37-dev.yaml rename to ci/envs/37-pd10.yaml index 7dd3f16..83cfb24 100644 --- a/ci/travis/37-dev.yaml +++ b/ci/envs/37-pd10.yaml @@ -2,28 +2,29 @@ name: test channels: - defaults dependencies: - - python=3.7.3 - - cython + - python=3.7 # required - - pandas + - pandas=1.0 - shapely - fiona - - pyproj + - numpy=<1.19 + #- pyproj - geos + - packaging # testing - pytest - pytest-cov - #- codecov + - pytest-xdist + - fsspec # optional - rtree - matplotlib - - descartes #- geopy - SQLalchemy - libspatialite - - pyarrow + - pip - pip: - - codecov - - geopy - - mapclassify>=2.2.0 - - git+https://github.com/pygeos/pygeos.git + - pyproj==3.0.1 + - geopy + - mapclassify==2.4.0 + - pyarrow diff --git a/ci/travis/38-latest-conda-forge.yaml b/ci/envs/38-latest-conda-forge.yaml similarity index 61% rename from ci/travis/38-latest-conda-forge.yaml rename to ci/envs/38-latest-conda-forge.yaml index d19642f..6d2348f 100644 --- a/ci/travis/38-latest-conda-forge.yaml +++ b/ci/envs/38-latest-conda-forge.yaml @@ -4,25 +4,31 @@ channels: dependencies: - python=3.8 # required - - pandas + - pandas=1.2 - shapely - fiona - pyproj - pygeos + - packaging # testing - pytest - pytest-cov - - codecov + - pytest-xdist + - fsspec # optional - rtree - matplotlib - - descartes - mapclassify + - folium + - xyzservices + - scipy - geopy - # installed in travis.yml, because not available on windows + # installed in tests.yaml, because not available on windows # - postgis - SQLalchemy - psycopg2 - libspatialite - geoalchemy2 - pyarrow + # doctest testing + - pytest-doctestplus diff --git a/ci/travis/38-no-optional-deps.yaml b/ci/envs/38-no-optional-deps.yaml similarity index 83% rename from ci/travis/38-no-optional-deps.yaml rename to ci/envs/38-no-optional-deps.yaml index d6fe127..7261cc6 100644 --- a/ci/travis/38-no-optional-deps.yaml +++ b/ci/envs/38-no-optional-deps.yaml @@ -8,7 +8,8 @@ dependencies: - shapely - fiona - pyproj + - packaging # testing - pytest - pytest-cov - - codecov + - pytest-xdist diff --git a/ci/envs/39-latest-conda-forge.yaml b/ci/envs/39-latest-conda-forge.yaml new file mode 100644 index 0000000..49c7f64 --- /dev/null +++ b/ci/envs/39-latest-conda-forge.yaml @@ -0,0 +1,35 @@ +name: test +channels: + - conda-forge +dependencies: + - python=3.9 + # required + - pandas=1.3 + - shapely + - fiona + - pyproj + - pygeos + - packaging + # testing + - pytest + - pytest-cov + - pytest-xdist + - fsspec + # optional + - rtree + - matplotlib + - mapclassify + - folium + - xyzservices + - scipy + - geopy + # installed in tests.yaml, because not available on windows + # - postgis + - SQLalchemy + - psycopg2 + - libspatialite + - geoalchemy2 + - pyarrow + # doctest testing + - pytest-doctestplus + diff --git a/ci/scripts/setup_postgres.sh b/ci/scripts/setup_postgres.sh new file mode 100644 index 0000000..1a5a3d7 --- /dev/null +++ b/ci/scripts/setup_postgres.sh @@ -0,0 +1,33 @@ +#!/bin/sh +set -e + +if [ -z "${PGUSER}" ] || [ -z "${PGPORT}" ]; then + echo "Environment variables PGUSER and PGPORT must be set" + exit 1 +fi + +PGDATA=$(mktemp -d /tmp/postgres.XXXXXX) +echo "Setting up PostgreSQL in ${PGDATA} on port ${PGPORT}" + +pg_ctl -D ${PGDATA} initdb +pg_ctl -D ${PGDATA} start + +SOCKETPATH="/tmp/.s.PGSQL.${PGPORT}" +echo -n 'waiting for postgres' +while [ ! -e ${SOCKETPATH} ]; do + sleep 1 + echo -n '.' +done +echo + +echo "Done setting up PostgreSQL. When finished, stop and cleanup using:" +echo +echo " pg_ctl -D ${PGDATA} stop" +echo " rm -rf ${PGDATA}" +echo + +createuser -U ${USER} -s ${PGUSER} +createdb --owner=${PGUSER} test_geopandas +psql -d test_geopandas -q -c "CREATE EXTENSION postgis" + +echo "PostGIS server ready." diff --git a/ci/travis/36-pd023.yaml b/ci/travis/36-pd023.yaml deleted file mode 100644 index 0fcd294..0000000 --- a/ci/travis/36-pd023.yaml +++ /dev/null @@ -1,31 +0,0 @@ -name: test -channels: - - defaults -dependencies: - - python=3.6 - - pip - # required - - pandas==0.23.4 - - nomkl - - shapely - - gdal=2.3 - - fiona - #- pyproj - - geos - # testing - - pytest - - pytest-cov - #- codecov - # optional - - rtree - - matplotlib=2 - - descartes - #- geopy - - SQLalchemy - - libspatialite - - pip: - - pyproj==2.3.1 - - geopy - - codecov - - mapclassify>=2.2.0 - - git+https://github.com/pygeos/pygeos.git diff --git a/ci/travis/36-pd024.yaml b/ci/travis/36-pd024.yaml deleted file mode 100644 index fcb46e7..0000000 --- a/ci/travis/36-pd024.yaml +++ /dev/null @@ -1,29 +0,0 @@ -name: test -channels: - - defaults -dependencies: - - python=3.6 - # required - - pandas=0.24 - - shapely - - fiona=1.7 - #- pyproj - - geos - # testing - - pytest - - pytest-cov - #- codecov - # optional - - rtree - - matplotlib==2.0.2 - - descartes - #- geopy - - SQLalchemy - - libspatialite - - pyarrow - - pip: - - pyproj - - codecov - - geopy - - mapclassify>=2.2.0 - - git+https://github.com/pygeos/pygeos.git diff --git a/ci/travis/setup_postgres.sh b/ci/travis/setup_postgres.sh deleted file mode 100644 index 96645f3..0000000 --- a/ci/travis/setup_postgres.sh +++ /dev/null @@ -1,21 +0,0 @@ -#!/bin/bash -e - -echo "Setting up Postgresql" - -mkdir -p ${HOME}/var -rm -rf ${HOME}/var/db - -pg_ctl initdb -D ${HOME}/var/db -pg_ctl start -D ${HOME}/var/db - -echo -n 'waiting for postgres' -while [ ! -e /tmp/.s.PGSQL.5432 ]; do - sleep 1 - echo -n '.' -done - -createuser -U travis -s postgres -createdb --owner=postgres test_geopandas -psql -d test_geopandas -q -c "CREATE EXTENSION postgis" - -echo "Done setting up Postgresql" diff --git a/codecov.yml b/codecov.yml new file mode 100644 index 0000000..c6d92a6 --- /dev/null +++ b/codecov.yml @@ -0,0 +1,6 @@ +coverage: + status: + project: + default: + target: 95% # the required coverage value + threshold: 0.2% # the leniency in hitting the target diff --git a/doc/Makefile b/doc/Makefile index 4ce53c3..2844e8d 100644 --- a/doc/Makefile +++ b/doc/Makefile @@ -41,7 +41,6 @@ help: clean: -rm -rf $(BUILDDIR)/* -rm -rf source/reference/* - -rm -rf source/gallery/* html: $(SPHINXBUILD) -b html $(ALLSPHINXOPTS) $(BUILDDIR)/html diff --git a/doc/environment.yml b/doc/environment.yml index 90614a6..bd8b4ae 100644 --- a/doc/environment.yml +++ b/doc/environment.yml @@ -1,34 +1,45 @@ name: geopandas_docs channels: -- conda-forge + - conda-forge dependencies: -- python=3.7 -- pandas=1.0.1 -- shapely=1.7.0 -- fiona=1.8.13 -- pyproj=2.4.2.post1 -- rtree=0.9.4 -- geopy=1.21.0 -- matplotlib=3.1.3 -- descartes=1.1.0 -- mapclassify=2.2.0 -- sphinx=2.4.1 -- sphinx_rtd_theme=0.4.3 -- numpydoc=0.9.2 -- recommonmark==0.6.0 -- ipython=7.12.0 -- pillow=7.0.0 -- mock=3.0.5 -- cartopy=0.17.0 -- contextily=1.0rc2 -- rasterio=1.1.1 -- geoplot=0.4.0 -# 0.5.0 has a bug (https://github.com/sphinx-gallery/sphinx-gallery/issues/568) -- sphinx-gallery=0.4.0 -- jinja2=2.11.1 -- doc2dash -# specify additional dependencies to reduce solving for conda -- gdal=3.0.4 -- libgdal=3.0.4 -- proj=6.3.0 -- geos=3.8.0 + - python=3.9.7 + - pandas=1.3.2 + - shapely=1.7.1 + - fiona=1.8.20 + - pyproj=3.2.1 + - rtree=0.9.7 + - geopy=2.2.0 + - matplotlib=3.4.3 + - mapclassify=2.4.3 + - sphinx=4.2.0 + - pydata-sphinx-theme=0.6.3 + - numpydoc=1.1.0 + - ipython=7.27.0 + - pillow=8.3.2 + - mock=4.0.3 + - cartopy=0.20.0 + - pyepsg=0.4.0 + - contextily=1.1.0 + - rasterio=1.2.8 + - geoplot=0.4.4 + - sphinx-gallery=0.9.0 + - jinja2=3.0.1 + - doc2dash=2.3.0 + - matplotlib-scalebar=0.7.2 + # specify additional dependencies to reduce solving for conda + - gdal=3.3.2 + - libgdal=3.3.2 + - proj=8.0.1 + - geos=3.9.1 + - nbsphinx=0.8.7 + - jupyter_client=7.0.3 + - ipykernel=6.4.1 + - myst-parser=0.15.2 + - folium=0.12.0 + - libpysal=4.5.1 + - pygeos=0.10.2 + - xyzservices=2021.9.1 + - packaging=21.0 + - pip + - pip: + - sphinx-toggleprompt diff --git a/doc/source/_static/binary_geo-difference.svg b/doc/source/_static/binary_geo-difference.svg new file mode 100644 index 0000000..d430d25 --- /dev/null +++ b/doc/source/_static/binary_geo-difference.svg @@ -0,0 +1 @@ + \ No newline at end of file diff --git a/doc/source/_static/binary_geo-intersection.svg b/doc/source/_static/binary_geo-intersection.svg new file mode 100644 index 0000000..2a06f5b --- /dev/null +++ b/doc/source/_static/binary_geo-intersection.svg @@ -0,0 +1 @@ + \ No newline at end of file diff --git a/doc/source/_static/binary_geo-symm_diff.svg b/doc/source/_static/binary_geo-symm_diff.svg new file mode 100644 index 0000000..f33736b --- /dev/null +++ b/doc/source/_static/binary_geo-symm_diff.svg @@ -0,0 +1 @@ + \ No newline at end of file diff --git a/doc/source/_static/binary_geo-union.svg b/doc/source/_static/binary_geo-union.svg new file mode 100644 index 0000000..1c6901a --- /dev/null +++ b/doc/source/_static/binary_geo-union.svg @@ -0,0 +1 @@ + \ No newline at end of file diff --git a/doc/source/_static/binary_op-01.svg b/doc/source/_static/binary_op-01.svg new file mode 100644 index 0000000..3bedcb6 --- /dev/null +++ b/doc/source/_static/binary_op-01.svg @@ -0,0 +1 @@ + \ No newline at end of file diff --git a/doc/source/_static/binary_op-02.svg b/doc/source/_static/binary_op-02.svg new file mode 100644 index 0000000..a8d4087 --- /dev/null +++ b/doc/source/_static/binary_op-02.svg @@ -0,0 +1 @@ + \ No newline at end of file diff --git a/doc/source/_static/binary_op-03.svg b/doc/source/_static/binary_op-03.svg new file mode 100644 index 0000000..37b1fa6 --- /dev/null +++ b/doc/source/_static/binary_op-03.svg @@ -0,0 +1 @@ + \ No newline at end of file diff --git a/doc/source/_static/code/buffer.py b/doc/source/_static/code/buffer.py new file mode 100644 index 0000000..427ff52 --- /dev/null +++ b/doc/source/_static/code/buffer.py @@ -0,0 +1,43 @@ +""" +Create an illustrative figure for different kwargs +in buffer method. +""" + + +import geopandas +import matplotlib.pyplot as plt + +from shapely.geometry import Point, LineString, Polygon + +s = geopandas.GeoSeries( + [ + Point(0, 0), + LineString([(1, -1), (1, 0), (2, 0), (2, 1)]), + Polygon([(3, -1), (4, 0), (3, 1)]), + ] +) + +fix, axs = plt.subplots( + 3, 2, figsize=(12, 12), sharex=True, sharey=True +) +for ax in axs.flatten(): + s.plot(ax=ax) + ax.set(xticks=[], yticks=[]) + +s.buffer(0.2).plot(ax=axs[0, 0], alpha=0.6) +axs[0, 0].set_title("s.buffer(0.2)") + +s.buffer(0.2, resolution=2).plot(ax=axs[0, 1], alpha=0.6) +axs[0, 1].set_title("s.buffer(0.2, resolution=2)") + +s.buffer(0.2, cap_style=2).plot(ax=axs[1, 0], alpha=0.6) +axs[1, 0].set_title("s.buffer(0.2, cap_style=2)") + +s.buffer(0.2, cap_style=3).plot(ax=axs[1, 1], alpha=0.6) +axs[1, 1].set_title("s.buffer(0.2, cap_style=3)") + +s.buffer(0.2, join_style=2).plot(ax=axs[2, 0], alpha=0.6) +axs[2, 0].set_title("s.buffer(0.2, join_style=2)") + +s.buffer(0.2, join_style=3).plot(ax=axs[2, 1], alpha=0.6) +axs[2, 1].set_title("s.buffer(0.2, join_style=3)") diff --git a/doc/source/_static/custom.css b/doc/source/_static/custom.css index e32de33..505f2b5 100644 --- a/doc/source/_static/custom.css +++ b/doc/source/_static/custom.css @@ -1,17 +1,34 @@ -/*This ensures that clickable links in the SG examples are the right color*/ -div.section a span { - color: #2980B9 !important +/* colors */ + +:root { + --pst-color-primary: 19, 156, 90; + --pst-color-active-navigation: 19, 156, 90; + --pst-color-h2: var(--color-text-base); } -/*Copied from sphinx' basic.css to ensure the sphinx >2.0 docstrings are -rendered somewhat properly (xref https://github.com/numpy/numpydoc/issues/215) */ +/* buttons */ -.classifier { - font-style: oblique; +.button>p>a { + box-shadow: 0px 4px 14px -7px #999999; + background-color: white; + border: 1px solid #bbbbbb; + display: inline-block; + cursor: pointer; + color: #139C5A; + padding: 1em 1em; + text-align: center; + text-decoration: none; + font-size: 140%; + margin: 2%; + width: 40%; } -.classifier:before { - font-style: normal; - margin: 0.5em; - content: ":"; +.button>p>a:hover { + border-color: #139C5A; + color: #e32e00; +} + +.button>p>a:active { + position: relative; + top: 1px; } diff --git a/doc/source/_static/dataframe.svg b/doc/source/_static/dataframe.svg new file mode 100644 index 0000000..20f8676 --- /dev/null +++ b/doc/source/_static/dataframe.svg @@ -0,0 +1,202 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/doc/source/_static/logo/favicon.png b/doc/source/_static/logo/favicon.png new file mode 100644 index 0000000..d77c9e2 Binary files /dev/null and b/doc/source/_static/logo/favicon.png differ diff --git a/doc/source/_static/logo/geopandas_icon.png b/doc/source/_static/logo/geopandas_icon.png new file mode 100644 index 0000000..234ea95 Binary files /dev/null and b/doc/source/_static/logo/geopandas_icon.png differ diff --git a/doc/source/_static/logo/geopandas_icon.svg b/doc/source/_static/logo/geopandas_icon.svg new file mode 100644 index 0000000..2399f36 --- /dev/null +++ b/doc/source/_static/logo/geopandas_icon.svg @@ -0,0 +1 @@ + \ No newline at end of file diff --git a/doc/source/_static/logo/geopandas_icon_green.png b/doc/source/_static/logo/geopandas_icon_green.png new file mode 100644 index 0000000..8c2eb17 Binary files /dev/null and b/doc/source/_static/logo/geopandas_icon_green.png differ diff --git a/doc/source/_static/logo/geopandas_icon_green.svg b/doc/source/_static/logo/geopandas_icon_green.svg new file mode 100644 index 0000000..dac4718 --- /dev/null +++ b/doc/source/_static/logo/geopandas_icon_green.svg @@ -0,0 +1 @@ + \ No newline at end of file diff --git a/doc/source/_static/logo/geopandas_logo.png b/doc/source/_static/logo/geopandas_logo.png new file mode 100644 index 0000000..b12f40d Binary files /dev/null and b/doc/source/_static/logo/geopandas_logo.png differ diff --git a/doc/source/_static/logo/geopandas_logo.svg b/doc/source/_static/logo/geopandas_logo.svg new file mode 100644 index 0000000..42ae211 --- /dev/null +++ b/doc/source/_static/logo/geopandas_logo.svg @@ -0,0 +1 @@ + \ No newline at end of file diff --git a/doc/source/_static/logo/geopandas_logo_green.png b/doc/source/_static/logo/geopandas_logo_green.png new file mode 100644 index 0000000..f6b80c8 Binary files /dev/null and b/doc/source/_static/logo/geopandas_logo_green.png differ diff --git a/doc/source/_static/logo/geopandas_logo_green.svg b/doc/source/_static/logo/geopandas_logo_green.svg new file mode 100644 index 0000000..4cc8617 --- /dev/null +++ b/doc/source/_static/logo/geopandas_logo_green.svg @@ -0,0 +1 @@ + \ No newline at end of file diff --git a/doc/source/_static/logo/geopandas_logo_web.svg b/doc/source/_static/logo/geopandas_logo_web.svg new file mode 100644 index 0000000..276e714 --- /dev/null +++ b/doc/source/_static/logo/geopandas_logo_web.svg @@ -0,0 +1,62 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/doc/source/_templates/accessor_callable.rst b/doc/source/_templates/accessor_callable.rst new file mode 100644 index 0000000..af5e103 --- /dev/null +++ b/doc/source/_templates/accessor_callable.rst @@ -0,0 +1,6 @@ +{{ fullname }} +{{ underline }} + +.. currentmodule:: {{ module.split('.')[0] }} + +.. automethod:: {{ (module.split('.')[1:] + [objname]) | join('.') }} diff --git a/doc/source/_templates/redirect.html b/doc/source/_templates/redirect.html new file mode 100644 index 0000000..9bb345f --- /dev/null +++ b/doc/source/_templates/redirect.html @@ -0,0 +1,10 @@ +{% set redirect = redirects[pagename.split("/")[-1]] %} + + + + This page has moved + + +

This page has moved here.

+ + diff --git a/doc/source/about.md b/doc/source/about.md new file mode 100644 index 0000000..2e2f061 --- /dev/null +++ b/doc/source/about.md @@ -0,0 +1,53 @@ +# About GeoPandas + +```{toctree} +:maxdepth: 2 +:caption: About +:hidden: + +Team +Citing +Logo +``` + + +GeoPandas is an open source project to add support for geographic data to pandas objects. It +currently implements `GeoSeries` and `GeoDataFrame` types which are subclasses of +`pandas.Series` and `pandas.DataFrame` respectively. GeoPandas objects can act on +`shapely` geometry objects and perform geometric operations. + +GeoPandas is a community-led project written, used and supported by a wide range of +people from all around of world of a large variety of backgrounds. Want to get involved +in the community? See our [community guidelines](community). + +GeoPandas will always be 100% open source software, free for all to use and released +under the liberal terms of the BSD-3-Clause license. + +```{container} button + +{doc}`Team ` +{doc}`Citing ` {doc}`Logo ` +``` + +## Project history + +Kelsey Jordahl founded GeoPandas project in 2013 during the Scipy Conference and +released a version 0.1.0 in July 2014. In 2016, Joris Van den Bossche took the lead and +became the maintainer of the project. Since the beginning, GeoPandas is a BSD-licensed +open-source project supported by a [community of +contributors](https://github.com/geopandas/geopandas/graphs/contributors) from around +the world and is now maintained by a [team](about/team) of core developers. + +In 2020 GeoPandas became [NumFOCUS Affiliated +Project](https://numfocus.org/sponsored-projects/affiliated-projects) and received two +[Small Development Grants](https://numfocus.org/programs/sustainability) to support its +development. + +## Timeline + +- **2013**: Beginning of the development +- **2014**: GeoPandas 0.1.0 released +- **2020**: GeoPandas became [NumFOCUS Affiliated + Project](https://numfocus.org/sponsored-projects/affiliated-projects) + + diff --git a/doc/source/about/citing.md b/doc/source/about/citing.md new file mode 100644 index 0000000..e01ef47 --- /dev/null +++ b/doc/source/about/citing.md @@ -0,0 +1,50 @@ +# Citing + +When citing GeoPandas, you can use [Zenodo DOI](https://zenodo.org/record/3946761#.Xy24LC2ZPOQ) for each release. +Below is the example of resulting BiBTeX record for GeoPandas 0.8.1 and a reference using APA 6th ed. + +_Kelsey Jordahl, Joris Van den Bossche, Martin Fleischmann, Jacob Wasserman, James McBride, Jeffrey Gerard, … François Leblanc. (2020, July 15). geopandas/geopandas: v0.8.1 (Version v0.8.1). Zenodo. http://doi.org/10.5281/zenodo.3946761_ + + +``` +@software{kelsey_jordahl_2020_3946761, + author = {Kelsey Jordahl and + Joris Van den Bossche and + Martin Fleischmann and + Jacob Wasserman and + James McBride and + Jeffrey Gerard and + Jeff Tratner and + Matthew Perry and + Adrian Garcia Badaracco and + Carson Farmer and + Geir Arne Hjelle and + Alan D. Snow and + Micah Cochran and + Sean Gillies and + Lucas Culbertson and + Matt Bartos and + Nick Eubank and + maxalbert and + Aleksey Bilogur and + Sergio Rey and + Christopher Ren and + Dani Arribas-Bel and + Leah Wasser and + Levi John Wolf and + Martin Journois and + Joshua Wilson and + Adam Greenhall and + Chris Holdgraf and + Filipe and + François Leblanc}, + title = {geopandas/geopandas: v0.8.1}, + month = jul, + year = 2020, + publisher = {Zenodo}, + version = {v0.8.1}, + doi = {10.5281/zenodo.3946761}, + url = {https://doi.org/10.5281/zenodo.3946761} +} +``` + diff --git a/doc/source/about/logo.md b/doc/source/about/logo.md new file mode 100644 index 0000000..9910f69 --- /dev/null +++ b/doc/source/about/logo.md @@ -0,0 +1,84 @@ +# GeoPandas logo + +GeoPandas project uses a logo derived from [`pandas` logo](https://pandas.pydata.org/about/citing.html), enclosing it in a globe illustrating the geographic nature of our data. + +## Versions + +We have four versions of our logo: + +### Primary logo + +The primary logo should be used in a majority of cases. Inverted logo or icon should be used only when necessary. + +```{image} ../_static/logo/geopandas_logo.png +:alt: geopandas-logo +:align: center +``` + +### Inverted colors + +If you want to place the GeoPandas logo on a dark background, use the inverted version. + +```{image} ../_static/logo/geopandas_logo_green.png +:alt: geopandas-logo-green +:align: center +``` + +### Icon + +Although it is possible to use icon independently, we would prefer using the complete variant above. + +```{image} ../_static/logo/geopandas_icon.png +:alt: geopandas-icon +:width: 25% +:align: center +``` + +### Inverted icon + +```{image} ../_static/logo/geopandas_icon_green.png +:alt: geopandas-icon-green +:width: 25% +:align: center +``` + +## Download + +You can download all version in SVG and PNG from [GitHub repository](https://github.com/geopandas/geopandas/tree/main/doc/source/_static/logo). + + +## Colors + +Pink and yellow accent colors are shared with `pandas`. + +### Green +```{raw} html + + + +``` +**HEX:** #139C5A + +**RGB:** (19, 156, 90) + +### Yellow +```{raw} html + + + +``` +**HEX:** #FFCA00 + +**RGB:** (255, 202, 0) + +### Pink +```{raw} html + + + +``` +**HEX:** #E70488 + +**RGB:** ((31, 4, 136) + + diff --git a/doc/source/about/roadmap.md b/doc/source/about/roadmap.md new file mode 100644 index 0000000..a4ab6d9 --- /dev/null +++ b/doc/source/about/roadmap.md @@ -0,0 +1,5 @@ +# Roadmap + +## Roadmap for GeoPandas 1.0 + +WIP diff --git a/doc/source/about/team.md b/doc/source/about/team.md new file mode 100644 index 0000000..fb277cd --- /dev/null +++ b/doc/source/about/team.md @@ -0,0 +1,20 @@ +# Team + +## Contributors + +GeoPandas is developed by more than [100 volunteer contributors](https://github.com/geopandas/geopandas/graphs/contributors). + +## Core developers +- Joris Van den Bossche - **lead maintainer** | [@jorisvandenbossche](https://github.com/jorisvandenbossche) +- Martin Fleischmann | [@martinfleis](https://github.com/martinfleis) +- James McBride | [@jdmcbr](https://github.com/jdmcbr) +- Brendan Ward | [@brendan-ward](https://github.com/brendan-ward) +- Levi Wolf | [@ljwolf](https://github.com/ljwolf) + +## Founder + +- Kelsey Jordahl | [@kjordahl](https://github.com/kjordahl) + +## Alumni developers + +- Jacob Wasserman | [@jwass](https://github.com/jwass) diff --git a/doc/source/changelog.rst b/doc/source/changelog.rst deleted file mode 100644 index 5ec53ae..0000000 --- a/doc/source/changelog.rst +++ /dev/null @@ -1 +0,0 @@ -.. include:: ../../CHANGELOG.md diff --git a/doc/source/community.rst b/doc/source/community.rst new file mode 100644 index 0000000..409b85d --- /dev/null +++ b/doc/source/community.rst @@ -0,0 +1,31 @@ +Community +--------- + +GeoPandas is a community-led project written, used and supported by a wide range of +people from all around of world of a large variety of backgrounds. Everyone is welcome, +each small contribution, no matter if it is a fix of a typo in the documentation, bug +report, an idea, or a question, is valuable. As a member of our community, you should +adhere to the principles presented in the :doc:`Code of Conduct +`. + +If you'd like to contribute, please read the :doc:`Contributing guide +`. It will help you to understand the way GeoPandas development +works and us to review your contribution. + +GeoPandas is a part of the broader Python :doc:`ecosystem `. It +depends on a range of great tools, and various packages are built on top of GeoPandas +addressing specific needs in geospatial data processing, analysis and visualization. + +.. container:: button + + :doc:`Contributing ` :doc:`Code of Conduct ` + :doc:`Ecosystem ` + +.. toctree:: + :maxdepth: 2 + :caption: Community + :hidden: + + Contributing + Code of Conduct + Ecosystem diff --git a/doc/source/code_of_conduct.rst b/doc/source/community/code_of_conduct.rst similarity index 99% rename from doc/source/code_of_conduct.rst rename to doc/source/community/code_of_conduct.rst index e80db51..332f809 100644 --- a/doc/source/code_of_conduct.rst +++ b/doc/source/community/code_of_conduct.rst @@ -92,7 +92,7 @@ free to contact the Code of Conduct Committee at 8. **A simple apology can go a long way**. It can often de-escalate a situation, and telling someone that you are sorry is an act of empathy that doesn’t - automatically imply an admission of guilt. + automatically imply an admission of guilt. Reporting --------- diff --git a/doc/source/contributing.rst b/doc/source/community/contributing.rst similarity index 70% rename from doc/source/contributing.rst rename to doc/source/community/contributing.rst index 99db144..21444db 100644 --- a/doc/source/contributing.rst +++ b/doc/source/community/contributing.rst @@ -21,11 +21,9 @@ In particular, when submitting a pull request: - All existing tests should pass. Please make sure that the test suite passes, both locally and on - `Travis CI `_. Status on - Travis will be visible on a pull request. If you want to enable - Travis CI on your own fork, please read the pandas guidelines link - above or the - `getting started docs `_. + `GitHub Actions `_. Status on + GHA will be visible on a pull request. GHA are automatically enabled + on your own fork as well. To trigger a check, make a PR to your own fork. - New functionality should include tests. Please write reasonable tests for your code and make sure that they pass on your pull request. @@ -46,7 +44,7 @@ In particular, when submitting a pull request: imports when possible, and explicit relative imports for local imports when necessary in tests. -- GeoPandas supports Python 3.5+ only. The last version of GeoPandas +- GeoPandas supports Python 3.7+ only. The last version of GeoPandas supporting Python 2 is 0.6. @@ -84,7 +82,7 @@ Some great resources for learning Git: * Software Carpentry's `Git Tutorial `_ * `Atlassian `_ * the `GitHub help pages `_. -* Matthew Brett's `Pydagogue `_. +* Matthew Brett's `Pydagogue `_. Getting started with Git ~~~~~~~~~~~~~~~~~~~~~~~~ @@ -109,16 +107,14 @@ want to clone your fork to your machine:: This creates the directory `geopandas-yourname` and connects your repository to the upstream (main project) *GeoPandas* repository. -The testing suite will run automatically on Travis-CI once your pull request is -submitted. However, if you wish to run the test suite on a branch prior to -submitting the pull request, then Travis-CI needs to be hooked up to your -GitHub repository. Instructions for doing so are `here -`__. +The testing suite will run automatically on GitHub Actions once your pull request is +submitted. The test suite will also automatically run on your branch so you can +check it prior to submitting the pull request. Creating a branch ~~~~~~~~~~~~~~~~~~ -You want your master branch to reflect only production-ready code, so create a +You want your main branch to reflect only production-ready code, so create a feature branch for making your changes. For example:: git branch shiny-new-feature @@ -133,12 +129,12 @@ changes in this branch specific to one bug or feature so it is clear what the branch brings to *GeoPandas*. You can have many shiny-new-features and switch in between them using the git checkout command. -To update this branch, you need to retrieve the changes from the master branch:: +To update this branch, you need to retrieve the changes from the main branch:: git fetch upstream - git rebase upstream/master + git rebase upstream/main -This will replay your commits on top of the latest GeoPandas git master. If this +This will replay your commits on top of the latest GeoPandas git main. If this leads to merge conflicts, you must resolve these before submitting your pull request. If you have uncommitted changes, you will need to ``stash`` them prior to updating. This will effectively store your changes and they can be reapplied @@ -159,7 +155,23 @@ An easy way to create a *GeoPandas* development environment is as follows: - Make sure that you have :ref:`cloned the repository ` - ``cd`` to the *geopandas** source directory -Tell conda to create a new environment, named ``geopandas_dev``, or any other name you would like +Using the provided environment +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +*GeoPandas* provides an environment which includes the required dependencies for development. +The environment file is located in the top level of the repo and is named ``environment-dev.yml``. +You can create this environment by navigating to the the *GeoPandas* source directory +and running:: + + conda env create -f environment-dev.yml + +This will create a new conda environment named ``geopandas_dev``. + +Creating the environment manually +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +Alternatively, it is possible to create a development environment manually. To do this, +tell conda to create a new environment named ``geopandas_dev``, or any other name you would like for this environment, by running:: conda create -n geopandas_dev python @@ -167,6 +179,9 @@ for this environment, by running:: This will create the new environment, and not touch any of your existing environments, nor any existing python installation. +Working with the environment +~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + To work in this environment, you need to ``activate`` it. The instructions below should work for both Windows, Mac and Linux:: @@ -187,12 +202,14 @@ See the full conda docs `here `__. At this point you can easily do a *development* install, as detailed in the next sections. + 3) Installing Dependencies -------------------------- To run *GeoPandas* in an development environment, you must first install -*GeoPandas*'s dependencies. We suggest doing so using the following commands -(executed after your development environment has been activated):: +*GeoPandas*'s dependencies. If you used the provided environment in section 2, skip this +step and continue to section 4. If you created the environment manually, we suggest installing +dependencies using the following commands (executed after your development environment has been activated):: conda install -c conda-forge pandas fiona shapely pyproj rtree pytest @@ -251,27 +268,42 @@ install *GeoPandas*) by typing:: 6) Updating the Documentation ----------------------------- -*GeoPandas* documentation resides in the `doc` folder. Changes to the docs are -make by modifying the appropriate file in the `source` folder within `doc`. -*GeoPandas* docs use reStructuredText syntax, `which is explained here `_ -and the docstrings follow the `Numpy Docstring standard `_. +*GeoPandas* documentation resides in the ``doc`` folder. Changes to the docs are made by +modifying the appropriate file in the ``source`` folder within ``doc``. *GeoPandas* docs use +mixture of reStructuredText syntax for ``rst`` files, `which is explained here +`_ and MyST syntax for ``md`` +files `explained here `_. +The docstrings follow the `Numpy Docstring standard +`_. Some pages +and examples are Jupyter notebooks converted to docs using `nbsphinx +`_. Jupyter notebooks should be stored without the output. + +We highly encourage you to follow the `Google developer documentation style guide +`_ when updating or creating new documentation. Once you have made your changes, you may try if they render correctly by -building the docs using sphinx. To do so, you can navigate to the `doc` folder +building the docs using sphinx. To do so, you can navigate to the `doc` folder:: + + cd doc + and type:: make html -The resulting html pages will be located in `doc/build/html`. In case of any -errors, you can try to use `make html` within a new environment based on -environment.yml specification in the `doc` folder. Using conda:: +The resulting html pages will be located in ``doc/build/html``. +In case of any errors, you can try to use ``make html`` within a new environment based on +environment.yml specification in the ``doc`` folder. You may need to register Jupyter kernel as +``geopandas_docs``. Using conda:: + + cd doc conda env create -f environment.yml conda activate geopandas_docs + python -m ipykernel install --user --name geopandas_docs make html -For minor updates, you can skip whole `make html` part as reStructuredText syntax -is usually quite straightforward. +For minor updates, you can skip the ``make html`` part as reStructuredText and MyST +syntax are usually quite straightforward. 7) Submitting a Pull Request @@ -292,19 +324,19 @@ and uses `Black `_ and `Flake8 `_ to ensure a consistent code format throughout the project. -Continuous Integration (Travis CI) will run those tools and +Continuous Integration (GitHub Actions) will run those tools and report any stylistic errors in your code. Therefore, it is helpful before submitting code to run the check yourself:: black geopandas - git diff upstream/master -u -- "*.py" | flake8 --diff + git diff upstream/main -u -- "*.py" | flake8 --diff to auto-format your code. Additionally, many editors have plugins that will apply ``black`` as you edit files. Optionally (but recommended), you can setup `pre-commit hooks `_ -to automatically run ``black`` and ``flake8`` when you make a git commit. This -can be done by installing ``pre-commit``:: +to automatically run ``black`` and ``flake8`` when you make a git commit. If you did not +use the provided development environment in ``environment-dev.yml``, you must first install ``pre-commit``:: $ python -m pip install pre-commit @@ -316,3 +348,31 @@ From the root of the geopandas repository, you should then install the Then ``black`` and ``flake8`` will be run automatically each time you commit changes. You can skip these checks with ``git commit --no-verify``. + +Commit message conventions +-------------------------- + +Commit your changes to your local repository with an explanatory message. GeoPandas +uses the pandas convention for commit message prefixes and layout. Here are +some common prefixes along with general guidelines for when to use them: + +* ENH: Enhancement, new functionality +* BUG: Bug fix +* DOC: Additions/updates to documentation +* TST: Additions/updates to tests +* BLD: Updates to the build process/scripts +* PERF: Performance improvement +* TYP: Type annotations +* CLN: Code cleanup + +The following defines how a commit message should be structured. Please refer to the +relevant GitHub issues in your commit message using GH1234 or #1234. Either style +is fine, but the former is generally preferred: + +* a subject line with `< 80` chars. +* One blank line. +* Optionally, a commit message body. + +Now you can commit your changes in your local repository:: + + git commit -m diff --git a/doc/source/community/ecosystem.md b/doc/source/community/ecosystem.md new file mode 100644 index 0000000..52dc4b1 --- /dev/null +++ b/doc/source/community/ecosystem.md @@ -0,0 +1,284 @@ +# Ecosystem + +## GeoPandas dependencies + +GeoPandas brings together the full capability of `pandas` and the open-source geospatial +tools `Shapely`, which brings manipulation and analysis of geometric objects backed by +[`GEOS`](https://trac.osgeo.org/geos) library, `Fiona`, allowing us to read and write +geographic data files using [`GDAL`](https://gdal.org), and `pyproj`, a library for +cartographic projections and coordinate transformations, which is a Python interface to +[`PROJ`](https://proj.org). + +Furthermore, GeoPandas has several optional dependencies as `rtree`, `pygeos`, +`mapclassify`, or `geopy`. + +### Required dependencies + +#### [pandas](https://github.com/pandas-dev/pandas) +`pandas` is a Python package that provides fast, flexible, and expressive data +structures designed to make working with structured (tabular, multidimensional, +potentially heterogeneous) and time series data both easy and intuitive. It aims to be +the fundamental high-level building block for doing practical, real world data analysis +in Python. Additionally, it has the broader goal of becoming the most powerful and +flexible open source data analysis / manipulation tool available in any language. It is +already well on its way toward this goal. + +#### [Shapely](https://github.com/Toblerity/Shapely) +`Shapely` is a BSD-licensed Python package for manipulation and analysis of planar +geometric objects. It is based on the widely deployed `GEOS` (the engine of PostGIS) and +`JTS` (from which `GEOS` is ported) libraries. `Shapely` is not concerned with data +formats or coordinate systems, but can be readily integrated with packages that are. + +#### [Fiona](https://github.com/Toblerity/Fiona) +`Fiona` is `GDAL’s` neat and nimble vector API for Python programmers. Fiona is designed +to be simple and dependable. It focuses on reading and writing data in standard Python +IO style and relies upon familiar Python types and protocols such as files, +dictionaries, mappings, and iterators instead of classes specific to `OGR`. Fiona can +read and write real-world data using multi-layered GIS formats and zipped virtual file +systems and integrates readily with other Python GIS packages such as `pyproj`, `Rtree`, +and `Shapely`. + +#### [pyproj](https://github.com/pyproj4/pyproj) +`pyproj` is a Python interface to `PROJ` (cartographic projections and coordinate +transformations library). GeoPandas uses a `pyproj.crs.CRS` object to keep track of the +projection of each `GeoSeries` and its `Transformer` object to manage re-projections. + +### Optional dependencies + +#### [rtree](https://github.com/Toblerity/rtree) +`Rtree` is a ctypes Python wrapper of `libspatialindex` that provides a number of +advanced spatial indexing features for the spatially curious Python user. + +#### [PyGEOS](https://github.com/pygeos/pygeos) +`PyGEOS` is a C/Python library with vectorized geometry functions. The geometry +operations are done in the open-source geometry library `GEOS`. PyGEOS wraps these +operations in `NumPy` ufuncs providing a performance improvement when operating on +arrays of geometries. + +#### [mapclassify](https://github.com/pysal/mapclassify) +`mapclassify` provides functionality for Choropleth map classification. Currently, +fifteen different classification schemes are available, including a highly-optimized +implementation of Fisher-Jenks optimal classification. Each scheme inherits a common +structure that ensures computations are scalable and supports applications in streaming +contexts. + +#### [geopy](https://github.com/geopy/geopy) +`geopy` is a Python client for several popular geocoding web services. `geopy` makes it +easy for Python developers to locate the coordinates of addresses, cities, countries, +and landmarks across the globe using third-party geocoders and other data sources. + +#### [matplotlib](https://github.com/matplotlib/matplotlib) +`Matplotlib` is a comprehensive library for creating static, animated, and interactive +visualizations in Python. Matplotlib produces publication-quality figures in a variety +of hardcopy formats and interactive environments across platforms. Matplotlib can be +used in Python scripts, the Python and IPython shell, web application servers, and +various graphical user interface toolkits. + +## GeoPandas ecosystem + +Various packages are built on top of GeoPandas addressing specific geospatial data +processing needs, analysis, and visualization. Below is an incomplete list (in no +particular order) of tools which form the GeoPandas-related Python ecosystem. + +### Spatial analysis and Machine Learning + +#### [PySAL](https://github.com/pysal/pysal) +`PySAL`, the Python spatial analysis library, is an open source cross-platform library +for geospatial data science with an emphasis on geospatial vector data written in +Python. `PySAL` is a family of packages, some of which are listed below. + +##### [libpysal](https://github.com/pysal/libpysal) +`libpysal` provides foundational algorithms and data structures that support the rest of +the library. This currently includes the following modules: input/output (`io`), which +provides readers and writers for common geospatial file formats; weights (`weights`), +which provides the main class to store spatial weights matrices, as well as several +utilities to manipulate and operate on them; computational geometry (`cg`), with several +algorithms, such as Voronoi tessellations or alpha shapes that efficiently process +geometric shapes; and an additional module with example data sets (`examples`). + +##### [esda](https://github.com/pysal/esda) +`esda` implements methods for the analysis of both global (map-wide) and local (focal) +spatial autocorrelation, for both continuous and binary data. In addition, the package +increasingly offers cutting-edge statistics about boundary strength and measures of +aggregation error in statistical analyses. + +##### [segregation](https://github.com/pysal/segregation) +`segregation` package calculates over 40 different segregation indices and provides a +suite of additional features for measurement, visualization, and hypothesis testing that +together represent the state of the art in quantitative segregation analysis. + +##### [mgwr](https://github.com/pysal/mgwr) +`mgwr` provides scalable algorithms for estimation, inference, and prediction using +single- and multi-scale geographically weighted regression models in a variety of +generalized linear model frameworks, as well as model diagnostics tools. + +##### [tobler](https://github.com/pysal/tobler) +`tobler` provides functionality for areal interpolation and dasymetric mapping. +`tobler` includes functionality for interpolating data using area-weighted approaches, +regression model-based approaches that leverage remotely-sensed raster data as auxiliary +information, and hybrid approaches. + +#### [movingpandas](https://github.com/anitagraser/movingpandas) +`MovingPandas` is a package for dealing with movement data. `MovingPandas` implements a +`Trajectory` class and corresponding methods based on GeoPandas. A trajectory has a +time-ordered series of point geometries. These points and associated attributes are +stored in a `GeoDataFrame`. `MovingPandas` implements spatial and temporal data access +and analysis functions as well as plotting functions. + +#### [momepy](https://github.com/martinfleis/momepy) +`momepy` is a library for quantitative analysis of urban form - urban morphometrics. It +is built on top of `GeoPandas`, `PySAL` and `networkX`. `momepy` aims to provide a wide +range of tools for a systematic and exhaustive analysis of urban form. It can work with +a wide range of elements, while focused on building footprints and street networks. + +#### [geosnap](https://github.com/spatialucr/geosnap) +`geosnap` makes it easier to explore, model, analyze, and visualize the social and +spatial dynamics of neighborhoods. `geosnap` provides a suite of tools for creating +socio-spatial datasets, harmonizing those datasets into consistent set of time-static +boundaries, modeling bespoke neighborhoods and prototypical neighborhood types, and +modeling neighborhood change using classic and spatial statistical methods. It also +provides a set of static and interactive visualization tools to help you display and +understand the critical information at each step of the process. + +#### [mesa-geo](https://github.com/Corvince/mesa-geo) +`mesa-geo` implements a GeoSpace that can host GIS-based GeoAgents, which are like +normal Agents, except they have a shape attribute that is a `Shapely` object. You can +use `Shapely` directly to create arbitrary shapes, but in most cases you will want to +import your shapes from a file. Mesa-geo allows you to create GeoAgents from any vector +data file (e.g. shapefiles), valid GeoJSON objects or a GeoPandas `GeoDataFrame`. + +#### [Pyspatialml](https://github.com/stevenpawley/Pyspatialml) +`Pyspatialml` is a Python module for applying `scikit-learn` machine learning models to +'stacks' of raster datasets. Pyspatialml includes functions and classes for working with +multiple raster datasets and performing a typical machine learning workflow consisting +of extracting training data and applying the predict or `predict_proba` methods of +`scikit-learn` estimators to a stack of raster datasets. Pyspatialml is built upon the +`rasterio` Python module for all of the heavy lifting, and is also designed for working +with vector data using the `geopandas` module. + +#### [PyGMI](https://github.com/Patrick-Cole/pygmi) +`PyGMI` stands for Python Geoscience Modelling and Interpretation. It is a modelling and +interpretation suite aimed at magnetic, gravity and other datasets. + +### Visualization + +#### [hvPlot](https://hvplot.holoviz.org/user_guide/Geographic_Data.html#Geopandas) +`hvPlot` provides interactive Bokeh-based plotting for GeoPandas +dataframes and series using the same API as the Matplotlib `.plot()` +support that comes with GeoPandas. hvPlot makes it simple to pan and zoom into +your plots, use widgets to explore multidimensional data, and render even the +largest datasets in web browsers using [Datashader](https://datashader.org). + +#### [contextily](https://github.com/geopandas/contextily) +`contextily` is a small Python 3 (3.6 and above) package to retrieve tile maps from the +internet. It can add those tiles as basemap to `matplotlib` figures or write tile maps +to disk into geospatial raster files. Bounding boxes can be passed in both WGS84 +(EPSG:4326) and Spheric Mercator (EPSG:3857). + +#### [cartopy](https://github.com/SciTools/cartopy) +`Cartopy` is a Python package designed to make drawing maps for data analysis and +visualisation easy. It features: object oriented projection definitions; point, line, +polygon and image transformations between projections; integration to expose advanced +mapping in `Matplotlib` with a simple and intuitive interface; powerful vector data +handling by integrating shapefile reading with `Shapely` capabilities. + +#### [bokeh](https://github.com/bokeh/bokeh) +`Bokeh` is an interactive visualization library for modern web browsers. It provides +elegant, concise construction of versatile graphics, and affords high-performance +interactivity over large or streaming datasets. `Bokeh` can help anyone who would like +to quickly and easily make interactive plots, dashboards, and data applications. + +#### [folium](https://github.com/python-visualization/folium) +`folium` builds on the data wrangling strengths of the Python ecosystem and the mapping +strengths of the `Leaflet.js` library. Manipulate your data in Python, then visualize it +in a `Leaflet` map via `folium`. + +#### [kepler.gl](https://github.com/keplergl/kepler.gl) +`Kepler.gl` is a data-agnostic, high-performance web-based application for visual +exploration of large-scale geolocation data sets. Built on top of Mapbox GL and +`deck.gl`, `kepler.gl` can render millions of points representing thousands of trips and +perform spatial aggregations on the fly. + +#### [geoplot](https://github.com/ResidentMario/geoplot) +`geoplot` is a high-level Python geospatial plotting library. It's an extension to +`cartopy` and `matplotlib` which makes mapping easy: like `seaborn` for geospatial. It +comes with the high-level plotting API, native projection support and compatibility with +`matplotlib`. + +#### [GeoViews](https://github.com/holoviz/geoviews) +`GeoViews` is a Python library that makes it easy to explore and +visualize any data that includes geographic locations, with native +support for GeoPandas dataframes and series objects. It has +particularly powerful support for multidimensional meteorological and +oceanographic datasets, such as those used in weather, climate, and +remote sensing research, but is useful for almost anything that you +would want to plot on a map! + +#### [EarthPy](https://github.com/earthlab/earthpy) +`EarthPy` is a python package that makes it easier to plot and work with spatial raster +and vector data using open source tools. `Earthpy` depends upon `geopandas` which has a +focus on vector data and `rasterio` with facilitates input and output of raster data +files. It also requires `matplotlib` for plotting operations. `EarthPy’s` goal is to +make working with spatial data easier for scientists. + +#### [splot](https://github.com/pysal/splot) +`splot` provides statistical visualizations for spatial analysis. It methods for +visualizing global and local spatial autocorrelation (through Moran scatterplots and +cluster maps), temporal analysis of cluster dynamics (through heatmaps and rose +diagrams), and multivariate choropleth mapping (through value-by-alpha maps). A high +level API supports the creation of publication-ready visualizations + +#### [legendgram](https://github.com/pysal/legendgram) +`legendgram` is a small package that provides "legendgrams" legends that visualize the +distribution of observations by color in a given map. These distributional +visualizations for map classification schemes assist in analytical cartography and +spatial data visualization. + +### Geometry manipulation + +#### [TopoJSON](https://github.com/mattijn/topojson) +`topojson` is a library for creating a TopoJSON encoding of nearly any +geographical object in Python. With topojson it is possible to reduce the size of +your geographical data, typically by orders of magnitude. It is able to do so through +eliminating redundancy through computation of a topology, fixed-precision integer +encoding of coordinates, and simplification and quantization of arcs. + +#### [geocube](https://github.com/corteva/geocube) +Tool to convert geopandas vector data into rasterized `xarray` data. + +### Data retrieval + +#### [OSMnx](https://github.com/gboeing/osmnx) +`OSMnx` is a Python package that lets you download spatial data from OpenStreetMap and +model, project, visualize, and analyze real-world street networks. You can download and +model walkable, drivable, or bikeable urban networks with a single line of Python code +and then easily analyze and visualize them. You can just as easily download and work with +other infrastructure types, amenities/points of interest, building footprints, elevation +data, street bearings/orientations, and speed/travel time. + +#### [pyrosm](https://github.com/HTenkanen/pyrosm) +`Pyrosm` is a Python library for reading OpenStreetMap data from Protocolbuffer Binary +Format -files (`*.osm.pbf`) into Geopandas `GeoDataFrames`. Pyrosm makes it easy to +extract various datasets from OpenStreetMap pbf-dumps including e.g. road networks, +buildings, Points of Interest (POI), landuse and natural elements. Also fully customized +queries are supported which makes it possible to parse the data from OSM with more +specific filters. + +#### [geobr](https://github.com/ipeaGIT/geobr) +`geobr` is a computational package to download official spatial data sets of Brazil. The +package includes a wide range of geospatial data in geopackage format (like shapefiles +but better), available at various geographic scales and for various years with +harmonized attributes, projection and topology. + +#### [cenpy](https://github.com/cenpy-devs/cenpy) +An interface to explore and query the US Census API and return Pandas `Dataframes`. This +package is intended for exploratory data analysis and draws inspiration from +sqlalchemy-like interfaces and `acs.R`. With separate APIs for application developers +and folks who only want to get their data quickly & painlessly, `cenpy` should meet the +needs of most who aim to get US Census Data into Python. + +```{admonition} Expand this page +Do know a package which should be here? [Let us +know](https://github.com/geopandas/geopandas/issues) or [add it by +yourself](contributing.rst)! +``` diff --git a/doc/source/conf.py b/doc/source/conf.py index 8c76297..3ce5df8 100644 --- a/doc/source/conf.py +++ b/doc/source/conf.py @@ -17,60 +17,56 @@ import warnings # If extensions (or modules to document with autodoc) are in another directory, # add these directories to sys.path here. If the directory is relative to the # documentation root, use os.path.abspath to make it absolute, like shown here. -#sys.path.insert(0, os.path.abspath('.')) +# sys.path.insert(0, os.path.abspath('.')) # -- General configuration ----------------------------------------------------- # If your documentation needs a minimal Sphinx version, state it here. -#needs_sphinx = '1.0' +# needs_sphinx = '1.0' # Add any Sphinx extension module names here, as strings. They can be extensions # coming with Sphinx (named 'sphinx.ext.*') or your custom ones. -extensions = ['IPython.sphinxext.ipython_console_highlighting', - 'IPython.sphinxext.ipython_directive', - 'sphinx_gallery.gen_gallery', - 'sphinx.ext.autosummary', - 'sphinx.ext.intersphinx', - 'sphinx.ext.autodoc', - 'recommonmark', - 'numpydoc', +extensions = [ + "IPython.sphinxext.ipython_console_highlighting", + "IPython.sphinxext.ipython_directive", + "sphinx_gallery.load_style", + "sphinx.ext.autosummary", + "sphinx.ext.intersphinx", + "sphinx.ext.autodoc", + "myst_parser", + "nbsphinx", + "numpydoc", + "sphinx_toggleprompt", + "matplotlib.sphinxext.plot_directive", ] # continue doc build and only print warnings/errors in examples ipython_warning_is_error = False ipython_exec_lines = [ # ensure that dataframes are not truncated in the IPython code blocks - 'import pandas as _pd', + "import pandas as _pd", '_pd.set_option("display.max_columns", 20)', - '_pd.set_option("display.width", 100)' + '_pd.set_option("display.width", 100)', ] # Fix issue with warnings from numpydoc (see discussion in PR #534) numpydoc_show_class_members = False + def setup(app): - app.add_stylesheet('custom.css') # may also be an URL + app.add_css_file("custom.css") # may also be an URL + # Add any paths that contain templates here, relative to this directory. -templates_path = ['_templates'] +templates_path = ["_templates"] autosummary_generate = True -# Sphinx gallery configuration -sphinx_gallery_conf = { - 'examples_dirs': ['../../examples'], - 'filename_pattern': '^((?!sgskip).)*$', - 'gallery_dirs': ['gallery'], - 'doc_module': ('geopandas',), - 'reference_url': {'matplotlib': 'http://matplotlib.org', - 'numpy': 'http://docs.scipy.org/doc/numpy', - 'scipy': 'http://docs.scipy.org/doc/scipy/reference', - 'geopandas': None}, - 'backreferences_dir': 'reference' -} -# connect docs in other projects -intersphinx_mapping = {'pyproj': ('http://pyproj4.github.io/pyproj/stable/', None)} +nbsphinx_execute = "always" +nbsphinx_allow_errors = True +nbsphinx_kernel_name = "python3" + # suppress matplotlib warning in examples warnings.filterwarnings( "ignore", @@ -80,193 +76,222 @@ warnings.filterwarnings( ) # The suffix of source filenames. -source_suffix = ['.rst', '.md'] +source_suffix = [".rst", ".md"] # The encoding of source files. -#source_encoding = 'utf-8-sig' +# source_encoding = 'utf-8-sig' # The master toctree document. -master_doc = 'index' +master_doc = "index" # General information about the project. -project = u'GeoPandas' -copyright = u'2013–2019, GeoPandas developers' +project = u"GeoPandas" +copyright = u"2013–2022, GeoPandas developers" # The version info for the project you're documenting, acts as replacement for # |version| and |release|, also used in various other places throughout the # built documents. import geopandas -version = release = geopandas.__version__ + +release = release = geopandas.__version__ +version = release +if "+" in version: + version, remainder = release.split("+") + if not remainder.startswith("0"): + version = version + ".dev+" + remainder.split(".")[0] # The language for content autogenerated by Sphinx. Refer to documentation # for a list of supported languages. -#language = None +# language = None # There are two options for replacing |today|: either, you set today to some # non-false value, then it is used: -#today = '' +# today = '' # Else, today_fmt is used as the format for a strftime call. -#today_fmt = '%B %d, %Y' +# today_fmt = '%B %d, %Y' # List of patterns, relative to source directory, that match files and # directories to ignore when looking for source files. exclude_patterns = [] # The reST default role (used for this markup: `text`) to use for all documents. -#default_role = None +# default_role = None # If true, '()' will be appended to :func: etc. cross-reference text. -#add_function_parentheses = True +# add_function_parentheses = True # If true, the current module name will be prepended to all description # unit titles (such as .. function::). -#add_module_names = True +# add_module_names = True # If true, sectionauthor and moduleauthor directives will be shown in the # output. They are ignored by default. -#show_authors = False +# show_authors = False # The name of the Pygments (syntax highlighting) style to use. -pygments_style = 'sphinx' +pygments_style = "sphinx" # A list of ignored prefixes for module index sorting. -#modindex_common_prefix = [] +# modindex_common_prefix = [] # -- Options for HTML output --------------------------------------------------- # The theme to use for HTML and HTML Help pages. See the documentation for # a list of builtin themes. -import sphinx_rtd_theme -html_theme = "sphinx_rtd_theme" -html_theme_path = [sphinx_rtd_theme.get_html_theme_path()] +html_theme = "pydata_sphinx_theme" # Theme options are theme-specific and customize the look and feel of a theme # further. For a list of options available for each theme, see the # documentation. -#html_theme_options = {} +html_theme_options = { + "search_bar_position": "sidebar", + "github_url": "https://github.com/geopandas/geopandas", + "twitter_url": "https://twitter.com/geopandas", +} # Add any paths that contain custom themes here, relative to this directory. -#html_theme_path = [] +# html_theme_path = [] # The name for this set of Sphinx documents. If None, it defaults to # " v documentation". -#html_title = None +# html_title = None # A shorter title for the navigation bar. Default is the same as html_title. -#html_short_title = None +# html_short_title = None # The name of an image file (relative to this directory) to place at the top # of the sidebar. -#html_logo = None +html_logo = "_static/logo/geopandas_logo_web.svg" # The name of an image file (within the static path) to use as favicon of the # docs. This file should be a Windows icon file (.ico) being 16x16 or 32x32 # pixels large. -#html_favicon = None +html_favicon = "_static/logo/favicon.png" # Add any paths that contain custom static files (such as style sheets) here, # relative to this directory. They are copied after the builtin static files, # so a file named "default.css" will overwrite the builtin "default.css". -html_static_path = ['_static'] +html_static_path = ["_static"] # If not '', a 'Last updated on:' timestamp is inserted at every page bottom, # using the given strftime format. -#html_last_updated_fmt = '%b %d, %Y' +# html_last_updated_fmt = '%b %d, %Y' # If true, SmartyPants will be used to convert quotes and dashes to # typographically correct entities. -#html_use_smartypants = True +# html_use_smartypants = True # Custom sidebar templates, maps document names to template names. -#html_sidebars = {} +# html_sidebars = {} # Additional templates that should be rendered to pages, maps page names to # template names. -#html_additional_pages = {} +# html_additional_pages = {} + +# Add redirect for previously existing pages, each item is like `(from_old, to_new)` + +moved_pages = [ + # user guide + ("aggregation_with_dissolve", "docs/user_guide/aggregation_with_dissolve"), + ("data_structures", "docs/user_guide/data_structures"), + ("geocoding", "docs/user_guide/geocoding"), + ("geometric_manipulations", "docs/user_guide/geometric_manipulations"), + ("indexing", "docs/user_guide/indexing"), + ("io", "docs/user_guide/io"), + ("mapping", "docs/user_guide/mapping"), + ("mergingdata", "docs/user_guide/mergingdata"), + ("missing_empty", "docs/user_guide/missing_empty"), + ("projections", "docs/user_guide/projections"), + ("set_operations", "docs/user_guide/set_operations"), + # other + ("install", "getting_started/install"), + ("reference", "docs/reference"), + ("changelog", "docs/changelog"), + ("code_of_conduct", "community/code_of_conduct"), + ("contributing", "community/contributing"), +] + +html_additional_pages = {page[0]: "redirect.html" for page in moved_pages} + +html_context = {"redirects": {old: new for old, new in moved_pages}} # If false, no module index is generated. -#html_domain_indices = True +# html_domain_indices = True # If false, no index is generated. -#html_use_index = True +# html_use_index = True # If true, the index is split into individual pages for each letter. -#html_split_index = False +# html_split_index = False # If true, links to the reST sources are added to the pages. -#html_show_sourcelink = True +# html_show_sourcelink = True # If true, "Created using Sphinx" is shown in the HTML footer. Default is True. -#html_show_sphinx = True +# html_show_sphinx = True # If true, "(C) Copyright ..." is shown in the HTML footer. Default is True. -#html_show_copyright = True +# html_show_copyright = True # If true, an OpenSearch description file will be output, and all pages will # contain a tag referring to it. The value of this option must be the # base URL from which the finished HTML is served. -#html_use_opensearch = '' +# html_use_opensearch = '' # This is the file name suffix for HTML files (e.g. ".xhtml"). -#html_file_suffix = None +# html_file_suffix = None # Output file base name for HTML help builder. -htmlhelp_basename = 'GeoPandasdoc' +htmlhelp_basename = "GeoPandasdoc" # -- Options for LaTeX output -------------------------------------------------- latex_elements = { -# The paper size ('letterpaper' or 'a4paper'). -#'papersize': 'letterpaper', - -# The font size ('10pt', '11pt' or '12pt'). -#'pointsize': '10pt', - -# Additional stuff for the LaTeX preamble. -#'preamble': '', + # The paper size ('letterpaper' or 'a4paper'). + #'papersize': 'letterpaper', + # The font size ('10pt', '11pt' or '12pt'). + #'pointsize': '10pt', + # Additional stuff for the LaTeX preamble. + #'preamble': '', } # Grouping the document tree into LaTeX files. List of tuples # (source start file, target name, title, author, documentclass [howto/manual]). latex_documents = [ - ('index', 'GeoPandas.tex', u'GeoPandas Documentation', - u'Kelsey Jordahl', 'manual'), + ("index", "GeoPandas.tex", u"GeoPandas Documentation", u"Kelsey Jordahl", "manual") ] # The name of an image file (relative to this directory) to place at the top of # the title page. -#latex_logo = None +# latex_logo = None # For "manual" documents, if this is true, then toplevel headings are parts, # not chapters. -#latex_use_parts = False +# latex_use_parts = False # If true, show page references after internal links. -#latex_show_pagerefs = False +# latex_show_pagerefs = False # If true, show URL addresses after external links. -#latex_show_urls = False +# latex_show_urls = False # Documents to append as an appendix to all manuals. -#latex_appendices = [] +# latex_appendices = [] # If false, no module index is generated. -#latex_domain_indices = True +# latex_domain_indices = True # -- Options for manual page output -------------------------------------------- # One entry per manual page. List of tuples # (source start file, name, description, authors, manual section). -man_pages = [ - ('index', 'geopandas', u'GeoPandas Documentation', - [u'Kelsey Jordahl'], 1) -] +man_pages = [("index", "geopandas", u"GeoPandas Documentation", [u"Kelsey Jordahl"], 1)] # If true, show URL addresses after external links. -#man_show_urls = False +# man_show_urls = False # -- Options for Texinfo output ------------------------------------------------ @@ -275,16 +300,121 @@ man_pages = [ # (source start file, target name, title, author, # dir menu entry, description, category) texinfo_documents = [ - ('index', 'GeoPandas', u'GeoPandas Documentation', - u'Kelsey Jordahl', 'GeoPandas', 'One line description of project.', - 'Miscellaneous'), + ( + "index", + "GeoPandas", + u"GeoPandas Documentation", + u"Kelsey Jordahl", + "GeoPandas", + "One line description of project.", + "Miscellaneous", + ) ] # Documents to append as an appendix to all manuals. -#texinfo_appendices = [] +# texinfo_appendices = [] # If false, no module index is generated. -#texinfo_domain_indices = True +# texinfo_domain_indices = True # How to display URL addresses: 'footnote', 'no', or 'inline'. -#texinfo_show_urls = 'footnote' +# texinfo_show_urls = 'footnote' + +nbsphinx_prolog = r""" +{% set docname = env.doc2path(env.docname, base=None) %} + +.. only:: html + + .. role:: raw-html(raw) + :format: html + + .. note:: + + | This page was generated from `{{ docname }}`__. + | Interactive online version: :raw-html:`Binder badge` + + __ https://github.com/geopandas/geopandas/blob/main/doc/source/{{ docname }} +""" + +# --Options for sphinx extensions ----------------------------------------------- + +# connect docs in other projects +intersphinx_mapping = { + "cartopy": ( + "https://scitools.org.uk/cartopy/docs/latest/", + "https://scitools.org.uk/cartopy/docs/latest/objects.inv", + ), + "contextily": ( + "https://contextily.readthedocs.io/en/stable/", + "https://contextily.readthedocs.io/en/stable/objects.inv", + ), + "fiona": ( + "https://fiona.readthedocs.io/en/stable/", + "https://fiona.readthedocs.io/en/stable/objects.inv", + ), + "folium": ( + "https://python-visualization.github.io/folium/", + "https://python-visualization.github.io/folium/objects.inv", + ), + "geoplot": ( + "https://residentmario.github.io/geoplot/index.html", + "https://residentmario.github.io/geoplot/objects.inv", + ), + "geopy": ( + "https://geopy.readthedocs.io/en/stable/", + "https://geopy.readthedocs.io/en/stable/objects.inv", + ), + "libpysal": ( + "https://pysal.org/libpysal/", + "https://pysal.org/libpysal/objects.inv", + ), + "mapclassify": ( + "https://pysal.org/mapclassify/", + "https://pysal.org/mapclassify/objects.inv", + ), + "matplotlib": ( + "https://matplotlib.org/stable/", + "https://matplotlib.org/stable/objects.inv", + ), + "pandas": ( + "https://pandas.pydata.org/pandas-docs/stable/", + "https://pandas.pydata.org/pandas-docs/stable/objects.inv", + ), + "pyarrow": ("https://arrow.apache.org/docs/", None), + "pyepsg": ( + "https://pyepsg.readthedocs.io/en/stable/", + "https://pyepsg.readthedocs.io/en/stable/objects.inv", + ), + "pygeos": ( + "https://pygeos.readthedocs.io/en/latest/", + "https://pygeos.readthedocs.io/en/latest/objects.inv", + ), + "pyproj": ( + "https://pyproj4.github.io/pyproj/stable/", + "https://pyproj4.github.io/pyproj/stable/objects.inv", + ), + "python": ( + "https://docs.python.org/3", + "https://docs.python.org/3/objects.inv", + ), + "rtree": ( + "https://rtree.readthedocs.io/en/stable/", + "https://rtree.readthedocs.io/en/stable/objects.inv", + ), + "rasterio": ( + "https://rasterio.readthedocs.io/en/stable/", + "https://rasterio.readthedocs.io/en/stable/objects.inv", + ), + "shapely": ( + "https://shapely.readthedocs.io/en/stable/", + "https://shapely.readthedocs.io/en/stable/objects.inv", + ), + "branca": ( + "https://python-visualization.github.io/branca/", + "https://python-visualization.github.io/branca/objects.inv", + ), + "xyzservices": ( + "https://xyzservices.readthedocs.io/en/stable/", + "https://xyzservices.readthedocs.io/en/stable/objects.inv", + ), +} diff --git a/doc/source/docs.rst b/doc/source/docs.rst new file mode 100644 index 0000000..8cd1b98 --- /dev/null +++ b/doc/source/docs.rst @@ -0,0 +1,19 @@ +Documentation +------------- + +The documentation of GeoPandas consists of four parts - :doc:`User Guide ` with explanation of the basic functionality, :doc:`Advanced Guide ` covering topics which assume knowledge of basics, :doc:`Examples `, and :doc:`API reference ` detailing every class, method, function and attribute used implemented by GeoPandas. + +.. container:: button + + :doc:`User Guide ` :doc:`Advanced Guide ` + :doc:`Examples ` :doc:`API reference ` + + +.. toctree:: + :maxdepth: 2 + :caption: Documentation + + User Guide + Advanced Guide + API reference + Changelog \ No newline at end of file diff --git a/doc/source/docs/advanced_guide.rst b/doc/source/docs/advanced_guide.rst new file mode 100644 index 0000000..cdbafea --- /dev/null +++ b/doc/source/docs/advanced_guide.rst @@ -0,0 +1,20 @@ +Advanced Guide +============== + +The Advanced Guide covers advanced usage of GeoPandas. Each page focuses on a single +topic and outlines how it is implemented in GeoPandas, with reproducible examples. + +If you don't know anything about GeoPandas, start with the :doc:`Introduction to +GeoPandas <../getting_started/introduction>`. + +Basic topics can be found in the :doc:`User Guide ` and further +specification in the :doc:`API Reference `. + +.. note:: + This section is currently work in progress. See the available pages below. + +.. toctree:: + :maxdepth: 2 + + user_guide/missing_empty + user_guide/reproject_fiona diff --git a/doc/source/docs/changelog.rst b/doc/source/docs/changelog.rst new file mode 100644 index 0000000..1b3e43f --- /dev/null +++ b/doc/source/docs/changelog.rst @@ -0,0 +1 @@ +.. include:: ../../../CHANGELOG.md diff --git a/doc/source/docs/reference.rst b/doc/source/docs/reference.rst new file mode 100644 index 0000000..66bda92 --- /dev/null +++ b/doc/source/docs/reference.rst @@ -0,0 +1,20 @@ +.. _reference: + +API Reference +============= + +The API Reference provides an overview of all public objects, functions and methods implemented in GeoPandas. All classes and function exposed in ``geopandas.*`` namespace plus those listed in the reference are public. + +.. warning:: + The ``geopandas.array`` and ``geopandas.base`` modules are private. Stable functionality in such modules is not guaranteed. + +.. toctree:: + :maxdepth: 2 + + GeoSeries + GeoDataFrame + Input/output + Tools + Spatial index + Testing + diff --git a/doc/source/docs/reference/geodataframe.rst b/doc/source/docs/reference/geodataframe.rst new file mode 100644 index 0000000..dc49c40 --- /dev/null +++ b/doc/source/docs/reference/geodataframe.rst @@ -0,0 +1,123 @@ +============ +GeoDataFrame +============ +.. currentmodule:: geopandas + +A ``GeoDataFrame`` is a tabular data structure that contains a column +which contains a ``GeoSeries`` storing geometry. + +Constructor +----------- +.. autosummary:: + :toctree: api/ + + GeoDataFrame + +Serialization / IO / conversion +------------------------------- + +.. autosummary:: + :toctree: api/ + + GeoDataFrame.from_file + GeoDataFrame.from_features + GeoDataFrame.from_postgis + GeoDataFrame.to_file + GeoDataFrame.to_json + GeoDataFrame.to_parquet + GeoDataFrame.to_feather + GeoDataFrame.to_postgis + GeoDataFrame.to_wkb + GeoDataFrame.to_wkt + +Projection handling +------------------- + +.. autosummary:: + :toctree: api/ + + GeoDataFrame.crs + GeoDataFrame.set_crs + GeoDataFrame.to_crs + GeoDataFrame.estimate_utm_crs + +Active geometry handling +------------------------ + +.. autosummary:: + :toctree: api/ + + GeoDataFrame.rename_geometry + GeoDataFrame.set_geometry + +Aggregating and exploding +------------------------- + +.. autosummary:: + :toctree: api/ + + GeoDataFrame.dissolve + GeoDataFrame.explode + +Spatial joins +------------- + +.. autosummary:: + :toctree: api/ + + GeoDataFrame.sjoin + GeoDataFrame.sjoin_nearest + +Overlay operations +------------------ + +.. autosummary:: + :toctree: api/ + + GeoDataFrame.clip + GeoDataFrame.overlay + +Plotting +-------- + +.. autosummary:: + :toctree: api/ + + GeoDataFrame.explore + + +.. autosummary:: + :toctree: api/ + :template: accessor_callable.rst + + GeoDataFrame.plot + +Spatial index +------------- + +.. autosummary:: + :toctree: api/ + + GeoDataFrame.sindex + GeoDataFrame.has_sindex + +Indexing +-------- + +.. autosummary:: + :toctree: api/ + + GeoDataFrame.cx + +Interface +--------- + +.. autosummary:: + :toctree: api/ + + GeoDataFrame.__geo_interface__ + GeoDataFrame.iterfeatures + +All pandas ``DataFrame`` methods are also available, although they may +not operate in a meaningful way on the ``geometry`` column. All methods +listed in `GeoSeries `__ work directly on an active geometry column of GeoDataFrame. diff --git a/doc/source/docs/reference/geoseries.rst b/doc/source/docs/reference/geoseries.rst new file mode 100644 index 0000000..0173a8c --- /dev/null +++ b/doc/source/docs/reference/geoseries.rst @@ -0,0 +1,196 @@ +========= +GeoSeries +========= +.. currentmodule:: geopandas + +Constructor +----------- +.. autosummary:: + :toctree: api/ + + GeoSeries + +General methods and attributes +------------------------------ + +.. autosummary:: + :toctree: api/ + + GeoSeries.area + GeoSeries.boundary + GeoSeries.bounds + GeoSeries.total_bounds + GeoSeries.length + GeoSeries.geom_type + GeoSeries.distance + GeoSeries.representative_point + GeoSeries.exterior + GeoSeries.interiors + GeoSeries.x + GeoSeries.y + GeoSeries.z + +Unary predicates +---------------- + +.. autosummary:: + :toctree: api/ + + GeoSeries.is_empty + GeoSeries.is_ring + GeoSeries.is_simple + GeoSeries.is_valid + GeoSeries.has_z + + +Binary Predicates +----------------- + +.. autosummary:: + :toctree: api/ + + GeoSeries.contains + GeoSeries.crosses + GeoSeries.disjoint + GeoSeries.geom_equals + GeoSeries.geom_almost_equals + GeoSeries.geom_equals_exact + GeoSeries.intersects + GeoSeries.overlaps + GeoSeries.touches + GeoSeries.within + GeoSeries.covers + GeoSeries.covered_by + + +Set-theoretic Methods +--------------------- + +.. autosummary:: + :toctree: api/ + + GeoSeries.difference + GeoSeries.intersection + GeoSeries.symmetric_difference + GeoSeries.union + +Constructive Methods and Attributes +----------------------------------- + +.. autosummary:: + :toctree: api/ + + GeoSeries.buffer + GeoSeries.boundary + GeoSeries.centroid + GeoSeries.convex_hull + GeoSeries.envelope + GeoSeries.simplify + +Affine transformations +---------------------- + +.. autosummary:: + :toctree: api/ + + GeoSeries.affine_transform + GeoSeries.rotate + GeoSeries.scale + GeoSeries.skew + GeoSeries.translate + +Aggregating and exploding +------------------------- + +.. autosummary:: + :toctree: api/ + + GeoSeries.unary_union + GeoSeries.explode + +Serialization / IO / conversion +------------------------------- + +.. autosummary:: + :toctree: api/ + + GeoSeries.from_file + GeoSeries.from_wkb + GeoSeries.from_wkt + GeoSeries.from_xy + GeoSeries.to_file + GeoSeries.to_json + GeoSeries.to_wkb + GeoSeries.to_wkt + +Projection handling +------------------- + +.. autosummary:: + :toctree: api/ + + GeoSeries.crs + GeoSeries.set_crs + GeoSeries.to_crs + GeoSeries.estimate_utm_crs + +Missing values +-------------- + +.. autosummary:: + :toctree: api/ + + GeoSeries.fillna + GeoSeries.isna + GeoSeries.notna + +Overlay operations +------------------ + +.. autosummary:: + :toctree: api/ + + GeoSeries.clip + +Plotting +-------- + +.. autosummary:: + :toctree: api/ + + GeoSeries.plot + GeoSeries.explore + + +Spatial index +------------- + +.. autosummary:: + :toctree: api/ + + GeoSeries.sindex + GeoSeries.has_sindex + +Indexing +-------- + +.. autosummary:: + :toctree: api/ + + GeoSeries.cx + +Interface +--------- + +.. autosummary:: + :toctree: api/ + + GeoSeries.__geo_interface__ + + +Methods of pandas ``Series`` objects are also available, although not +all are applicable to geometric objects and some may return a +``Series`` rather than a ``GeoSeries`` result when appropriate. The methods +``isna()`` and ``fillna()`` have been +implemented specifically for ``GeoSeries`` and are expected to work +correctly. diff --git a/doc/source/docs/reference/io.rst b/doc/source/docs/reference/io.rst new file mode 100644 index 0000000..f5d77ae --- /dev/null +++ b/doc/source/docs/reference/io.rst @@ -0,0 +1,37 @@ +============ +Input/output +============ +.. currentmodule:: geopandas + +GIS vector files +---------------- +.. autosummary:: + :toctree: api/ + + read_file + GeoDataFrame.to_file + +PostGIS +------- +.. autosummary:: + :toctree: api/ + + read_postgis + GeoDataFrame.to_postgis + + +Feather +------- +.. autosummary:: + :toctree: api/ + + read_feather + GeoDataFrame.to_feather + +Parquet +------- +.. autosummary:: + :toctree: api/ + + read_parquet + GeoDataFrame.to_parquet diff --git a/doc/source/docs/reference/sindex.rst b/doc/source/docs/reference/sindex.rst new file mode 100644 index 0000000..dbd1a29 --- /dev/null +++ b/doc/source/docs/reference/sindex.rst @@ -0,0 +1,52 @@ +============= +Spatial index +============= +.. currentmodule:: geopandas + +GeoPandas offers built-in support for spatial indexing using an R-Tree algorithm. +Depending on the ability to import ``pygeos``, GeoPandas will either use +``pygeos.STRtree`` or ``rtree.index.Index``. The main interface for both is the +same and follows the ``pygeos`` model. + +``GeoSeries.sindex`` creates a spatial index, which can use the methods and +properties documented below. + +Constructor +----------- +.. autosummary:: + :toctree: api/ + + GeoSeries.sindex + +Spatial Index object +-------------------- + +The spatial index object returned from :attr:`GeoSeries.sindex` has the following +methods: + +.. currentmodule:: geopandas.sindex.SpatialIndex +.. autosummary:: + :toctree: api/ + + intersection + is_empty + nearest + query + query_bulk + size + valid_query_predicates + +The concrete implementations currently available are +``geopandas.sindex.PyGEOSSTRTreeIndex`` and ``geopandas.sindex.RTreeIndex``. + +In addition to the methods listed above, the ``rtree``-based spatial index +(``geopandas.sindex.RTreeIndex``) offers the full capability of +``rtree.index.Index`` - see the full API in the `rtree documentation`_. + +Similarly, the ``pygeos``-based spatial index +(``geopandas.sindex.PyGEOSSTRTreeIndex``) offers the full capability of +``pygeos.STRtree``, including nearest-neighbor queries. +See the full API in the `PyGEOS STRTree documentation`_. + +.. _rtree documentation: https://rtree.readthedocs.io/en/stable/class.html +.. _PyGEOS STRTree documentation: https://pygeos.readthedocs.io/en/latest/strtree.html diff --git a/doc/source/docs/reference/testing.rst b/doc/source/docs/reference/testing.rst new file mode 100644 index 0000000..d8a5ce6 --- /dev/null +++ b/doc/source/docs/reference/testing.rst @@ -0,0 +1,14 @@ +======= +Testing +======= +.. currentmodule:: geopandas + +GeoPandas includes specific functions to test its objects. + +.. autosummary:: + :toctree: api/ + + .. testing.geom_equals + .. testing.geom_almost_equals + testing.assert_geoseries_equal + testing.assert_geodataframe_equal diff --git a/doc/source/docs/reference/tools.rst b/doc/source/docs/reference/tools.rst new file mode 100644 index 0000000..618fe99 --- /dev/null +++ b/doc/source/docs/reference/tools.rst @@ -0,0 +1,18 @@ +===== +Tools +===== +.. currentmodule:: geopandas + +.. autosummary:: + :toctree: api/ + + sjoin + sjoin_nearest + overlay + clip + tools.geocode + tools.reverse_geocode + tools.collect + points_from_xy + datasets.available + datasets.get_path diff --git a/doc/source/docs/user_guide.rst b/doc/source/docs/user_guide.rst new file mode 100644 index 0000000..0fa6c50 --- /dev/null +++ b/doc/source/docs/user_guide.rst @@ -0,0 +1,23 @@ +User Guide +========== + +The User Guide covers different parts of basic usage of GeoPandas. Each page focuses on a single topic and outlines how it is implemented in GeoPandas, with reproducible examples. + +If you don't know anything about GeoPandas, start with the :doc:`Introduction to GeoPandas <../getting_started/introduction>`. + +Advanced topics can be found in the :doc:`Advanced Guide ` and further specification in the :doc:`API Reference `. + +.. toctree:: + :maxdepth: 2 + + Data Structures + Reading and Writing Files + Indexing and Selecting Data + Making Maps and plots + Interactive mapping + Managing Projections + Geometric Manipulations + Set Operations with overlay + Aggregation with dissolve + Merging Data + Geocoding diff --git a/doc/source/aggregation_with_dissolve.rst b/doc/source/docs/user_guide/aggregation_with_dissolve.rst similarity index 51% rename from doc/source/aggregation_with_dissolve.rst rename to doc/source/docs/user_guide/aggregation_with_dissolve.rst index ea5f2ed..c8a10cd 100644 --- a/doc/source/aggregation_with_dissolve.rst +++ b/doc/source/docs/user_guide/aggregation_with_dissolve.rst @@ -12,17 +12,21 @@ Aggregation with dissolve Spatial data are often more granular than we need. For example, we might have data on sub-national units, but we're actually interested in studying patterns at the level of countries. -In a non-spatial setting, when all we need are summary statistics of the data, we aggregate our data using the ``groupby`` function. But for spatial data, we sometimes also need to aggregate geometric features. In the *geopandas* library, we can aggregate geometric features using the ``dissolve`` function. +In a non-spatial setting, when all we need are summary statistics of the data, we aggregate our data using the :meth:`~pandas.DataFrame.groupby` function. But for spatial data, we sometimes also need to aggregate geometric features. In the *geopandas* library, we can aggregate geometric features using the :meth:`~geopandas.GeoDataFrame.dissolve` function. -``dissolve`` can be thought of as doing three things: (a) it dissolves all the geometries within a given group together into a single geometric feature (using the ``unary_union`` method), and (b) it aggregates all the rows of data in a group using ``groupby.aggregate()``, and (c) it combines those two results. +:meth:`~geopandas.GeoDataFrame.dissolve` can be thought of as doing three things: -``dissolve`` Example -~~~~~~~~~~~~~~~~~~~~~ +(a) it dissolves all the geometries within a given group together into a single geometric feature (using the :attr:`~geopandas.GeoSeries.unary_union` method), and +(b) it aggregates all the rows of data in a group using :ref:`groupby.aggregate `, and +(c) it combines those two results. + +:meth:`~geopandas.GeoDataFrame.dissolve` Example +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Suppose we are interested in studying continents, but we only have country-level data like the country dataset included in *geopandas*. We can easily convert this to a continent-level dataset. -First, let's look at the most simple case where we just want continent shapes and names. By default, ``dissolve`` will pass ``'first'`` to ``groupby.aggregate``. +First, let's look at the most simple case where we just want continent shapes and names. By default, :meth:`~geopandas.GeoDataFrame.dissolve` will pass ``'first'`` to :ref:`groupby.aggregate `. .. ipython:: python @@ -35,7 +39,7 @@ First, let's look at the most simple case where we just want continent shapes an continents.head() -If we are interested in aggregate populations, however, we can pass different functions to the ``dissolve`` method to aggregate populations using the ``aggfunc =`` argument: +If we are interested in aggregate populations, however, we can pass different functions to the :meth:`~geopandas.GeoDataFrame.dissolve` method to aggregate populations using the ``aggfunc =`` argument: .. ipython:: python @@ -62,7 +66,7 @@ Dissolve Arguments ~~~~~~~~~~~~~~~~~~ The ``aggfunc =`` argument defaults to 'first' which means that the first row of attributes values found in the dissolve routine will be assigned to the resultant dissolved geodataframe. -However it also accepts other summary statistic options as allowed by ``pandas.groupby()`` including: +However it also accepts other summary statistic options as allowed by :meth:`pandas.groupby ` including: * 'first' * 'last' @@ -71,3 +75,25 @@ However it also accepts other summary statistic options as allowed by ``pandas.g * 'sum' * 'mean' * 'median' +* function +* string function name +* list of functions and/or function names, e.g. [np.sum, 'mean'] +* dict of axis labels -> functions, function names or list of such. + +For example, to get the number of contries on each continent, +as well as the populations of the largest and smallest country of each, +we can aggregate the ``'name'`` column using ``'count'``, +and the ``'pop_est'`` column using ``'min'`` and ``'max'``: + +.. ipython:: python + + world = geopandas.read_file(geopandas.datasets.get_path("naturalearth_lowres")) + continents = world.dissolve( + by="continent", + aggfunc={ + "name": "count", + "pop_est": ["min", "max"], + }, + ) + + continents.head() \ No newline at end of file diff --git a/doc/source/data_structures.rst b/doc/source/docs/user_guide/data_structures.rst similarity index 81% rename from doc/source/data_structures.rst rename to doc/source/docs/user_guide/data_structures.rst index 998249c..e459ff9 100644 --- a/doc/source/data_structures.rst +++ b/doc/source/docs/user_guide/data_structures.rst @@ -14,8 +14,8 @@ Data Structures ========================================= GeoPandas implements two main data structures, a :class:`GeoSeries` and a -:class:`GeoDataFrame`. These are subclasses of pandas ``Series`` and -``DataFrame``, respectively. +:class:`GeoDataFrame`. These are subclasses of :class:`pandas.Series` and +:class:`pandas.DataFrame`, respectively. GeoSeries --------- @@ -45,10 +45,10 @@ operation is carried out elementwise. The two series will be aligned by matching indices. Binary operations can also be applied to a single geometry, in which case the operation is carried out for each element of the series with that geometry. In either case, a -``Series`` or a :class:`GeoSeries` will be returned, as appropriate. +:class:`~pandas.Series` or a :class:`GeoSeries` will be returned, as appropriate. A short summary of a few attributes and methods for GeoSeries is -presented here, and a full list can be found in the :doc:`all attributes and methods page `. +presented here, and a full list can be found in the :doc:`all attributes and methods page <../reference/geoseries>`. There is also a family of methods for creating new shapes by expanding existing shapes or applying set-theoretic operations like "union" described in :doc:`geometric manipulations `. @@ -64,7 +64,7 @@ Attributes Basic Methods ^^^^^^^^^^^^^^ -* :meth:`~GeoSeries.distance`: returns ``Series`` with minimum distance from each entry to ``other`` +* :meth:`~GeoSeries.distance`: returns :class:`~pandas.Series` with minimum distance from each entry to ``other`` * :attr:`~GeoSeries.centroid`: returns :class:`GeoSeries` of centroids * :meth:`~GeoSeries.representative_point`: returns :class:`GeoSeries` of points that are guaranteed to be within each geometry. It does **NOT** return centroids. * :meth:`~GeoSeries.to_crs`: change coordinate reference system. See :doc:`projections ` @@ -117,6 +117,7 @@ We can also rename this column to "borders": Now, we create centroids and make it the geometry: .. ipython:: python + :okwarning: world['centroid_column'] = world.centroid world = world.set_geometry('centroid_column') @@ -129,14 +130,14 @@ Now, we create centroids and make it the geometry: gdf = gdf.rename(columns={'old_name': 'new_name'}).set_geometry('new_name') -**Note 2:** Somewhat confusingly, by default when you use the ``read_file`` command, the column containing spatial objects from the file is named "geometry" by default, and will be set as the active geometry column. However, despite using the same term for the name of the column and the name of the special attribute that keeps track of the active column, they are distinct. You can easily shift the active geometry column to a different :class:`GeoSeries` with the :meth:`~GeoDataFrame.set_geometry` command. Further, ``gdf.geometry`` will always return the active geometry column, *not* the column named ``geometry``. If you wish to call a column named "geometry", and a different column is the active geometry column, use ``gdf['geometry']``, not ``gdf.geometry``. +**Note 2:** Somewhat confusingly, by default when you use the :func:`~geopandas.read_file` command, the column containing spatial objects from the file is named "geometry" by default, and will be set as the active geometry column. However, despite using the same term for the name of the column and the name of the special attribute that keeps track of the active column, they are distinct. You can easily shift the active geometry column to a different :class:`GeoSeries` with the :meth:`~GeoDataFrame.set_geometry` command. Further, ``gdf.geometry`` will always return the active geometry column, *not* the column named ``geometry``. If you wish to call a column named "geometry", and a different column is the active geometry column, use ``gdf['geometry']``, not ``gdf.geometry``. Attributes and Methods ~~~~~~~~~~~~~~~~~~~~~~ Any of the attributes calls or methods described for a :class:`GeoSeries` will work on a :class:`GeoDataFrame` -- effectively, they are just applied to the "geometry" :class:`GeoSeries`. -However, ``GeoDataFrames`` also have a few extra methods for input and output which are described on the :doc:`Input and Output ` page and for geocoding with are described in :doc:`Geocoding `. +However, :class:`GeoDataFrames ` also have a few extra methods for input and output which are described on the :doc:`Input and Output ` page and for geocoding with are described in :doc:`Geocoding `. .. ipython:: python @@ -157,7 +158,7 @@ option to control: geopandas.options The ``geopandas.options.display_precision`` option can control the number of -decimals to show in the display of coordinates in the geometry column. +decimals to show in the display of coordinates in the geometry column. In the ``world`` example of above, the default is to show 5 decimals for geographic coordinates: diff --git a/doc/source/geocoding.rst b/doc/source/docs/user_guide/geocoding.rst similarity index 74% rename from doc/source/geocoding.rst rename to doc/source/docs/user_guide/geocoding.rst index c573f59..7605e8c 100644 --- a/doc/source/geocoding.rst +++ b/doc/source/docs/user_guide/geocoding.rst @@ -32,17 +32,17 @@ with the detailed borough boundary file included within ``geopandas``. boro_locations.plot(ax=ax, color="red"); -By default, the ``geocode`` function uses the -`GeoCode.Farm geocoding API `__ with a rate limitation -applied. But a different geocoding service can be specified with the +By default, the :func:`~geopandas.tools.geocode` function uses the +`Photon geocoding API `__. +But a different geocoding service can be specified with the ``provider`` keyword. The argument to ``provider`` can either be a string referencing geocoding services, such as ``'google'``, ``'bing'``, ``'yahoo'``, and -``'openmapquest'``, or an instance of a ``Geocoder`` from ``geopy``. See +``'openmapquest'``, or an instance of a :mod:`Geocoder ` from :mod:`geopy`. See ``geopy.geocoders.SERVICE_TO_GEOCODER`` for the full list. For many providers, parameters such as API keys need to be passed as -``**kwargs`` in the ``geocode`` call. +``**kwargs`` in the :func:`~geopandas.tools.geocode` call. For example, to use the OpenStreetMap Nominatim geocoder, you need to specify a user agent: @@ -54,6 +54,6 @@ a user agent: .. attention:: Please consult the Terms of Service for the chosen provider. The example - above uses ``'geocodefarm'`` (the default), for which free users are - limited to 250 calls per day and 4 requests per second - (`geocodefarm ToS `_). + above uses ``'photon'`` (the default), which expects fair usage + - extensive usage will be throttled. + (`Photon's Terms of Use `_). diff --git a/doc/source/geometric_manipulations.rst b/doc/source/docs/user_guide/geometric_manipulations.rst similarity index 67% rename from doc/source/geometric_manipulations.rst rename to doc/source/docs/user_guide/geometric_manipulations.rst index 4eefb4e..d29eeb6 100644 --- a/doc/source/geometric_manipulations.rst +++ b/doc/source/docs/user_guide/geometric_manipulations.rst @@ -3,7 +3,7 @@ Geometric Manipulations ======================== -*geopandas* makes available all the tools for geometric manipulations in the `*shapely* library `_. +*geopandas* makes available all the tools for geometric manipulations in the `shapely library `_. Note that documentation for all set-theoretic tools for creating new shapes using the relationship between two different spatial datasets -- like creating intersections, or differences -- can be found on the :doc:`set operations ` page. @@ -12,39 +12,39 @@ Constructive Methods .. method:: GeoSeries.buffer(distance, resolution=16) - Returns a ``GeoSeries`` of geometries representing all points within a given `distance` + Returns a :class:`~geopandas.GeoSeries` of geometries representing all points within a given `distance` of each geometric object. .. attribute:: GeoSeries.boundary - Returns a ``GeoSeries`` of lower dimensional objects representing + Returns a :class:`~geopandas.GeoSeries` of lower dimensional objects representing each geometries's set-theoretic `boundary`. .. attribute:: GeoSeries.centroid - Returns a ``GeoSeries`` of points for each geometric centroid. + Returns a :class:`~geopandas.GeoSeries` of points for each geometric centroid. .. attribute:: GeoSeries.convex_hull - Returns a ``GeoSeries`` of geometries representing the smallest + Returns a :class:`~geopandas.GeoSeries` of geometries representing the smallest convex `Polygon` containing all the points in each object unless the number of points in the object is less than three. For two points, the convex hull collapses to a `LineString`; for 1, a `Point`. .. attribute:: GeoSeries.envelope - Returns a ``GeoSeries`` of geometries representing the point or + Returns a :class:`~geopandas.GeoSeries` of geometries representing the point or smallest rectangular polygon (with sides parallel to the coordinate axes) that contains each object. .. method:: GeoSeries.simplify(tolerance, preserve_topology=True) - Returns a ``GeoSeries`` containing a simplified representation of + Returns a :class:`~geopandas.GeoSeries` containing a simplified representation of each object. .. attribute:: GeoSeries.unary_union - Return a geometry containing the union of all geometries in the ``GeoSeries``. + Return a geometry containing the union of all geometries in the :class:`~geopandas.GeoSeries`. Affine transformations @@ -52,23 +52,23 @@ Affine transformations .. method:: GeoSeries.affine_transform(self, matrix) - Transform the geometries of the GeoSeries using an affine transformation matrix + Transform the geometries of the :class:`~geopandas.GeoSeries` using an affine transformation matrix .. method:: GeoSeries.rotate(self, angle, origin='center', use_radians=False) - Rotate the coordinates of the GeoSeries. + Rotate the coordinates of the :class:`~geopandas.GeoSeries`. .. method:: GeoSeries.scale(self, xfact=1.0, yfact=1.0, zfact=1.0, origin='center') - Scale the geometries of the GeoSeries along each (x, y, z) dimensio. + Scale the geometries of the :class:`~geopandas.GeoSeries` along each (x, y, z) dimension. .. method:: GeoSeries.skew(self, angle, origin='center', use_radians=False) - Shear/Skew the geometries of the GeoSeries by angles along x and y dimensions. + Shear/Skew the geometries of the :class:`~geopandas.GeoSeries` by angles along x and y dimensions. .. method:: GeoSeries.translate(self, xoff=0.0, yoff=0.0, zoff=0.0) - Shift the coordinates of the GeoSeries. + Shift the coordinates of the :class:`~geopandas.GeoSeries`. @@ -90,9 +90,9 @@ Examples of Geometric Manipulations 2 POLYGON ((2 0, 3 0, 3 1, 2 1, 2 0)) dtype: geometry -.. image:: _static/test.png +.. image:: ../../_static/test.png -Some geographic operations return normal pandas object. The ``area`` property of a ``GeoSeries`` will return a ``pandas.Series`` containing the area of each item in the ``GeoSeries``: +Some geographic operations return normal pandas object. The :attr:`~geopandas.GeoSeries.area` property of a :class:`~geopandas.GeoSeries` will return a :class:`pandas.Series` containing the area of each item in the :class:`~geopandas.GeoSeries`: .. sourcecode:: python @@ -112,9 +112,9 @@ Other operations return GeoPandas objects: 2 POLYGON ((1.5 0, 1.5 1, 1.502407636663901 1.04... dtype: geometry -.. image:: _static/test_buffer.png +.. image:: ../../_static/test_buffer.png -GeoPandas objects also know how to plot themselves. GeoPandas uses `descartes`_ to generate a `matplotlib`_ plot. To generate a plot of our GeoSeries, use: +GeoPandas objects also know how to plot themselves. GeoPandas uses `matplotlib`_ for plotting. To generate a plot of our GeoSeries, use: .. sourcecode:: python @@ -130,22 +130,22 @@ GeoPandas also implements alternate constructors that can read any data format r >>> boros.sort_index(inplace=True) >>> boros BoroName Shape_Leng Shape_Area \ - BoroCode - 1 Manhattan 359299.096471 6.364715e+08 - 2 Bronx 464392.991824 1.186925e+09 - 3 Brooklyn 741080.523166 1.937479e+09 - 4 Queens 896344.047763 3.045213e+09 - 5 Staten Island 330470.010332 1.623820e+09 - - geometry - BoroCode - 1 MULTIPOLYGON (((981219.0557861328 188655.31579... - 2 MULTIPOLYGON (((1012821.805786133 229228.26458... - 3 MULTIPOLYGON (((1021176.479003906 151374.79699... - 4 MULTIPOLYGON (((1029606.076599121 156073.81420... - 5 MULTIPOLYGON (((970217.0223999023 145643.33221... + BoroCode + 1 Manhattan 359299.096471 6.364715e+08 + 2 Bronx 464392.991824 1.186925e+09 + 3 Brooklyn 741080.523166 1.937479e+09 + 4 Queens 896344.047763 3.045213e+09 + 5 Staten Island 330470.010332 1.623820e+09 -.. image:: _static/nyc.png + geometry + BoroCode + 1 MULTIPOLYGON (((981219.0557861328 188655.31579... + 2 MULTIPOLYGON (((1012821.805786133 229228.26458... + 3 MULTIPOLYGON (((1021176.479003906 151374.79699... + 4 MULTIPOLYGON (((1029606.076599121 156073.81420... + 5 MULTIPOLYGON (((970217.0223999023 145643.33221... + +.. image:: ../../_static/nyc.png .. sourcecode:: python @@ -158,10 +158,10 @@ GeoPandas also implements alternate constructors that can read any data format r 5 POLYGON ((915517.6877458114 120121.8812543372,... dtype: geometry -.. image:: _static/nyc_hull.png +.. image:: ../../_static/nyc_hull.png To demonstrate a more complex operation, we'll generate a -``GeoSeries`` containing 2000 random points: +:class:`~geopandas.GeoSeries` containing 2000 random points: .. sourcecode:: python @@ -178,7 +178,7 @@ Now draw a circle with fixed radius around each point: >>> circles = pts.buffer(2000) -We can collapse these circles into a single shapely MultiPolygon +We can collapse these circles into a single :class:`MultiPolygon` geometry with .. sourcecode:: python @@ -192,7 +192,7 @@ just use: >>> holes = boros['geometry'].intersection(mp) -.. image:: _static/holes.png +.. image:: ../../_static/holes.png and to get the area outside of the holes: @@ -200,11 +200,11 @@ and to get the area outside of the holes: >>> boros_with_holes = boros['geometry'].difference(mp) -.. image:: _static/boros_with_holes.png +.. image:: ../../_static/boros_with_holes.png Note that this can be simplified a bit, since ``geometry`` is -available as an attribute on a ``GeoDataFrame``, and the -``intersection`` and ``difference`` methods are implemented with the +available as an attribute on a :class:`~geopandas.GeoDataFrame`, and the +:meth:`~geopandas.GeoSeries.intersection` and :meth:`~geopandas.GeoSeries.difference` methods are implemented with the "&" and "-" operators, respectively. For example, the latter could have been expressed simply as ``boros.geometry - mp``. @@ -222,7 +222,6 @@ borough that are in the holes: 5 0.558075 dtype: float64 -.. _Descartes: https://pypi.python.org/pypi/descartes .. _matplotlib: http://matplotlib.org .. _fiona: http://fiona.readthedocs.io/en/latest/ .. _geopy: https://github.com/geopy/geopy diff --git a/doc/source/docs/user_guide/indexing.rst b/doc/source/docs/user_guide/indexing.rst new file mode 100644 index 0000000..971e501 --- /dev/null +++ b/doc/source/docs/user_guide/indexing.rst @@ -0,0 +1,29 @@ +.. currentmodule:: geopandas + +.. ipython:: python + :suppress: + + import geopandas + + +Indexing and Selecting Data +=========================== + +GeoPandas inherits the standard pandas_ methods for indexing/selecting data. This includes label based indexing with :attr:`~pandas.DataFrame.loc` and integer position based indexing with :attr:`~pandas.DataFrame.iloc`, which apply to both :class:`GeoSeries` and :class:`GeoDataFrame` objects. For more information on indexing/selecting, see the pandas_ documentation. + +.. _pandas: http://pandas.pydata.org/pandas-docs/stable/indexing.html + +In addition to the standard pandas_ methods, GeoPandas also provides +coordinate based indexing with the :attr:`~GeoDataFrame.cx` indexer, which slices using a bounding +box. Geometries in the :class:`GeoSeries` or :class:`GeoDataFrame` that intersect the +bounding box will be returned. + +Using the ``world`` dataset, we can use this functionality to quickly select all +countries whose boundaries extend into the southern hemisphere. + +.. ipython:: python + + world = geopandas.read_file(geopandas.datasets.get_path('naturalearth_lowres')) + southern_world = world.cx[:, :0] + @savefig world_southern.png + southern_world.plot(figsize=(10, 3)); diff --git a/doc/source/docs/user_guide/interactive_mapping.ipynb b/doc/source/docs/user_guide/interactive_mapping.ipynb new file mode 100644 index 0000000..58fe74d --- /dev/null +++ b/doc/source/docs/user_guide/interactive_mapping.ipynb @@ -0,0 +1,149 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "c554e753", + "metadata": {}, + "source": [ + "# Interactive mapping\n", + "\n", + "Alongside static plots, `geopandas` can create interactive maps based on the [folium](https://python-visualization.github.io/folium/) library.\n", + "\n", + "Creating maps for interactive exploration mirrors the API of [static plots](../reference/api/geopandas.GeoDataFrame.plot.html) in an [explore()](../reference/api/geopandas.GeoDataFrame.explore.html) method of a GeoSeries or GeoDataFrame.\n", + "\n", + "Loading some example data:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "caf2fbd5", + "metadata": {}, + "outputs": [], + "source": [ + "import geopandas\n", + "\n", + "nybb = geopandas.read_file(geopandas.datasets.get_path('nybb'))\n", + "world = geopandas.read_file(geopandas.datasets.get_path('naturalearth_lowres'))\n", + "cities = geopandas.read_file(geopandas.datasets.get_path('naturalearth_cities'))" + ] + }, + { + "cell_type": "markdown", + "id": "56bf1bcf", + "metadata": {}, + "source": [ + "The simplest option is to use `GeoDataFrame.explore()`:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "6b484ecc", + "metadata": {}, + "outputs": [], + "source": [ + "nybb.explore()" + ] + }, + { + "cell_type": "markdown", + "id": "7a797389", + "metadata": {}, + "source": [ + "Interactive plotting offers largely the same customisation as static one plus some features on top of that. Check the code below which plots a customised choropleth map. You can use `\"BoroName\"` column with NY boroughs names as an input of the choropleth, show (only) its name in the tooltip on hover but show all values on click. You can also pass custom background tiles (either a name supported by folium, a name recognized by `xyzservices.providers.query_name()`, XYZ URL or `xyzservices.TileProvider` object), specify colormap (all supported by `matplotlib`) and specify black outline." + ] + }, + { + "cell_type": "markdown", + "id": "798bf532", + "metadata": {}, + "source": [ + "
\n", + "Note\n", + "\n", + "Note that the GeoDataFrame needs to have a CRS set if you want to use background tiles.\n", + "
" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "94b4ff24", + "metadata": {}, + "outputs": [], + "source": [ + "nybb.explore( \n", + " column=\"BoroName\", # make choropleth based on \"BoroName\" column\n", + " tooltip=\"BoroName\", # show \"BoroName\" value in tooltip (on hover)\n", + " popup=True, # show all values in popup (on click)\n", + " tiles=\"CartoDB positron\", # use \"CartoDB positron\" tiles\n", + " cmap=\"Set1\", # use \"Set1\" matplotlib colormap\n", + " style_kwds=dict(color=\"black\") # use black outline\n", + " )" + ] + }, + { + "cell_type": "markdown", + "id": "5a10291e", + "metadata": {}, + "source": [ + "The `explore()` method returns a `folium.Map` object, which can also be passed directly (as you do with `ax` in `plot()`). You can then use folium functionality directly on the resulting map. In the example below, you can plot two GeoDataFrames on the same map and add layer control using folium. You can also add additional tiles allowing you to change the background directly in the map." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "cba9970b", + "metadata": {}, + "outputs": [], + "source": [ + "import folium\n", + "\n", + "m = world.explore(\n", + " column=\"pop_est\", # make choropleth based on \"BoroName\" column\n", + " scheme=\"naturalbreaks\", # use mapclassify's natural breaks scheme\n", + " legend=True, # show legend\n", + " k=10, # use 10 bins\n", + " legend_kwds=dict(colorbar=False), # do not use colorbar\n", + " name=\"countries\" # name of the layer in the map\n", + ")\n", + "\n", + "cities.explore(\n", + " m=m, # pass the map object\n", + " color=\"red\", # use red color on all points\n", + " marker_kwds=dict(radius=10, fill=True), # make marker radius 10px with fill\n", + " tooltip=\"name\", # show \"name\" column in the tooltip\n", + " tooltip_kwds=dict(labels=False), # do not show column label in the tooltip\n", + " name=\"cities\" # name of the layer in the map\n", + ")\n", + "\n", + "folium.TileLayer('Stamen Toner', control=True).add_to(m) # use folium to add alternative tiles\n", + "folium.LayerControl().add_to(m) # use folium to add layer control\n", + "\n", + "m # show map" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.2" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/doc/source/io.rst b/doc/source/docs/user_guide/io.rst similarity index 61% rename from doc/source/io.rst rename to doc/source/docs/user_guide/io.rst index 1316d6d..534891a 100644 --- a/doc/source/io.rst +++ b/doc/source/docs/user_guide/io.rst @@ -1,28 +1,36 @@ .. _io: Reading and Writing Files -========================================= - - +========================= Reading Spatial Data --------------------- -*geopandas* can read almost any vector-based spatial data format including ESRI shapefile, GeoJSON files and more using the command:: +*geopandas* can read almost any vector-based spatial data format including ESRI +shapefile, GeoJSON files and more using the command:: geopandas.read_file() -which returns a GeoDataFrame object. (This is possible because *geopandas* makes use of the great `fiona `_ library, which in turn makes use of a massive open-source program called `GDAL/OGR `_ designed to facilitate spatial data transformations). +which returns a GeoDataFrame object. This is possible because *geopandas* makes +use of the great `fiona `_ +library, which in turn makes use of a massive open-source program called +`GDAL/OGR `_ designed to facilitate spatial data +transformations. -Any arguments passed to :func:`geopandas.read_file` after the file name will be passed directly to ``fiona.open``, which does the actual data importation. In general, :func:`geopandas.read_file` is pretty smart and should do what you want without extra arguments, but for more help, type:: +Any arguments passed to :func:`geopandas.read_file` after the file name will be +passed directly to :func:`fiona.open`, which does the actual data importation. In +general, :func:`geopandas.read_file` is pretty smart and should do what you want +without extra arguments, but for more help, type:: import fiona; help(fiona.open) -Among other things, one can explicitly set the driver (shapefile, GeoJSON) with the ``driver`` keyword, or pick a single layer from a multi-layered file with the ``layer`` keyword:: +Among other things, one can explicitly set the driver (shapefile, GeoJSON) with +the ``driver`` keyword, or pick a single layer from a multi-layered file with +the ``layer`` keyword:: countries_gdf = geopandas.read_file("package.gpkg", layer='countries') -Where supported in ``fiona``, *geopandas* can also load resources directly from +Where supported in :mod:`fiona`, *geopandas* can also load resources directly from a web URL, for example for GeoJSON files from `geojson.xyz `_:: url = "http://d2ad6b4ur7yvpq.cloudfront.net/naturalearth-3.3.0/ne_110m_land.geojson" @@ -37,25 +45,32 @@ If the dataset is in a folder in the ZIP file, you have to append its name:: zipfile = "zip:///Users/name/Downloads/gadm36_AFG_shp.zip!data" -If there are multiple datasets in a folder in the ZIP file, you also have to specify the filename:: +If there are multiple datasets in a folder in the ZIP file, you also have to +specify the filename:: zipfile = "zip:///Users/name/Downloads/gadm36_AFG_shp.zip!data/gadm36_AFG_1.shp" -It is also possible to read any file-like objects with a ``read()`` method, such as a file handler (e.g. via built-in ``open`` function) or ``StringIO``:: +It is also possible to read any file-like objects with a :func:`os.read` method, such +as a file handler (e.g. via built-in :func:`open` function) or :class:`~io.StringIO`:: filename = "test.geojson" file = open(filename) df = geopandas.read_file(file) +File-like objects from `fsspec `_ +can also be used to read data, allowing for any combination of storage backends and caching +supported by that project:: + + path = "simplecache::http://download.geofabrik.de/antarctica-latest-free.shp.zip" + with fsspec.open(path) as file: + df = geopandas.read_file(file) + You can also read path objects:: import pathlib path_object = pathlib.path(filename) df = geopandas.read_file(path_object) -*geopandas* can also get data from a PostGIS database using the :func:`geopandas.read_postgis` command. - - Reading subsets of the data ~~~~~~~~~~~~~~~~~~~~~~~~~~~ @@ -172,9 +187,47 @@ by using the :meth:`geopandas.GeoDataFrame.to_postgis` method. countries_gdf.to_file("package.gpkg", layer='countries', driver="GPKG") cities_gdf.to_file("package.gpkg", layer='cities', driver="GPKG") -**Writing to PostGIS**:: + +Spatial databases +----------------- + +*geopandas* can also get data from a PostGIS database using the +:func:`geopandas.read_postgis` command. + +Writing to PostGIS:: from sqlalchemy import create_engine - db_connection_url = "postgres://myusername:mypassword@myhost:5432/mydatabase"; + db_connection_url = "postgresql://myusername:mypassword@myhost:5432/mydatabase"; engine = create_engine(db_connection_url) - countries_gdf.to_postgis(name="countries_table", con=engine) + countries_gdf.to_postgis("countries_table", con=engine) + + +Apache Parquet and Feather file formats +--------------------------------------- + +.. versionadded:: 0.8.0 + +GeoPandas supports writing and reading the Apache Parquet and Feather file +formats. + +`Apache Parquet `__ is an efficient, columnar +storage format (originating from the Hadoop ecosystem). It is a widely used +binary file format for tabular data. The Feather file format is the on-disk +representation of the `Apache Arrow `__ memory +format, an open standard for in-memory columnar data. + +The :func:`geopandas.read_parquet`, :func:`geopandas.read_feather`, +:meth:`GeoDataFrame.to_parquet` and :meth:`GeoDataFrame.to_feather` methods +enable fast roundtrip from GeoPandas to those binary file formats, preserving +the spatial information. + +.. warning:: + + This is an initial implementation of Parquet file support and + associated metadata. This is tracking version 0.1.0 of the metadata + specification at: + https://github.com/geopandas/geo-arrow-spec + + This metadata specification does not yet make stability promises. As such, + we do not yet recommend using this in a production setting unless you are + able to rewrite your Parquet or Feather files. diff --git a/doc/source/mapping.rst b/doc/source/docs/user_guide/mapping.rst similarity index 76% rename from doc/source/mapping.rst rename to doc/source/docs/user_guide/mapping.rst index c278db2..af0ad22 100644 --- a/doc/source/mapping.rst +++ b/doc/source/docs/user_guide/mapping.rst @@ -11,11 +11,13 @@ plt.close('all') -Mapping Tools +Mapping and Plotting Tools ========================================= -*geopandas* provides a high-level interface to the ``matplotlib`` library for making maps. Mapping shapes is as easy as using the ``plot()`` method on a ``GeoSeries`` or ``GeoDataFrame``. +*geopandas* provides a high-level interface to the matplotlib_ library for making maps. Mapping shapes is as easy as using the :meth:`~GeoDataFrame.plot()` method on a :class:`GeoSeries` or :class:`GeoDataFrame`. + +.. _matplotlib: https://matplotlib.org/stable/ Loading some example data: @@ -35,7 +37,7 @@ We can now plot those GeoDataFrames: @savefig world_randomcolors.png world.plot(); -Note that in general, any options one can pass to `pyplot `_ in ``matplotlib`` (or `style options that work for lines `_) can be passed to the ``plot()`` method. +Note that in general, any options one can pass to `pyplot `_ in matplotlib_ (or `style options that work for lines `_) can be passed to the :meth:`~GeoDataFrame.plot` method. Choropleth Maps @@ -44,8 +46,9 @@ Choropleth Maps *geopandas* makes it easy to create Choropleth maps (maps where the color of each shape is based on the value of an associated variable). Simply use the plot command with the ``column`` argument set to the column whose values you want used to assign colors. .. ipython:: python + :okwarning: - # Plot by GDP per capta + # Plot by GDP per capita world = world[(world.pop_est>0) & (world.name!="Antarctica")] world['gdp_per_cap'] = world.gdp_md_est / world.pop_est @savefig world_gdp_per_cap.png @@ -65,7 +68,7 @@ When plotting a map, one can enable a legend using the ``legend`` argument: @savefig world_pop_est.png world.plot(column='pop_est', ax=ax, legend=True) -However, the default appearance of the legend and plot axes may not be desirable. One can define the plot axes (with ``ax``) and the legend axes (with ``cax``) and then pass those in to the ``plot`` call. The following example uses ``mpl_toolkits`` to vertically align the plot axes and the legend axes: +However, the default appearance of the legend and plot axes may not be desirable. One can define the plot axes (with ``ax``) and the legend axes (with ``cax``) and then pass those in to the :meth:`~GeoDataFrame.plot` call. The following example uses ``mpl_toolkits`` to vertically align the plot axes and the legend axes: .. ipython:: python @@ -96,7 +99,7 @@ And the following example plots the color bar below the map and adds its label u Choosing colors ~~~~~~~~~~~~~~~~ -One can also modify the colors used by ``plot`` with the ``cmap`` option (for a full list of colormaps, see the `matplotlib website `_): +One can also modify the colors used by :meth:`~GeoDataFrame.plot` with the ``cmap`` option (for a full list of colormaps, see the `matplotlib website `_): .. ipython:: python @@ -113,7 +116,7 @@ To make the color transparent for when you just want to show the boundary, you h The way color maps are scaled can also be manipulated with the ``scheme`` option (if you have ``mapclassify`` installed, which can be accomplished via ``conda install -c conda-forge mapclassify``). The ``scheme`` option can be set to any scheme provided by mapclassify (e.g. 'box_plot', 'equal_interval', -'fisher_jenks', 'fisher_jenks_sampled', 'headtail_breaks', 'jenks_caspall', 'jenks_caspall_forced', 'jenks_caspall_sampled', 'max_p_classifier', 'maximum_breaks', 'natural_breaks', 'quantiles', 'percentiles', 'std_mean' or 'user_defined'). Arguments can be passed in classification_kwds dict. See the `mapclassify documentation `_ for further details about these map classification schemes. +'fisher_jenks', 'fisher_jenks_sampled', 'headtail_breaks', 'jenks_caspall', 'jenks_caspall_forced', 'jenks_caspall_sampled', 'max_p_classifier', 'maximum_breaks', 'natural_breaks', 'quantiles', 'percentiles', 'std_mean' or 'user_defined'). Arguments can be passed in classification_kwds dict. See the `mapclassify documentation `_ for further details about these map classification schemes. .. ipython:: python @@ -154,6 +157,17 @@ However, passing ``missing_kwds`` one can specify the style and label of feature }, ); +Other map customizations +~~~~~~~~~~~~~~~~~~~~~~~~ + +Maps usually do not have to have axis labels. You can turn them off using ``set_axis_off()`` or ``axis("off")`` axis methods. + +.. ipython:: python + + ax = world.plot() + @savefig set_axis_off.png + ax.set_axis_off(); + Maps with Layers ----------------- @@ -222,6 +236,41 @@ We can set the ``zorder`` for cities higher than for world to move it of top. @savefig zorder_set.png world.plot(ax=ax, zorder=1); + +Pandas Plots +----------------- + +Plotting methods also allow for different plot styles from pandas +along with the default ``geo`` plot. These methods can be accessed using +the ``kind`` keyword argument in :meth:`~GeoDataFrame.plot`, and include: + +* ``geo`` for mapping +* ``line`` for line plots +* ``bar`` or ``barh`` for bar plots +* ``hist`` for histogram +* ``box`` for boxplot +* ``kde`` or ``density`` for density plots +* ``area`` for area plots +* ``scatter`` for scatter plots +* ``hexbin`` for hexagonal bin plots +* ``pie`` for pie plots + +.. ipython:: python + + gdf = world.head(10) + @savefig pandas_line_plot.png + gdf.plot(kind='scatter', x="pop_est", y="gdp_md_est") + +You can also create these other plots using the ``GeoDataFrame.plot.`` accessor methods instead of providing the ``kind`` keyword argument. + +.. ipython:: python + + @savefig pandas_bar_plot.png + gdf.plot.bar() + +For more information check out the `pandas documentation `_. + + Other Resources ----------------- Links to jupyter Notebooks for different mapping tasks: diff --git a/doc/source/docs/user_guide/mergingdata.rst b/doc/source/docs/user_guide/mergingdata.rst new file mode 100644 index 0000000..cdcd6f7 --- /dev/null +++ b/doc/source/docs/user_guide/mergingdata.rst @@ -0,0 +1,162 @@ +.. currentmodule:: geopandas + +.. ipython:: python + :suppress: + + import geopandas + + +Merging Data +========================================= + +There are two ways to combine datasets in *geopandas* -- attribute joins and spatial joins. + +In an attribute join, a :class:`GeoSeries` or :class:`GeoDataFrame` is +combined with a regular :class:`pandas.Series` or :class:`pandas.DataFrame` based on a +common variable. This is analogous to normal merging or joining in *pandas*. + +In a Spatial Join, observations from two :class:`GeoSeries` or :class:`GeoDataFrame` +are combined based on their spatial relationship to one another. + +In the following examples, we use these datasets: + +.. ipython:: python + + world = geopandas.read_file(geopandas.datasets.get_path('naturalearth_lowres')) + cities = geopandas.read_file(geopandas.datasets.get_path('naturalearth_cities')) + + # For attribute join + country_shapes = world[['geometry', 'iso_a3']] + country_names = world[['name', 'iso_a3']] + + # For spatial join + countries = world[['geometry', 'name']] + countries = countries.rename(columns={'name':'country'}) + + +Appending +--------- + +Appending :class:`GeoDataFrame` and :class:`GeoSeries` uses pandas :meth:`~pandas.DataFrame.append` methods. +Keep in mind, that appended geometry columns needs to have the same CRS. + +.. ipython:: python + + # Appending GeoSeries + joined = world.geometry.append(cities.geometry) + + # Appending GeoDataFrames + europe = world[world.continent == 'Europe'] + asia = world[world.continent == 'Asia'] + eurasia = europe.append(asia) + + +Attribute Joins +---------------- + +Attribute joins are accomplished using the :meth:`~pandas.DataFrame.merge` method. In general, it is recommended +to use the ``merge()`` method called from the spatial dataset. With that said, the stand-alone +:func:`pandas.merge` function will work if the :class:`GeoDataFrame` is in the ``left`` argument; +if a :class:`~pandas.DataFrame` is in the ``left`` argument and a :class:`GeoDataFrame` +is in the ``right`` position, the result will no longer be a :class:`GeoDataFrame`. + +For example, consider the following merge that adds full names to a :class:`GeoDataFrame` +that initially has only ISO codes for each country by merging it with a :class:`~pandas.DataFrame`. + +.. ipython:: python + + # `country_shapes` is GeoDataFrame with country shapes and iso codes + country_shapes.head() + + # `country_names` is DataFrame with country names and iso codes + country_names.head() + + # Merge with `merge` method on shared variable (iso codes): + country_shapes = country_shapes.merge(country_names, on='iso_a3') + country_shapes.head() + + +Spatial Joins +---------------- + +In a Spatial Join, two geometry objects are merged based on their spatial relationship to one another. + +.. ipython:: python + + + # One GeoDataFrame of countries, one of Cities. + # Want to merge so we can get each city's country. + countries.head() + cities.head() + + # Execute spatial join + + cities_with_country = cities.sjoin(countries, how="inner", predicate='intersects') + cities_with_country.head() + + +GeoPandas provides two spatial-join functions: + +- :meth:`GeoDataFrame.sjoin`: joins based on binary predicates (intersects, contains, etc.) +- :meth:`GeoDataFrame.sjoin_nearest`: joins based on proximity, with the ability to set a maximum search radius. + +.. note:: + For historical reasons, both methods are also available as top-level functions :func:`sjoin` and :func:`sjoin_nearest`. + It is recommended to use methods as the functions may be deprecated in the future. + +Binary Predicate Joins +~~~~~~~~~~~~~~~~~~~~~~ + +Binary predicate joins are available via :meth:`GeoDataFrame.sjoin`. + +:meth:`GeoDataFrame.sjoin` has two core arguments: ``how`` and ``predicate``. + +**predicate** + +The ``predicate`` argument specifies how ``geopandas`` decides whether or not to join the attributes of one +object to another, based on their geometric relationship. + +The values for ``predicate`` correspond to the names of geometric binary predicates and depend on the spatial +index implementation. + +The default spatial index in ``geopandas`` currently supports the following values for ``predicate`` which are +defined in the +`Shapely documentation `__: + +* `intersects` +* `contains` +* `within` +* `touches` +* `crosses` +* `overlaps` + +**how** + +The `how` argument specifies the type of join that will occur and which geometry is retained in the resultant +:class:`GeoDataFrame`. It accepts the following options: + +* ``left``: use the index from the first (or `left_df`) :class:`GeoDataFrame` that you provide + to :meth:`GeoDataFrame.sjoin`; retain only the `left_df` geometry column +* ``right``: use index from second (or `right_df`); retain only the `right_df` geometry column +* ``inner``: use intersection of index values from both :class:`GeoDataFrame`; retain only the `left_df` geometry column + +Note more complicated spatial relationships can be studied by combining geometric operations with spatial join. +To find all polygons within a given distance of a point, for example, one can first use the :meth:`~geopandas.GeoSeries.buffer` method to expand each +point into a circle of appropriate radius, then intersect those buffered circles with the polygons in question. + +Nearest Joins +~~~~~~~~~~~~~ + +Proximity-based joins can be done via :meth:`GeoDataFrame.sjoin_nearest`. + +:meth:`GeoDataFrame.sjoin_nearest` shares the ``how`` argument with :meth:`GeoDataFrame.sjoin`, and +includes two additional arguments: ``max_distance`` and ``distance_col``. + +**max_distance** + +The ``max_distance`` argument specifies a maximum search radius for matching geometries. This can have a considerable performance impact in some cases. +If you can, it is highly recommended that you use this parameter. + +**distance_col** + +If set, the resultant GeoDataFrame will include a column with this name containing the computed distances between an input geometry and the nearest geometry. diff --git a/doc/source/missing_empty.rst b/doc/source/docs/user_guide/missing_empty.rst similarity index 93% rename from doc/source/missing_empty.rst rename to doc/source/docs/user_guide/missing_empty.rst index 39905d0..74ed2b7 100644 --- a/doc/source/missing_empty.rst +++ b/doc/source/docs/user_guide/missing_empty.rst @@ -22,7 +22,7 @@ empty geometries: a Shapely geometry object. - **Missing geometries** are unknown values in a GeoSeries. They will typically be propagated in operations (for example in calculations of the area or of - the intersection), or ignored in reductions such as ``unary_union``. + the intersection), or ignored in reductions such as :attr:`~GeoSeries.unary_union`. The scalar object (when accessing a single element of a GeoSeries) is the Python ``None`` object. @@ -67,7 +67,7 @@ you can use the :attr:`GeoSeries.is_empty` attribute: s.is_empty -To get only the actual geometry objects that are neiter missing nor empty, +To get only the actual geometry objects that are neither missing nor empty, you can use a combination of both: .. ipython:: python @@ -160,7 +160,7 @@ Consider the following small toy example: .. code-block:: python - >>> s1.intersection(s2) + >>> s1.intersection(s2) 0 GEOMETRYCOLLECTION EMPTY 1 POINT (1 1) 2 GEOMETRYCOLLECTION EMPTY @@ -169,7 +169,7 @@ Consider the following small toy example: * Starting from GeoPandas v0.6.0, :meth:`GeoSeries.align` will use missing values to fill in the non-aligned indices, to be consistent with the behaviour in pandas: - + .. ipython:: python s1_aligned, s2_aligned = s1.align(s2) @@ -181,5 +181,6 @@ Consider the following small toy example: depending on the spatial operation: .. ipython:: python + :okwarning: s1.intersection(s2) diff --git a/doc/source/projections.rst b/doc/source/docs/user_guide/projections.rst similarity index 90% rename from doc/source/projections.rst rename to doc/source/docs/user_guide/projections.rst index 2896ea5..8a9896a 100644 --- a/doc/source/projections.rst +++ b/doc/source/docs/user_guide/projections.rst @@ -30,7 +30,7 @@ referred to using the authority code ``"EPSG:4326"``. - CRS WKT string - An authority string (i.e. "epsg:4326") - An EPSG integer code (i.e. 4326) -- A ``pyproj.CRS`` +- A :class:`pyproj.CRS ` - An object with a to_wkt method. - PROJ string - Dictionary of PROJ parameters @@ -71,7 +71,7 @@ the :attr:`GeoSeries.crs` attribute): .. sourcecode:: python - my_geoseries = my_geoseries.set_crs("EPSG:4326"}) + my_geoseries = my_geoseries.set_crs("EPSG:4326") my_geoseries = my_geoseries.set_crs(epsg=4326) @@ -86,7 +86,7 @@ Re-projecting is the process of changing the representation of locations from on world = geopandas.read_file(geopandas.datasets.get_path('naturalearth_lowres')) # Check original projection - # (it's Platte Carre! x-y are long and lat) + # (it's Plate Carrée! x-y are long and lat) world.crs # Visualize @@ -109,8 +109,8 @@ GeoPandas 0.8 implements support for different projections assigned to different columns of the same GeoDataFrame. The projection is now stored together with geometries per column (directly on the GeometryArray level). -Note that if GeometryArray has assigned projection, it is preferred over the -projection passed to GeoSeries or GeoDataFrame during the creation: +Note that if GeometryArray has an assigned projection, it cannot be overridden by an another inconsistent +projection during the creation of a GeoSeries or GeoDataFrame: .. code-block:: python @@ -121,18 +121,12 @@ projection passed to GeoSeries or GeoDataFrame during the creation: - Lat[north]: Geodetic latitude (degree) - Lon[east]: Geodetic longitude (degree) ... - >>> GeoSeries(array, crs=3395).crs # crs=3395 is ignored as array already has CRS - FutureWarning: CRS mismatch between CRS of the passed geometries and 'crs'. Use 'GeoDataFrame.set_crs(crs, allow_override=True)' to overwrite CRS or 'GeoDataFrame.to_crs(crs)' to reproject geometries. CRS mismatch will raise an error in the future versions of GeoPandas. + >>> GeoSeries(array, crs=4326) # crs=4326 is okay, as it matches the existing CRS + >>> GeoSeries(array, crs=3395) # crs=3395 is forbidden as array already has CRS + ValueError: CRS mismatch between CRS of the passed geometries and 'crs'. Use 'GeoSeries.set_crs(crs, allow_override=True)' to overwrite CRS or 'GeoSeries.to_crs(crs)' to reproject geometries. GeoSeries(array, crs=3395).crs - - Name: WGS 84 - Axis Info [ellipsoidal]: - - Lat[north]: Geodetic latitude (degree) - - Lon[east]: Geodetic longitude (degree) - ... - -If you want to overwrite projection, you can then assign it to the GeoSeries +If you want to overwrite the projection, you can then assign it to the GeoSeries manually or re-project geometries to the target projection using either ``GeoSeries.set_crs(epsg=3395, allow_override=True)`` or ``GeoSeries.to_crs(epsg=3395)``. @@ -145,7 +139,7 @@ Upgrading to GeoPandas 0.7 with pyproj > 2.2 and PROJ > 6 --------------------------------------------------------- Starting with GeoPandas 0.7, the `.crs` attribute of a GeoSeries or GeoDataFrame -stores the CRS information as a ``pyproj.CRS``, and no longer as a proj4 string +stores the CRS information as a :class:`pyproj.CRS `, and no longer as a proj4 string or dict. Before, you might have seen this: @@ -176,7 +170,7 @@ for some more background, and the subsections below cover different possible migration issues. See the `pyproj docs `__ for more on -the ``pyproj.CRS`` object. +the :class:`pyproj.CRS ` object. Importing data from files ^^^^^^^^^^^^^^^^^^^^^^^^^ @@ -240,7 +234,7 @@ For example, instead of: gdf.crs = "+proj=laea +lat_0=45 +lon_0=-100 +x_0=0 +y_0=0 +a=6370997 +b=6370997 +units=m +no_defs" -we recommenend to do: +we recommend to do: .. code-block:: python @@ -267,11 +261,11 @@ including their EPSG codes and proj4 string definitions. **Other formats** Next to the EPSG code mentioned above, there are also other ways to specify the -CRS: an actual ``pyproj.CRS`` object, a WKT string, a PROJ JSON string, etc. -Anything that is accepted by ``pyproj.CRS.from_user_input`` can by specified +CRS: an actual :class:`pyproj.CRS ` object, a WKT string, a PROJ JSON string, etc. +Anything that is accepted by :meth:`pyproj.CRS.from_user_input() ` can by specified to the ``crs`` keyword/attribute in GeoPandas. -Also compatible CRS objects, such as from the ``rasterio`` package, can be +Also compatible CRS objects, such as from the :mod:`rasterio` package, can be passed directly to GeoPandas. @@ -306,7 +300,7 @@ Why is it not properly recognizing my CRS? There are many file sources and CRS definitions out there "in the wild" that might have a CRS description that does not fully conform to the new standards of PROJ > 6 (proj4 strings, older WKT formats, ...). In such cases, you will get a -``pyproj.CRS`` object that might not be fully what you expected (e.g. not equal +:class:`pyproj.CRS ` object that might not be fully what you expected (e.g. not equal to the expected EPSG code). Below we list a few possible cases. I get a "Bound CRS"? @@ -447,7 +441,7 @@ The ``.crs`` attribute is no longer a dict or string ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ If you relied on the ``.crs`` object being a dict or a string, such code can -be broken given it is now a ``pyproj.CRS`` object. But this object actually +be broken given it is now a :class:`pyproj.CRS ` object. But this object actually provides a more robust interface to get information about the CRS. For example, if you used the following code to get the EPSG code: @@ -457,7 +451,7 @@ For example, if you used the following code to get the EPSG code: gdf.crs['init'] This will no longer work. To get the EPSG code from a ``crs`` object, you can use -the ``to_epsg()`` method. +the :meth:`~pyproj.crs.CRS.to_epsg` method. Or to check if a CRS was a certain UTM zone: @@ -465,11 +459,11 @@ Or to check if a CRS was a certain UTM zone: '+proj=utm ' in gdf.crs -could be replaced with the longer but more robust check: +could be replaced with the more robust check (requires pyproj 2.6+): .. code-block:: python - gdf.crs.is_projected and gdf.crs.coordinate_operation.name.upper().startswith('UTM') + gdf.crs.utm_zone is not None -And there are many other methods available on the ``pyproj.CRS`` class to get +And there are many other methods available on the :class:`pyproj.CRS ` class to get information about the CRS. diff --git a/doc/source/docs/user_guide/reproject_fiona.rst b/doc/source/docs/user_guide/reproject_fiona.rst new file mode 100644 index 0000000..dea76dd --- /dev/null +++ b/doc/source/docs/user_guide/reproject_fiona.rst @@ -0,0 +1,87 @@ +Re-projecting using GDAL with Rasterio and Fiona +================================================ + +The simplest method of re-projecting is :meth:`GeoDataFrame.to_crs`. +It uses ``pyproj`` as the engine and transforms the points within the geometries. + +These examples demonstrate how to use ``Fiona`` or ``rasterio`` as the engine to re-project your data. +Fiona and rasterio are powered by GDAL and with algorithms that consider the geometry instead of +just the points the geometry contains. This is particularly useful for antimeridian cutting. +However, this also means the transformation is not as fast. + + +Fiona Example +------------- + +.. code-block:: python + + from functools import partial + + import fiona + import geopandas + from fiona.transform import transform_geom + from packaging import version + from pyproj import CRS + from pyproj.enums import WktVersion + from shapely.geometry import mapping, shape + + + # set up Fiona transformer + def crs_to_fiona(proj_crs): + proj_crs = CRS.from_user_input(proj_crs) + if version.parse(fiona.__gdal_version__) < version.parse("3.0.0"): + fio_crs = proj_crs.to_wkt(WktVersion.WKT1_GDAL) + else: + # GDAL 3+ can use WKT2 + fio_crs = proj_crs.to_wkt() + return fio_crs + + def base_transformer(geom, src_crs, dst_crs): + return shape( + transform_geom( + src_crs=crs_to_fiona(src_crs), + dst_crs=crs_to_fiona(dst_crs), + geom=mapping(geom), + antimeridian_cutting=True, + ) + ) + + # load example data + world = geopandas.read_file(geopandas.datasets.get_path('naturalearth_lowres')) + + destination_crs = "EPSG:3395" + forward_transformer = partial(base_transformer, src_crs=world.crs, dst_crs=destination_crs) + + # Reproject to Mercator (after dropping Antartica) + world = world[(world.name != "Antarctica") & (world.name != "Fr. S. Antarctic Lands")] + with fiona.Env(OGR_ENABLE_PARTIAL_REPROJECTION="YES"): + mercator_world = world.set_geometry(world.geometry.apply(forward_transformer), crs=destination_crs) + + +Rasterio Example +---------------- + +This example requires rasterio 1.2+ and GDAL 3+. + + +.. code-block:: python + + import geopandas + import rasterio.warp + from shapely.geometry import shape + + # load example data + world = geopandas.read_file(geopandas.datasets.get_path('naturalearth_lowres')) + # Reproject to Mercator (after dropping Antartica) + world = world[(world.name != "Antarctica") & (world.name != "Fr. S. Antarctic Lands")] + + destination_crs = "EPSG:3395" + geometry = rasterio.warp.transform_geom( + src_crs=world.crs, + dst_crs=destination_crs, + geom=world.geometry.values, + ) + mercator_world = world.set_geometry( + [shape(geom) for geom in geometry], + crs=destination_crs, + ) diff --git a/doc/source/set_operations.rst b/doc/source/docs/user_guide/set_operations.rst similarity index 77% rename from doc/source/set_operations.rst rename to doc/source/docs/user_guide/set_operations.rst index 0842cb5..f52a457 100644 --- a/doc/source/set_operations.rst +++ b/doc/source/docs/user_guide/set_operations.rst @@ -1,3 +1,5 @@ +.. currentmodule:: geopandas + .. ipython:: python :suppress: @@ -14,22 +16,23 @@ When working with multiple spatial datasets -- especially multiple *polygon* or those datasets overlap (or don't overlap). These manipulations are often referred using the language of sets -- intersections, unions, and differences. These types of operations are made available in the *geopandas* library through -the ``overlay`` function. +the :meth:`~geopandas.GeoDataFrame.overlay` method. The basic idea is demonstrated by the graphic below but keep in mind that overlays operate at the DataFrame level, not on individual geometries, and the -properties from both are retained. In effect, for every shape in the first -GeoDataFrame, this operation is executed against every other shape in the other -GeoDataFrame: +properties from both are retained. In effect, for every shape in the left +:class:`~geopandas.GeoDataFrame`, this operation is executed against every other shape in the right +:class:`~geopandas.GeoDataFrame`: -.. image:: _static/overlay_operations.png +.. image:: ../../_static/overlay_operations.png **Source: QGIS Documentation** -(Note to users familiar with the *shapely* library: ``overlay`` can be thought -of as offering versions of the standard *shapely* set-operations that deal with -the complexities of applying set operations to two *GeoSeries*. The standard -*shapely* set-operations are also available as ``GeoSeries`` methods.) +.. note:: + Note to users familiar with the *shapely* library: :meth:`~geopandas.GeoDataFrame.overlay` can be thought + of as offering versions of the standard *shapely* set-operations that deal with + the complexities of applying set operations to two *GeoSeries*. The standard + *shapely* set-operations are also available as :class:`~geopandas.GeoSeries` methods. The different Overlay operations @@ -57,16 +60,20 @@ These two GeoDataFrames have some overlapping areas: df2.plot(ax=ax, color='green', alpha=0.5); We illustrate the different overlay modes with the above example. -The ``overlay`` function will determine the set of all individual geometries +The :meth:`~geopandas.GeoDataFrame.overlay` method will determine the set of all individual geometries from overlaying the two input GeoDataFrames. This result covers the area covered by the two input GeoDataFrames, and also preserves all unique regions defined by the combined boundaries of the two GeoDataFrames. +.. note:: + For historical reasons, the overlay method is also available as a top-level function :func:`overlay`. + It is recommended to use the method as the function may be deprecated in the future. + When using ``how='union'``, all those possible geometries are returned: .. ipython:: python - res_union = geopandas.overlay(df1, df2, how='union') + res_union = df1.overlay(df2, how='union') res_union ax = res_union.plot(alpha=0.5, cmap='tab10') @@ -80,7 +87,7 @@ by both GeoDataFrames: .. ipython:: python - res_intersection = geopandas.overlay(df1, df2, how='intersection') + res_intersection = df1.overlay(df2, how='intersection') res_intersection ax = res_intersection.plot(cmap='tab10') @@ -93,7 +100,7 @@ the geometries that are only part of one of the GeoDataFrames but not of both: .. ipython:: python - res_symdiff = geopandas.overlay(df1, df2, how='symmetric_difference') + res_symdiff = df1.overlay(df2, how='symmetric_difference') res_symdiff ax = res_symdiff.plot(cmap='tab10') @@ -106,7 +113,7 @@ To obtain the geometries that are part of ``df1`` but are not contained in .. ipython:: python - res_difference = geopandas.overlay(df1, df2, how='difference') + res_difference = df1.overlay(df2, how='difference') res_difference ax = res_difference.plot(cmap='tab10') @@ -119,7 +126,7 @@ but with the geometries obtained from overlaying ``df1`` with ``df2``: .. ipython:: python - res_identity = geopandas.overlay(df1, df2, how='identity') + res_identity = df1.overlay(df2, how='identity') res_identity ax = res_identity.plot(cmap='tab10') @@ -138,7 +145,7 @@ First, we load the countries and cities example datasets and select : world = geopandas.read_file(geopandas.datasets.get_path('naturalearth_lowres')) capitals = geopandas.read_file(geopandas.datasets.get_path('naturalearth_cities')) - # Select South Amarica and some columns + # Select South America and some columns countries = world[world['continent'] == "South America"] countries = countries[['geometry', 'name']] @@ -146,7 +153,7 @@ First, we load the countries and cities example datasets and select : countries = countries.to_crs('epsg:3395') capitals = capitals.to_crs('epsg:3395') -To illustrate the ``overlay`` function, consider the following case in which one +To illustrate the :meth:`~geopandas.GeoDataFrame.overlay` method, consider the following case in which one wishes to identify the "core" portion of each country -- defined as areas within 500km of a capital -- using a ``GeoDataFrame`` of countries and a ``GeoDataFrame`` of capitals. @@ -171,7 +178,7 @@ To select only the portion of countries within 500km of a capital, we specify th .. ipython:: python - country_cores = geopandas.overlay(countries, capitals, how='intersection') + country_cores = countries.overlay(capitals, how='intersection') @savefig country_cores.png width=5in country_cores.plot(alpha=0.5, edgecolor='k', cmap='tab10'); @@ -179,7 +186,7 @@ Changing the "how" option allows for different types of overlay operations. For .. ipython:: python - country_peripheries = geopandas.overlay(countries, capitals, how='difference') + country_peripheries = countries.overlay(capitals, how='difference') @savefig country_peripheries.png width=5in country_peripheries.plot(alpha=0.5, edgecolor='k', cmap='tab10'); @@ -194,7 +201,7 @@ Changing the "how" option allows for different types of overlay operations. For keep_geom_type keyword ---------------------- -In default settings, ``overlay`` returns only geometries of the same geometry type as df1 +In default settings, :meth:`~geopandas.GeoDataFrame.overlay` returns only geometries of the same geometry type as GeoDataFrame (left one) has, where Polygon and MultiPolygon is considered as a same type (other types likewise). You can control this behavior using ``keep_geom_type`` option, which is set to True by default. Once set to False, ``overlay`` will return all geometry types resulting from @@ -205,7 +212,7 @@ where two polygons intersects in a line or a point. More Examples ------------- -A larger set of examples of the use of ``overlay`` can be found `here `_ +A larger set of examples of the use of :meth:`~geopandas.GeoDataFrame.overlay` can be found `here `_ diff --git a/doc/source/gallery/cartopy_convert.ipynb b/doc/source/gallery/cartopy_convert.ipynb new file mode 100644 index 0000000..b4ba243 --- /dev/null +++ b/doc/source/gallery/cartopy_convert.ipynb @@ -0,0 +1,232 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "# Plotting with CartoPy and GeoPandas\n", + "\n", + "Converting between GeoPandas and CartoPy for visualizing data.\n", + "\n", + "[CartoPy](http://scitools.org.uk/cartopy/) is a Python library\n", + "that specializes in creating geospatial\n", + "visualizations. It has a slightly different way of representing\n", + "Coordinate Reference Systems (CRS) as well as constructing plots.\n", + "This example steps through a round-trip transfer of data\n", + "between GeoPandas and CartoPy.\n", + "\n", + "First we'll load in the data using GeoPandas.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "import geopandas\n", + "from cartopy import crs as ccrs\n", + "\n", + "path = geopandas.datasets.get_path('naturalearth_lowres')\n", + "df = geopandas.read_file(path)\n", + "# Add a column we'll use later\n", + "df['gdp_pp'] = df['gdp_md_est'] / df['pop_est']" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "First we'll visualize the map using GeoPandas\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "df.plot()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Plotting with CartoPy\n", + "=====================\n", + "\n", + "Cartopy also handles Shapely objects well, but it uses a different system for\n", + "CRS. To plot this data with CartoPy, we'll first need to project it into a\n", + "new CRS. We'll use a CRS defined within CartoPy and use the GeoPandas\n", + "``to_crs`` method to make the transformation.\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Define the CartoPy CRS object.\n", + "crs = ccrs.AzimuthalEquidistant()\n", + "\n", + "# This can be converted into a `proj4` string/dict compatible with GeoPandas\n", + "crs_proj4 = crs.proj4_init\n", + "df_ae = df.to_crs(crs_proj4)\n", + "\n", + "# Here's what the plot looks like in GeoPandas\n", + "df_ae.plot()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now that our data is in a CRS based off of CartoPy, we can easily\n", + "plot it.\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "fig, ax = plt.subplots(subplot_kw={'projection': crs})\n", + "ax.add_geometries(df_ae['geometry'], crs=crs)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Note that we could have easily done this with an EPSG code like so:\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "crs_epsg = ccrs.epsg('3857')\n", + "df_epsg = df.to_crs(epsg='3857')\n", + "\n", + "# Generate a figure with two axes, one for CartoPy, one for GeoPandas\n", + "fig, axs = plt.subplots(1, 2, subplot_kw={'projection': crs_epsg},\n", + " figsize=(10, 5))\n", + "# Make the CartoPy plot\n", + "axs[0].add_geometries(df_epsg['geometry'], crs=crs_epsg,\n", + " facecolor='white', edgecolor='black')\n", + "# Make the GeoPandas plot\n", + "df_epsg.plot(ax=axs[1], color='white', edgecolor='black')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "CartoPy to GeoPandas\n", + "====================\n", + "\n", + "Next we'll perform a CRS projection in CartoPy, and then convert it\n", + "back into a GeoPandas object.\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "crs_new = ccrs.AlbersEqualArea()\n", + "new_geometries = [crs_new.project_geometry(ii, src_crs=crs)\n", + " for ii in df_ae['geometry'].values]\n", + "\n", + "fig, ax = plt.subplots(subplot_kw={'projection': crs_new})\n", + "ax.add_geometries(new_geometries, crs=crs_new)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now that we've created new Shapely objects with the CartoPy CRS,\n", + "we can use this to create a GeoDataFrame.\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "df_aea = geopandas.GeoDataFrame(df['gdp_pp'], geometry=new_geometries,\n", + " crs=crs_new.proj4_init)\n", + "df_aea.plot()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can even combine these into the same figure. Here we'll plot the\n", + "shapes of the countries with CartoPy. We'll then calculate the centroid\n", + "of each with GeoPandas and plot it on top.\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "tags": [ + "nbsphinx-thumbnail" + ] + }, + "outputs": [], + "source": [ + "# Generate a CartoPy figure and add the countries to it\n", + "fig, ax = plt.subplots(subplot_kw={'projection': crs_new})\n", + "ax.add_geometries(new_geometries, crs=crs_new)\n", + "\n", + "# Calculate centroids and plot\n", + "df_aea_centroids = df_aea.geometry.centroid\n", + "# Need to provide \"zorder\" to ensure the points are plotted above the polygons\n", + "df_aea_centroids.plot(ax=ax, markersize=5, color='r', zorder=10)\n", + "\n", + "plt.show()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.1" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/doc/source/gallery/choro_legends.ipynb b/doc/source/gallery/choro_legends.ipynb new file mode 100644 index 0000000..d1c3de8 --- /dev/null +++ b/doc/source/gallery/choro_legends.ipynb @@ -0,0 +1,577 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Choro legends" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import geopandas\n", + "from geopandas import read_file" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'2.4.2'" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import mapclassify\n", + "mapclassify.__version__" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'4.4.0'" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import libpysal\n", + "libpysal.__version__" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " Name Description Installed\n", + "0 10740 Albuquerque, New Mexico, Census 2000 Tract Data. 10740 i... True\n", + "1 AirBnB Airbnb rentals, socioeconomics, and crime in Chicago False\n", + "2 Atlanta Atlanta, GA region homicide counts and rates False\n", + "3 Baltimore Baltimore house sales prices and hedonics False\n", + "4 Bostonhsg Boston housing and neighborhood data False\n", + "5 Buenosaires Electoral Data for 1999 Argentinean Elections False\n", + "6 Charleston1 2000 Census Tract Data for Charleston, SC MSA and counties False\n", + "7 Charleston2 1998 and 2001 Zip Code Business Patterns (Census Bureau... False\n", + "8 Chicago Health Chicago Health + Socio-Economics False\n", + "9 Chicago commpop Chicago Community Area Population Percent Change for 20... False\n", + "10 Chicago parcels Tax parcel polygons of Cook county False\n", + "11 Chile Labor Labor Markets in Chile (1982-2002) False\n", + "12 Chile Migration Internal Migration in Chile (1977-2002) False\n", + "13 Cincinnati 2008 Cincinnati Crime + Socio-Demographics False\n", + "14 Cleveland 2015 sales prices of homes in Cleveland, OH. False\n", + "15 Columbus Columbus neighborhood crime False\n", + "16 Elections 2012 and 2016 Presidential Elections False\n", + "17 Grid100 Grid with simulated variables False\n", + "18 Groceries 2015 Chicago supermarkets False\n", + "19 Guerry Moral statistics of France (Guerry, 1833) False\n", + "20 Health Indicators Chicago Health Indicators (2005-11) False\n", + "21 Health+ 2000 Health, Income + Diversity False\n", + "22 Hickory1 2000 Census Tract Data for Hickory, NC MSA and counties False\n", + "23 Hickory2 1998 and 2001 Zip Code Business Patterns (Census Bureau... False\n", + "24 Home Sales 2014-15 Home Sales in King County, WA False\n", + "25 Houston Houston, TX region homicide counts and rates False\n", + "26 Juvenile Cardiff juvenile delinquent residences False\n", + "27 Lansing1 2000 Census Tract Data for Lansing, MI MSA and counties False\n", + "28 Lansing2 1998 and 2001 Zip Code Business Patterns (Census Bureau... False\n", + "29 Laozone Ozone measures at monitoring stations in Los Angeles basin False\n", + "30 LasRosas Corn yield, fertilizer and field data for precision agr... False\n", + "31 Line Line Shapefile True\n", + "32 Liquor Stores 2015 Chicago Liquor Stores False\n", + "33 Malaria Malaria incidence and population (1973, 95, 93 censuses... False\n", + "34 Milwaukee1 2000 Census Tract Data for Milwaukee, WI MSA False\n", + "35 Milwaukee2 1998 and 2001 Zip Code Business Patterns (Census Bureau... False\n", + "36 NCOVR US county homicides 1960-1990 True\n", + "37 NDVI Normalized Difference Vegetation Index grid False\n", + "38 NYC Demographic and housing data for New York City subborou... False\n", + "39 NYC Earnings Block-level Earnings in NYC (2002-14) False\n", + "40 NYC Education NYC Education (2000) False\n", + "41 NYC Neighborhoods Demographics for New York City neighborhoods False\n", + "42 NYC Socio-Demographics NYC Education + Socio-Demographics False\n", + "43 Natregimes NCOVR with regimes (book/PySAL) False\n", + "44 Nepal Health, poverty and education indicators for Nepal dist... False\n", + "45 Ohiolung Ohio lung cancer data, 1968, 1978, 1988 False\n", + "46 Orlando1 2000 Census Tract Data for Orlando, FL MSA and counties False\n", + "47 Orlando2 1998 and 2001 Zip Code Business Patterns (Census Bureau... False\n", + "48 Oz9799 Monthly ozone data, 1997-99 False\n", + "49 Phoenix ACS Phoenix American Community Survey Data (2010, 5-year av... False\n", + "50 Pittsburgh Pittsburgh homicide locations False\n", + "51 Point Point Shapefile True\n", + "52 Police Police expenditures Mississippi counties False\n", + "53 Polygon Polygon Shapefile True\n", + "54 Polygon_Holes Example to test treatment of holes True\n", + "55 Rio Grande do Sul Cities of the Brazilian State of Rio Grande do Sul True\n", + "56 SIDS North Carolina county SIDS death counts False\n", + "57 SIDS2 North Carolina county SIDS death counts and rates False\n", + "58 Sacramento1 2000 Census Tract Data for Sacramento MSA True\n", + "59 Sacramento2 1998 and 2001 Zip Code Business Patterns (Census Bureau... True\n", + "60 SanFran Crime July-Dec 2012 crime incidents in San Francisco (points ... False\n", + "61 Savannah1 2000 Census Tract Data for Savannah, GA MSA and counties False\n", + "62 Savannah2 1998 and 2001 Zip Code Business Patterns (Census Bureau... False\n", + "63 Scotlip Male lip cancer in Scotland, 1975-80 False\n", + "64 Seattle1 2000 Census Tract Data for Seattle, WA MSA and counties False\n", + "65 Seattle2 1998 and 2001 Zip Code Business Patterns (Census Bureau... False\n", + "66 Snow John Snow & the 19th Century Cholera Epidemic False\n", + "67 South US Southern county homicides 1960-1990 True\n", + "68 Spirals Synthetic spiral points False\n", + "69 StLouis St Louis region county homicide counts and rates False\n", + "70 Tampa1 2000 Census Tract Data for Tampa, FL MSA and counties False\n", + "71 US SDOH 2014 US Social Determinants of Health Data False\n", + "72 arcgis arcgis testing files True\n", + "73 baltim Baltimore house sales prices and hedonics, 1978. True\n", + "74 berlin Prenzlauer Berg neighborhood AirBnB data from Berlin True\n", + "75 book Synthetic data to illustrate spatial weights True\n", + "76 burkitt Burkitt's lymphoma in the Western Nile district of Uganda True\n", + "77 calemp Employment density for California counties True\n", + "78 chicago Chicago neighborhoods True\n", + "79 clearwater mgwr testing dataset False\n", + "80 columbus Columbus neighborhood crime data 1980 True\n", + "81 desmith Small dataset to illustrate Moran's I statistic True\n", + "82 geodanet Datasets from GeoDaNet for network analysis True\n", + "83 georgia Various socio-economic variables for counties within the... True\n", + "84 juvenile Residences of juvenile offenders in Cardiff, UK True\n", + "85 mexico Decennial per capita incomes of Mexican states 1940-2000 True\n", + "86 networks Datasets used for network testing True\n", + "87 newHaven Network testing dataset False\n", + "88 nyc_bikes New York City Bike Trips False\n", + "89 sids2 North Carolina county SIDS death counts and rates True\n", + "90 snow_maps Public water pumps and Cholera deaths in London 1854 (Jo... True\n", + "91 stl Homicides and selected socio-economic characteristics fo... True\n", + "92 street_net_pts Street network points True\n", + "93 taz Traffic Analysis Zones in So. California False\n", + "94 tokyo Tokyo Mortality data True\n", + "95 us_income Per-capita income for the lower 48 US states 1929-2009 True\n", + "96 virginia Virginia counties shapefile True\n", + "97 wmat Datasets used for spatial weights testing True\n" + ] + } + ], + "source": [ + "libpysal.examples.available()" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "_ = libpysal.examples.load_example('South')\n", + "pth = libpysal.examples.get_path('south.shp')" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "df = read_file(pth)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Default legend formatting" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "tags": [ + "nbsphinx-thumbnail" + ] + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "%matplotlib inline\n", + "ax = df.plot(column='HR60', scheme='QUANTILES', k=4, \\\n", + " cmap='BuPu', legend=True,\n", + " legend_kwds={'loc': 'center left', 'bbox_to_anchor':(1,0.5)})" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[' 0.00, 3.21', ' 3.21, 6.25', ' 6.25, 9.96', ' 9.96, 92.94']" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "labels = [t.get_text() for t in ax.get_legend().get_texts()]\n", + "labels" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Quantiles \n", + "\n", + " Interval Count\n", + "----------------------\n", + "[ 0.00, 3.21] | 353\n", + "( 3.21, 6.25] | 353\n", + "( 6.25, 9.96] | 353\n", + "( 9.96, 92.94] | 353" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "q4 = mapclassify.Quantiles(df.HR60, k=4)\n", + "q4" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "False" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "labels == q4.get_legend_classes()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Note that in this case, the first interval is closed on the minimum value in the dataset. The other intervals have an open lower bound. This can be now displayed in the legend using `legend_kwds={'interval': True}`." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Overriding numerical format" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "ax = df.plot(column='HR60', scheme='QUANTILES', k=4, \\\n", + " cmap='BuPu', legend=True,\n", + " legend_kwds={'loc': 'center left', 'bbox_to_anchor':(1,0.5)},\n", + " )" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAe8AAADlCAYAAAB6ZX8fAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8QVMy6AAAACXBIWXMAAAsTAAALEwEAmpwYAAD5N0lEQVR4nOydd3wc5Z24n5nZvtKqrXqXLPfeAINtMB1TA6GEJEBIryTHJbm7tEtPLvV3CXeXI8lBIPQWencDY9y7ZcnqvW5vszPv749ZrbSSjA2BBMg8nw9YO/Wd2dn5vt8uCSEwMTExMTExee8g/70HYGJiYmJiYvLmMIW3iYmJiYnJewxTeJuYmJiYmLzHMIW3iYmJiYnJewxTeJuYmJiYmLzHMIW3iYmJiYnJewzL3/JkXq9X1NTU/C1PaWJiYvKeZ+fOnUNCiMK/9zhM3j38TYV3TU0NO3bs+Fue0sTExOQ9jyRJ7X/vMZi8uzDN5iYmJiYmJu8xTOFtYmJiYmLyHsMU3iYmJiYmJu8xTOFtYmJiYmLyHsMU3iYmJiYmJu8xTOFtYmJiYmLyHsMU3iYmJiYmJu8xTOFtYmLyrkETAlXX/97DMDF512MKbxMTk3cNEqCLv/coTEze/ZjC28TE5F2Drgti8eTfexgmJu96Tlp4S5KkSJK0W5KkJ1Kf8yVJel6SpKbUv3nv3DBNTEz+ERACdjQP/b2HYWLyrufNaN5fAg5P+Px14EUhRAPwYuqziYmJyVtmMBBDkv7eozAxefdzUsJbkqQKYD1w+4TFlwF3pP6+A7j8bR2ZiYnJPxRCCNxOK3MqTSOeicmJONmuYr8CvgpkT1hWLIToBRBC9EqSVPQ2j83ExOQfCAHYbQoOm/L3HoqJybueE2rekiRdDAwIIXa+lRNIkvRJSZJ2SJK0Y3Bw8K0cwsTE5B8AXRhh5qbV3MTkxJyM2fx04FJJktqAe4F1kiTdBfRLklQKkPp3YLqdhRC/E0IsF0IsLyw0e8mbmJhMz1iKmJkpZmJyYk4ovIUQ/yKEqBBC1ADXAi8JIT4M/AW4IbXZDcBj79goTUxM3tfoQvBeL82i64K9rSO8crifI10+hDCnISbvHCfr856OHwP3S5J0M9ABfPDtGZKJick/GjFVo98XTWvdDkWmOM817bYCgYQECNKh6WJ8nbFYmrjYWCNSu8jGOmnSMXtHIggBspRZKMblsJDntk84r8GAL0o8qRn7CwhEEjT2BAAozXelx2Bi8k7wpoS3EGIDsCH19zBw9ts/JBMTk38kdF1nX9sIHYPh9LLyAhf5uc432EsY4nuSdpsS6YY0HdtSF3QfHsA/EObVBw+w9KJZLLqgAVmSkFOCvHc4zPamISyKhN2iEJ5QKGbt/BLU9PHGj+t2Wdm8sz/92ZttB2BuZS51xRNje01M3n7MCmsmJiZ/N4QQqAIW1ORTlONIL186w5v+e6L+eiJddky0SkA8oRGOqXQ3DfGXX77Cy3fupuacevoLnTyzo5PWPkNLTmo6u44Np/4WWBQJy4Q3o8dlm/ZcNqvCmnnF5GfZMwZnVczXqsk7j/mUmZiY/F3QhUDVBQJQFJlTZhextK6AXJeNzoEQ4aiKECIjgO2NvMgS48I9Ek/yyqE+XtzTw4FAjIYLGpBksFR6SOoCfYLFfTQQR5tgJ/dHVHJTArkg2542s088zxhFOU7mVeVmLLdazNeqyTvPX+PzNjExMTlphBAkhUDGMHonJ5m8ZUmioigLj9vGhv29AFQVullSP66FH094SxPWCSHY0zJMKGaYvhOajsNhIacwi3gwAU4LcypyqCvJQcKo6jZlrLrAbpHxuKwADHf6CQ6FKa4vwOWxo0ggIaGpOqMto2T1hlAjKrisNPcGqCxwYbWY+eom7xzmFNHExOQdRwhD29UEqAKSQmRoyjAufNv6g+llwYiKwNDS2/qDJLWpMenShH91XbCzaYhBf6ZAVntD+PpDtN9/gJyRGA3lOSDBS79/jmf+7Q/EmzoAqC/JZv2KSvKyHcSTOm0DIY50+Gjb08sT/28roz0BJAmssowaUbnz357jqV+/SvPLLYS7g3g9dlRNZ1vTUDpv3cTkncDUvE1MTN5RRMo8PlnsThRtEzVnb46DtoEQAJFEki0H+oglkkQSGm67Be+EQDZp0rEkBMV5TkYCMWJJPX3+/oNGGYqCWV5G9/XxajDO0otnct+//5mRnhFeu3cjP9//Gypr8gGYW51HocfB1sYBmnr8nLmujpmnVuDJd2FJ2dtfuGMX0XiS2Z9bSVTT8bhtDAXiAIRjSWIJDZfdfMWavDOYT5aJyT8IIpVLLQTICEaCcXKy7O94gJWm6SQF6cjuyQJ37G9d1znc4aPfF8WbbaRmFXqcHOn2p7dzThCG0+m1kixTWZhFZWEWyaROXNXY/vIx9NIsIv4YcX8M31CErsYheho7GekZAaCkvpSCsoKMYxXmOVlUm48sSWS7beC2ISaMX9d0Zl+zgJGkjk2Rpvi6Tc3b5J3ENJubmPwDoeqG33l78xB720fZdWyIyDvUPzsQSQBwpDvAi3u6ae0NpAPQJgrB9L+SxLG+IKFYkqFgHJfdyszKXC5YVkF+tg2bRcbttE6JOJ98nDEsqe2XLC3nsltXU3VaBeUrysmty8NbkcVTv7knvW3fsV5umfMZRnuG08uSms6x3gBtA0EiMTXj2KOhOGfctJSR1BTC47KlfexjNPcG3tT9MjF5M5jC28TkHxBFlglEErQPhjna4z/xDm+Sph4/z+zupqUvgI4gmtDY3z5KPDEu4CZnTkuSxOlzitPri/MM87jNqrB8RiHnLCnP3J5JgWqTxjAmzHNKspFkCeuSMgL5TjyzvYz0hjntg1dz+T9/klVXnwvArQ98nbyU9u3rGeH7536DwFCQ0VCCgx2j6ePGVI2W/iC6DvOqcqkvyWYoGCepjY9ATmq0b2oj7J8aDGdi8nZgms1NTP6BsEiQTKVJjWm/o6EEalJ726KjdSFo7jWCznp9UbqHI+l1dtvxXzkSUJDjYNWcInY2DVGa70ovdxzHdzxRkAsgGk/itFsyhDpA93AYVdPJtSl0vd6NrgniERXFaseVU8XH//OfmXn63PT2Sm4WxbMqUPuGsM+oTNd8USRICFhQnY9VkfBk2RBC0DkUJq5q2CIqcjRJ6xONqLEk2nCUK758ulltzeRtx9S8TUzehwghiIUTaEmdZEJjoNOHKoQhuIFZFbmU5DmxKBKDgRivpgKzDnf5GOw6sSYeV7Xj1u5u7Q8STJmZu4cj6XSrNyIzYM3wNR/vuqY7r8AoyvLS3h4Oto2gpbYRQjAwGuFg+yhFOQ4iuqDk4lnp/SL+ONn5Tpp3DrLtoYPpY2c5rZz2pQ9gn1FpHGc0wFDnIIok4bZbkGUj1U1A2u0ggNZ79nP0wYOoKRN6y55ebr/1aYZO4p6amLwZTOFtYvI+RBUC3SLz+G+3cvd3X+Thn2/hWJePfS3DCAx/cI7Lhpoy9fojKrtbRzi6v5+7v/Mirfv6UlHiOtoEgSmEoHskzBM7OglG1WnPPVaRzCJDXUkWcytzcdpkbBY5QwOdLk1s7BxHuvxs2NdrFGqZsO7o1g5ef/gQo13+KWbyrqEQmi441hfk9SMDJJIa+1pHeK1xkKQmGPDHSCR1gokkM86oxua0pAeia4LtTxzhgX9/iaEOH4EBP30DAdTeQUQ0TuPmA/zbqn/m4Mb9CCGQJbBIRqXz0GgUbVcv9s7A+DEn4B8ME5hgfTAxeTswzeYmJu9DZCRki8zqDy1iqMvPgCKzv9OP3SpTE87G47aRl2VHkcFpsyBL0L9lD/aYlWRC46Gfb2blJbNZecW8tBYrS0Zzj0MdPjRd0OeLTikdGk0kGQ0Z6VIXLK9CliU0XVCU42Q0nMAXiqerl00MWptYYGVvyzCB1MSgqcfP4glFWg5taqO7cYjapaUZ5w3HVA51+NKfB/wxdhwdZDiVujXw9FY88+uwlXhJvtpJ86FBymYU0NM8zHB3kLKGPMK+GAPtPvzdPn59ww/xDfiJhaI4s51c+OOPM9o7wkDbANKZEghB864ebE4L+ze20rq1E4Ds/OnrsZu+b5O3G1N4m5i8zzAKohhFUNz5Ltz5LgqiKr17e4irOq8e7ueUmYV0DYUAiVAsSbKxlce//nsWnbuUqoWnMfu0SuadWZtxXF1AIJzAHzaiyPe0jtAxEOKshaUosmHE6xuNsqd1hEKPfbzhlxB0D0dI6oJXDvXjslsoyLYzrzoPJZWmNmY27xoKZzQo6R2NslDXEZrg9UcP0X10iIJKD0W1+Rmm9tbe4BRNXNMMs3ais48Xfno/To+Tsz52DaM9xvh9AyHsLgtqLM7L/3cv/n4/l936UR74wR30tfSlj1NcV4nabKSUNW1v4uwbz8E3EGbTffsY7Qult5t77QKG9vcRHIlO+U4iqUmEicnbhSm8TUzeRyR1I6caMs3SWU4rS+oL2H1sGAnY3TKM3aKka3qXLJ/NnwIPoCVUXLlZ6f0kIDAcwJ2XhSLLeNw2LlxRSVNPgIHRCKfPK0EVRs7z0W4/HUOG4B0MGNHXCTXJkS4fydR5NF0QjKoU5zrTgnsiWY5M/3iepnPvN18gNBolETX8yLULSoBMzX1eTR42q8yRLj+OgTBRr4vRcAKPy8qRzXtR4yrqoMqmOx5kwXkXg5CJBOKUz/Ti6+ukPyWs/X3tOLOdLL1gGe4cF5vv28zi89cx0hvl+h98jk13/YWtj7xKcV0tvoHxSUZ2WRahHDtZa2rIObMWCYgc6WDDD++mrKGc/NJlb/7LNDF5A04ovCVJcgCbAHtq+weFEN+WJGkx8N+AA0gCnxVCvP4OjtXExOQNEELw/O93UlSbR+UCL/uf3822R14lrySfsrlVeNYsxZttJxxPEool0WyGQLWFEiSPjWKbW4zksqOpSWSLgiRJ6ELwvfO+yalXnMaV37gWMJqIzK7MZXZlbvrcGlBdnE1C0xFCYFVk1KRGa3+AAd9UTXTMtD6mPY9pzblZtvQkw9EbYs8zTSQTWnq/wuocVl4xb/yaU/9KksTMilwqC7N47Ug/sWgSoeu0/eVVNv3vM9QuqqV1byujfaMU1+ShazDY6UfXBVaHl7UfuYS9z71CYU0xn7ztc0bTlGgci81CcU0hI70ddB4JceHnr0dWZOoWlXL5l1bx+G+2olgVFl+7kPZwgqQu0hOVaCRKz9EuVl97BpVzyt6Or9jEJM3JaN5xYJ0QIiRJkhXYIknS08B3gX8XQjwtSdJFwE+BM9+5oZqYmByPrY8e4vDWDkZ6gxzc3IakD7Lx7qfS61d/4kKqFxupUA6bkRIWTWgkXmqlo8koTOJw25h1egU/ueQ7DHUO8YNXf8ax7Udp29vKSPcwF//TFdid9rTADAyGObSxFUmCU66cj8UiM6PMQ+9IhNFwgteODBCKJfF67ETiWkYxmKSm0z0YIs/jwKJI2FJpapIkUVmYRXGuk41/2p0huAHWXLcYxSJPSREbw2m3cNbCco52+RgYDqFVFVEyv4bgoJ+LvvAhbM5s+luNyO/ckiyGu/wkYkkkOZ+zP341aiLIsT0tVC+qpXEgwuf+cAsxX5xoME7YH+PIa704z52BEIL6JWXc8MPzcbisdHYP8eittzPU2k/prHK6D3Uy2jtCTmEOVfOqcbgcmJi8nZxQeAsjzHTMsWNN/Tc2WfaklucAPe/EAE1MTMbRdEHPSJiiHCd2qyHwQr4orz5ykIkZVN65lRRUFzPc3g+AqygPWYL8LEP42hQJi6KgraujLyW897/UQtvuNsK+OL5+H99a+zVsDiO4LDAU4Klf/4XLv/5BANSYyj3ffB41rrF8/Xjq1ZgPHSAUS1KQbccXTpDUBN5sO0PBOLJkTBx2HhtGkgxT+aq5xenrkTAKs3hyMgXe2g8vpnSW97iCO/1Zghy3jSPdGpaZ1Zz5n18iW4Zo8yidG49gtSZxeHKJhRIkUmPVdcGRTa9ycPM+Xnv4VT7x288w4MrmmV1hSvOcnPqxZRTlODjwcgsv372HVZfPxZltJ6/YcDH07mri8Mv70XUdb4WXwfYBrHYr33/pB4RGQ5iYvN2clM9bkiQF2AnMAH4rhNgmSdItwLOSJP0MI+Vs1Ts2ShMTE4QQtPQH2NMywqmzCqn0GoIjGkpgscaJBgbRVBUkgXP5JVx05jewR2M0P7AFbdDJ6COHkS+ciWZXkCXQRBKrIlE4x0njc69htVuJFs1l0QUXErz7Xoa7hrnwc+spbSglHoqhJce14K5DA6hx4/Oe55uZe2YtHq8bq0WmujCL9sEQFhkCETVdeWwoGCfPbUMXAn9ETV0TBKMqLT0B5lTlgiSlBfLS9bMJDEXQdUH5TC8Np1Rm3I8hfxSbVSE7FfE+tp+mJukZGU/N8jitBKIqoeEeXvz9nwGQFZnaRfXULFlBIq4Q6D/Mwc37AGjb20rFnErqspwcaB/BH0nQOhDCbpW55NwZ5BS6SaqZbVbWfuhMXn3oVQ5s3I8aMwLirvz6VeSV5OGtLPwrvnUTk+k5KeEthNCAxZIk5QKPSJI0H/gk8GUhxEOSJF0N/B44Z/K+kiR9MrUtVVVVb9e4TUzeN4QDMVzZ9mmrcGmpqHE5ta6iMIsBf4ytjYMc6vRTmudgoGuEF39/b3qftZ+9BGdeFglVw5abhcteSmg0SjKpU5bUseQ5sCgyw8E4qibYdtdTdB0yWmKe/bEZRPzwr098n7pllUiKTP+xXr44+9Mc3HyQbQ+/SmF1MR/9j08xb20NBze2ocaTvHT7q1z+9XNJxJJEewMU5DlJJDV0HdSxNp6ajtrmw5JlQziUjOtt6g1QlOukYIK2bXVYOPdTK6e9Z2pS52CHj0AkwZzKXGpLPel7dN+37kaqKsW9xLAIqJqOJZ5E6tewuxzEIzF0TefYriaCI0FWX3cJrz98IOP4t3/+v/ncHV+mLN/N1oEBCj12grt6efL1Hhatq5+SEjbcM4zVbmXlJavILqxm3llns/qaJUQjOsVV7pN5DExM3hTS8aokHXcHSfo2EAa+CeQKIYRk/Ar9QgjPG+27fPlysWPHjrc8WBOT9wuHd3YjqTpqPEk8onLolXYS8STrPrGc2gYvuoBdLUPMKM3B5bBgkSR0BGPls4/1+jnY7gPAaVOIt/dy5we/h7e+lMvu+jfiqQ2Lc53kjMRIWGXaNY0Cjx2EYCiYINtpRVOTDG0/zLb/fYrufa186uWfY5Es5BVlMbe+AIsi87+f/S3P/+5ZAArKCsjKz+LHr/8SxWYhNBzhsf94jJf+8ARfue/rHHlliIF2H3UfnE/cY2jEeW4bo+EE9mCcpj/vB6D+zFqUIhdJt41kyge/cqaXkvypgm6ieXzs74NtIxzrG+/7nZ9tZ+DRjYDgoR8+QOmsClb/9stIkoTQBYmXW+lvHsHusuLOTvL4r/6EltQ464ZL0fQ88kqcHN60haPbDnDBt65n/6OvcuWtV3DGh85kNBhjb8sIoWCM7rv2o8aTLFpXz7k3Ls0Yp64L/vTN5xns9LNy/SzmnFaFtzLnbSmNKknSTiHE8r/6QCbvG04m2rwQUIUQPkmSnBja9U8wfNxrgQ3AOqDpHRynicn7huFgnHiunT337cffOkpWnjOdL9zUF6Q5kqC2OJvW/hDheJKVs4qATP9ufWkOyaTOcCDOUDAOpUV8/PHvQkEesZTgXlybT1VxNgAjgRhth/oZDsRZUJNHKJ7EpsiMxgSuJbM567bZNP/mQZoe2UTZ1efgH4mQl+ukqiiLG/7jZoQuaHzlMGF/mK4jXfgGfBRUeMkqcLH9L5sIjgS56+t3ULlgJbqmgD8GKeHtjyTItYAvEsadA2E/HNvQCoDH6yJ/RgHOleUc7Q5Q4HFOaa0pgKGOQdx5bmKBJA6PPd2xDMAiS2iBGLue3sfR14zJQce+VkI7D5O9fC6uriCdqTxtu9OKbyjJJV++mUf/43d4isoY7Ysy2hdl7trTmX/lKlyrFnDeitnc9alfkoyrVMyr5oyl9by2oYVYeTZqQsOdY5/yvfa3jZKIJ8ktzuK0K+Zhtb09teJNTKbjZMzmpcAdKb+3DNwvhHhCkiQf8GtJkixAjJRp3MTE5PiMBONsOtiHqum4z6xhtG00Lbhr1tYQtyvEwgl2txhBZP5Qgq7BEJXeLCR5XINLajptAyHiE32vRQXYrQqxiEpJriMtuMGov+2yKdhtCl6Pg6qibEaCMV49PJDeJhaM8tq9G8m9fxNn3LAe+yfPQwCyVeH6H9/IU796jAe+fx8Am/+0hbzyagJDYZZeuJq4ugHF46T27DqOPddOoGkYR1kWQpHREir3f+wnDLT2IysyZ95wDUnVEOyBoQjO0mycusAXTjDkj1JaMK59j2najiwHoz0hHv/VVqxuK96rjHQxm0XGNRJj3z37qFt2KtFghM6DxwCw+4NcvLIKaYVg6amVbHt0H41btmPLqmKkP8Zlt34al8dNbkkOvr4QI70hvDleXFaFaH4u6/7tem7/0u9IxlXuCjzAGWvq+P1jR7C7bVTNG+9+NsaWBw/gHwhz1VfXmILb5B3nZKLN9wFLplm+BTArD5iYvAkOdo6mfcCKJHP1N9dhkSVkWSLL62YkGGfXsSGiCQ2X3YLLrrCnZYTOwTCnzytJH6dzMFNwKzLYrQqJpI4MjIQS7GsZJjfLEJJdQ2EiCY1IQuPVlw+w7ryFeHOclOU76RmJIoSg51A7AN7KMoJ9Fh76/ss0LCvg6LZdbPrzBopqiphz+hx6jvbQtP0YzqNGwFrtWbO58IOnI0sgJIl5H8rh4J/34U1oRHxRooEOBlqNqHdd02nfs4OyuachSRI1a2thTgFhVcPjtKY7iY0RGo4Q8kU5tqOb3c81I3SBpunkIOFH4NIEhx85CEAkkGDO6rPoa+7k83/8EqdedUZqwiNRUJWL1RZi68MbWXnJ6cTCUYRahH/Iy9XfPI/8yhyG2ka5/3svM3JshDmXzUUsaOCjL/yMRz/yQzbe8SJnf+J8rvr6Wg5uaiOvKCtjnIe3dtB+oJ/S+nxK66ZvqmJi8nbypn3efw2mz9vkH51+X5S9bcOEohrnLi1Lt+EUQtC8rZOGU6tACPzhBK8c7k9HatcUZ7GwJh9SzTCEEMQSGq8c7iccS1KQZWc4FCfbacVlV+j3ZdbSXlJfQCKR5O6P/5IDz+9m3tr53HLPV8n2etjVPETzU9s48pdXiQWjzFmzmsCIwGrViIx28dojGzOOVbu4lrAvxuzV5wEw85JZxMqyM7bxJDQinX4CR4Z4/dG/EBwOEvYFSSaMKPM111/E/M9ciHBYUHWdWELn3CXlOCe0/gwMhrnvOy8Sj6g4smzEwom070C2ysy/fhGtTzeRCMaIR8ZzyK2WYc791FnULW9IL4sEIvzTgs8Rj8YJjYynbpXPruC7L/+E5u09HNvZzaVfOYPdzzax44kj5JZkkz+zAOwaT3zjdk696gMsPLueuWtryXJa075s34CP/73lDnKKq7jsS2dSXJP3pp+LE2H6vE0mY5ZHNTH5GyCEEWyW77GzZkEZqmr0zxZC0Lqzh30vNtPVOET9igpkRWY0lEgLboCEqjFWLNzIZZZw2C0sb/DS3h8irmpYZBmrIqFpOl6PHU0TaKmKXxVeNxJwZIPhEz648QD3fvMuPv0/n2f5zCKkI0U8vMnQYLMLPPQ09TDYPsC81ePVzFw5WXgr8mnd00rF7AqstiiJuAN/qw/7JOGdzLLhnldE17YuZpy6DrvDgmKVsdqSdBw4TOGptQQAYklsFpmG0mycdovhDugPkq/IbL5jN/FUSpm33ENX4xAAJfX5WCwyB+/ei6bqyIrEzHV1HH25BYvsZ9Ofn+W1h1/mG898l/oVhgC//1t3Mdw9zKqrziKroBBXTh6HN7/Kt1/4Nha7jUXnN+ApcGFz2yipd5GMdePrK8XX58dqTzBjuZG2tuW+/YwUuVhYk095yrw/0NbP5nue5xuPf5/Cqty398ExMTkOpvA2MXmHeWl/D3arwrKG8Xxfi0VmoNPH5jt203tsJL18185u4m4rsiQhS0YzEICRw0Ns2tbN4gtn4vGO+4Rz3XZy6saDp7Yc6EUXMBqMpwPcFtflp7XE2/v+xDfXfJ1EUmPtDWent5l31oL0MQ5s2E/5rEryy7wIAWs/fDGK1YLNVYgjS6Hj4H/TdaSLnqMPctaNH6RoVSUTu1XnuqyE40kiCUHV6dU0P9NENDQeYOatmYt7QQNjRv9EUscXTrCneYihQIxIQsM9GiMqBFWrKslZWIKQJfQsG+F2H30T7hcYueKJQIzi2jwiPt2oYx5X+c7Z/8oNP/sYVQtqePq3TzJ3zSIsripiEYhFYlz3vZux2A23gqzI1J9SiQT85T8e4pX7NyErMksvXMmOJ17jC3/8MjZXIdufaGSuy0HPSCQtvF//y+tc9pXLWXr+fGT5r48sNzE5GUzhbWLyDhJTNYZSHaW8niDVxdmEoir7WodJDEYyBHfJohJ6dR0RHNvezshIhOBzLXR0GuKxqCYPz2pDaEyuMIYQBCIJkjoUeuwMB+LMrsqluigrvZ0rx80VP7iBYHERAw4rtaqG3aqw68lmLvnyDex88mVWXHouowNJLBaZ/FIrA60dJBM6yWQCi208v7mwuhDFFcc/1iJE03H0hAiWutFS7gCtNpdZl82m8S9HQIDDbSW3JBvbaJychgLKvS4C4QTtAyEGU/fJbbdgq/DgynNQ6LEzGIjjsigUn1XL6Otd+De1Z9zjshkFtO0wCjw63HY83lwCQz4q51Ry++f/B13XqV1cR25RFmuvX8zuZ44SGIrw0p270TUdi11n9hkzGe70EbMpLPriVcy6+WJCnQO88O07kBWZotoiZp8+F5vDQjKmsnzxeEvSAxv3c+NPb8JiNV+nJn87zKfNxORtQheCmKrRORiirsSDVZFxWBXqS7I51hekezhMWYGLHUcHCURVbC4r3tleho4Y5uC+/X3MWV1FOBWINhSIw64+hjv9CCGw2WPseuYgM1dVIivKlBaYMVUn5REnGE1yzpJyHHaLMa5wHGeWnY6BIKOFhQjNiO5+5WAfxSGVXc8amZ5nXPcB+lpGAUiqOiN9ITb9+RlcOS5WXrqO0KiX9V+8nrY9e2nceoQXbvsLC5s6WPuZazj4VBOJqMrMi2aiVRolHzRVQ9cE3nIPDreNoe4AfcdGWHzuDGbMTqXAFQgSqkY4rqVcBYLRVNvRwUAcSYJkUkcDEkMRiqpyGUj17lYsMqP94/nesbDK6ddejc2hIckKzTubAWjd08Kc1fNYcHY9C86uR42qHN7czEt/fIbtj2+ifmk9Hq+HsnNX4FrYgI7EkYc2UbOohjXXrqZzfxuHNx3kkluvwOnI7GFet6Se4toSTEz+lpjC28TkbUAIQUIXyIpM51CYxu4AFV438ypz0jW7C7LtWC0Kp80p5tldXSQ0HUuZzNDTu3Dn5TDU0Yv7SY2C805JHzc8bJT5VCw6L//fg8iyzOGNG7n629cx8/S5OFzjjUKO9fjJdlkpyHYwuyo3bSpveq2TnU82MvuS2XSKzLKeoViS8J7e9OfAUISCcg/D3QHjujSj7WXEH2HX05tYfuklDLS2c3CTUZHs9GvW8MU/fYXuw4Psjhr+6Y6NbZRcMx/bcIREh5+m3b1MpnhCRLYuwB9R0yVTi3IcgIoQgnhjO5Zogo6dQZy5DiLDUSQZCqtyGOzwUzGviOylpYzu76dndy9CE2QXuFITkCQXfuGT+HqaGWzrIDQUIDQaIisvC8ki8bOrv0MsZHQ8O7T5IMV1Jcz4pw+R7Bum/aGX2fOk0SRxxxPbWf7B1Zxy7iIe/tEDrL/lCuxWC+5sw11x2VcuJ7c49+QfFhOTtwFTeL8FQqNR1ISGJEvIkmT8Kxv/pv+2yFitU4tNTIcQ4sRVmKbZZmy/N8wXECId6DTt5xMtP8l1SVUnOBhGFwJ0geKyIjstCGGMc+w+SRido7Iclrel8tS7hQmxZVQWZrG3dYTm3gD9viir5hRTV+phNGhEgNttCnOrcjnU4WNo11EObdmf3rdk2QzqXFZkWWI0lCDv4lmUqRqdz+1A13R0TafxtSN878Jvs/6Ll3DDLz6R3tftsHCsL5jRJ9vfF2TjXXuIR1SOvXQMx1m1TBTfQgh8qUptQgjikTA9h3fgKfIiWUuQlXH/utVuRZZCjPQMULOwBovdykd+fAOSLFM+p4jZq6po3tFFflk26mtd9LSOkIgmKWsooKdpGMWhULWykvM+tAjbhKhyRZYo97rxp7TpRDhG5MAxul7axev3b2LemkUUVC8mMmwIWqGDq9zDzAXFJMqzCUgSluVlZA10MLCvnVhwBrKso+syYV8chzuL5p3NNO9spnVvC+u/dCkLzlmCrGQ+f3pSp+ue59jyu6dJqkkKqwoZ7h7mrK98gLoPrKWyPA+e385ffraRJefMYtG6egCKa6bmfJuYvNOYwvst8PKf99K4rfMNtznl8jmsuGzuyR/0BCl7Y+lBf+1+xzvOcY9/kusCQ2Hu/Jdn08tnfmAuscLxnN2x5hBjXLWqhveP6AYZQXO3H4tiCN2CbDuSBBISFouMLEt4c5wIoKexixd+9gjHdjUz2NafcZyShXX4IyrZDuOnmdB0ErJE8YXL4Pt3prfLysvi4i9dlrHvWNrZgC/KrueasVtlOg4MEI+oOPOdFJ5dR0yRsCoykXiSWHsfXU9uRVIhEU2gxiPse2EPum6I94IKL3NOX4jdbWfGsgY6D3Xw2iMvEh4NI4Tgh6/8B/mVhfj7gniKszjnEysoqctnw117xu+LVaZodTUFZ9eRUCSiSZ0DnaMsrvdmTN5mlOUQiSWJhOM8dONPaN9rVGCTFZmSGQ2o44+Ocf31+QTd1vRnIaDxxZ00v3YE2ILH62HxRZeBkAmNDqe36zzUyX3f/jP//anfAjB71RyaXj9K9fxqAsMBNvz28fHvYvEMrvjzN7C47AQiKvvbR6iZW8Oy8wvoafJxdHsXSVWjbEYBuZPyvk1M3mlM4f0OYXNaT7zR28CUoKW/E5FAZl6xcGRWmLIomVaI9xv9/hiHOn2A0S87NqEPta4LFNmwkPz2xl+y8a6X0+sKyguI+Cd0wKoqQoMpVgn14DBrP3IxhzftpKAqn28++10stvFnLJHUCEdV8hwWhl5qZet+Y1JQu7CEitleXKur8euGVSSu6sR2H+GhL96GYlWwu+yEfWFqFtUiKRLoYHPa8FYUsOW+l8gvy0+byQG+8fR3qF5YR05RDqO9AV5/+BB9raNk5TrSAXiFcwspWVNDQpFIWIzJgp40ntTOoQhVhfGMJiQSsLCuAIDIZy7ivz/9W6rm17PysvOxOZ0MdvtQo3Gj9Kqko0oaRnfi1D3WdLr2t6U/B4YCaLFebO4Shjp7mXvGXHz9PnqaenBkjZ/3yKuHuezWm1BjcXY/s9n4TqqLufQ/P4ean0cEyNIFIqnRcvtf2Ns5wKzTzyQ7P4uWvYY7YOGZtZz3MTMF2+Rviym83yHsfyPhnYrzTf/9dnOykwOhT9pKTNarM9e/n7RugOYXd/H6r/6CpzgPV0E2VTesT69T5PHrPeO6NRnCe7I7wpafQ3TSsa2xJMe2tAMFzF5zHp/8r0vTglsCBvxRdjcPE1M1oz92fT6khHfYF2Ogw8eMyhyoM4qHJPuH2fizBxBCYLFZ0q0+2/a2Mm/NfI6+fhSH20Hja42pIRpjzMrL4sM/vpGF5xoNOYbafTzwg5fRUgF2weEIeRUeSk+vRvM68Sd1SApIGnnnY1H3LptC11AIfyTBgC/K/Jp8sib8Xs762Lm8ct+rlM9dzkBHGEGIY9teoudoFyV1pagJlfLr5jFxeqgPjhILZ04g45EIweFDtO5pSS9zZjvxVnrpbR73w0uyhZBfJxqJcfkvPkXeqQtQU89zjsuKzxdh34/vYv9zu6hZNJPBziCDneNBcu0Hx0vMmpj8rTCF93uENxKgkzsuvR2MHetkj6dPFt6T9kx2BrCPxkAxfN9CF4aW9z7h0MYDHH3lEAB5ZfkZwluW5fTdWHTeUk657BSCI0F6GnvIK8lDVizYHA4UqwJxHVtcxWJXcDssSIASVSmeX4ysSOiaIKYJtHgSh00BSaKjP0RMNQSwEKCWZuHIdZCMqgz3GIFnetSoQCZ0nR3/cS+D7YbAiYVizFw5k6OvHwWgfX8bVfOqOJaK0l54ziLOuHYtSy5YRk5xbnqy0fx6Jy/fsTstuMfwzisilGuHZOby0VACl81oAxqOJ2kfDGM0J4TXXmtmUV0BhdVFCCHw94dZdP45dIwJRWGM2+VxISsSilVByc7sPhZp65nyncTCIfpb+zKWRYNR4uF4xjItqSDJ8KE//xsBi5IW3ACKrvPa1/+bY6n7462c6t/2eF2EAzHcHseUdSYm7xSm8H6P0NLrJ6HqgAQSzCzzpAOTxl41JytojycyJy9/M5OBwqpcPvqT8wEJSQLFbWVP64jR8QoY3tdP75HB9Pb6lfOR38O9G+LROIlogsd++Sj5ZQW89shW6pbU4cx2Mdg5ePwdJQnFauHQZkPQ+wZ8XP7VTzHSa2iNjXcZwWsN1y1Mt9TEacW+qpKCbDvDwTgb9vciAxefWg3AsgYvS4Xgpb29hiVGgrqPLEJLavTcdxBJkoj0BHGrGrFwBJtFZu4ZRjyGJEt4ygr48C1XITQNoSbRNJ3FsQTeGeUUzyhDC0V48Hv3kpWfhdPjwuK0MdQdpm79ImSrBUkXiFRxEqvbhjffRSKpIxBUet0U57nob/dxZFc3ulXBKusEhoeQLDKSYiEuSYzUFOKKqoSGwjzxq1dJhOLpB1CSJEobquht7iESiLD0ilXp21mQbWM4mMDX1DXlVg+29TPYNlUrttit2F12ZIuFVVedSzSoYrVZOHr3fhpuXkpMCCQkBIKRIx30HunCneNGkiRKZlSgJlJFcSSw2i3MWFZ+so+Nicnbhim83wJzTq+itKHAEGxCGMFcIiXoBEZea1VuhjCcaN5+s8sAuocjjE6oUlVTnIVjGj9y50AIh02hMNcopqHrAk2IdNS3IksZ0chjHE9Qn6xJ3u62YXOP57++/vBBhrv86Xi6ZDQz4qh7MIRsG3v8RHo7SZLIz7bhsGU+mnFVYzjtV5dQJCjKc6bymkEgpv17Mt2NneiebCwOW+a1CcFE44FI/w/KC1xTfPbDXUO8/sR2giMhZp42h0/9z+cRuo7QBVa7lcKZRjU1IcSUkRTXZeYEJ+MRjIZ940h6pubqsMkMB8c1RoumE/bHcOc4QJLQBSyfWchwIMrR7gBZDiuaRabm6vm03L+fwFCYvpYRnNl2Ciqr2XzP0+ljfeS+byDKi5Ewem/7wgmsGHpxSyqHejSq8uyPHuD0T62n4YYLydVFSm8mwyQOwIjhwy/Ld1JRmIUkSXTt7KHxmaaxi2P/c08w2mfkk8+7aAX2unIa+40jFn5wHo6uAEefPJo+5KzTV+EpmYPQjd9bx+92UL+2luFZhp+88vrzWacVoSU0kKD2nHpEXQGSJHHoV/ex76ntSLJENBDl0OaDeLy5rP/STYQDCaKBeLoM68HfGulh5TML6D46jBrpIBIYj0korMzlvM+djwBe2NONzSKTXerBn9SY2oncxOSdwxTeb4GKBSVUvMH66UzO0wnH4wnM6ZZl2S0ZwnuKlTpF13CYQX8Mr8fOjFIPx3qDDE4IJptTkUNDRe4bjH76sRxvrCPBOC19AbweB9UTWlB2HOxPF/sAKCj3ZOx3qNNHcJJpdYxzl5SjTLpAXyTB1sZxjbYg205+rnPSqI739zgb79nEaEJQcskZU9a5bBYiieSU5XOiOcyvyssIIiuqKebR/3iYj/7sYyw8f2nG9pPv1eSRzDtrAY/89KH058DQCMje9OfZl8/BWpaNSGjEwjEUXcPqyCY2Mcmr3c+DjxyhfFYBa65fgt1lJcdtI8dto6oom6e2j2dD1K+fxb4/7QUgGoyTX16dXicrMpbKkrSpOBJTKfQ4SGp6ulBKca6TOZ9fT25JHqWXryWZ2lYIgdsfpyzHybKlFehCcLTbRzimEUskyXLY0ves++jQhBsis/iCtWTP9eIqyCEZyfRVA4hJ5niEhD7peZEntt2UJJJxAcggwGK3ExOAEDRtPkAsFKOkvoRowIgoKJlRSfdRI7jO43Vhc1oJDo8LaS11rmhg3LcNcOTVJoKjNtZ+ZAnrFpXxzM4uonGNQo8DPZUSaWLyt+CEwluSJAewCbCntn9QCPHt1LovAJ8HksCTQoivvoNj/cdmUs3kN0rdAqM611DgDcy3J8FEISSYXoDHEkm6hyNkOSYF6E15iWXuKSe0KdeU3nLaVLa//qX46n2b2PXUDo7tbOYTF51CVBkfsySBxSJBYup+R3sCzK/K7BT14I8fIDgSZMkFmV1xT8bVsODsxSw6dxHJuMZIzzAHXt7KJ37zRbzVpQhFIp7joKnXj9AF2/71dwQGfCy6ei1lF67C6o9DLEnSHye/NJt1Ny5Dtmb6HyQBclJHt6TcKpbx9TlFbmSLjKcwl8CgzygPimDMLpLltDIYiGGzyKxsKKQoz5mq112Es7KYcCxJY6cPe7ufrtc66QzEKb9pKfY5RrW0Sm8WWw4ZwXJWi4S/P8SRLe0komq6+EvZsjI8p64kkhKQVsnQ+EcmTk7V8Wj94zKhjoI8eTY74dmSZGO7rLzxdK6CinHfdWAoQllDAbIi4R8IY7ErDKbK0XpK5nHtd0+j6+BeFpy7hOTcGQS3dfPQjzZwxa2rWb+ikkMdowghiMSSGYF3JibvJCejeceBdUKIkCRJVmCLJElPA07gMmChECIuSVLROznQ9yNvJrhssvA6Xnr32zXxlyb8O9mnPt0yZVLwWWKSmVxMij7XggnIsWORZfKzbSRTZuL6Eo8RiDXpPCe6rslCc/Lmz/z2CZ7+zRP0NPVw3ifPZ35NPvv7w8QSxnlnlnloKM9NTxyEMHpm728fZW5lbobWfeiVQ4z2jrLgguVoNhvReBIlVZwHYTQdecNxyTIf+cnHCI0E8fWNcufX/sjMVfVke3OMe6PpNHb7iR5spXmbEfG98f89ypX5pbQd9KW/e4tVRtMFMoZ7ZO+zTeSWZtF5YIBEbxDXkhISWTZ0lyFQcovc+AYM0/Tq66+hY+9OsmryEYqM121NhVMY15lI6hMEt0FFYRZCCA7du4+mQ+MTQ6tj/DWS5bRit8jEkzpNPQEUi8L2J44Y47Up1C4vR1lZnhbcY/da7wvDoQG0hEYiomIrzqJsRoExJknC4bZSPsub8b26i7PweOwITRA6NEj5zAI0NclAWyvxRBRShmxJkqiaV4XVYWPemnl0H+mmuK4+HWcA0NM0TFaeEyQduz1GNBBGxhD8fc0jXPvdG8ityueZnV14TqtEjSbZ+0Iz62cXsqAmn9a+IJVe03Bu8rfjhMJbGG+zsQa41tR/AvgM8GMhRDy1nZkv8Q4yWUk92uXDosgc/OPTBPpH0xIilkga1b5kidmXnkbuLMNEKoCSPCc1xdkZL8CB0SgdQ8bXm+uyMaM8J739GBIQjCRo6g6gI7DIEomkDhLE4oaG1D0Uxh9KkJ9tp7bUgxof15zmXrcAJddBuYDI3j6iQxGSfSHIsbOkPp/SAnfGuabT9q2KREG2naSmk9RFuuQoE7Z9o8+yItPTZEQkn3nDOZSW51NUksuQP4bVIuO0W1KCavzu1JZ6mFHmwTJp5jBn1RxGHC6KE/DSXuOYY8FkkgQzy3KoLzPcBMGIynAghiSB02ahLPWCr15Ymx7jqmvWZMxOxgTmyIFj6WWJaIJ9T27GWzPe/Sup6nQdHKB2aRnJhMYrDx7ISNmTjgxSPr8YvSyLilleLDYlLbyDwzEKqucz8xPLiGuCoWAcIQTWw0NoozFsLivqwjIcrgmFUIDexiG6D2dadNRoMn3XbFaFM+aV8OrhPpbWF1LgsdOwsoJjO7vRkhpylpWENtVd4j86RMeEMqp2m0JP83hxlYpZXrobhzL2yTurlpFAHEnTaU/50622OBvufJwPnFqLq8pwRdQum8HhjfvpONgBwOLzT0OSrJTWu9C1JMPdQyRVG6HRKLlFbjbfPe6PH+PGn12T/ooiSZ3ZV8xFOzyIGlZxZttQZInhQByX3WKazk3+JpyUz1uSJAXYCcwAfiuE2CZJ0kxgtSRJPwBiwK1CiO3v3FDfPcicWGt+q8FpxwtYE5PO2JXyz219cAt9TVPTZACKFtWTLBsPjirNd6IocsaRIimzNxja2/F88HFVp3PYePErskSOK9M8OFabus8XxR9JUHf1PKM4CRC2yIRSmpYWiNPTNExBROW6jy45oUo9dj/cThunzxu/lunvUebyidfi6/el/1ZSZmRFkSnOd6WPN/narZKEMo1pv20gRE9s+rx1IaCx20/XUJgsp4V+37h25/XY08I7Y+9J96DvWB/h3Y1sv/sl6hbX4R/wM9wzTDwSo2xmAcNdQWIpf3Q0Fc9gdVi4+Vfref4PO/CsqEAkNYZ29qBHVQ4/25w+4VipUjACKyN7+5EWGCZk50CEo5vb0+MYPaeekoZxX7wElM0u5GO/WM//3foUeqombPeRQeasraVnKEyO24bbaeWcJRVpa8XKy+dwbGc3QodwT5DsCg/xVHCjIkkE9h5F6/FhtUXJKihEURRG+kKckLFo9ImBhprh0+7bepC8kQBZMyrY8dhr6fUWm5WKOQsZ7jF82Yri45V7n2blFWchKUW4yu3Eo5mpZAD7XtjLqVev5ryl5aiqTo7Lhm32uLGxtjib0VCcoUCMohznlP1NTN5uTkp4CyE0YLEkSbnAI5IkzU/tmwecCqwA7pckqU5MclhKkvRJ4JMAVVVVb+PQ/35MH2Y1zskGp72ZgDUJiXWLyth6uJ9oqnrXBcsq2F6Yc1zhLUmTo8qnCqKJcmMkGOdw+yiVhVlTzODJCdqSpou0f9LrGe8lLUnGuo5BQ8hnp0qiimkC0/yD4eNOVE6W6e7n2PLJx9364Cvpv2XL9NXeJu8TCcXZfM8+dE1H03SEJtA1gWt+IWTZUBIamiKDMlXIh+NJEslMv+0b1XKfuObAC7t55Av/TXFdMS17WrBYLcw8ZRYzTjmV7sZh3LkOymd6UWMqrXt6mXVGDYpFxpFtZ8YVc2nqCYBNIeuMagIvHMu4UT1Nw5TP9OLzR6k5u55EnoMsu4XQgQG6JpX83fbIIXIKs1h7wxKkCdfnynVw7bfXcf/3X8ZT4Gagw0fL/j4ORxNYFImGshzqSj0IIdj/4jF0VU8L+r6jw4x2BfjY/7s4nfXw/W//L/teMALqLvzCJwn7wrhzHVTNLSQR0xjuDmScfwwhGb8geUJh+VjYEPpb73qJ8tkVDHUOMnf1XJpeb0KNq6z9yCUEhscnVN2HG0nEEmy551nqV86i7jOf5/pHvsv/rrs141zdh7sIdAcY7QvizLYTjIc4uq2R+qX1NKyYiVWRKcpxEohMEzRhYvIO8KaizYUQPkmSNgAXAF3Awylh/bokSTrgBQYn7fM74HcAy5cvfzNuXpMJNJTl4HRYWDbDy2tHBlneUIDNqpBTmHP8nSYJi6mFVDIFSjyp09QbYMAfTXd4GsMzSdMWQmCNa+iKjCWeJNthJRhNkLQqRkkxjBaZk0nGjWjuZEIj7IsZfsYT8GYemuMF2P1iv1HL2t/vw2KRiQXiHNzUSumMAspnF05/DkXi0CvtGYscbiveeBLfQIhYKEHxzAKKL2hgJJRI+3rT1zrpfsvSmHVDYEkVbpkuMyEr34ja728xAr+SapKj2xqpmLcUsBH2xQj7YlTM8tK6t4/n/+d1zvv0SmRFRp1w/oSmU7i8nIGjw0zEM7cQS4mboACSOktqPDx95x6iwTgLzqqjbV8fNQuK2b+hlc7DgzTt6CKvJJvLv74GS8pdoSY0QGKk19Bgn//ta1R/cD5xt5WD7aMU5TqJxpL0B+O0PNuEtzKHoVQQmECM1yjQdQ5tPDg+5pgx4Qn7YtgcFkZTGrisyBTX5qGk6sQDaFEVbApChqp5RYz2hYj5rRTXlpBbnJOuEHdo8yEq51aiqTpWRwFqwhCwipLk6LYj6XMfe72RM0Nhom43N2/9Df7djXTvOEqo30c8lsOd33geAJs9xgu33wcYzVp+0X4H7cMRSnKd1Jd4iKd6pJuYvJOcTLR5IaCmBLcTOAf4CYYffB2wIWVCtwFDxz+SyV+Dy2FBAPkeBxetrEwv/+h/fIxrv/fhaffpDyXpnqD0JqfxNb5V95yiCVru2JO5zCJRf9EshKqhBROEwgkQAsvSUrTUy0yfoCUFBsNThLeuC4IjEWRFxp3rOKnOY+17e4kG41TNL8aVO3686SLkc4pz0XXBy3/YyeFX2llx8SzKZhdOe9zpggJzirIIDIYJjURR7AqFZ1QTiCRQU9eV67ZmCOZlDYXIMuk8+xf3dGMFBv7SiKxIzDmjhnln1WWc49UHtjB71WySiSRt+9pIJpLkFOUgRKbFYCydqaDckxZoVbkuuje3k/DHsLps+EJhZIuGnpTwVuZw/mdOY2efH5GKSZhblUuR18113zkbq8uKJEmsBdSoyv4NrQDEIyp9LSP0Nw9TNruQUFSlaXcPycRYVTcBIsjRO5+i4qo1WArz2NcyTCCiMrCzBzWuMdzlp2KWl+BwhERSo6XHTziuEd/fRFI1JnQ1p8ym5ualyD0hIkcG6ZxQ1EeNJelvzfRDf+yzp+DMMiw/0urxe/i9877J/pf2Zmzb19LPRZ+/ltH+BFl5DnKLshjqDrDupst46Y+PYbFZOe9T16C1hZBnOYkj41g4k7lLZkGbj6anmtLHSkT86b8bVs6kezRG32iUaFxjZlkOU0sDm5i8/ZyM5l0K3JHye8vA/UKIJyRJsgF/kCTpAEaCzQ2TTeYm7zzFdSXH10wHQ3QfM7SuPLeNYFRlX0umFiYB3mx7ht3WIktTNO+T+WaLavI4+pcjU5bXLyxBSynuE4WxO8c+Zduh9lHu//7LyIrMZ353RXqM0zHS5ePQxnaad3QR8sWYt7qG/PJsFp/f8AZ7QeOWNg6nNOqkTaFjIGhsnRqb0Q0MtEn3IL80m4F2XzoozDvTy4gQSBrkum2oSQ2LLKerylkUCbstUwNTkzqiK8BAqg3nwnNmZKzvP9bLkS2H8A8aAsJb6WXljedRMrOeqjIvrz16iIgvht1lSUf0L10/Kz12T66Drte7iEdUZEVj+6OPEvaFcGY7+c6LPySvNJvVBS4Oto9QXZSdbg5id9syniOr08rc1TUc2tyWXjYUiHNkTw/heJLsmlwUiwZ6kKbXd9N1OBUM5g9w5g8/ni7aUnXZbA7c9jpCQFcq4GzBJ5ZzINX+05mTR265F1/3EEs/tM6wXBS58JTXUVPkpm2jcX59momn3WGdYk7Xk9oUwb3grOVULVxGcFSldmEhbfv7CI0apvMcbyn1y+cwb+1afANRQls6yT4yTNGCYpL1eahJUIailNTnU1STi8Ntx9+fzWDnPAbbBiiqKSISN76HeCq9TZYlkpr+vm/GY/L35WSizfcBS6ZZngCmV/ne55xoXu0LxRkNZQa9KLKENjESWJIMM2pq0fi8R6K2JJvJvKVZ0USBrMj0jk5ueQEFWXaGJ411cjBaaoAUZI8L2ymNSADlOL5k/fAgQtWNRhgWKZ0C1Ht0mJwJhV0ObWhh0z17ETrYs8ertR3v2pMJnT0vNKc/H9zchs1pYdH5MzO2m6x9B4fGi3EkHBb2tIxMe3zPpOtxemyMdPURDQZx5+aRUzOTWOrYvnACb7Y9LbjB+G4zerULw5RumWB9OLihhRkrKtL37n8/e1tacAMMdQ5Rfv4puLOdzJ1XwqxVVSQiKpFAjHu+/SL5pdm07u5hRsoaI8sS+aXZ9LUM0bbrFcK+EFa7lU//z+epXWr0n7ZZZRRZ4sBzTfQfHMBqV1h19QKK6wsyrnf2qioObW7DU5ZN9UUz6UTHkdIqg0mdnPluHv2nuzL26T3cyaA/lr7mgKaTV5tLsCdIMq5Rf94M/BNua9Ru56r/+2duP/drEyruQVDVUOYWUqVqdLzaOb3LZ4LgTkTjtO46hsebWQzo9KvPw+oqIzhiCOuQL5oxEXXnuVh8/rkMdozf8+BwBPb2oe3qIZnQ05Ok+WtrmX1GDUhzWXzBIuLhOBXzqkAIuofCdA4ZsR6SJBGKqeROqDhoYvJ2Y1ZYewucSJBG4kn2tWWa+Ca/2MEQkpM1XBmomUZ4v5WxCF0YWjXHrYcyJYr9jRieNP4FH1/G/tt3ArDuxqVUp6KWJVlCkiTu++6LhEZijLb70ilKE8kpdDN7dU36c+X8YpKpvGu7a+qjOVkIdx2eWoTGMc0Ls2c4TFLTEb4YyUCCzsNvPqtRT/Sw/8W9HHh5T3qZcAsqP3xB5gAn0FDmQZak9JiDUcPXqha70s1ZHNl2ZGV8m4/9+pPcMv9z6WNULJlBFJmS1IRKsSo4cxSsdgsIGOkNsuWefZTPKsSV40DTdWovm43zSCcb7/wTABd85iJOu3p1eohHu/20D4bJqcph4CmjBOkD399Aw/Jyll08m6zSLNr6ggwlkiz49AoiMvg1gSIZgj+SMpdnnTKf4lkV9DeO1xUf7hwkvGkf3kWzIJYEi0wwplFal09S1VhxZi3ufBe6LtCFQNMF7XtbcOdlMXionZqFDYzNbTRdYFtcAq91kEwkkOUx7VtHkiUGWvuxOCw0b2vkiV8+xrGdzXz2f79g1Jj3uCisqUEXBRmumsEOP0U1uUT8MbLyXPQ0DWN3Wymqzk1bQxDgrcwhHkrQc2x8YndoUxuFFTkU1OZRWDNe5EWSJOqKs6mdMBG1W995rXvnzp1FFovldmA+k+vrmrwf0IEDyWTy48uWLZvy0jKF9zvAtH7a6RZNs+xEkewTDyeAw5ta6T5imCPHNBFJMv5nr/QwnNJgCz1TTdRvxEQtG03HYlNIDEcgqRNPmVqjKZOwK9fB7DOqkSeZCa12KxCjaFEJrpEoPTszo+J9AyGG/TEKchwEIwnaJghj+3Ta/yTUEjcLPr4MdEGsP0TTk0dxZGXuF00kOdA+SjSh4YlrhFp9KG4bucVZ+PpDSLogP8u4R1Kq6Uu4f5ShQ21ENYHVFqKwqpIDL+/lwIY9meefUNbTZbdgkWVyXFbsVpkZpTl4c5xpoRzxRfGlLByFVgtrfnw+rlyjk9jYdykBBeVeLv7S1ahxiZ7mFk79zoeJMrUfujqhjGvIF0ubvWVZZma9l+5IgjWfu5Sdd72IEAJf3yh5JXkM+KIc6TK0zIAQuLxOIkOGRaZpRzdSroPcZWUkkhoJXScqCTTN8OVH4hpCgM0ikUgKJAmqljew+Ko1hIb81KxegLumlK77D3H0vgMZ43Xn2OltHmGwaRjvmkztuLFvhPBoiIqVs9OCW5LAORTl6COHyCuy8ehP/yu9fcXsCrqOdPHyHw2tv6SuhL6WPuwuOw/+8H56U9kX3pZ+5p99Abo2fu9yi9wMtPmM7yzVBSweVhlJBpEtEnpSYHdZad3bx6yVFVx77UIOb+3g6OtdrPvwYgpqctEmzXetqcnqxJ/z3yLX22Kx3F5SUjKnsLBwVJZl02X5PkPXdWlwcHBuX1/f7cClk9ebwvsd4Hha7l/DZK1z7O++YyMc2dox7T71a2tgtpGnG1N1vNl2CnOc5GbZCEQSDAXi5LttLJ3hzXj5xFSNTQfGWynGX2wl6o+hxpKULS2DlPBWdZ0ln1nJ0lmFUwT3GC6vE2YWYEnqLFhWhr0vxLEd3QSHwiy7fC57WoaZV51Ha1+QwVTt8sLqHNZ/YVWGUJsckQ0QkCCqSKBI5M3IZ/5HFmO1yhzr8aeCxgTBaDKdWhewK1hrcuh/pIccr5uyhgKErmeU5QQIHW7n0VsMYWFz2lh6wWnULj2V+uWnoqcau5VeMQfNYhR2kSQJh1Whz2cIwfwsG3keOwO+KJ2DIQTQ/VwzA4cHyavIIVSaTfZp1VO+SwHYs52Uz5nN4VfaySudi+5PQI6Dpp4AdqtCXUm2YZYNJph16WzUqErL88cyxm+zyggB1dedC9EYT/z6LzRvb+Jfnvs+jV2+jPOWLi3n2HPjrgd5dkH6OmRJwmmzEI4nkSWZRFIlkdTxOK1ouorbbuXLv/8SG/b1pmvC27NsfPiH59PTNMRffjGenjd2kS/+cRcHN7Yy2hfCalOw2C1Ybcak5sDDW1j8z9cZ7iVNp+ulFnRNMNqnMm/tMg5uNKw8nkIPTAitsDqsyIpM1fxqml4fb2Yy1DlIeLgFZ+54XEFWnjNtBRrtGwV9EMXqoPm13dQsnE1+5Yz0xLF1fx/Nu3qoXVTCBZ9cQUldvtHcRyLd7MciS9MK6pMJtHwbmG8K7vcvsiyLwsJCf19f3/zp1pvC+x1g2h/u3+HnNdG3F4yqBIHKoiwKc50U5jqpL4Pm17vYu7WT064er9w1JdBGMiLDAarq8qhdXJax2jmhrrmm6xxq99EzHKby0lnoikwgFRXtl+Diy+ayYv1sFKuMrgv2be/k9aOG0NY1nZpFJaz/4irDrDx2HRi+45beAHWlnvT9nRhDoNgURlOm9uEOH26HhXBsapMRXZGQFZm+lJ/bVeGBSRHvY7WwAfSkjjuvCP/ghHgBGXKQM3pWTzSTjoQSDPlibG8eSvtqNV0YUdtHh4hOE3swkXh4fDLR8ZdG5ty4BNWmcKB9lL7RCCtnFTGs6URLjVrd8794qhEIF0/yyI83IoCC1dVE1CjbH9gMwJFXD/P6gR7CukRpnpMCjwO3IrNtSweSDAXlOXgrPDgcFmJaApss4xyNEuoNkewP0xVO4Dy/HkmSCERVZpZ5mJUqG3v6vGKe390NwIqGQix2C1ULSvjA19bw8E82ARCe0HUsEoyTTGjpTl59Rw2hvPeRV1h47VlQXoytO0RoxLhPFqvM4S170vtP7iHeeaiTBWctZP/L+wCwOmzMXDmfWDhKLBzEUxgGSSK7IDcdNGd8uWE23T3eXW3hOWsZ6RlvROLKsZNbkk3zzh6ad/aw5iunU1eXj9fjOK5mrWo6/aNRylLFf95hZFNwv79Jfb/Takam8H4LnGhO7bIpzK/OG99OAossU1qQ+YO2yBLJyTY4DB/tZLweB7Y3mzs6bYOPyZsI9jzfjDvXwYJzZ0w78ZhY3zrX68Y1qQlJIqnR2hskEE3QPxpFF+B2WPAldZgQJXzO4jLjpTcWgT3pVLPPncGs2vyMMcQSSQ6k4gd6RiLouqDcm0VcTWYI78n3cbqAOgBF1aZ0p5rMxECopJrk0KZXaDjt3PEN9BM3IDnc6csIslJj47ENiZg63S5pJroM4hGVqATRVNDUUCBOa2+AnpHxZyQQT/LMf73GaGeAUGpiEH+miZZdW4gGjc+rPn4B/iSAoLTARYXXEPyX/tNqEtEENpfhOpjYwvTubzzP6ARhVrqpA+taw2IwcRLlsCno4RjBPUd4afte8oqLcXnyEEDFnELcM/JJhFTc1TmoIZXYaJT80mx8gyHUmEbYN36OP13zfT78m38mNKpRVJWLf7AXPSlRvXAGvUc7qF08CxDULq6jdU8LYJjNhdA588Pnk1tWTSwsiAQSWKwyG++8k/0vGULdW1nIwnNWgaQgSTaEPl5Ep25JHRHfKDZnIYmoMemLBOKUXjYb70UNqIDsth43CE2k/Pc9wxGyndaM38y7BSGEognyBMIqIamKxKgkSSfRAcbk3YgpvN8CJ5rqZrlsuF2ZP/I3U2HtqdfbmSxfzphbTL5V4bn/epL2fW3p5fGwSmgknOFAlySwu90Ehmy4mJTDPFV6oyV1Nt2zD0+Rm5pJWjVkCrOShsyI5K7BELuODU/eZVqt12lTpp35KKpGvdueIbjjqsaWA31EVS1DCB7u8jPcF2Q0GEeSJOzxJFJMI1GRObGRZWnK/a0rySLR6qN5QuCdvTQbfez6Uv94ls7i48//hNvP/Rr5ZQXMXbsGdYJlXbErU2upT5ooTV6fjE68H5k3YYpLZNLOk+d3LX3BjIkLgJYUacENEA8l6G3sTn8unD1e3TCjfKcEdtd4mtiY+0QIuOZb63jgey8z3B0AoPfIIDMXFJFXn4/NqqAmdQ5v3M+jP7qfAxv2pw950ReuJ+QbD2Kbe3YdmqohY7QmtL3WRedewy2TV+LE7nJisVnRkhqXfvkmOraNx+Zsf+wJooEI53/6Khads4aRPuOLcOfaad3zO2oX1dJ5qJO+lj5WX1fBSO/4d+vy2NAmVLkb6hyk/1gzBzeNF4WZvWoOR149DJLES//3F/JKvaz58OXEwhLeihwkRUqX9vW4bdOmf+mpCY9Fkakuypqy/t2AquslmqCUtBYnSAoqFUn0WmW57w13Pkk2b97suvnmm2tisZi8bt06/x/+8IdOWZ56v/7lX/6l5O677/bKsszPf/7zjiuvvDLwRvtHo1Hpqquuqt2/f78rNzc3+cADD7TMmjUrAfCf//mfBT/72c9KAW699dbeL3zhC1NfRsfhrrvuyv3ud79bJssyFotF/PznP+88//zzp9TlvfTSS2v37dvntlqtYvHixeG77rqr3W63i927dztuuummmkOHDrm+/vWvd3/3u9/tB4hEItIpp5wyO5FISJqmSZdccsnoL3/5yx6Ar3zlK2V33XWXNz8/Pwnw7//+793XXHONf/I5TwZTeL8LmSallef+318Q0Sib7trAcPf48zl39VwObT407XHW5NmoWrMwY9kbtdY8uKF1WuE9cWKgTNT+hZhWcBsBYBIjk1LQEprAPuG3PCbwLDGNF/7wGodmFOApdKNYZKxuK+HqqdXjHF0Bdjx1NEPaVSwqQSpypQW/tWkEvdCF1esiy2FlUV1+ulWjVF2Ax2Xjhd9vIbcmD9ljn1IJDcAqKyw8ZzkNK5eDNCFtTUAs4id6qAVJkrA6bcw6bQ52q4zXo9PTOIim6Tg8dixyaj8JCpeVY1tezqgusNgUWvsCyJKEJIGMBPKYSJeQXRZK6vLQdaMCmeyLYRcp73+qkHfM5zOERsrnrsaCWG0qSAqOrCycbkFuUT75tcVYHTYGDnfgqComtzAHm1UhrmpoEx60sTsgSxJOu8WwFtktXPG1Nbx8526sVgWLXSHPZUOyKuxuHqJzKIzDk8cpP/oUvk//gq69hiYsK5kTqWS7D8qMSGxHX4iWCYGJ0WCSqkWnsubWKxndM8xo3/gERJJ1ogEjre/Z/36Qgopi5p1lRPeHfXE++fCPaH19D617jWIyoz295FeNR4FPV5tgcr64xWahdkkdLbuMuIHR3iEe+4/bWX3dBUQ8DuZW5dHlj1Ga56S2KJuR3iBZuQ5sE1p/vtsbkaQEd/k0q2RNUI6u83YI8M9+9rPVt912W/u6devCZ555ZsODDz7oufrqqwMTt9m5c6fj4Ycfzm9sbDzY3t5uPffcc2dedtllBywWy3H3//Wvf+3NyclJdnR0HPjd736X95WvfKXiySefbOnv71d+8pOflO3cufOQLMssWbJk7rXXXusrLCw8KWvCJZdcEvjQhz7kk2WZbdu2Oa+99tq61tbWg5O3u/7660ceffTRVoDLLrus9le/+pX3a1/72mBRUVHy17/+dceDDz6YN3F7h8MhtmzZ0piTk6PH43FpxYoVs1588UX/2WefHQb49Kc/3T8m6P8aTOH9LmQ6bXzfMzsQCZWS+tIM4T3U+QZF7d7kS6V1bx/3f+dFShoKcDgteKwK886uZ/vRYarnzKNvkqA+ngVCkSUGA5mCu74kG+skrSU8GkV/tZOBfmOy29M8nO4klZXvJH+C8BZCYG8a5ejLLRnHKCj3IKkabO/BUZaNSOgc29hKzenVJHMdjITiDPpj2K1K2u3g6x9i5xNPsejy08kfrcUhSUZRrLH7JUskRvwc29FIcf1i4pFMH3Xn/i20/sp42ZfPKueKg+OR0Dtv20bYF6PspszSCOecU4/LYaVnKMyeg33sax05blCT5IvR1zKeamjf2ZPpq5V0jr2+ge4jnVP2LSgvYt66C1EsWdStWEP1Rxaj2RWcepL/XfNl/qvl9wAcbBula4J7JttpJRhVkSVYM7+U7FS1NWe2nQs/d2p6O18ozqYDfbhTbUBjKbPA2d/6CHdc+e/G8KTM1j2tzzdT/+FFRBQZdJGuzAYQCxvuAHdlMYG2GEwQ3oqS+Q4e7uonO99BcCRmRMkXZVF26WqUXzyElkgy3DNAXnkfyMVIkkRwJMb6L32EJ3/9p/QxkpP6hB/YsJ9PvPQzNKcDrXsAX1sfW3/3FGpcZbg7wNFHDzNjSRnZisIfbn2K4GiUGUvKOOvDi8l5D7QATZnKS99oG01QahFiIFXi+i3R3t5uDYVC8jnnnBMGuP7664cfffTRvMnC+8EHH8z9wAc+MOJ0OsXs2bMT1dXV8Q0bNrgbGhoSx9v/iSeeyP3Od77TA3DTTTeNfu1rX6vSdZ1HH300Z82aNYHi4mINYM2aNYGHH34451Of+tT0hRsmkZOTk77eYDAoH+/3OFEzXr58ebirq8sGUF5eniwvL08+9thjuRO3l2U5fexEIiElk0npnQhgNIX3ewSh6xzbdQzPpFrmkiQx+/Q5RP0R2g8YVcPO+vIHqDtvObZsF7bszBSxWCLTnO2s8LDg0ytSap8hxHSMWrcWp5Vsl42zPrwknX52UmOdpN07bQq1pZ4pfsBAf4iu/dNPQCdva01oNL/cgj3bxszrF4EAEVWRZIn9/7fbyJXe25f2dU809R9oHyUvy5YW3gde2o5/wM+BJ7dDdJrSqBKU1uVwwec+gs3hpPto5gRpovbmH/DTsb+NqgU1aKpG2BclqerYO/zEq3ImHtK4F3GNlv/bQ8P6mcQrjJQpOalhiWlo2VY0IU0JyJqM1ZKYVnADzDytgZwiN1m5Dnz9IawDYajOofGelwHILjA04OC+Jtqf342nupjc1UsIx6R0CtiG/b2cPqeYHLcNSQYlZfoc9sd45XCq3vokv461KD/9t9EcZFywOdx2mu7YQ3aBC6nEicWWNLqBpduBCbRkEnehGz2hkYwk0BM6MlA6o5KkqpJMJKmcW0vIH0VSoPaCmQQxAgGXXXoqwd5hOg52sPnPz7LuxotRY4Z5PTAgMf+sRRx42ai6ZnNO47OWZRKagJJCsksKuWzFHLZ99x6qF+aRiKoc3tpBUtUJ+WIgjDrq09UTeDeiCfI4cQ64rAnyLBInbXKeTHt7u7W0tDQdzFFdXZ3o7e2dku/Z3d1tO/XUU9Om6bKyskRnZ6fNZrOJ4+3f399vq62tTQBYrVaysrK0/v5+S3d3t7WioiLt0CovL090d3efOMd0AnfeeWfut7/97fKRkRHrQw891PRG28bjcem+++4r+MUvfjH9j28CyWSS+fPnz+3o6LDfcMMNA+vWrUvPlH//+98X3XvvvQWLFi2K3HbbbZ0naymYjCm83wKTW4LquqB9IGj4C1OlNXUBNcVZTPRvTif6JKB5RzeaOlYnGhwDIdLl11LWUlk2vqrQcJAZy2bQ29JHcU0RLbtb6G/tp2HleFWxkkX1xLOziQNMKqySNSnYDIcFv0idZ5IuLYupgjCW0DjYNoIkkW4uMZXM41gUGZd96qNmdVioX1bGsUn537JVpvS0Ktweu3GopE7vxnZK6vJAkghs70YsLwOnccwFH1/GgT/uyuxlPWWiMf45MGBMpGOhKC6PjUggM1WsvKGAkd4Q0WCcJeeV0bCygl3PHOWyW1fjzLbzmxubaN9vmGpDoyH6mnuoWlBD02ud6SIzvsZhKucXMeZ5H/DHqHZYCaaqcLW90ELtefWow1E6d3STTGh87BcXgcPCsNtOz8H+jOIib3R/x3DluLn5/32KfS+005+Kpu96pZ2hB4+w46FNeCu8WF3GZO6FXz1C41Yj32r1x/upvnE9WQ4bo6EEigz720awW40+5zPLc5El0oIbjCY2dotMTNVw9oXp2thG+axquhvbef53D/Kh73+FrkZDFni8LoLDEXx9IULD/bz0hwenjN05w0Xu6sVkzS3EFkrQfLcRZNZw2rr0NhZLgJf+eKfxbbpGKb/uXFCTtO5oYrBtfGyHNu2gv7V/3C1jtVA6o4ze5h6SCZXc4lyCw0G0pIZiVdCtloxbGlUsnHLt+TRuykzBzC/NZuXFs8gtysbufFMy4u+GQJzUQI3t3rp2OF1l7Om0zeNsN21l7bH938o+J8tHP/pR30c/+lHf008/nfWtb32r/Jxzzjl6vG1vuOGGqlNPPTV0wQUXnLBfrcVi4ciRI4eGhoaU9evX12/fvt2xYsWK2Je//OWBn/70pz2SJHHLLbeUf/azn6184IEH2t7UoMfO8VZ2+kdnsl6kCTGlohpA9YSKS2/E5nv2ptNixsgpcuOfUJXM4TQi1XVdx57lIDwaomV0/Bny9Y1Sf+ocjr12+A3PNbsyJ+MnWprn4rTZCluPjAcJ2SwyhTmOKQI3rmrsbRmmP5UHbNV0tNe6sbqt6IvHe23HGofR23wghFEgRMCzr3Ry/mdPyTheSX0BF37+NPSkjtAFuqbjG46wuy9ANKkTTZnenRaZ3glNKty5DkrmF6GmTLd+RWL+J5Zz5M49qKn0I3lS3fRIXCUv207v0W46Dhkv5Yg/hKfCRn52ESLV8lNTNUjoRFOTnsXnN+DOdzL/7Pr0sa793od57eFXxw8+obDIGIGhULq+Nxjaa3VxNoFU73Q1nuTo443p9dkFLpw5DiRZwrWghEVnl7DvpS605NQMA12fPlr93578Np6iXMpnR9j30rHUNcZxuWqZc0aQq75xefrlNubjBdj5wGZqP3gmIstGjtuGIksMB+PkyTY6BsN0DIbJHo1hcVlJ2sfHkyVJ+J5voTPVMGTM1734vFPpahymYpaX7qYhkvFxxUIIO5IkTXkhK9bxZy2RZaNudTUtE3qLA6hqFvPPXMKBDbvZcNvjrApF0JJahuAG6Gvpo3p+ddoSlVSTWFIZDrKi4Ov3IcsyikVBUzV8B1pwzhv/fhVZYsWVC1h10RysNgt2lxWbw4IkSwx3B8gvO/kKiH9vJCT1ZPJUje3eOjU1NepETbu9vd1WUlIy5ZgVFRWJzs7OtNmip6fHVlFRob7R/iUlJYnW1lZbfX29qqoqoVBIKSoq0ioqKtSNGzemv4zu7m7b2rVrg7wFLrzwwtDHP/5xe29vr6W0tHRKtO0//dM/lQ4NDVmeffbZY9Ptfzy8Xq92xhlnBB9//PGcFStWxCorK9PH/vznPz948cUXN7yV8YIpvN8W/up2LMdJa5qIp8iDO9dN2Dc1jQxgxccvouTcFawd9uHKz8Z3HMur3ZoZKa0oMrlZmYLu9LnFZLvGqo6N//TjCS0tuAFEUqf7QD8Wm0J5Uke2KuiaTne7L2PiAaRfntMx1l9bQSG3OIvYhEIiMNVaH/bF6Lj3ADXn1KVNz34hKP3IIrLDKgfv2suxJxopv3lpep/ekSiDrx9hpGeYgvICept7UWMJXHOKSHrHTb42CYIvtqY/+/qC+AdCCN2YiOi6IGmzcMan1jPSPsChZ7ZzeMtBTvnAKmacUknt0nIQglg8yYaj4xOOsWsoqsnjos+eipbUSKoaSVVHUzVqFpVmWDiOvnaA7Y9uYNlFa4gGZBTFhyxbUNUshMjikxt+Qai9jz/f8FMsVgvffObfaThlFmCUli2bMZ4VoFhlcotOZe8L/bTu2Yw710l2gQcQxMNxLv/alcxtKOZAjzEZHKuuNxbRLmk6TY83olhkKs+sIVaWjZzUaH/yKCNd4y7NmactpvNQC1UL5uAb0OlqHKK4Jg+rXcHhthILq2hJC6d+9ByCQ35Cg36CA34CfSNIVhkJsFokLIqCc0U5Oa2j+CccX5JkvFWVwG4A9j/5OjULaqY8T44sB11HujKWdR7qZPF5SzjwshEVr+t6ehbe+tRrzE0J75JcJ8vqC3A7rJARhmRogCfb6e7dgiIxmhRU8samc12RmKp9vAmqq6tVt9utv/jii+6zzjorfPfddxd87nOfm1LS88orr/Rdf/31dd/61rf629vbrW1tbY4zzzwzbLFYON7+69ev9/3hD38oOOecc8J//OMf80477bSgLMtcfvnl/u9+97vlg4ODCsDGjRs9v/zlL7sAPve5z5Wfcsop4Y9+9KO+4435wIED9rlz58ZlWWbLli0uVVWl4uLiKYL7F7/4hfell17K2bx5c6OinDhdt6enx2Kz2YTX69VCoZC0YcMGz6233toHhnuhurpaBbj33ntzZ82a9cZFH94AU3i/C5hWdE+aEfQ1d5JXmk/t4lpGejJ/Z2Xza8hft9zw2+XmYLdb8Vpk/KlWlULXEdEY3Y9uJthwberFPU73gTb2fu9PVM6v5rrvfQSLMv5yauzy4QslQAKrkvnSUlIv+2RCY7B5GE+BO138JBOdkc5D3HbjuFAk5atf9/HzT3gv5GnMeYWVOYSbR3C7bcTzHEgYnb2UbDvZRSqBnmGGnklgcViR7VYc3iwe/+6f6W81tLS5q+dxaPNBwn0j2CcIbzUQpnvndhyeGoqq89n19FHaD2RqdjOvmU/NRy6gBjjt2zeQJRsV4hWrko7GP7qti/jWdvJn5JO9qJS8lEAsqsunKLMDqHE7Jl17Mq4SGg2x8e6n0svW3fIBahfWkTWrAL8Q2BqquPG/Ps/qK04h2zvuX8/2ujMC3KrmFeEbMDR+X78xqQr7QsQjhmVgzhnzqK3Mp8ufwBdOEO0KoHT4EUUuahaUYPXH6SNGMq5y4N5nqTt/JdakjdGejFgkNM3D+Z+5imhIZkwy9qcsUnVLS1ly3kwOb2nDunIVo+FMV0Whx04koaEmdSLxJJE4VJ1bz/4/7k71P/eTTMQYHeinck4lnYc7qZpXzf4N+5m3Zl5G+ldhVRH9rX043A7C/vFJ5FDHIO48N/6BzMycfU/vYOFnL2f5khoqve7jBxJK0nvG1z2GJEmaIone40SbA6BI9P41wWpj3Hbbbe0333xzbSwWk84666zABz/4QT/A3XffnbN9+3b3r371q57ly5fHLr/88pGZM2fOUxSFX/ziF+0Wi+UN9//Sl740dOWVV9ZWVVXNz8nJ0e67775jAMXFxdo///M/9yxbtmwOwFe/+tWeseC1Q4cOOa+44grfG433nnvuybvvvvsKLBaLcDgc+p/+9KeWsdS2tWvXzrjjjjvaa2pq1K9+9avVpaWl8eXLl88BuPjii0d/9rOf9XZ0dFhWrFgxNxwOK5Ikif/5n/8pPnz48IHOzk7rjTfeWKtpGkII6bLLLhu57rrrxq6l4tChQ04wrBB//OMf2487wBNgCu+3gTfT3GPa/adT3ackEkPX4U6sdgvRQIS5Z8xlsGOY06+9nEA4c4I7Vk2t/9GNtG7eT/O2cfPsB//psinCOzjoZ/+zO4kO+2nb3ohitZCVl0VJQxm+cCJdLtOiSHidVgZeagUh6J3w8rbaLMcR3IbWuee57VOWW2yWKcJ7OkRUpXym1zCt6wKhC3yDISL+OKVWhfxz6ghG1bRAaN93mAPP7844Rl5pPqO94+M78sph5q2ZxxNfu50rn/wxAHooSqypk9cf28yqD9pIxDxYTlAYJ64JLLLMYEpISZKEK8/B/hePMdwTYM6pVcyfXTR+Lzi5YntqfKoVs3T5TLSafCNGIXWcC28+d0pwX3aBC1mRsDoseMtz8PWHKJ2Rnx6fLEus/L8vs+WejSg2K68/upWZq+awZn4pB7a2s+G+/SBg+cWzWFhnaPAvx3rYcOdLSLJMlncGiWiS8pkFdB9NxTgJnXiwi52P7+CUyy8ExnPJbS4LF3z2VGRFpnSWl+Ye/xThHU0YddMTEwLhYk4LVnuEgy9voe9Yb3r5vDXzcfeO0LzTiC86uOkg89bM5+CmAzSsmEnTdsNtqcZUZiyfgRpT6TjUgTvHzWCnYQ1RrArObCehkRAzljewdl4JBYXvzhztvxarLPeh62TmeQOGxv225XmvWbMm0tTUNF2qlf/6669Pz5h+8pOf9P3kJz+Zcs7j7e9yucTTTz/dMnk5wC233DJ8yy23TAm0U1VVGotcPx4/+MEP+n7wgx9Me+0bN25M1wxOJpM7p9umqqoq2d/fv2/y8lNOOSV6+PDhafN3x1LO3g5OKLwlSXIAmzDqK1iAB4UQ356w/lbgP4BCIcQb5C29f2jd1Z0RTGSryiF/kuk52u7j6NaOdJS2BFQtKJnScEMA6z66hKSqGxHUCLY++Aph3wiyEZILgKYZ1pzWPamc1r5RLrv104z0RsktmT4TJDoayhDcAAPHekmEM4PY/P2G4Gne0cw3134dAI/Xw9obz6H4g+ekt0tqgmhSp2vfNM/7W7AkGo1LoGMgSFN3AEkCy3CU4IstSIqELMtIisT5t57Bjq4gh7e0pVOLxtARBKOTlk2TKK+pmdYwXdc5vOUw6799vfE5HGHPT/5M14G21DHA1x/C5pz6ExGTrlX1x7nvN6+nP7ty7ET8xj22u6fGC02+VYO+KNGEhiwbbWIVWeK0689k0XlL0JIaelJDUzWq5lfis9npTcVHaPpxpo2SRMPKCrqPDKYj5T0Frgxt/PKvfYCVH1gFQDSWZM+xYUCgOseDt8K+CMmEisVmpaDcEOIOt5NEqgDPWMlTRdHoPLid5u2NzFszn60PPcmpH7gIVXVRUOnhyq+fmVH7vtKbxaFUP+8xQrEkWY7xey1LRrGjuutPoaezJUN4j/T6mH/WUnY9tY2aRTNp23uUg5sOsOicxbTuHX/HCyFo3jFet71xWyNXfO3TCCF44fa7ifgiXPDpC7n55zdjdzmmu5PvG6yy3GcRYmCaCmt/tcb9bmTLli1vGDn+fuBkNO84sE4IEZIkyQpskSTpaSHEa5IkVQLnAtN3xnif8sx/vY42QUOo/dgStEkamn9bF42dmea5D33/XGzTdMuqWZpp0fr9F35By+7xl9CS85eyYN0i2vZOP2kLj8bxhhMIWUK1K5Ay/eQ1TLWU/dcn/pPBjsxWmnVLptpxA0MBDry4l5zLz5r2nJN5I9nt65k+iM6ainy3WWTiapKkDnZdZ7R3PObEnevA5rBy+rULOf2aBYSGI7z64EGObjOyNaRpylCGhwNTllXOrUKNJzi6bTyYVNd1bKVe1K5+jj24gUOpdCKA4voGRvuiDLT5yC/Lzqh5rcgSFlkmqaeegUmWk4lm18lFcaYTti19wbR1Y4zlSxooK5iaRyyEYMPeHoKxJEIIRroDKLKE023FmTuu7ZbU5dO4dTyjZWIkvjzJ/ZFIanQMGi6Q8cxXnQ1/fIgnf/l/LDh7Mdd978Oc+8kLUKwWXr3/CPFIgoEOH4WVdl78/f34+n0AtO5pQbEqvPiHB1h+8So+9L1PT3nmLYpEjj9O2KFgGY2hDkWwOqyEZow7mfOy7EYLWqudUz93OYef3YnVYeOCT19HIm4jHkuy/pYFjPSEmXX6WmwOhd1PPU3lnEoODk5R3sgtLmDpRWcw3GPc58Xnns5gexs3/+Lj2J1vruPeexVJknQjHey947M3OT4nFN6pePyxsGZr6r+xN8Evga8Cj70jo3uXMq2ZexLTCZWTZbLmuPCcxay/5TKWXriM7134HXQtFb2bOoUaT9J8l2G9WfyZFchZdnRdkH3KHBSrBVd+NitvOJeunUcpqC5m8A/PTrqe6ccxd81pDN9/EITA5rZSf8VcZjV4WfXr9eknQFM1/vjl/6Vl5whgmGQlWTZS5mQZu8vB3hd2THv8BWcvBqAk381FK928erCPIV0w86q5HH3QsDqFfTGCg2E8xVkgSWR53ay7cSmnXD7HiFqWAJeVaELjcOcowWiSwIAv4zzZxXms+MoHue/GnzJj2QyadxraWEFFEdmePEKtPRRXVzJv7TKO7TxMLBRhQtlrhjsa8fUP8+EffZSyWeXY3DYkSeJA6zCjoQSy7fg/I226cnmTOFm3i5GKL3HG/FI2PHmEY08d5b5UwZO6JaVc8LlT0xpuUW3e+E4C4hPqqdscVnRhaLc7H9/Gvd/+M2f89ss4WnyMdvpxZFvpb9xFYypzoetIF+d8/DwqU8FhhTW5vPaI8f0kVSthfyR97EggQllDGcHhIDueeJXSBZXUXXs2FkVmfk0eboeVnc1D+Dt89OzoSRdsySl2U1CZjWpTsIdVEgktXQNfCEHFnBqWXHhBqkFMInVpxrVGgwkUJUnXkXa6jpA2oQPkl3lZdfVFSLIro7lMYU05Z99w2j+M4DZ5/3FSPm9JkhRgJzAD+K0QYpskSZcC3UKIve+l6Mu3g8nCTprm3StNE9t5sndpYj1mANmigCQxb90i/hx5CE1NMtwxyL6XOhnt687YNilJBAKpPtNWOx977ifImkbY4aT00tWoja0wSXhXzKnkqw//GyKV2oUwXpitewbY/rhhfQr7YiyoK8DtmWpejPgDU3pdj5FfXjDtcpgage5yWCAogSXz5vUdGzaE99h+Dgu5JdkZIi8HKM51EoqpLHv++0hIJIFDQR0Jwzf9wSd/jNI/RPMHjEpgq67+AC1PHiPH6yIWdFFQNZ9ENEbT6wfpbdxN2B9GQqL9QCthXwjZcgP2Ce6RUDzJaDiBIkss+uwKtInfsJrkvuu+y8GXn0SxyMiKQkl9CXPXzMNis3LeZ9djc4w1AznuLUqTEfUfjHP0scMZ+7Xs7qX78CCV843yoMmERn5ZNv7BMLIsEwslqJxTSHA4Qvl5M9iwrwerRWbv8/to39dKzvfvpHzWMsKjMay2GCO9g8xbM4+RnlH6Wnpp3X2MivnVSJLEsvWz6D46ROfBAUb7opz/mevQEgl0TSce9rPhT8+kBi1RcsEphgYNDO2LUVOURSiqoiwqYeaSUlrv2U90JIq/P4z+xFGyC1w0Nw5hd1nJr8rFcVoFyYI8LvjGzRx7MdPt6cy2A0HcOXa2PfJMevnBTQfSAnzJBasJDEtApmWjcm4ls06bfeIbb2LyLuWkhLcQQgMWS5KUCzwiSdJC4N+A8060ryRJnwQ+CVBVVXWCrd8bTNG8pxXeJypqdHwma97KBGEmKzKyYqNkZjnt+0+c3RG12vAW2NP+SffcOm5++of8/sJ/RVYUvvHUt+lu7KagamqlMWueh13Pt6DFNBxZNlw50/sFLRM0T2e2M93JCkli0ZWr2fTfT6AlpjYqSURVosEIzmwjh93jsgFh7CVZzPzcSmyhBJHOAM17eqmcX4LT88ZakiRLZLtsZM+uBCAWT7Jn9/jkRo4mUdsTXHrrzfQ1HUNWkpTP9OLrD6HGjfF5CrOYdepsepq66DmaOTE63hxV0wVxmyXd0xrAZlUyytgCZOW6+fM37gKgdnEd89YtAmDrd+/g2I4mZIuCYlGQJInyn95E2QXLjPOS+YgNtY+gJXqxu/NRE8Y9KazKoem1TqLBOLkVOcRtStrUr6GTXeCi++gQuiYoSmjEUn7rqjMWcGGOB93nIjxqTPqEUBjqHKLzUCfz184nGozwm4/9mtlnzKOorgRJkbn0n86gbVcPe59vJjQyQDiioCVtZBfkcvlXP4XQEyguBTGcgCJr+j4N+KKEUucO6YLa6xZy6LfbAAgORbCl8sjjEZXeI4N4hsIULiima1cPpXX5GX77ZKoSXXCwneGuzIyAg5sOsPi8pahqZnDmGPWLK8nKfX8GqJn8Y/Cmos2FED5JkjYAlwG1wJjWXQHskiRppRCib9I+vwN+B7B8+fK/NiP63cHkq5hG9Z7WbH6Sqrc2qfTk5EYP48vf/AQhoQnKK7xc+S8f5KybzqWoroS5axcQiapYrDKdAyGynVbyPQ5aBsPMvHQOrc81M/uaBaTLvU3ii3/6J+7+2h0c291M56FO5q2ZRywcZ86lp5F79ko+dtVaXvnhnzn0TGbE+eM/f5ijWw/zwe98CFlRqPC6OdA+iiTLxJJJYg4LNOSjbmznmd++xmVfXf2G1zxZyCUm3UdLIE7LLqOam8NTzWifitsDYX8svU1fczfdjV2UNUxt0PLcfz2FI9tJ3dJ6FKuFSHERWMZSh078aNsmdJq7/9//TP+Nv8ThdlBYXUQiHMc3wdz/4LfvBlVj2SUrpxy5ZcdBttz7HMV1JSy96HzcubkMtPsY7PDT2+On/MKZBDSN0e59ICCZUHFmLUDXUuePJCDPmIg9+fXbuezebyGODNH6ciqmQsQoayhD1wUDbQNEAhHmrp6bat1pFOMZ7vDz1G3bELrAao2x84nnWHHpBQRT85WcQjejrWHUcAfeCxtQHRayNEEgqmbEBEQ0jfy6PEZStdzVWKbVKTAUwdEygjU1QSyo8DCcyv3uaxmhYpaX4EhmP/Yx9jy3i4/+5BQqZtfhcNuM/7JsuHMdFFbkTLvP+5m4qintA6G8qKpZnVZFrS7KGrVbJxWQN3nPcDLR5oWAmhLcTuAc4CdCiKIJ27QBy/8Ros2FEMz5vFEpbCxhx/9yG6H+kFFRzAgap+vAdjoPtgAiZY6GrFwJTbMa5s7UG/ma76wje1KDg5K6EoY6BtMa/u1f+G9WffB0XHnZGaLTNreQ2RXj5mOBUXLUEdfSY4Op4jbH4+Sa730k/Vm2KPQMhGjrDxKJa5y5oJR9LcNE4knCeQ7KrlvAiC7Y1jhIfakHb45jvHUkYHXaCflD6XKbYzm39ecZmmNUtrDsmx/FU5LHa//3XMa9fOhHD3Bo80EWnr2ImafNYUZDNcOBcWEKEB6JEBgIc/e/PMfc1TVke10c3tKGYlGw2i1453ix1+QhyxKzKnPStbgdNpkldQXoQqALAXku5NNCHEkFcrlzHVP8zWNGlZWXXwAoRAJ+ug8fJBlPsvHuDencaIArbvsi7oVGgSSXw0IkoaEHQhy67VHsWVOtFNIEX0oilmCkx0hd62nqYeapszKE97GdzTz168f4n0//hmgwyid++xlc2U5evuNFdj5lxBD0t/QhoTLQPr6fPdtOQNMBieGeQXpSxUrmn3UGpQ25FNXkUbu8nFEEe57ayWjHgHF/ZhYwO8dB7yuNPPmrR40iJkDtoloc2U4ObT6EK2dcU335jvFytEnNQcQX5sXf38epH1iL1VWNNaVB+wfC+O/YQ/3Kchp391J9SiXqXG9agLsdFjyXzqakL0TP1g7i/hhWu4Ia18gv8+BwWdPNapzZNkZ7gxTV5GK1W9BUI70spzyHwuoSBtvH9QZnlpNrv3Mdl3zxfCxWMyN2b9tISXNvoFTTRfoh3N8xWjmj1NO7qCb/bUkVW716dcPAwIBV0zRp5cqVwTvvvLNjLId7jEceecTzjW98o1xVVclqtYof/ehHXZdeemkQ4Atf+EL5Aw88UBAIBJRIJJLO9fzpT39aePvttxfKsozb7dZ+97vftS9btiwGoCjKsoaGhigYddJfeumlZt4ETzzxRPatt95amUwmpby8vOT27dsbJ29zvJagY+s3btzoWrdu3Zzbb7+95aabbhoFKC8vX+B2u7WxdqMHDhw4DPCHP/wh74c//GFZS0uLY8OGDYfXrFkTmXy+k+VknupS4I6U31sG7hdCPPFWT/heRxcQntSZKJHQCA5lfgfxcBxff6ZZOx5JoCYmCYtpqqtJikxyUmqTJKeCdyYsUxFEJmmXTiA2aXxikmIynflX1wWRVBnL3ceGiCY03KnyqGMtMwf8MQb8MS5cVoF1UqW2yalYkxECGj5xCYtuuoAdtz3G/sdfSwvKw1sOcXiLEQB1wb9dR/H60zP21VJBTf7BMO37++hpyjRH2+cV0t1vmIijR4bQwgkkSaJkZgGV88ZbRFIChV43R7Z2YndZyCvOIh7JTDMTwrifyaQNWQGXJwerI4uepiay8rPILsg2Kq1pguXLaqiYX56qDCajqUk+6rkaXdfJys+ipK4EXdeJR1TWXH8pI109gBFINbnPsdVmJbvAQzAVKW+1W2k/2EFg0MhY+M1Nv8Lj9RAYGo+kX3TuClTVxsSnomBeEWNx8UUzyvH3+Vl4zqmEfDrz15UyZ00tAIfueon7P/2rjDHosoR/UGfx+UvZ+/xutKSGrMjous5Vv/k8+/0a/i4fLruFJRfM5Jn/MszdQpdZtn4VO554hf5jHTSsqsA/OP57KJ/p5dj2bhDQsqWd0qEI2YuKiWVbSXZGUCpyCOXY8VzQgFWRGHjsCMVZdnqah9MpmTanhYF2H7omGGjzpY9ddXoVriUlXFx4M3/86A8AmLlyJl9/6F/xVngxMQR3Y7d/SuqJpgt5bPnbIcAfe+yxY/n5+bqu61x44YX1f/jDH/I++clPZrwEi4qK1CeffLK5pqZG3b59u2P9+vUzBwYG9gFcfvnlvltvvXVgzpw58yfu8/GPf3z4q1/96iAYBV9uueWWys2bNzcB2O12/ciRI9P3RD4BQ0NDype+9KWqZ555pqmhoSHR3d09rTw8XktQMBqQfO1rX6s444wz/JP327hx49HJpVYXL14cfeihh5o/8YlP1LyVMU/kZKLN9wFLTrDNXz2Q9wr6NNFFlmmabhzP1H0yWKaJXtb16axbbzFQ8AS7+VMCzX2c1FeLZarpWlNPbH0TAoTLyZwvXMWSL11FrKmDxm2NWO02ZKtCZCTIq797irNy3GSvWpTeb2JO/eSJx4JPLMc/YTjHXu9iIFUsZtmFMzOFN+PxBPFI0qgMNyGdT1H8RCZU5PL1G757T+F4gZexymwAgZ5hnMtmjO8vW3FkO4n4w4RGQoRGQlhsVs666Qb8QyrBkfFzTTQdn3rFOuxuJyUzannlvhfIK83F7nZMSQ3MLsgU3uGRUQ60PsectWsBiby6UvQCJ6R8wYsvP4/84nkkExphfxyhGfXj7/nXO3js54/g8eZy1o3XEnr6IMM97XjyarHaoux6egdF1UWUzSxjz/N7AFid7yGS0DjS5UeW4aLllXzslxfRtqeHY60DZM1fQe7cMp794b3oOqy87EL625NUzPbSdSTTINd7ZJChthGy89109AQomenFM6+QRJ4TFZnqy+dw4LevZ+xTVJWb2RY1Rc6CYvyqDnUlrPncpTQ+tY1vPP4tcotyp2z7j0hc1ZTm3sAbtgRt7g2UzqnIGbBZlL8q5zs/P18Ho0CKqqrTtsE8/fTT05GDy5YtiyUSCTkajUpOp1OM9bs+3nEBQqGQ8nYFSN9+++3569evH21oaEiA0eJzuu2O1xIU4Ic//GHRZZddNrpjx46T6g+7dOnS2Im3OjlMe9KbZLo0McU+VVArlpMT3tNFGk9X1Wu6wiMnzaSqIu9EbsDkPsnHY+zcMR2or+JjG36JJknoAkI7D/Pabx/j6W/fyWX/8xXsdYaykHnt46N35DqIWmWYsN4yodCHO3fq7OPw5n1ERpvweAtQrHlUzEppZ5LEtoe3TSmdCSArb/wzGQ3G8YXjdG3t5MwbP5xWhBORwXRNdID6ZfMpn12PrmlY7RYq5s1GkhRU1YMAVBXO/cQH2fv8hmlz+m0uGzNPmUnnoU6y87PpPNJJPBynt/keZpwyi8rrP0kgGEUWhgVBcloyemdvuX8/rz64gcObdtJwyjzmrj4FJAVfdx8b//g0C85aQvsBI6J7oH2A0hnj7/z7PvYzbnzxZ0SFhCLLyLJMNBRm28MvMDQYYNacqyk9ZS4A7ftbCfvuZ+Wl66YIbgCrQ8GT72I4VaGv7+gQfUeHyCvNJueiGUQODlBYlcNgh/FdyLLOaN8QRsnV8Zla4RwvoQmBDvUfPo8b//06cgveO41D3mnaB0J5E03l06HpQm4bCOXNLMt5yy1BxzjjjDMa9u3b5167dq1/zIR8PO644468uXPnRpxO5wkDRn70ox8V3nbbbcWqqsrPP/982rSdSCTk+fPnz1EURdx66619H/nIR3wnO9ajR486VFWVVq5cOSscDsuf+cxnBj7/+c8f9x5Mbgna2tpqffzxx/O2bt3aeM0110wR3meffXaDJEncdNNNg7feeuvb7lI2hfebZLoeIso0TTfkkxTe02GxTy3koienCu+TFcK1JVmsmDUWTS6QkBjyR0kk9fQxkkmd/CwbAsOUL5CwKjJOm0I0cWLB/JV7v4pit6KrGh3723jkxw9Mu93kSXNUN8YEkIgm0g0lDvzPX+hr7cPmsFG/bC7VCxchSTKWCROlmC8GLaMotblGtTEhiE0IPnPnTQ1k8vWPsOOJVymuKyfbW0xSVQiOGPtY7VOj2QWCwfbxGkTJhJpuELPhzxvRaivpCxmWCltCIzQyfv6yhhrDxJ9yKfgGBVrSmLRHw1DWMGOKC+D/t3fe4XFU18N+78x2raRV79Vqltwb2BgDxnQMofcODimEkhA+UoB0QhJIQsiP0AImQIDQezUYsI17tyXLkqzey0rbd2e+P3a10korWzYGbJj3sR7vztyZOVN2zr3nniJkmYYdkUU1jBYjE2ZOoG5THU67kymLprLzsx14XcF454yiDLxOD8+cejslR5Sw9eOgaT5/ygSmn3oKqirwewZo3bWdtW+sBODYyxfT0xYgq8RI886gxXTLsg1kT8xGkgQZRZls/nAz006eScnZRxM/IYuYGCOuAS+dH6zhtWWr2bW6ilUvrcQUY6L4msWoKYkUHDkRf98AfR19vPvQixxz2Tn4fEOdKHOCicKLpyD5FNQPaujePZSytqeln8BrVdjbHeiNMtmlybgd/Wx48wNqN+1mwsxisiuORFUlEgtsxByTHy6eAlCWbSNZU9wRuHyBcZUEdXnH125ffPrpp7ucTqc466yzCl977bW4s846a3TGJGDt2rWmO+64I+vtt98eVya022+/veP222/vePDBBxPvvPPOjBdffLEOoLq6enN+fr5v+/bthhNOOKF0xowZroqKCs8+dgeA3+8XmzdvtnzyySdVDodDOvLII8sWLFgwMGXKlKjbjywJ+v3vfz/n7rvvbhw5rw/w2Wef7czPz/c1NTXpFi5cWFJRUeE+5ZRT9llKdH/QlPd+EnD5CKxogFCebVSV9l07ad5ZjRpQUAIKSiDAVX9dwm2v/BQYyrL10Pf+ye41VaHRdlDZeJxHAZEhK+5+F+kT0ofl8lZ4+Z53UEUcKEHnN0VROf+O45hZHDmvp0ZxCI9mZqpq6osoWQmQHGukc0T9b1Ofm443dhHwB88t4FfY6VUpX5A/dExAF4pZ7nX5MeSlc8qfv0uMDJkZNnbU99LW60QSgoGddah5WfuszLRnSx0Bf4AeZzcJ6WnoTMGXfIzNRGpeLJWffYaqwuqHN2NNiSfvnPlY42w0NA29K7Yuq2H5U5uQdFIo1log1KCibatpwtnXi8c91GH2eYLKMDknBSXgR2/w4Hf30rBtaBRc9XkVxlBNbJc3EFbcMNp/YbiVxmjRj5pfj0Zvu8IpP7iIN+9/CoDEzETiU+PZ/snQtF7AGwgrbgBrgpVda3aNOmb7nja6moIz4PEp5rDiBqhZt4XCWUfjstvp7+omvTCd3rZeZJ1MZklm+Hguv4qhfAIuwOv04Vq9hdd+/jgAGROCI3Ov20ffJxuInV7K5DOO4K1fP43PPSjfUMcvJi2G3PMq6PcpICDttBIyu11UvbQdbyjtrb3dgZAFPl8gaCZX2qndFKzCuHvdLpx9DiYes4iMU0voH9ahNeokcr+hucm/CGa9PK5Sn2bD+NqNB4vFop5++um9L730ki2a8t69e7f+3HPPLXr00Udrx6toB7nuuuu6b7311nDMcX5+vg+gvLzce+SRR/avXr3aMt59Zmdne5OTk/1xcXFKXFyccsQRR/SvXbvWEk15RysJunnz5pjLL7+8EKCnp0e3bNmyeJ1Op1522WW9g3JlZWX5TzvttN6VK1fGaMr7aybgU2jaEhlT2t/eTfVIJ0UBhhHZmwa67TRVRo6q/FHin7uaumjdHek/4u534/NHdo4lSYwaykoiSiQb0ZaNc9zuV8O1rQf5+D8bmDhMeQM43D7W7+qMKDgxOT8BnSzh8wfCznBv3vYIU06dS9HJ8/E02zFmx4Oi0rm2Cb1+SKbYpNiwN3bp3Fn0tIfyafe68TgcbFkWWXhk41ufM/Pc+QivQDamYYox0d/tiggDA4hPHjpGZ30TuVOm0tManIbLm1KIySrTsL0BV187HXtq2frRFoQQFEwtwBxrpm7rHgqnFOBxefB29rLtj/9h4g/ORrJa8Lc7yJiQGLwnoWQ3GROCBUH0Jh312yILyIyVqW+gV+b0my6ncuVKGrc3hq8DBJX54Hdbmo3YxNhwffKROPsGiLEZcfR66OtwUTZvKjtXBFPA1m+rI7M0l82bm6nZEHTQLZtbxs6VO9GbhkLaYhKHRrKu3Y0s+8sL4e8tu1u48i/XcNL3T0NR4LW/fAx9RsrmluHsc9BU1UTdxo1kTz6SpJI0Eo8vxOEbUrgqKvYYPflXTsf+yR5aN7eRMT0D21G56Nx+2j6rZNXSZRHn1FLdTG/7/7D37GbC+cehz05DEoKTZmRjjOKL8W0nL9Xas6W+J2dvpnNZEkp+qnXfSSP2Ql9fn9Tb2yvn5eX5fD4fb7/9dvxRRx01qrZ2Z2enfOqppxbfddddjSeeeOJeC4cMsmXLFuPkyZM9AM8++2x8Xl6eB6Cjo0O2Wq2K2WxWW1padGvXrrX+7Gc/a4XxlQQ999xze3/wgx/k+nw+3G63tGHDBuutt97aNrLdWCVBm5qatgx+Puecc/JPP/30vssuu6zXbrdLgUCAhIQExW63S8uWLYv7+c9/3jyec90fNOW9n0TzDo/qvh3lxRw1cUuU3UU7xtcWIB9NwUQ53xXb20aZ16XBoioRebUlFKdK1cuhfOerhxKhJKQHlYask0nOSQmX73SO6q+Olsk94OKzx98DYNqJs7GUTKW3bXRHd7jC3Pje58RnlIa/K2oC2z5+A4BlT7xK+fzy8Da1oTnoCTMmsDWUenOQsiWLEetbaNzaRsCvIMkiwskOIDXPNkqOgD+6h75ON8Drf32RsrllQwlvQqQVpLPjs+CoOKs0O5wGNNr5ARhMAq/ewUB3O93NLRROK6SntQchCaaeMInJCy+hrbaVF377LJJBz3du/S4IlTf+/jhGiwGTXqJv+QYkg572tTuwxJoZ7EqUHllKx54OhCTx6j0f01LdC0BXUzfNVcFO6u711agI8pf8CJcvgFCAUG71wdTwbr+CbUEe6bOz6NZJwWgOWZBwTCmNP3tg1PVx2Z2se2kFvfVtZE4vJu/iE2ntcZKfqpnMR2LUy4GijLiWaN7mgxRlxLV8UWc1u90unXbaaUVer1coiiKOOuoo+6233hr2EB8sCXrPPfek1tfXG+++++7Mu+++OxPggw8+qMrKyvJff/312S+99FKi2+2W0tLSplxyySWd9957b/O9996b+sknn8TpdDo1Pj7e//jjj9cCbNy40fSDH/wgTwiBqqrcdNNNrYMhZOMpCTpjxgz3okWL+srKyiokSeKyyy7rmD17thvGVxJ0rP02NjbqzjrrrCKAQCAgzjnnnK5zzz3XDrB06VLbrbfemtvT06M766yziidOnOg80CIqmvLeT6KGdkVRZtFGVdEStwzG00YeI8rvaHz9g/ETbX/R2kU535ElKCFSQYcPEWoWcPsw9rnxxBqRZAlVUfaaPrZsXlmEUgr4RlyPaPloh7Hx3TUkZpcQ9fEedtHO+PE19LR60Rt8DHQ1IklSuHRo2dwyGnY0jNo82j1Ut/bQuKs7nFwn2jMy3AlRp/dSv2U9OqkUSIhoF/A08fkLnwDQ3dJNan4a5jgzkhA0VTVRdtRcSubNAzXYESqacyTVq1fi9wVCxxWUHlEajIpQVOo3r2HDO+vD+7fH2HE7gtaIGafOJiEriZSCdH5z8p0k56SRmBVcN++c4/j4qXdY8dQyZN1yJFnC5/FhjjVTOL0QvVFP5apKKldVojda6W7Vh87NF1bcg9Ss34XxZw8x85yTaNncQ0ZFCpJRh2KUUYuTiLcakIWg26eQHGeky+5BBVyq4Nx/3sD/vn9/xP5knUxWaRbVa6upXlvNJblJ5B1zwahrrhFkMAxsZJy3LAnlYMV55+Tk+AdjmUcyvCToPffc03LPPfdEVXwPPvhg44MPPtg4cvm///3v0T9E4IQTTnBUVVVFDRMbT0lQgN/85jdtv/nNb0aNtsdTEnQ4L7zwQt3g5/Lycm9lZWVUuS6//PLevVkD9gdNee8nSjQlFXVEPU4lH22UPV6lvB/Ke/DIg1PiE9LjyEywoKDidnrY8NY6fEY9PjUYZy50MorHi8vuQW9wgiqCrm5CoDOM7lyk2cz4FSVcrnLwmC6nl22PbsDV7yF7ajoGsymovKPI6B7oZ+L8cpKKMrnqJxeCqtKxYRetaysRQiImPgZXvxM3KhULKgBByeK5xGQmoypK0EcgoKAqCgaPRKA3dLaDF1QIUDycdsMlCAFWmwVLXCw+t4MPHl0OQN6kPHpautEZdORW5LJ73e6wsssoyoyo9jZIb6M9ooMR7bb4/W70Rg9N27ewc0Uw1MxldzDr9OOJSQj6LfR3tbPxnV3hRDDtde1MOmZS2AEtNT+NrlbfqOiBwaQ4ACarCffA0FTBxHkTI9oOz1DncwdorurE1eegYFopbsdQbLbQDaXLDfgDZJdls2frHmJsMZitZrZ9MnTM9x95lTlnL8bvNSDG6FjtXL4VWUBaYSn164MWh5jUGMoq0ugY5gsw6Idh0En4/AqmKSUc+91T2P72Otr3BKcdyuaV4exzcslvLiUhI5ETrj5hnz4U33am5ie2TsyOb69rH0hweQN6s0H25adae77oiPtQRSsJqjEKZ28ftes+Ck5rEpw7VlWFrNLscGGPmaedxsZ3W9n0fhsIkGWJz198EZ/XT/qEdCRZIiYhlmPv+wHVfh3Vm5oBFVlReOGi3+L3BUjOCb7QMyfmMvtXV496OTU9tZnnf7cMWSchJEFCeiyn33xURAJTdcT/DPueOswTu7Ohg5dv/GdEm4yiDFqqIzvIBdMKqN1YS2xSLFf/7byIddOLgvK+s64Bjy+onDfWdqOXBNnzc4NTwCqc+PMrqH57LSoqQh3MbxaU2O0YYMen2zGkJuJLtAFgnVrM5j8+i9flZeL88nAyl0Hm/uJS3JYYRGgvg6rJsKePXatG/37TCxPo79URYzOhKDr6OgbQG4LmfiEJErOSsCZaaaluoaupC2OMkfKjK+hp6caWFk9nQwcnXX8BOoMxfE9ik+NICGYNRQioXb8OVVWD1dUkgRASNWv72PHpVnyeIUXlHvDi9RrpCcUvC7Wbhu17Rt2rQdrr2pi00I/fN7Zj8MiQwr7OSH+h4ZaD9x9dS3dLsLOVM/lIUnKMdDR4QufhoGh2MdUhR7jknGQcfQ56W3tJzonMgz/QM4CnvwPZmMXgvUzJTSE5JwUhCWSdxEDPAFs/2kJiZhbIMVjTrKSePZEOf4B4iz6cW2CQ4bXKU46aSsLmWmSDjqSsJHZ+toN55x7FBb+4cMzroDEag05WDkY4mMahgaa89xOvxzvqBTuS/m43qjrkuKUzyOEQqEESMhNxKQLcQ/OeJolRCtOWmYQnMCyfKkEF4eiNdMQaHkK1v9b0aDHk0UYyQhKUHFGKwaTnn1f9FWOMicKZs8mfmk5BqCa5LcZIW68LdVAQAZ7cyDzSLdW17Fr55qj9D84xV763nik/vgBVBV1KArlTCqj+fFTWwr0izKMf7ezSZBorO0nNi6d9Tx9xyRYGety4++rCxx9uYoZgprztn2yLSM7icUk47EP3xOOy4xoYut+fv7J81DUtnl2Cq98VdgoDmHf+qfR1hkaasQaKLzuFCRfOpae6CSEEzSu30bErsjhKd0MVsWnl4fsz8jaNPG57XRvXrfg7g26Lwh9goLKR7vVN6AwG4pIF9lB2wPbaWnxuL0KG5f/7OHjNyrI59f9upvKlT+h8K2g97G3tISE9gYFeBz63F51Bh04vI+QAXmc7iZmJWOIt4bn5igWTqN0Y9BnY9vEaKo4/lax5ObhCVieXN4BBJ/D6h55cv8NN5YMvkViUzfqnP6SzoYObnriZ//ziScqPLuf6B7436v5qaHyb0JT3frKvNKAAihrpyx3NohdVOUbbWZR2UtRtD9xsqI43AYwKVcOUqM6gx+VIYfsndSTnxFN2VB6mvEhFLaL4uselxJEzMYeGHQ3oTQbyJuXRXtcWvgCxaTYkhoKMzKHqTyPn2s/447WYbVasJgO9A95wGlcAZIGsEwRCCkHWCbpbgs6v+lAcvRJQMcXo6WkKKq/h4VfDscRZaN09pn/KKP+GaFMhTntw+m14/vLgMxBsa0m00B9QwRZPzKzgNZS31rE7VHt88HnZ+N5aLrhrHrJOHw4jOO1Hl/Huv57F5/ESlxxHUlYSQpZQAwp6o57eDVUYp5YCAiQdtkmFNC7vxDnQR4zNRGKGDntHDx8+GXT4S8pKwpZmo7etlxlXn4xTb6D0/OP4+O8vA9Ba08rMU2ayc+VObKnx2LvsfPLMe0w+fhqb3gt2flILhjLbdTV1DvvcRckZJXjSYkAF2RdAdfmIT7VGhCn2b6pi7QufRVzDT/67nP+r/BcGk0Ezk2t869GU934yrkxiI2OtoyngcVYEG6+Sj+YANl6iZm+L6kEf+XWw7riqQkd9Hx31m8kqS8Y8JwuvWR9VWGOPm4FOB407G0mfkE5/Vz/Va3ehN+rDaWE7qpvRCxh02I5JCpZ1rNsyZPGQ9Tps86fS41XB6yHeoiegqAy4/RgGvLQsq8MSb8Y14MHvCaAz+PA6fYAOe6cj4hQnzJpBwbRJ+DxBuQY9vNMK0kjOSaZ2Y21EuNZIH4fhfhDhmugjsHcFOw72zn7SQoVnti//nNypR+L3BkiuSGV410FVVRz1rUw9YRp+j5+G7fXh1Kittd2oypClRdbrUFUVvVFPT0tPhKwAGPTMmDrkVS+Gyetx9PPeg8+RVZZN8ZwSdq2uwt7VT/HsYhZcejZpZcW4ACcS8647hXVPfUjx7GI2L9uMNcGKzqDD4/CQXpgeVtwAzl4HphgTOTOK8bg8wJBPlEixoqhgcPppe7OKmCQLcSdOINFqxB9QsLt8JE4vwWA2RHSo0grTMZpHJ9LR0Pg2oinv/WRfI+/BeszDiaYHx6+8o2wbTaHvx0hkZEufXscxN5wZSgqjoAYUZFeAtMI8VEUJLzPHmajZOOSwFc0rPuANUPffrdgyYrGmWZHz4tGbdCg6CV3zAHUf1WIwWVBVNSKW3efx4XMPzXv6W7sgNSkob+ha+dx+vnPrdUDQzDx8gNvn9BHT1I/aaKd2W1vYgcwSL+NztPLBw+9RvmAKGcV5OPsDyDrobe/E7+7G7o1H8fXTVltHVmk2tZtqqDh6ErvWVIXD1QCmnzSD8+68jC0fNA67LwIhQaieCaqqUHFMqK6COnT/Bp3OnH0OEtITMJgN6I0SeqOM3xvAnBkbobx9e1rY9O4GiucUU/V5VcQ1liIzwhLwKaTmZTDnrFMY6O7k4ydfCyecAahdU83kj2oQsowx3oTHKCPrJQqmpbP25Xfw+/zs2VJHRlEGiVlJWGLNbP9kG1nlR9K7oRXj8YUoAYWknBRMVlP4XHpagqHBiZmJ+LyRc9Y+j49L/vtzPAk29JKg5pn3+Pj+V7Cl2dj6r1fIP2YWDet78Th99Hc5UY0yxnk5WIw6EqwGXHqZigWTaKps4rjLjmPSsZOZctyUkY+bxn7gGvDI2z7dk+DodetjbCZfxfy8HrPVqJUEPUzRlPd+kliay3Wf/T2kAYfUoBr6KgnBwunZEdso/gAb3ng52E4NvtHzJuWz+IjciHZ9Dg/qyn8wfIhr1kl4kILlRkNrUuKMnPjwWUMbCqLnbR2DkS1bPIKcCxZFLPN8UANEjuDMVgOSvBIlMPR7H8xHMojfq+D3Bujc00vnnl5YHZzrzy5NpnbQMStarXMizc9rH3ub6bdfgqoOjXRNVhNej8RAjxubMGJx+UASSE39+Hrd9PS4aK0eklnWBfh46fO47EGz+NaPNuJzuagMmf6TspOJT44jb9pkGnfuonpNZdhk7Ha4KZxeSOvuVrqauvj+wz/imCuORwkovP1/GyPk1ht1+Dz+8Llt+zgy9joxKynie3tdG0WziqnfVovRYsKalIi9uR1ndx/99W2o/gC1n2wJj6ZHIlDwu1swWDJRFAlzrJGjLjydtjoHYGXRkivpbamhZv1WEtJsCElQs2oV5oQSACZfO5OrLpyKyaijZu3nYbnjU+OR9Tr8Hh+nfP8inAN+epv7Saxu5NM/Pk3Tjgayy3JG5X/Pn5yPx+VBCaj0tHRTOL2QP6y+D1WF11fX41NUci5YxLVnHc1zF/yalU9/xLqXVjD/ovMYfAXZYg1IxqAFYWK2Db0sMe3ea7GlxhOXHDkVo7H/fPzfzekb3q/O8HsD4VHDp//bmjN9UVHLMRdOOSglQd1ut7jqqqtyV65cGSuEUO+8886mK6+8snd4m72VBB1k4cKFRQ0NDcZdu3ZtA/j73/+edOedd2anpaX5AJYsWdJ+yy23dEKwDOnGjRtjZs2aNbBs2bL9Kgfa0dEhX3zxxfl79uwxGo1G9bHHHqsdjPMezquvvhr7//7f/8v2+XzS5MmTHc8++2ydXq/n9ddfj73ooosmZGVleSEy/ruzs1O+9NJL8yorK81CCB566KG6RYsWOW688cbMt956yyZJEklJSb6nnnqqbjAb2/6iKe/9RGc24FKjpDELIUujR9VCBOf6hpOWnzZ6hI7APSK5h8mkw+kYORcrkEZkkxLy+B3VRs5CR4t0izbkdw14WXjVmXzy9BuhNLAKSKD6FQY7Mp2NfWHHsOEE/F50ej+qCrkVJRiMAq/bxY5Pt+Pz+MgoyaJ07kR2rgg6c219fRVH3PAdPDExFMybRkpKLoGAHntn0KTd29KP+nY1fe1DoZzhIiMh+lqrw4r7uge+R+ncMj549L2w8u5q7MTr8tDV9BF9odKbaYVpbP9kO12NwftVPKeEWYvncOxVwc6NLMmYYg24+yOM3EOXLUrHxGqLoXvY/S85oiQc3rXxvWBt7sSZeTSt2Ma6l1ZEbFv1eRXzrjkZSa+jp74Nd1sP1WtW0Li9HmuilbwpEyBrMq7+oeM6ej1YE2IBNewcF5sYyzn3nUJMQQJ2GUyhSniX3n0ljt4BBrr62fFZMEw3KTuZ9FIjqqri97jZ+tibNO1ooHTuFCYePYfGnY+Ej5VZnMn6kJNfTnkOPS3dnP2z84P13gWUZcezszF4bV16A3pjMBGP1+VF9fczGOc+MOBjYpKFqmY7K3e2M7csldzyyM6txoHx8X83p695s3JUkha/NyANLj8YCvz222/PSElJ8dXV1W0NBAK0t7eP0i97KwkK8MQTT9hiYmJGWQMWL17cs3Tp0lGpBH/yk5+0OhwO6eGHH04ZuW5f/OIXv8iYMmWK87333tu9YcMG0/e///3clStXRpi5AoEAS5YsKXj33Xcrp0yZ4rnpppsy//GPfyTffPPNnQBjdRqWLFmSc+KJJ9rffvvtGrfbLQYGBiSAO++8s/Vvf/tbM8Bvf/vb1J/97GcZTz/9dPQUiftgn8pbCGEClgPGUPv/qap6pxDiT8BiwAvsBq5SVbX3QIQ4nNiXcXq81uuR9brhq82i5up38uZfX6G3tZess4+BmMiiONESsQhZUHDqTBJn5/Lcd/8KwMePPzG6nRAcfemlDK8AtWfTZla99HH4uznWzOOdz+Bze5H0OnQGHZ317bzyl5fIrchFb9Sz/JePcfRdVyIlJ9HwaTsw4pqNmFturOwkb3IavW0OhKSyOzTqv+ZvSzhhycmoQMO2yEiB/q5+KhZMoq+jj9yK3HDnYZDW3S386MkfRyxLyY6nYUdHVDGiGRVMVlMoLh1AoDfqSC1Ipb12KF1q27pddNWNfn8m5KVRcc1puBQoADreXcXbvw7mPbd32tny4QaOvigFnTGVQGBoHtzZ109bzZDJPybRisvoxS8BatDKIYQgPtXGT174OTdVfD/cdsL8yaRNTgNUNrz4Og2bayieXUL+9CPobvFSOGMiNeuDir70hBlMv+JE0meV0rRsPZIk4egZoHb9brIrcujsGxb3LwTzf3Ier9z0fwBsev8zJh1/OlmzszDMyiQ3OYaWbhdGg4QxSmU9jf3HNeCRN7xfvdeSoBver844YnFZuykmSgKH/eCZZ55Jrqqq2gogyzIja1nD3kuC9vX1SX//+9/THnrooT0XXnjhhPEc88wzz+x//fXXDyi1XmVlpen2229vBZg+fbq7sbHR0NDQoMvJyQnL3dbWpjMYDMpgvvOTTz7Z/oc//CF9UHlHo7u7W/r8889j//e//9UBmEwm1WQyBSCyvKnD4ZC+iOPleEbeHmChqqoDQgg98KkQ4i3gPeB2VVX9Qog/ArcDtx2wJIcJ+7rYUddH0crR5s6jZiKNepC9igCAP6BQ02InxqQnKzlSMavAncfeTt2mWjJKsii+6Hj8AuItBmRZ4PIG0B2dR8uw0XPu/Dws09Jw+hQMqXFc89YfePn6v9K1Z1RyItKLMhiuuGH0dbn2/usRsoRhWNFwr9ND/pR8+jr66GnpwZZuY82fn8UQGwM+BWtiEqoYGl2brEb6OpwR+110zSzMcSYQkFkk8dTPlnL8tSeBECj+AJmzSkmbM5HMmcUEHG42PvZWuPxm9rRC6rdFdoInzi8nbULkuy8mwRxRSjR+ZkZwXl6A4vPTtntSRIUYo8XI+reHkjQVzy6OUNwA/Y3tSARzuvd3DVkR5333VDyh50IFUk46kowXPqVlWCdkzWvLySnPx5oQF14m6yOvd1tNK/Uvf4IlIxGExHb3dCqOnRK+N9c+ciN/POUOvnPf9zCUF4a3cz/txT3gJi41CafdgxCCKccfTc36HZz084tJO3UuibFGOu0emjbsZs/WPXz85If835J/ULGggl1rdnHaX64nZkox/o4ePJ19xCTEIMt6FlxyBt2tCrY5WfT7FbY39DJvYirxFgMaB4dtn+5JGG4qj4bfG5C2fVqXMPOkkgOOAe/s7JQBbrnllswVK1bE5uXleR566KH64YpwJCNLgt5yyy1ZN954Y5vVah3ViXjrrbdsJSUl1sLCQvc//vGPhqKioi9cSGXSpEmu559/3nbSSScNLFu2zNLS0mKsq6szDJc5PT3d7/f7xfLlyy0LFixwPvvsswktLS3hB3TDhg3W0tLS8rS0NN+9997bMGvWLPfOnTuNiYmJ/vPOOy9/+/btlilTpjgefvjhhri4OAXghhtuyHr++eeTYmNjAx9//PH+xcAOY5/KWw1ORA4midaH/lRVVd8d1mwVcO6BCvFNIppejZpxK4rXetRCFdHCzPZyfFVVaep0sK2+B49PwaiTSLGZMIwoUTrv/Pmcddu5HHnefABaupysrR7WmZQFaZPT8A14yDq5hD5FwTksi5gn1srp917PE+f8arQMisJ3bp2PFE5SAmtf+4yVL34UblNyZOmo7eo21lC3uS78vbe1l9S8VLZ8GCymYY4zU7FgGgFfgJyKMvQGmczi0Hxy6NL197gwxwc7BAuvPoHjrjgeETp3WSeTd/5CXN4AKmB2OCi/ZBH2B1/nnJ9fgqoorHhqSEaA028+i5G07u6OyJsuz89BDU2VqLrRc95hB7YQIwvWFM0soretl+ZdzaTmpaKqKgPdwf2nzCzFNeyxUNXIYiEQDE3btTrSYjB54WTK5pbhdXup2VBD0axiVv53yPKx9eXPWHDxMRScvxC/kPDGxnPRe3/GoJMictQnpMUTKM6kt7UDS2IxAL0dXs77w/cwHV1OqLAeAN0NQWuEsy/YoQr4g9XPNj70Gq4BD63VwdoMc86YR0rhZLpb3VhijfR83kj+CUVkJ8doivsg4+h1j6vU50DP+NqNhc/nE21tbfr58+cPPPLII4133XVX2g033JDz8ssv10ZrP7Ik6IoVK8y1tbXGRx99tKGysjLiITj//PN7r7vuum6z2azec889KZdeemnBqlWrqqLtd3/49a9/3bJkyZLcsrKy8rKyMldZWZlTp9NFvIQlSWLp0qU1N998c47X65WOO+64vsHiJPPmzXPs2bNnc3x8vPLss8/Gn3POOUV79uzZ6vf7xY4dOyx/+9vf6hcuXOi46qqrcn75y1+mD5rL77///qb777+/6fbbb0//05/+lHrfffcdUNGScc15CyFkYB1QBDygqurnI5pcDTx7IAIcbthiDGFHs/cfXkNTVWcwljn4j9qNq3ilKjh6C4YNwe9W3MOz3lci9nNN6iVclXwROkMwROrXy35PSkF6pBPbyJCzvTD4xPkDCut3D3WgPX6FqoY+JhUkRrQ/67bzIjoVBv3oznn8gjzMRl1EpbCIY6YnU3HSTPqbOrHEmtEZdAT8AVz9LryufgpnFoXb5k3Ji9g2LtU2rvNq3tVMfGo8fe19uOwu2uuaqd+6B6/LQ1LetFHt3cMroAkRVtyDKMM6SFJCHKmTTRz3z5tRVIgXCpf85zYIpYFFCCrX72b966sJhNKuqoqKo88PpEaVV+jkYPGVYe7gwz/nVuRSO8xjH8BgNlAdiudu39NOWkEaeZPyAZXGd9eQdOpREe1TspNoCdUUBzjpexfzxt+WhkP39CYDij84322ONTNh5gS6GiOtfKqi8Pxvn+XaU+fjHjbOsRh1yMNs//Ubauht7UHWyeRMmouiCGTJwWu/+y8zzz2avMtPwefXo6oqnaH0pebYYPa++q31VCyYRMqkfEouPJ7Xv/83mrfW4fcJHL3B+yQbZCYUJFKRY8Nq1cLADjYxNtO4RqjWhPG1G4u0tDS/yWRSLrvssl6ASy+9tPs///lPcrS20UqCfvLJJ9atW7dasrKyJvv9ftHd3a2bM2dO6erVqyvT09PDvclbbrml4ze/+c2YRVb2h8TERGXQtK0oCjk5OZNLS0tHlQNdtGiRY926dZUAL774Ylx1dbVpcPvBNhdccEHfLbfcktvS0qLLz8/3pqWleRcuXOgIreu5++6700fu96qrruo+7bTTir9U5a2qagCYJoSwAS8JISapqroVQAjxc4KTkU9F21YIsQRYApCbe+AOKKt3ddDa4xq1vHflFt77/TODgoYV5uBwYDDuNm9yPnct+8Nej7Hu1R1MWjgBo3Xvvf9BE7C738tAV6RM/R32Uc5pil8Z5cg00BtZ8UoX8iqOMC8fwHSIXidTnmNje0NveFlNWz9Gg0SazUJ8TPDcRo7xk+PNpNnMtPUOnY/bryCPkfpY7/bj3dRGWkY2294Znbfflh5ZcENniFSiHz76DonZRfjcgVAomorbqSM5J43OhiFT/ED3ANll2aiKSnpRBn1twfNy9g0Q6cMdpL/LTnudQA0oJGQlYTQZhtLEKireYTWgzQYd3d5A+GLorGZEfmSkgCkxlqdueThiWWJmEpOOPz38XR1xowxmI+6Boes4PASur72P1II0HL0OVEVFkgTbR6R8battC4eoGa0W3HZnMGQvoGCMMbHpjTXkTsolb3IFptgEett9LL75Gt56YClJ2Ul0NXaGC7u4+l3Ieh13vf87/n7FvcF0p4Kwg563dwDihupgD7h9eIZZWGRTUKEG/AFQ+9Dr9Cx/6lV8Hh+fPf4ebTvqmfv77xLT4+bIc46nfstuZH3wteK0O0nJT2XJvdfw5tpGTrv/BtrW7uTje1/g2Esn0tMaDBNrrOpk5sklUe6mxhelYn5ez6f/25qzN9O5ziArFfPze77IcSRJ4vjjj+974403Ys8444z+N998M664uHjUC3uskqC33XZbx2233dYBUFlZaTj99NOLV69eXQmwZ88efV5eng/g6aefthUWFo7yCB/JeEqCdnZ2ylarVTGZTOp9992XPGfOnP7hCnmQpqYmXVZWlt/lcok//elP6bfffnsLQH19vS47O9svSRLLli2zKIpCWlqaX5Ik0tPTvZs2bTJOnTrV8+6778aVlpa6IbK86fPPP2+bMGHCaKU2TvbL21xV1V4hxEfAycBWIcQVwOnA8eoYxYlVVX0IeAhg1qxZB+yTpSgq7iimZq/PT9+wrFVj4ezbd+lYe6eTj5au57irZmIw79uKFLVIyTjnvEciyQfPQWdCZhw7m3oZHoa9o6GPQEAlLqS8R+c9g/JcG112F34F9C4fPrMeh8dPcqwxnP1K8ilIlV3UrqpHCagkpEX3hXH2OSJCpIRBT/nJs1HV4Oh11dsbmLrQSuvOyNzbs79zJts/fh/PwNBcdlxKHEaLkZZdzeH54LQJkUp2kH/f9A/qt9YBcPeqv1A4qzh8rq09TtRQVi9zvxdHXR8mg4xiM+Ax66P2lTxWKyXHTaVq2aaox4uGwWzA5/aSkptCYmZieIQMkD0xO6KQiCRJFE4rpGZjDUKSMMWY8Hv9+DxejBYzPU2drH9zTbh90awinHYnO1fsJLOsAldbsGPQ3erhpOsvom7TZpqrIlOqXvmXa0kvyWLeefPZvbYaIQmKZ5VQs2E3r1/3Z36/6i8kpCeACgN9Tj7c0oIwBJ//9AlZKB4/qqKyfflqAoFAOD+7kCQmTJ9K41NbCPgUsksnopJCbJKJ9OIS3n/4Bc667Vx0shQ0x2Mgbu4UTrs7gTd+8hDHXnYa+dPKmHR0fkTVNY2Dh9lqDExfVNQSzdt8kOmLilq+qLMawL333tt48cUXF/zkJz+Rk5KS/EuXLq2D8ZcEHWu/99xzT+o777xjk2VZtdls/scff7xucN3MmTNLa2pqTC6XS05LS5vyz3/+s+6cc86xj6ck6MaNG03XXHNNgSRJanFxsfupp54K73d4SdBf//rX6e+99168oiji6quvbh8MbfvPf/6T8Nhjj6XKsqyaTCZl6dKlNVIodOf++++vv+SSSwq9Xq/Izc31PPPMM3UAP/nJT7JrampMQgg1Ozvb++ijj+491/ZeGI+3eQrgCyluM7AI+KMQ4mSCDmrHqKrq3OtODgITc2woqkpTtzPCsWu83nrjqdTl6vdQs7GF5FwbM08v2/c+xxlbPbpfM3q78SZtGQ9CCGYVpbC6asgjujDdSkm2bS8SQKzFQIbRwJ5lNeze1ErJBZNQDDpaP6nH0+/BGGukv22A/q6h293b4WbmqfNZ9+anEfta9th7XPbna8Lf44tzmPGLyyPaWPQSrTtXRyxz9HrIqSjm02feCS9LyEhk9/rd4e+SLGGOy2Ew3Dy7NDlU+CTA8ifrhl+I8LmqqorsV9B5/OjaHNSvamRgmCUne0o63hnpYBz9k5gwbxIBuxdrYjzm2BjiUxJJChWO6aqvY9Pvn8Btd+K2OzHHmvG5vQT8AVprWmmtaaVgakF4XyNTsCqKQu2mWk6/6XLsXUP5ygcfmZ7mHcDwacOh5z3gcwNDo+beDgVnX2RH3mS10Li9id62Huq37AlaogIqfq8Pp92J0+5k2cPvcM4dF4GA/97+OCv+9yln3fV9FL9ESs5kZpx2Av19brprerAmmPB7elAVhbiUBDoavIBC1rDwwP4uNxkTcjj/zh+SlJsGQnDijGyWbWrG4fEjTcjhzL9dj2t7O0pAIS0/0kqjcXAZDAMbGeetM8jKwYzzLikp8a5du3aUA9Z4S4IOUlpa6h2M8QZ44IEHmoCmaG0HzdkjGU9J0EWLFjn27NmzNdq64SVB//WvfzUCo0qV/uxnP+v42c9+1jFyOcC8efNc0UqkvvPOO7ujtT8QxjPyzgCeCM17S8Bzqqq+LoSoJhg+9l5Iga5SVfX6gyXYSOItBuaVpdHv8vHuxqZw/ejxetqPYRiIwDUQHF2ufGEbmz/YzWV3n4Quyst8b/scV23vEV8tibHUd7sweoMG2MEYWYEgP/2AoiDo3tqGvLMDn9PHcVfOIN5mHtVmUFIV8Hn8rH99J+vf3hWuS93+US393a6IcpfZpckRyltVVKzJEzjiLD2fv7QsvPzNf7xOydwyjjgnOF9rMoy+jk6fgiHWgLc/UqEZzJHz873tvUyYMSGswFVFJTXfhiQZQAh62gZw9LqJSzJFbDc83O2F3y6jfU8vSkBl0g/m4Pm4LqJt4+ZWEiYmk5IS9MwfdBbv/LgOR72OqScuorPRTky8CUefO6yovAM9bBk2bZBRlBFOrzpI6dzplB11JKqqIsmCXWtGVDsTAllnAVzhYyfnxHPuz4/lP/+vmy0fDDsneeic+traiUsbmlaMSzazfG2oGMgxMymeMwMVmW0f7+Lj/7xB2rB84ztX7iQmPgZHn4NZi+eEjquy/q21OHodDDTb6W4JWifjZmZiMMq4n92C3mrEasmldXsHRkscZqsdRajE5MQh1/UQ8AxaxwStNf28/cAqFt8yH0kSHD8tk89X7KJNNhLIyWTe/EkUZA55yGt8eRxz4ZTWIxaXtW/7tC5hoMettyaYfBXz83sOxoj7UEQrCQqoqroZmB5leVGU5l86sWY9JZlx7Aglfhiv9o6WynMkrmFKxNHr5rGbX6WncSdblq0PKlRJQpIEQhJIssR3H/wh3/np2WEtKIDv5rxKbFJs2OFJiGDSi72RmJPC7m43dEdO5QgBKfEmzEZd1Ljrsehq6OPDfw/lmd7yZhXzL54auW+G+hAtlR2889AaBrojlU5vm4OskmSaqoacnZp2dRGfGhORHEVVFSxxFsrmTWTnimBnMzE/jZqqFmb4FfQ6ibgYAzpZ4B+RhCa2SGbtox8Rn2wjpaCQlMnFBDyRpvSWXc3himPB46mseO5NZp52It2tQzIHAiq2tCR620I+B0KgKiqv//WzsOIuOrmY/oDChKtnkKOTidFJ4Q6XKcVCfZ+bhs6hc3P0DN6TYBufx09csiVciUuMtJhE6SOa4pLpbgmV2pQEOeWFNGyPTDPb2x557c+/YyGSTiJnYk7E8kFPboCksmzKzpsVOnmV7k9qOPMnQWuHOdZCc3XoOkqJxCXHYUtLILMkC6/bi9/rx2AykDd1Gts/aaZus51AQKFk7nRW/u99WnZVkT11CsakGPxGGY9fIeWcClQgzu2ndXtHuAMz8fxJOBJMFJUm46vsoub9ocFF/bZ2Xvj9R5z0vSNQFR//+s5dGGNMWOItzHzv7oNqcdLYO6YYg/JFwsE0Di0OywxrZVk2atr6g441B9Fs7h6IdDT0ulQs8fFjVpsarKU9nP6u/lEJWEa9oITgn+3PhEbYoVG2LNHW66JysFMSkvmDTc2j0qgKgvWORyp0RVHYubyO5U9Hzs9ufL+a4iNzSCtMDG8//HIkZMaNUtzhfZp1mGwm3KESpKqiYjDpQvKp6HV2Nn/wGZ0NHZzx2ytZ8Icl+Ax6fCEl/dbaBhZMSic+xkC6K0CjTDANXYiYORV0/erJYPKUjzdx9cp/EFDh5Dsv5e1f/Sfcrru5m+LZxeFRa8P2Ghp3PsR3fvo9upqCzn+OXg/HXH4Wb/ztCfxeH0KIYEieGqwgBmAqTMAbUHD6AmRXpBFjivRt8EoiQnkPMpj+1Ov24/P4ySxOonlXF9KI9HRqFO2tqkMdR1VRKT/2ePKmlPDpf98GYNKxMyOez9Ijc8IZ9I69+gSyy3PY9F4VLrsXWa9D0n2KyWoh7+TZ9A0+AjpBW50dfyjMyxw77LxUiYLpxXTWt2GKNUWEsiXnT8G+oR0IeYpbg5aHz19ahjk3nuxFxxMQApNewh2ywLSsaIg4v77qLnSzs3D5FZQcK7YcEeEP0rq7m9fu/ZiPn/gvAz0DDPQMYO/QY3U7AW3kraFxIByWyluvkzhuUgY7m/ponzFOL9V9aG8loOB2jI6WMFiSmHXaPOyd3VR9HhlL+0Wy4yQnxoxaJoSIUN5joQKfbW8l1qQnKc5ITWs/JoOM3elDLyC5PJWB1gEGBmORVVj5/FbOum1BOD/6cEyxRo74zkQ+f3loikZv0VN63iT6TTLFMzLZMmwk31Hfhy1FYeM7n1C/rS68PK4wE6esGyoHFmLdrk5iWwZY/fxWLPEmkgoSMOfG486wojhdYWfC0kUz8CnBaIGcE+cg/fbpcJhVa01rhAOcyWrh5O9fitFsRJIdJGXFYbTocQ94Oe1H1/LKn/8PIQnaa3vCpua4rLhghrGQZTdqdbYx7qnbGezAZRQlYokzMuX4Irqaunn/od2UH12B0WwmOT8fnV6H026no24Pg7F+PreTYHqEIK5+L0k5QYe7uBQbSTkZ4XsSn2rl2CtmhNvKOpnS+RW01frY/GFwRFs891is8XqE2RIh41g+GKqqsOOTLXjdwXMon19OQlYWphgrKXmJCFmP3+2itboae89QxyUmNTgX7fYFSIkzIoQfqcNOy55mZFlHwC9ASAinD88HtZhKY9n+n7fZ+PrnJGYmUXH8aeFStb1tLiYffwTLnwp2WCxxFixxFjQ0NA6Mw1J5A8RZDMwpTmFnVzcGkyH8YhqLfc15uweib+/z6rEkFmNOUMmZNBVrRizxUzJYdndw5OwLmYUPBvvTFeh3+egZ8FIfGiU6PX58ARWXUcZwZDa5OonuT/bQurmNsrk5LLx6VjhsPNqVmHZKKWvfrCLgDVB4/AR0ZUnYQ3PfdoNEckkSnVVdCEkBfxuv3vvuqH2seOAV5v1xtNvDQL+Lqjc+RpZtOPvcODe2wMYWio4vxJ06FJZXdvKscB/LpQpmXXwcq5/8gNJFMzj6tgsQisrcQICAx4e/0UX96lbAgyQLOuqHOj0J+TbO+d0SZJMBoYqw2T8uOw6EIDnOREBRaO1y4q3toa/NEewkqODy+jFJAr/HDyosungqjh4Xq17cBiq01vSQVZpMVnkqMUl69EaJ7Z9so2h2BbFpMXhcoDfEsf2TIY/ypKwshD7SK18ImRhbLAuvvDBs+jeYdFzyuxNG5a0PMnTXfG4/PW4/SZ4ADPPSHv6M+9wu9AYXQc8Jf/j30VTZSFMlnPGTBfS2uWiu7kOn97Fn0xp2r9vF9BOnUzi9ELfDg6u1C+ueFhLSUuiRBH5Fxe/zsf6td+lp7iYlN5WsiXlYYgtw9ptJ6Hey8fVgCoju5i7wNxEICAI+HzmTp9DZKDj+mrOp27CJi399KXFJ2qhbQ+NAOWyV9yBlR5Zy09JbuOf8u/fabl+e4WMp70GEECDFkL54Og6fwokP3MSApPLu+kaKMuLITbNiNugOKDZ76BgHvu3IvsmAXyHp6DzmLCoid1J6WK5oV6HL7mZzbRflV89AL0t0+gP4h8VDq0DawgJ6qnez/q2PSC+MHh4293unj1oW6Orls18+Rv3mWuaduxCdeWgOt/qDGnKPGEp2MrKDNfGs+aROzCPj2Om4RrgsiBRIc6q0bW0Lm8QHSTq1BG9AwRdrpanTSVyuDcXrJ7EiFUUn0WkPTgH0DHhxL6uhvSYyxDU130Z7XS8Ap149k5T8BKrXNNHZGDkXb0tL4NQbz+ST/y4fMTUSKU/A70c3IvKwYdt2jrvybPw+QXyqnoGuTmTJx39/sTTsKzHoN1E4cwJ97aN9NsSIRYGAgt/ZgCTLfLR0QzjfQN7kfACKZleQVVaAEAKrzYzHpeBzOljx7Iu4HcFr4uhzUrMhOB/fXNWE7sE3OfbKy8n7Tjn+eCO6ZBszzj+GD/76Eh317XicbhKzgu4v9i4P00+ay4Z3VlKxoIKmyjpq1u9G1smY4nNQAjIBYpl+6ukUz5o46nw0vlz6u+zyh0s/TOhu6dYnZiT6Fl6+sCc2KU4rCXqYctgrb4D5582n9+/f5bEfPxq14AeMY+TdPyqxzijKLp9OX2jezxNQCTrWqlQ29dHe5+LoSWPl/x+fVhZfQPNHO79+v0LmtNRRhx8cfXt9AXbU97KnYyhhjAgEsBh0OL1D19HX0Mq79z3P7tXBjIQx8aNN/giBpTArQsm6K/fwzm0P0d8ZVHqbP1zN9NOzEeqwDF6r21l88xW8/rcnMZgMpNtMePwKshAQk0FsRhK9UV4vKhCXG0/b1tG51QevxOa6oFK2HJuP+7N63GYdbmfk1Ig+Sjx/tPuQNyWNnStHF/8Z9HmQh8fpq6OVt0EKIOsCIekUCqdX0NHoRgk48bsbWfH8B4xFQnoC885bzMgb6avqxNvvDWd+S86KJ+APmqJ7Xxzy/Pe6vegMOkrnzqC/R0JVobGym+TsGD7/YHlYccNox87ErCS8Lh+dH9dhXVyC6nKjN+qZduJ0fG4vQggUVQqdp0J8ehHlRw+wbfmW8D6K5pUj6w0ogQBCgNVmJj41yjOk8aXx+G3/Tn/9/tcyvC5vuJf55M+X5px+w+KWK/941UEJFXv44YcT/vSnP2UoiiIWLVrU9+CDD44Kr3K73eLSSy/N27x5s0UIwV/+8peG008/vR9gzpw5pe3t7XqTyaRAZPz3I488kvCHP/whUwjBxIkTna+99lptVVWV4ayzzpoQCASE3+8XS5Ysaf/pT38aNXRrkKqqKsMVV1yR39XVpbPZbIFnnnmmZsKECb4VK1aYv//97+cNDAzIkiSpt956a8t11103KnHNWNvvTRZFUbjxxhuzXnvttQRJktSrr7664xe/+EV7V1eXfN555xU0NTUZAoGAuOGGG1pvvPHGcTsUfiOUN8DpNyxm2gnT+P1Zv6Nx56hnZp8Oa8k58WEnpGiUnV0+5BwUBbvTx9b1NZTOLUNV1OAoOmSnfvNvrwQzjIUc1EAgpGCCDp1Bx8KrTwSCKUpnFwc90wfnXsWwv+GMdD4f6/Sqmvooz0sY1bat28mGmq6IjGMQvE5GvYTTC2aDjEkJ8NC1f8Ez7AXfvKsZW5qN3rZeSuaUoDfpEZJE8wfriT+yAslsovv91bz9m6fCc9ZCCP6w4s8k5aTS1dDHiue30lTViTXBRMm8fP5y5T9IL0pFZzDw6udDeQuS48xgHyOh0hj3I5pjvq/PjUGFUXuK0jjS6Sy4vvjIXGKTLLz+95WRm4e2jxh5j9ilo7eHypVb6G0behccf80FKIHI0Lax6Gntwe10AZFzxM5OJ+17eqNuM9xhrGVXM9NOnI57oAe9wQJIKAE3nXuasCbEUHJEafB5FYKAP7LzW3LEZBASjl438QGFtXc/xfYPN5E/JT+ch/7IpGQMMXmh40qkFRSw/ZMt5JQXMvHsueScNheEwBRQmZmfSLIWHvaV8vht/05/8Z4XRiVp8bq80uDyL6rAW1tb5TvuuCN73bp1OzIzM/1nn312/iuvvBJ75plnRtTqvu+++5IBqqqqtjc1NelOPPHE4lNOOWXHYOd36dKlNQsWLIjIG7JlyxbjX/7yl4xVq1btTElJCTQ1NekAcnNzfWvXrt05WJGsvLy84vzzz+/dW33sG2+8Mfviiy/uuuGGG7peffXV2B//+MfZL7/8cq3ValWefPLJ2smTJ3vq6ur0s2fPnnjWWWfZk5OTA+PZfm+y3H///UmNjY363bt3b5VlmUH5//SnP6WUlpa6Pvzww+rm5mbdxIkTJ333u9/tNplM40og8o1R3gDZZTlcc++1/PaM34TzPA/icXrCZRCHM6hjDTEGzrr9GFa/tJ01r0U6pmXOzMSVatlrprSAolLjlZlyywW0vLua/uYuKj/ewkB3f0RGrZEYLUaOCytvmYyk6COSkYeWwr2D0PoxZKtusVOWE48sSaNymY9U3IP0OrykxpvotLtxqXDsTWfzzu+ejmhTdEQpnXVtVK0eqg+wa3UV571xN0mxRpa/tioip/dfNt5PWlFm8IsQNFd3kZJrw2DSIcsS2RVDGdMyEsy0hBKoRMtiN8hIT//UXBu9XQ50IlgKb5D41gGmnT8ZU3osqiTC16G+fQDPrEziypLp2lZH+5ZgMpSexi4UnxdZJ/Hcnf+JmM9w23sQooJPn96E3ihj7wy+m9yOIW99ncHMSdefH7onKmrAy9aPhkaiAKo6NFJPzMrk5O9dGDopMKZYMGbEBmum+wP43R5S83MBHYpfpXNbHQPNndjb+0lMj2XaSTOQZBH6k3APeDFZIqMHBH7e+deLQGTlsoKpBdSGqqrlT8mns7GTpKwkssryyJ08G48rQMaERBy9bhwf1iGpQUvF8N/XpvdXM++8dOJTUzFa9EASZ912PV3NLrKLJ+AJBN0kPYDHKEf9HWp8OfR32eXX739tryVBX7//tYxzbju3PTYx9oBjvisrK40FBQWezMxMP8Dxxx9vf/755xNGKu/t27ebFy5caAfIysryx8XFBZYvX2457rjjxkz09cADD6Rcd9117SkpKYHB7SBYanOwjcvlEso4woF37dplPvXUUxsATj/99P6LL764CGCw5CdAfn6+LzEx0d/S0qIbqbzH2n5vsjzyyCOpzzzzTM1gB2VQfiEE/f39sqIo2O12KT4+3q/X68edhfQbpbwBZp4yi9999Ad+dcqdEckyelq6x1Tc4e9CcMTZFeSUp/LiPctBhZjUGGKOzMYzhqIbiZxkI/uioDIuuepU3rz2T/S1j+1BPt4sbSM5floWiqIOKTBVxekJ8Mb9r9EVqu4kQlW9BoovJC4pMtmLWZIwtfQTsJnwmnThaxNn1uFXVNr7hsaouYtmYrjvBbzO4PN9xQt3Yky28dAxN4fbxKbaOObms4k16ejq91B8/HTySjL59L/LuXvVX8iuGAp3M8caUBWVjvpeALqa+ph2Skk4RWZCrDGsvAkoyN4AUqgjoOgkAgKQBJIkSMqKRdLJGE06Gis7ScyKw+EJRIyom9Y1k55iJTXXhinOFL5e66s78BtkSDRj7+9h+dNvAWBLt9Hb2kvx7GI+/k9krof41HhUkU7D9m4AdCYdFzxyC3qjHmtiCqjgbemnenldeJvEjMikMwaTIcK/IS45NRwznVaUiGFhQcSzmhJnpMM+1B1xbR3gw8dfBmD6yTO4+A/nROx/83u7cDsjk/JIsiC1IJOOuhbcA0P3dniceozNSt3mOgYYID41BXtXsF1vhwN7hwMloJJdPoP8KeVsePvDIXnsTja89R4nfe/KiJwAAIERRW067G4MOpmU+PFZHTS+GB8u/TBhuKk8Gl6XV1q29MOEM24684BjwMvLyz27d+82VVZWGgoLC72vvvpqgs/nG9VDmzp1qvO1116zXXfddd27d+82bN261bJnzx4D4AS49tpr8yVJYvHixT1//OMfWyRJorq62ggwY8aMskAgwC9/+cvmc8891w5QXV2tP/XUU4sbGhqMd9xxR+PeRt0AEydOdD799NMJv/zlL9uffPJJm8PhkFpbW+XhxU+WLVtm8fl8ory8fNRc6t62H0uWhoYG45NPPpnwxhtvJCQmJvofeOCB+smTJ3t++tOftp988slFaWlpUxwOh/zYY4/VyPuRJvsbp7wByo8q54ZHb+T9x95j60fBEBmjZahi0aDSHkttZpalcO3fTuf5339E9jnl9I9TcY9EToxn5oXH8eHfXx6zzXh6i1H3LUvo5MhziNPJ7HhzdThRyiApiTGcd+fF4e8Bv8I7/1xFw/agkk/KjSdpWgaeNAuyLGEfEdfu0hs47pZzeOe3T3PMDWcSSEvGBVz54p3oE+JQTEaEJHD7FPpDP4Gc7yzg5Fk5XPibS0nJT4vYX2xyDAaTDq87aKJ1O3x0NfSF49CHO8s1vrid7iZ7hFOayWqIcDDMKkkKK7/uJjvxG1px2d0MlnoTwLbltbgdXqaeGCxr6fUrDL+t1vRhCnYvt6RiwcwIxSrpJPRlwfSng54DJudI58fId1iMLYbAsDoRfl8gnBLVmhOPb0Qnc1Ry3WEdPjlUNS3gDwT/vH4+fOxNdKZMhtdUVwIqJXMmo9MFpz3C8kccKyLvcPij1+UjOTue9j29uPpdtO5aB6iUHFFC1edVoTYelIA3nAPA6/YjJNAbZAIBJRzbr5Ml4mO+UPVJjf2gu6V7XBd7vO3GIiUlJXDfffftOe+88wolSWL27NkDdXV1o8rE3XjjjZ07duwwT548uTwrK8szY8aMAZ0u+Mw8++yzNQUFBb6enh7p9NNPn/DPf/4z6Yc//GFXIBAQu3fvNq5cubKytrZWf8wxx5Qde+yx25KTkwNFRUW+qqqq7XV1dfrFixcXXXrppT17qyF+//33Ny5ZsiR34sSJyUceeWR/amqqT68fOvU9e/bor7rqqsJHH320Npoi3dv2Y8ni9XqFyWRSt27duuOJJ56wXXnllfnr1q2rfPnll+MnTZrkWrlyZdX27duNJ510UsmJJ564LVpxlGh8Y9MbzT9vPne99SvuePMuTDEmbGk2YOxQqZGYYo1c+rsTsXzBMoWJkwv3uv5AR94Q/TyiOa7ZOyJH/ts/qgkrboCu+j6qXt1J+7PbcNdGLy5Ucvpcpp07n5ILF4aPrc9Ow6U34AmoGEeU3vQrKpJglOKGoLk7JTc+Ytmq/w0lDhk05xv7PXTW943yJh+dbS7yu6fXRWtVF61VnbRWdiLrJJqrutAbddRvbsXR7WTrrk4Mbj9Ghw9Tnwd355B1b7BDVbdlDyZr5AjRHB95PiNN9wCyopJdmkx2STJZJcmYR1Spm3TcDJTA0PVqrekhqyTo6xBwj37vjDzCcKeygC9Ad1MXn7/4Gb846lYevO5+Vjz/Ad6B0c51Sbl5yDqZmPiYoTn6YTsf/ugMv8aJ6bHhuXVZ6qdy5XaaKpvoauyibG4ZaQVpDPQM0FJVjdftx+v2Y4oxkJqXQNXHdXT9bzuG6m6Mdi8GSYyqLa/x5ZGYkTiuUp/jbbc3Lr744r7Nmzfv3Lhx487S0lL3hAkTRo1c9Xo9jz76aMPOnTu3f/DBB7vtdrtu4sSJboCCggIfQEJCgnLBBRd0r169OgYgIyPDu3jx4l6j0aiWlZV5CwsL3du2bYt4Mefn5/tKS0td77///l7zSefn5/vefffd3Tt27Nj+17/+tQkgKSkpANDd3S2dcsopRXfccUfT8ccfHzUv+t62H0uWtLQ078UXX9wDcNlll/VWVVWZAZ544omk8847r0eSJCZNmuTJycnxbNq0adwmqW/kyHs4U46bwv9V/YvdOxoJKGpEreJ9ISRBmqufPTsaME0s2PcGISakx5KbGioYMTmDioJEHvnhgzQdgCPdfhNlh8m5KcNWq9TuaI+6qcvuoX1lI9bFJeHRpdkgYzLI9Ax4WfCLy+geNuINDB8BRjuPYU53I1en5CbQVDVkpWup7qJ+Syu5k9Px+hVUVcW+OnqZ2+H5vaOuH5H1TAl1Bj58PJhoJndyKp0NdpyhrHEZ09KJy0vhgoeD0wDv3rUUAJ/bS9KEdNQUFVt6ArIshTtHqqpCoJ2A24ChJpueys5wxryASUdT5ZD52JYaacKec/p0utt07N4wVJ+hsbKT7NJkOnZ0kDg5da9zwsM7fBveWc8Pi68jLjmO7uZu6kLz19Gc+Qa6umnYMZQdTdbJNO9q4ayfXovPp0PWCWITbdg7uzGYjai+FnRGI+17Boi1mUC2oPgt6E3BqmldTV10NXVhMIcq1YmgP0FihpXulgHMzuByR6+b6g+C4WczCo4d87w0Dj4LL1/Y8+TPl+bszXRuMBuU4y5fGL3Xvh8Mls7s6OiQH3nkkdTnnntuVBGO/v5+SVVV4uLilJdeeilOlmV15syZbp/PR2dnpy4jI8Pv8XjEm2++Gb9w4cJ+gLPPPrv36aefTvzRj37U1dLSoqutrTWVlpZ6du/erU9LS/NbrVa1o6NDXrt2rfWnP/1pG4xdErSlpUWXmprql2WZX/ziFxkXXXRRJwS94E877bSiCy+8sOvqq68e81qMtf3eZDnllFN633rrrdjS0tKuN998MzYvL88DkJWV5X333XfjTj755IGGhgZdTU2NqaysbO8xy8P4xitvgKTMJCzJ8XywsQmrWU9yvImkWBPxVsMIs2EkWz/YxJ/O/T0ep4eTf3kJiYvm7PU4x03JwDpYWnLYfiuOncKxly3kqZ8vHbWNEji4YZbROgOrXljBCd89BUt8DC3dTpidxcSiJHY8N7qgTk9LP8lOP16TTJzTT3+cAVco5Wb3gJdEq4F+lw9fQMWol8OjZPv6ZiRvAFGRQkAvYzYMvSsGk8MMfgZIHjHy9vsU5NBo0OcPYO7z0LB79BRcdmkyXc0RPjDhS52QZkVnlLF3R/q+6EcUl3H1ebDazGHlHT8/F+ew4isG65CyFULQWtsarq9tS09HZ85BCJXlz7yNNcGK3xvpzZ9ZFDnHPXJmpGLBJFprByKUd7CdiqPXTW5jP2pRIia9TPeAJ4rZPHKHfq8/rEAHmXLNyegMJlRFxR1nJDDgYu1vHsdoMeIJ+S4E/AEmHTub7lYfquoLy7rjs+C0S+G0Quq31+MPhQ2e9qPLcPTpmXveRej0EgazHlXpofKzNehNBgZ6uzCaXEhSMO47xmaip20AFRVJ7ULWGXDZHUAKGl8NsUlxgdNvWNwSzdt8kNNvWNzyRZzVBrn++utztm/fbgG47bbbmgedwIaXBG1ubtaddNJJJZIkqenp6b6nn366FsDlckmLFi0q9vl8QlEUcfTRR9tvueWWDoCzzz7b/vbbb8dNmDChQpZl9de//nVDenp64KWXXoq57bbbsoUQqKrKD3/4w9Y5c+a4IOgYF60k6Ntvvx171113ZQkhOOKII/off/zxeoDHHnssYc2aNdaenh7d008/nRxaVjtv3jzXTTfdlDl79mzHJZdc0jfW9ps3bzaPJcuvf/3r1nPPPbfgn//8Z5rFYlEefvjhOoDf/e53LZdcckl+SUlJuaqq4q677mrMyMgY0+Q/EjGealsHi1mzZqlr1679yo43kuXbWmntHeYVLAezbQ3+xVr04RHPp09/xD+v+XtE3PhRV55A/pWnIcYw+50wPQtzlCpkij/AdVlX0N9lj7IVPOd/9YDOZ1g0WhivOxT3q4Lf40PWy6gKGGMMSDodG3d3Ud8xgF6W6H6zirQZmehTLLjr+9j9/m4Un0LR3Bxadnbi6HFReMU0/KbIc0qOM9Jp95AcZwonPDFU91D9wW4kWaAzyMg6mYt/dwLm2KB1y+fx8eGj79C0o5FZPzoHd0CltdcV6ugEz+Ho8jTiY018tKkZd6eD6v9sRsiCSVfPZMvDwecmqySZgV4nAb9Cal4CR50/hbqmPvrcPlRFRVVUti3dwLB04hTOyCS7NJldaxoxmvTUbW2LmHMv/cEcXMMmwNf+6t/sfC84Ss8syYqoj63T61hwyalseOdTelq6iU2MZfppZ0dcn8yiJJqrhzoeVpuJN+//FwBpBWk8XPMolasbee0fkWFnZUfmUPl5A6l5Nk64ZT5ur5/VuzrD19uolyjNjGfLS5/ibu1m1UsradjRgMFsIHdyPk07G8Nz35cs+yvKsN+2c0s1L37vb6QXpqMoKl2NnRTPmUTpUXPpCWV40xu8fPDoMwDIehklZAEZZM4Zx2CMC4aEDf5OdHofK557EfeAm4SMBHpaejjy7GMxxOSRMSGR5uouHF1VrH9rFQAnXHMiNzzyIzT2DyHEOlVVZw1ftmnTprqpU6d2jrXNcKLFeRvMBuVgxnkfSsyfP7/4m1JZbNOmTclTp07NH7n8WzHyHiQryRKhvP0BldYeF60hz2aDTiIpzkigo5e/X37vqO0/e/w9uuvamH77ZUgx0aYmoneEAv4A8l5TqI5UweNDHfE/gN40NAIzRpGxqz+obH0BhdiTigiPUXPjmfbDI+jf3sGud8KlbGl7ZSfpi0vxWYJOGYLgCDHJamS49VqYgh0aJaDidfkBP8v+vY4Fl09jzYuf8vxv/ktnQ/A9E3vEJIxFOUOyq8HRc4wlKLvXFyAu0cLk784CFfoETF4SfG/lZcWRl22LmGuWXV562/wMCjRpyWya3tnFpOOLKJmSjqPHRSCgsPyZzQCkFybicXjxuoMuZnqHD5dxqEN21M3nhpV36RGlWGLNVK8LXhO/z0/thi30tAS9zU1WU7jKmiXOSF5FGlOOLWDVqztore0hJt6Ea8DDlfdcxdo31pCSF8wol1mUFFGdTJIFcUkW9CYdCy+fwUCPi/YuB6U2M7ZUC6WZ8Zj0MlazjsCsIj56/H3ypxbQsKOBy577JWpyAt4I34DIZ7F1VTBcsbWmlYJphcw680wGuj1hxQ3gc/WGP5ceWRaR4hVg/dsrKJrVQd3mGopmlZFcMAmfV0dmcTY1G6qRQg4+Pc1tZJVn0dflwN1XE1bcAPbO6B1YjS+XK/94Ves5t53bvmxYhrXjLl/YczBG3Ici3xTFvTf2qbyFECZgOcHa3Trgf6qq3imESASeBfKBOuB8VVW/8LzJl0lBWiyNnQ7a+qIn/fD6FVq6XZj9Y1sjdny0mZ6m+zj2j99Flxo0j8aZ9cTHGJCl6Ap6z64WKs6YS8AfiCgVCoAQdPS6EQLcnX107w6ZUlV1aH6V4DyuJAnSizNJzkuNepx9Ud/Wj0kv44jiFGU2yHQ6fZBvY/K1M9ny2DpQgvOVHW9XM+GcchSLHrvLF573ThzmiBXNcatmQwvNu9p5/6HHI2K+O9dXklUUWepSZcjk7/YrxJj19Hn84T7NYIKczc12klOsWIdlRnN6Is/HpxOknFpCv1mPKdaIKdZIwK9giTPitHvoqO8lId1Kar6N5Knp9JtkEmMM4fPyxMWy+PdXk5Vl49TLgw56r9z3Mv/+yWMoikLtploS0hPoae0hKTuZM354JLJeR1JmbHhEml2WQsCvIEmC3nYHiRmxnH3rOXicwWcvNtHM2T8+mid+9g5ZJcks/sFcPC4fM04sIuBXSTTpKCqINL8PUjG3jKKp+ax9cy1KQEFOTgBZwmrWoddJdPS5R1U3q/lsSBGnFWTS11oT6jQFS90aLAl4HcHraE20ojfqmXTMJCCYJKapsonk7CR2rgjWC9/60UZMa3eSVZJDzYZgx2bQCa5y1Q4qV+1g7jnHsua1TyPk2PDOejS+HmITY5UvEg6mcWixT7O5CL6NYlRVHRBC6IFPgRuBs4FuVVXvFkL8PyBBVdXb9ravr9tsDuDxBXh1Tf1eHcXMHjcPH3/rXvcTk2Dl5HuWYJ5YwMIpmVgtY0darNzRRscYHYbhSC3tLD3vN3tt88u3f8XkRdP3ua9ofLK1hZ4Bb9gMO5ykWCNdw1LE6qp7qPkg6G9SdnY5zpTRFaB6P1xD584GHF19pGRn4vcmjWoD0FL5ObtWDyW+KZg+gaPuvyn8XVVUJFVFXdWE3+snoKjEpFrxT47eSSnLjqck2xb+vn1PD9UtwRGdAOJjDPQ6vKTZzMwuTQn7NTjtbt78+0pad3eHt518/Wz6Qg9DcpwRWZJwuH2YDTqOqUiP8Loe6B1g8web+NcPH6RiQQV9HXZ+/sovsMTuX3UsVVHpbu2nq8lOcnY8CenWL5S0xO70srOpj+ykGLbV99Dj8KKqKuYuF0iC3tpG/nfj38Pti2YVUb22etR+Ko6uYOeqnSRlJtG+J9KpsfzoCoCI0bhOr4uYVkorTKetZsgCWzxnIh5nMIWqx+mmdXfQYfOJtqdJSNWyrO0PY5jNayZPntwjSdJXN/ep8ZWiKIrYsmVLwtSpU0eFLe1z5K0GtftgCKs+9KcCZwLHhpY/AXwE7FV5HwoY9TJmg27UaC2Sfb9IHT0DvHT9XznlzssQU884eALug5Ge1LB3aQd/1S6Pn57QyLLT7olQ1sPnrgex5MSBBGVnlWPIjcckifDI1KiTcA84WX7/K9g7+iibW4ajux+LzYbX0YoQAr05jUBARtb5iUuyRuy7dsNupq7Zhik1iZjEBDqW1eG2ewj4A/iCCeOJ7XFjm5QSVanVtfYTa9aHs9GZDTLxFj0Od4AFk9OQJYn69gGqW+wEAioDHh9ef4DkeDPFs7PobrLjdfvRW/QMCDDrZWJM+mBhj0CAAbef1HhThOJWVZWNH9RhTUjne//6GUeeceCFNYQkSMqMI+kgpQmNsxiYVZSM3ellRmESu9vs1LX0U/VCcJTsczVFtG+uakaSpbA1xGgxojPokA06imeXjMoTAICqYu+0k1mcGY4TH9nxzyzKICkzMRhGaNCTOmE6XnewTWpuLPbONhq2VbN7fQuzTtaU90Fga0dHR3lKSkqfpsC/eSiKIjo6OuKB0Z7FjHPOWwghA+uAIuABVVU/F0KkqaraAqCqaosQ4sBsuV8xqqri2qviZtzTz0pA4Y07nqAwP4mjLz5m/BseAPdu+geZZdlRK4+NzMQd7XtrT2TYYle/h3iLHue6ZvrybTCiQIfBZmLi9+fg8Ck4nT6yky3MKU1Fr5OC4VABhZxHfsTdZ/4GWa9j/Vsr8bk/Dm9vtBiZdfrRbH53HZb40SPTl29+kAWXnArSkOdxVkkSbXt68XsCzDytlKIZ2RHbqIA/pHDiQvPjAijIiKMgPRZFHYpPLs22oZcFn1e2Y3d6CQRUJubYCBQmUL5kFkqfB9Wswy0LYow6Ou1upOCMBqY+N9vfr2FPgpn800ow9HqoW1lP9YZm8ielM//cSaiqigLBAiqHAJIQ2GKM+PwKsWYDhelxDEZ6J+dkExMfgzneEvRUVwXFR5Sw5cPN2FJt/LPyQfRGPbJOpqmyiUdueogN726I2L+qquGaAWXzyqhcWRmhvMvnl4e3qVgwic0fbmJh3iQGXzGSTo/baSGlYApVa5qYdXLpl35Nvun4/f5rW1tbH2ltbZ3ENzhnx7cYBdjq9/uvjbZyXMpbVdUAME0IYQNeEkJMGu/RhRBLgCUAubm5+2j95SOEwGyQcXoPXojW/Zffi72th9Nu+s4Xq+u5F5Jzk0eUnRwfKlDbYmfLnl6SY410DprGAwoDnzdRu6KemM1tpJ9Zhi/kVR5n0dPt8jE8f0xT2wAFFiMJodGiLEtkTwzOWw909+MbUU/d4/Tw2XPvA9Db1kPZvImjRnSqoiKGnVJTVReyXuLMG+eROy1jr8l0hjvrCUAVIrLGiACnN0B36HyN+uBcsMkgkZcdjyvZz86mPvCpGHTBDoEkJHQ68O3po313N9Y0K4HWfvS1vWRPTGHRd+egkwWyEARU8KsqksQXMnkfbPQ6ibKseLbUDE1t9nWqTD3pCFY8N5TStKupk/TCdOadexRmqzl8DjkTc7jr7V+z/L/LefTmh+lt6wWISJSzc8VOKhZMore9FzWg0Lyrmfi0FHLK84lLtrJteXCgoA67Lq013WQWJdJc3U3zri76u13EJkbGv2vsHzNnzmwHvjqzn8YhxX55m6uq2iuE+Ag4GWgTQmSERt0ZQNTMH6qqPgQ8BME57y8o70GhKCOOzXv24lt3AO/iJ279N0JInH7TmXvLrnlAmGPNGK17f9GNlTkuqLiD59rZ7yEhNB9s6XSyY0VwbOboddP2eiWpi0sxxBpxewMRiltVVdS1LbzxWhUnLplNSkFCMCFHKN64fls91gQrAz0Do44/SFZZFrf89zZkg4wkS0iShKzTUb2miQ+fGBrlpeTEM2F6Bt6D8KTEmfVYjMEpErNBpiM0NTAxNxFDkkRrr4teh5dYs47jpgaLpgQCCp7CFGpXNjDQNkC+J4C9wEb9zk4kRaVi4YSIEKwDixP4chFCUJQaS+3sLHatCZrM1WGhcLJO5tTvn8oFv7yQmITR8+1CCI656BgKpxXyw4rvo6oqOkPkq6J63S4e7/wvNWt38fxvX8QYW0DZ0cXI0gBCMlK9ZjuDJWD0JhmjWR+srBdioEdT3hoaX4R9DuWEECmhETdCCDOwCNgJvApcEWp2BfDKlyTjQac0K554i2EvLfbvdTxl4RQW33gGkxdUYJAlDJJAJwR6KfiXlWghOc5ISWYcCda9HTc6MfEx+xzdjdR1Ab9C9e5Otu/qhGGe3j0OL2k2E+70WNImDaX6HOhy4f28CeHyjao2Zqrto2FjC71tAzz/22Ws+G8w5Cp1Qgazz5hDRnEmRbOKw3m2R5Kan8Ynz3xCXFo8tpR4YhJiMcfHYIgxEpcSWUXNaNYz6OwvEawvIg/7G8+dEaG/oow4JuXaSI0zRtTormu109PvZn5FGpKAyflJdPUFQ6ZkWcJiM3HhnQuRZMHWpRsw6yRqP67j81d3sOLZzfR1Bqcg9PuRre+rxu8JMP34YLIUnW6A2k2VlB9dwbxz5vHA9n9y3d++S1xyPHsrhJAzMYejL1wAQGtNZEKZYy49DlkvUzy3jHnnn4wSUPE4fTgHjCTmTOLkH1yOkGWyS5NR/CoDPW66mvrRhZL31G39xoUWa2h8pYxn5J0BPBGa95aA51RVfV0IsRJ4TghxDVAPnPclynlQEUKQnWShb1QBif3fz33r/0bhtEhHQGmECbckM56SzGBGsV6Hh/c2No8rv/ogcSnjd+5RgYZdHbz/wGocIQ/3xOw4rKcUgyRIjjXS1udGVSHumDxkg0TXzk6Ss+Np3NGBpbmfzMUleGOCnQxTt4uq94c8k1UVNi+roeK4QmzpsaTkpbLm1dU0VzWRUZSBJEs0VUY6SPW0dHPlPVchqaCXgo5Sg+cv64eUR1pBAgG/Qlt1F9klyVE7LINzzQFVZW9p4Q1SMFVpZoKF3GQrvQ4v728OOlpVNduparYTa9Jhs+hZsaONfpePWcXJZIac4JLzE7jyz6fQ7/axuq6H7DlZNK5uYv3bu7B3OJh3ziSS0q1Ih2ie7hibiZ7WfuadVYK7v5NFV85m0oJxz3aF+f6DPyA1P5WdK3bQ1Thkik8ZlnI3WpbC7hY3CWmx4YIxAI4+N7a0GHrbHGz6YBdHnjHxkJpy0NA4nBiPt/lmYFRskqqqXcDxX4ZQXwUTc2wMuH3s6YiSf36c75P5588fpbj3hS3GyLGTM/h0exu+QOQIt2RKHv+seST4MpQkJCEQEmzc1cGayvZwLPSgo5BRL+MLKMF2Iug8NSEzjroeV1hxA3Q32sl2+nDbTENz3oDHr2DNiqN9a3u4lKOzz83sklRsmcH8/h21PezWSQSGpQ8N+BRWvLOLnKPzwnOiAC3VwdHZxKPKMVisxCUn8ckzb+Hz+EjKSsJk1KOoQxHIPo8fR7eL8qPymH1aKSnZkSlToyGEQCZ4rqqqElCJ2CcEOzAKUNXYS2uPiyn5icSZdUzOSwhPIUgCjAYdPQOecI72tbs6mRZQyE0NnrvFZsasmpAbeombmUnj6iZkncTMk0pIyYrD5w0gH6JpjmSdRN6kNPImjS4Msz9Y4ixc/vsruCbvqojlHoeH9a+tpvTocsQYueY9rtG1Ljpqt9Hf1cealytZcEEx5UeVfyH5NDS+rRyir54vH0kIZhenkBJvprKpj/6IF834tPfim848oGOnxJnIT7VS3zmAZ5hStCVaSU4Y7ZmttrmH6lsPw2rSMTAi4Up9p4P4KObcLc9sYcIxBYgJNtSQ45vsC7Dngxr8I5z3ErPjwiOi9KIkLrxzIU/94v3w+uSyZNSJydS2D+A3jq66tuOz7Zz8g+tw2r2c94vv4fOoNO8O4PcGkPUSgQEPWz6uwxxrZMK0dCYdlbe3yzUmQgh0ofyqwxPaiNC6grRYOu1uGjsdTC1IJDsphpQ4E629Lrr6PbT1jr6mG2u6kSRBdnIwvE0WgnmlqVTXBmPDA36Ftx5azWnfO4Ks4uQDkvtwZMbJM3nnobfD31f87zP+9/vnEEKQP6WQwllzUBQDeqOBQCCAzx3AmmAmISOW7mY7rv6glatlVz11m4PFU1796yua8tbQOEC+1eEFkhAUpsVy3KQM9nf6UpIlcibm7LvhGEwvTGLx7FxiTUMhWqNLXe6d/TG9q4pKx7Z24ocdz7+hFY8zcnSUkDHagSkhK57jr54Z/p4xPy88Wi1bPC+irc6gZ/HNV+K0B1/Wks5Ed6uLrmY79i4n9k4nVWuamLpwAlOPK8QapbNyIAxW9JJC/wOY9DJHl6czNZSpLNasJznOxKTcBArTxq4cuL66i+auoEVGAWxxJuZOzeRHD5/FhOmZ2DudvPiXTxnoceHbV9jhN4TvP/gDrvrT1QBklWaH872rqkrtpt188Ogz+JytuB1eYhMswQppDX00VXZiMOnDUQU5FSXhNKrVa2vo745aeVFDQ2MffGtH3sMxGWQWTs5kfU0X3QOecQ28L7rrYmLiY/bdcC9IQjCnJJmVO9txegPEx+y/M9v+cO7PjsEcb4KQ6f3JUBKPQXRGGbPVSHttD6kFkZWyJs7PY/17u8g+rTSckQxAyUxlzuWL2PrKKsyxMcw45Wj6OofWD/S4kGSBx+Wjra4bi83E9EVFX+p57guvX6HX4aEix4YsC9p6XKNS5nb2ucPz3xDsWMlGHXNOL8Xn8dO+p4cHb3yd5Ow4jjyznNgEc7gm9zcRIQTf+fFZNFU1svWjqDkjCAQCSEB3Sz/dLUOV3/o6HGSXJYMKbmc8xXNaqFy5mfSiXNpqe4lN/GK/Iw2NbyPf6pH3cBJjjSyamskZs3PJj9WjN46d7hQgoyjjoBw3KdbECdOyKM+OR7+/zk9jDL2FTsKSHBmGc9KS2UHFDcEqXpLg/DsXhucr45IsxMSZaN7Vxdv/XIVrIDJ9auOeHpLPKItQ3INMvOZUFl13GRXHnYzHE/ki7u92kVmUxClL5uC0e0lIHXvE+1WhkwUen4KQBI2dTkqy4slKCloAspMsnDcvn+kFiWFvcjHsQmcVJ3P+/zuGYy+eRlq+jc5GO68/sIqX//pZRP72byJCCC773RUYLaOnSoQk7dUU1FTVSU9rP50NfZTNP4LFN19B4fSprH9vdJpWDQ2NfaMp7xGYDDKTpxdwx5t3ceJ1JxFjGz0q+NFjN3LUefMP2jGNepny3IR9NxzBWO9KYZBJPbeCyd+dRcb0DHInp1F8ZKSJX1FUdrT2M+mqGSRlx+Fx+ugLOe/ZO528/9AalJBpXADZ+YnkpVlHHgrF62PDH57G0dMdVajEjFiOuWAyRrOe6YsmEJd0cMzkXwRJCGYVJTMxK555ZakYdBLxZgMGnUR5TjCGXa+Twz8On3+0Up50dD7n3rqAhDQrmUVJuAa8LHt601d7Il8D8SnxfPeB7/GdH5/FrFOHUm2fcfNV6C1jloxGVYKRBXFJFnpavfR1Qnerh/rt7bTWHtL1jDQ0Dkk0s/kYTF04lakLpzLr1Fncd9m9uB1uVFXlmEuOZdFVJxz040lC4LW72b5iD0pADYZTBVQCAQVjaSLJoVjl4X7VkhBYjKNH6zpJQlGhD9DPySLdZg6mDg1NB/gDCut2ddDW6ybOINPb4SDgiXRa63f6qNrTTWl+YjhrXFlOAnqdxLY9vQC4d9bxye+foq2mlRkny1hTykbJMuW4QlLyEtDpD72QKiEEFqMOi1FHotVIRa4tYr5fCIFBAtMYVhhzrJEzbzqKHSv2YDDpKDviwH0gDifKjyqn/KjyYN3wpItw2p3oYvVIPQqKbwzrgwhOoaTm2rB3OSNWrX59B6csmYPeqL2ONDTGyz6rih1MDoWqYgeCz+Nj9Wufs+Gd9Vz+hyuIS953SNOB0Nvh4JEfvzlqecGV0wlEUdJmg4wrSprXRKsxOHc/jPxUK1MKk/D4AqyubKdnwIssCVqe2YK7N3K+N2tWJqY5WfgCKslxRuaVp0esr9nTyct3PMmqp5aFlyWkJzDtlFMJ+IdewAaTjuvuPQ3zASSmOVzoqO/FaDFgiTcekh2UL5s1m+ppcQZwK2DWSfR9XEdvbU8wC50CPq8fIQSxCWb6QrXLs0qSw6GJEOwbnvOTo8mfnD7WYb71RKsqpvHtRuvqjgO9Uc9R587nqHMPnqk8GrEJZnImptCwoyNiuRBfvINV1z5AjElHfccA/a6gh3RAUSm+cDJbHlzDlOMnkFWSTNXuLgKFNnyhXNaddg8tXY5wBS8AZ3VThOKGYM3nZf9+iuOvuRCf10hqno3FP5z7jVbcAMnZ8VFrmX9bmD4pm54tLbgdXlx+hYyTizm3YkgJ/+t7r+Bz+8OKGxg18lZV2LGynsziZAwm7ZWkoTEetDnvQwhZJ7Hg/CmjV4yhu9UxZ72jL99e38tIV/o+VeXMO45jwSVTmTAnm5MumEJuqjXKdkO4HaPjowfZ9N4HTFuYy8W/XEhClDnybxrfZsUNIEsC07Cc5V39Hqqb+8LfR1r2hATxKRayipNIzIwlJSceIcHuTc0MRMlloKGhER2tm3uIkV6YQFyyBfuwkcpYA+/9nfHITbEyKT+B5Vta8PoVPH6FBZPSsVmHvIclSZCZaKGubajIiMPjp6vPRVJ80IPd3e9Cp9cR8AdQVZWY+BiOvvBocspzKZs3keJZxfsnmMZhixAi7Ng4SGr8sEiH0EMam2imv8eFJEn0tg0w0BOcqknNtYWT3XjdPrxuvzb61tAYB9qv5BBDCMGRiyfy7r/XhZeV5ScgRymkIomg85kQobIbof9lAXmh6urh0pmKQl56HL0DHtw+BRWVzERz1NjywLDyj5mJZooy40mwGpEIJi2ZsnAql/7uMp7//XNMOmYys0+fzcxTZ5GYkajlqv4WsvHPz7Bs6TLSijLInlzAsQ9cD6HnarCDKYQAFUxWA7FJFjxOH6qq0ts+QHphIs3VXax4aTtCwJk3HrXfCYs0NL5taMr7EGTKcYVUrWmkbmsbAPk5NsR+1PIeqzwoQJzFgE4WuLwKzd0ucnvdJMUbkaWh/Qf6PRhcPkSskVklwV7AYNpRvSRIyUriyLPmsuiqRfi8fmyptjEriml882mva0dVVVp3NdO6q5k/NnZw5q1nM+vMI1FDo3IlVD7W0evGEeEgqeC0e/B7AxyxeCJbl9fS1dhHSq7tqz8RDY3DCG3O+xBl6sIJ4c8HMx5AkgTFmUNVylZVtrNiWxv+UIKR2vXNvPr7j9n95Cb63qqmu6EvPHwKAIoaHEVlTMggJsFKUmaSpri/5XTUBx0sZZ2MyWqhYPo0ti9vxOf2hee8JWnsV01nYx+p+TZad3chyYLNH9d+JXJraBzOaCPvQ5TUPBuyTiIQJUHIFyUn1UplU1+4KEqPw8tHm5uJb3Py+XNbwr2F9ppuXv7zJ1zwy+OISQ56m4vQGFwIsdda0BrfDvq7XZQfeyql84eeU7cTcIJOr0MlGA8v9jFMkCRB3dY28ialUXGAhWo0NL5N7FN5CyFygKVAOsEpz4dUVf2bEGIa8CBgAvzA91VVXf0lyvqtIj4lhvKj8tjyJYxCZEmiKCOObcO8yL39Hta9tD1sH590bAHphYkkZcUTE2dCJ4IDcG1OW2M4lasbxuxgfvjoOiQhcA94sGQkkX9OedByA+Ggh8GnydLrYcdzW5l1Sgnm2NHpVzU0NCIZz8jbD/xYVdX1QohYYJ0Q4j3gHuBXqqq+JYQ4NfT92C9P1G8fi66YQVyKBdSRAV5DHKhJPS8tll3NdryhF69/U3u4NKisk5h5SilxKTGoBB8SFdBJQlPeGhFUb2xBktXw3PYgGUVJVH7eEP7eVdVFf0s/OZdNDeYQCDUf3EroJFRFpX5HO3kVX6wGuYbGt4F9Km9VVVuAltDnfiHEDiCL4O9ucPI0Hmj+soT8tiLrJI5cPBG/qhI4mBPfgF6WOHlmNr6AgsvjxzI9i9oNzWxbXkfmhCRiY41hhwhVgE5oilsjEl9AQTo6l97PlrPx9c8j1un0OuZdeEnEMm+/F7nBji9zdHGawXj5bZ/UcdTZkzRvcw2NfbBfc95CiHxgOvA5cBPwjhDizwQd3+aNvaXGgSKEQAcExgjqHusVF235ht2duDwBEMHUqgVpscRbjeFqZsVH5lJ8RA6SCM5sB/9X0e3F2Ujj24s9VAs+Pjlu1Lqx0i7XflBDyXcm0h8bGaLoHwjWfx/ocVO7uZUJ0w5O1T4NjW8q434rCyGswAvATaqq2oHvATerqpoD3Aw8OsZ2S4QQa4UQazs6OqI10dgHwQIZ0dW0GuVvrOW9A1467G46+ty0VXexa1ktPc32kQdDJRgrDiBro22NMbA7vZgNMtfedy2F0yeQnD1Uz3ws5e1z+uja1j56xbDHbNOHuw+2qBoa3zjGpbyFEHqCivspVVVfDC2+Ahj8/DwwJ9q2qqo+pKrqLFVVZ6WkpHxReb+1SIOJWA4SDa9XserFbTxzx/useHYzji4Hqi+ALEJx4n4FSWgOahpj43D7cXkDbG7u56QlJ3Hd35cMrdzLNE/rplbiQvn1B1ECCkIoCEmhflsz9q7+L0lqDY1vBvtU3iL49n4U2KGq6r3DVjUDx4Q+LwR2HXzxNIajP4jzgJ6QyVMJqKx/exf//snbVK6oRycEAZcPR59HU9waeyUv1YotxkBqvJlTrj+VXWuGXgGDSVnGYuvSjcQPa7L9lff5eOmTfPzEk3z42FKe/91/vyyxNTS+EYxn5H0UcBmwUAixMfR3KnAd8BchxCbg98CSve1E44sjCXFwFLgy2jsY4LMXtrJjRT3te3qxpcRE2VBDY4hYs565pankpsTw6fOf8r8/PL9f23etH/JxNVjNEeveeegdvG7vQZFTQ+ObyHi8zT9lbL+omQdXHI19IQuBJHHAHugmvURAgcnXzGTLo8H86UICSSeDLAigkpJjO7hCa3xjiTXr8XkD1G1zc9xVVwUXhqZevvt/Z0ZUXdv56Q5+dcLPg02EIH9HAXtuqwttIyidW8auNVUofgW3w03V6iomLZj01Z6QhsZhgpZh7TBECIHM2B7o+9rWFwjQpxPkfndWxLqUOBOxaVYscVqSDI3xoaoqK17chhBiVLIWdUR4oZAg4A+EvyuBAD6PL/y9cuVOimcVs2vtLiRJYu0bazTlraExBloM0GHKwZqNlkMjI50kSLAaMOq1lKca+0dMvInWmi4gWK0u7Gk+qpZ35OvG0edEb9RH7iz0PCqKwqfPfTqm17qGxrcdbeR9mLI3d6DBCmCDn/dGcUYcXf0ebDEGYs160mzmfWyhoTGEEIJZp5Twxv1Pse6t4DTMwqsvwe/TsfXD3agqeB0+EODo7YvYtq2mlYyiTFqqh+a+pWEj9fa6NqpWV1F6ROlXczIaGocRmvI+TJEIxmIHxkidGk47OWzZ3ImpKKpKn8OLqkJaghlZktCFYrtR1YiXp4bGeLEmjs6a9umzW1CGOWbY0kZ3DFtrWiidW0blyp0A+H1DIWSmGBO7N+zWlLeGRhQ0s/lhihCCwcjvsRK1DDK4zGjQYTbqyUiMISMpBkmSUAGfqqKihk3oGhr7y3f/cX3YBP7hY0/xyX+Wjmoz8ukqP7oCVVHZva6aoplFQDDeW2/UY4wxIiTB/37/HAM9A1+2+Boahx2a8v6GM94Zw8GUqBoaB4LVZuWIM48Mf9/XXPXEoyay/ZNtAPi9fgwWIxOPmkjtplp8Hh8ehwdXv4vOhk5e/stLX6rsGhqHI5rZ/DBGEoxLO++rmeDgOcBpfHs58bqT+PyVVUxeOIVdq6swGlpZ9uSHQNBSlD0xB73JgOIPULmqMmLb+NRE9mzdQ0Zxzqj9NldraZU1NEaiKe/DGEkIdCIY8/1FEKF9KZpnr8YXYPJxkzn+ykVs/3Qbv//4bm6a9qOI0DC/x4dvjMQriVkT0FsKo64zWvQE/AqyTjMUamgMov0aDnN0kvjCN1EBTXFrfGFkWeaqP1/NvHOPIiU3BSUwIu4bkHWjQxH1JgNux9jz2h6nj+bqroMtrobGYY028v4GsK9R83jUsqKC5miu8UUxW81cdOfF7F6/G0u8BQC9UY/P48Ng1KMzBl85QhIISUIKla+Llq53OH5vYK/rNTS+bWgj728Ag+U7x1vbO9prMqCqSOy7oISGxr7we/30tHbjcXjImZiD0+7C0evA7/PjcXgI+AP4vX58bi8ehwePw7PPjqPRrN97Aw2Nbxma8v4GIETQdD7W2GXk8rHiwsWIdJYaGgeC3qgnxmblxCUn4ep34XV5gJDZXC+jN+qR5MhXz768040WTXlraAxHU97fEHRjxGiPdzQ++CBoM98aB4P8yflc99clZJZkhZdJkiDgC+YzL5tbFrmBprw1NPYLTXl/QxCAQRLoxL4d2FQgoKgEhs0zOr1+OvpcON1+LZ+0xhfGEmdB1sn86LEbAUjKSqJuU90B709T3hoakezTYU0IkQMsBdIJOiY/pKrq30LrbgB+CPiBN1RV/emXKKvGXghmXAvGfqvqUMnQsdRwt93Nyp3tWM16Yow62vpcFKTGMmNCEk6PnxiT9rLU+OLExMcw//z51GyoiegUqoDJakKn0yFkieaqnVSv2RVcF2qnqiqyTiYpKxlZf87XIb6GxiHLeLzN/cCPVVVdL4SIBdYJId4D0oAzgSmqqnqEEKlfpqAa40cIgQ6QUVERBFR1dCETEXyB9rt89LuCZRnd3oCWaU3joJOQnkDzruaIZTs+3R7xXVUyIvKaD6IEFBAgSZqRUENjOPtU3qqqtgAtoc/9QogdQBZwHXC3qqqe0Lr2L1NQjf1juPOZpAYLmAxP5hJtLrylx0l7n4tYbdStcRDJKMrcZ5uR5UKHk5iZeDDF0dD4RrBf3VkhRD4wHfgcKAGOFkJ8LoT4WAgx+0uQT+MgIIRAJwkMw/6S40zMK0ulNCs+3E4Fdrf2o9dpHucaB4+TlpxMzsTRaU+HI/ZSFCcpK+lgi6Shcdgz7iQtQggr8AJwk6qqdiGEDkgAjgRmA88JIQrVEd5OQoglwBKA3Nzcgya4xv4zvNynUSeTnRRDdlIMqqpS1WwnzqwnK9GC168SJRGWhsYBoTfqmXv2PAxvraVhR2M4dGw4kiQwmA1kFmdiMBsYtA11N3dROD162lQNjW8z41LeQgg9QcX9lKqqL4YWNwIvhpT1aiGEAiQDEVUEVFV9CHgIYNasWdp06iHI1PxEEq1GTHqZVNvomssaGl+US397GZf+9jJ623t59a+v8MY/XsfV7wqvVxUVr8tL3ea6UduOCivT0NAYl7e5AB4Fdqiqeu+wVS8DC4GPhBAlgAHo/DKE1PhyEUKQm2L9usXQ+BZgS7Vx+e+v4PQffYfn7/4k7JDm6m1m+wgnNgh6q5fMKf0aJNXQOLQZz8j7KOAyYIsQYmNo2c+Ax4DHhBBbAS9wxUiTuYaGhkY0JCHjcfnwuoIe5jo5+jzNFX+8Er1Rc6DU0BjJeLzNP2XsRF2XHlxxNDQ0vg1YEyOnZ6L1+pNzUjjxupO+GoE0NA4ztOBJDQ2NrxydXqZoxlDq1GjpUQum5mvx3RoaY6D9MjQ0NL4WKubn7TVErKO+Y8x1GhrfdjTlraGh8bWQnBXPFb89gdzyVGISbKPWH3vZSfS2D3z1gmloHAZoyltDQ+NrYcvyWj7931bmnzMpIsOaKcZEZnEm5fOnEp8c8zVKqKFx6DLuJC0aGhoaB5OiGZnsWtfEZy9t4+jzZ5JZaMJgNnDcZQvpabHjtPv2albX0Pg2I77K6K5Zs2apa9eu/cqOp6Ghcfjh9wZoq+shqyT56xblkEEIsU5V1Vlftxwahw6a2VxDQ+OQwu8LaIpbQ2MfaMpbQ0PjkMIUY/i6RdDQOOTRlLeGhoaGhsZhhqa8NTQ0NDQ0DjM05a2hoaGhoXGYoSlvDQ0NDQ2NwwxNeWtoaGhoaBxmaMpbQ0NDQ0PjMENT3hoaGhoaGocZmvLW0NDQ0NA4zPhK06MKITqAPV/ZASNJBjq/pmMfDDT5v34O93PQ5P96+SLy56mqmnIwhdE4vPlKlffXiRBi7eGcG1iT/+vncD8HTf6vl8Ndfo1DC81srqGhoaGhcZihKW8NDQ0NDY3DjG+T8n7o6xbgC6LJ//VzuJ+DJv/Xy+Euv8YhxLdmzltDQ0NDQ+Obwrdp5K2hoaGhofGN4BunvIUQ5wkhtgkhFCHErBHrbhdCVAshKoUQJw1b/lFo2cbQX+pXL3mEnAdyDjOFEFtC6/4uhBBfveSjEUJMFUKsDMn2mhAiLrQ8XwjhGnbNH/y6ZY3GWPKH1kW9F4cSQohpQohVoWu8VggxJ7T8cLn+UeUPrTvkrz+AEOLZYde5TgixMbT8sLgHGocoqqp+o/6AiUAp8BEwa9jycmATYAQKgN2AHFoX0fbr/jvAc1gNzAUE8BZwytd9HiG51gDHhD5fDfwm9Dkf2Pp1y/cF5B/zXhxKf8C7g88CcCrw0WF2/ceS/7C4/lHO5y/AHYfTPdD+Ds2/b9zIW1XVHaqqVkZZdSbwX1VVPaqq1gLVwJwo7b529vcchBAZQJyqqitVVVWBpcB3vjqJ90opsDz0+T3gnK9RlgNhLPkPl+dJBQatBfFA89coy4EwlvyHy/UPE7KGnQ8883XLonH4841T3nshC2gY9r0xtGyQf4dMV788VEzOURjrHLJCn0cuPxTYCpwR+nwekDNsXYEQYoMQ4mMhxNFfvWjjYiz59/U8HSrcBPxJCNEA/Bm4fdi6w+H630R0+Q+X6z+co4E2VVV3DVt2ONwDjUMQ3dctwIEghHgfSI+y6ueqqr4y1mZRlg262l+iqmqTECIWeAG4jODo9UvjIJ/D3s7tS2dv50LQ1Px3IcQdwKuAN7SuBchVVbVLCDETeFkIUaGqqv0rEXoYByj/13rNh7MP+Y8HblZV9QUhxPnAo8AiDp/rP5b8h8z1h3H/ni8ictR9yNwDjcOPw1J5q6q66AA2ayRy1JdNyASnqmpT6P9+IcTTBM1vX6ryPsjn0Bj6PHL5V8I4zuVEACFECXBaaBsP4Al9XieE2A2UAGu/RFGjciDys5fn6atmb/ILIZYCN4a+Pg88EtrmsLj+Y8nPIXT9Yd/PkBBCB5wNzBy2zSFzDzQOP75NZvNXgQuFEEYhRAFQDKwWQuiEEMkAQgg9cDpBU+mhSNRzUFW1BegXQhwZMvlfDow1ev9KGfTcF0JIwC+AB0PfU4QQcuhzIcFzqfm65ByLseRnjHvx9Ui5V5qBY0KfFwK74PC5/owhP4fP9R9kEbBTVdXw9NZhdA80DkEOy5H33hBCnAXcD6QAbwghNqqqepKqqtuEEM8B2wE/8ANVVQNCiBjgnZDiloH3gYe/Lvlh/88htNn3gMcBM0Fv87e+esmjcpEQ4gehzy8C/w59XgD8WgjhBwLA9aqqdn8dAu6DqPLv414cSlwH/C008nMDS0LLD5frH1X+w+j6D3Ihox3VDpd7oHEIomVY09DQ0NDQOMz4NpnNNTQ0NDQ0vhFoyltDQ0NDQ+MwQ1PeGhoaGhoahxma8tbQ0NDQ0DjM0JS3hoaGhobGYYamvDU0NDQ0NA4zNOWtoaGhoaFxmKEpbw0NDQ0NjcOM/w+MLZfZ7nJSHgAAAABJRU5ErkJggg==\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "ax = df.plot(column='HR60', scheme='QUANTILES', k=4, \\\n", + " cmap='BuPu', legend=True,\n", + " legend_kwds={'loc': 'center left', 'bbox_to_anchor':(1,0.5), 'fmt':\"{:.4f}\"})" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "ax = df.plot(column='HR60', scheme='QUANTILES', k=4, \\\n", + " cmap='BuPu', legend=True,\n", + " legend_kwds={'loc': 'center left', 'bbox_to_anchor':(1,0.5), 'fmt':\"{:.0f}\"})" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The new legends_kwds arg `fmt` takes a string to set the numerical formatting." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## When first class lower bound < y.min()" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "ax = df.plot(column='HR60', scheme='BoxPlot', \\\n", + " cmap='BuPu', legend=True,\n", + " legend_kwds={'loc': 'center left', 'bbox_to_anchor':(1,0.5),\n", + " 'fmt': \"{:.0f}\"})" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "BoxPlot \n", + "\n", + " Interval Count\n", + "----------------------\n", + "( -inf, -6.90] | 0\n", + "(-6.90, 3.21] | 353\n", + "( 3.21, 6.25] | 353\n", + "( 6.25, 9.96] | 353\n", + "( 9.96, 20.07] | 311\n", + "(20.07, 92.94] | 42" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "bp = mapclassify.BoxPlot(df.HR60)\n", + "bp\n" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "['(-inf, -7]',\n", + " '( -7, 3]',\n", + " '( 3, 6]',\n", + " '( 6, 10]',\n", + " '( 10, 20]',\n", + " '( 20, 93]']" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "bp.get_legend_classes(fmt=\"{:.0f}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In some classifiers the user should be aware that the lower (upper) bound of the first (last) interval is not equal to the minimum (maximum) of the attribute values. This is useful to detect extreme values and highly skewed distributions." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Show interval bracket" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "ax = df.plot(column='HR60', scheme='BoxPlot', \\\n", + " cmap='BuPu', legend=True,\n", + " legend_kwds={'loc': 'center left', 'bbox_to_anchor':(1,0.5),\n", + " 'interval': True})" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Categorical Data" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "ax = df.plot(column='STATE_NAME', categorical=True, legend=True, \\\n", + " legend_kwds={'loc': 'center left', 'bbox_to_anchor':(1,0.5),\n", + " 'fmt': \"{:.0f}\"}) # fmt is ignored for categorical data" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.1" + }, + "nbsphinx": { + "execute": "never" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/doc/source/gallery/choropleths.ipynb b/doc/source/gallery/choropleths.ipynb new file mode 100644 index 0000000..9e643cc --- /dev/null +++ b/doc/source/gallery/choropleths.ipynb @@ -0,0 +1,862 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Choropleth classification schemes from PySAL for use with GeoPandas\n", + "\"PySAL\n", + "PySAL is a [Spatial Analysis Library](), which packages fast spatial algorithms used in various fields. These include Exploratory spatial data analysis, spatial inequality analysis, spatial analysis on networks, spatial dynamics, and many more.\n", + "\n", + "It is used under the hood in geopandas when plotting measures with a set of colors. There are many ways to classify data into different bins, depending on a number of classification schemes.\n", + "\n", + "\n", + "\n", + "For example, if we have 20 countries whose average annual temperature varies between 5C and 25C, we can classify them in 4 bins by:\n", + "* Quantiles\n", + " - Separates the rows into equal parts, 5 countries per bin.\n", + "* Equal Intervals\n", + " - Separates the measure's interval into equal parts, 5C per bin.\n", + "* Natural Breaks (Fischer Jenks)\n", + " - This algorithm tries to split the rows into naturally occurring clusters. The numbers per bin will depend on how the observations are located on the interval." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "ExecuteTime": { + "end_time": "2017-12-15T21:29:37.736444Z", + "start_time": "2017-12-15T21:29:37.716444Z" + } + }, + "outputs": [], + "source": [ + "import geopandas as gpd\n", + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "ExecuteTime": { + "end_time": "2017-12-15T21:29:39.866422Z", + "start_time": "2017-12-15T21:29:39.846422Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Observations, Attributes: (49, 21)\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
AREAPERIMETERCOLUMBUS_COLUMBUS_IPOLYIDNEIGHOVALINCCRIMEOPEN...DISCBDXYNSANSBEWCPTHOUSNEIGNOgeometry
00.3094412.440629251580.46700319.53115.7259802.850747...5.0338.79999944.0700001.01.01.00.01000.01005.0POLYGON ((8.62413 14.23698, 8.55970 14.74245, ...
10.2593292.236939312144.56700121.23218.8017545.296720...4.2735.61999942.3800011.01.00.00.01000.01001.0POLYGON ((8.25279 14.23694, 8.28276 14.22994, ...
20.1924682.187547463626.35000015.95630.6267814.534649...3.8939.82000041.1800001.01.01.00.01000.01006.0POLYGON ((8.65331 14.00809, 8.81814 14.00205, ...
30.0838411.427635524233.2000014.47732.3877600.394427...3.7036.50000040.5200001.01.00.00.01000.01002.0POLYGON ((8.45950 13.82035, 8.47341 13.83227, ...
40.4888882.997133675723.22500011.25250.7315100.405664...2.8340.00999838.0000001.01.01.00.01000.01007.0POLYGON ((8.68527 13.63952, 8.67758 13.72221, ...
\n", + "

5 rows × 21 columns

\n", + "
" + ], + "text/plain": [ + " AREA PERIMETER COLUMBUS_ COLUMBUS_I POLYID NEIG HOVAL \\\n", + "0 0.309441 2.440629 2 5 1 5 80.467003 \n", + "1 0.259329 2.236939 3 1 2 1 44.567001 \n", + "2 0.192468 2.187547 4 6 3 6 26.350000 \n", + "3 0.083841 1.427635 5 2 4 2 33.200001 \n", + "4 0.488888 2.997133 6 7 5 7 23.225000 \n", + "\n", + " INC CRIME OPEN ... DISCBD X Y NSA NSB \\\n", + "0 19.531 15.725980 2.850747 ... 5.03 38.799999 44.070000 1.0 1.0 \n", + "1 21.232 18.801754 5.296720 ... 4.27 35.619999 42.380001 1.0 1.0 \n", + "2 15.956 30.626781 4.534649 ... 3.89 39.820000 41.180000 1.0 1.0 \n", + "3 4.477 32.387760 0.394427 ... 3.70 36.500000 40.520000 1.0 1.0 \n", + "4 11.252 50.731510 0.405664 ... 2.83 40.009998 38.000000 1.0 1.0 \n", + "\n", + " EW CP THOUS NEIGNO geometry \n", + "0 1.0 0.0 1000.0 1005.0 POLYGON ((8.62413 14.23698, 8.55970 14.74245, ... \n", + "1 0.0 0.0 1000.0 1001.0 POLYGON ((8.25279 14.23694, 8.28276 14.22994, ... \n", + "2 1.0 0.0 1000.0 1006.0 POLYGON ((8.65331 14.00809, 8.81814 14.00205, ... \n", + "3 0.0 0.0 1000.0 1002.0 POLYGON ((8.45950 13.82035, 8.47341 13.83227, ... \n", + "4 1.0 0.0 1000.0 1007.0 POLYGON ((8.68527 13.63952, 8.67758 13.72221, ... \n", + "\n", + "[5 rows x 21 columns]" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# We use a PySAL example shapefile\n", + "import libpysal as ps\n", + "\n", + "pth = ps.examples.get_path(\"columbus.shp\")\n", + "tracts = gpd.GeoDataFrame.from_file(pth)\n", + "print('Observations, Attributes:',tracts.shape)\n", + "tracts.head()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Plotting the CRIME variable\n", + "In this example, we are taking a look at neighbourhood-level statistics for the city of Columbus, OH. We'd like to have an idea of how the crime rate variable is distributed around the city.\n", + "\n", + "From the [shapefile's metadata](https://github.com/pysal/pysal/blob/master/pysal/examples/columbus/columbus.html):\n", + ">**CRIME**: residential burglaries and vehicle thefts per 1000 households" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Let's take a look at how the CRIME variable is distributed with a histogram\n", + "tracts['CRIME'].hist(bins=20)\n", + "plt.xlabel('CRIME\\nResidential burglaries and vehicle thefts per 1000 households')\n", + "plt.ylabel('Number of neighbourhoods')\n", + "plt.title('Distribution of neighbourhoods by crime rate in Columbus, OH')\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now let's see what it looks like without a classification scheme:" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "ExecuteTime": { + "end_time": "2017-12-15T21:29:54.097280Z", + "start_time": "2017-12-15T21:29:53.766283Z" + }, + "tags": [ + "nbsphinx-thumbnail" + ] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAWYAAADtCAYAAACMJt+5AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8vihELAAAACXBIWXMAAAsTAAALEwEAmpwYAABusElEQVR4nO2dd3gU1frHP2e2ZDfZ9EYSQhIglNClW6gqiCIqFsR61Yt67b397A2vXnu5145drIAiTUVURAGlF+kQkpBet++c3x+7ICVlN9lNNjif55lnd2Znzjmb7H73zHveIqSUaGhoaGiED0pbD0BDQ0ND41A0YdbQ0NAIMzRh1tDQ0AgzNGHW0NDQCDM0YdbQ0NAIM/RtPQANDQ2NtqSrENLq57mFMF9KOT6kA0ITZg0Njb85VmCan+c+CEmhHMt+NGHW0ND4WyMAXVsP4jA0YdbQ0PjbE26LbZowa2ho/K0RaMKsoaGhEXaIth7AYWjCrKGh8bdHmzFraGhohBnajFlDQ0MjjBCEnxCG23g0NDQ0Wh1txqyhoaERRmheGX6SlJQks7Oz23oYGhoaYc7KlStLpZTJLW1HE2Y/yM7OZsWKFW09DA0NjTBHCLErKO0Eo5EgEpbCrKGhodFaaCHZGhoaGmGIZsrQ0NDQCCO0xT8NDQ2NMESzMWtoaGiEGdqMWUNDQyOM0EwZGhrNYMaMGVRWVmIymTCbzZhMpkO2g49FRUWRlpaGEOF2c6oRrmheGRoazeC2W2/mlBP6EmE0Yne6sDlc2B0u7E4XdrvT+9zhwu5wsqewmG+//Y7jjjuurYet0Y7QZswaGgGSndWJK88bw7D+uU2eO+bSx3E6na0wKo2jiXC7vwq3HwoNjSPIzs5m594Sv85VVYlOF243phrhzH4bsz9ba6HNmDXCnuzOXdmZv8evcz0eVRNmjYAJtxmzJswaYU/nzl1YuXi1X+dKKbnlphuItkThcrtwu9243R5MpggslmgsFgtRlmiio2OwRMcQHR3N4MGDGTNmTIjfhUY4E26mA02YNcKe7OxsPiso8+vc/z5wKXuKytDrFAx6PXq9gk5RcDjd1Frt1NTZqLXaqbNWUltTxNq1Rcz64lOWLlse4nehEa4E2ytDCBEHvA70BiRwGbAZ+BjIBnYC50opKxpqQxNmjbAnJyeHnXuK/Tq3d7dMenfL9Lvtleu2c+XDHzZ3aBpHCUGeMT8HzJNSni2EMAKRwN3At1LK6UKIO4E7gTtaaTwaGsEnKyuLPYXFeDxq0Ns2m4zY7fagt6vRfgjm4p8QIgYYAbwBIKV0SikrgUnADN9pM4AzGmunyb6EEG8KIYqFEOvqee1WIYQUQiQ1cO1OIcRaIcQqIYSWYFmjWZhMJhLi4ygsafDOr/ltRxiw2TRh/rsj/NyAJCHEioO2aYc11RkoAd4SQvwhhHhdCBEFpEopCwF8jymNjccfU8bbwIvAO4e8ESEygZOA3U1cP1pKWepHPxoaDZKTncWO/BI6dkgMarvmCCN2hyOobWq0P4Tip1+GKkullIMaOUMPHANcJ6X8VQjxHF6zRUA0OWOWUi4Byut56RngdrzGbQ2NkJKTk8OOfP/szIGgzZg1hACdTvFr84N8IF9K+atv/1O8Qr1PCJHm7U+kAY1+mJtlYxZCnA7slVI25cMkgQVCiJX1TPkPb3Pa/tuDkhL/ggk0/j5k5XRhl59BJoFgNmkzZg0QQvi1NYWUsgjYI4To7js0FtgAzAYu8R27BJjVWDsBe2UIISKBe4CT/Tj9OCllgRAiBVgohNjkm4EfgZTyVeBVgEGDBmmzcI1D6Ny5Cz9+82vTJwZIhNGA0+lCVVUURVsL/3si/Ddl+Md1wPs+j4ztwD/wToJnCiEux2v+PaexBprjLtcFyAFW+35BOgK/CyGG+H4tDiClLPA9FgshvgCGAPUKs4ZGY2RnZ/Pu3uAvVQghiIgw4nA4MJvNQW9fo30QzGyEUspVQH126LH+thHwFEFKuVZKmSKlzJZSZuO1qRxzuCgLIaKEENH7n+OdYR/h2aGh4Q85OTnsDIGNGcAUYcRms4WkbY12gPAu/vmztRb+uMt9CPwCdBdC5Pum4g2dmy6EmOvbTQV+EkKsBn4DvpZSzgvGoDX+fmRmZlJYXIbL5Q5622ZThObL/DdGEDwbc7Bo0pQhpTy/idezD3peAEzwPd8O9Gvh+DQ0ADAYDHRISWZPURmdM1OD2rY2Y/6bIwSKfx4XrUZ4jUZDoxFycvxP/xkIWvSfhqIIv7bWQsuVodFuyMnpzI784AuzNmP+e7PflBFOaMKs0W7IyunCzvw1QW/XHKHNmP/WiAAi/1oJzZSh0W7o3LkzOwvrC0JtGd7oP23G/Hem3S3+aWgcjpSSffv2sXPnTnbt2sWOHTvYtXM7u3ZsZ+euXYDgg49m0r9//6D2m52dzc784PkySymxO1zodIo2Y/5b07qucP6gCbNGwPzwww+MHj2aXrlZ9OicRlZqDHnpCZzSqydZacexbmsBJ584hhtvvpXBgwcjpWT16tVsWLuKuIQkunXvcWAGotfrMRgMB6Lu3G43VVVVVFZWUlVZQWVlOXarFYfDQWVlJZu27mrx+F//5DtuePQdHA4nRqOBSLOZuLi4Frer0T4RgrDzytCEWSNgRo4cyWX/uITdm//g3YcvIsJoOOT1Prkdye2Uwrtff89jsz9EEQo9c5IZlJNKZfVuVn3vjTNSpYrbI3G5PUhfEL5OEcRaTMRGGUmzmOmeaSbSFEeEUY9B34mzfviJyupa4mIszR7/7oJSbr31Nh544AGtPqAGoC3+aRwFCCH436uvc945k7n0/nf58PHLjjhnUK9sBvXKDnrfHZJiWbZqK+NH9G92G06Xh0SLRRNljQO0piucP4TX/F2j3aDX63n7nff4YlHr1j/ISk9ixfrtLWrD6fZgNBqDNCKNdo+fC3/a4p9Gu0BKSUQrC1y3rFQ2bt3bojYcTrcmzBoHEGjuchpHEU6n8wj7cqjpnpXCzhYGmThdHiIiIoI0Io12jwBFJ/zaWgttxqzRbJxOJ0ZD636EsjOSKKuqbVEbTpdmytA4FG3xT+Oowel0YjS2sjCnJ1JdY21RGw6XW5sxaxxCuzNltLBK9nghxGYhxFYhRMAFCTXCm7aYMedkJFFd2zJhdro0G7PGXwgEivBvay38sTG/DYw//GBTVbKFEDrgJeAUIA84XwiR1+yRaoQdTqcTg751hTk1MQaXR6WopLLZbWimDI1DCMNE+f7kY14ihMiu56X9VbIbKio4BNjqy8uMEOIjYBLewoQaRwGxsbEUFJdTUFxJekpcq/QphCA5PpqptzxPt5x0LGYTMRYT0VFmoi1m4mIiibVEEh8TRXyMhfjYKOJiIg+p5+d0ujRThsYhHBU25oOrZDfyhjKAPQft5wNDG2lzGjANoFOnTs0ZlkYrk5mZybXXXseVj37I7GevarUPt8PuYMe2fJKEh912F1anC5vDTZ3Thd3pxuZ043C5cbg8OD0qbo+KXqegVxT0OoGUUF4e/GRIGu2ToyIkO4Aq2fV9Sxusfq1VyW6f3Hvf/QwdPJv3vl7GRacNb5U+UxJiuP3kPlx8Qk+/zldVid3lxuoT7bNeXEiHDh1CPEqN9kP4JTFqzs/EwVWyd/JXlezDP+n5QOZB+x2BguYMUiN8MRqNPPTIY7w1+7dW6zPaYmZftf8LgIoiiIwwkBRtJjMxmkhzBBs3bmTz5s2Ulpbi8XhCOFqN9kC7j/yTUq4FUvbv+8R5kJTy8HyMy4FcIUQOsBeYAkxt/lA1wpWTTjqJK/95Oas27aF/j8ymL2ghyfEWCiqb75lxcs903nruCf7zyP2UVtdSXWcj1mIhMT6OxIR4EhMTSUxKJiElhcSkFJKSkkhMTCQpKYnk5GTy8vIOsVlrtHMEiDD7fzYpzL4q2aOAJCFEPnC/lPKNBs5NB16XUk6QUrqFENcC8wEd8KaUcn3whq4RLphMJm674y6ueOhFHrnmNJLjo4m1mOmSmRySWUZ6Sjz5e4qaff09Ewdwz8QBB/Y9qkpFnYOyWvtfW00pZfvyKdvuYJfVTZnVRVmtnVXbC5n52eeMGzcuGG9FI0wIpinDN1mtATyAW0o5SAiRAHwMZAM7gXOllBUNtRGyKtm+/bnA3Kb60Gj/XH/99cTExPDIq6/gcDgoKS2jrq6Oq88dwQNXnRbUGWZ2eiJr12wNWns6RSEp2kxStLnJc8995Tuqq6uD1rdGOCC8K4DBZfRhVoQ7gW+llNN9MR13Anc0dHF4zd812i06nY7LL7+cpb+uYOWqtezOL+CP1WtZvLaEa6fPDEofqqry7pxfmDHrZ7bta3CyEVLMRp1W7eQoQwhQ9Dq/thYwCZjhez4DOKOxk7WQbI2Q0alTJ+Z8/Q2dMjvy9C2TMUU0nfDI6XRz/u2v8vuGnZRU1OL0eJPoRxh06ITAYjJw7qDOvPFT2wizSa9o9QGPQgIwuSUJIQ7Odfuqz6PsYCSwQAghgf/5Xk+VUhYCSCkLhRApNIImzBohJT4+nrwe3fhlzTZGD+7R6LlWm4P+Zz9IvEHw7OTBDMpOIj4yAkUIKm0Oah1uOidF4/KovPjdOlRVbfVFOLNBmzEfdQgB/tuYS6WUg5o45zgpZYFPfBcKITYFOiRNmDVCztiTx/Pdb2sZPbgHu/aW8vBrX1NTZ6Omzk6dzYnd7sLhdFFYUsmAzES+vPpEIgyH3jamGiJJ9T036nUY9Tr2lNWSlRzTqu8lQie0GfNRSDC9MnxrbUgpi4UQX+CNgt4nhEjzzZbTgOLG2tCEWSPknHDCCJ566GsA3vnqF76Yv5yzB3ehk8VAdKIJS4SBaJOB9LgoTsrLwOBHFFas2cjW4spWF2azQRPmo5FgeQ8JIaIARUpZ43t+MvAQMBu4BJjue2wolQWgCbNGKzB06FCWr9tGeWUtlTU2dDqF/15wXIvaTLCY2FFSE6QR+o/JoKfaWtfq/WqEDiEEQh+0GXMq8IVP6PXAB1LKeUKI5cBMIcTleBO/ndNYI5owa4SchIQEIo0G0sfeSk5yDJf7GUrdGDohePTzX3lnyQaMBh0mg44Igx6zQYfJqCfSaCDSoMMcoScqwkhkhJ7oCANRJoN3hm42Em0yEhtpJNpkIMZs9MtebTboKba1LO2oRvghRHCE2Ze0rV89x8uAsf62owmzRqvQo0cPrulj4axjcoLSntvloQfQy+bEaZXYJDikxK5CjZQ4VIldVXGo0repOKXEqaq4VIlTlbikxK1K3FLiwes7qlcEa5+4kC6pcfX2azLqsFn/Eubt27fzxx9/4HQ66908Hg/p6elkZmZSXFxMWloao0aNCsrfQCNIiPBLlK8Js0bIyc/PZ+269Rx7xulBazMuKoJeBh1Xp8cHpT0pJS4Jo9fsZntxdcPCbNDjqP3Lxnzd1VdSW7yLtMQY36KkcsgmgA0/WMkvrcHlchER14FRS34Oypg1gocmzBrtFlVVsVqtREVFBbRY8siDD3D5cd3oEBvZ5Llut8qeir9q+imKIC3WjPGwhPwdYs3sK6ryf/BNIITAKMCsU6i01u8OJ6Xko+U7GX+hNxxbVVWWLvuV9a9eTYeE6Cb7mLd8C4/P2cj69eupq6s7YrPb7Qgh0Ol0KIpy4PHg55GRkUyYMAF9KxcoOLoRECRTRrDQ/rsafvPYo4/ywIMPIqUkOjqa6GgLU8+fyhP//neD1xQUFPDJzI/ZeP8ZR7y2ZV8Vry7ZyKKNBXx9/TjS46KY8MI8fvyzEL3P3iuROD0qekVBpwiMOgVFCDyqJNXQokisevEKs7Pe1z75dQtFDoXrrr8BgI0bN5IQE+mXKAMkx0ayZ9cOzp44jiiTEYs5gkiT1+4dFaHHZNAhJahS4lHlX4/qX/tb95by+v9e4aNPPiMysukfOg0/0EwZGu0Ft9vNpNNPR6fTkZCQQHx8PMt+/ZXpD9/LjdddRU1NLUt+WsqV192GwWCge48ejBo1iszMQ7PL2e12LCYjiRYT4J1lPvz1H/x38UaqbU4Gd0xk7d5yRj35Nb0z4li6dR8fnT2MU3L/yiLrcHuwuT043CrVDheqhN8LK7jn2+DnxDLrFKrqEeYqq4NbZ/7GzC/nYDB4Ixh//vlnju3lf1GHgd0y2D7jhhaNz+ly88/nvmbMyBOY/fU3pKQ0GkCm4QeCoyBRvsbfA0VR+H7xYp576lEMBgPl5RVEjTyWU8adiF6vJz4+jlNPOZlXnpOsXruOzz/9mCeemM6HH36E2WwmKysLvV6PXq+ntKKawY98CUKyu7SWKKOe58f1Y0JuBww6hbX7qlhRUMHvRVUcn5XMsZmJh4wlQq8jwpenINUn8AC2EORRNisK7/28keO6pZEeF8X46V8SGaGn0upkxNhxHHfcX25+S39czPDurZtw32jQ8/Ytp/Pgez+Q16MbN9x4EzfdfAsWi6VVx3FUIQS0t7SfGn9PFEXhkosvZueuPTz64D31nqPX6zlz0qmcOelUpJScd9EVnD/lPGrr6tizJx9VVRFC0DUxmqk90nBLycCR8QzvmIjuoFvHPqmx9EmN5R8BjC/VEoHNFXxhHhlr5oOiSh74fBnnDetGZVUd53WIY6FHpXe//oec+/PPP3PTnRODPoamEELwwEWjuHBMH+5/bza5L73A8y+8zDnnntvqYzlaCDdThpCy8SpOQog3gdOAYillb9+xh/FmS1LxhhZeuj8M8bBrd3JYXlJ/BjVo0CC5YsWKpk/UCCk7duxg0KBB7Nmyqln2TCklg4aO4pR4lXtOaDxPRnPajp0+ix/7diLBENz5xScl1Ty8uxRVwoXpCdyZHsf88lqetir0692L6qoqyioq2LZnN5Vf3tPmSfNn/rCWV77fyQ8//9qm42gLhBAr/dWVhugXb5Hzxx7helwvaZ8tbXF//uDPJ+ptYPxhx56UUvaVUvYHvgLua+T60VLK/q3xZjSCS05ODoMGDmTWnG+adf0nn81i06bNXNQ3+MV1hRDEmYxstbuC3vaJ8VFMz0nhp/5Z3JkeB8DouCj+ZfJw4va1XFyZT3ppIYN7dGxzUQbIzUiksjJ4Hip/O4RAKIpfW2vRZE9SyiVA+WHHDs4UHkUjRVY12jdTpkzhy68CF+YdO3ZxxT//xSunDqCTH25yzSE5ysQOW/0eFC0hXq9jQoKFuIPy7xoVwaSkaE5OsHBsbCR7VBg/KDfofTeHuCgzVVry/mYjAKFT/Npai2bfAwohHgUuBqqA0Q2cVl9e0obamwZMA28eX43woFNWFiUlZQFdU1xcwnEjTuTCvp04p1fHEI0MOkSb2WNtm4RCRR6VkX2z26Tvw9lXWYvVpqUibTZh6C7X7J8AKeU9UspM4H3g2gZOO05KeQxwCnCNEGJEI+29KqUcJKUclJyc3NxhaQSZ6Ohoamprmz7xIMaedBpDk6OYPqZXiEblpWOMib1Od0j7qI+ddie1DhcDuqa1et+Hs3VvGec8+inPvfBSWw+lHdMOTRl+8AEwub4XDs5LCuzPS6rRjoiJiaG62v8sbus3bGLr9p28dEo/v9J3toQMi4mSEHhmNMVnJTUM6paBoWWlhlrM7F82csKtb3P/Q49x/vmNlubUaAIhhF9ba9EsU4YQIldKucW3ezpwRIb+RvKSarQjMjMzyd9bgMPhICIiosnzP/j4M+xuD91enE+0UU+s2Ui8OYIEs5GkSCNJJgPxJgMWo54oo44og56c+Cj6d4gLeGwdLBHUtkEo7TKbi3MGt719efonv/LiK69yzjmNZpDUaApBIBVMWoUmhVkI8SEwCm+tq3zgfmCCEKI7Xne5XcBVvnPTgdellBNoIC9pKN6ERuiIioqib98+zFvwLZMmTmjy/EcfvId77riJXbvzyd+7l/z8QgqKiti3r5iS0jLWlJZRU12F3WrD6XDgdDrYU1jMzhtPIc5kDGhsqVEm2iIBZ4GqMiIM7MsGvY60tLY3pxwNtKaZwh+aFGYpZX33SG80cG4BMMH3vN68pBrtj9tvu50nnnzCL2EGiIyMpGePbvTs0c2v8zMzc/l5dxmndgtMZDpYIrB51ICuaSmFDpc3lLxbRqv2Wx9GvQ6nM/heKX83hBBaSLZG+2PY8OFs274jZO337NOH73cVBCzMKVEmbK7WXfz7rLSGfl3SiTC2zVenoKyaOruLH9fuZEdBqSbMwaIV7cf+EF4/ExphSUxMDDU1gXlmBMLkM09n/rZ9AV+XEhWB1eVBVVtv1vxTnYNxg7q0Wn8Hk19SRf+r/8uEBz7l/eXFXHPzHQwbNqxNxnK0IRTh19ZaaDNmjSYxm83Y7XaklCFZmb7ognO5/qbbKbc5STD7b2eOMurRK4JCp5uMAO3TzWWvhFH9mleF5b9zfuXXTfnERpmIs5hIiDZj1Ouos7uwOd3YHC7s+x9dbhwuNw6nx/vocrO1sJJrr7+RBx7U1tCDivBtYYQmzBpNoigKRqMRh8OByWRq+oIAiYyMJDUxnh93lTKpR3pA1yZERrDN7moVYS5xuimptvLpkvV8+fNGpJRIvHk79udRlkik6tvH+4jvvM+XrGdUXkfKSquptjmptTtxeVQiDHpvBj2Db9PrMBv0RBgUYk16TJYIrE4Xv2zM58677g7a+1m5ciU7d+48kAVQCEFGRgbdunXDbDYHrZ92QZiZMjRh1vALi8XC/z3wOE8+/kBIZs29+vbju127AhbmFIuJHXYXDUYuBZGPi6uRwJ69pT6/1r/K3ns9rv46JvjrNUWAQHDR8T155sLj0TXDA+CL5VvZoyT69cNYUVHBjBkzGDp0KLm5uSQmJlJUVER5eTlOp5PS0lI2bNjAjTfeyKDOaXSIteBWVVQJ+RV1bC0qxWyKYO68BRx77LEBj7U9Ema6rAmzhn/MmzePq666knc/mMnFF5wX9PbPnjyJR+6uP71oY6RFm8mvrAv6eOrjF6uD208bxGPnDm+V/g7mxy37GDG23jiuQ3A4HJx52gT0FXt55wUP2/dVouh0CKmSGmfBqNcRHxlB5zgTc68cw8k9jlxwlVLy2ML1zPzog7+FMAshELrwUmZNmDX8YtCgQTzxxL+55l9Xc8GUs9Hpghv1dsGUyfzr2psoqXOQHNV0IMt+Okab2FlcGdSxNES+CqN6to2b3JItxbx8X0MpabyoqsqlF04l0V7CR1ecgKIIPKpKcY2DDjEmv+90hBBkxUfyx7ZtwRh6+yDMpsyaV4aG34wZM4a4+Hg+nPlZ0Ns2mUx0SErgp92lAV2XYTFR1gpeGZVuN2VWO8O7tm7FEoCKOjtbC8sYOHBgo+fdfcft7Fr9KzPOG4Ti8yDQKQppseaAzU8T8jKYu3ARTeVrP2pQ/Nz8QAihE0L8IYT4yrefIIRYKITY4ntssrS7JswafiOE4PnnX+CWO+9nz569QW+/z4ABfLszMGFOtURQ1wof4y9La8ntEE90AF4jweLnPwsZOnAARmPDfb/y8kt88cEMvrh4GOYg+Fg73Cpx0ZZWzQ/RlgQ5V8YNwMaD9u8EvpVS5gLf+vYbRRNmjYAYMmQIN95wIxf84yrc7uAGd0w550wWBujPnBplwtYKk7rvq22M65sV+o7qYcmfRYw48eQGX583bx4P3Xs3c/5xLEmW4HjNqD5Pk78F3pVa/7ammhKiI3Aq8PpBhycBM3zPZwBnNNWOJswaAXP7HXcQn5DEuInnsmDR97zx9nvEpubgcrWsmsi5Z59BcZ2Notojcwu7VZVf88tYsK2Izzbk89YfO3nh1y3M3VJItTP4VUwOZ7eEUT0D8xgJFku2ljBqVP325Y0bN3Lx1Cl8dMFQuiRFB63POevzGTnihKC1F+4InfBrw5szaMVB27TDmnoWuB1vHqH9pEopCwF8j02WNtcW/zQCRqfT8fkXX/DIww/z72dfITYmlurqGqqqqklKSmy6gQZ44JEniBAK3Z/7hmiDHlVK3wZuqeKUECcEBiEwAgbhnVmEOl9GnVultM7OcbmtL8w1Nicbd+9jyJAjM+aWlZUxcfzJPDE+j+M7N/ldD4hah5uOOW1zh9Am+G+xKW2oTJ4QYn9t1JVCiFEtGY4mzBrNQqfTcf8DDxzYz87Ooqa21m9hdrvdlJdXUFZeQVlZOZ/P+oq3/vc6g+Kj2FBWw4ORRvQCDIBeCK6usnKTlPSRkoPvsd3AJYBTVTGGKEPYnLIaspJjiQvAWyRYLN1SyMB+fY7wX7bZbEyaMJ6zuidw8ZDOQe93S4Wd/id3D3q7YUnwci0fB5wuhJgAmIAYIcR7wD4hRJqUslAIkYa3gHWj+JP2syVVsscDzwE6vOlAp/v7DjXaF9HR0X7l05g7byGTzpqKW0oMQmDQKZh0Cmadjmf65yAl/F+1jZ6GQ93xrKqkvhRHeiAC2GV3kRsZGuFcVGXl5KFtk395yeZCRow96ZBjUkouOPdssqji0fGDQ9LvL7vKuervlIcjCLospbwLuAvAN2O+VUp5oRDiSbzzh+m+x1lNteXPjPlt4EXgnYOOPSmlvNc3gOvxVsm+6uCLhBA64CXgJCAfWC6EmC2l3OBHnxrtDJPJhN3uaPB1VVXZsWMXz7zwX07JSOLlAdko9cxSdtc5qHIfWpXEISUeIKGBtqOFYJvdGTJh3iHhhh5t47/84/ZSHrz+UPvy448/zh+//syG20854BYXbHaWVNK9+99kxkzIa/5NB2YKIS4HdgNNVjbwJx/zEiFE9mHH/KmSPQTY6svLjBDiI7yzbE2Yj0JEE1OOHj0GsHtvIWmRETzeu1O9ogzQMdKIW1UpcKuk672miUpVEiEESgNuAnGKwm57aNJ/2lWVEquD47u3vn3Z6nCxenshw4d7Iw2tVis3Xn8tr73xFhcO7oIxhKWtUmItFBQU/H3EOci6LKVcDCz2PS8DxgZyfSirZGcAew7azweGNtKeViX7KGPjpj+pramlvLKSnXsLWDNuADGGxj9yihB0jo5kqcvF2XrvDLhSeoW5If+tBCDfERrPjLlltaTFR5EU3fpJfZZtKyKtQyrbt2/H4XBw6YVT6Zts5IqReRSU+l+HsTl07xDHtm3b/hbCLP5mVbLre6cNekZqVbLbPwdHib3y6lv0OeZYTj5xAlPPuYAzOqU0Kcr76RsXxRrXX54WlarE2MgXJ0FVKQpRwvz5FXWc2LttvBMSLSZyE02cN3Ecp407kZtHZPHOP0eTmxbPvhpbSPsWgMfT+oVu2wxF+Le1EsHwyvgA+BpvLcCDyQcyD9rvCByxQKhxdJDXK48LLrqC5OQkjKYI1q3fhCrhhKQYTIqCGZWH1u/GoleI1Omw6BWiDTosOh0xBj0xBh0xej2xRoU+MWZW7vtrzlAnJZVuDzfpdURIuMXj4eCf7ngp2eMOTTTEdgRX5rWNfblfp2TmXH9kYElOcgwl9fh6B5Nd5bVkZf193OXCLcAxZFWygeVArhAiB9gLTAGmNmuUGmHP1Vf/ixkz3mF0yT48eH+FnWYjjso6qoB90ruIZ5cSh++5Q0qcUuLyPbql1/0NwKIIvP4WMMKoJy02kkopeaLWziY4RJjjgJoQ+DI7VZV9dXZOaAP7cmN06xBPeV1ohTkvJYYff/yRvn37hrSfsMDPqL7WJGRVsqWUbiHEtcB8vO5yb0op14fmbWi0NUOHDmVQXh65u7czrIW5GipVyeTKOtyqil5R0AtxwH0uVqfDqR5qtogFrO7gC/PCijqSos10iIsKetstoWtqLFanG4+qNiu3sz8c3ymG9WtWhaTtcCTMdDl0VbJ9+3OBuc0enUa74vLrruOTu+5gGC0TyThFEKUI1rpVBhgPFR69gMOX+WIBuxp8e+i8ilrG9skOerstxWTUY9ApVFidQcuNcTiKENjtoZ2VhxVhtvinRf5pBI3zzz+f22+6iUqTjrgWftC7GAz85nQz4LDZt0EI9teFfkcIVut1OFWJR/UwdNUu3+qyNwHPfqvzgUcpD91nv6OHr0SU7+CB50juiA+v2TLAy4vWEGsyEhvCTHdju3XgmXe/DVn7YUUYemVowqwRNGJjYzltwgQWzfuas02GFrXVQ4GN9ZgnDIgDM+bfdTrOijTSP8LA1cVVfNgvi0i9gkD4yjn5yj3xVwIxxedxvf91IQTKYa8J32snLN3MiABLXYUaVVV59MvlPD6xPwZd8M0YqqryR34FczfuZefeQq649GI2b1jP7fc+wMSJE4PeX9gQZrYMTZg1gso/r72Wq75dxGTpaVH+gY4CvnSrXFdZh0QghXcWu8utskfAKkWh0uNmXFQ0GXodkYpArwi6RgXn1r7Y4cLmURnds2NQ2gsW0+esJEInuGBg8yp170dVVVbtrWDh5iJ+21XK9vI6SmodVFjtGHUK3ZJjuXxwF/qWrcPlLuenJUuOamEWYZZnUxNmjaAycuRIag0GplXUYhL7TQJ/CfQBM8KBQ+KA6cAlJYoi0AtBjUfFjWRIlPmAs73O15JOgA6vHTrdN2uM1enYbnWQF6RAkN8q60iJjkQJ0eJac1BVlefmr+LlyYPR+zlbVlWVdYVVzF6fz+q9FWwtraO01k651Y5BUeiWHMOAtHjGHJNMz+Ro8lJijyjt9d4qPd/t3B6KtxQ+aDNmjaMZRVE4ftQoZn76GdPiIg+YETji8a8g7v2mg/eqbfSIj2ZcxyQAHvl9G5OjTCTomxahBL2OPTZnk+f5y/yyWgbnpgatvWBw58dLSY6K4My+mUe8tl+AF2wu5LddpWytclJidVNRXeu9cxGCKb3SuXxAInkpMfRMjiGliYXDaruL537ZypxtZWT1aihTyVHAwR/SMEETZo2gc8ddd/PrwoVcEWsMyJwxx+pkatc0zu/qteu+s6WQn+0OJlqangUn6hQK7MEJy65xe1i4r5Ll158SlPaCgdPt5o3F63n3wuFs2FfJgk2F/LqrjK2VDkqsbspratHpdHTr2oVjBozgn/360CuvO7169qCquprBx53If08fEFCfa/dV8c7mMl5/+x2OP/74EL2ztkcgECGw17cETZjDkN9//527br4RnaKg0+kwRETw2FNP06NHj7Yeml8MGDCAMoeTGtVATABl4d1SYj6o+na/pBhWFpUz0dL0tSmKYF+Q8mV8va+KtFgLeRnNT/ofDJxuN/PX7OHrVdv5etUuXOg4791fEYqgW9cu9O93HJf160OvvB706tmd1NSUen8Iq6qr62m9aRIjjUQY9Jx00klNn9ze0UwZGk1RXFzM3j838uCwLnhUyUeb/+STmTO597772npofiGEQK9TAvZmdkuJ6SAhH5Bg4cPCcr+uTRKwzdlyX2aHR+WlXaVcNr5fi9sKBLdbZdGG3Xz1+06W7yimoKKWshobiRYTOYnR7Kuq45Ybr+Wm666iQ4fUgO5EpJTNulNPjoqgpLyiGVe2M/a76YQRmjCHIbm5uVS7PIzv7LVxSiRvfLsQ2okwA3RM7UCBrZy4AG4RXRLMB6Wy7BVvwV9ZiNcp1LRQmKWU3LelCEOkkf+bFJoE9Afz/PxVfPjLnxRU1FFSYyXeHMGg7GTO7pPBMZmJHJOZQJzZyKTXFnPs0EH8+7EHmtWPlLJZM0LvZeElWKFBhJ1bhibMYUhWVhbFVbXY3R5Meh3DMxKZtmgJbrcbvb59/Mt69+3DD98twFVPqs4IIegRcaSfs0dKTAcJeV68hQqnC1VVm/SOSFBEi8Oyn9tVyoLSav6YfkHIvTF+31nMPTOXcvfJfRmU5RXhxHpc/T79YydLd5SwY+v3ze5LyuatbdncHgx6PXPnzsVms2Gz2bBarUgpiY+PJzExkYSEBBITE0lNTSUiovVLbwWNMPsBah/f8r8Zer2erPQObK+sIy8phkSzkYxYC2vWrOGYY45p6+H5RVJGR16stjHLfeQstsLm5MmkGEYc5pblkRLTQTPmZLORCEVho8tDr4jGhTJep2D3M02l3a2ysc7G+ho7W+sc7LI62GVzss/lJj0hmnOe/waDzlv2KsKgJ8Kgw2TQYTboMRm9j6lxkdxxWr01Of1i2hvfc8Vx3blrXJ8GzymttXPlR8t46qkniIuLa3ZfzWVXhZXi8kqef/wezBEGIk0GzBF6BIKKWjvlVXWUV1kpLCln4KBBzJ23sNXHGBQ0U4aGv+TmdmVbRS15STEADE+LZcmSJe1GmOPi47jz+B7cN7LnEa+NnvEjW2qsRwizW0LkYVU5uidEs9Rmp1c9M+yDiVcOFeY5RZUsKq2m0uWh2q1S6fJQ43Jj9XhwSIgEEhWFFCHooKrUCEGnuEguz+uI06Pi8G12j8Tu9mC3ubDXOqh2q9g9Ki/vKGJcnyz6ZwWeO3zpnwX8WVjO3GkjGz3vX5/8RveePbnisosC7uNgZAMFBpqixuEiIyWOuc9Oa/S8H1b+yf0zljarj/BAgC501WCagybMYUpuz15sXfVXroIRHWJ47YP3uOGGG9qF3S8vrxcfz/6w3tcyYswUVBxZuNXDoV4ZAMckRrNmW9NFXuN0AofqFaC3d5cyfUshx+l0xKsqmVKSBCTiTReagO+Dr/5l+tisU7ggL5Mr+zcdUVdpd9HrzRKOe3AmekXx3QWLA3fDAq9jdkP/JYfbww2je5HSSDDMrvJa5q7bw57t85scT1PExcZgczjJe+UHxnS0cNvxPcjyIweI28/sdYqioKqhyYfdaoTZd0oT5jClW888fvt53oH9M7ql8czq33jv3Xe56OKL23Bk/tG3b1/uL6m//FHHGBPL68kG55FgPiyYpG+ChQU7m57NRAmBCryzxyvKdwD9AqjAIVSJx4+ZpZSS8+asoHNyDHOuHA1CICWoUiKlRJXexVq1CXN3TmLjPoCRvmovSUktd9lLS+vArs1/8NU3C3jj7fc48YPf2HJNfdXgDsWg1+H242/orfoV/LSrrYYAwijCE/zLx/wmcBpQLKXs7Tv2JDARcALbgH9IKSvruXYnUAN4ALeUsvlGub8Zubm5fFj9V9VpvaLw3IjuTLn5JvJ69WLgwIFtOLqmycjIoKiyfmHuFGPmdbfKGaU1jNEJro/3ipQKRB0mzHnxFir9EgeBScBjfxZyIxCos5siVb+E2a1Klu0to+7pqRhDuBCbGBWB0+3BarUSGRnZ4vZSUpK57JIL6Na1C+eef4lf10QZdLj8WFBVhEBt6pco3AmzGbM/PxNvA+MPO7YQ6C2l7Av8CdzVyPWjpZT9NVEOjNzcXLaVHRoYMCgtnoeGZDHxxDGcc8bpbN68uY1G1zSxsbHYnC7s9Sz+/fOYHBZcdAJjOqewyufipkpv6k3jYTOXbrFR1Djd1Dbxxd/udOORcCXe8uyBIqRXdJvCIyWKECEVZQBFEUSbjGzavKXpkwNqV2m48OZhRBr0uOv5/9XbZru2ZAjvjNmfrZVosicp5RKg/LBjC6SU+8tILMNbSUgjiGRmZlJeZ6XWeWi1jql5may6+Hj6VGznuMEDOWHIIJ5//nkKCsKrnGJRURFxUeZDvCz2Y9ApHJMWT058FDrfN9qN98N4uJtahE4hLcrEL43kwXCqKteU1HCKotD4clrDKIDLD2FWm+cSHDC1Dhduj4rHD2EMBCEE/ipztFGHy09TRrueMR/I9erH1lRTQpiEEL8JIVYLIdYLIR70HU8QQiwUQmzxPcY31k4wfgIuA75p4DUJLBBCrBRCNLq0K4SYJoRYIYRYUVJSEoRhtW8URaFLp0y2VdQd8VqUQc8tg7vw52WjuD5Dx7I3n6dXt1x653bhysv/wTvvvMOWLVtwu0NTOdof1q9fT4/UxhPfWIx67D4hdsuGP4x9k2L4rZE8GDeU1pIoJVNbIA46/J8xt8ZN74s/bCItrQODBwfXC0cI4SsLcCR2l5t5W4q4c95qTnrrByZ+/Jtf77WZ8SthhM8rw5+taRzAGCllP6A/MF4IMQy4E/hWSpkLfOvbb5AW3Y8JIe7BO9l5v4FTjpNSFgghUoCFQohNvhn4EUgpXwVeBRg0aFC7vjEKFt26dWNLRQn9UmPrfT1Cr2NClw5M6NIB1+ierC2pZtmOFcxZ8SP/V1BOYUU1D9x3L/fcd3gB89CzevVq8hIaz142KD2eJ6Rks8NNuao26Ep6TIKFz4vqjwF8p6qOzXYnz+IV1+birzDrhEARgtHPLeD7G46sYB0Mqm1Onli0jg/enxH0thVFQaqSX/eUsWjrPn7NL2dXnYsyq4OKGiuJsRZ652YwfOQxTOuazuBeTVfKdjhd7Ty4hKD9skivb+J+NyKDb5PAJLy1UwFmAIuBOxpqp9nCLIS4BO+i4FjZgKOkrwYgUspiIcQXeM1/9QqzxpF079OXLT/O9utcg07hmA5xHNMhjn/5jq3aV8k/3ni9QWGWUvL6668TGxtLTk4OOTk5JCYmBsUdb/GCeZyTVv8Pyn76d4jD4fFwRWEF0REGOsfU76nQK97C6/WMaa/LzRtVNm4BGr0v9AOvKaPpGXekQccvF45g4IzFuN0qej9SkgbK80s206FDGqdNCL7wFxQWUllTw8QPl9GzcxoDj+nB5NwM+nTNIK9zByyRgRcacLjc7VuYCai0VJIQYsVB+6/6JpV/tSWEDlgJdAVeklL+KoRIlVIWAkgpC32T1QZpljALIcbjVfuRUkprA+dEAYqUssb3/GTgoeb093elR8885s77rNnX90uJpa6mhrlz5/L7ypXs3PonRfuKmfX1XHQ6Hdu3b+f2m25gRE4au6tt7Cyrwq2qZGWke4U6txs5XXPJzs4mMzOTjh07kpKS0mS4sqqq/Lj0F164fESj55n0Ol45bSBXzlnJI0O6Mblzh3rP6xVvodJ5qCnjsxobT1TUkQYElsyyfnR4zSn+0DXeglGnUFRjo2OQawJW2Zw8tWgdM2e+G9R291NdU0OnDgls/uKBoLXpcLZ/YQ4gV0ZpU44MUkoP0F8IEQd8IYToHehw/HGX+xDvFDxJCJEP3I/XCyMCr3kCYJmU8iohRDrwupRyApDqG9T+fj6QUs6rpwuNBjjhhBO45bp9FFu7khIZ+AdfCMG4nGTOOess/tG3E31jzbyxaA1utxudTseGDRtItZh5bFgO2bFegam0u9hdbWVnVTW7Nyzhz9++5Vubm701NvZW1lBls5OenERGWhqZWVl0zO5MZlbWAeHu2LEjbrcbk15Hqh8VnCf3zEABps35nTm7S3hzRK8jhL9DZARCCLY63dSpKk/XOtjrUZnUPZ31W4vA0/KFJz3egAp/Mel17KuxB12Yn128iYyMdE45+cSgtrsfXQgi3LzCHJpq3a2CECEJyZZSVgohFuP1atsnhEjzzZbTgOLGrm1SmKWU59dz+I0Gzi0AJviebydwd1KNg+jcuTMXXXoJD/08nxdH5zWrjbsG5XBdv050S/CaCW78du2BREjDhw9n/DnnM+q9d+mTHMut/TMZ2SmJOFMsfVPqN0PY3R4Kau1eoa7Zxd7fNrN+iYcFNjcFNTbyK2sor7OSmxjj9xjP7JlBvw6xnP/Zcrp/+jPZFjOj0+IZ1zGJOKMBl6oSa9RzVVkNbuCyYzpzy7CuvLt6N5u27mvW3+Vw/PXK2E+UQU9RtRVvPGFwqLQ6efq7dXzxWf0Rk8FAEUqzQ7Qb4mgwZQQrJFsIkQy4fKJsBk4EngBmA5cA032PsxprR4v8C3Puf+gR+vf6jLfW7uYffToFfH36QWG/UkpiI03s2LGDrl27kpSUxLMvvMj0J5/i7bff5sYH7+WPC5Iabc+k19E5LorOcQ3PFP8sr2H4Oz/gVlX0fvp+do63sPSyUawoKGfxrlLmbt3Hm3/uxeWbDXdNjGZq70wu7pdFrK8Ct1P1tGjB72B0BCbMFqOeklpH0ycGwDOLN9KpUyYnjR2N3W5n9lfzmLfwO+645Tq6d8sNSh86nQ412MLc3mfMEEy3kjRghs/OrAAzpZRfCSF+AWYKIS4HdgPnNNaIJsxhTlxcHIt++JFRxw0nyqDj3B4ZzW5LCMFtg7sycdzJfDp7Dj179uS9d9/ljVdeYuwpE9hVVkmx1dEss8nBdEuIJtKoZ11xNf07xPl9nU4RDO2YyNCOidxxXPcmz3d5ZFCFORBTRpzJSFG1LSh9Syn5aVsxTy1aS8f0DDqkZFFWW0eiQY+QEpvNxofvvBaUvkIRDKJKiVKPv3q7wU8fZX+QUq6hnmUPKWUZMNbfdjRhbgd07dqV+d8t5sSRJ6ATMLl788X5hoE5JJr2MOq44XRITSXSUce/eqezZPb7mPQ6tlXUtliYAdItZn7eXRqQMAeKR6rs8nh4S1FIVlVOABr3A2kYr43Zf8VKMDdfmCusDj7+fSffrM9nw95K9lVbEUC/yAiG2KroExdBr7RoYnQKMyvq+HzlH83qpz50Ol3QTRlHBe0tV4ZGeNCrVy/mLvyWyRNPY/6eCqYf140Es7FZbV3YK5OBHeLYXWXl5JyeCCE4u0cGz47qiRKkmcPUvAyeXraFfw7sjDFEhS6vH9oVq8vD9vJaPtxeQpKUDGtmW3oCM2UkmY2U1NqbPE9VVb7fUsSsNXv4ZXsJu0trqHK6yIwwMjgqgmmRBvolJpNh0NXrptjLZOClvcGL6lQUEXRTxlFBmEXIaMLcjhgwYABrNm3m7ttvY+gHH/CfEd05PTetWW31TIymZ2L0IceCJcoANwzqykt/7OTV33dw7eAuQWv3YJIiTTx1snd9ucP0WaR6mi84OsARgCkj2WxgTdWR6UjXFlTwye87WbJ1HzuKayits2NWBH2iTIwy6enbIYY8kwGznzO03AgDNU4npaVlQck0p9PptRnz4WiJ8jVaisVi4fmXX+HcqRdw+UUX8Nn2Ep46oTvJQTA/BJv/jOrF5d/8jpRw3ZDQiDN4Z6V1HpXAU9b/RSCmjHK7k8JaG+uLKjnrte/ZW1FHflkttU43HinpGWlioEnPuXFmeqfFkNQC+6tREXQyGfnsizlc+c9Lm93OfhRFaMJ8BFqifI0gcfzxx7Nqwybu/797GPbG6zw0vAvn52UGddbbUibmpjErchhnf/kb2yvreGRUHlHG0HzkUswRPOdwcaeqNmtBsL6Q7Eq7k+92l/JzfhlrS6opqLZTbndg86ik6BQy9TqUrcUMQvKHzcmHOUn0iDAEvZBBf7ORBd9+HxRhFopo55ngQkQYfW9AE+Z2jdls5t//eZpzz5/KNf+8gtc3ruDfx3VlcFpLA5SDx/CMRH66YARnfPEbH63dzVMn9WVqn8ygipeiKKy+9mSynvqKvUCgToU2oADYVFLF+JlL2Vtto9zmwOpRSdIpdDbo6S5gvE4hx2KioyLQHzb+TxxuKt0qwtSy97XF7uLhfdWMjDLSzWQgN8JAH6OOj/5Y3aJ296MPweJfu5+BC6Et/mkEn0GDBvHLyt959513uOD2WzmpYwIvjO4RNrPnnLgoVv9jNB+s38Mdi9bx+h87eWlCf3omRQdNoC1GPVEGHTXOhjPqWYHVwAZgJ1Ch01GjqlilRAWiHU66VNRyoiLIiYogU6dg8HN86Xod62xOhvsR7djo+9AJVlkdlMcl4K6xUrG3EpeqEmVqeqHRHxRFCfrin9XmJDIyLqhttjph8l3ZjybMRwmKonDJpZdy1uTJpKWm8MixXYg3Nc9rI1RM7ZXJWd3TuGzuH5zw1mJMOoWhmUmMykpkcHoCFXYnG0qq2VJhZUxWEuf06hjQj4vZoKfW6aYWWAOsB3YBlT4BtklJghBkKQq9PB6yPB46AkbgRuB/0ZFkNDMpUbJOId/V8tzJaQY916bE8EldLfn5W9Dr9axbt4HS8vKmL/YDr7tcUJo6QI3VTkxCXHAbbW00YdYIJdHR0Qi86SnDEZNezwenD/YmOsov4/PNBXywNp+nf9lKhF5HamQE6ZYIbl24li83F/HOGQMxNOBuV1RrZ9G2ffySX8764ipK6+w8hzcPbYIQZCsKfT0eOnk8ZOINyTJICYclf/8S6KjXN1uUAcyALUiKd3lCFN/uLufs8y7hy8/ep3fv5oXj14c3wCS4ylxjdZKU7X8IftjRHmv+abQ/PKqKLszcfw5HURRGdkpmZKf6fSnKbU6GvPsDtyxYw5CMeNbuq+bPsmr2VNkprbVT5XDhkpJ4RSFVCFI8HtLxZoaZDuTUI8ANUaYodPC74FL9mIGyIFWK1gnBf9JimTxvAV/M+pozJ50alHYBdErwbcw1Nic50dFNnxi2BC/yL1howhwmSCkpLCxk27ZtB7ay0mKsdbVcfOnljBkzJoDWBNct3kynSB3pURFkWMykR5tIt5hIjowIG9tzYySYjcyZPIyhb3/PjN93kKPTkSAlWapKfyAJb5SfcpDvsR34DHgTeDiAvmqFwNLCHzITElsQqyt1NOq5PTWWyy6dxthdG4mJCc6MNBQ25hqrk+h2Lcy0P2FuYZXs8cBzeL2RXpdSTg/e0Ns/27dv59X//ZdlS39izbr16BSF3Ow0OndMonN6PD3jLWyqLOLlF58LSJi/W7yYTZs2sWfPHjbt3M63u3eRv3kve4uKqK61khYfQ3pMJJd3T2VKz+aHd4eanonRDEiNJ6K4kpP8mP2agERFwRNgiak6oGMLv5cRgDPIgndWrJlFtQ7GT5jM0p8WBqXNUOTKqK5zBO2Ho81ob8KMt0r2i8A7Bx1bCNwlpXQLIZ7Am5/5kDIpvuxKLwEnAfnAciHEbCnlhmAMvL2iqirz5s3jpRee5bfflnPJpOHcffGx9Mk9h9SkIzM9FBRX0O/sh/F4PH7n0h02bBjDhtUfnGy32ykoKOCLL77gkzdeCmthBrhzeC4XffkbY/GvQKVNCKxAJRDnZx91QGwLv5geKYNu1xdC8EiHGE5ftZoXX3mda6++osVt6nQ6mqPM5VW1rN6ylw3bCvlzdzG7CssoKquhqs7OvrJqptQeGQXZvmhnwiylXCKEyD7s2IKDdpcBZ9dz6RBgqy8vM0KIj/DWvfpbCnN5eTlvvvkmr7z0AvEWI1efewIzHz4LcxOeE+kp8aQmxrJq1SoGDhzY4nGYTCY6d+7MqaeeyitPhv8NzNisFNxANf4JbW+Phx8VhctVlQydjuf9mGlbpSS6haLqAMo8Hj4pr8ODxIO3orYHUJGoEtxSHjgmkbglOH3HXVLikuCSEjfe527pPSdawC233sVZk04lPb15Ifj7OTxXhtPpZsOOQtZuLWDzzn1s31vC3pIqKqpt1Fjt1Nkc1NkcuN0eEmKjSEuOo2NqAtnpyRx/TC7pKfH899OfDuT4breEly4HxcZ8GfBxPcczgD0H7ecDQxtqxFdFexpAp06B5x0OV9atW8fT/3mSL774glNH9OO9Ry9iSJ+cgPx3xwzpzqJFi4IizPvp3Lkz+eVVOD1qyJIMBYPnVmwlXlGI89M8kQvkqio24EmPBysQ2cQ1dimJbaGNeacq2eH08JlHogiBgkAR3vwj3s37XKeIAwVdFQFGRcGgKBh0gihFwagIjDoFgyJ8r3nP+XJbEfc//ASvvfJsi8Yp8N61pY+7kzqbA6vdiSXSRGpCDB1T4+mUnsjYoemkJ8eRkeLd0pPjSIyLavAzu3z9LgoKgpdoqdU52gJMmqiSXd9/scF7qKOtSvaePXu45647mD9/HjdcMIaNsx4iJYCqHgczdmh3Xpn1DXfc0WBR3YAxGo10TE1mZ5X1QHWTcOStNbsYFKDNGLxeEhYh2CAljRZow7toGNfCGbNUJdf178wjx/ZoUTsNkRsXxb1ffQ0tFGa9Xk+N1cG8V24kPTmOtKRYDIaW5YnISI5hz+5dLWqjzWmHNuZ68aNKdj6QedB+R7yRr0c1tbW1TJ/+GK+8/DJXnTOCP796mOgoc9MXNsLIQd25+O43sdvtmEzBqxSR27UrWytqw1aYd1TWUVBjY0ozr09UFP70eJoUZkcQZszRQlDuaDjqsKVMyEnlmu/Xsmr1Wvr369PsdvQGA5bICIb17Ry0sXVMTeCNN+aQlJxCp06dsFqtZGZmMmDAADp0qL/AbvhxFAizP1WygeVArhAiB9gLTAGmNmuU7YT58+dzxWWXMmJgF1Z+fA+d0oJTDy4uJpJeuZn88ssvjB49OihtAnTp0ZOtG38MWnvB5uZv15Kr02H20x/5cJKlxJ95nBOIb6EwxyjerHOhwqzXcVqXNO5/aDqzPqvvBtU/lBAkMZo4si8Op5t1m39gzU81RJoMvPrnXmweHavWrMNgMAS3w1AQXrocuirZPo+Na4H5eN3l3pRSrg/R+2hT6urquO3WW5gz63Nef+AiTjq2V9D7GDM4l0WLFgZFmO12O489/DAfffA+b5wUcGX1VuHxpZtYsrOYf7agjURVZZOiQCOmEDfexbiEFvQDEC8EBQ5XC1tpnHO6dOCmX39rURuhiPyLMkdwyenDDzkmpWT8tS/z4osvcNNNNwe1v5DQ3kwZza2S7dufC8xt9ujaAcuWLePiC6cyJC+DVZ/cS3xscMvZ72fssJ7c88o8Hn30Mb/Ot9vtlJSUUFJSQnFxMZmZmfTq1QspJYP796ODp46fzxtOx5iWmVlCwYy1u3jylz+5iJbVoE7A683RGFbAgFewWkKColDpx4xZVVWcqkqtS8XmdmN1e4jU68iMbmqJErrGRVFTW9eicep1+hbGOPqHEILnbp3MiCse5vzzp4a3SUPQ/oRZo36cTicPPnA/b7z+Ks/feR5nn9yUJbMlfbnRKYLfV6/l/fffx+VyUVVVRWVlJZUV5VRVllNaXOwV4ZISSsoqsDscJMfHkpIQw4Zte7jmmmt5+plnEEJw0aWX8saz/8GgC68PI8DsLQXcuGA1Z+NdlGgJCYC1iYXDOvA7g1xjxAjYU2Oly9vf4pESVZXeR9/mUX2uclJ6c5koAr0i0CsKTo+KxagnKyaS87qmcWWfrHp/KDpGm6h1OnE6nRiNzUtQFYoZc0P0yOnAP04fxu233sw7733QKn02DwHiKPLK+Luybt06LrrgfDISjPw+8//oUE9gSCCUVdSwZsteflu7nW2797GrsJx9pdVUVluprrNRa7UTHWmiW2YyH/3vSeIsZmIjjcRFGUiPMtEj2URybgeS47qSEh9FcqyFWIsJIQSf/bCWO99czIMPPXSgv9vvvAu73c7EV1/m6zMGtkr1E4fbw7KCCnolRZPUQH/vrd/NdfNWcTrQLQh9xuH1L27MZS5YwhwnoM7lYdGFI7yubjoFo05Bryh/ub/pvK5xh+cxcasqfxRV8v2uUl5evZMnVm7jxMwkHhzenQzLX3c0ETodAoHVam22MOv0rVuM9f+uOIVBFzzBzJkzOffcc1ut34DRZsztF4/Hw9NP/4d/T3+cx244g8vOPL5B305VVSkqrWL91gI27Shk255idhWUsa+smspaO3VWB1af877H4yE+1oLb48GgCC4aN5CcYd3JSUsgJy2erNR4TBGBL6AUldVw7XNzmP31vCNyGdx7/wPYbTZOf/9tvp40sNmFXRtje2UdC3cUs6iwhp92FmGxWJjSOZGHj+9+xLnP/LaFh3/cyJl4Z7qr8Joh9L7N4HsUeMXW6XssVhSsqooRb/rOCLyh2fufG4A5QD+8Qh3vO76fYAlzpKIQbdTTNyXwH2m9ojA4PYHB6QncNiyXxbtKeW7FNvq//wMpUSZOzEjk4eN6EGM0oAhwOptvyw7F4l9jREeZ+OCxSzn1X1cxaNAgOncOnjdIUAkvXdaE2V++++47rr3mav7cspWRg7rx8Te/8fpnP2KzO7E6XDicbpxOFw6nC6fTjd3pwqDXER9roUNyHBmpiWRldGDYwF6kpSSQlhxPWko86SnxxMdavOG3L37Cgu9+5d9XByeb2LaCMrI6dWLo0CPjeoQQPDr9CRwOB2d8/jFzJh1DbDPE/3C2V9bx0urdLNpTjtUjGTduPJdeOYn3TjyR7du3c8HEU3j4+EOvOe/L3/h6WxEAsw0G0pKT6T9gAEP79MFeV0ddbS11tbVYa2tRVZX4+Hhifdujjz3Gtf1y8AA1TjfVLg81Tjc2t4cKl4csl4slbpV5Lu8xh0dFEQKDIjAoCgKJ261yU42NQXqFkyMMJDfD3hyF8LtmYGMIIRidnczo7GSqHS4W7Sjmld93kPv2d/RMjMGtSpyu5guzTtHRSDhBSBiYl8Xdl53MlHMn89PSX5s92w8pQZoxCyEy8aav6ACowKtSyueEEAl4A/Gy8dZpOFdKWdFQO5ow+0FhYSFnnnE6Bp3CaWMGkxQfTVJ8NAmxFmJjooiLiSIu2vcYE0lcdBSx0ZEYjYEJXYzFjK2RChyBkpkSy97CwgZfF0Lw1DPPcp3DzplzZjPr9GOIbmFNvkU7i1mri+ez+Z/Qt2/fQ+4o4uPjqVNhc1kNcSYDc7YW8eWuSjZUOLjkkkuYNm0affv2xWLx3696zqefcHbXZPon+zdTlVJic6vUutzUutw8vnwLs7cV0ctiZondyVuVViJ1OpJ1gu7AaKOegXqlycXBKAVczQiEaYyYCANn9cjgrB4Z7K6ycvOitZjKdDjsjma3GYpE+f5w3fmj+W7FVu668w7+8/QzrT+AJgnalNkN3CKl/F0IEQ2sFEIsBC4FvpVSThdC3AncyWH5hQ5GE+YmqK2t5bQJ44mzRJDVMZXPX749ZH1ZoszYg1AFYz/piTFIj5u5c+cyYcKEes8RQvD8S69w5eUOzv5qId+cObBFaUG7xEVhtKr069ev3r4mnj6JMz//hCqHm1PGj+P6Jy5i/PjxmM3N8w7pmZfH5oodfguzEIJIg45Ig44UIkiOjGCIxcxNiVFAFC4p+dPhZrXdxQqnh0fq7NhUSaJBT4ZU6atXMErJHhWKVEm1QU+dENhUFX0Qc2AvLyhnZ6UVq8tNnctDnctDj0QLi3YUMeaUSSQnJSF8od3g8yrZvy8EQgiEUPDuChRFQQiBx+PB7fYw+oqncHtUVI/ErUoyU+N479HLMIWo6o0Qgjfum8qgC55g1OgxTJw4MST9NIsghmRLKQuBQt/zGiHERrzpKSbhdTsGmAEsRhPm5uF2uznvnMn0z4mj38k9efur5SHtL8YSiSOIwqzX65j5wPlMunAqewuKGowaVBSFhx+fTm7nj3F6VEz65ofodo23sPXHhguH3nXvfZw66QxOPPHEoEQx5vUfwOY5zc+LpeC939yPQQh6mQz0Mhl80VDRFLs9rLG7WOXw8FFVHTGREQzpmMQJsWY6xZjpGGMmI9pMdlzwXCWnfrWKYwYPISk5mShLNFHRMcRFR9PL8Tm7d2zjhqmjkXi9P6SUSAmqVL2PB455PUKkz0tE9T0O7zkRo0GPQa/DoNeh1+uY/d3vZI6/i8Q4C4oQCEX4hN/7+TDoFQw6HUaDjgijHo/Hg6pK6uwubHYXdqd3czjd5HVO4/vXbzniPSXGWXj/0UuZfPmlrFi5iszMzHreeRvh/29qkhBixUH7r/rSSRzZpDf52wDgVyDVJ9pIKQuFECmNdaIJcwMUFxdz8YVTEfYyXn5oGp8sWkmdLTgFMQ9HVVV2F5SyfXcRTldww3qP7Z2N0+di1ZgQfvD++0zqntEiUQboGG2mtLISq9VKZOSRvhCdOnUKapKqXr1789ZHzbe5CiGQTdhcU/Q6TrToONECG51uTu2XzV3HhyYnxn5UCf97awbp6emHHO/Zsyfvvvofbrz0lKD2d9Olp7Dg57VUVNXhUVWvu5/v0e3x4HC4sDtc2BxOrDYnT77xFTdeeCKZqfHERJuJi44kzueLPfHaF6iutRJjOfL/f2z/Ltw0dRRTzp3M4iU/h09UoP93iaVSyiZ9Y4UQFrx1G26UUlYHWnRYE+Z6+Pbbb7n4wqlcctpgHrhyGnq9joSYSGwhCrm9+bG3ee2jhSTFRzOib3bQ21dV2WQu57df+x/T+6a2uC+dIshKjGPr1q307du3xe01RV5eHpvLa5p9vSIOnTE3hQfQt0I2PiGo161t4MCB3LR+ewj6E4w73r//V3FZFc/M+IanbjmnXq+knl3S+c87i3jwX6fXe/2tF5/ED7//j3vuvot/P/lUi8YdPIJnhhJCGPCK8vtSys99h/cJIdJ8s+U0vFXQGkQT5oNwu93cf9+9vP3ma7z1wEWcOKzngdcS4yw4HKER5gijnhF9s/jmqZYEIDeMx+M5YvGqsLCQpUuXsvTnn1iy+Dt27tnNCac2fxa4r87OzE0FfLC1BBu6oCZbaoyuXbuSX1mN3e1p1mxfEYG5j6lSBtWW3BACUa8w5+TkYDSaWPrHnxw7IBje3oHjdHkDnhqaBf5z8vHc/O+ZvPLJD+h1OvR6BaNBz8nDe/LUTecQaTYy48GLGHjBdEaOGs2ppwavpmGzCZ5XhsAbGb1RSvn0QS/NBi7BW5LyEmBWY+1owuxjz549TJ1yDmZhY8X7d5J6WIrOxNgo7C3wH22MtOR4vq8OjZkEvGLyxx9/sGLFCpb9vISlS3+hpraGYb07M7xHGo9fPIwp92/lm+37OLWL/6GzNpeHr7cV8cHWUn7bW8qk00/n+funMWLEiBaHOPuLwWAgp2MGW6vq6N2MtKp6ReAOQJlVCa0RMNnQjFkIwa2338H012cw+6W2Eeb0lHhcbg9Olxuj4UgJmTZ5BCcNy/Ml2XditTvZV1bNCx9+R9qJtzKodxciIiJASq66chp78ve2wbs4CBHUYqzHARcBa4UQq3zH7sYryDOFEJcDu4FzGmtEE2Zg1qxZTLviMm66YDS3XnxivaKSEBuFPURJalIS46ixhy4BTpwlkmmXTGF4XiZje2Zw78SpdMtMPmTGM+XEAby88s8mhVlKyS97y/ngz33M2lLAwGOO4ZL/e4TPzzyTqKjQ5Alpip49e7K5oqBZwtw1NoqPAlhw9SAxtEZhAVH/jBngsssu55GHH2LN5t307d76RSUURcFkNFBeVVdv1KsQgs4dj6x+fv4pQ7j7+c/ZVGpk2pVXEh8fT0ZGmJQ2C5IwSyl/omG7yFh/2/lbC7PD4eC2W29h9hef8vlTVzC8X5cGz421mHG7PVitdiIjg3ubnpoUS10z7Ndut5uZ369h7rJNvH772Zgi6nd1KvziniYrppw3ph8fLvy9wdd3VNbxwca9fLSlGHNMLBdfMY1HLrooLL5Yef0HsGn+1mZdOygljpIAFlxVCfpWCN/dX2mkPkwmEzfedDP3v/g5nz9/XUDVcIJFhNFARbU14HQE8dGRpEckN+i+2WaEWUh2eGXuaEW2bNnC8KGD2LPxV1Z+cEejogw+/1ezkR35jdrsm0VqUhxWP4V5z74Kbn1pDn0ufYb40x7krtcX8OO63Vz7bMMmK3++uMN7dQIhmOeLwAOotLt4a80uTv7id8Z8toLafqP55JsFrNuyjTvuvDMsRBmgV+8+bLE2z5slJ8aMS0pmVlr5oc7OOruTQpcbZwOi6EFiaAUzjWhkxgxw7bXXUVDu5KGXvgz5WOpFgMsduGvn2ScP4uOPPsLpDF3u6max35zR1NZK+JOP+U28lUqKpZS9fcfOAR4AegJDpJQrGrh2J1CDdzHb7Y+bSWvw6aefcvWV/+SBKydw1Tkj/J5xxEVHsiO/mF7dgnv72CEpDlsD0VyqqjJn6QZen/Mbq7bvo7SihqH9unLl+Scy/oR+dM1K5aeVmzn1yqd4+pqJxFiaN5tXFIXzxvTnhT+2IITgw60lLNxexNjRo7jjmYc45ZRTwse16TDy8vLYVNG8Ks37AzPecbpRXIJapxuby43DrfoSD+kw6Lzh2wZFwSrg4WVbeHH1bnQC9AJ0QmAQXh9oo04hQqdgMihEKDpMBgWzXodJr2DS64g06L0BLnodkUY9kXodUUYdFoP+wGO0UQ8+/+OGiIyM5Ku58xg+bAiZaQlcNnlkc/98AZNfVEad1U737MC9eHIykpCqSk1NDYmJwSkkERTCbMbsjynjbeBFvPHf+1kHnAX8z4/rR0spSwMfWvBxu93cdecdfPrx+8x94V8MzMsK6Pr42Ch2F5QEfVwJcRacLjfVtXZiLCaKK2p56fOfmb10EzsKy4gwGpg0dhBXXjyBMUPziDQfmp3t+IHdGdSnM9Oe+oyPHrig2eMYP7Qb7y9Yyb932Lj4ypv53/nnk5DQ0hTyoadbt27sLKvE5VEDtv9W+xZ0t9wy4RA3OFWV1LncVDvc1Dhc1Pgez3x/KZed1J9e2Sk4nB5cbg8Ol9u3ebC73Ngc3uc2p5tqp4sSp/e43erA6bJ6z3W6cfoW0JxuDy63isvtweVRcXs8SAllZWWNJv1JTU3lm3kLGDnieNJT4hh/wpHRlqFg4dJ1ZKcnExFgyoH9mCKM2Gy2II+qJQjCLYuRP4nyl/giWA4+thH8u0UOF/bt28eUc8/GqNbw27u3kxgXeJ27pLhoCoobzDvSbMorazFFGDnznrfZVlTJvrJq+vXI4oIzTmDCiP707JLe5N/6ydvOZ9RFj1BaWUtSM94bwMeL13P1tTcw/YknmnV9W2EymeiYmsr2aivd4wN77yv3VZEYFXGEb7KiCKIjDERHGPCWdvUSZTJy4dh+9OuSFoyhN8jpD35Cfn4+gwcPbvS87t2789nnX3LGpNNY8Ppt9OsR2GSjOZiMBlTZvLwgG7YVYHM4cDian+8j6PwNE+VLYIEQQgL/ayh0EUAIMQ2YBgQ1Mgzgl19+4dyzz+LS0wZz37QL0DVzVT0lPprCAIVZVVU2b9/LirXbWPfnbv7cWcDeonIqa+qoqbVRU2fD5XKTlBBDRmYa/7r0NE4c3otYPypaHMwxedmMHtaLf0z/hDnT/xHQtQDf/76VhSu2su2TbwO+NhzI69mDTRVlAQvzqpIqsgK4RkqJrhVszL0z41mzZg1nnnlmk+ced9xxvPDiK0y65gZ+/uD/yEgN7V2OJdKEvZnJth55Yz7XXncjXbo0vqbTuggQLYt4DTahFubjpJQFvrjwhUKITVLKJfWd6BPtVwEGDRoUlPxXUkpefvllHrz//3jt3qlMHNmyW73kBAs7CqsO7LvdbkoraigqqaS0opqKqjoqq2vR6XVs3LqXVRt38/OKdegUQXpqAtkZyXTtlMoJA7qSmZZIVnoSndISSUmMCYrf753/PI0zrgk8c9f3v29lysMf8/Ennx+Rt7m9kJLZide/+YMqh4u8BAu9E6Mx6b0f7x1VdZzy9UoQ+yuHKCh4bcPVDic9kv1/z1K2TuRf7+xkZq1a6ff5U6ZMYceO7Uy8+lm+e/sO4mJC57oYbTHjbKYwe1RJnz7Nr/IdMv5OM2ZfDUCklMVCiC+AIUC9whxsrFYrV027gtUrfuGnN2+ha6dGc4YcQnllLT+v2sbKTbvZsHUvu4oqKa+uo6KqDofTRWSvKd4sXR4Vo0GPOcKA2RSBwaBjT2EZo0edwIknjefGSZfz3emn417/TquYffrkZlJZY8XpdGP0I33nxp37eOS9H/juj+18/MnnjBkzJuRjDDbLli3jiUcf5scff6RfViIvby2kqLKWaqsTs1FPVIQBl9vD6L7Z3HTaQGxON3affdflUVm6aS/zVvof4qxK2ew7rkDok5PKo599E9A1d955F0VFhYz751PMf+3WkIlzdGRE0HO6tDl/l9JSQogoQPGlvosCTgYeauKyoLBt2zbOOuN0+mTH8fNbtxAZYHWO9JNuJzkhhs6ZKXTPSWdI/+7kZKaQ0zGZ5PhooswRmCIMmCIMh8x0n37rGxat2sc38xcihMDlcqHT6VrNFm+JMhEXHcnP63Yy+piuDZ63s7CcB2Z8z/zlW7jpllt57fPrAsqBHA4sWbKEe++6nV3bt3HzhH688+JlRB2UstLtUSmqrGNveQ2FFXWM7tWJ2KgjS1plJ8fy8c+b/O5XSom+FUwZ3TsmsXN3Pna73e/wdiEEzz77PDfeeD3j/vkU8169NSTFgQ16PWpbJHUOKe1sxiyE+BBvHtEkIUQ+cD9QDrwAJANfCyFWSSnHCSHSgdellBOAVOALnyjpgQ+klPNC8zb+Ys6cOVx+2SXcd8V4rj53ZMCi6HS6cbs97Fn8fMB9P/3OfBYsWnygT28eXMHPv//Jcce0Tvhszy4ZLP5jW73C/OeeEl74fBkffbeaa6+7ni0fLSAmJvBouXDg0Qfu5YQ0hQXXXYyhnhwZep1Cx8RoOiY2bqbo2iGOKqsDVVX9Mid5Z8yh/xIbDXq6dExl48aNDBgwwO/r9ovzrbfczPEXPMKsl26ga1YYV6gOC1rXR9kf/PHKOL+Bl76o59wCYILv+Xa8pdZaBY/HwwP338fbb77G50/+k2P7N39xwWwy8uOKzZww6MjadI1RWV1LTk7OgX29Xs8777zLOddfQ8EPzzV7PIHQr0cWKzfvOrDvdnuYs3Qjr8xZwdrtRVx2+RVsfOVTUlL8N+2EI7k98oiv21SvKAdCQrQZnU5hS1kt3ZOb/pGSklZZ/APonZ3CunXrAhJm8Irzf55+hq65uZxw4f+x9MN7yenYvv/fIUUQdot/4WVYaSZlZWWceso4flzwJb+9e3uLRNlo1HPNlNFcdk+DDiT1oqoqdvuROY/PO+886qx2Kqvrmj2mQOidm8H2ogpm/bSea56dTeepT/HM1xv5x/V3szu/gMenP9HuRRkgr3cfNhU1P93nwWQlx/DjTv9c7VUpW2XxD6B3ZhxrVq9q9vVXX/0vJpx6GvOWNFy4QMNHe4v8C3dWrVrFmZMmEmsW3HLxScz9aS3H9utC9+zm375dc+4onv/guwZfX752O8tWbcFoNGA06Ikw6imrqKFb185H5D12uVzExcWyq6A0pCvl+8nrksG+8hpeXridcadOYsEj/yMvLy/k/bY2PXv25MP/VgalrR4dk/hjbwXqQBW7W8Xqi/yzu1VvAVe3B5vLW8hVVVV0rZD2E6B3Tir/+/GPFrVx7HEn8MPX73P11CANqoWUVtTiakEx2dDQDgNMwp2FCxeQ1SmTqKgo5qwsY9uOXazbWsh/bjm72W0mxllwudxIKeu1UT/zzkIqnCY6dcrE5azDYfc6zN9626ElvNxuN+efdw4De2bSq2vHZo8nEHp0TkNFYcF3P7SrAKBA6dmzJxt3Bydvic3u5I3VO3h9xXYU37qAThHoFMW76bwudjqdgsPlweMJbtHVhuiT3YF1/22ZX/nIkSN55MF7G/wstwbVtVaenLGAd2f/wp59FVxwRThF/fn4u3hltBa33XY7t932V4HUJ554grJNi1vUptGgIAGXy1Ov25nV4eLqa27hjDPOaLSd0tJS5s6bz8pPH2oVFyuAKHMEdocDl8sVnmXig0RqaipuVVJSZSU5NrBgnMPR6xSunjiU568+pVHxcrrcmCc+zPUvfU1FrZWSKhsIgc3pDbE+EJrtdHPN6UN44p/jm+zb5nDhdHtdL12+x/2b0+2hpKyciooK4uPjm/XecnNzcbpVtu3e12qLgNW1Vr75aT3f/baJH1f+yc6CMnplJXPvOccy44dNZGWFPjoxYMJsEtPuhflgpJQs/3UZAzKan5bT6XQzcOpjHJOXjV5fv5hWVtcRG9t0usMOHTrw0EMPMfDs+3C53MRGR/Lrxw/QOTN0Nt7Vm3aT16PbUS3Kqqry0ksvIpA4m5Hh7HBioyKoqnM0OaNUFMHlpwwCCYv+2Ead3cUzN55BfHQkcRaT79HM9Pe+48/8sib73VFYQY/LnyPSbEKv02EwGHwVP3To9Xr0Oj09u3fDZrM1W5iFEFx11dWced0LPHX7eZw4vHdQJwlut5sFv2zgy+9WsWFbAbsKyiipqCEtMZr+nTtw7fj+nDGsO+k+75h3lvzpTZIfdmjCHDJmz57NokULee3rRxs9b8bspbw9eymqyoGCk/srCBeUVJLTMYVvXr2tQfepopJKvzOt7Z/Rf/TRR9x+y/WkJITWPW3l+h0MGjwkpH20NY8/9iifv/MqPz10HhlNuMP5Q3yUiZ0VTd9e63U6Xr1hIgD5JZX07pbJ1Wced8R5ybFRFBeXN9leWY2Vvnk9WLl6XeCDDoD7H3iQzl26cu8zT3Hl/W9z3ilDGNgrm349OpGWHIdep0OnUzDodYd85qWU1NTZWL5mO8vXbefPnUWUV9ZQUFyJw+Gk04m3UVpVS1yUiWE9MxnfuyODzxrCcT0zsTQQO+BW1fDLUigEQgkvr4yjSpjHjRvH8OHDmfboB0w781gMeh19u3U8UL13Px988xtVdQ7OOmmwz4aooNd5H80mIxdPOr7BpPMAd087lannn8evv60gLc2/ZDYxMdFkdsomfeT1DMjrzFO3ncvgPg1nDmsuKzbs4dhxU4LebriwYsUKnnv6Pyx/bAqZScH5kUu0mFidH1gOFINewdHAbD3KbOCn9XvoeulzeNcJBYrirePnXdwXCMDp9qA3tU5gz0UXXcRFF13E6tWr+fLLL5n5wwrufm4WJaVleFQVt9uNoij06JJJpCmCPYWllJRXAqC63fTvkkbnDvFkRpvp1zuDi47NpUfHRPrlpJIS5/+ittujoteHo+xoM+aQYTKZ+GLWHK6/7hoe/2A5NpuNfUUFzHrmSnp1+asM/KnH9+G1L5fyf1ef0ax+Lp50PN/9uonPP/+ca665xq9rJkw4lQkTTqWoqIjc3K4hc7lasW4H198TFmmvQ8LjDz/A/ZMHB02UARKjzVRbA6u5aNDrcDZQkurqs47jmO6ZvrswFY8q8XhUJBzYV1XJlj0lfPNH69a769evH/361R9eYLVa2bBhA1arlaysLJKTk1m3bh3X/mMKy6YHx62jsRzTbYfQFv9Cjclk4tXX3jiw/847Mxh75U28/+gljB3qrXo95ZTB3PbMp9jsTsym5tlih/bN5o/f660P0Cgvv/wSk8YMZEBedrP6bYxtu/dRXF4dnkligoTq8ZAawAzNH1JiI6mxBpaG0qjX4XTXny8iJT6aicf3arKNlZv2MH91YUD9hpLIyEgGDTr0R91isVBrC161EYvJSG1t84oahJbwmjGH189ECLj44kt46JHH+M/7Pxw4lpIQQ1ZGMrc/9VGz201NjKW0ODB3rcLCQl568QUevq7pVI7N4e0vfuKCCy4MPxteEImIiMARQPFUf3CrapvM5ExGA/YGKteECxaLhZoA7yYaIzrSSHV1ddDaCxphFmBy1AszwAknnMCO/EMrj3zz4rXM+HIJi3/b2Kw2k+NjKCkNTJjvv+9eJo0ZQKf04JfUsTuczJj1M5ddfkXQ2w4njBERQfHEOJgPftzIsb0Cc+HyqGqLkxmZjPqwF+Z335lB76zgeRHFR0VQWhoWBY0ORSj+ba3E30KYTSYTFdW1rN6858DMqEtmCpPHDuCpN+cG3J6Ukve/+gUpA/sFTUlJZv7SjXQ++TauuPdNPvz6F/aVVjV9oR88+cY3DB4y9Kg2YwBUVVYSGxlcd6t5q3awYnM+0z9awuc/baCs2trkNS632uI8HRCuNlcva9as4dmnn+KVK8cGrc3huSl8v3B+0NoLDkIT5rYgOzubS/9xOZPvmEHX0x/g5v98yuIVmxkxsBvb9+wLuL3Siho+/PoXZs35OqDrHnn0cfL3FjJ/0WIGjDyTT37YSc/T7mLA5Pu59d8f8s2S1dTWBX7buH1PMc+/v5Bnn38x4GvbG1u3bWsyY1ygfHjjaQztksqsnzcy7dnZ3P/u901e41HVBv3c/cXmdBEZaW76xDbA6XRy8QVTmH7RCDolN+2z7y8TBnZl3oIFeDzBvetpEYKgCbMQ4k0hRLEQYt1BxxKEEAuFEFt8j006pYe6SvZ44DlAhzcd6PQm31kI0Ol0/PvJp3ji30+ydu1avvzyC2578TPWb9xEpMnIG58tZtTgnnTOTPErbNVo0KMoCsnJyQGPRQhBjx496NGjB9dddx1ut5sVK1awcOECnnx/Pufd/BIDe3dl7NBujB3ei8G9O6NvZGbm8ahccd9b3HHnXeEZURVESkpK2PDnNq58w4UQHOJ/fsFx3bhjUvO8Uc4e3oOzh/cA4NrXFvDl0o2kxkWhUxSEAEUInG4P1VYH1VYHNVYHv23eS7fO6U203DhWuxOzn7mWW5uHHryfjha4dGzfoLabmRxDx6QYZs+e7VfZrNYjaPbjtzmyePWdwLdSyulCiDt9+3fUc+0BQlYlWwihA14CTgLygeVCiNlSyg1+9BkShBD07duXvn37ct9997N161beffcdvl+3iftf+jc6ASMH92Dk4NxGhdpo0OMMUiIWvV7PsGHDGDZsGPfeex91dXX8+OOPLFwwn2se/5Sdu3YzYkgeJw7pztjhvejR+dDCrE+//Q3SEMMtt9walPGEM0lJSaxevRqXy+XLda2gKArLli1j5v+e5o5JLe8jMTqSylo7i9bsPiD6UkoMeh0WcwRRZiPR0VGce9JAzh7dsqy2NocLszn8ZszLly/ntf++wu9PXxKS/BpPXzqSKVf8g/KyMi6/IhzWRIK3sFdf8WpgEt6c9gAzgMW0VJhbUCV7CLDVl5cZIcRHvgG2mTAfTteuXXnwQW9RFSklW7Zs4fvvv+f7779tVKiNBj0OhzMkiWGioqIYP34848d78ywUFxfz3XffsXDBPP5z9fO43U7GDuvF2GE9SE2M5T8zFrB8xe9HZLU7Gtn/w3o4P/30E50Sg+NCl5eZSHpSLD+87J9/ekuw2l1ERrYsz0ewsdvtXHLh+Tx7+RjSEkJT/3FUnywWPzKFU+69C3OkmalTLwhJP4Hht1kqSQhxsIXg1caKTPtIlVIWAkgpC301UBsllH7MGcCeg/bzgaENnRzKKtn+IISgW7dudOvWjSuvvBIpJVu3buX7779n8fff8sDLTyKkysghPRk5KBfwJucPdRRTSkoKU6ZMYcqUKUgp2bZtGwsXLmTOwnn8suxLnnv+xaPehNEUUkoMQagqUl5j47EvfiMuunVmseEYBfefp54kLzWS804IbarYHh2TmH33mZx03TVkZ+dw7LHHhrS/JvHfw6ZUShnyCK5Qfirq+6Y0uAQdiirZLUEIQW5uLrm5uUybNu2AKC5evJjF3y1i4ID+bTKmrl270rVrV66++upW7z9c6du3L28+X9L0iU1wymOfk9EhgQ8evCgIo2oanSLCaxEM+HPTBoZ0aZ1CCn2yU3jz2vGcO/lMNmze0oZlzgQh9oPYJ4RI882W04Am/WxDOZp8IPOg/Y5AQQj7Cyn7RfGKK67gvQ8+YvnK38NutvN3Zfjw4ewuqWZncctcD/PLa7jz4rGtNmPW63S4G4gebCtuvOV2nvlqJXX24EX7NcaEQV0Z168Td9/ZqMk19IQ2wGQ2cInv+SXArKYuCKUwLwdyhRA5QggjMAXvADU0goper+fiSy7m0S+XN7uN/LJqyqqt9OvaMk+LQNDrlbCr5jFgwABGjBzFQx/93Gp9PnHxCD6d+RHLlzf//9dyhJ9bE614i1f/AnQXQuQLIS4HpgMnCSG24HWGaNI7rUlhrq8jIcSZvorZw/FWyZ7vOzddCDEXQErpBq4F5gMbgZlSyvVNvjMNjWZw3wMPMW9NPj+s39P0yYdx9wdL6Hnjm1xy6lBiLa3nJREfbaaisrLV+vOX51/6L7NWFfDsrNYRyoRoMw+ffxw3X39t2wTcCII2Y5ZSni+lTJNSGqSUHaWUb0gpy6SUY6WUub7HJnPCNinMDXT0he95hJQyVUo5zndugZRywkHXzpVSdpNSdpFSNp4kWUOjBcTGxvLam29z4UvzyS8LrEjrJ8u28sLNk/nf7c0vR9YckuMslJY1nbe5tUlNTWXR9z/wzNzVzFq2uVX6vHRsX0oL9/Dzz603U/8Lf2fLWjFWDY2AmTBhAtfeeAvnPvsai++bjNHgnwuh3eUiJz2hRX273B5sDhc2hwur3XnguXffhc3512t23/GqWjslZeVtWo+vITp16sSnX8xi4oRx9OiYRPeOwc/vcjA6ncLEQZ1ZuGABxx9/fEj7qhcRXu6mmjBrHFXccedd/PLTj9z2/o/ccuox2F1uHC5vpWu7043D7fHuu9zYXd7nNoeLr37ewC9rd3rF0+HB5nRjc3qwOlzYHG6vsB4iuE6sNgc2hxOb3YGqSiLNJsymCCIjzZhNJsxmE5HmSMxms3eLjCQyMgqTOcb7vKOFZ589I+xEeT9Dhw7lkceeYPL0B1n8yBSSYkLrc31sj3T+t/THkPbRIGH2P9CEWeOoQlEUZrz/ISePGcUJD3+BKSKCCKORiIgIIiIiMJkifM9NmEwmIkxR9Ok3AFtsN6piYomMjKJD5F9iGunHc7PZjMFgCFuBbQnTrrySXbt2kHX5M3RIjCUtIYaUuChizAaiTXqiI/RYTHriLWbSEiykJ1hIT4gmIzE64L+HQa+gqq1TgfxQWtdM4Q+aMGscdcTHx7P8j9VtPYyjhkcfm849/3cfhYWFFBUVsW/fPqqrq6mpqaG2tpbq6ip2lxQz//d8Cgo2kl9QiNvtYmiPTqTHRyGRvrwmeMPcpe+5L9eJ9B0vLKsiMTO3bd5kmP2oasKsoaHRJJGRkXTp0oUuXbr4df7evXtZtmwZZWVlh+Q1qW87+PW8vNBGHDaMJswaGhpHORkZGUyePLmth+E/2oxZQ0NDI4wQWjFWDQ0NjTBEE2YNDQ2N8EIzZWhoaGiEG5owa2hoaIQRmh+zhoaGRtghtMU/DQ0NjTBDszE3zcqVK0uFELta2EwSUBqM8bQi2phbB23MrUNrjDlIddU0YW4SKWVyS9sQQqxojdpcwUQbc+ugjbl1aDdj1vyYNTQ0NMIRbcasoaGhEV5oNuZW49W2HkAz0MbcOmhjbh3ayZjDz5Qh2qTGloaGhkaYMOiYfnLFj9/4da6wZKxsDbv50Txj1tDQ0PAPzZShoaGhEW6ElzCHl2ElSAgh4oQQnwohNgkhNgohhrf1mBpDCNFdCLHqoK1aCHFjW4+rKYQQNwkh1gsh1gkhPhRCmNp6TE0hhLjBN9714fo3FkK8KYQoFkKsO+hYghBioRBii+8xvi3HeDgNjPkc399ZFUKEsducz8bsz9ZKHJXCDDwHzJNS9gD6ARvbeDyNIqXcLKXsL6XsDwwErMAXbTuqxhFCZADXA4OklL0BHTClbUfVOEKI3sA/gSF4PxenCSHaqJZRo7wNjD/s2J3At1LKXOBb33448TZHjnkdcBawpNVHEwgCTZhDjRAiBhgBvAEgpXRKKSvbdFCBMRbYJqVsaeRja6AHzEIIPRAJFLTxeJqiJ7BMSmmVUrqBH4Az23hMRyClXAKUH3Z4EjDD93wGcEZrjqkp6huzlHKjlHJzGw0pQISfW+twNNqYOwMlwFtCiH7ASuAGKWVd2w7Lb6YAH7b1IJpCSrlXCPEUsBuwAQuklAvaeFhNsQ54VAiRiHfME4AVbTskv0mVUhYCSCkLhRApbT2go4WVv6+eL8xJSX6e3iph8UejMOuBY4DrpJS/CiGew3vbd2/bDqtphBBG4HTgrrYeS1P4bJyTgBygEvhECHGhlPK9Nh1YI0gpNwohngAWArXAasDdtqPSaGuklIebYNqco86UAeQD+VLKX337n+IV6vbAKcDvUsp9bT0QPzgR2CGlLJFSuoDPgWPbeExNIqV8Q0p5jJRyBN5b7y1tPSY/2SeESAPwPRa38Xg0QshRJ8xSyiJgjxCiu+/QWGBDGw4pEM6nHZgxfOwGhgkhIoUQAu/fOawXWQH2mwCEEJ3wLky1l7/3bOAS3/NLgFltOBaNEHNURv4JIfoDrwNGYDvwDyllRZsOqgmEEJHAHqCzlLKqrcfjD0KIB4Hz8JoD/gCukFI62nZUjSOE+BFIBFzAzVLKb9t4SEcghPgQGIU3beY+4H7gS2Am0Anvj+I5UsrDFwjbjAbGXA68ACTjNXetklKOa6MhtiuOSmHW0NDQaM8cdaYMDQ0NjfaOJswaGhoaYYYmzBoaGhphhibMGhoaGmGGJswaGhoaYYYmzBoaGhphhibMGhoaGmHG/wPgGut2L8rX8wAAAABJRU5ErkJggg==\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "tracts.plot(column='CRIME', cmap='OrRd', edgecolor='k', legend=True)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "All the 49 neighbourhoods are colored along a white-to-dark-red gradient, but the human eye can have a hard time comparing the color of shapes that are distant one to the other. In this case, it is especially hard to rank the peripheral districts colored in beige.\n", + "\n", + "Instead, we'll classify them in color bins." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Classification by quantiles\n", + ">QUANTILES will create attractive maps that place an equal number of observations in each class: If you have 30 counties and 6 data classes, you’ll have 5 counties in each class. The problem with quantiles is that you can end up with classes that have very different numerical ranges (e.g., 1-4, 4-9, 9-250)." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "ExecuteTime": { + "end_time": "2017-12-15T21:30:30.408917Z", + "start_time": "2017-12-15T21:30:30.088920Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Splitting the data in three shows some spatial clustering around the center\n", + "tracts.plot(column='CRIME', scheme='quantiles', k=3, cmap='OrRd', edgecolor='k', legend=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "ExecuteTime": { + "end_time": "2017-12-15T21:28:00.376417Z", + "start_time": "2017-12-15T21:27:57.039Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# We can also see where the top and bottom halves are located\n", + "tracts.plot(column='CRIME', scheme='quantiles', k=2, cmap='OrRd', edgecolor='k', legend=True)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Classification by equal intervals\n", + ">EQUAL INTERVAL divides the data into equal size classes (e.g., 0-10, 10-20, 20-30, etc.) and works best on data that is generally spread across the entire range. CAUTION: Avoid equal interval if your data are skewed to one end or if you have one or two really large outlier values." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "ExecuteTime": { + "end_time": "2017-12-15T21:28:00.376417Z", + "start_time": "2017-12-15T21:27:57.045Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "tracts.plot(column='CRIME', scheme='equal_interval', k=4, cmap='OrRd', edgecolor='k', legend=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "ExecuteTime": { + "end_time": "2017-12-15T21:28:00.386417Z", + "start_time": "2017-12-15T21:27:57.048Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAVUAAAD4CAYAAABc+XWqAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8vihELAAAACXBIWXMAAAsTAAALEwEAmpwYAABx6UlEQVR4nO2dd3hU1daH332mT3onDRIg9CaEIqiAdFBsWLACdsXPeu2993ItVyzYRUXsooKCIALSpPdOCCQhfTJ9zv7+mIABEjJJZpKA532eeebMKXuvSWZ+s87ea68lpJRoaGhoaAQHpakN0NDQ0DiR0ERVQ0NDI4hooqqhoaERRDRR1dDQ0AgimqhqaGhoBBF9UxtQHfHx8TIjI6OpzdDQ0NColuXLlx+QUiZUd6xZimpGRgbLli1rajM0NDQ0qkUIsaumY9rtv4aGhkYQ0URVQ0NDI4hooqqhoaERRDRR1dDQ0AgimqhqaGhoBBFNVDU0NDSCiCaqGhoaGkGkWcapamgEA1VVWbx4MUIIzGYzZrMZi8VyaNtsNmMymRBCNLWpGicQmqhqnLDs2bOHgQMH0qtbe5wuN06XB6fLhcPpwul043S58Hi8mExGzCYTZrMJq9XKtM++oE+fPk1tvsZxiiaqGicsLVq0QFEEf3z+FHq9rtpzVFXF5fbgcLpxutxccccr5ObmNrKlGicSmqhqnLCYTCYSE+LJ2X+AjLSkas9RFAWL2YTFbPJfYzSg01UvwBoagaBNVGmc0GS0asXOnLyAz1el1ERVo0FooqpxQpOZmcmOPYGLqs+nHhJVn8+Hy+XCZrNRXl6OqqqhMlPjBEK7/dc4oclo3ZadOdsCPj/camLMmDGoqooQAr1eh8Hg/5rY7U4sFjPhYWGEh4cdeo6IiCAqKobX3vgfCQnVZoPT+BehiarGCU1mZiZzf1gc8PlfvHYnPp+KXq9DUQ6/kVNVFbvDhc3uwFbhxGZ3UG5zYLM7ue3xqWzZskUTVQ1NVDVObDIzM5makx/w+TqdrsYxVUVRCA+zEB5mgSO087m3v8XpdDbEVI0TBG1MVeOEJjMzk505+0Pej8VsxOFwhLwfjeZPraIqhJgqhMgXQqyt5tgdQggphIiv4dqdQog1QoiVQggtlb9Go5Oamkr+gSJcLk9I+zEbDZqnqgEE5qm+D4w8cqcQIh0YBuyu5frBUsoeUsrsupunodEw9Ho9qSnJ7M4NfAigPmieqsZBahVVKeV8oKiaQy8BdwIy2EZpaASTzIxW7KzDuGp9MJk0T1XDT73GVIUQY4G9UspVtZwqgVlCiOVCiGtqafMaIcQyIcSygoKC+piloVEtrTIy2bEntOOqFpPmqWr4qfPsvxDCCtwHDA/g9AFSylwhRCIwWwixsdLzPQop5VvAWwDZ2dma96sRNDJbt2VHzlFTAkHFrHmqGpXUx1NtA2QCq4QQO4E0YIUQosWRJ0opcyuf84GvAS31j0ajk5mZya69B0Lah8VkwG63h7QPjeODOouqlHKNlDJRSpkhpcwAcoCeUsrD7q+EEGFCiIiD2/g929C6Cxoa1ZCZmcmOOqz/rw+ap6pxkEBCqqYBi4D2QogcIcSVxzg3RQgxs/JlErBACLEKWAL8KKX8ORhGa2jUBf/6/30h7cNiNuFwaJ6qRgBjqlLK8bUcz6iynQuMrtzeDnRvoH0aGg2mRYsWlJbZsDucWC3mkPRhNhlwHtAmqjS0FVUa/wIURaFVelpIw6osZhNOuyaqGpqoavxL8C9XDd24qn9MVRNVDU1UNf4ltKpjXtW64h9T1URVQxNVjX8JmZlt2BHC23/NU9U4iCaqGv8KWrduHdJYVYtJ81Q1/Gj5VDWaDLvdzq5du9i1axfdu3cnOTk5ZH1lZGSENFbVYjZqcaoagCaqGo3A1q1b+fnnn9mxfTu7d25j586d7NqTQ1m5jVapiSTHR7F1zwG+/f5HevXqFRIbMjMz2bE7eKWn7Q4ny1Zvxe504nC62bQ9B4dDE1UNTVQ1GoGZM2dy8803c8+VozinbyoZ53SiVXIsSXGRh0qWfD3nb0YOH8qI4cPp3K0HPp+PdatX8ufChSiKQu/sXlgsVgAUnYLeYMRgMCCEAPylTmxlZZSWllBSUkJpaSll5eU4nS5cbjcutweHw0nOvgOkJVeb/rdOfPz1XB597Uu6dO6IxWLFYrFw+YSJDW5X4/hHSNn8cpdkZ2fLZcu0nNYnClJKrr/uWjatXMiPr96A2WSo9rwdew8wd+lGNmzfj0Gvo12rJPr3aIOUkhUbduPx+gB/xVOP14e38jWAEILwMBPREVaiwi1EhVuIDLdgMRkwGfUYDXo6n/MQz913NReccVqD39PLU79hR4mJ//731Qa3pXH8IYRYXlOOaM1T1Qg5Qghef+N/XHrxRVx63/t8+fzV1Z6XmRpPZuop1R5rn3FUvp460yY9kZXrtwdFVN1uL0ZjRIPb0Tjx0ERVo1HQ6XS898FHhIWFAdWLaqhpn5HEhm17gtKW2+PFZA7NkleN4xstpEqj0VBVFZOx+lv/xiCrZSI5ucEJq3K5PRiNxqC0pXFioYmqRqPhdrsxNqGotkqJo6i0PChtuT1eTCZTUNrSOLHQRFWj0XC73RgNTTfilJkaT1l5cNLzuT0+TVQ1qkUTVY1Gwy+qTeepZqbEU26zo6pqg9tyub3a7b9GtWiiqtFouFyuJvVUoyOt6HQK23Y1PGG126uJqkb1BJL5f6oQIl8IcVQpFCHEHUIIKYSoNppaCDFSCLFJCLFVCHF3MAzWOH5p6tt/gNSkWBat2NjgdjzamKpGDQTiqb4PjDxypxAiHRgG7K7uIiGEDngdGAV0AsYLITrV21KN4x63241Br2tSG1qnJ7B6w44Gt+NyaZ6qRvUEUk5lvhAio5pDLwF3At/WcGkfYGtlWRWEEJ8BZwHr62eqxvFOamoq+wtLWbVpD93bpzeJDVnpibw/YzYr1m8jzGLCajYTHmYmzGom3GomMiKMyHAL0RFhREZYiY4MJyYyjJjoCGKjIjCb/ULq9miiqlE99boXE0KMBfZKKVcdXHtdDalA1UjrHKDvMdq8BrgGoGXLlvUxS6OZEx8fzzPPPsfEh55g8Uf/aZKhgN37CikqsXFynAGby01FRQX2Ii8FLi8VLg92txe7y4PD7cXh8eLy+HB5vLi8PjxeFSEEep2CImDY2Isa3X6N5k+dP9VCCCtwH/6S08c8tZp9NSYakFK+BbwF/rX/dbVL4/hg4sRJfD1jOk+9+zMPXXdGo/efmhjNmT1b89i5fep8rZQSj0/F7vZy/pTftR9/jWqpz+x/GyATWCWE2AmkASuEEEcuzs4Bqt7jpQHBy72mcVwihODFl19lyow/ghLaVFdapcSxr6SiXtcKITDqdURbTTUmhdHQqLOnKqVcAyQefF0prNlSyiPX/y0FsoQQmcBe4CLg4vqbqnGikJWVRUpKKj/MX83YQT0ate+26QnklTZ8AUByhImzzz6L6Ihw4mKiiY+LIy4ujrj4BGITE4mLTyQhIcG/74iHNhZ7YlOrqAohpgGDgHghRA7wkJTy3RrOTQHekVKOllJ6hRCTgV8AHTBVSrkueKZrHM/c98DDPPrgnZzWsx3RkdZG67dD62SKbA0ve/LWZQN4fXw/iu0uCm0uDtgcFNlcFNr2UZizg8JNbrY5vBTaPRTaXBTZHBSW2ykqq8BsMhIXE0VGRga//v4HOl3TRkRoBJdAZv/H13I8o8p2LjC6yuuZwMwG2KdxgnLOOefw808/kjX2QXp1aY3Pq9I6LZY+nVty/rBeRIZbQtJvVnoiDrcPj9fX4PAug15HYqSVxEgrEBPQNVJKyhxuCm0uejz8JXa7nYgILYXgiYS2okqjSVAUhbffmcrfq9Zwyz1PcPejz9PttHP5YfkBBkx4nl25hSHpV6dTMBl05JUFJwdAXRFCEGU10ToxEqtW1+qERMunqtGktGzZ8tAs+rBhw7jpppt49tlnOP/Ot1ny8V31anPtlr3MX7EZu8ONUAQpCdFEhZt58/N5LFq5FYfby59b93Nhn6b1EM1Gg1aB9QREE1WNZsdtt93Ok088QX5RGYmxkQFdo6oq597yBvOWbsTrU2mTFI3ZoEdKSVGFkwqnhxHdWvHV5BHcOX0xOwuCkwKwIViMBs1TPQHRRFWj2aHX6xl46gDmLNnIRSNrjydVVZV+lzxJeXEZ8+45m84psShKjYtSSIqysre4fmFVwcRs0Gue6gmIJqoazZLTh41kzh/fHBLVZ9/7mdWbc7DZXdgcThwONy63F6fLQ1GJjRaRZhbefy7R1tqTnCRHWesdqxpMzEa95qmegGiiqtEsOfXUU3n7jZcOvX7yrR84tV0KGfERRCaEEWGOJsxkIMJsICnKysD2KViMgX2cW0Sa2bA3NBNhdcFs0Gme6gmIJqoazZKuXbuyMyef0nI7EWFmosIsXD2wI2f2yGhw2/HhFsqc3oYb2UAsmqd6QqKJqkazxGAw0Co9je7nPkxRWQUGnYI1QE+0NqKtRvaXVTB1/gbCTAbCzXoizEYizAYizUYiLAaiLEZMIU74YtZrnuqJiCaqGs2WrLZtiSnVcf/YXrSKi+AYGdHqRIHNQXGpg2enL8atqrhViUeVuKWKV5V4pMRXmdJHJ0AnBDohUCqfdYpApyiHPet1ymGPlvHhfHPz6GPaYTHoAvZUVVXF4/Hg8/mwWCxB+1toBB9NVDWaLT6vl76tk8iIDyysKlBax0cSa9TzU7eas0xJKfFKcEuJS5V+8ZUStypxVT67VfnPvirb5T4fL6yuNnf7YZj1ymGe6vTp07n7P7fhdntwezz/PHs8eL0+jAYDiiIwGg1ktkzH5XaTk7ufv1euom3btkH522g0HE1UNZolf/31FytXLOOzx8cFve1OKbGUeI49piqEwCDAgCBMB/70FYHhUSXP7DqAqqooSs2LFkvsLqT8J8vl19M/5/qRXblgcDeMeh0GvQ6jXofRoEOvUxBCIKWkuNzBjv3FmAw6LnxiBnZ706wO06geTVQ1QsbMmTNxu91EREQQGRlJZGQkaWlphIWF1Xrtg/fcxX2jumEOcFzT7vRw74zFuH3/pBM06hRaxUcSbtITYTbQIioMi0mPqqq4VIlLVTEdQ/Tqi0ERCMDm9BJprT4j1YLN+1i2u4gPzz//0L6FixbxwOMXkpYQVWPbQghiI63EViahkRI+/vhjwsPDqbDZqKgop8JWjt1m8yfgtlcgpUSn06EoSpVnPYqiHNqn0+mYcNW1jBx5VOUkjTqiiapGSPB6vZxxxhmcOWYk5eU2ysrLycsvoE/vPsz46qtjXrtp0yZWr1rJt+MvPOrYlrwS3vp9Hb+tz2VdTiF7X76C+AgLL/+6mmmLtnBq5qGslLi9Kn9uyMXl9eH0+ih3efCpfs9QCFhvc3FSZGgStxgVQWGFs1pR9Xh93DhtMS+9+jqRkf6hjb1791JRYaNdWrU1NGvk+jN6sX37YvRmHVFmIylmI9YEI2HpZsLMkVjNBoQQqKrEp6qVzxJVVn2tUlbhYsJlF/PEU89y5VVXBeVv8G9FE1WNBuP1eunUqSOKohATHUNsbCyRkZFYLBa+nf7RofOWLlvBkNHncdGFF9KhQwd69urF2LFjj2ovPDwcBIdlkZq1djc3fvgH+0ps9G2ZwBmZCazec4AeD3xBi2grW/JKuDa7DU8M7RKQzT3emM1WRyhFVaGowklmwtHjwS//upaW7Toxbtw/Qxt//vknJ3fJrPME1E3n9GuwrQc5rVsmY+6/n927d/HAgw+h12vyUB+0v5pGg9HpdOTnF/D5R28TER5OUXExRcUlnHvm4RV3snudxJ9zfmTVmrVs2ryNq6++CqPxQ9q1a0d8fPwhrw2grKyCkx78ApNex/4SO8V2J3ee2oHJfdtgrRwSuLFfW9bsL2HV/lLWxUVwUdfAiwkmR1jZ7XQF5w9QDSZFcO+Xf/HkuL70ykgk+8HpOD1eTHodO4or+HvNusMEdMEf8xjQITlk9gRCu/R4Frw0iUuf+ZKun33Ko088zbhx47RIgzoiqg6UNxeys7PlsmXLmtoMjTpwx+2343VV8PLzTwR8zTvvfcTzL7+B2+0hv6Dg0MSOlJK0MAM39WlNudtLm9gwhrROIixIcaoAV3+7nNKcQl7MCo2QPbjzAPOLyjmpQwpf3TQS81VTeKR1Ig6f5NW8corKyw/zBLN7dOWlSQMY0KVVSOypC1JKZi3bwv3v/44wRzDlnffo1atXU5vVrBBCLJdSZld7rDZRFUJMBc4A8qWUXSr3PYa/3LQK5AMTKhNUH3ntTqAc8AHemow4Ek1Ujz9yc3Pp0qULW9cuITY2sITNVfH5fDidTnw+lcHDz2BktMoDgzqFwFI/D89Zx++rd/Fxp9CVyv5wXzEv5RZj1inoVckfPTMBOGvrAUZfMQmLxUJpUSGF+fnM+PZbCr+9H7Ox+dS+UlWVRz+cw1ZnDJ9+8WVTm9OsOJaoBjL1+T5w5JTgc1LKblLKHsAPwIPHuH6wlLJHoIKqcXySkpLCsKFD+WLGN/W6XqfTERYWxoaNm9mwfiMXdEkLroFH0CLcTHmIc7SfFh3GBfGRvJiZyJwqy2snx1ko/PwDSt57nbAfppM7eybt0xOalaCCP5F4dvs0SktLmtqU44paP1VSyvlA0RH7yqq8DOMYpac1/j1cdvnlfDxtRr2vLysr44wzz+PegZ1oH+SA/yNJCjdjD/HQV4bFyD2t4jk5yoqhSirCYTFh3JsWw/+lxzMpJQYbghF9skJqS32JCjNpolpH6j1IJYR4ArgcKAUG13CaBGYJISQwRUr51jHauwa4BtDqqR+n9OvXjw2bNtX7+lMGjqB3ciS39w+9wCSFm3D4Gr9EdnXskTCoe2ZTm1EtUWFmSkvLaj9R4xD1vv+RUt4npUwHPgEm13DaACllT2AUcKMQ4rRjtPeWlDJbSpmdkJBQX7M0mpCIiAjKy231uvaUgSOoyN/HB+dkN8psc4twMw6vL+T91EaJx0tRhZP+nZt+gupIVFXlmS8W0jareXrRzZVgDCp9CpxX3YGDk1dSynzga6D2NO4axy0mkz9BtMtVt1ClaZ/PYMOaNSy4ajARpsYZV0wMN2P3eFHVpvVWvykop21qPBEBJNduTLw+Hze++iM5FXo+m37sxRoah1MvURVCVP3pGgtsrOacMCFExMFtYDiwtj79aRw/REVFUVxcUqdr7rv/Eca0TwFAbaQQv3CjHkUI8jxN663+VmpnRJ92TWrDkZTbXZz8f++w1x3BDz/9cujHUiMwah1TFUJMAwYB8UKIHOAhYLQQoj3+kKpdwHWV56YA70gpRwNJwNeVt3J64FMp5c+heBMazYfOnTuxeu16WrRICvgar9fLtNX7+GLNbtyqilmvI8JkIMpsJMZiJNZqIt5qJNqkJ8qkx2rQEWbU0yUpigEt67assyoxFiPbHG6SG8k7ro7dCO5pZuOpu/NLKHNJls38WQv8rwe1iqqUcnw1u9+t4dxcYHTl9nage4Os0zjuGDxoMF9+/T3Dh9Y0d3k0u3esP7TtdrvZs2cvu/bkkLN3L7n78sjLyye/4ADbS0upqKjAWWzHYbezedZq8u8+C4OufqNYSeEWdjjcnBJde4KXUGDzqhywOTila/MaTzVWLg/WBLV+aMtUNYLK5Jtuol27djx0739ITa37aiWj0UibNpm0aVO795aQ2JJlucWcnB5XH1NJjrSwp7zp0uZ9X1hGqxYxRIeHJv9AfTEadLjdnqY247gltNHPGv864uLi6NC+PTt27gp5X63btmXejoJ6X58SYSHX1XS1qmYXVzC8d/MaT61wuPlj9U7cHndTm3LcoomqRtCJjIyktCz0sY0jRg7j52159b4+PcLEAW/Tzf7vRHB6j9ZN1n9Vbv3fzySe9zStL3uRt+ftYuLESU1t0nGLdvuvEXSsVisOR+irhF418TKeefYlXF4fJn3gmfkPkhRupqKJxg2dqkp+E46nSilxeTyUV7j5fdUOvlm0hWV/r8Lr9dKmTRttPLUBaKKqEXSsViv2RqgS2jI9jagwK0v3FnFKq7ovGEkKN4V8qWpNzDxQTnJcJPFR9Z8ke/yjOTz+0RwMOgWDXnfoWQiBz6fikxKfTz2UkNqnykNJqQ8m69brFDw+lalTp5KRkRGkd/fvRhNVjaBjsVgoKytvlL7atsti7o6Ceopq062q+uZAGflOD2njnuSgrksObVRuSY7UfAkg/WfaXR4eOqs3E0/tgM3lweb0UO70IJEYdTpMBh1GneJ/1lfZrnzWKQrFFS4y75rGJZdcEvT3+Ouvv3L37bcSEW7FYDCgKP5SLq3atKVDpy4kJiYyevRooqJqLh9zPKKJqkbQad++PXfe9yBms4mrJl4W0r5GjhrOt1PfqVeawMQmFNUcKZh0SkfG9W6DEP7wJYG/zItAHNoHVO6v3EfVcwUdkqMx6nUEHhV8OAu27KNvr5MwGquvpXUkNpuNSy4YR3h4OL369adz586EhYWxatUqysvLcblcFB0oYOfWzcz+fT5X9G/Hub2S8Pr8HrJXlews2MDmH5fx+e5C5s39jTffeqee1jdPNFHVCDq333EHY844gwEDBjDunLFER4fOE7lq4qU88eRzODw+LIa6jasmhZmwe7x4VRV9CAoA1oRbVcm3u7j7jJ60iLI2Wr/VMX9LHqcNPbqkTXV4vV4uPO8c4h37ODkhng2zPuarqSW4vSrdU6KItugx6gRpFiMDWkfw5siLSIys+f0t3ZHPDV/9Gay30mzQRFUjJHTo0IExY0bz+pR3ue+u20LWT0pyMjERYfyVU8igKkX/AsGk12HW69jt9NK6hqqnoeDXogriI8xNLqgAf2w7wAt3175QQ0rJDdddgzdvB1NuHHJY/bD6khxlZffeXJxOJ2azucHtNRe0kCqNkHHPPffy3zfeprCwqPaTG0Db9u2ZW8941Tirie0hrFVVHT8WljGkc+gqDgRKucPNhj359OlTe56jp558gqVzf+HzawYFRVAB0mLDyUiI4q+//gpKe80FTVQ1QkbHjh255OJLuPqG2whlLbQzzhjFz1vrF6+aFGFhh6NxVw9t9sGQjqmN2md1/Ll1P726d63VS/z4o4+Y8t+X+O7GoURYguvR25we4uPrn7+hOaKJqkZIeerpp9mxew9vvftByPq4asKlbMwvpcJd99VRyREWclyNJ6qqqpJnd3JaZVaupuSPLXmcNmTYsc/54w9uu3ky300eSkpM8HMk6BTR5OkXg40mqhohxWQyMW3aZzzw6DN8PO0LwJ805YlnXmTv3n1B6SM+Po64yHAW7yms87VpkWb2NeI697klFURaTKTHhjdanzUxf9sBBg0+vcbj27dv5/xzz+aDiafRJa1++RWOxc4DZeSX2U+4+Fhtokoj5HTo0IHffvuNs88+i9vuehCbrQKHw0Hnjh3qlXSlOhJT07hv9hq+XLcHp1fF41Nx+VTcPpXcMgd5JXZ8Enyq9AfFS+kPigeSTY33Nfj+QDmndwptUcNAsLs8rN65n5NPPrna42VlZZw5agT3jujM8C6hGf/dU2SjQ1ZbIiIiQtJ+U6GJqkaj0LVrVzZu3ERxcTFWq5Vrr7kGW0X9Sq9UxW630yqjI7YKOzogodyFXoABMAJhSOZUuLgQyOKf/YbKxzJgbiOGU23wSu5tBuOpi7fn0a1TB6zWoyMQPB4PF407l4Etw7hxSJeQ2VBS4SI8vOk99mCjiapGo2EwGEhM9Ic91bWe1bTPZzBn3h/YbBWU22zYK+w4Kuzs3ZtLSwX+e1ImQ/7ewQMWPUoVkZRSMr3CxSCgugCmRMDeSElVVFUlz+FqFuOp8zfvr3Y8VUrJtVddiTywixevr3loIBgs3XmAXv2OPaZ7PBJI5v+pwBlAvpSyS+W+x4Cz8Gf+zwcmHKxHdcS1I4FXAB3+igBPB9F2jeOYuorqDdf9Hz2sRhKMeuIVQZgQWHUCs1kwPCWRRIMOvRBs9am0qyKqNun/8NUUERoFOBupqurCMgdmo57MhKa/3Z2/rZB7rjtaNJ9/7lnWLJrLb7eNDFroVE38ubOYu2+osRbocUsgnur7wGvAh1X2PSelfABACPF/wINUllQ5iBBCB7wODANygKVCiO+klOvR+Nej1+vx1TLrW1ZWxvSvvmflqtVUuNy83r0lRqXm7Eltw8wsdvtoZ/jnY12sqpgUAWr1IV3R+DNGNQbfFpRxWofUJs8A5fL4WL4tl/79+x+2f/bs2Txw//2sevQCwhqhxIzd7SUmJibk/TQ2gZRTmS+EyDhiX9VkmWEczP9wOH2ArZVlVRBCfIbfu9VEVSMgBg4aRd727bSPsHB/66RjCipA1zATawvLgH8K1ZVIiVEoQPVr/CMAD/4hAKs+tGOraz0qtzeDSaolO/Lo2K4NkZGRgH/56YP338d7b0/B6/ORGoLQqepoGRvGtm3b6Nu3b6P011jUe0xVCPEEcDlQClS3zi0V2FPldQ5Q419PCHENcA1Ay5Yt62uWxnGMqqrk7tuPy+nC6XKxectWvumSTmaAAeedrEb+LD78lrVElRiP4RkqgBnY4XTTOTy0SyXzXG5Oax+caIeGMH/Tflq1zmLHjh2oqsrl4y8kzF3C8gfOpv09n1JQ7qBlXOiHKNrGmtm2bVvI+2ls6v3TLKW8T0qZDnwCTK7mlOo+yTUuq5FSviWlzJZSZick1D2Nm8bxz3kXXk5G22506daHvn1Oo1OYOWBBBWhvNVFyxPhoiSox1fyxAyBSEWx3hrZ8yLJSO4oQtGsRHdJ+AqFtUhT5W1YzsF82XTt3YmymiR9vGkZSlBWL0UBBeegTjAOVeV+btkR4KAjG7P+nwI/4S1dXJQeoGuCWBhw1maXx76RVq1ZMffcdioqKsVjMWMwWfp09hzPjIxgcE06YTiFcJ9hc4SRCryNCp8OqcNjM/pFkWYyUe704VRVz5XmlUpLvU3kUiATGw1Fp8mKEwq4QL1X9uqCMU9s3/XgqwIV92nBhnzaAf7a/qk0Wo56C8tAnGAfYWexidJs2jdJXY1IvURVCZEkpt1S+HAtsrOa0pUCWECIT2AtcBFxcLys1TjgmTJzI9TfcQP7q1cTqdXikJFlVWVliZ0mJHY+UuKXELcEnJV78tzk6QCdAQaATAp0AnRDohUCnCAwSfnd5GVnp4Q43GYgUgiJV8pPLw08+lQlH2BILIV+qusrj48bOTT+eeiRHirzVqOdAI4lqnFXP1i2bG6WvxiSQkKppwCAgXgiRg98jHS2EaI8/pGoXlTP/QogU/KFTo6WUXiHEZOAX/N+FqVLKdaF5GxrHG2azmVsm30jRh+9ztSmw0B2vlLgBV6XYuqp5/Z6UrPf4GFlZ9TlJp3BWpcDuROCxH31rG6uq5NUjb0Bd2O/yNIvx1NoIM+nJL2scUR3XqxW3f/MVjzz6WKP011gEMvs/vprd79Zwbi4wusrrmcDMeluncUJz5bXXMfS995kkJboAbov1QqAHrMc4d71PZbm7+nE6A1BRzf5oKdkewgUAa8od+FRJp5TYkPURLGIsRvLLGmdMVUowm0y1n3icoa2o0mgyunTpQmrLdJbl7qavMTgfxbY6hZ9rCJ8yCKjqj7qBQqAMyHN5+Cq/1J8TAP8tmKwcelAlqFTul6DKKttV9ks4lFNAVmnjj5IKemYmoNQSEtYc8PhU7J7Qeu0H6ZAczbpNv55wSao1UdVoUq6afBMz7r+XvrXM0AdKW72OUm/1npaBf0R1B/4VKyYBBgQer48p+0oQgFJZA0qpUi9Kwb+tVNaJUoTw7xNV91c9XvkaKFMlHRshmL6h5BTZWLIjn/9eemqj9JcYaSUlJpKtW7fSuXNnXC7XCSGumqhqNCnjL76Yu2+/ndIwPVFBSGzSQhF4pGSfVyX5iGB+o/xHVFcBHUwGpkRa2OH1MbnMwS/dWzW4/+oYtXp3yDI9BZOJ787ljB6ZdE4N3TCFqqr8vfsAs9fmsGRHHjtz87lk3Dnszt2Hx6dSWlaOThfa5bGhRhNVjSYlOjqa0aNGMXv2T4wLQlZ5RQjidAr/V+7AqihIOPQo9/rwCsF/dDrKVB+DK7+80YrAFaKlqi5VZafdyQV92oak/WCxeX8Ji7fuY+VjFwalPVVVWbm7kNnr9rBkex7b8sspKHdQUuHEpNfRLiGSHsnRPDOiGx0TImgf34He78wnPz+f5OTmP6F3LDRR1WhyrrrxRi6cOZO5zgoQR64QEUgkksr76ioHpf8wXhW8Asw6/5ilDWgHDDfpKm/bKx8m/aGQLB0GOlYmDIkUArfksPjWYLGy3Em0yUh8hCWo7Qabie/OZfzJ7WmTWLfKt6qqsjqnkO//3smqPYVszSujsNxBkd2JUaeQFR9Jj+QYBndPp1NCJB0TI4m3Vj85lRoTTk5OjiaqGhoNZdCgQRS6XPQ0GWip84vaQSE8yMGa9xy5H5jt8lKh1zGhi//2/e8DZazZV8wYc2Cer04IrEKw0+GmQ1hwx/TmlNppl9a8Z/1X7Cxg9Z4DfHFDzWn4VFVl7d5iZq3dzV/b8tha5OSA3UNxaTk+VcVg0HNRpxSu7JZOp8RIOiZEkhAW2Mz+gl0FfLcln50HSikqCm2RyMZAE1WNJken03HdpEnIL6ZxqaXuEzobpSA9LY4bu2QAsDivmAn7iuvURpROYbvDE1RR9UrJl3mlfHTD8KC1GQqufv93rhnUmdSYcFRVZX1uMb+s3eMXz0IHBXY3xWU29Do97du1oUf3AVzTrQudO7Wnc8cO/D7/T+6/+z5eH9OjXv1P/G4V4yddzcwXxgVU2bW5o4nqcYaUkg8//BCHw4Fer0en0xEbG8tZZ53V1KY1iDPOPZfHvv2aS2sIhzoWbikx6f65be8UE06J24NXNaIP8HY+RqdjT5DX/88vqcBk0DOmR0ZQ2w0W+0vsvDx7Fat2H8ClKky/ezrFZTaEotAuqzU9u/fjqu5dD4lnYmJCtcts/ZVy6x+9ERNu4eJLLqFHjx71fzPNCE1UjzNcLhcTJkzgit7tQIBPwnfr9rB6/QZatQrN7HVjEBkZibvaHDy14wWMVcQz0mgg0mhgpVcl2xiYqMbpFHKDvKrqw7wyRvZoHhnXDpQ7+Hr5dmavy2HD/lLySisod7jx+FTSUpO5/pab6NypA507ticpKbFOOQr8olr/GNyEMDP5+fn1vr65oYnqcYbZbCa9RSJ3nZxJZoy/vo/N7eOPP/44rkU1PDwcm89Xr7xpHglG3eFf6s5xkSwpKiM7wEUF8QLygyiq3x8oY7XNwfQL+9d+cpApsTv5ZvkOflm7h3W5JeSV2ilzuGidGMXJbZO5eWg6vTISWLajgPu+Xsam1X9VW6sqUKSUDZBUCDPoqKiobq3b8YkmqschWa1bs7XQdkhUB7QIY/6c37j00kub2LL606FDB3bbKvBGW9DXMZOTF4nliNjGXnER/J5fEnAbcVKywxOcNHRrbE7u357PGxMHkxhZf7GqKwfKHfR4aDqF5Q5axUdyctsWTB7SmZ6tEuiaFofJ8M/fKLe4gju/WMjbb73RIEE9iGzA7b/Dq2KxNO/oiLqgiepxSNsOHdm6bwUH52oHtIrnvd/mNalNDcVisdAiLpb7ioqw1OCtnmzQM6KaWFaPlEd5ql1iw5lhCDyIPEYR2IKwqGubw80VG3K4eWR3Lu3fruEN1oGr3vud7unxzJg8HLOh5q+2lJKr3p9Hz549ufD8cxrcr99Trb+vWljhYMqb/+OLzz/FabfjcDiw2+0AxMbGEhOXQFx8AnFxcSQmJjJu3DiMxobHNIcKTVSPQ7I6dmLrhkWHXndNiiJn334KCwuJi4trQssahiqgLDacrGpW9OSUVvD+/lJGVHOdV4L5CE+1U0wEJd7APc8YRVDhCuz8AreXNTYnm+wutjvc7HV5KfSqlHt8OFCRCN6eu56p8zaiCIFOJ9ALBZ1OQa8T6BQFg06g1ynodQotoizMuGlUwLZWx/4SO3PW57Dw/nOPKagAn/+1lSU78tm1bW6D+jyIf0y1/mzKK6KjJ49+LaOwmqOxmBOxmAxIKSkus1NUWkrRgVy273DyxE9LaNOmTbMuwaKJ6nFIu3bt+LXMdei1XlHok5HEn3/+ydixY5vQsobRKj2N+zqGMSgz8ahjf+UUcv6ni6q5yh+6VHX2H6B1pAWH10ehqhIXQARAjCJwVclCv7i0gjdyirCp/kUBNq9KhdeHQ1VRgSghiFcUEoE0n48eQDzwFPDDqGyseh1uVcXlU/959klcqorbd/j+p1ZsY3+JnRbR9b8NnzR1DiO6taJL2rF/VPPL7Nzw0Xz++8oLh2pUNRSJpCG5t8MtRm6+ZAjZnTNqPXfpuj2ojVSosb5oonoc0q5dO7YcKDts36CUCKZ9+P5xLapdT+rJ6p1LqhXVFuFmHDWU3vBytKeqVxRaRVhZ6PJwpqX2IPQoRTm0VHV5mZ2rN+zlFAkZ+MtbRwJx+IUzHBBSQjX2WHQKbaKsJAbQJ8A+u5Nn/t5Oxh0folSucBCVCV0EQOU24tjz6z5Vsvzh82vt75NFW0hJTeWKy6rL6Fk/0lJT2FlQTLe35zM4NYLb+rejVXTgxQNVCTpdYDOUQjTcMw41mqgeh7Ru3ZqcolI8PhVD5Yfxut6t6fn2XObOncvgwdXVYWz+9OjVmz//nl/tscQwMw6PD1VVjyqp4pESSzWVUHskRLFyTz5nBjAHEi0ELlWyvsLJpPV7GYdgVD0mX4QQ+AL80ju8Ps75ZQWndUjhy8kj/SkDpcSn+qd9ZGUaQVXWLiQWo57oGpZ/ViXCbEAfoIAFyqDTTmHnxr/54adZfPTpF5z83p/k3hr4ggdFgDfAfLaKohz/nqoQYipwBpAvpexSue854Ez8KSm3AROllCXVXLsTKMdfH9grpcwOmuX/YoxGI6mJCewsqSCrsuplmFHPc0M6cMNVV7Jw2fLjsp56Wloa++zVlzWxGHSY9ApXV7ix+HzcFm6itd7/8fVVc/sPcFJsOB/mHAio77DKXKsXr93DKCEYVc8vrgACvXRdsY0DTg/rbhtzzNpbwSQp0oKtvDzo7bZokcRVEy9j5LAhdOxxcp2u1QkFd4A5XIWg2YtqIP/J94GRR+ybDXSRUnYDNgP3HOP6wVLKHpqgBpe2bdqwtdB22L4z26cwLMVCu9YZPPP0U4dmUI8XkpOT2X+M+khfXzyAqwZ2oNBqYr7zny+hV/pvu4+kU0wExQEO9tmkxAQMRHBOA760ihB4A/RUpZQYdEqjCSr4c5g6HKErl6Ioos6354oicAUoqoqoe/uNTa3/TSnlfKDoiH2zpJQH/wqL8VdK1WhEsjp2ZMsRoiqE4NkhHZl9cV/+mvYO7TJb8egjD7NxY3V1GZsfZWVlhBtrXvt/WkYCN/XLIiXi8FhWHxKr/uibrk6x4ZS43AF5NjeVOemoKFysqg0KZBcCvAGKsk9K/zhqIxJhNuBwha4cd32qxeqEqIOnKk4IT7U2JgE/1XBMArOEEMuFENccqxEhxDVCiGVCiGUFBQVBMOvEpn2nLmyrEgFQlQ4JkXx6zkl8cVY39v/yOUMG9KNb+ywefuhBfv/992a7emXdunV0jK19Btwnj35d3e1/vNmIRa9jfS3jdS+UOyj2+rihgYIK/iqvgXqqqqyfCDWEKfM2kNU2dLldRR09yfX5pbg83oBFtT6ecGPToIkqIcR9+IeiPqnhlAFSylwhRCIwWwixsdLzPQop5VvAWwDZ2dnN+6/WDGjfvj1flxy7QFvPlBh6psTw/LBOLNpTyA9zvuSeT99jdU4BHdu2pv9pg+jQuQt9+/alV69ejWR5zaxd9TcdYmqfbOnWIop1BSWA/1wv1U9UAXSMjWRRqY0uNSxX/cPl4Senh4fxz/I3FCH8M/GB4JPSX37bq6Kvwf5gkltcwdT561k4f3bI+vAPZRz9/veVOfhp6z4W7ipkfZGdfKeHYpt/GKJD62SyWiYF1L7H68NgaN6laeotqkKIK/BPYA2RNfx0VFZXRUqZL4T4GugDVD+9q1En2rVrx9aC0oDOVYRgQMt4BrSMB8Dp9bEit5jFm/9gxfI53Hf3XvIOFDb5KpVlfy3m7B615x4dkB7LzHV7+KDChQP/2n+zvvrVUz3jI1lSVP3fya6qPFHu5HIgWGlPBATsqbaJtGIW0PK2D8n974QgWVAzT/z4N106d6JH964h60MIgdencvPMv1mdX8Z+h4+iCgdOl4fMtARO6tiKi4em07ltKl3bppKcEFUnb93p8mBq5hVY6yWqQoiRwF3AQClltbMhQogwQJFSllduDwcerbelGofRsmVLDpTbqXB7CatjJVKzXkf/lvH0rxTZ1QU2FixYwOmnn17jNY8/8jD79uWS2bYdmZmZhx7R0dFBuYUtKSlhw+at9DnjyDnRoxnaJombfSo/KQpZ0WFckBJLcg2lWLrGhvOj/mjPRlVVri+xkykEA4N4OykQeAP0VFPCzMw9sy8dPw+9n5FTZOPDBRtY8ueckPZTXm7D6/GQa41g5OgudMnyi2dmanzAsajHwuX2Hv+iKoSYBgwC4oUQOcBD+Gf7Tfhv6QEWSymvE0KkAO9IKUcDScDXlcf1wKdSyp9D8i7+heh0Otq0TGNzYTknJTcsfGpkq2i++Gwaa9euZcGcX9m8eTOt27Thq+9/BPyz1M899xx3ntyanWv+YL7Nw86SCnYWlCAUhcz0VDIyMslom0Vm2yxatmxJWloa6enpJCYmBjS7vWjRInq1TKrR46xKUriZ987tw4SvljAyPYGrO9XsZ3aJCaf0iOWqmz1e7nV6KfOpXEtDktYdjRAEHKcKEG7Q4fGp1cbfBpPHf1hB965d6NKlU8j6AP9nxWQy8O0rN4akfZfnBPBUpZTVLb14t4Zzc4HRldvbge4Nsk7jmIweexZT/viBNxsoqqOykuj/1juM7tSKce0T6dPSxKvLVxw6npubi8vt5rSMBLJTYg55plJKip0edhZXsLOklF2b5rNh2a/8aveSU2pnb4mNUruDlIR4UlOSSUtvSXpmG9JbtSI9PZ20tDTS0tJISkpi06ZNdIwNPFPRmR1S+OyCflw2Ywk/7Cng8yHdMVcTAdA2Kgybx0uZquKW8GKFi+Wqys392/PBkm3oHNVP9tUXQd1EVa8o6ISgqMIVsjpWuwvL+WThJpb/FXqPWFEUCOFEktPlafZlrLUVVccx9z34EB3afMDf+4ob5K32aBHN7AmnMaBlPEIIVuQW8+mef8QmMTGRBx96iAlv/o8w4WNC52Suzs7EoFOItRiJtRjpmVJ9/06vj9wyB3vLHOSU5ZKzahvrF3mYXeFlb5mDvcXllNgdhJtN3N43s052D2vbgr9vGMblXy2l8/Q/aRtpZWhqLBPap5NQORygFxBvMXJduZMCVWVYVgpzTmtP9xbRvL9kG8EuhqxAwLf/B7HodewvtYdMVB/7fgUn9ehGxw6hz5ql0+tCqam43CeAp6rRfImKiuLJZ59jwv13MfuSviTWs76SEIJTWiUcem3QKRSXlB26JTUYDNx73/3cfc+9/P7779w6+QZiLDmM71b79I5Zr6N1bDitY8NrPMfl9XHJ9MWsP2Cr8ZyaSI6w8Mvlp7Jw9wF+33mAnzbv5/lVO9ArAkUIfKok3KTnvJMymdy3DRkx/6xJV6UMSkxhVUQdgv8PYjXo2FdqrzUZSn3YeaCMzxZv5u+lfxzaZ7fbmbdgISOGnh70IQdFURqUW7U2NFHVCDkTJ01i+9YtnPnxVH4e35eYGiZs6kKXxEgSTXDv3XfxxFNPo9PpcLvdfPTRR8THx3PpxCtZOOMdxncLwhsATHod47qk89Cc9fW6Xqn8UTilVQL3D+yIV1UpdnhQpUSnCOIsxmon01Qpg+6pCgIPqTpIuFHP/pLQrH575NtltMpoyetvvsvCBYvYvW0HxXY7KjD1rVeDmlgFQK8Lrafq8/nQVzPM05xo3tZpBMSjTzyJzWbj7C9m8MNFvYkwNSyOTwjB5+f25IpvPmPkkiVcNulKHnvgPlpZBXavZMXuPNomBje3wNkdU7j22+UUOdzENvCHQa8oAZVHVlXJAfzJKcIJzoRVXcdUAWJNRvYWB2dBRm6xjWl/bWXW2t1s3lNMXrkdsyJYuucjshW43KCjfVwELzs9/PTLb0EXVUVRmn1wfqjRRPUEQAjBi6/8l2ttNkZ8+jNvje5Cl6SoBrXZItzMjxf15tF5m3nr8ft5ZWAGp7f2B2hvPlDOhoKyWlqoG2a9nhYRFr7dsJeJPes2tlpfOidH89neIqb6/CupnsYfstIQhKz7mGqs2cj+srp7qqqqMmvtHmYs387SrXnkHCjH5vGSYTTQ06DjGp2gU2w4idWEMnUR8EOVychg4b/9/3ejieoJghCCKe9O5Z2332bUXf/h+p6tuKN/W4wNiA3UKwqPDu5w1P528RG0i49oiLnVcucp7Xjgt7Vc1LUlljqUQqkvv0wceGg76pEZBGOkri7B/weJMxsoCEBU1+YUMn3pNuZtzGXHvhIKKhyECYWuZgNDBHQKM5Glt2AIIG64g17H27n76mRnIOj1Os1TbWoDNIKHEIKrr7mGUaNHc83ECZzy/p+8OapLjTPzzY0re7XmuT+38NCcdTwzvGujrYvfU+ofY2yYb++nPmOqCSY9a22Hh3blFtuYvmw7v67dzcY9xeSV2fFJlXZGIz30gjE6hQ4x4cTX80eztV6hwu0hP7+AxMSE2i8IkFCHVB0PaKJ6ApKWlsaPs2bz0YcfcvatNzOhaxr3npoVUGB9UzPt/D6c+fGf5NpcTD27V4M87UBZurcIC/6kvw39QtTFU91nd/JbTiF/5BaxtdxBpzs/oczuotzppkKVtDEa6GbQcaki6BhlIU2nBO2HxiAEaUYDM775geuvmRiUNgH0er12+9/UBmiEBiEEl19xBcNHjOD6q6+k39QFvDi0w6Fx0ebKSckxrLxxKAPe+Z0RH/7Be2dnHxYGFQqGt21BuNXE804Pd6pqg8KsBPKoMdUCh5tfcwpYlFfChuIK8iqcFLvcuFVJikFPW72OcTqFJJebRIOO6aoBi1R5ODK0ZZu7GnTM/m1uUEVVm6jSRPWEp0WLFnz13Q988803TP6/yXRduZenB7cjM6bmuNGmJt5qZs0Nwzl72kJOemM2V/TM5LHTOzU4qqEmwo161t48kuSnvqUEqD2lS/WUAXavjw827eG9jTmHxNOlSlrodbQ1GsgWkkyDQqYljBaKQFeN57ne42NhYJnwAuZRmwsdkh46hdZ6HZl6hc4KzFixMqj96PX66pJUBY3jQa81Uf0XIITgnHPOYdSoUbzw3HOc8vyzXNszgwdOa9fo+TwDxahXmHnZKWw+UM6F0/+i039/4Y0ze3Jmh5SQ9Gc16jHrFGw+tVZRLQVWA5uAHKBUp8Pm82EH8PpILLXTT6+jtUEh02wlRadUK541kaJTKAuwZlOg7PR62eLxsT09jYL8fMpcbixCIFzBzV0cytl/KSV2hxOrNRhJGkOHJqr/IsxmM/c98AATJk2iQ7ssrs/OCCiesylpFx/B39cP5dXFW7jq22VYZ+ro3yqRgS1j6ZseR+fESLyqZENBGevzy2gRbmZgZgL6eqwUMup02Hz/iFkJfvHcCOwVglJFwebz4QbihaCVotDD5yPN5yMV+EsIFugU3oxq2Jc+USdwBDm7/dMRFi4rruC+h+7m8ksuwm6388vsuZSVBTc07uAKLSll0H+w7U43JpNRC/7XaH6kpqZi0OnQKc3TS62Om/plcX2fNvy4aR/fb8xlyvKdPDx3PRVuL6qURJqNxFlNFDtcJIaZ+fnyUwP+wdhVUsGv2/Kw+7xMAUSl5+kGEoWgpaLQ0+cj1ecjDUgElGpKVM8BJpkb/pUy16F6QKAk6hT+E27mxutvYfSIYcTHx3HOWWOC2kdVQiGq5RVOIsJDO74eDDRR/ZfiU9U63ZI2B/SKwlkdUzmrY+qhfXtK7cRYjIRX5pRVVZXhHy7g9Pfm8de1p2M1+Pc7vV6W5xazJKeI5XuL2VhgI6/MQZnLjQ+IVRSE6i/+d2GleCZQvXhWhwoUSsnoIIz7msTRJWOCwVCzgd+9KsNHnMWK5QuC30El/oqnkmBnMtREVSOk+Hw+7HY7Pp+P6Ojoul+vqhQ5XESY9I1efC6YpB9xq60oCrMuP4XOr82m40s/4VMlFW4vLimxCIhRFBIRpPl89MAvnJGAUFU2CcHXUrJYCG6so6fowP9lqs+ww5GYhKjzUtdAuctqZPzGzTz17Evcc+etIelDEJo6UmUVTiLCm+8E60E0UW3G+Hw+tm/fzpo1a1izZg3btmxk+7ZtbNu+g/wDRVjMJtweDxs2bKRNmzZ1antAv74M/GgxpbYKWkRFkBodTmqEmWSLjtRwA6mRVlIizKRGWkiNtARFLBoLRVGYfmE/+r75K+cCyfgD+3US8NU8VtleSgYCW4So8zSzAwhWbIJJ+CvEhoIIRfBwhJl7H3mKC847mzZtQrAkWPiT1QSb8gonkZGRQW832ASS+X8q/lpU+VLKLpX7ngPOBNzANmCilLKkmmtHAq8AOvwVAZ4OnuknLmvWrOG1V1/hs88+JyYqjK5Z6XRpncjArAQmDj6NNunjSEmIQlEUJjz4IbNmzeL666+vUx+/zPkdAJfLRW5uLjk5Of88du1kya4d7N2aw849OZyaHstHZ/UI/hsNIV2SokiPslJRaq9TiJQTMNVjksgJh5XNbgg6REhDh7KNekZZjAwbdiZbt64Oevo/ESL7yyochJ8gnur7wGvAh1X2zQbukVJ6hRDP4C+vclfVi4QQOuB1YBj+yJOlQojvpJT1y+92guPxePj66695/dWX2bJ5M9ecN4B1Mx4kJTH6mNcN6ZPF97N+rrOoHsRkMh2qN1Uda9as4YJRQ+vVdlNzde/WvDxnHX3qsGzUJQS5UjILfw2hQPNlOQieqHqQhHoO8QaLgcsKCph8839449UXgtq239Gvm6qWlNlZuXkP67flsnlXHrtyC9l3oIxSmxOb3Ynd4cJmd9KpY/ug2hoKAimnMl8IkXHEvllVXi4GxlVzaR9ga2VZFYQQnwFnAZqoVmHfvn1MmfImb735P7JaJnD9uFM45/TLMBgCG5kZ0qcjt73wBD6fD50u+MtQ27Zty478YnyqPK6iBQC6JUVRXsd1+H2lxCgEPwCfSMmtQI8ArgumqHqlf/ThHZsTFQ5/SHn0PiSq9G/78FeX9SErn/3LZn1CIIWCKgSqAFUIhE7hg/c+4vJLL6Jf395Bsf0gB2//3W4vG3fuY/XmvWzauZ/tOQXk5JVQXG6nvMJJhcNFhcOFx+sjNjKMFvFRpLeIJSMljv7d25CSGENKYhSpiTFszyngyY8WBdXOUBCMMdVJwOfV7E8F9lR5nQP0rakRIcQ1wDXgrxR6orNo0SJefvE5Zs3+lQtHZPPTa9fTNSutzu2kJEaTFBfFypUr6dWrV9DttFgsJMXFsLu0olmvwqqOJ+dt5CRFgTrczscAp0vJ6cAMnY4llRNateEieKJarkpcwLaYCBQhKh/+ZNwKAt3B7cr9evHPPp0QGBWBQVEwKGBUBEZFQS8Ehsr9OuXgtuCrHfk8+sRzzPzui6DYDmAxG2k75j7sTjd2p4swi4nE2EjSkmJolRLH4D7tSU2MISXBL5apidHERYfVOgxh0OvI2ZsbNDtDRYNEVQhxH+AFPqnucDX7anQbpJRvAW8BZGdnHweL0erHhg0b+M/tt7BuzSpuuXgQb/7wGFERDQsWP713Fr/++mtIRBUgq20bthTajitRdXtVVuwt5MoGfJLifT4C/Qo7AUOQHPkYnV/wvh3RMzgNHoPWkVYmzAuu91de4eTz566lQ0YLWsRHYjIGZwovJSGK3P15Ia8821DqbZkQ4gr8E1iXyOoHUHKA9Cqv0yDgz+gJR0FBATdcfx2nndKf0ztFs+Hrh7jp4iENFlSAIX3a89usn4JgZfW069iZLYV1rx/VlLy0cBPRQiGxAW3E4l+CGghOAh9/rY0Y/ImuPUFeVVUdJyfFIFQfX371XdDaNBr09OuaSauUuKAJKoDJaCA6Mpz333+fdevWsXv3bjZt2oTb7W5WSVzqJaqVs/p3AWOllDVl110KZAkhMoUQRuAiIHj/ueMEVVV57bXX6NSxPYby7az/6kFuuWwoxgDHTANhYK92LPprKU6nM2htVqVdp85sKQlN26Hi3WU7yW6gKMUCFQG24SR4IVWKomDSKZS5g5xVpbq+hODirFRefOnVoLUpQhRSBfDYDWfyw2dTOOeMEQzol82YEadjsVi48PxzQ9JffQgkpGoa/onQeCFEDvAQ/tl+EzC7cinaYinldUKIFPyhU6MrIwMmA7/gD6maKqVcF6L30SzJyclh0oTLKDuwl3nv3EKHzOSQ9BMdaaVz23QWLVrE4MGDg9r2/v37+e3nn4gOcoKPUHLzjysoKrfTtYHtxAKOyomh2rwPO2ANopAYdQqlbi9x5mD5vzVzUZsWvDdzWdDaC1VIFcDV553K1eedetg+p8tD9wueYObMmYwePTo0HdeBWj1VKeV4KWWylNIgpUyTUr4rpWwrpUyXUvaofFxXeW6ulHJ0lWtnSinbSSnbSCmfCOUbaU5IKfn444/peVI3TusYw/x3bwuZoB7k9N5tmT17Vu0nBoiUktdfe5WuHdvTwZHDy8M6Ba3tUPLcHxt5f9kOLgPqV7D7Hyz4vYFAxqxsikJEEKMjjIpCqdsTtPaORfvoMFxeL7n7glRepR4hVQ3BbDLw8n/O4+abbsTlctV+QYjRVlQFmQMHDnD9tVezYc0KfnrtRk7q0DiRDEP6tue+Kb/Ak09Ve1xKSUlJCQUFBRQUFJCfn09BQQF5eXkU5O/nQN5+SkrLmPLOVNLT03E6nTz84IP8X890/nPq0XWqmiOfrtrF43PWcTENL+B3kGhFYaOqUltcRrkQpARRVPXAbzmF7Cp34PD5cHlVHF4Vp0/Fpfpw+iQen//Z5fPh8ql4VIlbVXH7VEw6HSPS47mgTQvMtWR1EkKQZDXz15IVQUmyIvCv/W9MRp3SlSkzFvL8889x3333N2rfR6KJahD5/vvvue6aqxg/oicffHwX5hAlVT5IflEZi1dtZ8XG3azZnMOKlWu4/JKLqLDZKC0tobS0jJLSUkrLyikpK8diMpIYG0VCdDjxUWEkRllIiDSREWVld+5Odhd6SUjw1yuyWCz8Ovd3hg8eRIeEyJDlMQ0WX67bw3XfLONcoFUQ200Qgp0BnGcDYoKZQ0EInvp7G5kx4Rh0CgadgvHgQ39wW4dJr2AyGQnTKf5tnf9R7vby6sY93PXXJlIiLFzaOpmburaqcblxcriF9Rs3BUdUhUA2QVGVl+44jz6XPsMFF1xIVlZWo/d/EE1Ug0B5eTm33vJ//DbrJz554nJO69WuwW3a7E7WbNnL+u372LIrjzVbcthXUIrD6aHU5g+cdnt9tIiNIKNFLO3S43no8iEkRLuJCo8kOiyRqHAz0WEWosJMRIdbMBmr/3dvyy3kqc/+5Ne58zCb/7lp7t69Oz/Oms3oYUMx6hRGZLVo8PuqC7nlDn7dmkeMxXhMUX9r6TbumLmSs4Bg+9SBhlVVSEmsLniiatEpvHduby7q2rA7nYIKF99t3MuLC7fw6vpdnJoUw3+6t6ZL3OHVcI2KEtRb58b2VAEyU+N5+NrRXHTBOBYuXoLJ1DS5gjVRbSDz589nwuWXMrhXa/7+7F4iw2uuK+T1etlfWM6OnAI27tzP5l157N5XSG6Bfzleud2/usTucOJ2e4mKCCMpIZrUFvEcKHZQUlrBY5OGkZkcQ0ZSDC1iw4MSrzfx+W+578GH6N69+1HHsrOz+e6nnxk7agQfnKkwuHVDgpSOjcvrY9GeQmbvOMDsXcXklNjo368faxYu54z2ydXm53xs7jqen7+RcfiTpqwCCvR6VJ0OndeL4vNhwD8zL/Anq3ALgddoxKXTscfjwSwAnw/Fp2KEwx5FQJ4QzJOSCPwZraIrH1W/PBVSEh/E2ElFStxBmBxMCDNxZa/WTOqZyZ+7C3l9yXZG/rSUCKOB/glRPN63HclWMzoh8HqDE20gRGiyVAXCDRcOYs6yrfznjtv576uvNYkNmqjWk9LSUiZOnMDXX39D784ZlJaVc+6tb1DucONweXG6PLjcXlxuD26PB5fb/9pk1BMRZiUhLoq05ATSkxPo1rUzyYkxpCTFkZwYQ3JCLAlxUYcJ5msffM/UT37gkqE9gv5etu4t5PzzL6jxeL9+/Zjx3Q+cN/YMPj27B6e0Cl5JY/CPhX61tYg/tu+jQ1ZbRp55HlNGj6Z3797odDqyWqWzan8pPZKjD7tu+Pvz+GPXAQC+MhhIjo+nx0knMeaUUwgPD8dut2O326mw2agoK8Pj8RAdF0dUdDRRUVGsWLGCFR98wDP9OmD3+rB5vNi8KmUeH3av/2Hw+ghze5nr9VHh8WL3+HD4fLh9/ny0Bp2CQRGoXh+vVbiZ7/IwyGSgr0HXoMxeOgmuY2TUqitCCE5pFc8preJx+1T+2FnAq0u20evLP8mICsOoCHxB7K8pPFXwv893HryYXuOf5vQhQzn77LMb3QZNVOuBqqoMH3o6GzasZ9DJ3YiNjiQuJoL27SOJiQonOjKM6MiDz2GV+8KJDLeir2eZ6IhwCy5v7cmS60PLpFj27NlDampqjeeceuqpfDp9Bheffx5fnNuTfulxQev//nmbueeRx/ng4ouJizu63bHnnMsPq+fQIzmaIoebHzflMn3zATbbVK688komTJhA9+7diYiIqKb1mlm4cCFr5sziqo7ptZ98BKqUlULsF+O+Xy3kPKuOXQietbmwqSqxBj2pAnobdAw3GkjQBy6yipQh+38bdQpD2iQxpE0S+RVOHp+3kU9W7qSkJDilVfxjqk1HTGQYHz8xgfOuuZKePXs2+rJ3TVTrwZ3/uYOc3TsIs5qZ82n1s+3BJjLcissTmi9Zu7RYvv/uW/r163fM84YOHcoHn37GBeMv5OsLetMrJSYo/bdJiKZz587VCirA2eeN4/JPP2JJfgV/7cpnyKCBTHzgdsaOHUtYWP0zwXfs2JHNBUX1Kv2hCEG4QU+4QQ+YsAjB2WYj8ToFwkwUqirrPD5W+1TmeHy8U+EiTKeQoNPRUYHBJgO99ApOYLNXZavXx06fSq5PpcygJ8frParUdTAoc3mwub3Y3V4qPD4q3F7Gtk9mwc4CZs3+jVvuuBdFURBCQVEEiqJUeQh0ig6hCIQQ6HQ6FKGg6KoeV/D5VN6c/jtmowGP14fL7cXj9XHJmL707BjMacSa6d+jDbdePJjxF47j9/l/YjCEdtK4Kpqo1pHXXnuVH76ZzmfPXM1ZN7/eaP1Ghltxh0hUn7lyCP1uepsBp5xaa/D0qFGjuGby//HOrC+CJqpZ0RY2b97M6aefXu3xAQMGcN5lE+jb72S+Gj06aDk1Y2JiCA8LY2+Fk7RjjIUHStWb5zhF4TSTwmmVrz1SssWrss7j5W8VHil34FAlXiDGaiQ10kqrmHD6R1tpGWUhPcrKqRnxDbapKvN25HPmpwuJj44izGIhzGrFGmYlLCyMyLRMNvy9im0bV6GqElWqSNUfiqdKtXKfRFVVpJRIyT/nSek/T/U/t2uTxq9Lt2HQ6zEa9OgNepCSgZOeZ/jJnchIiUNfKcR6vYJOUdDrFMKtZsIsRsKtZiLCzESGmbGYjJSU28nNL2F/YSkFxTYOFJdTVFpBSbmD/7tkCOOGVZ/z4o4rhvH78v9x/3338syzzwX1b3ksNFGtA++99x5PPvYIf7x3O2EWI85GCs4GiAiz4A7SRMKRJMdFcvWok1iw4I+AVqTM/flHbssK3he+TaSBzRs31Hhcp9PxwosvBa2/qnRq145NJRUNFlUhjl3u3iAEnQw6Ohl0nA8QbuK0gjLy7xlLeBDXxx8Lm9vLsIGn8uOvc486VlhYSOvMDL556/6QJStZsXYrT70xnU17S1F9Kj5VxevzoaoSr9eHy+3B6XLjdLlxuTw43W4qKhzodAqpiTFER1qJiQwjLiqcNulJ5BYUc/9r39Yoqoqi8MGjl5N9ydOcNnAQY8aErtBhVTRRDQCbzcbkG67jr4Xz+PmNyWSmxuP1+nC6PHi93pCWzP3km7l89csiVq3fjscTurXgUkoUpfbx3s2bN7N16zaGBzFxdVZcOIvWrQ1ae3WhU/fubF4xlyFpDf+RqOvNugTM9Rxjrw/HmpWPi4sjJiaarTv30a51zWPrDaFnl7ZMf+OeOl1jyhrLvjkvEBF29Pq4vMIyMkfdTVGJjdjo6u9eEmIj+PiJCVw46QqWLV9JWlrd02vWleabP6uZsGrVKrJ79oDy3Sz5+C66tPV/4PR6HSajnpz9B0La/0vvfsO+Xbu5a1w/Vr41OWT9qFLWmuS6rKyMRx95mPM6JWPQBeejY3N72VJoY9v27UFpr6506tadTfaG/1gJ6iaqBxOONGbtL8Gxl49m9+rFor9rvmNobIpKylClJNxafbxpUlwk3du35KpHPmT6L0uZvWg9y9ftZNfeA4eFh53aM4ubLhzI+AvPD1rY2LHQRLUGpJS8/vrrDD19EPdOGMjUhy8jzHL4PzcyzML23XkhtSMlKZbs9mlcNaY3aQlRIetHVQ8XVSklmzdv5oMPPuCaqybRrVN7UpKTmPn9txSVOxrUl0+VzN2ez1U/rKbtf2ezSCTxwquNNz5dlU6dOrG5PDgZuOokqlSfcDiUKLXEj156+QRe+/CnZpNGLzLcipT+oYGaeOi6M9i2p4B7X/2GiQ++x4jrX6bzuQ8RP/A2LrjjTfYfKAXgronDMckKHnwg9EtYtdv/aiguLuaqSRPYsXktC967naxW1a8kj4m0sisntKKa2iKenJ07Q9oHgE9KdmzezJNPPsmiP35n8ZKlWE0G+nVqSf8OyVw5eSjd27Tgu4UbuP31H+vVx6YDZXyyZi/T1uWSkNSCy666jhcvuZTExNAtKKiNTp06samguF4RAFVRhMBVBzHy0fiiWlvtqLFjx3LfvXfz64KVDDv1pEa0rHr0ej0mo4HicjuJsdVXUR05oAsjB3Q5av/i1dt58p2ZtBl9L5GR4ZTb7Hi8Pnbm2Xj8iSdDmuRaE9UjWLRoEeMvPJ+xp3Xi4/dvP2aS3bjoCPbmFYbUntSkONasCn3GxNbJscz95S8SPXu4rE8qb0y4ltRqPONRfdpzxdPT2VJYTlZc7XGhhXYX09fm8MnGfPaWu7j4ssuY+dokunZtaGK+4JCQkIDeYCDP4aZFDbeZgRBm0JOvSgIt+CxpAlHl2KKqKAp33X0vT/3v5WYhqgBmo4HCkooaRbUm+nVrzXf/nUz3C57gxdfepn///lit1gb9cAaKJqqVqKrKM888zcsvPs+U+8czdlCPWq9JiAknN78opHa1SIih1F7/KIP9ReW8+tVCUhOiuOGsmuNQJ43KZtKo7FrbC7MYGdIri+f+2MhbZ1dfLM7tU/lp8z4+3ZDPvB37GTNyJI//72mGDBkS0km9+tIxK4tNJbYGiWq02cj+OozXqbIpPFWBlMdeNTV+/HgefOA+5ixcxen9j1623NgYjXqKy2rKg187ZpMRvV7foHjmutL8PuFNQF5eHpdfejH24lyWfHwX6S0CqxSfGBdJ/oGSkNqWFB9NhStwUVVVldnLtzHl+79Yvi2P/MJSunXMZMOWxVwwsAvxNcyS1oVLhnTnrv/NPGyflJJlucV8sjaXGev30rlTJy67+V4+Ov98IiPr5mU0Np26dWPTuoUMTKn/KrEki4GNJS4GqiqRUOvtZZPc/lN7nlODwcCbU97mkssv5fdpT9K+Tehny4+Foii4PPV3Ki4e0ZO33nw96Mnbj0Ugmf+n4q9FlS+l7FK573zgYaAj0EdKWW3acCHETqCcQ5VyZe2uUCMzb948Lr7oAiaO7cOD19xcp2WkiTHhbN6zK4TW+T1Vu9N9zHNKbHbe+PYvvvlzI1tzC9HpdJw5tC//vfxchvTvTkS4lbFXPcrE577i+ycub7BNY/q1Z9KzX7KtyIZRp/DZmhw+2bAfn97EZZOuZMmnV5CZGeiNcNPTqXsPVi2d16A2wgx6fnB4+NnlxadKjJXp+vxVTQUG4X/opcSgqigeLz7gws8XYdbrMOsVTHodFoOCVa/DrNdhNeqxGnRY9DrCjHrCjTosBj0RJj3hRv8jwqSvNV/qQYRfVWs9b+TIkTz+5FOMufIR/pz+DEkJwVnkUVecTjdFxeV0bVv/EK/+Pdrw6W8/BNGq2gnkv/E+8BrwYZV9a4FzgSkBXD9YShnauKN6IKXkhRee5/lnn+b9Ry5jeP/OdW4jPjqcMlvDZsJrIyk+Grvj6JRsC9fu5PVvF7NoYy77CkrolNWScWcOZszg3nTrmHnU2NEzd0+g95m3sCevhPSk6AbZFG4xMahHG4Z8sAAPCuPGjWPqo1dx8sknN8qYVbDp3Lkz023H/uGqjWK3h3tP68gDgzvh8amUu72UuzyUu7yHtstcXmyVzzuKbaxbup2Udi1xuL243F7K3F6cbg8upxen24nL48VZucTT5fHi9vjweP95eFUVb2USFF1l6Wn/s39bOfRaVM78Q3RsYPG4V111Nbt37+bMqx9n7qdPEGZtaB2FuvPL/OXExYQTH1O3nA5VMRp0IavdVhO1iqqUcr4QIuOIfRuA4/ILBP78p1dOvIIdm9aw6IP/0Kqet32x0WE4qhG8YJIYH43d6cZmd/LOzGVMn7eOzXuL8Hi9jBrUmyfvGsGI03oRG33sD17Hti05a/jJTHhuBr89f2WDbFJVlZzCCibecBMPPfTQYTlYj0c6duzIxgYO4xR6VDJi/JVxDTqFWIuRWEvN9aVW7Svm0/W5vH7z2Ab1C+D1+XB7fLg8fvE9KMD+bd+h7T0FpTzw4fyA233kkUfZvWsnF9/8PF+9eU+tcczBxuP1YWpggUyzyUBpWXmQLAqMUI+pSmCWEEICU6SUb9V0ohDiGuAaIKRZZTZu3Mi5Z4+lf5cU5r17a4Oy88dGhmF3BjOxr8qWHXtZvmYrazbvYvP2veTsP0C41UzieU/RumULzh05gJdO7012t6w6f8gfv+Myugy/nk17CmifXv/0fTP+WIc5MpYnn3zyuP1hrUpycjIeVeWA0018PQvtlbs9ZEQHPhniVlV0QSq/otfp0Ot01OZM+nwqN7zyPeXl5QFl9BJC8Nbb7zJqxHBue2Iqrzx4dVDsDZRwqxlXAyrKqqrK2bdO4bxx44JoVe2EWlQHSClzhRCJ+CuvbpRSVvtTWSm4bwFkZ2eHJPr4yy+/5Pprr+aJyWO56txTGtxeXHQYTlfdbhtVVWXHnjw++noOfy5bT0FRGSVlNsptDmwVdvR6HcmJcWSkJ9G2VTL9TupARloip/Xp0uCxrcz0Flx6zulc8+K3zHvpqnq1sWLzXv7v9Z/4/MuvTwhBBb94dGzbls0lFcS3qF5UvarK/Nwiwgw6oowGIo16rHoFq06PUa9Q7vLQMtoacJ9un4quEVdTAeh0Ch0zUli3bl2tGckOYjQamfH1Nwzo349X3vuWmyeeFWIr/yEi3Iq7AUuzvT6VHTl5vPTyf4NoVe2EVFSllLmVz/lCiK+BPkDg9x9Bwuv1cs/ddzH9s0/48dUbyO6cEZR2zUYDdoeTb2ctorTcjs3uoLTMTlFpOSVlNsrKHdjsDiocTqxmM2V2F2s2bMcaZiUvr4DbrzmP1ulJtEpNpGVKAi1TEomMCPyLWR/OH30KE39bUq9rf12+lcue+Yo3przDoEGDgmtYE5Kfn49HSiYv2kCK2Uiq1URmhIV20eF0iQ2nbaSV839dxd+FpRj1OlxeH26vD58q8akSARj0Cgl1CMny+CRKEAsFBkqXzATWrFkTsKgCREdHM/OnX+h/cl/iYyK55OzGmUmPaqCoNhUhE1UhRBigSCnLK7eHA4+Gqr+ayMvL46ILxmHwlbHk4zvrPOjtdLp5/7uFrNy0hy2788kvqqDEZqfM5sDhdBETGc7Nj76F2WjEYjZiNhuJiggjKsJKZISVtOR4Pv12Lj2z+/LEw3fTrVs31q9fz1233cBz90wK0buumU5ZLSkqq6jTNb+v3M6jn/zB3mIn7334SbOorR4Mtm/fznPPPMVn06ZxXnZrsntkk1NsY2dhBYsOlPNl7i7yy+w4PT70isKqxy6kbdLhCyKk9Atryi0f8Pe+YgYEWBXB7VUbdd3/Qbqkx7J61d91vq5Vq1bMmv0bw4b60zM2hrBGhFtwhyhRdygJJKRqGjAIiBdC5AAP4S/d8yqQAPwohFgppRwhhEgB3pFSjsZfJfjryltEPfCplPLn0LyN6lm8eDHnn3cOV5yRzUPXXoquHklAHnvrR974Yh6nD+hBv97dadOyBa1btqB1ejKpLeJqDcGau2gVM2YtYfqXMw4FIKuqimj0KEU/yYmxSCnZknOArFoyMy3fvJd735vDjvwKHnzkMS6++OJmGbxfV/bu3cvtN0/m119/46rT2rP20XG0iKr5DsHh9uL0+IgJO9oTFUKg1wnaJEWxeE9RwKLqUdWm8VRbt+DH71fW69rOnTsz+9c5DBt6OlJKLj2n+vy3wUKI4zM1SSCz/+NrOPR1NefmAqMrt7cDTbIkQ0rJG2+8wSMP3c/bD17CmQPrb0ZZhZNB/brx1Zv31ev61z/6iQcefPiwFR0Gg4HduXls2bGXrMzQpFmrCSEEbVolM3v51mpFVUrJXxv28NLXf7FwfQ4PPPQIV155VaNmTg81CxcuZNvKpWx98gIijjFDfxCLUY+lhkq0B+mYEsOq/SUB2+DxSfRByvRVF7pmJrFm3Vf1znVwUFhHjhjGzr0F3HfjBSfM2HqwOD5/Co6B3W7nissuYcqrz7HgvTsaJKgA6S1i+Hv9tjpPSB2kzOY4Kpqhb9++TJh0DVf855UG2VZfundszaJ1uw/bZ3e6eefHpfSe/DaXvzCTfqMvYcu2nVx33fUnlKACdOjQAZvHF5CgBkrH5Gh2lAYes+xqgokqgBaxEUhVJS+v/omAOnfuzF9LlvH9vLVce98bQbTuxOCEEtVt27Zxct/e+Ep2sfD9O2jbsuHZj+64Yjh6RfD4q5/X63qH043FcnhWeUVRuOmmm9iwZXeTpFnr3jGTTXsLqXC4+XHxRm787w9kXPIiP25y8NTLb7J52w5uv/12rNbQTpo1FVlZWezYX4gniON1WYlRFDoDX07pVdUm8VSFEHRtk8qaNWsa1E5KSgpz5s7j02/n4ghiWOGJwAkjqt9//z0n9+vD1Wf04MPHr6h31dIjURSFS0b3ZuHy9cc8r6zcTkmZDYfThc/n/7KqqsrWnXtJTz+6Wmd8fDwSOFAUnAqWdaFj23S27ysm5cJnePGnLbTsewbLV67m2x9+YsSIESFNi9YcMJvNpLVIYltB8P72bZKiKHUEfjfj9qlN9nfu0iq+waIKEB4eTqcO7Vm+ZmsQrAo+TZUX9vifdcA/ITV27FgMBj33vvYNtzz3OT6fj0+fuZoLR1SfSakuRIZbqHDUvNTN5fKQ1PsSzCYTLrcbl8uNoigYDHpaZ2aQkZFx1DXPPPM0yQmxhFdTJiLUdMpKx2S2sGvLtjqXdT5R6NihPZv2ldAhOVgVYSOxuTz0fed3VPyZ/VX5z7PvYLE86S+g5/L6MNUyThsqOreKY0k9IgCqY8Cpp/HH0nWc0rvuy7xDyZZdeVz18AeYG6n+V1VOCFHt06cPW7ZswWr1V4a0Wq1cfeUE7HXwHI5FVLil2vX3BymvsBNmtVJYVHxon9frxeVyVTtb/uOPP/Lfl19kyTcvYDHXP91cfclIS6KouOSEmMmvL+27dGPDroWcFXAG1GNjNRlAwCVjehMVbkFfmVBFr1Mw6HXoK7cPPpZsyOHtmUsPa6O8wsmuvBJ2F5SQe6CcfYVl5JdWUOFw89r/jcVaz9VeR9K1dQum/r4wKG0NHnw6/3v5SepWeSo07NlXyNNTf+aXhevYV1DCqL4dMBqDN24eKCfEt0pRFNq2bXvYPo/bg8EQHC9wzZYc1GPUYK+wuwgLO3z8Ua/X1yhaJ510Eh6vyvSZC4iPiSQizMKQAT0ID2t4meRA2F9QTER4+HG/Zr8hpLdsxfJlvwa1TaNex4WDu5GeGF3rufklFewrLCP+7MeocLhxe33oFIHVYiIyzExUuJWYqDBio8L4bfF6zhrQibMGdKq13XK7i49n/43L48XrUw9/qBKPV6XU7mLdxs0NrnYAcOqpp3LZpevYtC2nUdMEer1evp+/hum/LGPD9n0UFJVRVFbBKd1a88AlgxjbvyM2h4sBt77faDYd5IQQ1SNZvXo1s3/9lf+cd1OD27rnla94/7vF/PR+zesW9hcUkZgQ+Fr6lJQUPvzoY775+itKN+7k8+kz+PWTJxstKfCy1VvI7tXzXxsK8+Tjj/HSC8/z1mUDgtquUa+jzB7YpM05p3Sibcq1RFiNXPbkFww+uQvP3Hpetf+T9mPvpyLAu67F63fz7FfLOOfcc9FbDOgNBvR6gz9Rs8H/3EKv541zrw3K/z82NpaXX3mFUy/8D1ecdzpXXjCMDm2OnkNoCF6vl3nLtvDVbytYsnYH+wpKKSmrICrcwuk923LliB50yWxBz6wUIqsMpxWXOzA0MCFLfTghRfXtt9+ic+sWdG6TUuu5593+Jis3+T1RWTneJaVEqv5tp8vD3GlP0atrVo1t2OxOSkpLKS0tJSoqsOJ8o0aNYtSoUXz44YfMmfMbFrMRj8fbKB+CZWu2kt2nb8j7aY58+uknfDjlNZbdfxZpsQ1P2F0Vg15HeYCiajYa6N3B79nFRFjQ63U1ipzJaKCilpy6B7G7PPTo1pWXX3k1MKODwKRJV3Lqqafxzjtvc/olD5DWIp6+PbLo0TGDDm3SMRkN6PUKOkVHXEwEyYmxCCHwen0UFpdRUFTK0tWb+XPZerbu3EdJmQ2n043D6cKkV4jodxMRYSb6dGzJhad2ole7VNqnJ5ASf+zk5x6fr0nCAU9IUX3mmWc568wxXHrfe5w3pAcGvY4ubVNok350iNXmnfkM7t+dcaNOQa/TodMpVZ4VMtKSak1kcnr/7ow8tRtnnjGaefMX1MkD6NOnD+MvuYwbHn6PHTt3MeH8Ybz8QP2SnQTKsrXbue7mC0PaR3Nk9+7d3HLTZH6YPDToggp181SrYtApeI6xxj06wsqdb/3CA+//hhD4V+MJ4d8W/jApgf+1z6fSqnXbGtsKFVlZWTzzzLM8/vgTLFiwgBUrVjD/7+W8M+NPPB4PPp8Pr9dLfsEBvF4PFrOJvIIiYmOiiY+LpfBAAV0zEjilQxop8a2JCjMTFWYmNsJKh5YJxETUfWjM61M1TzVYWK1Wvv3+R+668w4+X7AHj8fDosc+5c37x3PO6YcXNOvTpSXFJTZGDap/UQIhBK88eDUtB0xix44dtG7dOuBrO3TowCuv+LPoXDz+QsKtoQ2zkVKybPVmsrObXRGGkDPlzf8xPrsVvTLqn/bwWBh1gXuqVTHodbg8NcfMznjhOnILSvCpKqoq/Q8p8flUfzSBevBZMm/ZZlbm1L/8SEMxGAwMHjz4mOVL8vPzcTgcpKWlHUpfOfjUk7n77M6cflKboNmihVQFGavVyquv/bPaY9myZZw99gy27MrnzokjDu0/Y2B3bnr684aXKFYU+nRvz/Lly+skqgdZuXIlc377jU2/vVlvGwJhycpNxMTEkJJS+9DICYcQxFpDNxtsMtTPUzXqdcdMHJIQG0FCbGChbxUOF6tymmfc6EGqK0keHh6OLUjROgeJsJooL69b8qBgcGJHeVchOzubv5Yu58l3fyY3v+TQ/hEnd8LpcvP+lw2fCU6MjyI/P79e1971n9u5f/IFIU/9N/XLOUyYeOW/cpLKbLbg8h67mmhDUAT1SlWnKAJVDY5dFpOx0cuHBIOIiMh6efnHItJqpsxmC2qbgfCvEVWA1NRUOrbPYltOwaF9VouJN++/hP97+E127NnfoPYTYyMoKCio/cQjmDVrFju2b+Wa8SMb1H9tVNidfDnzD6644oqQ9tNcMZlMuI8RGtcQVFVlX0kFHVvVfWm0x6tiCNIKQLPJcNyJqtvtZu26dUQFeSFMhNVIuc0etB+sQPlXiSpAXFwc5RWHf+jGDetFny4ZPPLKtHq3KysjBQoK6p6o4pOPP8LpcnHPcx/y87xlVNhD86V47q2vGDZ0GKmpjZsZq7ngdDoxhijd3tvzN1BYZqdVUnSdx/K8PjVoy6oNeh1ud3Bvo0PNY48+QlqUnjH92ge1Xb1OR5v0JFatWhXUdmvjXyeqaS1b8n/PTufOl75iwd9b8FVWo7zjiuH8/Hu1lbYDYtp38/jylyVcdlndvcB3p77HF19+Q3R6d55+5xda9LmMwRffz+OvfsbivzfiDULij2279vH6RzN5/sWXGtzW8Ur+/lwSIkKz4EFKSUy4ha6TXsE68kE6TniJeau2B3StT1UxBCm5itPlOa4WdSxbtowp/3udt245MyRDUmP6ZPH9998Fvd1jccJOVNXElLfe5e+//+brr7/iphe+Yv/+/Yw5tStt0+LwNeA2obS8ghEjR9apTMVB9Ho9/fr1o1+/fjzwwAPYbDb++OMPZs+exXUPvsuu3XsYdHJ3hpzchaGn9KB967Q6fQCllEx+aAr/ufPOapO7/FtYMO93sk9OZdO+4irr8v2z5h2SYzAZ6u8tXje4C9cN7gLAnsJyRr/0IwvW7GRg99onLX2qij5IlUodLvdxk13M6XRy+SXjeen6kbXGnNaXMX2zuH/aNzz44EMhab86Asn8PxU4A8iXUnap3Hc+8DDQEegjpazWxRNCjAReAXT4KwI8HSS7640Qgp49e9KzZ08ee+xxduzYwTfffMOXn0+jtLyCoZc9yMDeHRnUryt9urfHFGC1VaNBj9sVnEHx8PDwQ4sDwF8SZs6cOcye9QvPvfMoqs/L0AE9GNK/K0MG9CA5MfaY7f3v45kUlnu57bbbg2Lf8YiUEp3ByBO/bkZRtqIoyqHH/vwDPHxG10Oi2FDS4yJIjQ7jhel/8vWCDf44UvFPSXe314fbo+Lx+fB4fRSW2ujbq0NQ+rZXk2qyuXL/fffQKSWCiwZ3C1kfp3RpxfYdXzJt2jTGj68p335wCcRTfR94Dfiwyr61wLnAlJouEkLogNeBYUAOsFQI8Z2U8tg59BqZzMxMbr31Vm699VZKS0tZsGABc+fO4Y5nP2PDpk307t6BgX06MahvV/r2qFlkjQYDnhCNZSUlJTF+/HjGjx+PlJKtW7cye/Zsvpn9Czc/+g4pSXEM6d+NoQO6M7BvFyLC//FUNmzdzcOvTOPPhYtPuGTTdUEIwfKVq6s99sADD5C76qeg9pceG8Zep48J557qX6lXuWJPAhazkTCLEavZSJjFRJjFRLes4IxzO1weLJbm76n++eeffPLhB6yccn1II1GMBj2znr6cs++4mU0bN/DQw4+EPPIlkHIq84UQGUfs2wDUZlwfYGtlWRWEEJ8BZwHNSlSrEhUVxZgxYxgzZgwApaWl/Pnnn8ydO4f/PPcZ6zduok+Pf0S2T492mE3+uEejUY/LFfpkvUIIsrKyyMrK4oYbbsDn87FixQpmzZrFSx/9wvibn6NHp7YM6d+F00/uzm1PTOWxx5+gXbt2IbfteGXN8qVc2OrY3n5dyUiIZHOFyuTxoa3jdCQOpweztXl7qhUVFVxx6cW8ftMYEqKDv7LtSLq1SWbRK1cx7O73iImN5eabbwlpf6EcU00F9lR5nQPUuOBcCHENcA1wVPmRpiIqKorRo0cfqh5aVlZ2yJO98/nPWbdhY6Un2xGv19cks646nY7evXvTu3dv7rvvPux2OwsWLGD27Fnc8uRHdOl6Etdee12j23U8YbaY8fqCF8+4IbeYdxZspm+PmvNFhAqfqqLTNX46ybrwzNNP0TcrgbNPqT3rVrBIio3gu0fHc8otj9GmTVvOOOOMkPUVSlGtzo2tMdZESvkW8BZAdnZ206wvq4XIyMijRPagJztvwRx6NoOln1arleHDhzN8+HB47vmmNue4oMtJvVi+4GsuPjk47Q167nsuHtOPZ289LzgN1gGdouDz1X0BQmOybs0qhnZuvDSBB8loEcOXD17AWVdcxsrVa0MWWhjKkKocoOpUcxqQG8L+Gp3IyEhGjRrFs88+x19Ll/O//9U4xKzRjBk79iy+XbUnKGvFD5Q7KLU5ePbW8zA2QTIPnU6g+oJXeysUTL75Nl6YsTioNcICpV+nllw3JptbbroxZH2EUlSXAllCiEwhhBG4CGjcgDENjQDo2rUrlohIZq7eXfvJtfDDyp1kpMY3iaBCpafaBGJVFwYPHkzrrA68/cOSJun/notPZeWyv/j+++9D0n6toiqEmAYsAtoLIXKEEFcKIc4RQuQAJwM/CiF+qTw3RQgxE0BK6QUmA78AG4AvpJTrQvIuNDQagBCCF//7Ord8/hd2V/0zPP139mru+mopw05uunpNEWFmyssbv5hkXXnxldd49NMF/Lq88ZO/mI0GXps8iltuujEkk8u1iqqUcryUMllKaZBSpkkp35VSfl25bZJSJkkpR1SemyulHF3l2plSynZSyjZSyieCbr2GRpAYOXIk/U4dxK2f/1WvYYBFW/dzz4y/ePHOC/nvXU2XqzY+OpwDBw40Wf+B0qVLF2Z8/S2XPv0VSzfmNHr/w7Kz6JAaxf/+90btJ9eRf90yVQ2Nmpjy7nss3udkyu8b6nzthtxiWqcmcOmYfk1a4jshJoKC40BUwV/faso7U7ng8S/IL278bFK3nNOHLz79OOjt/uuWqWpo1ERERATf/DCT/n2y6ZURT+/MwDNO7SutILYOMZc+n4rD5cbh9GB3uv3bLk/la1eVbf8xp8uDw+nG7vTgcHtxuLyV2x4cLi8Oh/+8sgoH5bbjJ0vVOeecw9Ili7n4qRn8/NSlQVuuGwj9O7di9bpPKSsrIzIyeMtkRVNlxz4W2dnZctmy+ic30dBoCDNmzOCOydfy+sX98HhV3F4fLq8Pp8f/7PJU2faquHzw27rdHHB6Gdink1/kXJ5DQucXTzd2h6ty24XH48ViNmGxmLFaLFgsZixmM1arFYvFcuhhtYZhtlqxWKxYw8IPHT/6vH9eJyUlHVeZyHw+H6NHDKOlxcGTk4YSG2lptHy/J10/hamfzqBXr151uk4IsVxKWW0MpeapamgcwXnnnceWTRt48eefMJlM/ofZitlswWg2Y4o0YzJbMFusRJjNxJtMjD/Ng9PppF27dtUK3ZEiaDKZ/pWJwqtDp9Mx/atvuHT8BWRNeBmHw0WL+GiSYiOJDDMRbjERbjYQYTEQaTaQFGMlOS6SlLgI0hKiyGgRU++/parKGkvJ1xfNU9XQ0GhWOBwO9u/fT15eHuXl5dhstkPPJSUl7N+3l305e9i3L5edu/Zgd9jp0ymDVgmRSDhUw8ufgQwkssq+f45LCbOXbmDJ0uV07NixTjZqnqqGhsZxg8ViITMzk8zMzIDO37dvH4sXLyY3NxedTndYBrLqHkKIQ9uTTKag58XQRFVDQ+O4Jjk5mXPOOaepzTiEFlKloaGhEUQ0UdXQ0NAIIpqoamhoaAQRTVQ1NDQ0gogmqhoaGhpBRBNVDQ0NjSCiiaqGhoZGENFEVUNDQyOINMtlqkKIAmBXkJqLB46PXGjHRnsfzQvtfTQvGvt9tJJSJlR3oFmKajARQiyraY3u8YT2PpoX2vtoXjSn96Hd/mtoaGgEEU1UNTQ0NILIv0FU32pqA4KE9j6aF9r7aF40m/dxwo+pamhoaDQm/wZPVUNDQ6PR0ERVQ0NDI4ic0KIqhIgWQnwphNgohNgghDi5qW2qK0KI9kKIlVUeZUKIW5rarvoghLhVCLFOCLFWCDFNCGFuapvqgxDi5sr3sO54+l8IIaYKIfKFEGur7IsVQswWQmypfI5pShsDoYb3cX7l/0MVQjRpaNUJLarAK8DPUsoOQHeg7gXdmxgp5SYpZQ8pZQ+gF2AHvm5aq+qOECIV+D8gW0rZBdABFzWtVXVHCNEFuBrog/8zdYYQIqtprQqY94GRR+y7G/hNSpkF/Fb5urnzPke/j7XAucD8RrfmCE5YURVCRAKnAe8CSCndUsqSJjWq4QwBtkkpg7XarLHRAxYhhB6wArlNbE996AgsllLapZReYB7QfGp5HAMp5Xyg6IjdZwEfVG5/AJzdmDbVh+reh5Ryg5RyUxOZdBgnrKgCrYEC4D0hxN9CiHeEEGFNbVQDuQiY1tRG1Acp5V7geWA3sA8olVLOalqr6sVa4DQhRJwQwgqMBtKb2KaGkCSl3AdQ+ZzYxPYc95zIoqoHegL/k1KeBFRwfNzaVIsQwgiMBaY3tS31oXKs7iwgE0gBwoQQlzatVXVHSrkBeAaYDfwMrAK8TWqURrPiRBbVHCBHSvlX5esv8Yvs8cooYIWUMq+pDaknQ4EdUsoCKaUH+Aro38Q21Qsp5btSyp5SytPw34ZuaWqbGkCeECIZoPI5v4ntOe45YUVVSrkf2COEaF+5awiwvglNaijjOU5v/SvZDfQTQliFEAL//+O4mzgEEEIkVj63xD85cjz/X74DrqjcvgL4tgltOSE4oVdUCSF6AO8ARmA7MFFKWdykRtWDyrG7PUBrKWVpU9tTX4QQjwAX4r9d/hu4Skrpalqr6o4Q4g8gDvAAt0kpf2tikwJCCDENGIQ/TV4e8BDwDfAF0BL/D9/5UsojJ7OaFTW8jyLgVSABKAFWSilHNIl9J7KoamhoaDQ2J+ztv4aGhkZToImqhoaGRhDRRFVDQ0MjiGiiqqGhoRFENFHV0NDQCCKaqGpoaGgEEU1UNTQ0NILI/wPkwghW+Y9W/AAAAABJRU5ErkJggg==\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# No legend here as we'd be out of space\n", + "tracts.plot(column='CRIME', scheme='equal_interval', k=12, cmap='OrRd', edgecolor='k')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Classificaton by natural breaks\n", + ">NATURAL BREAKS is a kind of “optimal” classification scheme that finds class breaks that will minimize within-class variance and maximize between-class differences. One drawback of this approach is each dataset generates a unique classification solution, and if you need to make comparison across maps, such as in an atlas or a series (e.g., one map each for 1980, 1990, 2000) you might want to use a single scheme that can be applied across all of the maps." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "ExecuteTime": { + "end_time": "2017-12-15T21:28:00.376417Z", + "start_time": "2017-12-15T21:27:57.042Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Compare this to the previous 3-bin figure with quantiles\n", + "tracts.plot(column='CRIME', scheme='natural_breaks', k=3, cmap='OrRd', edgecolor='k', legend=True)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Other classification schemes in PySAL\n", + "\n", + "Geopandas includes only the most used classifiers found in PySAL. In order to use the others, you will need to add them as additional columns to your GeoDataFrame.\n", + "\n", + ">The max-p algorithm determines the number of regions (p) endogenously based on a set of areas, a matrix of attributes on each area and a floor constraint. The floor constraint defines the minimum bound that a variable must reach for each region; for example, a constraint might be the minimum population each region must have. max-p further enforces a contiguity constraint on the areas within regions." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
AREAPERIMETERCOLUMBUS_COLUMBUS_IPOLYIDNEIGHOVALINCCRIMEOPEN...XYNSANSBEWCPTHOUSNEIGNOgeometryMax_P
00.3094412.440629251580.46700319.53115.7259802.850747...38.79999944.0700001.01.01.00.01000.01005.0POLYGON ((8.62413 14.23698, 8.55970 14.74245, ...0
10.2593292.236939312144.56700121.23218.8017545.296720...35.61999942.3800011.01.00.00.01000.01001.0POLYGON ((8.25279 14.23694, 8.28276 14.22994, ...0
20.1924682.187547463626.35000015.95630.6267814.534649...39.82000041.1800001.01.01.00.01000.01006.0POLYGON ((8.65331 14.00809, 8.81814 14.00205, ...2
30.0838411.427635524233.2000014.47732.3877600.394427...36.50000040.5200001.01.00.00.01000.01002.0POLYGON ((8.45950 13.82035, 8.47341 13.83227, ...2
40.4888882.997133675723.22500011.25250.7315100.405664...40.00999838.0000001.01.01.00.01000.01007.0POLYGON ((8.68527 13.63952, 8.67758 13.72221, ...3
\n", + "

5 rows × 22 columns

\n", + "
" + ], + "text/plain": [ + " AREA PERIMETER COLUMBUS_ COLUMBUS_I POLYID NEIG HOVAL \\\n", + "0 0.309441 2.440629 2 5 1 5 80.467003 \n", + "1 0.259329 2.236939 3 1 2 1 44.567001 \n", + "2 0.192468 2.187547 4 6 3 6 26.350000 \n", + "3 0.083841 1.427635 5 2 4 2 33.200001 \n", + "4 0.488888 2.997133 6 7 5 7 23.225000 \n", + "\n", + " INC CRIME OPEN ... X Y NSA NSB EW CP \\\n", + "0 19.531 15.725980 2.850747 ... 38.799999 44.070000 1.0 1.0 1.0 0.0 \n", + "1 21.232 18.801754 5.296720 ... 35.619999 42.380001 1.0 1.0 0.0 0.0 \n", + "2 15.956 30.626781 4.534649 ... 39.820000 41.180000 1.0 1.0 1.0 0.0 \n", + "3 4.477 32.387760 0.394427 ... 36.500000 40.520000 1.0 1.0 0.0 0.0 \n", + "4 11.252 50.731510 0.405664 ... 40.009998 38.000000 1.0 1.0 1.0 0.0 \n", + "\n", + " THOUS NEIGNO geometry Max_P \n", + "0 1000.0 1005.0 POLYGON ((8.62413 14.23698, 8.55970 14.74245, ... 0 \n", + "1 1000.0 1001.0 POLYGON ((8.25279 14.23694, 8.28276 14.22994, ... 0 \n", + "2 1000.0 1006.0 POLYGON ((8.65331 14.00809, 8.81814 14.00205, ... 2 \n", + "3 1000.0 1002.0 POLYGON ((8.45950 13.82035, 8.47341 13.83227, ... 2 \n", + "4 1000.0 1007.0 POLYGON ((8.68527 13.63952, 8.67758 13.72221, ... 3 \n", + "\n", + "[5 rows x 22 columns]" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "def max_p(values, k):\n", + " \"\"\"\n", + " Given a list of values and `k` bins,\n", + " returns a list of their Maximum P bin number.\n", + " \"\"\"\n", + " from mapclassify import MaxP\n", + " binning = MaxP(values, k=k)\n", + " return binning.yb\n", + "\n", + "tracts['Max_P'] = max_p(tracts['CRIME'].values, k=5)\n", + "tracts.head()" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "tracts.plot(column='Max_P', cmap='OrRd', edgecolor='k', categorical=True, legend=True)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.7.6" + }, + "nbsphinx": { + "execute": "never" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/doc/source/gallery/create_geopandas_from_pandas.ipynb b/doc/source/gallery/create_geopandas_from_pandas.ipynb new file mode 100644 index 0000000..00aa6c2 --- /dev/null +++ b/doc/source/gallery/create_geopandas_from_pandas.ipynb @@ -0,0 +1,228 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "# Creating a GeoDataFrame from a DataFrame with coordinates\n", + "\n", + "This example shows how to create a ``GeoDataFrame`` when starting from\n", + "a *regular* ``DataFrame`` that has coordinates either WKT\n", + "([well-known text](https://en.wikipedia.org/wiki/Well-known_text))\n", + "format, or in\n", + "two columns.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import pandas as pd\n", + "import geopandas\n", + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "From longitudes and latitudes\n", + "=============================\n", + "\n", + "First, let's consider a ``DataFrame`` containing cities and their respective\n", + "longitudes and latitudes.\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "df = pd.DataFrame(\n", + " {'City': ['Buenos Aires', 'Brasilia', 'Santiago', 'Bogota', 'Caracas'],\n", + " 'Country': ['Argentina', 'Brazil', 'Chile', 'Colombia', 'Venezuela'],\n", + " 'Latitude': [-34.58, -15.78, -33.45, 4.60, 10.48],\n", + " 'Longitude': [-58.66, -47.91, -70.66, -74.08, -66.86]})" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "A ``GeoDataFrame`` needs a ``shapely`` object. We use geopandas\n", + "``points_from_xy()`` to transform **Longitude** and **Latitude** into a list\n", + "of ``shapely.Point`` objects and set it as a ``geometry`` while creating the\n", + "``GeoDataFrame``. (note that ``points_from_xy()`` is an enhanced wrapper for\n", + "``[Point(x, y) for x, y in zip(df.Longitude, df.Latitude)]``)\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "gdf = geopandas.GeoDataFrame(\n", + " df, geometry=geopandas.points_from_xy(df.Longitude, df.Latitude))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "``gdf`` looks like this :\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "print(gdf.head())" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Finally, we plot the coordinates over a country-level map.\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "tags": [ + "nbsphinx-thumbnail" + ] + }, + "outputs": [], + "source": [ + "world = geopandas.read_file(geopandas.datasets.get_path('naturalearth_lowres'))\n", + "\n", + "# We restrict to South America.\n", + "ax = world[world.continent == 'South America'].plot(\n", + " color='white', edgecolor='black')\n", + "\n", + "# We can now plot our ``GeoDataFrame``.\n", + "gdf.plot(ax=ax, color='red')\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "From WKT format\n", + "===============\n", + "Here, we consider a ``DataFrame`` having coordinates in WKT format.\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "df = pd.DataFrame(\n", + " {'City': ['Buenos Aires', 'Brasilia', 'Santiago', 'Bogota', 'Caracas'],\n", + " 'Country': ['Argentina', 'Brazil', 'Chile', 'Colombia', 'Venezuela'],\n", + " 'Coordinates': ['POINT(-58.66 -34.58)', 'POINT(-47.91 -15.78)',\n", + " 'POINT(-70.66 -33.45)', 'POINT(-74.08 4.60)',\n", + " 'POINT(-66.86 10.48)']})" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We use ``shapely.wkt`` sub-module to parse wkt format:\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from shapely import wkt\n", + "\n", + "df['Coordinates'] = geopandas.GeoSeries.from_wkt(df['Coordinates'])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The ``GeoDataFrame`` is constructed as follows :\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "gdf = geopandas.GeoDataFrame(df, geometry='Coordinates')\n", + "\n", + "print(gdf.head())" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Again, we can plot our ``GeoDataFrame``.\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "ax = world[world.continent == 'South America'].plot(\n", + " color='white', edgecolor='black')\n", + "\n", + "gdf.plot(ax=ax, color='red')\n", + "\n", + "plt.show()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.1" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/doc/source/gallery/geopandas_rasterio_sample.ipynb b/doc/source/gallery/geopandas_rasterio_sample.ipynb new file mode 100644 index 0000000..1f1f312 --- /dev/null +++ b/doc/source/gallery/geopandas_rasterio_sample.ipynb @@ -0,0 +1,173 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "# Using GeoPandas with Rasterio to sample point data\n", + "\n", + "This example shows how to use GeoPandas with Rasterio. [Rasterio](https://rasterio.readthedocs.io/en/latest/index.html) is a package for reading and writing raster data.\n", + "\n", + "In this example a set of vector points is used to sample raster data at those points.\n", + "\n", + "The raster data used is Copernicus Sentinel data 2018 for Sentinel data.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import geopandas\n", + "import rasterio\n", + "import matplotlib.pyplot as plt\n", + "from shapely.geometry import Point" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Create example vector data\n", + "=============================\n", + "\n", + "Generate a geodataframe from a set of points\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Create sampling points\n", + "points = [Point(625466, 5621289), Point(626082, 5621627), Point(627116, 5621680), Point(625095, 5622358)]\n", + "gdf = geopandas.GeoDataFrame([1, 2, 3, 4], geometry=points, crs=32630)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The ``GeoDataFrame`` looks like this:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "gdf.head()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Open the raster data\n", + "=============================\n", + "\n", + "Use ``rasterio`` to open the raster data to be sampled" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "src = rasterio.open('s2a_l2a_fishbourne.tif')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's see the raster data with the point data overlaid.\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "tags": [ + "nbsphinx-thumbnail" + ] + }, + "outputs": [], + "source": [ + "from rasterio.plot import show\n", + "\n", + "fig, ax = plt.subplots()\n", + "\n", + "# transform rasterio plot to real world coords\n", + "extent=[src.bounds[0], src.bounds[2], src.bounds[1], src.bounds[3]]\n", + "ax = rasterio.plot.show(src, extent=extent, ax=ax, cmap='pink')\n", + "\n", + "gdf.plot(ax=ax)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Sampling the data\n", + "===============\n", + "Rasterio requires a list of the coordinates in x,y format rather than as the points that are in the geomentry column.\n", + "\n", + "This can be achieved using the code below" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "coord_list = [(x,y) for x,y in zip(gdf['geometry'].x , gdf['geometry'].y)]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Carry out the sampling of the data and store the results in a new column called `value`. Note that if the image has more than one band, a value is returned for each band." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "gdf['value'] = [x for x in src.sample(coord_list)]\n", + "gdf.head()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.2" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/doc/source/gallery/index.rst b/doc/source/gallery/index.rst new file mode 100644 index 0000000..bb1f864 --- /dev/null +++ b/doc/source/gallery/index.rst @@ -0,0 +1,11 @@ +Examples Gallery +================ + +The following examples show off the functionality in GeoPandas. They highlight many of the things you can do with this package, and show off some best-practices. + + +.. nbgallery:: + :name: nbshpinx-gallery + :glob: + + ./* \ No newline at end of file diff --git a/doc/source/gallery/matplotlib_scalebar.ipynb b/doc/source/gallery/matplotlib_scalebar.ipynb new file mode 100644 index 0000000..0cde080 --- /dev/null +++ b/doc/source/gallery/matplotlib_scalebar.ipynb @@ -0,0 +1,217 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Adding a scale bar to a matplotlib plot\n", + "When making a geospatial plot in matplotlib, you can use [maplotlib-scalebar library](https://pypi.org/project/matplotlib-scalebar/) to add a scale bar." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import geopandas as gpd\n", + "from matplotlib_scalebar.scalebar import ScaleBar" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Creating a ScaleBar object\n", + "The only required parameter for creating a ScaleBar object is `dx`. This is equal to a size of one pixel in real world. Value of this parameter depends on units of your CRS.\n", + "\n", + "### Projected coordinate system (meters)\n", + "The easiest way to add a scale bar is using a projected coordinate system with meters as units. Just set `dx = 1`:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "tags": [ + "nbsphinx-thumbnail" + ] + }, + "outputs": [], + "source": [ + "nybb = gpd.read_file(gpd.datasets.get_path('nybb'))\n", + "nybb = nybb.to_crs(32619) # Convert the dataset to a coordinate\n", + "# system which uses meters\n", + "\n", + "ax = nybb.plot()\n", + "ax.add_artist(ScaleBar(1))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Geographic coordinate system (degrees)\n", + "With a geographic coordinate system with degrees as units, `dx` should be equal to a distance in meters of two points with the same latitude (Y coordinate) which are one full degree of longitude (X) apart. You can calculate this distance by online calculator [(e.g. the Great Circle calculator)](http://edwilliams.org/gccalc.htm) or in geopandas.\\\n", + "\\\n", + "Firstly, we will create a GeoSeries with two points that have roughly the coordinates of NYC. They are located on the same latitude but one degree of longitude from each other. Their initial coordinates are specified in a geographic coordinate system (geographic WGS 84). They are then converted to a projected system for the calculation:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from shapely.geometry.point import Point\n", + "\n", + "points = gpd.GeoSeries([Point(-73.5, 40.5), Point(-74.5, 40.5)], crs=4326) # Geographic WGS 84 - degrees\n", + "points = points.to_crs(32619) # Projected WGS 84 - meters" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "After the conversion, we can calculate the distance between the points. The result slightly differs from the Great Circle Calculator but the difference is insignificant (84,921 and 84,767 meters):" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "distance_meters = points[0].distance(points[1])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Finally, we are able to use geographic coordinate system in our plot. We set value of `dx` parameter to a distance we just calculated:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "scrolled": true + }, + "outputs": [], + "source": [ + "nybb = gpd.read_file(gpd.datasets.get_path('nybb'))\n", + "nybb = nybb.to_crs(4326) # Using geographic WGS 84\n", + "\n", + "ax = nybb.plot()\n", + "ax.add_artist(ScaleBar(distance_meters))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Using other units \n", + "The default unit for `dx` is m (meter). You can change this unit by the `units` and `dimension` parameters. There is a list of some possible `units` for various values of `dimension` below:\n", + "\n", + "| dimension | units |\n", + "| ----- |:-----:|\n", + "| si-length | km, m, cm, um|\n", + "| imperial-length |in, ft, yd, mi|\n", + "|si-length-reciprocal|1/m, 1/cm|\n", + "|angle|deg|\n", + "\n", + "In the following example, we will leave the dataset in its initial CRS which uses feet as units. The plot shows scale of 2 leagues (approximately 11 kilometers):" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "nybb = gpd.read_file(gpd.datasets.get_path('nybb'))\n", + "\n", + "ax = nybb.plot()\n", + "ax.add_artist(ScaleBar(1, dimension=\"imperial-length\", units=\"ft\"))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Customization of the scale bar" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "scrolled": true + }, + "outputs": [], + "source": [ + "nybb = gpd.read_file(gpd.datasets.get_path('nybb')).to_crs(32619)\n", + "ax = nybb.plot()\n", + "\n", + "# Position and layout\n", + "scale1 = ScaleBar(\n", + "dx=1, label='Scale 1',\n", + " location='upper left', # in relation to the whole plot\n", + " label_loc='left', scale_loc='bottom' # in relation to the line\n", + ")\n", + "\n", + "# Color\n", + "scale2 = ScaleBar(\n", + " dx=1, label='Scale 2', location='center', \n", + " color='#b32400', box_color='yellow',\n", + " box_alpha=0.8 # Slightly transparent box\n", + ")\n", + "\n", + "# Font and text formatting\n", + "scale3 = ScaleBar(\n", + " dx=1, label='Scale 3',\n", + " font_properties={'family':'serif', 'size': 'large'}, # For more information, see the cell below\n", + " scale_formatter=lambda value, unit: f'> {value} {unit} <'\n", + ")\n", + "\n", + "ax.add_artist(scale1)\n", + "ax.add_artist(scale2)\n", + "ax.add_artist(scale3)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "*Note:* Font is specified by six properties: `family`, `style`, `variant`, `stretch`, `weight`, `size` (and `math_fontfamily`). See [more](https://matplotlib.org/stable/api/font_manager_api.html#matplotlib.font_manager.FontProperties).\\\n", + "\\\n", + "For more information about matplotlib-scalebar library, see the [PyPI](https://pypi.org/project/matplotlib-scalebar/) or [GitHub](https://github.com/ppinard/matplotlib-scalebar) page." + ] + } + ], + "metadata": { + "interpreter": { + "hash": "9914e2881520d4f08a067c2c2c181121476026b863eca2e121cd0758701ab602" + }, + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.2" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/examples/nyc.png b/doc/source/gallery/nyc.png similarity index 100% rename from examples/nyc.png rename to doc/source/gallery/nyc.png diff --git a/examples/nyc_hull.png b/doc/source/gallery/nyc_hull.png similarity index 100% rename from examples/nyc_hull.png rename to doc/source/gallery/nyc_hull.png diff --git a/doc/source/gallery/overlays.ipynb b/doc/source/gallery/overlays.ipynb new file mode 100644 index 0000000..4ade5e6 --- /dev/null +++ b/doc/source/gallery/overlays.ipynb @@ -0,0 +1,222 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "source": [ + "# Overlays\n", + "\n", + "Spatial overlays allow you to compare two GeoDataFrames containing polygon or multipolygon geometries \n", + "and create a new GeoDataFrame with the new geometries representing the spatial combination *and*\n", + "merged properties. This allows you to answer questions like\n", + "\n", + "> What are the demographics of the census tracts within 1000 ft of the highway?\n", + "\n", + "The basic idea is demonstrated by the graphic below but keep in mind that overlays operate at the dataframe level, \n", + "not on individual geometries, and the properties from both are retained\n", + "\n", + "![illustration](http://docs.qgis.org/testing/en/_images/overlay_operations.png)" + ], + "metadata": {} + }, + { + "cell_type": "markdown", + "source": [ + "Now we can load up two GeoDataFrames containing (multi)polygon geometries..." + ], + "metadata": {} + }, + { + "cell_type": "code", + "execution_count": null, + "source": [ + "%matplotlib inline\n", + "from shapely.geometry import Point\n", + "from geopandas import datasets, GeoDataFrame, read_file\n", + "from geopandas.tools import overlay\n", + "\n", + "# NYC Boros\n", + "zippath = datasets.get_path('nybb')\n", + "polydf = read_file(zippath)\n", + "\n", + "# Generate some circles\n", + "b = [int(x) for x in polydf.total_bounds]\n", + "N = 10\n", + "polydf2 = GeoDataFrame([\n", + " {'geometry': Point(x, y).buffer(10000), 'value1': x + y, 'value2': x - y}\n", + " for x, y in zip(range(b[0], b[2], int((b[2] - b[0]) / N)),\n", + " range(b[1], b[3], int((b[3] - b[1]) / N)))])" + ], + "outputs": [], + "metadata": {} + }, + { + "cell_type": "markdown", + "source": [ + "The first dataframe contains multipolygons of the NYC boros" + ], + "metadata": {} + }, + { + "cell_type": "code", + "execution_count": null, + "source": [ + "polydf.plot()" + ], + "outputs": [], + "metadata": {} + }, + { + "cell_type": "markdown", + "source": [ + "And the second GeoDataFrame is a sequentially generated set of circles in the same geographic space. We'll plot these with a [different color palette](https://matplotlib.org/examples/color/colormaps_reference.html)." + ], + "metadata": {} + }, + { + "cell_type": "code", + "execution_count": null, + "source": [ + "polydf2.plot(cmap='tab20b')" + ], + "outputs": [], + "metadata": {} + }, + { + "cell_type": "markdown", + "source": [ + "The `geopandas.tools.overlay` function takes three arguments:\n", + "\n", + "* df1\n", + "* df2\n", + "* how\n", + "\n", + "Where `how` can be one of:\n", + "\n", + " ['intersection',\n", + " 'union',\n", + " 'identity',\n", + " 'symmetric_difference',\n", + " 'difference']\n", + "\n", + "So let's identify the areas (and attributes) where both dataframes intersect using the `overlay` method. " + ], + "metadata": {} + }, + { + "cell_type": "code", + "execution_count": null, + "source": [ + "newdf = polydf.overlay(polydf2, how=\"intersection\")\n", + "newdf.plot(cmap='tab20b')" + ], + "outputs": [], + "metadata": {} + }, + { + "cell_type": "markdown", + "source": [ + "And take a look at the attributes; we see that the attributes from both of the original GeoDataFrames are retained. " + ], + "metadata": {} + }, + { + "cell_type": "code", + "execution_count": null, + "source": [ + "polydf.head()" + ], + "outputs": [], + "metadata": {} + }, + { + "cell_type": "code", + "execution_count": null, + "source": [ + "polydf2.head()" + ], + "outputs": [], + "metadata": {} + }, + { + "cell_type": "code", + "execution_count": null, + "source": [ + "newdf.head()" + ], + "outputs": [], + "metadata": {} + }, + { + "cell_type": "markdown", + "source": [ + "Now let's look at the other `how` operations:" + ], + "metadata": {} + }, + { + "cell_type": "code", + "execution_count": null, + "source": [ + "newdf = polydf.overlay(polydf2, how=\"union\")\n", + "newdf.plot(cmap='tab20b')" + ], + "outputs": [], + "metadata": {} + }, + { + "cell_type": "code", + "execution_count": null, + "source": [ + "newdf = polydf.overlay(polydf2, how=\"identity\")\n", + "newdf.plot(cmap='tab20b')" + ], + "outputs": [], + "metadata": {} + }, + { + "cell_type": "code", + "execution_count": null, + "source": [ + "newdf = polydf.overlay(polydf2, how=\"symmetric_difference\")\n", + "newdf.plot(cmap='tab20b')" + ], + "outputs": [], + "metadata": { + "tags": [ + "nbsphinx-thumbnail" + ] + } + }, + { + "cell_type": "code", + "execution_count": null, + "source": [ + "newdf = polydf.overlay(polydf2, how=\"difference\")\n", + "newdf.plot(cmap='tab20b')" + ], + "outputs": [], + "metadata": {} + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.2" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} \ No newline at end of file diff --git a/doc/source/gallery/plot_clip.ipynb b/doc/source/gallery/plot_clip.ipynb new file mode 100644 index 0000000..e8a0047 --- /dev/null +++ b/doc/source/gallery/plot_clip.ipynb @@ -0,0 +1,231 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "source": [ + "# Clip Vector Data with GeoPandas\n", + "\n", + "\n", + "Learn how to clip geometries to the boundary of a polygon geometry\n", + "using GeoPandas." + ], + "metadata": {} + }, + { + "cell_type": "markdown", + "source": [ + "The example below shows you how to clip a set of vector geometries\n", + "to the spatial extent / shape of another vector object. Both sets of geometries\n", + "must be opened with GeoPandas as GeoDataFrames and be in the same Coordinate\n", + "Reference System (CRS) for the `clip` function in GeoPandas to work.\n", + "\n", + "This example uses GeoPandas example data ``'naturalearth_cities'`` and\n", + "``'naturalearth_lowres'``, alongside a custom rectangle geometry made with\n", + "shapely and then turned into a GeoDataFrame.\n", + "\n", + "
\n", + " \n", + "Note\n", + "\n", + "The object to be clipped will be clipped to the full extent of the clip\n", + "object. If there are multiple polygons in clip object, the input data will\n", + "be clipped to the total boundary of all polygons in clip object.\n", + "
\n", + "\n" + ], + "metadata": {} + }, + { + "cell_type": "markdown", + "source": [ + "Import Packages\n", + "---------------\n", + "\n", + "To begin, import the needed packages.\n", + "\n" + ], + "metadata": {} + }, + { + "cell_type": "code", + "execution_count": null, + "source": [ + "import matplotlib.pyplot as plt\n", + "import geopandas\n", + "from shapely.geometry import Polygon" + ], + "outputs": [], + "metadata": {} + }, + { + "cell_type": "markdown", + "source": [ + "Get or Create Example Data\n", + "--------------------------\n", + "\n", + "Below, the example GeoPandas data is imported and opened as a GeoDataFrame.\n", + "Additionally, a polygon is created with shapely and then converted into a\n", + "GeoDataFrame with the same CRS as the GeoPandas world dataset.\n", + "\n" + ], + "metadata": {} + }, + { + "cell_type": "code", + "execution_count": null, + "source": [ + "capitals = geopandas.read_file(geopandas.datasets.get_path(\"naturalearth_cities\"))\n", + "world = geopandas.read_file(geopandas.datasets.get_path(\"naturalearth_lowres\"))\n", + "\n", + "# Create a subset of the world data that is just the South American continent\n", + "south_america = world[world[\"continent\"] == \"South America\"]\n", + "\n", + "# Create a custom polygon\n", + "polygon = Polygon([(0, 0), (0, 90), (180, 90), (180, 0), (0, 0)])\n", + "poly_gdf = geopandas.GeoDataFrame([1], geometry=[polygon], crs=world.crs)" + ], + "outputs": [], + "metadata": {} + }, + { + "cell_type": "markdown", + "source": [ + "Plot the Unclipped Data\n", + "-----------------------\n", + "\n" + ], + "metadata": {} + }, + { + "cell_type": "code", + "execution_count": null, + "source": [ + "fig, (ax1, ax2) = plt.subplots(2, 1, figsize=(12, 8))\n", + "world.plot(ax=ax1)\n", + "poly_gdf.boundary.plot(ax=ax1, color=\"red\")\n", + "south_america.boundary.plot(ax=ax2, color=\"green\")\n", + "capitals.plot(ax=ax2, color=\"purple\")\n", + "ax1.set_title(\"All Unclipped World Data\", fontsize=20)\n", + "ax2.set_title(\"All Unclipped Capital Data\", fontsize=20)\n", + "ax1.set_axis_off()\n", + "ax2.set_axis_off()\n", + "plt.show()" + ], + "outputs": [], + "metadata": {} + }, + { + "cell_type": "markdown", + "source": [ + "Clip the Data\n", + "--------------\n", + "\n", + "The object on which you call `clip` is the object that will\n", + "be clipped. The object you pass is the clip extent. The returned output\n", + "will be a new clipped GeoDataframe. All of the attributes for each returned\n", + "geometry will be retained when you clip.\n", + "\n", + "
\n", + "\n", + "Note\n", + "\n", + "Recall that the data must be in the same CRS in order to use the\n", + "`clip` method. If the data are not in the same CRS, be sure to use\n", + "the GeoPandas `GeoDataFrame.to_crs` method to ensure both datasets\n", + "are in the same CRS.\n", + "
\n", + "\n" + ], + "metadata": {} + }, + { + "cell_type": "markdown", + "source": [ + "Clip the World Data\n", + "--------------------\n", + "\n" + ], + "metadata": {} + }, + { + "cell_type": "code", + "execution_count": null, + "source": [ + "world_clipped = world.clip(polygon)\n", + "\n", + "# Plot the clipped data\n", + "# The plot below shows the results of the clip function applied to the world\n", + "# sphinx_gallery_thumbnail_number = 2\n", + "fig, ax = plt.subplots(figsize=(12, 8))\n", + "world_clipped.plot(ax=ax, color=\"purple\")\n", + "world.boundary.plot(ax=ax)\n", + "poly_gdf.boundary.plot(ax=ax, color=\"red\")\n", + "ax.set_title(\"World Clipped\", fontsize=20)\n", + "ax.set_axis_off()\n", + "plt.show()" + ], + "outputs": [], + "metadata": { + "tags": [ + "nbsphinx-thumbnail" + ] + } + }, + { + "cell_type": "markdown", + "source": [ + "
\n", + " \n", + "Note\n", + "\n", + "For historical reasons, the clip method is also available as a top-level function `geopandas.clip`.\n", + "It is recommended to use the method as the function may be deprecated in the future.\n", + "
\n", + "\n", + "Clip the Capitals Data\n", + "----------------------\n", + "\n" + ], + "metadata": {} + }, + { + "cell_type": "code", + "execution_count": null, + "source": [ + "capitals_clipped = capitals.clip(south_america)\n", + "\n", + "# Plot the clipped data\n", + "# The plot below shows the results of the clip function applied to the capital cities\n", + "fig, ax = plt.subplots(figsize=(12, 8))\n", + "capitals_clipped.plot(ax=ax, color=\"purple\")\n", + "south_america.boundary.plot(ax=ax, color=\"green\")\n", + "ax.set_title(\"Capitals Clipped\", fontsize=20)\n", + "ax.set_axis_off()\n", + "plt.show()" + ], + "outputs": [], + "metadata": {} + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.1" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} \ No newline at end of file diff --git a/doc/source/gallery/plotting_basemap_background.ipynb b/doc/source/gallery/plotting_basemap_background.ipynb new file mode 100644 index 0000000..70ad577 --- /dev/null +++ b/doc/source/gallery/plotting_basemap_background.ipynb @@ -0,0 +1,267 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "# Adding a background map to plots\n", + "\n", + "This example shows how you can add a background basemap to plots created\n", + "with the geopandas ``.plot()`` method. This makes use of the\n", + "[contextily](https://github.com/geopandas/contextily) package to retrieve\n", + "web map tiles from several sources (OpenStreetMap, Stamen). Also have a\n", + "look at contextily's \n", + "[introduction guide](https://contextily.readthedocs.io/en/latest/intro_guide.html#Using-transparent-layers)\n", + "for possible new features not covered here.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import geopandas\n", + "import contextily as cx" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's use the NYC borough boundary data that is available in geopandas\n", + "datasets. Plotting this gives the following result:\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "df = geopandas.read_file(geopandas.datasets.get_path('nybb'))\n", + "ax = df.plot(figsize=(10, 10), alpha=0.5, edgecolor='k')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Matching coordinate systems \n", + "\n", + "\n", + "Before adding web map tiles to this plot, we first need to ensure the\n", + "coordinate reference systems (CRS) of the tiles and the data match.\n", + "Web map tiles are typically provided in\n", + "[Web Mercator](https://en.wikipedia.org/wiki/Web_Mercator>)\n", + "([EPSG 3857](https://epsg.io/3857)), so let us first check what\n", + "CRS our NYC boroughs are in:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "df.crs" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now we know the CRS do not match, so we need to choose in which\n", + "CRS we wish to visualize the data: either the CRS of the tiles,\n", + "the one of the data, or even a different one.\n", + "\n", + "The first option to match CRS is to leverage the `to_crs` method\n", + "of GeoDataFrames to convert the CRS of our data, here to Web Mercator:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "df_wm = df.to_crs(epsg=3857)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can then use `add_basemap` function of contextily to easily add a\n", + "background map to our plot:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "tags": [ + "nbsphinx-thumbnail" + ] + }, + "outputs": [], + "source": [ + "ax = df_wm.plot(figsize=(10, 10), alpha=0.5, edgecolor='k')\n", + "cx.add_basemap(ax)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "If we want to convert the CRS of the tiles instead, which might be advisable\n", + "for large datasets, we can use the `crs` keyword argument of `add_basemap`\n", + "as follows:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "ax = df.plot(figsize=(10, 10), alpha=0.5, edgecolor='k')\n", + "cx.add_basemap(ax, crs=df.crs)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This reprojects map tiles to a target CRS which may in some cases cause a\n", + "loss of sharpness. See \n", + "[contextily's guide on warping tiles](https://contextily.readthedocs.io/en/latest/warping_guide.html)\n", + "for more information on the subject." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Controlling the level of detail" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can control the detail of the map tiles using the optional `zoom` keyword\n", + "(be careful to not specify a too high `zoom` level,\n", + "as this can result in a large download).:\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "ax = df_wm.plot(figsize=(10, 10), alpha=0.5, edgecolor='k')\n", + "cx.add_basemap(ax, zoom=12)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Choosing a different style" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "By default, contextily uses the Stamen Terrain style. We can specify a\n", + "different style using ``cx.providers``:\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "ax = df_wm.plot(figsize=(10, 10), alpha=0.5, edgecolor='k')\n", + "cx.add_basemap(ax, source=cx.providers.Stamen.TonerLite)\n", + "ax.set_axis_off()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Adding labels as an overlay" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Sometimes, when you plot data on a basemap, the data will obscure some important map elements, such as labels,\n", + "that you would otherwise want to see unobscured. Some map tile providers offer multiple sets of partially\n", + "transparent tiles to solve this, and `contextily` will do its best to auto-detect these transparent layers\n", + "and put them on top." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "ax = df_wm.plot(figsize=(10, 10), alpha=0.5, edgecolor='k')\n", + "cx.add_basemap(ax, source=cx.providers.Stamen.TonerLite)\n", + "cx.add_basemap(ax, source=cx.providers.Stamen.TonerLabels)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "By splitting the layers like this, you can also independently manipulate the level of zoom on each layer,\n", + "for example to make labels larger while still showing a lot of detail." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "ax = df_wm.plot(figsize=(10, 10), alpha=0.5, edgecolor='k')\n", + "cx.add_basemap(ax, source=cx.providers.Stamen.Watercolor, zoom=12)\n", + "cx.add_basemap(ax, source=cx.providers.Stamen.TonerLabels, zoom=10)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.1" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/doc/source/gallery/plotting_with_folium.ipynb b/doc/source/gallery/plotting_with_folium.ipynb new file mode 100644 index 0000000..e01574f --- /dev/null +++ b/doc/source/gallery/plotting_with_folium.ipynb @@ -0,0 +1,253 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Plotting with Folium\n", + "\n", + "__What is Folium?__\n", + "\n", + "[Folium](https://python-visualization.github.io/folium/) builds on the data wrangling strengths of the Python ecosystem and the mapping strengths of the leaflet.js library. This allows you to manipulate your data in Geopandas and visualize it on a Leaflet map via Folium.\n", + "\n", + "In this example, we will first use Geopandas to load the geometries (volcano point data), and then create the Folium map with markers representing the different types of volcanoes." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Load geometries\n", + "This example uses a freely available [volcano dataset](https://www.kaggle.com/texasdave/volcano-eruptions). We will be reading the csv file using pandas, and then convert the pandas `DataFrame` to a Geopandas `GeoDataFrame`." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Import Libraries\n", + "import pandas as pd\n", + "import geopandas\n", + "import folium\n", + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "df1 = pd.read_csv('volcano_data_2010.csv')\n", + "\n", + "# Keep only relevant columns\n", + "df = df1.loc[:, (\"Year\", \"Name\", \"Country\", \"Latitude\", \"Longitude\", \"Type\")]\n", + "df.info()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Create point geometries\n", + "geometry = geopandas.points_from_xy(df.Longitude, df.Latitude)\n", + "geo_df = geopandas.GeoDataFrame(df[['Year','Name','Country', 'Latitude', 'Longitude', 'Type']], geometry=geometry)\n", + "\n", + "geo_df.head()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "world = geopandas.read_file(geopandas.datasets.get_path('naturalearth_lowres'))\n", + "df.Type.unique()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "tags": [ + "nbsphinx-thumbnail" + ] + }, + "outputs": [], + "source": [ + "fig, ax = plt.subplots(figsize=(24,18))\n", + "world.plot(ax=ax, alpha=0.4, color='grey')\n", + "geo_df.plot(column='Type', ax=ax, legend=True)\n", + "plt.title('Volcanoes')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Create Folium map\n", + "Folium has a number of built-in tilesets from OpenStreetMap, Mapbox, and Stamen. For example:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Stamen Terrain\n", + "map = folium.Map(location = [13.406,80.110], tiles = \"Stamen Terrain\", zoom_start = 9)\n", + "map" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# OpenStreetMap\n", + "map = folium.Map(location = [13.406,80.110], tiles='OpenStreetMap' , zoom_start = 9)\n", + "map" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Stamen Toner\n", + "map = folium.Map(location = [13.406,80.110], tiles='Stamen Toner', zoom_start = 9)\n", + "map" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This example uses the Stamen Terrain map layer to visualize the volcano terrain." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Use terrain map layer to see volcano terrain\n", + "map = folium.Map(location = [4,10], tiles = \"Stamen Terrain\", zoom_start = 3)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Add markers\n", + "To represent the different types of volcanoes, you can create Folium markers and add them to your map." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Create a geometry list from the GeoDataFrame\n", + "geo_df_list = [[point.xy[1][0], point.xy[0][0]] for point in geo_df.geometry ]\n", + "\n", + "# Iterate through list and add a marker for each volcano, color-coded by its type.\n", + "i = 0\n", + "for coordinates in geo_df_list:\n", + " #assign a color marker for the type of volcano, Strato being the most common\n", + " if geo_df.Type[i] == \"Stratovolcano\":\n", + " type_color = \"green\"\n", + " elif geo_df.Type[i] == \"Complex volcano\":\n", + " type_color = \"blue\"\n", + " elif geo_df.Type[i] == \"Shield volcano\":\n", + " type_color = \"orange\"\n", + " elif geo_df.Type[i] == \"Lava dome\":\n", + " type_color = \"pink\"\n", + " else:\n", + " type_color = \"purple\"\n", + "\n", + "\n", + " # Place the markers with the popup labels and data\n", + " map.add_child(folium.Marker(location = coordinates,\n", + " popup =\n", + " \"Year: \" + str(geo_df.Year[i]) + '
' +\n", + " \"Name: \" + str(geo_df.Name[i]) + '
' +\n", + " \"Country: \" + str(geo_df.Country[i]) + '
'\n", + " \"Type: \" + str(geo_df.Type[i]) + '
'\n", + " \"Coordinates: \" + str(geo_df_list[i]),\n", + " icon = folium.Icon(color = \"%s\" % type_color)))\n", + " i = i + 1" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "map" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Folium Heatmaps\n", + "\n", + "Folium is well known for its heatmaps, which create a heatmap layer. To plot a heatmap in Folium, you need a list of latitudes and longitudes." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# This example uses heatmaps to visualize the density of volcanoes\n", + "# which is more in some parts of the world compared to others.\n", + "\n", + "from folium import plugins\n", + "\n", + "map = folium.Map(location = [15,30], tiles='Cartodb dark_matter', zoom_start = 2)\n", + "\n", + "heat_data = [[point.xy[1][0], point.xy[0][0]] for point in geo_df.geometry ]\n", + "\n", + "heat_data\n", + "plugins.HeatMap(heat_data).add_to(map)\n", + "\n", + "map" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.1" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/doc/source/gallery/plotting_with_geoplot.ipynb b/doc/source/gallery/plotting_with_geoplot.ipynb new file mode 100644 index 0000000..7e0f09f --- /dev/null +++ b/doc/source/gallery/plotting_with_geoplot.ipynb @@ -0,0 +1,197 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "# Plotting with Geoplot and GeoPandas\n", + "\n", + "[Geoplot](https://residentmario.github.io/geoplot/index.html) is a Python\n", + "library providing a selection of easy-to-use geospatial visualizations. It is\n", + "built on top of the lower-level [CartoPy](http://scitools.org.uk/cartopy/),\n", + "covered in a separate section of this tutorial, and is designed to work with\n", + "GeoPandas input.\n", + "\n", + "This example is a brief tour of the `geoplot` API. For more details on the\n", + "library refer to [its documentation](https://residentmario.github.io/geoplot/index.html).\n", + "\n", + "First we'll load in the data using GeoPandas.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import geopandas\n", + "import geoplot\n", + "\n", + "world = geopandas.read_file(\n", + " geopandas.datasets.get_path('naturalearth_lowres')\n", + ")\n", + "boroughs = geopandas.read_file(\n", + " geoplot.datasets.get_path('nyc_boroughs')\n", + ")\n", + "collisions = geopandas.read_file(\n", + " geoplot.datasets.get_path('nyc_injurious_collisions')\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Plotting with Geoplot\n", + "=====================\n", + "\n", + "We start out by replicating the basic GeoPandas world plot using Geoplot.\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "geoplot.polyplot(world, figsize=(8, 4))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Geoplot can re-project data into any of the map projections provided by\n", + "CartoPy (see the list\n", + "[here](http://scitools.org.uk/cartopy/docs/latest/crs/projections.html)).\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# use the Orthographic map projection (e.g. a world globe)\n", + "ax = geoplot.polyplot(\n", + " world, projection=geoplot.crs.Orthographic(), figsize=(8, 4)\n", + ")\n", + "ax.outline_patch.set_visible(True)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "``polyplot`` is trivial and can only plot the geometries you pass to it. If\n", + "you want to use color as a visual variable, specify a ``choropleth``. Here\n", + "we sort GDP per person by country into five buckets by color, using\n", + "\"quantiles\" binning from the [Mapclassify](https://pysal.org/mapclassify/)\n", + "library.\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import mapclassify\n", + "gpd_per_person = world['gdp_md_est'] / world['pop_est']\n", + "scheme = mapclassify.Quantiles(gpd_per_person, k=5)\n", + "\n", + "# Note: this code sample requires geoplot>=0.4.0.\n", + "geoplot.choropleth(\n", + " world, hue=gpd_per_person, scheme=scheme,\n", + " cmap='Greens', figsize=(8, 4)\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "If you want to use size as a visual variable, use a ``cartogram``. Here are\n", + "population estimates for countries in Africa.\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "africa = world.query('continent == \"Africa\"')\n", + "ax = geoplot.cartogram(\n", + " africa, scale='pop_est', limits=(0.2, 1),\n", + " edgecolor='None', figsize=(7, 8)\n", + ")\n", + "geoplot.polyplot(africa, edgecolor='gray', ax=ax)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "If we have data in the shape of points in space, we may generate a\n", + "three-dimensional heatmap on it using ``kdeplot``.\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "tags": [ + "nbsphinx-thumbnail" + ] + }, + "outputs": [], + "source": [ + "ax = geoplot.kdeplot(\n", + " collisions.head(1000), clip=boroughs.geometry,\n", + " shade=True, cmap='Reds',\n", + " projection=geoplot.crs.AlbersEqualArea())\n", + "geoplot.polyplot(boroughs, ax=ax, zorder=1)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "These are just some of the plots you can make with Geoplot. There are\n", + "many other possibilities not covered in this brief introduction. For more\n", + "examples, refer to the\n", + "[Gallery](https://residentmario.github.io/geoplot/gallery/index.html) in\n", + "the Geoplot documentation.\n", + "\n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.7.6" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} \ No newline at end of file diff --git a/doc/source/gallery/polygon_plotting_with_folium.ipynb b/doc/source/gallery/polygon_plotting_with_folium.ipynb new file mode 100644 index 0000000..8dec0b0 --- /dev/null +++ b/doc/source/gallery/polygon_plotting_with_folium.ipynb @@ -0,0 +1,234 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Plotting polygons with Folium\n", + "This example demonstrates how to plot polygons on a Folium map." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import geopandas as gpd\n", + "import folium\n", + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Load geometries\n", + "This example uses the nybb dataset, which contains polygons of New York boroughs." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "path = gpd.datasets.get_path('nybb')\n", + "df = gpd.read_file(path)\n", + "df.head()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Plot from the original dataset" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "tags": [ + "nbsphinx-thumbnail" + ] + }, + "outputs": [], + "source": [ + "df.plot(figsize=(6, 6))\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Notice that the values of the polygon geometries do not directly represent the values of latitude of longitude in a geographic coordinate system.\n", + "To view the coordinate reference system of the geometry column, access the `crs` attribute:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "df.crs" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The [epsg:2263](https://epsg.io/2263) crs is a projected coordinate reference system with linear units (ft in this case).\n", + "As folium (i.e. leaflet.js) by default accepts values of latitude and longitude (angular units) as input, we need to project the geometry to a geographic coordinate system first." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Use WGS 84 (epsg:4326) as the geographic coordinate system\n", + "df = df.to_crs(epsg=4326)\n", + "print(df.crs)\n", + "df.head()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "df.plot(figsize=(6, 6))\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Create Folium map" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "m = folium.Map(location=[40.70, -73.94], zoom_start=10, tiles='CartoDB positron')\n", + "m" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Add polygons to map\n", + "Overlay the boundaries of boroughs on map with borough name as popup:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "for _, r in df.iterrows():\n", + " # Without simplifying the representation of each borough,\n", + " # the map might not be displayed \n", + " sim_geo = gpd.GeoSeries(r['geometry']).simplify(tolerance=0.001)\n", + " geo_j = sim_geo.to_json()\n", + " geo_j = folium.GeoJson(data=geo_j,\n", + " style_function=lambda x: {'fillColor': 'orange'})\n", + " folium.Popup(r['BoroName']).add_to(geo_j)\n", + " geo_j.add_to(m)\n", + "m" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Add centroid markers\n", + "In order to properly compute geometric properties, in this case centroids, of the geometries, we need to project the data to a projected coordinate system." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Project to NAD83 projected crs\n", + "df = df.to_crs(epsg=2263)\n", + "\n", + "# Access the centroid attribute of each polygon\n", + "df['centroid'] = df.centroid" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Since we're again adding a new geometry to the Folium map, we need to project the geometry back to a geographic coordinate system with latitude and longitude values." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Project to WGS84 geographic crs\n", + "\n", + "# geometry (active) column\n", + "df = df.to_crs(epsg=4326)\n", + "\n", + "# Centroid column\n", + "df['centroid'] = df['centroid'].to_crs(epsg=4326)\n", + "\n", + "df.head()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "for _, r in df.iterrows():\n", + " lat = r['centroid'].y\n", + " lon = r['centroid'].x\n", + " folium.Marker(location=[lat, lon],\n", + " popup='length: {}
area: {}'.format(r['Shape_Leng'], r['Shape_Area'])).add_to(m)\n", + "\n", + "m" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.1" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/doc/source/gallery/s2a_l2a_fishbourne.tif b/doc/source/gallery/s2a_l2a_fishbourne.tif new file mode 100644 index 0000000..0ed5142 Binary files /dev/null and b/doc/source/gallery/s2a_l2a_fishbourne.tif differ diff --git a/doc/source/gallery/spatial_joins.ipynb b/doc/source/gallery/spatial_joins.ipynb new file mode 100644 index 0000000..81f79a0 --- /dev/null +++ b/doc/source/gallery/spatial_joins.ipynb @@ -0,0 +1,257 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Spatial Joins\n", + "\n", + "A *spatial join* uses [binary predicates](http://shapely.readthedocs.io/en/latest/manual.html#binary-predicates) \n", + "such as `intersects` and `crosses` to combine two `GeoDataFrames` based on the spatial relationship \n", + "between their geometries.\n", + "\n", + "A common use case might be a spatial join between a point layer and a polygon layer where you want to retain the point geometries and grab the attributes of the intersecting polygons.\n", + "\n", + "![illustration](https://web.natur.cuni.cz/~langhamr/lectures/vtfg1/mapinfo_1/about_gis/Image23.gif)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "## Types of spatial joins\n", + "\n", + "We currently support the following methods of spatial joins. We refer to the *left_df* and *right_df* which are the correspond to the two dataframes passed in as args.\n", + "\n", + "### Left outer join\n", + "\n", + "In a LEFT OUTER JOIN (`how='left'`), we keep *all* rows from the left and duplicate them if necessary to represent multiple hits between the two dataframes. We retain attributes of the right if they intersect and lose right rows that don't intersect. A left outer join implies that we are interested in retaining the geometries of the left. \n", + "\n", + "This is equivalent to the PostGIS query:\n", + "```\n", + "SELECT pts.geom, pts.id as ptid, polys.id as polyid \n", + "FROM pts\n", + "LEFT OUTER JOIN polys\n", + "ON ST_Intersects(pts.geom, polys.geom);\n", + "\n", + " geom | ptid | polyid \n", + "--------------------------------------------+------+--------\n", + " 010100000040A9FBF2D88AD03F349CD47D796CE9BF | 4 | 10\n", + " 010100000048EABE3CB622D8BFA8FBF2D88AA0E9BF | 3 | 10\n", + " 010100000048EABE3CB622D8BFA8FBF2D88AA0E9BF | 3 | 20\n", + " 0101000000F0D88AA0E1A4EEBF7052F7E5B115E9BF | 2 | 20\n", + " 0101000000818693BA2F8FF7BF4ADD97C75604E9BF | 1 | \n", + "(5 rows)\n", + "```\n", + "\n", + "### Right outer join\n", + "\n", + "In a RIGHT OUTER JOIN (`how='right'`), we keep *all* rows from the right and duplicate them if necessary to represent multiple hits between the two dataframes. We retain attributes of the left if they intersect and lose left rows that don't intersect. A right outer join implies that we are interested in retaining the geometries of the right. \n", + "\n", + "This is equivalent to the PostGIS query:\n", + "```\n", + "SELECT polys.geom, pts.id as ptid, polys.id as polyid \n", + "FROM pts\n", + "RIGHT OUTER JOIN polys\n", + "ON ST_Intersects(pts.geom, polys.geom);\n", + "\n", + " geom | ptid | polyid \n", + "----------+------+--------\n", + " 01...9BF | 4 | 10\n", + " 01...9BF | 3 | 10\n", + " 02...7BF | 3 | 20\n", + " 02...7BF | 2 | 20\n", + " 00...5BF | | 30\n", + "(5 rows)\n", + "```\n", + "\n", + "### Inner join\n", + "\n", + "In an INNER JOIN (`how='inner'`), we keep rows from the right and left only where their binary predicate is `True`. We duplicate them if necessary to represent multiple hits between the two dataframes. We retain attributes of the right and left only if they intersect and lose all rows that do not. An inner join implies that we are interested in retaining the geometries of the left. \n", + "\n", + "This is equivalent to the PostGIS query:\n", + "```\n", + "SELECT pts.geom, pts.id as ptid, polys.id as polyid \n", + "FROM pts\n", + "INNER JOIN polys\n", + "ON ST_Intersects(pts.geom, polys.geom);\n", + "\n", + " geom | ptid | polyid \n", + "--------------------------------------------+------+--------\n", + " 010100000040A9FBF2D88AD03F349CD47D796CE9BF | 4 | 10\n", + " 010100000048EABE3CB622D8BFA8FBF2D88AA0E9BF | 3 | 10\n", + " 010100000048EABE3CB622D8BFA8FBF2D88AA0E9BF | 3 | 20\n", + " 0101000000F0D88AA0E1A4EEBF7052F7E5B115E9BF | 2 | 20\n", + "(4 rows) \n", + "```" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Spatial Joins between two GeoDataFrames\n", + "\n", + "Let's take a look at how we'd implement these using `GeoPandas`. First, load up the NYC test data into `GeoDataFrames`:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "%matplotlib inline\n", + "from shapely.geometry import Point\n", + "from geopandas import datasets, GeoDataFrame, read_file\n", + "\n", + "# NYC Boros\n", + "zippath = datasets.get_path('nybb')\n", + "polydf = read_file(zippath)\n", + "\n", + "# Generate some points\n", + "b = [int(x) for x in polydf.total_bounds]\n", + "N = 8\n", + "pointdf = GeoDataFrame([\n", + " {'geometry': Point(x, y), 'value1': x + y, 'value2': x - y}\n", + " for x, y in zip(range(b[0], b[2], int((b[2] - b[0]) / N)),\n", + " range(b[1], b[3], int((b[3] - b[1]) / N)))])\n", + "\n", + "# Make sure they're using the same projection reference\n", + "pointdf.crs = polydf.crs" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "pointdf" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "polydf" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "pointdf.plot()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "polydf.plot()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Joins" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "join_left_df = pointdf.sjoin(polydf, how=\"left\")\n", + "join_left_df\n", + "# Note the NaNs where the point did not intersect a boro" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "join_right_df = pointdf.sjoin(polydf, how=\"right\")\n", + "join_right_df\n", + "# Note Staten Island is repeated" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "join_inner_df = pointdf.sjoin(polydf, how=\"inner\")\n", + "join_inner_df\n", + "# Note the lack of NaNs; dropped anything that didn't intersect" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We're not limited to using the `intersection` binary predicate. Any of the `Shapely` geometry methods that return a Boolean can be used by specifying the `op` kwarg." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "pointdf.sjoin(polydf, how=\"left\", predicate=\"within\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can also conduct a nearest neighbour join with `sjoin_nearest`." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "pointdf.sjoin_nearest(polydf, how=\"left\", distance_col=\"Distances\")\n", + "# Note the optional Distances column with computed distances between each point\n", + "# and the nearest polydf geometry." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.7.6" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/examples/test.png b/doc/source/gallery/test.png similarity index 100% rename from examples/test.png rename to doc/source/gallery/test.png diff --git a/examples/test_buffer.png b/doc/source/gallery/test_buffer.png similarity index 100% rename from examples/test_buffer.png rename to doc/source/gallery/test_buffer.png diff --git a/examples/volcano_data_2010.csv b/doc/source/gallery/volcano_data_2010.csv similarity index 100% rename from examples/volcano_data_2010.csv rename to doc/source/gallery/volcano_data_2010.csv diff --git a/doc/source/getting_started.md b/doc/source/getting_started.md new file mode 100644 index 0000000..87af771 --- /dev/null +++ b/doc/source/getting_started.md @@ -0,0 +1,64 @@ +# Getting Started + +```{toctree} +--- +maxdepth: 2 +caption: Getting Started +hidden: +--- + +Installation +Introduction to GeoPandas +Examples Gallery +``` + +## Installation + +GeoPandas is written in pure Python, but has several dependencies written in C +([GEOS](https://geos.osgeo.org), [GDAL](https://www.gdal.org/), [PROJ](https://proj.org/)). Those base C libraries can sometimes be a challenge to +install. Therefore, we advise you to closely follow the recommendations below to avoid +installation problems. + +### Easy way + +The best way to install GeoPandas is using ``conda`` and ``conda-forge`` channel: + +``` +conda install -c conda-forge geopandas +``` + +### Detailed instructions + +Do you prefer ``pip install`` or installation from source? Or specific version? See +{doc}`detailed instructions `. + +### What now? + +- If you don't have GeoPandas yet, check {doc}`Installation `. +- If you have never used GeoPandas and want to get familiar with it and its core + functionality quickly, see {doc}`Getting Started Tutorial `. +- Detailed illustration how to work with different parts of GeoPandas, how to make maps, + manage projections, spatially merge data or geocode are part of our + {doc}`User Guide `. +- And if you are interested in the complete + documentation of all classes, functions, method and attributes GeoPandas offers, + {doc}`API Reference ` is here for you. + + +```{container} button + +{doc}`Installation ` {doc}`Introduction ` +{doc}`User Guide ` {doc}`API Reference ` +``` + +## Get in touch + +Haven't found what you were looking for? + +- Ask usage questions ("How do I?") on [StackOverflow](https://stackoverflow.com/questions/tagged/geopandas) or [GIS StackExchange](https://gis.stackexchange.com/questions/tagged/geopandas). +- Report bugs, suggest features or view the source code on [GitHub](https://github.com/geopandas/geopandas). +- For a quick question about a bug report or feature request, or Pull Request, + head over to the [gitter channel](https://gitter.im/geopandas/geopandas). +- For less well defined questions or ideas, or to announce other projects of + interest to GeoPandas users, ... use the [mailing list](https://groups.google.com/forum/#!forum/geopandas). + diff --git a/doc/source/install.rst b/doc/source/getting_started/install.rst similarity index 92% rename from doc/source/install.rst rename to doc/source/getting_started/install.rst index 33f9df4..a9b889d 100644 --- a/doc/source/install.rst +++ b/doc/source/getting_started/install.rst @@ -94,14 +94,13 @@ as well:: - `fiona`_ provides binary wheels with the dependencies included for Mac and Linux, but not for Windows. - - `pyproj`_ and `shapely`_ provide binary wheels with dependencies included + - `pyproj`_, `rtree`_, and `shapely`_ provide binary wheels with dependencies included for Mac, Linux, and Windows. - - `rtree`_ does not provide wheels. - Windows wheels for `shapely`, `fiona`, `pyproj` and `rtree` can be found at `Christopher Gohlke's website `_. - So depending on your platform, you might need to compile and install their + Depending on your platform, you might need to compile and install their C dependencies manually. We refer to the individual packages for more details on installing those. Using conda (see above) avoids the need to compile the dependencies yourself. @@ -139,10 +138,11 @@ Dependencies Required dependencies: - `numpy`_ -- `pandas`_ (version 0.23.4 or later) +- `pandas`_ (version 0.25 or later) - `shapely`_ (interface to `GEOS`_) - `fiona`_ (interface to `GDAL`_) - `pyproj`_ (interface to `PROJ`_; version 2.2.0 or later) +- `packaging`_ Further, optional dependencies are: @@ -155,9 +155,8 @@ Further, optional dependencies are: For plotting, these additional packages may be used: -- `matplotlib`_ (>= 2.0.1) -- `descartes`_ -- `mapclassify`_ +- `matplotlib`_ (>= 3.1.0) +- `mapclassify`_ (>= 2.4.0) Using the optional PyGEOS dependency @@ -177,9 +176,9 @@ experimental speedups by installing PyGEOS. This can be done with conda More specifically, whether the speedups are used or not is determined by: -- If PyGEOS is installed, it will be used by default (but installing GeoPandas - will not yet automatically install PyGEOS as dependency, you need to do this - manually). +- If PyGEOS >= 0.8 is installed, it will be used by default (but installing + GeoPandas will not yet automatically install PyGEOS as dependency, you need + to do this manually). - You can still toggle the use of PyGEOS when it is available, by: @@ -194,7 +193,8 @@ More specifically, whether the speedups are used or not is determined by: The use of PyGEOS is experimental! Although it is passing all tests, there might still be issues and not all functions of GeoPandas will - already benefit from speedups. But trying this out is very welcome! + already benefit from speedups (one known issue: the `to_crs` coordinate + transformations lose the z coordinate). But trying this out is very welcome! Any issues you encounter (but also reports of successful usage are interesting!) can be reported at https://gitter.im/geopandas/geopandas or https://github.com/geopandas/geopandas/issues @@ -212,8 +212,6 @@ More specifically, whether the speedups are used or not is determined by: .. _fiona: https://fiona.readthedocs.io -.. _Descartes: https://pypi.python.org/pypi/descartes - .. _matplotlib: http://matplotlib.org .. _geopy: https://github.com/geopy/geopy @@ -230,8 +228,6 @@ More specifically, whether the speedups are used or not is determined by: .. _libspatialindex: https://github.com/libspatialindex/libspatialindex -.. _Travis CI: https://travis-ci.org/geopandas/geopandas - .. _conda: https://conda.io/en/latest/ .. _Anaconda distribution: https://www.anaconda.com/distribution/ @@ -247,3 +243,5 @@ More specifically, whether the speedups are used or not is determined by: .. _PROJ: https://proj.org/ .. _PyGEOS: https://github.com/pygeos/pygeos/ + +.. _packaging: https://packaging.pypa.io/en/latest/ \ No newline at end of file diff --git a/doc/source/getting_started/introduction.ipynb b/doc/source/getting_started/introduction.ipynb new file mode 100644 index 0000000..d548e15 --- /dev/null +++ b/doc/source/getting_started/introduction.ipynb @@ -0,0 +1,545 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "tags": [] + }, + "source": [ + "# Introduction to GeoPandas\n", + "\n", + "This quick tutorial introduces the key concepts and basic features of GeoPandas to help you get started with your projects.\n", + "\n", + "## Concepts\n", + "\n", + "GeoPandas, as the name suggests, extends the popular data science library [pandas](https://pandas.pydata.org) by adding support for geospatial data. If you are not familiar with `pandas`, we recommend taking a quick look at its [Getting started documentation](https://pandas.pydata.org/docs/getting_started/index.html#getting-started) before proceeding.\n", + "\n", + "The core data structure in GeoPandas is the `geopandas.GeoDataFrame`, a subclass of `pandas.DataFrame`, that can store geometry columns and perform spatial operations. The `geopandas.GeoSeries`, a subclass of `pandas.Series`, handles the geometries. Therefore, your `GeoDataFrame` is a combination of `pandas.Series`, with traditional data (numerical, boolean, text etc.), and `geopandas.GeoSeries`, with geometries (points, polygons etc.). You can have as many columns with geometries as you wish; there's no limit typical for desktop GIS software.\n", + "\n", + "![geodataframe schema](../_static/dataframe.svg)\n", + "\n", + "Each `GeoSeries` can contain any geometry type (you can even mix them within a single array) and has a `GeoSeries.crs` attribute, which stores information about the projection (CRS stands for Coordinate Reference System). Therefore, each `GeoSeries` in a `GeoDataFrame` can be in a different projection, allowing you to have, for example, multiple versions (different projections) of the same geometry.\n", + "\n", + "Only one `GeoSeries` in a `GeoDataFrame` is considered the _active_ geometry, which means that all geometric operations applied to a `GeoDataFrame` operate on this _active_ column.\n", + "\n", + "\n", + "
\n", + "User Guide\n", + " \n", + "See more on [data structures in the User Guide](../docs/user_guide/data_structures.rst).\n", + "
\n", + "\n", + "\n", + "Let's see how some of these concepts work in practice.\n", + "\n", + "## Reading and writing files\n", + "\n", + "First, we need to read some data.\n", + "\n", + "### Reading files\n", + "\n", + "Assuming you have a file containing both data and geometry (e.g. GeoPackage, GeoJSON, Shapefile), you can read it using `geopandas.read_file()`, which automatically detects the filetype and creates a `GeoDataFrame`. This tutorial uses the `\"nybb\"` dataset, a map of New York boroughs, which is part of the GeoPandas installation. Therefore, we use `geopandas.datasets.get_path()` to retrieve the path to the dataset." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import geopandas\n", + "\n", + "path_to_data = geopandas.datasets.get_path(\"nybb\")\n", + "gdf = geopandas.read_file(path_to_data)\n", + "\n", + "gdf" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "tags": [] + }, + "source": [ + "### Writing files\n", + "\n", + "To write a `GeoDataFrame` back to file use `GeoDataFrame.to_file()`. The default file format is Shapefile, but you can specify your own with the `driver` keyword." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "gdf.to_file(\"my_file.geojson\", driver=\"GeoJSON\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "tags": [] + }, + "source": [ + "
\n", + "User Guide\n", + " \n", + "See more on [reading and writing data in the User Guide](../docs/user_guide/io.rst).\n", + "
\n", + "\n", + "\n", + "\n", + "## Simple accessors and methods\n", + "\n", + "Now we have our `GeoDataFrame` and can start working with its geometry. \n", + "\n", + "Since there was only one geometry column in the New York Boroughs dataset, this column automatically becomes the _active_ geometry and spatial methods used on the `GeoDataFrame` will be applied to the `\"geometry\"` column.\n", + "\n", + "### Measuring area\n", + "\n", + "To measure the area of each polygon (or MultiPolygon in this specific case), access the `GeoDataFrame.area` attribute, which returns a `pandas.Series`. Note that `GeoDataFrame.area` is just `GeoSeries.area` applied to the _active_ geometry column.\n", + "\n", + "But first, to make the results easier to read, set the names of the boroughs as the index:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "gdf = gdf.set_index(\"BoroName\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "gdf[\"area\"] = gdf.area\n", + "gdf[\"area\"]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Getting polygon boundary and centroid\n", + "\n", + "To get the boundary of each polygon (LineString), access the `GeoDataFrame.boundary`:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "gdf['boundary'] = gdf.boundary\n", + "gdf['boundary']" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Since we have saved boundary as a new column, we now have two geometry columns in the same `GeoDataFrame`.\n", + "\n", + "We can also create new geometries, which could be, for example, a buffered version of the original one (i.e., `GeoDataFrame.buffer(10)`) or its centroid:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "gdf['centroid'] = gdf.centroid\n", + "gdf['centroid']" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Measuring distance\n", + "\n", + "We can also measure how far each centroid is from the first centroid location." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "first_point = gdf['centroid'].iloc[0]\n", + "gdf['distance'] = gdf['centroid'].distance(first_point)\n", + "gdf['distance']" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Note that `geopandas.GeoDataFrame` is a subclass of `pandas.DataFrame`, so we have all the pandas functionality available to use on the geospatial dataset — we can even perform data manipulations with the attributes and geometry information together.\n", + "\n", + "For example, to calculate the average of the distances measured above, access the 'distance' column and call the mean() method on it:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "gdf['distance'].mean()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Making maps\n", + "\n", + "GeoPandas can also plot maps, so we can check how the geometries appear in space. To plot the active geometry, call `GeoDataFrame.plot()`. To color code by another column, pass in that column as the first argument. In the example below, we plot the active geometry column and color code by the `\"area\"` column. We also want to show a legend (`legend=True`)." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "gdf.plot(\"area\", legend=True)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "You can also explore your data interactively using `GeoDataFrame.explore()`, which behaves in the same way `plot()` does but returns an interactive map instead." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "gdf.explore(\"area\", legend=False)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Switching the active geometry (`GeoDataFrame.set_geometry`) to centroids, we can plot the same data using point geometry." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "gdf = gdf.set_geometry(\"centroid\")\n", + "gdf.plot(\"area\", legend=True)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "And we can also layer both `GeoSeries` on top of each other. We just need to use one plot as an axis for the other." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "ax = gdf[\"geometry\"].plot()\n", + "gdf[\"centroid\"].plot(ax=ax, color=\"black\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now we set the active geometry back to the original `GeoSeries`." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "gdf = gdf.set_geometry(\"geometry\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "
\n", + "User Guide\n", + " \n", + "See more on [mapping in the User Guide](../docs/user_guide/mapping.rst).\n", + "
\n", + "\n", + "## Geometry creation\n", + "\n", + "We can further work with the geometry and create new shapes based on those we already have. \n", + "\n", + "### Convex hull\n", + "\n", + "If we are interested in the convex hull of our polygons, we can access `GeoDataFrame.convex_hull`." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "gdf[\"convex_hull\"] = gdf.convex_hull" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "ax = gdf[\"convex_hull\"].plot(alpha=.5) # saving the first plot as an axis and setting alpha (transparency) to 0.5\n", + "gdf[\"boundary\"].plot(ax=ax, color=\"white\", linewidth=.5) # passing the first plot and setting linewitdth to 0.5" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Buffer\n", + "\n", + "In other cases, we may need to buffer the geometry using `GeoDataFrame.buffer()`. Geometry methods are automatically applied to the active geometry, but we can apply them directly to any `GeoSeries` as well. Let's buffer the boroughs and their centroids and plot both on top of each other." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# buffering the active geometry by 10 000 feet (geometry is already in feet)\n", + "gdf[\"buffered\"] = gdf.buffer(10000)\n", + "\n", + "# buffering the centroid geometry by 10 000 feet (geometry is already in feet)\n", + "gdf[\"buffered_centroid\"] = gdf[\"centroid\"].buffer(10000)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "ax = gdf[\"buffered\"].plot(alpha=.5) # saving the first plot as an axis and setting alpha (transparency) to 0.5\n", + "gdf[\"buffered_centroid\"].plot(ax=ax, color=\"red\", alpha=.5) # passing the first plot as an axis to the second\n", + "gdf[\"boundary\"].plot(ax=ax, color=\"white\", linewidth=.5) # passing the first plot and setting linewitdth to 0.5" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "
\n", + "User Guide\n", + " \n", + "See more on [geometry creation and manipulation in the User Guide](../docs/user_guide/geometric_manipulations.rst).\n", + "
\n", + "\n", + "## Geometry relations\n", + "\n", + "We can also ask about the spatial relations of different geometries. Using the geometries above, we can check which of the buffered boroughs intersect the original geometry of Brooklyn, i.e., is within 10 000 feet from Brooklyn.\n", + "\n", + "First, we get a polygon of Brooklyn." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "brooklyn = gdf.loc[\"Brooklyn\", \"geometry\"]\n", + "brooklyn" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The polygon is a [shapely geometry object](https://shapely.readthedocs.io/en/stable/manual.html#geometric-objects), as any other geometry used in GeoPandas." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "type(brooklyn)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Then we can check which of the geometries in `gdf[\"buffered\"]` intersects it." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "gdf[\"buffered\"].intersects(brooklyn)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Only Bronx (on the north) is more than 10 000 feet away from Brooklyn. All the others are closer and intersect our polygon.\n", + "\n", + "Alternatively, we can check which buffered centroids are entirely within the original boroughs polygons. In this case, both `GeoSeries` are aligned, and the check is performed for each row." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "gdf[\"within\"] = gdf[\"buffered_centroid\"].within(gdf)\n", + "gdf[\"within\"]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can plot the results on the map to confirm the finding." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "gdf = gdf.set_geometry(\"buffered_centroid\")\n", + "ax = gdf.plot(\"within\", legend=True, categorical=True, legend_kwds={'loc': \"upper left\"}) # using categorical plot and setting the position of the legend\n", + "gdf[\"boundary\"].plot(ax=ax, color=\"black\", linewidth=.5) # passing the first plot and setting linewitdth to 0.5" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Projections\n", + "\n", + "Each `GeoSeries` has its Coordinate Reference System (CRS) accessible at `GeoSeries.crs`. The CRS tells GeoPandas where the coordinates of the geometries are located on the earth's surface. In some cases, the CRS is geographic, which means that the coordinates are in latitude and longitude. In those cases, its CRS is WGS84, with the authority code `EPSG:4326`. Let's see the projection of our NY boroughs `GeoDataFrame`." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "gdf.crs" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Geometries are in `EPSG:2263` with coordinates in feet. We can easily re-project a `GeoSeries` to another CRS, like `EPSG:4326` using `GeoSeries.to_crs()`." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "gdf = gdf.set_geometry(\"geometry\")\n", + "boroughs_4326 = gdf.to_crs(\"EPSG:4326\")\n", + "boroughs_4326.plot()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "boroughs_4326.crs" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Notice the difference in coordinates along the axes of the plot. Where we had 120 000 - 280 000 (feet) before, we now have 40.5 - 40.9 (degrees). In this case, `boroughs_4326` has a `\"geometry\"` column in WGS84 but all the other (with centroids etc.) remain in the original CRS.\n", + "\n", + "
\n", + "Warning\n", + " \n", + "For operations that rely on distance or area, you always need to use a projected CRS (in meters, feet, kilometers etc.) not a geographic one (in degrees). GeoPandas operations are planar, whereas degrees reflect the position on a sphere. Therefore, spatial operations using degrees may not yield correct results. For example, the result of `gdf.area.sum()` (projected CRS) is 8 429 911 572 ft2 but the result of `boroughs_4326.area.sum()` (geographic CRS) is 0.083.\n", + "
\n", + "\n", + "
\n", + "User Guide\n", + " \n", + "See more on [projections in the User Guide](../docs/user_guide/projections.rst).\n", + "
\n", + "\n", + "## What next?\n", + "\n", + "With GeoPandas we can do much more than what has been introduced so far, from [aggregations](../docs/user_guide/aggregation_with_dissolve.rst), to [spatial joins](../docs/user_guide/mergingdata.rst), to [geocoding](../docs/user_guide/geocoding.rst), and [much more](../gallery/index.rst).\n", + "\n", + "Head over to the [User Guide](../docs/user_guide.rst) to learn more about the different features of GeoPandas, the [Examples](../gallery/index.rst) to see how they can be used, or to the [API reference](../docs/reference.rst) for the details." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.2" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/doc/source/index.rst b/doc/source/index.rst index 63f009f..27fbb60 100644 --- a/doc/source/index.rst +++ b/doc/source/index.rst @@ -5,12 +5,11 @@ GeoPandas is an open source project to make working with geospatial data in python easier. GeoPandas extends the datatypes used by `pandas`_ to allow spatial operations on geometric types. Geometric operations are performed by `shapely`_. Geopandas further depends on -`fiona`_ for file access and `descartes`_ and `matplotlib`_ for plotting. +`fiona`_ for file access and `matplotlib`_ for plotting. .. _pandas: http://pandas.pydata.org .. _shapely: https://shapely.readthedocs.io .. _fiona: https://fiona.readthedocs.io -.. _Descartes: https://pypi.python.org/pypi/descartes .. _matplotlib: http://matplotlib.org Description @@ -24,60 +23,32 @@ operations in python that would otherwise require a spatial database such as PostGIS. .. toctree:: - :maxdepth: 1 - :caption: Getting Started + :hidden: - Installation - Examples Gallery + Home + About + Getting started + Documentation + Community -.. toctree:: - :maxdepth: 1 - :caption: User Guide +.. container:: button - Data Structures - Reading and Writing Files - Indexing and Selecting Data - Making Maps - Managing Projections - Geometric Manipulations - Set Operations with overlay - Aggregation with dissolve - Merging Data - Geocoding - missing_empty + :doc:`Getting started ` :doc:`Documentation ` + :doc:`About GeoPandas ` :doc:`Community ` -.. toctree:: - :maxdepth: 1 - :caption: Reference Guide - - Reference to All Attributes and Methods - Changelog - - -.. toctree:: - :maxdepth: 1 - :caption: Developer - - Contributing to GeoPandas - Code of Conduct - - -Get in touch +Useful links ------------ -- Ask usage questions ("How do I?") on `StackOverflow`_ or `GIS StackExchange`_. -- Report bugs, suggest features or view the source code `on GitHub`_. -- For a quick question about a bug report or feature request, or Pull Request, - head over to the `gitter channel`_. -- For less well defined questions or ideas, or to announce other projects of - interest to GeoPandas users, ... use the `mailing list`_. +`Binary Installers (PyPI) `_ | `Source Repository (GitHub) `_ | `Issues & Ideas `_ | `Q&A Support `_ -.. _StackOverflow: https://stackoverflow.com/questions/tagged/geopandas -.. _GIS StackExchange: https://gis.stackexchange.com/questions/tagged/geopandas -.. _on GitHub: https://github.com/geopandas/geopandas -.. _gitter channel: https://gitter.im/geopandas/geopandas -.. _mailing list: https://groups.google.com/forum/#!forum/geopandas +Supported by +------------ + +.. image:: https://numfocus.org/wp-content/uploads/2017/07/NumFocus_LRG.png + :alt: numfocus + :width: 400 + :target: https://numfocus.org Indices and tables ------------------ diff --git a/doc/source/indexing.rst b/doc/source/indexing.rst deleted file mode 100644 index bb9f90a..0000000 --- a/doc/source/indexing.rst +++ /dev/null @@ -1,30 +0,0 @@ -.. currentmodule:: geopandas - -.. ipython:: python - :suppress: - - import geopandas - - -Indexing and Selecting Data -=========================== - -GeoPandas inherits the standard ``pandas`` methods for indexing/selecting data. This includes label based indexing with ``.loc`` and integer position based indexing with ``.iloc``, which apply to both ``GeoSeries`` and ``GeoDataFrame`` objects. For more information on indexing/selecting, see the pandas_ documentation. - -.. _pandas: http://pandas.pydata.org/pandas-docs/stable/indexing.html - -In addition to the standard ``pandas`` methods, GeoPandas also provides -coordinate based indexing with the ``cx`` indexer, which slices using a bounding -box. Geometries in the ``GeoSeries`` or ``GeoDataFrame`` that intersect the -bounding box will be returned. - -Using the ``world`` dataset, we can use this functionality to quickly select all -countries whose boundaries extend into the southern hemisphere. - -.. ipython:: python - - world = geopandas.read_file(geopandas.datasets.get_path('naturalearth_lowres')) - southern_world = world.cx[:, :0] - @savefig world_southern.png - southern_world.plot(figsize=(10, 3)); - diff --git a/doc/source/mergingdata.rst b/doc/source/mergingdata.rst deleted file mode 100644 index 82cdcb2..0000000 --- a/doc/source/mergingdata.rst +++ /dev/null @@ -1,114 +0,0 @@ -.. currentmodule:: geopandas - -.. ipython:: python - :suppress: - - import geopandas - - -Merging Data -========================================= - -There are two ways to combine datasets in *geopandas* -- attribute joins and spatial joins. - -In an attribute join, a ``GeoSeries`` or ``GeoDataFrame`` is combined with a regular *pandas* ``Series`` or ``DataFrame`` based on a common variable. This is analogous to normal merging or joining in *pandas*. - -In a Spatial Join, observations from two ``GeoSeries`` or ``GeoDataFrames`` are combined based on their spatial relationship to one another. - -In the following examples, we use these datasets: - -.. ipython:: python - - world = geopandas.read_file(geopandas.datasets.get_path('naturalearth_lowres')) - cities = geopandas.read_file(geopandas.datasets.get_path('naturalearth_cities')) - - # For attribute join - country_shapes = world[['geometry', 'iso_a3']] - country_names = world[['name', 'iso_a3']] - - # For spatial join - countries = world[['geometry', 'name']] - countries = countries.rename(columns={'name':'country'}) - - -Appending ---------- - -Appending GeoDataFrames and GeoSeries uses pandas ``append`` methods. Keep in mind, that appended geometry columns needs to have the same CRS. - -.. ipython:: python - - # Appending GeoSeries - joined = world.geometry.append(cities.geometry) - - # Appending GeoDataFrames - europe = world[world.continent == 'Europe'] - asia = world[world.continent == 'Asia'] - eurasia = europe.append(asia) - - -Attribute Joins ----------------- - -Attribute joins are accomplished using the ``merge`` method. In general, it is recommended to use the ``merge`` method called from the spatial dataset. With that said, the stand-alone ``merge`` function will work if the GeoDataFrame is in the ``left`` argument; if a DataFrame is in the ``left`` argument and a GeoDataFrame is in the ``right`` position, the result will no longer be a GeoDataFrame. - - -For example, consider the following merge that adds full names to a ``GeoDataFrame`` that initially has only ISO codes for each country by merging it with a *pandas* ``DataFrame``. - -.. ipython:: python - - # `country_shapes` is GeoDataFrame with country shapes and iso codes - country_shapes.head() - - # `country_names` is DataFrame with country names and iso codes - country_names.head() - - # Merge with `merge` method on shared variable (iso codes): - country_shapes = country_shapes.merge(country_names, on='iso_a3') - country_shapes.head() - - - -Spatial Joins ----------------- - -In a Spatial Join, two geometry objects are merged based on their spatial relationship to one another. - -.. ipython:: python - - - # One GeoDataFrame of countries, one of Cities. - # Want to merge so we can get each city's country. - countries.head() - cities.head() - - # Execute spatial join - - cities_with_country = geopandas.sjoin(cities, countries, how="inner", op='intersects') - cities_with_country.head() - - -Sjoin Arguments -~~~~~~~~~~~~~~~~ - -``sjoin()`` has two core arguments: ``how`` and ``op``. - -**op** - -The ``op`` argument specifies how ``geopandas`` decides whether or not to join the attributes of one object to another. There are three different join options as follows: - -* `intersects`: The attributes will be joined if the boundary and interior of the object intersect in any way with the boundary and/or interior of the other object. -* `within`: The attributes will be joined if the object’s boundary and interior intersect *only* with the interior of the other object (not its boundary or exterior). -* `contains`: The attributes will be joined if the object’s interior contains the boundary and interior of the other object and their boundaries do not touch at all. - -You can read more about each join type in the `Shapely documentation `__. - -**how** - -The `how` argument specifies the type of join that will occur and which geometry is retained in the resultant geodataframe. It accepts the following options: - -* ``left``: use the index from the first (or `left_df`) geodataframe that you provide to ``sjoin``; retain only the `left_df` geometry column -* ``right``: use index from second (or `right_df`); retain only the `right_df` geometry column -* ``inner``: use intersection of index values from both geodataframes; retain only the `left_df` geometry column - -Note more complicated spatial relationships can be studied by combining geometric operations with spatial join. To find all polygons within a given distance of a point, for example, one can first use the ``buffer`` method to expand each point into a circle of appropriate radius, then intersect those buffered circles with the polygons in question. diff --git a/doc/source/reference.rst b/doc/source/reference.rst deleted file mode 100644 index dcd7df7..0000000 --- a/doc/source/reference.rst +++ /dev/null @@ -1,217 +0,0 @@ -.. _reference: - -Reference -=========================== - -GeoSeries ---------- - -The following Shapely methods and attributes are available on -``GeoSeries`` objects: - -.. autoattribute:: geopandas.GeoSeries.area - -.. autoattribute:: geopandas.GeoSeries.bounds - -.. autoattribute:: geopandas.GeoSeries.length - -.. autoattribute:: geopandas.GeoSeries.geom_type - -.. automethod:: geopandas.GeoSeries.distance - -.. automethod:: geopandas.GeoSeries.representative_point - -.. autoattribute:: geopandas.GeoSeries.exterior - -.. autoattribute:: geopandas.GeoSeries.interiors - -.. autoattribute:: geopandas.GeoSeries.x - -.. autoattribute:: geopandas.GeoSeries.y - -`Unary Predicates` - -.. autoattribute:: geopandas.GeoSeries.is_empty - -.. autoattribute:: geopandas.GeoSeries.is_ring - -.. autoattribute:: geopandas.GeoSeries.is_simple - -.. autoattribute:: geopandas.GeoSeries.is_valid - -`Binary Predicates` - -.. automethod:: geopandas.GeoSeries.geom_almost_equals - -.. automethod:: geopandas.GeoSeries.contains - -.. automethod:: geopandas.GeoSeries.crosses - -.. automethod:: geopandas.GeoSeries.disjoint - -.. automethod:: geopandas.GeoSeries.geom_equals - -.. automethod:: geopandas.GeoSeries.intersects - -.. automethod:: geopandas.GeoSeries.overlaps - -.. automethod:: geopandas.GeoSeries.touches - -.. automethod:: geopandas.GeoSeries.within - -.. automethod:: geopandas.GeoSeries.covers - -`Set-theoretic Methods` - -.. automethod:: geopandas.GeoSeries.difference - -.. automethod:: geopandas.GeoSeries.intersection - -.. automethod:: geopandas.GeoSeries.symmetric_difference - -.. automethod:: geopandas.GeoSeries.union - -`Constructive Methods` - -.. automethod:: geopandas.GeoSeries.buffer - -.. autoattribute:: geopandas.GeoSeries.boundary - -.. autoattribute:: geopandas.GeoSeries.centroid - -.. autoattribute:: geopandas.GeoSeries.convex_hull - -.. autoattribute:: geopandas.GeoSeries.envelope - -.. automethod:: geopandas.GeoSeries.simplify - -`Affine transformations` - -.. automethod:: geopandas.GeoSeries.affine_transform - -.. automethod:: geopandas.GeoSeries.rotate - -.. automethod:: geopandas.GeoSeries.scale - -.. automethod:: geopandas.GeoSeries.skew - -.. automethod:: geopandas.GeoSeries.translate - -`Aggregating methods` - -.. autoattribute:: geopandas.GeoSeries.unary_union - -Additionally, the following attributes and methods are implemented: - -.. automethod:: geopandas.GeoSeries.from_file - -.. automethod:: geopandas.GeoSeries.to_file - -.. automethod:: geopandas.GeoSeries.to_json - -.. autoattribute:: geopandas.GeoSeries.crs - -.. automethod:: geopandas.GeoSeries.to_crs - -.. automethod:: geopandas.GeoSeries.plot - -.. autoattribute:: geopandas.GeoSeries.total_bounds - -.. autoattribute:: geopandas.GeoSeries.__geo_interface__ - -.. automethod:: geopandas.GeoSeries.isna - -.. automethod:: geopandas.GeoSeries.notna - -.. automethod:: geopandas.GeoSeries.fillna - - -Methods of pandas ``Series`` objects are also available, although not -all are applicable to geometric objects and some may return a -``Series`` rather than a ``GeoSeries`` result. The methods -``isna()`` and ``fillna()`` have been -implemented specifically for ``GeoSeries`` and are expected to work -correctly. - -GeoDataFrame ------------- - -A ``GeoDataFrame`` is a tabular data structure that contains a column -called ``geometry`` which contains a `GeoSeries``. - -Currently, the following methods/attributes are implemented for a ``GeoDataFrame``: - -.. autoattribute:: geopandas.GeoDataFrame.crs - -.. automethod:: geopandas.GeoDataFrame.to_crs - -.. automethod:: geopandas.GeoDataFrame.from_file - -.. automethod:: geopandas.GeoDataFrame.from_features - -.. automethod:: geopandas.GeoDataFrame.from_postgis - -.. automethod:: geopandas.GeoDataFrame.to_crs - -.. automethod:: geopandas.GeoDataFrame.to_file - -.. automethod:: geopandas.GeoDataFrame.to_json - -.. automethod:: geopandas.GeoDataFrame.to_parquet - -.. automethod:: geopandas.GeoDataFrame.to_feather - -.. automethod:: geopandas.GeoDataFrame.to_postgis - -.. automethod:: geopandas.GeoDataFrame.plot - -.. automethod:: geopandas.GeoDataFrame.rename_geometry - -.. automethod:: geopandas.GeoDataFrame.set_geometry - -.. automethod:: geopandas.GeoDataFrame.explode - -.. automethod:: geopandas.GeoDataFrame.dissolve - -.. autoattribute:: geopandas.GeoDataFrame.__geo_interface__ - -All pandas ``DataFrame`` methods are also available, although they may -not operate in a meaningful way on the ``geometry`` column and may not -return a ``GeoDataFrame`` result even when it would be appropriate to -do so. - -Testing -------- - -GeoPandas includes specific functions to test its objects. - -.. autofunction:: geopandas.testing.geom_equals - -.. autofunction:: geopandas.testing.geom_almost_equals - -.. autofunction:: geopandas.testing.assert_geoseries_equal - -.. autofunction:: geopandas.testing.assert_geodataframe_equal - - -Top-level Functions -------------------- - -.. currentmodule:: geopandas -.. autosummary:: - :template: autosummary.rst - :toctree: reference/ - - GeoDataFrame - GeoSeries - read_file - read_parquet - read_feather - read_postgis - sjoin - overlay - clip - tools.geocode - tools.collect - points_from_xy - datasets.get_path diff --git a/environment-dev.yml b/environment-dev.yml new file mode 100644 index 0000000..2487d60 --- /dev/null +++ b/environment-dev.yml @@ -0,0 +1,42 @@ +name: geopandas-dev +channels: + - conda-forge +dependencies: + - python + # required + - fiona>=1.8 + - pandas>=0.25 + - pygeos + - pyproj>=2.2.0 + - shapely>=1.6 + - packaging + + # testing + - pytest>=3.1.0 + - pytest-cov + - pytest-xdist + - fsspec + - codecov + # styling + - black + - pre-commit + + # optional + - folium + - xyzservices + - scipy + - libspatialite + - geoalchemy2 + - pyarrow + # doctest testing + - pytest-doctestplus + # geocoding + - geopy + # geodatabase access + - psycopg2>=2.5.1 + - SQLAlchemy>=0.8.3 + # plotting + - matplotlib>=2.2 + - mapclassify + # spatial access methods + - rtree>=0.8 diff --git a/environment.yml b/environment.yml index ee133d2..3bd63d1 100644 --- a/environment.yml +++ b/environment.yml @@ -1,33 +1,21 @@ -name: geopandas-dev +name: geopandas channels: - - conda-forge + - conda-forge dependencies: - # required - - fiona>=1.7 - - pandas>=0.23.4 - - pyproj>=2.2.0 - - shapely>=1.5 - - # geodatabase access - - psycopg2>=2.5.1 - - SQLAlchemy>=0.8.3 - - # geocoding - - geopy - - # plotting - - descartes>=1.0 - - matplotlib>=2.0 - - # testing - - mock>=1.0.1 # technically not need for python >= 3.3 - - pytest>=3.1.0 - - pytest-cov - - codecov - - # spatial access methods - - rtree>=0.8 - - # styling - - black - - pre-commit + - geopandas + - shapely + - fiona + - pyproj + - pygeos + - rtree + - mapclassify + - libpysal + - matplotlib + - geopy + - cartopy + - pyepsg + - contextily + - rasterio + - geoplot + - folium + - packaging diff --git a/examples/README.md b/examples/README.md new file mode 100644 index 0000000..794634f --- /dev/null +++ b/examples/README.md @@ -0,0 +1,3 @@ +# Examples Gallery + +Examples are available in the [documentation](https://geopandas.readthedocs.io/en/latest/gallery/index.html). Source Jupyter notebooks are in [`doc/source/gallery`](https://github.com/geopandas/geopandas/tree/main/doc/source/gallery). diff --git a/examples/README.txt b/examples/README.txt deleted file mode 100644 index 1ee851a..0000000 --- a/examples/README.txt +++ /dev/null @@ -1,8 +0,0 @@ -.. _gallery: - -Examples Gallery ----------------- - -The following examples show off the functionality in GeoPandas. They highlight -many of the things you can do with this package, and show off some -best-practices. diff --git a/examples/cartopy_convert.py b/examples/cartopy_convert.py deleted file mode 100644 index 9d5e189..0000000 --- a/examples/cartopy_convert.py +++ /dev/null @@ -1,106 +0,0 @@ -""" -Plotting with CartoPy and GeoPandas ------------------------------------ - -Converting between GeoPandas and CartoPy for visualizing data. - -`CartoPy `_ is a Python library -that specializes in creating geospatial -visualizations. It has a slightly different way of representing -Coordinate Reference Systems (CRS) as well as constructing plots. -This example steps through a round-trip transfer of data -between GeoPandas and CartoPy. - -First we'll load in the data using GeoPandas. -""" -# sphinx_gallery_thumbnail_number = 7 -import matplotlib.pyplot as plt -import geopandas -from cartopy import crs as ccrs - -path = geopandas.datasets.get_path('naturalearth_lowres') -df = geopandas.read_file(path) -# Add a column we'll use later -df['gdp_pp'] = df['gdp_md_est'] / df['pop_est'] - -#################################################################### -# First we'll visualize the map using GeoPandas -df.plot() - -############################################################################### -# Plotting with CartoPy -# ===================== -# -# Cartopy also handles Shapely objects well, but it uses a different system for -# CRS. To plot this data with CartoPy, we'll first need to project it into a -# new CRS. We'll use a CRS defined within CartoPy and use the GeoPandas -# ``to_crs`` method to make the transformation. - -# Define the CartoPy CRS object. -crs = ccrs.AzimuthalEquidistant() - -# This can be converted into a `proj4` string/dict compatible with GeoPandas -crs_proj4 = crs.proj4_init -df_ae = df.to_crs(crs_proj4) - -# Here's what the plot looks like in GeoPandas -df_ae.plot() - -############################################################################### -# Now that our data is in a CRS based off of CartoPy, we can easily -# plot it. - -fig, ax = plt.subplots(subplot_kw={'projection': crs}) -ax.add_geometries(df_ae['geometry'], crs=crs) - -############################################################################### -# Note that we could have easily done this with an EPSG code like so: -crs_epsg = ccrs.epsg('3857') -df_epsg = df.to_crs(epsg='3857') - -# Generate a figure with two axes, one for CartoPy, one for GeoPandas -fig, axs = plt.subplots(1, 2, subplot_kw={'projection': crs_epsg}, - figsize=(10, 5)) -# Make the CartoPy plot -axs[0].add_geometries(df_epsg['geometry'], crs=crs_epsg, - facecolor='white', edgecolor='black') -# Make the GeoPandas plot -df_epsg.plot(ax=axs[1], color='white', edgecolor='black') - -############################################################################### -# CartoPy to GeoPandas -# ==================== -# -# Next we'll perform a CRS projection in CartoPy, and then convert it -# back into a GeoPandas object. - -crs_new = ccrs.AlbersEqualArea() -new_geometries = [crs_new.project_geometry(ii, src_crs=crs) - for ii in df_ae['geometry'].values] - -fig, ax = plt.subplots(subplot_kw={'projection': crs_new}) -ax.add_geometries(new_geometries, crs=crs_new) - -############################################################################### -# Now that we've created new Shapely objects with the CartoPy CRS, -# we can use this to create a GeoDataFrame. - -df_aea = geopandas.GeoDataFrame(df['gdp_pp'], geometry=new_geometries, - crs=crs_new.proj4_init) -df_aea.plot() - -############################################################################### -# We can even combine these into the same figure. Here we'll plot the -# shapes of the countries with CartoPy. We'll then calculate the centroid -# of each with GeoPandas and plot it on top. - -# Generate a CartoPy figure and add the countries to it -fig, ax = plt.subplots(subplot_kw={'projection': crs_new}) -ax.add_geometries(new_geometries, crs=crs_new) - -# Calculate centroids and plot -df_aea_centroids = df_aea.geometry.centroid -# Need to provide "zorder" to ensure the points are plotted above the polygons -df_aea_centroids.plot(ax=ax, markersize=5, color='r', zorder=10) - -plt.show() diff --git a/examples/choro_legends.ipynb b/examples/choro_legends.ipynb deleted file mode 100644 index 03c96bf..0000000 --- a/examples/choro_legends.ipynb +++ /dev/null @@ -1,542 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [], - "source": [ - "import geopandas\n", - "from geopandas import read_file" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "'2.2.0'" - ] - }, - "execution_count": 2, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "import mapclassify\n", - "mapclassify.__version__" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "'4.2.0'" - ] - }, - "execution_count": 3, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "import libpysal\n", - "libpysal.__version__" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - " Name Description Installed\n", - "0 10740 Albuquerque, New Mexico, Census 2000 Tract Data True\n", - "1 AirBnB Airbnb rentals, socioeconomics, and crime in C... False\n", - "2 Atlanta Atlanta, GA region homicide counts and rates False\n", - "3 Baltimore Baltimore house sales prices and hedonics False\n", - "4 Bostonhsg Boston housing and neighborhood data False\n", - "5 Buenosaires Electoral Data for 1999 Argentinean Elections False\n", - "6 Charleston1 2000 Census Tract Data for Charleston, SC MSA... False\n", - "7 Charleston2 1998 and 2001 Zip Code Business Patterns (Cen... False\n", - "8 Chicago Health Chicago Health + Socio-Economics False\n", - "9 Chile Labor Labor Markets in Chile (1982-2002) False\n", - "10 Chile Migration Internal Migration in Chile (1977-2002) False\n", - "11 Cincinnati 2008 Cincinnati Crime + Socio-Demographics False\n", - "12 Cleveland 2015 sales prices of homes in Cleveland, OH. False\n", - "13 Columbus Columbus neighborhood crime False\n", - "14 Denver Demographics and housing in Denver neighborho... False\n", - "15 Elections 2012 and 2016 Presidential Elections False\n", - "16 Grid100 Grid with simulated variables False\n", - "17 Groceries 2015 Chicago supermarkets False\n", - "18 Guerry Moral statistics of France (Guerry, 1833) False\n", - "19 Health Indicators Chicago Health Indicators (2005-11) False\n", - "20 Health+ 2000 Health, Income + Diversity False\n", - "21 Hickory1 2000 Census Tract Data for Hickory, NC MSA an... False\n", - "22 Hickory2 1998 and 2001 Zip Code Business Patterns (Cen... False\n", - "23 Home Sales 2014-15 Home Sales in King County, WA False\n", - "24 Houston Houston, TX region homicide counts and rates False\n", - "25 Juvenile Cardiff juvenile delinquent residences False\n", - "26 Lansing1 2000 Census Tract Data for Lansing, MI MSA an... False\n", - "27 Lansing2 1998 and 2001 Zip Code Business Patterns (Cen... False\n", - "28 Laozone Ozone measures at monitoring stations in Los ... False\n", - "29 LasRosas Corn yield, fertilizer and field data for pre... False\n", - "30 Line Line Shapefile True\n", - "31 Liquor Stores 2015 Chicago Liquor Stores False\n", - "32 Malaria Malaria incidence and population (1973, 95, 9... False\n", - "33 Milwaukee1 2000 Census Tract Data for Milwaukee, WI MSA False\n", - "34 Milwaukee2 1998 and 2001 Zip Code Business Patterns (Cen... False\n", - "35 NCOVR US county homicides 1960-1990 False\n", - "36 NDVI Normalized Difference Vegetation Index grid False\n", - "37 NYC Demographic and housing data for New York Cit... False\n", - "38 NYC Earnings Block-level Earnings in NYC (2002-14) False\n", - "39 NYC Education NYC Education (2000) False\n", - "40 NYC Neighborhoods Demographics for New York City neighborhoods False\n", - "41 NYC Socio-Demographics NYC Education + Socio-Demographics False\n", - "42 Natregimes NCOVR with regimes (book/PySAL) False\n", - "43 Nepal Health, poverty and education indicators for ... False\n", - "44 Ohiolung Ohio lung cancer data, 1968, 1978, 1988 False\n", - "45 Orlando1 2000 Census Tract Data for Orlando, FL MSA an... False\n", - "46 Orlando2 1998 and 2001 Zip Code Business Patterns (Cen... False\n", - "47 Oz9799 Monthly ozone data, 1997-99 False\n", - "48 Phoenix ACS Phoenix American Community Survey Data (2010,... False\n", - "49 Pittsburgh Pittsburgh homicide locations False\n", - "50 Point Point Shapefile True\n", - "51 Police Police expenditures Mississippi counties False\n", - "52 Polygon Polygon Shapefile True\n", - "53 Polygon_Holes Example to test treatment of holes True\n", - "54 Rio Grande do Sul Cities of the Brazilian State of Rio Grande do... False\n", - "55 SIDS North Carolina county SIDS death counts False\n", - "56 SIDS2 North Carolina county SIDS death counts and r... False\n", - "57 Sacramento1 2000 Census Tract Data for Sacramento MSA False\n", - "58 Sacramento2 1998 and 2001 Zip Code Business Patterns (Cen... False\n", - "59 SanFran Crime July-Dec 2012 crime incidents in San Francisc... False\n", - "60 Savannah1 2000 Census Tract Data for Savannah, GA MSA a... False\n", - "61 Savannah2 1998 and 2001 Zip Code Business Patterns (Cen... False\n", - "62 Scotlip Male lip cancer in Scotland, 1975-80 False\n", - "63 Seattle1 2000 Census Tract Data for Seattle, WA MSA an... False\n", - "64 Seattle2 1998 and 2001 Zip Code Business Patterns (Cen... False\n", - "65 South US Southern county homicides 1960-1990 False\n", - "66 StLouis St Louis region county homicide counts and rates False\n", - "67 Tampa1 2000 Census Tract Data for Tampa, FL MSA and ... False\n", - "68 arcgis arcgis testing files True\n", - "69 baltim Baltimore house sales prices and hedonics 1978 True\n", - "70 berlin Prenzlauer Berg neighborhood AirBnB data from ... True\n", - "71 book Synthetic data to illustrate spatial weights True\n", - "72 burkitt Burkitt's lymphoma in the Western Nile distric... True\n", - "73 calemp Employment density for California counties True\n", - "74 chicago Chicago neighborhoods True\n", - "75 clearwater mgwr testing dataset False\n", - "76 columbus Columbus neighborhood crime data 1980 True\n", - "77 desmith Small dataset to illustrate Moran's I statistic True\n", - "78 geodanet Datasets from geodanet for network analysis True\n", - "79 georgia Various socio-economic variables for counties ... True\n", - "80 juvenile Residences of juvenile offenders in Cardiff, UK True\n", - "81 mexico Decennial per capita incomes of Mexican states... True\n", - "82 networks Datasets used for network testing True\n", - "83 newHaven Network testing dataset False\n", - "84 nyc_bikes New York City Bike Trips False\n", - "85 sids2 North Carolina county SIDS death counts and rates True\n", - "86 snow_maps Public water pumps and Cholera deaths in Londo... True\n", - "87 stl Homicides and selected socio-economic characte... True\n", - "88 street_net_pts Street network points True\n", - "89 taz Traffic Analysis Zones in So. California False\n", - "90 tokyo Tokyo Mortality data True\n", - "91 us_income Per-capita income for the lower 48 US states 1... True\n", - "92 virginia Virginia counties shapefile True\n", - "93 wmat Datasets used for spatial weights testing True\n" - ] - } - ], - "source": [ - "libpysal.examples.available()" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Downloading South to /home/jovyan/.local/pysal_data/South\n" - ] - } - ], - "source": [ - "_ = libpysal.examples.load_example('South')\n", - "pth = libpysal.examples.get_path('south.shp')" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [], - "source": [ - "df = read_file(pth)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## New default legend formatting" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "%matplotlib inline\n", - "ax = df.plot(column='HR60', scheme='QUANTILES', k=4, \\\n", - " cmap='BuPu', legend=True,\n", - " legend_kwds={'loc': 'center left', 'bbox_to_anchor':(1,0.5)})" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "['[ 0.00, 3.21]', '( 3.21, 6.25]', '( 6.25, 9.96]', '( 9.96, 92.94]']" - ] - }, - "execution_count": 9, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "labels = [t.get_text() for t in ax.get_legend().get_texts()]\n", - "labels" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "Quantiles \n", - "\n", - " Interval Count\n", - "----------------------\n", - "[ 0.00, 3.21] | 353\n", - "( 3.21, 6.25] | 353\n", - "( 6.25, 9.96] | 353\n", - "( 9.96, 92.94] | 353" - ] - }, - "execution_count": 10, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "q4 = mapclassify.Quantiles(df.HR60, k=4)\n", - "q4" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "True" - ] - }, - "execution_count": 11, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "labels == q4.get_legend_classes()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Note that in this case, the first interval is closed on the minimum value in the dataset. The other intervals have an open lower bound. This is now displayed in the legend." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Overriding numerical format" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "ax = df.plot(column='HR60', scheme='QUANTILES', k=4, \\\n", - " cmap='BuPu', legend=True,\n", - " legend_kwds={'loc': 'center left', 'bbox_to_anchor':(1,0.5)},\n", - " )" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "ax = df.plot(column='HR60', scheme='QUANTILES', k=4, \\\n", - " cmap='BuPu', legend=True,\n", - " legend_kwds={'loc': 'center left', 'bbox_to_anchor':(1,0.5), 'fmt':\"{:.4f}\"})" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "ax = df.plot(column='HR60', scheme='QUANTILES', k=4, \\\n", - " cmap='BuPu', legend=True,\n", - " legend_kwds={'loc': 'center left', 'bbox_to_anchor':(1,0.5), 'fmt':\"{:.0f}\"})" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "The new legends_kwds arg `fmt` takes a string to set the numerical formatting." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## When first class lower bound < y.min()" - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "ax = df.plot(column='HR60', scheme='BoxPlot', \\\n", - " cmap='BuPu', legend=True,\n", - " legend_kwds={'loc': 'center left', 'bbox_to_anchor':(1,0.5),\n", - " 'fmt': \"{:.0f}\"})" - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "BoxPlot \n", - "\n", - " Interval Count\n", - "----------------------\n", - "( -inf, -6.90] | 0\n", - "(-6.90, 3.21] | 353\n", - "( 3.21, 6.25] | 353\n", - "( 6.25, 9.96] | 353\n", - "( 9.96, 20.07] | 311\n", - "(20.07, 92.94] | 42" - ] - }, - "execution_count": 16, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "bp = mapclassify.BoxPlot(df.HR60)\n", - "bp\n" - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "['(-inf, -7]',\n", - " '( -7, 3]',\n", - " '( 3, 6]',\n", - " '( 6, 10]',\n", - " '( 10, 20]',\n", - " '( 20, 93]']" - ] - }, - "execution_count": 17, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "bp.get_legend_classes(fmt=\"{:.0f}\")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "In some classifiers the user should be aware that the lower (upper) bound of the first (last) interval is not equal to the minimum (maximum) of the attribute values. This is useful to detect extreme values and highly skewed distributions." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Categorical Data" - ] - }, - { - "cell_type": "code", - "execution_count": 18, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "ax = df.plot(column='STATE_NAME', categorical=True, legend=True, \\\n", - " legend_kwds={'loc': 'center left', 'bbox_to_anchor':(1,0.5),\n", - " 'fmt': \"{:.0f}\"}) # fmt is ignored for categorical data" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.7.3" - } - }, - "nbformat": 4, - "nbformat_minor": 4 -} diff --git a/examples/choropleths.ipynb b/examples/choropleths.ipynb deleted file mode 100644 index 723b584..0000000 --- a/examples/choropleths.ipynb +++ /dev/null @@ -1,861 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Choropleth classification schemes from PySAL for use with GeoPandas\n", - "\"PySAL\n", - "PySAL is a [Spatial Analysis Library](), which packages fast spatial algorithms used in various fields. These include Exploratory spatial data analysis, spatial inequality analysis, spatial analysis on networks, spatial dynamics, and many more.\n", - "\n", - "It is used under the hood in geopandas when plotting measures with a set of colors. There are many ways to classify data into different bins, depending on a number of classification schemes.\n", - "\n", - "\n", - "\n", - "For example, if we have 20 countries whose average annual temperature varies between 5C and 25C, we can classify them in 4 bins by:\n", - "* Quantiles\n", - " - Separates the rows into equal parts, 5 countries per bin.\n", - "* Equal Intervals\n", - " - Separates the measure's interval into equal parts, 5C per bin.\n", - "* Natural Breaks (Fischer Jenks)\n", - " - This algorithm tries to split the rows into naturaly occurring clusters. The numbers per bin will depend on how the observations are located on the interval." - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": { - "ExecuteTime": { - "end_time": "2017-12-15T21:29:37.736444Z", - "start_time": "2017-12-15T21:29:37.716444Z" - }, - "collapsed": true - }, - "outputs": [], - "source": [ - "%matplotlib inline\n", - "import geopandas as gpd\n", - "import matplotlib.pyplot as plt" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": { - "ExecuteTime": { - "end_time": "2017-12-15T21:29:39.866422Z", - "start_time": "2017-12-15T21:29:39.846422Z" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Observations, Attributes: (49, 21)\n" - ] - }, - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
AREAPERIMETERCOLUMBUS_COLUMBUS_IPOLYIDNEIGHOVALINCCRIMEOPEN...DISCBDXYNSANSBEWCPTHOUSNEIGNOgeometry
00.3094412.440629251580.46700319.53115.7259802.850747...5.0338.79999944.0700001.01.01.00.01000.01005.0POLYGON ((8.624129295349121 14.23698043823242,...
10.2593292.236939312144.56700121.23218.8017545.296720...4.2735.61999942.3800011.01.00.00.01000.01001.0POLYGON ((8.252790451049805 14.23694038391113,...
20.1924682.187547463626.35000015.95630.6267814.534649...3.8939.82000041.1800001.01.01.00.01000.01006.0POLYGON ((8.653305053710938 14.00809001922607,...
30.0838411.427635524233.2000014.47732.3877600.394427...3.7036.50000040.5200001.01.00.00.01000.01002.0POLYGON ((8.459499359130859 13.82034969329834,...
40.4888882.997133675723.22500011.25250.7315100.405664...2.8340.00999838.0000001.01.01.00.01000.01007.0POLYGON ((8.685274124145508 13.63951969146729,...
\n", - "

5 rows × 21 columns

\n", - "
" - ], - "text/plain": [ - " AREA PERIMETER COLUMBUS_ COLUMBUS_I POLYID NEIG HOVAL \\\n", - "0 0.309441 2.440629 2 5 1 5 80.467003 \n", - "1 0.259329 2.236939 3 1 2 1 44.567001 \n", - "2 0.192468 2.187547 4 6 3 6 26.350000 \n", - "3 0.083841 1.427635 5 2 4 2 33.200001 \n", - "4 0.488888 2.997133 6 7 5 7 23.225000 \n", - "\n", - " INC CRIME OPEN \\\n", - "0 19.531 15.725980 2.850747 \n", - "1 21.232 18.801754 5.296720 \n", - "2 15.956 30.626781 4.534649 \n", - "3 4.477 32.387760 0.394427 \n", - "4 11.252 50.731510 0.405664 \n", - "\n", - " ... DISCBD X \\\n", - "0 ... 5.03 38.799999 \n", - "1 ... 4.27 35.619999 \n", - "2 ... 3.89 39.820000 \n", - "3 ... 3.70 36.500000 \n", - "4 ... 2.83 40.009998 \n", - "\n", - " Y NSA NSB EW CP THOUS NEIGNO \\\n", - "0 44.070000 1.0 1.0 1.0 0.0 1000.0 1005.0 \n", - "1 42.380001 1.0 1.0 0.0 0.0 1000.0 1001.0 \n", - "2 41.180000 1.0 1.0 1.0 0.0 1000.0 1006.0 \n", - "3 40.520000 1.0 1.0 0.0 0.0 1000.0 1002.0 \n", - "4 38.000000 1.0 1.0 1.0 0.0 1000.0 1007.0 \n", - "\n", - " geometry \n", - "0 POLYGON ((8.624129295349121 14.23698043823242,... \n", - "1 POLYGON ((8.252790451049805 14.23694038391113,... \n", - "2 POLYGON ((8.653305053710938 14.00809001922607,... \n", - "3 POLYGON ((8.459499359130859 13.82034969329834,... \n", - "4 POLYGON ((8.685274124145508 13.63951969146729,... \n", - "\n", - "[5 rows x 21 columns]" - ] - }, - "execution_count": 2, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# We use a PySAL example shapefile\n", - "import pysal as ps\n", - "\n", - "pth = ps.examples.get_path(\"columbus.shp\")\n", - "tracts = gpd.GeoDataFrame.from_file(pth)\n", - "print('Observations, Attributes:',tracts.shape)\n", - "tracts.head()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Plotting the CRIME variable\n", - "In this example, we are taking a look at neighbourhood-level statistics for the city of Columbus, OH. We'd like to have an idea of how the crime rate variable is distributed around the city.\n", - "\n", - "From the [shapefile's metadata](https://github.com/pysal/pysal/blob/master/pysal/examples/columbus/columbus.html):\n", - ">**CRIME**: residential burglaries and vehicle thefts per 1000 households" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAY0AAAEiCAYAAAAF7Y7qAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nl6J2iYOPAwAAAABJRU5ErkJggg==\n", - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# Let's take a look at how the CRIME variable is distributed with a histogram\n", - "tracts['CRIME'].hist(bins=20)\n", - "plt.xlabel('CRIME\\nResidential burglaries and vehicle thefts per 1000 households')\n", - "plt.ylabel('Number of neighbourhoods')\n", - "plt.title('Distribution of neighbourhoods by crime rate in Columbus, OH')\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Now let's see what it looks like without a classification scheme:" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": { - "ExecuteTime": { - "end_time": "2017-12-15T21:29:54.097280Z", - "start_time": "2017-12-15T21:29:53.766283Z" - } - }, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 4, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAWYAAADxCAYAAAD4Mh1ZAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\nAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMS4xLCBo\ndHRwOi8vbWF0cGxvdGxpYi5vcmcvAOZPmwAAIABJREFUeJzsnXeYVNX5xz/n3qm7s703lgWWKk0W\nAVGaBcWW2MVYosaSWKOxxF9iN5iYxBoTo0bU2A0q0aBYELuC0ou0XVgW2F6nzz2/P2bABWZ3Z3dn\nl1k4n+e5z8zcOfecMzD7nfe+5z3vK6SUKBQKhSJ20A70BBQKhUKxN0qYFQqFIsZQwqxQKBQxhhJm\nhUKhiDGUMCsUCkWMoYRZoVAoYgwlzAqFQhFjKGFWKBSKGEMJs0KhUMQYpgM9AYVCoTiQDBJCOiNs\nuwPek1Ke0KMTQgmzQqE4xHECl0fY9i5I78m57EYJs0KhOKQRgH6gJ7EPSpgVCsUhT6wttilhVigU\nhzQCJcwKhUIRc4gDPYF9UMKsUCgOeZTFrFAoFDGGspgVCoUihhDEnhDG2nwUCoWi11EWs0KhUMQQ\nKiojQtLT02X//v0P9DQUCkWMs3Tp0mopZUZ3+1HCHAH9+/dnyZIlB3oaCoUixhFClEWln2h0EkVi\nUpgVCoWit1BbshUKhSIGUa4MhUKhiCHU4p9CoVDEIMrHrFAoFDGGspgVCoUihlCuDIWiC8ydO5f6\n+npsNht2ux2bzbbX0fpcfHw8OTk5CBFrN6eKWEVFZSgUXeA3N/2aE48ehdViwe314fL4cHt8uL0+\n3G5v8LnHh9vjZduOSj788CMmT558oKet6EMoi1mh6CT9C/txxTkzmDimuMO2My7+A16vtxdmpTiY\niLX7q1j7oVAo9qN///6Ubq+KqK1hSHQ91m5MFbHMbh9zJEdvoSxmRczTf8AgSsu3RdQ2EDCUMCs6\nTaxZzEqYFTHPgAEDWbpoeURtpZTceMN1JDji8fl9+P1+/P4ANpsVhyMBh8NBvCOBhIREHAmJJCQk\nMH78eGbMmNHDn0IRy8Sa60AJsyLm6d+/P29U1ETU9u93Xsy2nTWYdA2zyYTJpKFrGh6vn2anm6YW\nF81ONy3OepqbdrJy5U7emvc6X3z1bQ9/CkWsEu2oDCFEMvAUcBgggUuA9cArQH+gFDhbSlnXVh9K\nmBUxT1FREaXbKiNqe9jgAg4bXBBx30tXbeaKe17q6tQUBwlRtpgfBhZIKc8UQliAOOC3wIdSyjlC\niFuBW4FbujwfIcQzQohKIcSqMO/dJISQQoj0Nq4NCCGWhY63I/1UCkVrCgsL2bajkkDAiHrfdpsF\nt9sd9X4VfYdoLv4JIRKBKcDTAFJKr5SyHjgNmBtqNhf4SXv9RDLWs8AJYSZQABwHbG3nWpeUckzo\nODWCsRSK/bDZbKSmJLOjqs07v673bTXjcilhPtQRER5AuhBiSavj8n26GgBUAf8SQnwvhHhKCBEP\nZEkpdwCEHjPbm0+HwiylXAzUhnnrr8DNBH0oCkWPUtS/kC3lkYXMdQa71YLb44l6v4q+hdBERAdQ\nLaUsaXU8uU9XJuBw4Akp5VighaDbolN0ybUihDgV2C6l7Gip3Bb6VflKCNGu6a5QtEdRURFbyiPz\nM3cGZTErhABd1yI6IqAcKJdSfh16/TpBod4lhMgJjidygHa/zJ0WZiFEHHA78PsImveTUpYAs4GH\nhBAD2+n38t23B1VV0beMFH2bwqKBlEW4yaQz2G3KYlaAECKioyOklDuBbUKIIaFTxwBrgLeBi0Ln\nLgLeaq+frljMA4EiYLkQohTIB74TQmSHmWRF6HEzsAgY21anUsond98eZGR0u7ai4iBjwICBbKkI\n51HrHlaLGa/Xh2FEf2FR0VeIzI0RcmVEwjXAv4UQK4AxwP3AHOA4IcQGgmtzc9rroNPhclLKlbRy\nXIfEuURKWd26nRAiBXBKKT2hqI3JwB87O55CAcFY5ue3V3fcsJMIIbBaLXg8Hux2e9T7V/QNopmN\nUEq5DCgJ89YxkfYRSbjcS8CXwBAhRLkQ4tJ22pYIIZ4KvRwGLBFCLAc+BuZIKddEOjGFojVFRUWU\n9oCPGcBmteByuXqkb0UfQHRq8a9X6NBillKe18H7/Vs9XwJcFnr+BTCym/NTKAAoKChgR2UNPp8f\nszm6+6LsNquKZT6EEUTXYo4GsbZFXKEIi9lsJjszg207I9ua3RmUxXyIIwSarkV09BZKmBV9hqKi\nyNN/dga1+0+haSKio7dQuTIUfYaiogE9sslEWcyHNrHoylDCrOgzFBYNpLR8RdT7tVuVxXxIE1r8\niyWUK0PRZxgwYAClO6Ifyxzc/acs5kOZaG0wiRbKYlZ0Giklu3btorS0lLKyMrZs2UJZ6WbKtmym\ntKwMELz48quMGTMmquP279+f0vLoxTJLKXF7fOi6pizmQ5reDYWLBCXMik7zySefMH36dEYUFzJ0\nQA6FWYkMz03lxBHDKMyZzKqNFRx/7Ayu//VNjB8/Hikly5cvZ83KZSSnpjN4yNA9FojJZMJsNqNp\nwZs3v99PQ0MD9fX1NNTXUV9fi9vpxOPxUF9fz7qNZd2e/1OvfcR19z2Hx+PFYjETZ7eTnJzc7X4V\nfRMh6NWIi0hQwqzoNFOnTuWSn1/E1vXf8/w9F2C1mPd6f2RxPsX9Mnn+nY+5/+2X0ITGsKIMSoqy\nqG/cyrKPg6m9DWngD0h8/gAylKNQ1wRJDhtJ8RZyHHaGFNiJsyVjtZgwm/px+iefUd/YTHKio8vz\n31pRzU03/YY777xT1QdUAGrxT3EQIITgH08+xTlnncHFdzzPS3+4ZL82JSP6UzKif9THzk5P4qtl\nGzlhStfdJF5fgDSHQ4myYg+9GQoXCbFlvyv6DCaTiWefe4F5Hyzp1XELc9NZsnpzt/rw+gNYLJYo\nzUjR54lw4U8t/in6BFJKrL0scIMLs1i7cXu3+vB4/UqYFXsQqHA5xUGE1+vdz7/c0wwpzKS0m5tM\nvL4AVqs1SjNS9HkEaLqI6OgtlMWs6DJerxdLlBMKdUT/vHRqGpq71YfXp1wZir1Ri3+Kgwav14vF\n0svCnJtGY5OzW314fH5lMSv2ok+6MoQQzwghKoUQq8K8d5MQQoaS4Ye79iIhxIbQcVG4Noq+yYGw\nmIvy0mls7p4we33Kx6z4EYFAE5EdvUWkPuZngRP2PSmEKCBYJmVruIuEEKnAHcAE4AjgjlBlE8VB\ngNfrxWzqXWHOSkvEFzDYWVXf5T6UK0OxF30xUT6AlHKxEKJ/mLf+CtxM24UFZwILpZS1AEKIhQQF\n/qVOz1QRcyQlJVFRWUtFZT25mb2zc04IQUZKArNvfITBRbk47DYSHTYS4u0kOOwkJ8aR5IgjJTGe\nlEQHKUnxJCfG7dlZCOD1+pQrQ7EXB42PWQhxKrBdSrm8nQ+VB2xr9bo8dC5cf5cDlwP069evq9NS\n9CIFBQVcffU1XHHfS7z90JW99uX2uD1s2VROugiw1e3D6fXh8vhp8fpwe/24vH48Pj8eXwBvwMAf\nMDDpGiZNw6QLpITa2ugnQ1L0TQ6aLdlCiDjgduD4jpqGOSfDNZRSPgk8CVBSUhK2jSL2+N3v72DC\n+Ld54Z2vuODkSb0yZmZqIjcfP5ILjx4WUXvDkLh9fpwh0T79sYVkZ+9X1F1xyBJ7SYy6+jMxECgC\nloeqZOcD3wkh9v22lwMFrV7nAxVdHFMRg1gsFu6+937+9fY3vTZmgsPOrsbIFwA1TRBnNZOeYKcg\nLYE4u5W1a9eyfv16qqurCQQCPThbRV/goNj5J6VcCWTufh0S5xIp5b45Gd8D7m+14Hc8cFtXxlTE\nLscddxxX/OJSlq3bxpihBR1f0E0yUhxU1Hc9MuP4Ybn86+EH+PO9d1Dd2Exji4skh4O0lGTSUlNI\nS0sjLT2D1MxM0tIzSU9PJy0tjfT0dDIyMhg+fPhePmtFH0eAiOL/Z0gPm4AA4JdSloQCIV4B+gOl\nwNlSyrq2+ohImIUQLwHTgHQhRDlwh5Ty6TbalgBXSikvk1LWCiHuAb4NvX337oVAxcGDzWbjN7fc\nxmV3P8a9vzqZjJQEkhx2BhZk9IiVkZuZQvm2nV2+/vZTxnL7KWP3vA4YBnUtHmqa3T8eTdXU7Cqn\nZrOHMqefGqePmmY3yzbv4NU3/sPMmTOj8VEUMUIPuDKm72Oo3gp8KKWcI4S4NfT6lrYujjQq47wO\n3u/f6vkS4LJWr58BnolkHEXf5dprryUxMZF7n3wCj8dDVXUNLS0tXHX2FO688uSoWpj9c9NYuWJj\n1PrTNY30BDvpCfYO2579xEc0NjZGbWxFLCCCK4A9y2kEjVuAucAi2hFmdT+miAq6rnPppZfyxddL\nWLpsJVvLK/h++UoWrazi6jmvRmUMwzB4fv6XzH3rczbtavMusEexW3RV7eQgQwjQTHpER4RI4H0h\nxNJQtBlAlpRyB0DoMbPNq1FbshU9SL9+/Zj/zv/oV5DPX248A5u144RHXq+f825+ku/WlFJV14w3\nEEyibzXr6ELgsJk5u2QAT392YITZZtJUfcCDkE643NKFEK1z3T4ZiihrzWQpZYUQIhNYKIRY19n5\nKGFW9CgpKSkMHzqYL1dsYvr4oe22dbo8jDnzLlLMgofOGE9J/3RS4qxoQlDv8tDs8TMgPQFfwOCx\nj1ZhGEavL8LZzcpiPugQAiL3MVdLKUvaayClrAg9Vgoh5hHc9bxLCJEjpdwhhMgBKtvrQwmzosc5\n5vgT+OiblUwfP5Sy7dXc8893aGpx0dTipsXlxe324fH62FFVz9iCNN686lis5r1vG7PMcWSFnltM\nOhaTzraaZgozEnv1s1h1oSzmg5BoRWUIIeIBTUrZFHp+PHA38DZwETAn9NjWbmlACbOiFzj66Ck8\nePc7ADz33y+Z9963nDl+IP0cZhLSbDisZhJsZnKT4zlueB7mCHZhJdktbKys73VhtpuVMB+MRDF6\nKAuYF+rPBLwopVwghPgWeFUIcSnB3EJntdeJEmZFjzNhwgS+XbWJ2vpm6ptc6LrG38+f3K0+Ux02\ntlQ1RWmGkWMzm2h0tvT6uIqeQwiBMEXHYpZSbgZGhzlfAxwTaT9KmBU9TmpqKnEWM7nH3ERRRiKX\nRriVuj10IbjvP1/z3OI1WMw6NrOO1WzCbtaxWUzEWczEmXXsVhPxVgtxVhMJVjPxNnPQQrdbSLBZ\nSIqzkGAzk2i3ROSvtptNVLq6l3ZUEXsIEVsBakqYFb3C0KFD+dVIB6cfXhSV/vy+AEOBES4vXqfE\nJcEjJW4DmqTEY0jchoHHkKHDwCslXsPAZ0i8hsQnJX5D4peSAMHYUZMmWPnAzxiYFT5bns2i43L+\nKMybN2/m+++/x+v1hj0CgQC5ubkUFBRQWVlJTk4O06ZNi8q/gSJKiNhLlK+EWdHjlJeXs3LVao78\nyalR6zM53soIs85VudFJ7y2lxCdh+oqtbK5sbFuYzSY8zT/6mK+56gqaK8vISUsMLUpqex0CWPOJ\nk/LqJnw+H9bkbKYt/jwqc1ZEDyXMij6LYRg4nU7i4+M7tVhy7113cunkwWQnxXXY1u832Fb3Y00/\nTRPkJNmx7JOQPzvJzq6dDZFPvgOEEFgE2HWNemf4cDgpJS9/W8oJPwtuxzYMgy+++prVT15FdmpC\nh2Ms+HYDf5i/ltWrV9PS0rLf4Xa7EUKg6zqapu15bP08Li6OWbNmYerlAgUHNwKUK0PRV7n/vvu4\n8667kFKSkJBAQoKD2efN5oE//rHNayoqKnjt1VdYe8dP9ntvw64Gnly8lg/WVvDOtTPJTY5n1qML\n+PSHHZhC/l6JxBswMGkauiaw6BqaEAQMSZY54p1YERMUZm/Y9177egM7PRrXXHsdAGvXriU1MS4i\nUQbISIpjW9kWzjxlJvE2Cw67lThb0O8dbzVhM+tICYaUBAz546Px4+uN26t56h9P8PJrbxAX1/EP\nnSIClCtD0Vfw+/2cduqp6LpOamoqKSkpfPX118y553dcf82VNDU1s/izL7jimt9gNpsZMnQo06ZN\no6Bg7+xybrcbh81CmsMGBK3Me975nr8vWkujy8v4/DRWbq9l2p/e4bC8ZL7YuIuXz5zIicU/ZpD1\n+AO4/AE8foNGjw9Dwnc76rj9w9VR/9x2XaMhjDA3OD3c9Oo3vPrmfMzm4A7Gzz//nCNHRF7UYdzg\nPDbPva5b8/P6/Pzi4XeYMfVo3n7nf2RmtruzVxEBgoMkUb7i4EfTND5etIiHH7wPs9lMbW0d8VOP\n5MSZx2IymUhJSeakE4/niYcly1eu4j+vv8IDD8zhpZdexm63U1hYiMlkwmQyUV3XyPh73wQh2Vrd\nTLzFxCMzRzOrOBuzrrFyVwNLKur4bmcDRxVmcGRB2l5zsZp0rKE8BVkhgQdw9UAeZbum8cLna5k8\nOIfc5HhOmPMmcVYT9U4vU46ZyeTJP4b5ffHpIiYN6d2E+xaziWdvPJW7XviE4UMHc931N3DDr2/E\n4XD06jwOKoSAGEvj2qEwCyGeAU4GKqWUh4XO3UMwW5JBcGvhxbu3Ie5zbQBYGXq5VUoZvdUfRY+i\naRoXXXghpWXbuO+u28O2MZlM/PS0k/jpaSchpeScCy7jvHPPobmlhW3byjEMAyEEg9ISmD00B7+U\njJuawqT8NPRWt44js5IYmZXEzzsxvyyHFZcv+sI8NcnOizvrufM/X3HOxMHUN7RwTnYyCwMGh40e\ns1fbzz//nBtuPSXqc+gIIQR3XjCNn80YyR0vvE3x44/yyKN/46yzz+71uRwsxJorQ0jZfhUnIcQU\noBl4rpUwJ0opG0PPrwWGSymvDHNts5Sy0z/lJSUlcsmSJR03VPQoW7ZsoaSkhG0blnXJnymlpGTC\nNE5MMbj96PbzZHSl76Q5b/HpqH6kmqN74/daVSP3bK3GkPCz3FRuzU3mvdpm/uLUGH3YCBobGqip\nq2PTtq3Uv3n7AU+a/+onK3ni41I++fzrAzqPA4EQYmlHuSs6YnSKQ753zH57QsKS88YX3R4vEjr8\nRoerkL1blEPE00YdP0XfpqioiJJx43hr/v8475wzOn39a2+8xbp163nxiog3PEWMEIJkm4WNbh9H\nRFmYj02JJ17XODLRTnLIhTI9OR630Yx980ocusYr1Y2kDs0/4KIMUJyXRn398gM9jb6LEFGtYBIN\nujwbIcR9QohtwPnA79toZhNCLBFCfCWE2H9ZXhHznHvuubz53/91+rotW8q47Be/5ImTxtIvgjC5\nrpARb2OLK3wERXdIMenMSnXsEWUAiyY4LT2B41MdHJkUxzYDTigpjvrYXSE53k6DSt7fZQQgdC2i\no7fo8khSytullAXAv4Gr22jWL2T2zwYeEkIMbKs/IcTlIRFfUlVV1dVpKaJMv8JCqqpqOnVNZWUV\nk6ccy89G9eOsEfk9NDPITrCzzePrsf7bY2fAYOqo/gdk7H3ZVd+M06VSkXaZULhcJEdvEY2fgBeB\nsPe5rfKSbiZYSmVsuHahNk9KKUuklCUZGRlRmJYiGiQkJNDU3Nxxw1Ycc9zJTMiIZ86MET00qyD5\niTa2e/09OkY4St1emj0+xg7K6fWx92Xj9hrOuu91Hn708QM9lT5M0JURydFbdGkkIUTre7hTgf0y\n9AshUoQQ1tDzdGAysKYr4ykOHImJiTQ2Rp7FbfWadWzcXMrjJ46OKH1nd8hz2KjqgciMjnijqomS\nwXmYIy811CO8/eVajr7pWe64+37OO6/dspyKDhBCRHT0FpGEy+1XIRuYJYQYQjBcrgy4MtR2T4Vs\nYBjwDyGEQfAHYI6UUglzH6OgoIDy7RV4PB6sVmuH7V985Q3c/gCDH3uPBIuJJLuFFLuVVLuF9DgL\n6TYzKTYzDouJeItOvNlEUUo8Y7LD56Zoj2yHleYDsJX2K5ePs8YfeP/ynNe+5rEnnuSss9pN7avo\nCEFnKpj0CpFEZYT7KX66jbZ7KmRLKb8ARnZrdooDTnx8PKNGjWTB+x9y2imzOmx/3123c/stN1C2\ntZzy7dspL99Bxc6d7NpVSVV1DSuqa2hqbMDtdOH1ePB6PWzbUUnp9SeSbLN0am5Z8TYORALOCsNg\nSgz4l80mnZycA+9OORiItagMtfNP0SE3/+ZmHvjTAxEJM0BcXBzDhg5m2NDBEbUvKCjm8601nDS4\ncyKT7bDiChiduqa77PD4glvJB+f16rjhsJh0vN7oR6Ucaggh1JZsRd9j4qRJbNq8pcf6HzZyJB+X\nVXRamDPjbbh8vbv490Z1E6MH5mK1HJg/nYqaRlrcPj5dWcqWimolzNGiF/3HkRBbPxOKmCQxMZGm\nps5FZnSGM356Ku9t2tXp6zLjrTh9AQyj96zmz1o8zCxpM+qzRymvamDMVX9n1p2v8+9vK/nVr29h\n4sSJB2QuBxuxFi6nLGZFh9jtdtxuN1LKHlmZvuD8s7n2hpupdXlJtUfuZ463mDBpgh1eP3md9E93\nle0Spo3uWhWWv8//mq/XlZMUbyPZYSM1wY7FpNPi9uHy+nF5fLh3P/r8eHx+PN5A8NHnZ+OOeq6+\n9nruvOvuKH+qQxwROmIIJcyKDtE0DYvFgsfjwWazdXxBJ4mLiyMrLYVPy6o5bWhup65NjbOyye3r\nFWGu8vqpanTy+uLVvPn5WqSUSIJ5O3bnUZZIpBF6TfCRULv/LF7NtOH51FQ30ujy0uz24gsYWM2m\nYAY9c+gw6djNJqxmjSSbCZvDitPr48u15dx622+j9nmWLl1KaWnpniyAQgjy8vIYPHgwdrs9auP0\nCWLMlaGEWRERDoeD/7vzD/zpD3f2iNU8YtRoPior67QwZzpsbHH7mBL1Ge3PK5WNSGDb9upQXOuP\nZe+DEVc/nhP8+J4mQCC44Khh/PVnR6F3IQJg3rcb2aalRfTDWFdXx9y5c5kwYQLFxcWkpaWxc+dO\namtr8Xq9VFdXs2bNGq6//npKBuSQneTAbxgYEsrrWti4sxq7zcq7C97nyCOP7PRc+yIxpstKmBWR\nsWDBAq688gqef/FVLjz/nKj3f+YZp3Hvb8OnF22PnAQ75fUtUZ9POL50erj55BLuP3tSr4zXmk83\n7GLKMR0nkvJ4PPz05FmY6rbz3KMBNu+qR9N1hDTISnZgMemkxFkZkGzj3StmcPzQ/RdcpZTcv3A1\nr7784iEhzEIIhB5byqyEWRERJSUlPPDAH/nVL6/i/HPPRNeju+vt/HPP4JdX30BVi4eM+I43suwm\nP8FGaWV9VOfSFuUGTBt2YMLkFm+o5G+/n95uG8MwuPhns0lzV/HyZUejaYKAYVDZ5CE70RbxnY4Q\ngsKUOL7ftCkaU+8bRNFkFkLowBJgu5TyZCFEEfAykAp8B1wgpWw3nEZFZSgiZsaMGSSnpPDSq29E\nvW+bzUZ2eiqfba3u1HV5Dhs1vRCVUe/3U+N0M2lQ71YsAahrcbNxRw3jxo1rt91vb7mZsuVfM/ec\nErRQBIGuaeQk2Tvtfpo1PI93F35AR/naDxq0CI/IuA5Y2+r1A8BfpZTFQB1waSTTUSgiQgjBI488\nyo233sG2bduj3v/IsWP5sLRzwpzlsNLSC1/jN6ubKc5OIaETUSPR4vMfdjBh3FgslrbHfuJvjzPv\nxbnMu3Ai9ijEWHv8BskJjl7ND3EgiVauDCFEPnAS8FTotQBmAK+HmswFOkyBrIRZ0SmOOOIIrr/u\nes7/+ZX4/dHd3HHuWT9lYSfjmbPibbh6waj7uNHFzFGFPT9QGBb/sJMpxx7f5vsLFizg7t/9lvk/\nP5J0R3SiZoxQpMkhQXClNrKjYx4CbiaYRwggDaiXUu7+YykHOvSHKWFWdJqbb7mFlNR0Zp5yNu9/\n8DFPP/sCSVlF+Hzdy4189pk/obLFxc7m/XML+w2Dr8treH/TTt5YU86/vi/l0a838O6GHTR6ez4n\n81YJ04Z1LmIkWizeWMW0aeH9y2vXruXC2efy8vkTGJieELUx568uZ+qUo6PWX6wjdBHRQTCZ25JW\nx+V7+hBid23Upa27DjNchz95avFP0Wl0Xec/8+Zx7z338MeHniApMYnGxiYaGhpJT0/ruIM2uPPe\nB7AKjSEP/48EswlDytABfmnglZAsBGYhsABmEbQsejpfRovfoLrFzeTi3hfmJpeXtVt3ccQRR+z3\nXk1NDaeccDwPnDCcowZkRnXcZo+f/KIDc4dwQIjcY1PdTs2/ycCpQohZgA1IJGhBJwshTCGrOR/Y\nr3D1vihhVnQJXde5484797zu37+QpubmiIXZ7/dTW1tHTW0dNTW1/Oet//KvfzxFSUo8a2qauCvO\ngkmAGTAJwVUNTm6QkpFS0voe2w9cBHgNA0sPZQibX9NEYUYSyZ2IFokWX2zYwbjRI/eLX3a5XJw2\n6wROH5LKhUcMiPq4G+rcjDl+SNT7jUmilGtZSnkbcFuwSzENuElKeb4Q4jXgTIKRGRcBb3XUV0TC\nLIR4Bthtpu+ulH0PcBpBX0olcPHuiiX7XHsR8H+hl/dKKedGMqaib5GQkBBRPo13FyzktNNn45cS\nsxCYdQ2brmHXdf46pggp4f8aXQwz7x2O5zQk4VIcmQArUOb2URzXM8L5QYOT4yccmPzLi9fvYMox\nx+11TkrJ+WefSSEN3HfC+B4Z98uyWq48lPJw9Owa5y3Ay0KIe4HvaSNtcmsitZifBR4Dnmt17k9S\nyt8BCCGuJViQ9crWFwkhUgkm1i8h6FdZKoR4W0pZF+G4ij6CzWbD7fa0+b5hGGzZUsZfH/07J+al\n87ex/dHCWClbWzw0+PeuSuKRkgDBINBwJAjBJre3x4R5i4Trhh6Y+OVPN1dz17V7+5f/8Ic/8P3X\nn7Pm5hP3hMVFm9KqeoYMOUQsZoh6giIp5SKC5fR2l9bb3xfVDhHd+0kpFwO1+5xrXZY3nvAO7ZnA\nQillbUiMFwIndGaCir6B6MDkGDp0LCNGTWDjN98wOz81rCgD5MdZ8BsGFf4f/cb1hsQqRJtf1mRN\nY6u7Z9J/ug2DKqeHo4b0vn/Z6fGxfPMOJk0K7jR0Op1cftkl3H777RzVPx1LD5a2ykxyUFHRoSv0\n4EFEePQS3fIxCyHuAy4EGoAzuypdAAAgAElEQVRwy8Z5wLZWr9sMFQmtbl4O0K9fv+5MSxEjrF33\nA81NzdTW11O6vYIVM8eSaG7/K6cJwYCEOL7w+TjTFLSA62VQmNuK30oFynuoWva7Nc3kpMSTntD7\nSX2+2rSTnOwsNm/ejMfj4eKfzWZUhoXLpg6nojryOoxdYUh2Mps2bTokrGYhom8xd5durZZIKW+X\nUhYA/wauDtMk4lARVSW779N6l9gTT/6LkYcfyfHHzmL2Wefzk36ZHYrybkYlx7PCt7fFbGnnDyfV\nMNjZQwnz36tr4djDDkx0QprDRnGajXNOmcnJM4/l11MKee4X0ynOSWFXk6tHxxZAIND7hW4PGJqI\n7OglohWV8SLwDkF/cmvKCRZy3U0+Ib+L4uBi+IjhnH/BZWRkpGOxWVm1eh2GhKPTE7FpGnYM7l69\nFYdJI07XcZg0Esw6Dl0n0Wwi0ayTaDKRZNEYmWhn6a4fbYYWKan3B7jBpGOVcGMgQOuf7hQp2ebv\nmd0QmxFcMfzA+JdH98tg/rX7bywpykikKkysdzQpq22msPDQCZeLtQ2OXRZmIUSxlHJD6OWpwLow\nzd4D7hdCpIReH08onERxcHHVVb9k7tznmF61iwDBX2Cv3YKnvoUGYJcMLuK5pcQTeu6REq+U+EKP\nfhkMfwNwaIJgvAVMsZjISYqjXkoeaHazDvYS5mSgqQdimb2Gwa4WN0cfAP9yewzOTqG2pWeFeXhm\nIp9++imjRo3q0XFigsh39fUakYbLvUTQ8k0XQpQTtIxnCSGGEAyXKyMUkSGEKAGulFJeJqWsDYXV\nfRvq6m4pZe1+Ayj6PBMmTKBk+HCKt25mYjdzNdQbkjPqW/AbBiZNwyTEnvC5JF3Ha+zttkgCnP7o\nC/PCuhbSE+xkJ8dHve/uMCgrCafXT8AwupTbORKO6pfI6hXLeqTvWCTGdDkyYZZSnhfmdNhYPCnl\nEuCyVq+fAZ7p0uwUfYpLr7mG1267hYl0TySTNUG8JljpNxhr2Vt4TAL2XeZLAtxG9P2hC+qaOWZk\n/6j3211sFhNmXaPO6Y1abox90YTA7e5ZqzymiLHFP7XzTxE1zjvvPG6+4QbqbTrJ3fyiDzSb+cbr\nZ+w+1rdZCHYnsn1OCJabdLyGJGAEmLCsLLSyHEzAs9vrvOdRyr1fszvQI1QiKnRyz3Mkt6TElrUM\n8LcPVpBks5DUg5nujhmczV+f/7DH+o8pYjAqQwmzImokJSVx8qxZfLDgHc60mbvV11AN1oZxT5gR\neyzm73Sd0+MsjLGauaqygZdGFxJn0hCIUDmnULknfkwgpoUirne/L0Lx0a3fE6H3jv5iPVM6Weqq\npzEMg/ve/JY/nDIGsx59N4ZhGHxfXse7a7dTun0Hl118IevXrObm393JKaecEvXxYoYY82UoYVZE\nlV9cfTVXfvgBZ8hAt/IP5At4029wTX0LEoEUQSu2zG+wTcAyTaM+4GdmfAJ5Jp04TWDSBIPio3Nr\nX+nx4QoYTB+WH5X+osWc+Uux6oLzx3WtUvduDMNg2fY6Fq7fyTdl1WyubaGq2UOd041F1xickcSl\n4wcyqmYVPn8tny1efFALs4ixPJtKmBVRZerUqTSbzVxe14xN7HYJ/CjQe9wIe06JPa4Dn5RomsAk\nBE0BAz+SI+Lte4Lt9VBPugCdoB86N2Q1Juk6m50ehkdpI8g39S1kJsSh9dDiWlcwDIOH31vG384Y\njylCa9kwDFbtaODt1eUs317HxuoWqpvd1DrdmDWNwRmJjM1JYcbhGQzLSGB4ZtJ+pb1eWGbio9LN\nPfGRYgdlMSsOZjRN46hp03j19Te4PDlur52sez/+uIl7t+vghUYXQ1MSmJmfDsC9323ijHgbqaaO\nRSjVpLPN1W4ZtU7xXk0z44uzotZfNLj1lS/IiLfy01EF+723W4DfX7+Db8qq2djgpcrpp66xOXjn\nIgTnjsjl0rFpDM9MZFhGIpkdLBw2un08/OVG5m+qoXBEW5lKDgJ6ebt1JChhVkSdW277LV8vXMhl\nSZZOuTPmO73MHpTDeYOCft3nNuzgc7eHUxwdW8FpukaFOzrbspv8ARbuqufba0+MSn/RwOv38/Si\n1Tz/s0ms2VXP++t28HVZDRvrPVQ5/dQ2NaPrOoMHDeTwsVP4xeiRjBg+hBHDhtLQ2Mj4ycfy91PH\ndmrMlbsaeG59DU89+xxHHXVUD32yA49AIHrAX98dlDDHIN999x23/fp6dE1D13XMViv3P/gXhg4d\neqCnFhFjx46lxuOlyTCT2Imy8H4psbeqvj06PZGlO2s5xdHxtZmaYFeU8mW8s6uBnCQHw/O6nvQ/\nGnj9ft5bsY13lm3mnWVl+NA55/mvEZpg8KCBjBk9mUtGj2TE8KGMGDaErKzMsD+EDY2NYXrvmLQ4\nC1azieOOO67jxn0d5cpQdERlZSXbf1jLXRMHEjAkL6//gddefZXf/f73B3pqESGEwKRrnY5m9kuJ\nrZWQj0118NKOyPYjpQvY5O1+LLMnYPB4WTWXnDC62311Br/f4IM1W/nvd6V8u6WSirpmappcpDls\nFKUlsKuhhRuvv5obrrmS7OysTt2JSCm7dKeeEW+lqvYQyNC7O0wnhlDCHIMUFxfT6AtwwoCgj1Mi\nefrDhdBHhBkgPyubClctyZ24RfRJsLdKZTkixUGkspCiazR1U5illPx+w07McRb+77SeSUDfmkfe\nW8ZLX/5ARV0LVU1OUuxWSvpncObIPA4vSOPwglSS7RZO++cijpxQwh/vv7NL40gpu2QRBi+LLcHq\nGUTMhWUoYY5BCgsLqWxoxu0PYDPpTMpL4/IPFuP3+zGZ+sZ/2WGjRvLJR+/jC5Oq0yoEQ637xzkH\npMTWSsiHpzio8/owDKPD6IhUTXR7W/bDZdW8X93I93PO7/FojO9KK7n91S/47fGjKCkMinBamFC/\n178v5YstVWzZ+HGXx5Kya2tbLn8As8nEu+++i8vlwuVy4XQ6kVKSkpJCWloaqamppKWlkZWVhdXa\n+6W3okaM/QD1jb/yQwyTyURhbjab61sYnp5Imt1CXpKDFStWcPjhhx/o6UVEel4+jzW6eMu/vxVb\n5/Lyp/REpuwTlhWQElsriznDbsGqaaz1BRhhbV8oU3QNd4RpKt1+g7UtLlY3udnY4qHM6aHM5WWX\nz09uagJnPfI/zHqw7JXVbMJq1rGZdexmEzZL8DErOY5bTm6rJmfHXP70x1w2eQi3zRzZZpvqZjdX\nvPwVDz74AMnJyV0eq6uU1TmprK3nkT/cjt1qJs5mxm41IRDUNbupbWihtsHJjqpaxpWU8O6Chb0+\nx6igXBmKSCkuHsSmumaGpycCMCknicWLF/cZYU5OSebWo4by+6nD9ntv+txP2dDk3E+Y/RLi9qnK\nMSQ1gS9cbkaEsbBbk6LtLczzd9bzQXUj9b4AjX6Del+AJp8fZyCAR0IckKZpZApBtmHQJAT9kuO4\ndHg+3oCBJ3S4AxK3P4Db5cPd7KHRb+AOGPxty05mjixkTGHnc4d/8UMFP+yo5d3Lp7bb7pevfcOQ\nYcO47JILOj1Ga2QbBQY6osnjIy8zmXcfurzddp8s/YE75n7RpTFiAwF6z1WD6QpKmGOU4mEj2Ljs\nx1wFU7IT+eeLL3Ddddf1Cb/f8OEjeOXtl8K+l5dop6Ju/8KtAfaOygA4PC2BFZs6LvKarAs8RlCA\nnt1azZwNO5is66QYBgVSkg6kEUwXmkroi2/86PpYr2ucP7yAK8Z0vKOu3u1jxDNVTL7rVUyaFroL\nFnvuhgXBwOy2/pc8/gDXTR9BZjubYcpqm3l31Ta2bX6vw/l0RHJSIi6Pl+FPfMKMfAe/OWoohRHk\nAPFHmL1O0zQMo2fyYfcaMfY31aEwt1Eh+0/AKYAX2AT8XEpZH+baUqAJCAB+KWXX7/0OMQYPG843\nny/Y8/ong3P46/JveOH557ngwgsP4MwiY9SoUdxRFb78UX6ijW/DZIMLSLDvs5lkVKqD90s7tmbi\nhcAAntsWFOVbgNGdqMAhDEkgAstSSsk585cwICOR+VdMByGQEgwpkVJiyOBirdGBu7sorf0YwLhQ\ntZf09O6H7OXkZFO2/nv++7/3efrZFzj2xW/Y8KtwleD2xmzS8Ufwbxis+hX9tKu9hgBiaIcnRGYx\nP8v+FbIXArdJKf1CiAcIJr+/pY3rp0spq7s1y0OQ4uJiXmr8seq0SdN4eMoQzv31DQwfMYJx48Yd\nwNl1TF5eHjvrwwtzv0Q7T/kNflLdxAxdcG1KUKQMIH4fYR6e4qA+InEQ2ATc/8MOrgc6G+ymSSMi\nYfYbkq+219Dyl9lYenAhNi3eitcfwOl0EhcX1+3+MjMzuOSi8xk8aCBnn3dRRNfEm3V8ESyoakJg\ndPRLFOvEmMXc4c9EGxWy35dS7s5W/hXBghWKKFJcXMymmr03BpTkpHD3EYWccuwMzvrJqaxfv/4A\nza5jkpKScHl9uMMs/v3i8CLev+BoZgzIZFkoxM2QwdSbln0sl8FJ8TR5/TR38Ie/2esnIOEKOlkn\nPoSQQdHtiICUaEL0qCgDaJogwWZh3foNHTfuVL9a+KKbYYgzm/CH+f8L22ef9mSIoMUcydFLRGOk\nS4D/tfGeBN4XQiwNVcFWREhBQQG1LU6avXtX65g9vIBlFx7FyLrNTB4/jqOPKOGRRx6JuVLzO3fu\nJDnevleUxW7MusbhOSkUpcSjh/6i/QS/jPuGqVl1jZx4G1+2kwfDaxj8qqqJEzWN9pfT2kYDfBEI\ns9G1kOBO0+zx4Q8YBCIQxs4ghCBSZU6w6PgidGX0aYt5T67XCI6OuhLCJoT4RgixXAixWghxV+h8\nkRDiayHEBiHEK0KIdpNpd+tnXwhxO8G/qX+30WSylLJCCJEJLBRCrAtZ4OH6uhy4HKBfv37dmdZB\ngaZpDOxXwKa6FkZnJe31XrzZxI3jB3L12P58WFbFvGce4Y7f3kZeTjaTp0xh8tTpTJo0iaKiogMW\n97x69WqGZrWf+MZhMeEOCbFftm0ljEpP5Juqeo5rI6XnddXNpEnJ7G6Ig07kFnNv3PQ+9sk6cnKy\nGT8+ulE4QohQWYD9cfv8LCqtZtGmXSzdUc/WFl9En7WL+1diiKhGZXiAGVLKZiGEGfhMCPE/4NfA\nX6WULwsh/g5cCjzRVifdKcZ6EcFFwWNkG/E4UsqK0GOlEGIewbvMsMIspXwSeBKgpKSkT98YRYvB\ngwezoa5qP2HejdWkM2tgNrMGZuObPoyVVY18tWUJ85d8yv9V1LKjrpE7f/87bv/9vsXLe57ly5cz\nPLX97GUluSk8ICXrPX5qDaPNUNLDUx38Z2f4PYDPNbSw3u3lIYLi2lUiFWZdCDQhmP7w+3x83f4V\nrKNBo8vLAx+s4sV/z41635qmIQ3J19tq+GDjLr4ur6WsxUeN00Ndk5O0JAeHFecxaerhXD4ol/Ej\nOq6U7fH6+vjmEqL2yxLSwt1hRObQIYEZwOzQ+bnAnURbmIUQJxBc7JsqpXS20SYe0KSUTaHnxwN3\nd2W8Q5UhI0ex4dO3I2pr1jUOz07m8Oxkfhk6t2xXPT9/+qk2hVlKyVNPPUVSUhJFRUUUFRWRlpYW\nlXC8Re8v4Kyc8D8ouxmTnYwnEOCyHXUkWM0MSAwfqTAixcFTYea03efn6QYXNwIp+1/WKYKujI4t\n7jizzpc/m8K4uYvw+w1MEaQk7SyPLF5PdnYOJ8+KvvBX7NhBfVMTp7z0FcMG5DDu8KGcUZzHyEF5\nDB+QjSOu84UGPD5/3xZmOlVaKl0IsaTV6ydDRuWPfQmhA0uBQcDjBCPX6luty5UDee0NEkm4XLgK\n2bcRrC2/MPRH/JWU8kohRC7wlJRyFpAFzAu9bwJelFIuCDOEog2GDhvOuwve6PL1ozOTaGlq4t13\n3+W7pUsp3fgDO3dV8tY776LrOps3b+bmG65jSlEOWxtdlNY04DcMCvNyg0JdPJiiQcX079+fgoIC\n8vPzyczM7HC7smEYfPrFlzx66ZR229lMOk+cPI4r5i/l3iMGc8aA7LDtRqQ4qPfunTnujSYXD9S1\nkAN0LplleHSC7pRIGJTiwKJr7GxykR/lmoANLi8PfrCKV199Pqr97qaxqYl+2amsn3dn1Pr0ePu+\nMHciV0Z1R2G/UsoAMEYIkQzMA/bfZdWBp79DYe5khewKYFbo+WY6H7WkaMXRRx/NjdfsotI5iMy4\nzn/xhRDMLMrgrNNP5+ej+jEqyc7TH6zA7/ej6zpr1qwhy2Hn/olF9E8KCky928fWRielDY1sXbOY\nH775kA9dfrY3udhe30SDy01uRjp5OTkUFBaS338ABYWFe4Q7Pz8fv9+PzaSTFUEF5zOG5aEBl8//\njvlbq3hmyoj9hD87zooQgo1ePy2GwV+aPWwPGJw2JJfVG3dCoPsLTyaCGyoixWbS2dXkjrowP7Ro\nHXl5uZx4/LFR7Xc3eg/scAsKc89U6+4VhOiRLdlSynohxCJgIpAshDCFrOZ8oN3VerXzL4YZMGAA\nF1x8EXd//h6PTR/epT5uKynimtH9GJwadBNc/+HKPQuCkyZN4oSzzmPaC88zMiOJm8YUMLVfOsm2\nJEZlhndDuP0BKprdQaFuKmP7N+tZvTjA+y4/FU0uyuubqG1xUpyWGPEcfzosj9HZSZz3xrcMef1z\n+jvsTM9JYWZ+OskWMz7DIMli4sqaJvzAJYcP4MaJg3h++VbWbdzVpX+XfYk0KmM38WYTOxudBPcT\nRod6p5e/fLSKeW+E3zEZDTShdXmLdlscDK6MaC3+CSEyAF9IlO3AscADwMfAmcDLwEXAW+31o4Q5\nxrnj7nsZM+IN/rVyKz8f2floldxW236llCTF2diyZQuDBg0iPT2dhx59jDl/epBnn32W6+/6Hd+f\nn95ufzaTzoDkeAYkt20p/lDbxKTnPsFvGJgijP0ckOLgi0umsaSilkVl1by7cRfP/LAdX8gaHpSW\nwOzDCrhwdCFJoQrcXiPQrQW/1uh0TpgdFhNVzZ6OG3aCvy5aS79+BRx3zHTcbjdv/3cBCxZ+xC03\nXsOQwcVRGUPXdYxoC3Nft5ghmmElOcDckJ9ZA16VUv5XCLEGeFkIcS/wPW14HXajhDnGSU5O5oNP\nPmXa5EnEm3XOHtrumkG7CCH4zfhBnDLzeF5/ez7Dhg3jheef5+knHueYE2dRVlNPpdPTJbdJawan\nJhBnMbGqspEx2ZFnRdM1wYT8NCbkp3HL5CEdtvcFZFSFuTOujGSbhZ2NrqiMLaXks02VPPjBSvJz\n88jOLKSmuYU0swkhJS6Xi5ee+2dUxuqJzSCGlGhh4tX7DBHGKEeClHIFYZY9Qq7diPc+KWHuAwwa\nNIj3PlrEsVOPRhdwxpCui/N144pIs21j2uRJZGdlEedp4ZeH5bL47X9jM+lsqmvutjAD5DrsfL61\nulPC3FkC0qAsEOBfmkaGYXA00H4cSNsEfcyRK1aqvevCXOf08Mp3pfxvdTlrttezq9GJAEbHWTnC\n1cDIZCsjchJI1DVerWvhP0u/79I44dB1PequjIOCPpgrQxEDjBgxgncXfsgZp5zMe9vqmDN5MKn2\ndjcPtcnPRhQwLjuZrQ1Oji8ahhCCM4fm8dC0YWhRshxmD8/jL19t4BfjBmDpoUKX104YhNMXYHNt\nMy9triJdSiZ2sS8TnXNlpNstVDW7O2xnGAYfb9jJWyu28eXmKrZWN9Hg9VFgtTA+3srlcWZGp2WQ\nZ9bDhimOsJl5fHv0dnVqmoi6K+OgIMZ2yChh7kOMHTuWFevW89ubf8OEF1/kz1OGcGpxTpf6GpaW\nwLC0hL3ORUuUAa4rGcTj35fy5HdbuHr8wKj125r0OBsPHh8M/Mme8xZZga4Ljg54OuHKyLCbWdGw\nfzrSlRV1vPZdKYs37mJLZRPVLW7smmBkvI1pNhOjshMZbjNjj9BCK7aaafJ6qa6uiUqmOV03KYt5\nX1SifEV3cTgcPPK3Jzh79vlcesH5vLG5igePHkJGFNwP0ebP00Zw6f++Q0q45oieEWcIWqUtAYPO\np6z/kc64MmrdXnY0u1i9s57T//kx2+taKK9pptnrJyAlw+JsjLOZODvZzmE5iaR3w/9q0QT9bBbe\nmDefK35xcZf72Y2mCSXM+6ES5SuixFFHHcWyNeu44/9uZ+LTT3H3pIGcN7wgqlZvdzmlOIe34iZy\n5pvfsLm+hXunDSfe0jNfuUy7lYc9Pm41jC4tCIbbkl3v9vLR1mo+L69hZVUjFY1uat0eXAGDTF2j\nwKSjbaykBMn3Li8vFaUz1GqOeiGDMXYL73/4cVSEWWiij2eC6yFi6O8GlDD3aex2O3/88184+7zZ\n/OoXl/HU2iX8cfIgxud0d4Ny9JiUl8Zn50/hJ/O+4eWVW3nwuFHMHlkQVfHSNI3lVx9P4YP/ZTvQ\n2aBCF8Fo/3VVDZzw6hdsb3RR6/LgDBik6xoDzCaGCDhB1yhy2MjXBKZ95v+ax0+930DYuve5Nrh9\n3LOrkanxFgbbzBRbzYy06Lz8/fJu9bsbUw8s/vV5C1wItfiniD4lJSV8ufQ7nn/uOc6/+SaOy0/l\n0elDY8Z6LkqOZ/nPp/Pi6m3c8sEqnvq+lMdnjWFYekLUBNphMRFv1mnaJ01qa5zAcmANUArU6TpN\nhoFTSgwgweNlYF0zx2qCongrBbqGOcL55Zp0Vrm8TIpgt2O7n0MXLHN6qE1Oxd/kpG57PT7DIN7W\n8UJjJGiaFvXFP6fLS1xc7xeLjSox8reyGyXMBwmapnHRxRdz+hlnkJOVyb1HDiTF1rWojZ5i9ogC\nTh+SwyXvfs/R/1qETdeYUJDOtMI0xuemUuf2sqaqkQ11TmYUpnPWiPxO/bjYzSaavX6agRXAaqAM\nqA8JsEtKUoWgUNMYEQhQGAiQD1iA64F/JMSR18WkRBm6Rrmv+7mTc8wmrs5M5LWWZsrLN2AymVi1\nag3VtbUdXxwBwXC5qHS1hyanm8RUJczRRAnzQUZCQgKCYHrKWMRmMvHiqeODiY7Ka/jP+gpeXFnO\nX77ciNWkkxVnJddh5aaFK3lz/U6e+8k4zG2E2+1sdvPBpl18WV7L6soGqlvcPEwwQXiqEPTXNEYF\nAvQLBCgguCXLLCXsk/z9TSDfZOqyKAPYAVeUFO/S1Hg+3FrLmedcxJtv/JvDDuvadvxwBDeYRFeZ\nm5xe0vtHvgU/5uijNf8UfYyAYaDHWPjPvmiaxtR+GUztFz6Wotbl5YjnP+HG91dwRF4KK3c18kNN\nI9sa3FQ3u2nw+PBJSYqmkSUEmYEAuUAlMAcoCiPAbVGjaWRHXHApPHagJkqVonUh+HNOEmcseJ95\nb73DT087KSr9Auha9H3MTS4vRQkJHTeMWaK38y9aKGGOEaSU7Nixg02bNu05aqorcbY0c+HFlzJj\nxoxO9Ca4ZtF6+sXp5MZbyXPYyU2wkeuwkRFnjRnfc3uk2i3MP2MiE579mLnfbaFI10mVkkLDYAyQ\nTnCXn9Yq9tgNvAE8A9zTibGahcDRzR8yGxJXFKsr5VtM3JyVxCUXX84xZWtJTIyORdoTPuYmp5eE\nPi3M9D1hFkI8Q7BSSaWU8rDQuT8BpwBegkmgfy6lrA9z7QnAwwSjkZ6SUs6J4tz7PJs3b+bJf/yd\nr774jBWrVqNrGsX9cxiQn86A3BSGpThYV7+Tvz32cKeE+aNFi1i3bh3btm1jXelmPtxaRvn67Wzf\nuZPGZic5KYnkJsZx6ZAszh3W9e3dPc2wtATGZqVgraznuAisXxuQpmkEOlliqgXI7+bfpRXwRlnw\nTk+y80GzhxNmncEXny2MSp89kSujscUTtR+OA0ZfE2bgWeAx4LlW5xYCt0kp/UKIBwgmzr+l9UWh\n7EqPA8cRzNj/rRDibSnlmmhMvK9iGAYLFizg8Ucf4ptvvuWi0ybx2wuPZGTxWWSl75/poaKyjtFn\n3kMgEIg4l+7EiROZODH85mS3201FRQXz5s3jtacfj2lhBrh1UjEXvPkNxxBZ5WCXEDiBeiDS5agW\nIKmbf5gBKaPu1xdCcG92IqcuW85jTzzF1Vdd1u0+dV2nK8pc29DM8g3bWbNpBz9sraRsRw07a5po\naHGzq6aRc5v33wXZt+hjwiylXCyE6L/PufdbvfyKYJ7RfTkC2BjKqoQQ4mXgNILRSocctbW1PPPM\nMzzx+KOkOCxcdfbRvHrP6dg7iJzIzUwhKy2JZcuWMW7cuG7Pw2azMWDAAE466SSe+FPs38AcU5iJ\nH2gkMqE9LBDgU03jUsMgT9d5JAJL2yklCd0UVQ9QEwjwWm0LASQBghW1A4CBxJDgl3LPOYnEL8Eb\nOu+TEp8En5T4CT73y2CbBAE33nQbp592Erm5XduCv5t9c2V4vX7WbNnByo0VrC/dxebtVWyvaqCu\n0UWT002Ly0OLy4PfHyA1KZ6cjGTys1Lpn5vBUYcXk5uZwt9f/+yAFf2NGrGly1HxMV8CvBLmfB6w\nrdXrcmBCW50crFWyV61axV/+/CfmzZvHSVNG88J9F3DEyKJOxe/OOGIIH3zwQVSEeTcDBgygvLYB\nb8DosSRD0eDhJRtJ0TSSI3RPFAPFhoEL+FMggBOI6+Aat5QkddPHXGpItngDvBGQaEKgIdBEMP9I\n8Ag+1zWxp6CrJsCiaZg1DbMuiNc0LJrAomuYNRF6L9jmzU07ueOeB/jnEw91a56C4F1b7sxbaXF5\ncLq9OOJsZKUmkp+VQr/cNI6ZkEtuRjJ5mcEjNyOZtOT4Nr+z364uo6IieomWep2DbYOJEOJ2gtFJ\n/w73dphzbd5DHWxVsrdt28btt93Ce+8t4LrzZ7D2rbvJ7ERVj9YcM2EIT7z1P2655ZaOG0eIxWIh\nPyuD0gbnnuomsci/VpRR0kmfMQSjJBxCsEZK2i3QRnDRMLmbFrM0JNeMGcC9Rw7tVj9tUZwcz+/+\n+w50U5hNJhNNTg8LnoCnuu0AACAASURBVLie3IxkctKTMJu7lyciLyORbVvLutXHAacP+pjDIoS4\niOCi4DEyfPxNOVDQ6nWHda4OBpqbm5kz536e+NvfuPKsKfzw33tIiLd3fGE7TC0ZwoW/fQa3243N\nFr1KEcWDBrGxrjlmhXlLfQsVTS7O7eL1aZrGD4FAh8LsiYLFnCAEtZ62dx12l1lFWfzq45UsW76S\nMaNHdrkfk9mMI87KxFEDoja3/KxUnn56PukZmfTr1w+n00lBQQFjx44lOzt8gd3Y4yAQ5lC0xS3A\nVCmls41m3wLFQogiYDtwLjC7S7PsI7z33ntcdsnFTBk3kKWv3E6/nOjUg0tOjGNEcQFffvkl06dP\nj0qfAAOHDmPj2k+j1l+0+fWHKynWdewRxiPvS4aURGLHeYGUbgpzohbMOtdT2E06Jw/M4Y675/DW\nG+FuUCND64EkRqdMHYXH62fV+k9Y8VkTcTYzT/6wHVdAZ9mKVZjN5ugO2BPEli5HFC73EjANSBdC\nlAN38P/tnXd4VFXawH9nSjKZ9A6EUAMkoQSko4IIShMQUSlKWUVYFnBVRNFdpImCothwPzvogtiQ\nskoVkCZKV6RIlZKEFBJSJtPP98cMLCVlZjKTDOz9Pc997tw7557zzmTy3nPf8xaHF0YgsM5pd9oh\npfyrEKIWDre43k6PjfHAGhzuch9LKX/30eeoVoqLi5n09ERWLl/Kh9OGcVenpl4f4862jVi/fp1X\nFLPRaOSlmTNZsngRH93VzAvSeZ+Xtx9m86ksHqtEH9F2O4dVKijHFGLFsRgXVYlxACKFIN1kqWQv\n5fNAwxo8+fMvlerDF5F/wUGBjOjX8apzUkp6jn+Xd955myeffMqr4/mEG82UIaUcUsrpUgsJSinT\ngd5XHH8PfO+xdDcAO3bsYPjDQ2mXmsC+r6YQGe7dcvaX6NYhhX/8azWzZr3kUnuj0Uh2djbZ2dlk\nZWWRmJhI06ZNkVLStmUaNWzFbBvUkdphlTOz+IKFv/3Jqz/9wTAqV4M6Coc3R3kYAC0OhVUZolQq\n8l2YMdvtdsx2O0UWOyVWKwarDb1GTWJoRUuUkBQRTGFRcaXk1Kg1lYxxdA0hBG8+PZDOo2YyZMhQ\n/zZpCG48xaxQOmazmenTpvLRh+/z1uRB3H93RZbMyoxlRa0S7Nn/G4sWLcJisXDx4kXy8/PJz7vA\nxfwL5GRlOZRwdjbZuXkYTSZiI8OJiwrj4PEzjBs3ntfnzUMIwbCRI/nojdfQqv3rxwiw4mg6T6zd\nz/04FiUqQxRgqGDhsBhcziBXHmECzhQaaLjgB2xSYrdLx9652exOVzkpHblMVAKNSqBRqTDb7IQE\naKgbpmdQUk3GNK9b6o2idqiOIrMZs9lMQIBnCap8MWMui+T6NfhLvw488/RTfPrvxVUypmcIEDeR\nV8b/KgcOHGDYQ0NIiApgz5f/pEYpgSHukJtXyK9Hz/HLbyc4fvo8f2Zc4HxOAfkFBgqKSygyGAnV\n62icGMuS914lIiSIcH0AEcFaagXrSI7VEduoBrERScRFBhMbHkJ4iA4hBN/8+BuTP97E9BkzLo/3\nzOTnMBqN9H3/Xb67t3WVVD8xWW3sSM+jaUwoMWWM9+/fTzNh9T76AY29MGYEDv/i8lzmvKWYIwQU\nW2ysf7izw9VNrSJArUKjUv3X/U3tcI27No+J1W5nb2Y+G//M4d39p5iz+zjdE2OY3rEJCSH/faIJ\nVKsRCAwGg8eKWa2p2mKs/xzVizYPzeHLL7/kwQcfrLJx3UaZMd+42Gw2Xn/9NV6Z/TIv/f1eHhlw\nW5m+nXa7ncyci/x+LJ3DJzM4fiaLP9NzOZ9bQH6RkWKDCYPTed9msxEZHoLVZkOrEgzr0Zr6HZpQ\nv2YU9WtGUjc+El2g+wsombmFjH9zJSu+W31dLoMpU6dhLCmh36IFfNe/tceFXcvjRH4x605msT6j\nkK2nMgkJCWFwg2hm3tbkurbzfjnKzC2HGIBjprsPhxlC49y0zr3AoWzNzn2WSoXBbicAR/rOQByh\n2Zdea4GVQBoORR3pPH8JbylmvUpFaICGFnHu36Q1KhVta0XRtlYUkzo0YtOfOby56zgtF/1IXLCO\n7gnRzLw1mbAALSoBZrPntmxfLP6VR2iwjsUvjaTP3/5KmzZtaNDAe94gXsVLelkIkYgjSroGYAfe\nl1K+KYSIwhHvUQ9HOvAHpZR5ZfWjKGYX2bBhA+PHjeWPo8fo0qYxX6z6hQ+/2UKJ0YzBZMFktmI2\nWzCZLZjNVoxmC1qNmsjwEGrERpAQH03dhBp0aN2UmnFR1IyNpGZcJLXiIokMD3GE377zFWs3/Mwr\nY72TTex4ei5169Shffvr43qEEMyaPQeTycS9S79gZf9bCPdA+V/Lifxi5u8/zfozFzDYJD169GTk\nmP78u3t3Tpw4wUN9ezHztquvGbTsF747ngnACq2WmrGxtGzVivbNm2MsLqa4qIjioiIMRUXY7XYi\nIyMJd26zXnqJ8Wn1sQGFZisFFhuFZislVht5Fht1LRY2W+2stjjOmWx2VEKgVQm0KhUCidVq58nC\nEtpoVNwdqCXWA3tzMMLlmoHlIYSga71YutaLpcBkYf3JLP615ySNFmwgJToMq11itniumNUqNeWE\nE/iE1ql1ef6Ruxn84EC2bv/Z49m+T/HejNkKTJRS7hFChAK7hRDrgJHAD1LK2UKIycBkrkljcSWK\nYnaBjIwMBtzbD61axT13tiUmMpSYyFCiwkMIDwsmIiyYiFDnPkxPRGgw4aF6AgLcU3RhIUGUlFOB\nw10S48I5l5FR5vtCCObOe4MJJiMDVq5geb9bCK1kTb71p7L4TR3JN2u+okWLFlc9UURGRlJshyO5\nhUTotKw8lsmyP/M5mGdixIgRjB49mhYtWhAS4rpf9cqvv+L+pFhaxro2U5VSUmK1U2SxUmSx8vLO\no6w4nknTkCA2G818km9Ar1YTqxY0AboGaGitUVW4OBisAosHgTDlERao5b7kBO5LTuD0RQNPrf8N\nXa4ak9HkcZ++SJTvChOGdGXDrmM8N/lZXnt9XtULUCHeUcxSygwgw/m6UAhxCEcUdH8c3m0AC4FN\nKIrZc4qKirind08iQgKpWzuepe8+47OxQoKDMHqhCsYlakWHIW1Wvv/+e3r37l1qGyEEb83/F2Me\nNXH/f9axakDrSqUFbRgRTIDBTlpaWqlj9e3XnwFLv+KiyUqvnj14fM4wevbsSVCQZ94hKampHMk7\n6bJiFkKg16rRa9XEEUisPpB2IUE8GR0MBGORkj9MVvYbLewy23ix2EiJXRKt1ZAg7bTQqAiQkjN2\nyLRLCrQaioWgxG5H48Uc2DvTL3Aq34DBYqXYYqPYYiM5OoT1JzO5s1d/YmNiEM7QbnB6lVw6FgIh\nBEKocBwKVCoVQghsNhtWq42uo+Zitdmx2yRWuyQxPoJ/z3oEnY+q3ggh+OiFobR5aA53dL2Tvn37\n+mQcj/BRSLYzx1Ar4Gcg3qm0kVJmCCHiyrtWUczlYLVaGfTAQFrWjyDt7hQW/GenT8cLC9Fj8qJi\n1mjUfDltCP0fHsq59MwyowZVKhUzX55NowZfYLbZ0Wk8D9FNigzh2JayC4c+N+UF+vS/l+7du3sl\nijG1ZSuOrPQ8L5YKhyHwElohaKrT0lSndUZDhZJltfGr0cI+k40lF4sJ0wfSrnYMt4cHUScsiNph\nQSSEBlEvwnuukkP/s49b2rYjJjaW4JBQgkPDiAgNpalpKadPHufvQ7sicXh/SCmREuzS7thfPufw\nCJFOLxG7c98xpS8BWg1ajRqtRo1Go2bFhj0k9nyO6IgQVEIgVMKp+B2/D61GhVatJkCrJjBAg81m\nw26XFBstlBgtGM2OzWS2ktqgJhs/nHjdZ4qOCGHRrJEMfHQku3bvIzEx8foPXl24fk+NEULsuuL4\nfWc6iau7EyIER3rwJ6SUBe7WtlQUcxlkZWUx/OGhCGMu784YzVfrd1Nc4p2CmNdit9s5nZ7DidOZ\nmC3eDevt1KweZqeLVXmKcPGiRfRvklAppQxQOzSInPx8DAYDev31vhB16tTxapKqps2a8ckSz22u\nQghkBTbXOI2a7iFquofAIbOVPmn1eO423+TEuIRdwnufLKRWrVpXnU9JSeGz91/jiZG9vDrekyN7\nsXbbb+RdLMZmtzvc/Zx7q82GyWTBaLJQYjJjKDHz6kf/4YmHu5MYH0lYaBARoXoinL7Yfce/TUGR\ngbCQ6//+nVo25MmhdzD4wYFs2rzNf6ICXVecOVLKcn1jhRBaHEp5kZRyqfP0eSFETedsuSaOYjtl\noijmUvjhhx8Y/vBQRtzTlmljRqPRqIkK01Pio5Dbp15awAdL1hETGUrnFvW83r/dLivM5bzgg/eY\n3SK+0mOpVYK60REcO3aMFi1aVLq/ikhNTeXIhUKPr1eJq2fMFWEDNFWQjU8ISnVra926NU/+fsIH\n4wl63Oba3ysr9yLzFq5i7sQHSvVKSmlYi9c+Xc/0v/Ur9fqnh9/Fj3ve4x/PP8crr86tlNzewztm\nKOH4Qj4CDkkpX7/irRXACByVz0YAy8vrR1HMV2C1Wpn6whQWfPwBn0wbRvcOKZffi44IwWTyjWIO\nDNDQuUVdVs2tTABy2dhstusWrzIyMti+fTvbt21l86YNnDpzmtv7eD4LPF9s5MvD6Sw+lk0Jaq8m\nWyqPpKQkzuYXYLTaPJrtq4R77mN2Kb1qSy4LgShVMdevX5+AAB3b9/5Bp1be8PZ2H7PFEfBU1uP5\nYwNv46lXvuRfX/2IRq1Go1ERoNVwd8cU5j75APqgABZOH0brh2bT5Y6u9OnjvZqGHuM9r4xbgWHA\nb0KIfc5zz+NQyF8KIR4FTgMPlNeJopidnDlzhqGDHyBIlLBr0WTir0nRGR0ejLES/qPlUTM2ko0F\nvjGTgEOZ7N27l127drFj22a2b/+JwqJCOjRrQMfkmrw8vAODpx5j1Ynz9GnoeuhsicXGd8czWXws\nh1/O5dC/Xz/emjqazp07VzrE2VW0Wi31aydw7GIxzTxIq6pRCaxuaGa7hKoImCxrxiyE4OlnnmX2\nhwtZMb96FHOtuEgsVhtmi5UA7fUqZPTAztzVIdWZZN+MwWjmfG4Bb3++gZrdn6ZNs4YEBgaClPx1\nzGjOnD1XDZ/iCoT3irFKKbdS9vS7m6v9KIoZWL58OaNHPcKTD3Xl6eHdS1UqUeHBGH2UpCYuOoJC\no+8S4ESE6Bk9YjAdUxPplpLAlL5DaZwYe9WMZ3D3Vry7+48KFbOUkp/OXWDxH+dZfjSd1rfcwoh/\nvsjSAQMIDvZNnpCKSElJ4UheukeKOSk8mCVuLLjakGirorCAKH3GDPDII4/y4swZ/HrkNC2aVH1R\nCZVKhS5Ay4WLxaVGvQohaFD7+urnQ3q14/m3lnI4J4DRY8YQGRlJQoKflDZTIv/8B5PJxKSnJ7Li\n269ZOncUHdMaltk2PCQIq9WGwWBEr/fuY3p8TDjFHtivrVYrX278le93HObDZ+5HF1i6q1PGt/+o\nsGLKoDvT+HzdnjLfP5lfzOJD51hyNIugsHCGjxrNi8OG+cU/VmrLVhxec8yja9vERZDtxoKrXYKm\nCv6JL1UaKQ2dTscTTz7F1HeWsvStCW5Vw/EWgQFa8goMbqcjiAzVUyswtkz3zWrDzxRzhbd+IcTH\nQogsIcSBK849IIT4XQhhF0KUuUIphDglhPhNCLHvGheTaufo0aN0bN+GM4d+ZvfiZ8tVyuD0fw0K\n4OTZchdTPSI+JgKDi4r5zPk8np6/kuYj5xF5z3Se+3AtWw6cZvwbZa8luPKP27FpHRCC1c4IPIB8\no4VPfv2Tu7/dw53f7KIorStfrVrLgaPHeXbyZL9QygBNmzXnqMEzb5b6YUFYpOTLfAM/Fhs5YDST\nYbFiLkMp2pBoq8BMI8qZMQOMHz+B9AtmZsxf5nNZSkWAxeq+a+f9d7fhiyVLMJt9l7vaIy6ZMyra\nqghPq2QfAO4D3nPh+q5Syhz3RfMdX3/9NWPHPMa0Mb356wOdXZ5xRITqOXk2i6aNvfv4WCMmgpIy\nornsdjsrtx/kw5W/sO/EeXLyCmmflsSYId3peXsaSXXj2br7CH3GzOX1cX0JC/FsNq9SqRh0Z0ve\n3nsUIQSfH8tm3YlMunW9g2fnzaBXr17+49p0DampqRzO86xK86XAjE/NVlQWQZHZSonFislqdyYe\nUqNVO8K3tSoVBgEzdxzlnf2nUQvQCFALgVY4fKAD1CoC1Sp0WhWBKjU6rYogjRqdRoVOo0av1TgC\nXDRq9AEa9Bo1wQFqQrSay/vQAA04/Y/LQq/X85/vV9OxQzsSa0bxyMAunn59bnM2M5dig5Em9dz3\n4qmfEIO02yksLCQ62juFJLyCn82YPa2SfQhcm4n5E1arlecmP8vXXyzi+7f/RuvUum5dHxkezOn0\nbK/LFRURgtlipaDISFiIjqy8IuYv3caK7Yc5mZFLYICW/t3aMGZ4b+5sn4o+6OrsbLe1bkKb5g0Y\nPfcblkx7yGM5erZvzKK1u3nlZAnDxzzFe0OGEBVV2RTyvqdx48acys3HYrO7bf8tcC7oHp3Y+yo3\nOLtdUmyxUmCyUmiyUOjcD1i0nUfuaknTenGYzDYsVhsmi9W52TBarJSYHK9LzFYKzBayzY7zRoMJ\ns8XgaGu2YnYuoJmtNixWOxarDYvNjtVmQ0rIzc0tN+lPfHw8q1avpUvn26gVF0HP26+PtvQF67Yf\noF6tWALdTDlwCV1gACUlJV6WqjII/K2Eia9tzBJYK4SQwHulRchUFefPn2fwg/cTYC/kl8+eITrC\n/Tp3MRGhpGeVmRDKYy7kF6ELDGDAPxZwPDOf87kFpCXX5aF7b6d355akNKxV4U3w1UlDuGPYi+Tk\nFxHjwWcD+GLT74wd/3dmz5nj0fXVhU6no3Z8PCcKDDSJdO+z7z5/kejgwOt8k1UqQWigltBALY7S\nrg6CdQE83C2NtIY1vSF6mfSb/hVnz56lbdu25bZr0qQJ3yxdxr3972Hth5NIS3ZvsuEJugAtdulZ\nXpCDx9MpMZkwmTzP9+F1/gcT5d8qpUx3xoWvE0IcllJuLq2hEGI0MBrwamQYwE8//cSD99/HyHva\n8sLoh1B7uKoeFxlKhpuK2W63c+TEOXb9dpwDf5zmj1PpnMu8QH5hMYVFJRQWl2CxWImJCiMhsSZ/\nG3kP3Ts2JdyFihZXcktqPbp2aMpfZn/Fytl/cetagI17jrFu1zGOf/WD29f6A6kpyRzOy3VbMe/L\nvkhdN66RUqKuAhtzs8RIfv31VwYMGFBh21tvvZW33/kX/cf9nW2L/0lCvG+fckL0OoweJtt68aM1\njJ/wBA0blr+mU7UIEJWLePU2PlXMzlJTSCmzhBDfAu2AUhWzczb9PkCbNm28kv9KSsm7777L9Kn/\n5IMpQ+nbpXKPerFRIZzMuHj52Gq1kpNXSGZ2Pjl5BeRdLCa/oAi1Rs2hY+fYd+g023YdQK0S1IqP\nol5CLEl14rm9VRKJNaOpWyuGOjWjiYsO84rf7+TH7uHece5n7tq45xiDZ37BF18tvS5v841CXGId\nPly1l4smC6lRITSLDkWncfy8T14sptd3u0FcqhyiQoXDNlxgMpMc6/pnlrJqIv+a1Ytl+b7dLrcf\nPHgwJ0+eoO/YN9iw4FkiwnznuhgaEoTZQ8Vss0uaN/e8yrfP+F+ZMQshggGVM/VdMHA3MKOCy7yG\nwWDgr6NHsX/XT2z9eCJJdcpN5nQVF/KL2LbvOLsPn+bgsXP8mZnPhYJi8i4WYzJb0Dcd7MjSZbMT\noNUQFKglSBeIVqvmTEYuXe+4ne539eSJ/o+yoV8/rL9/WiX2+OaNEskvNGA2WwlwIX3noVPnefHf\nP7Jh7wm++Gopd955p89l9DY7duxgzqyZbNmyhbS60bx7LIPM/CIKDGaCAjQEB2qxWG10bVGPJ+9p\nTYnZitFp37XY7Gw/fI7Vu10PcbZL6fETlzs0rx/PrG9WuXXN5MnPkZmZQY/H5rLmg6d9ppxD9YFe\nz+lS7dxopaXKqJJ9AXgbiAW+E0Lsk1L2uLJKNhAPfOtUSBpgsZRytW8+xtUcP36c++7tR/N6EWz7\nZCJ6N6tz1LrrGWKjwmiQGEeT+rVo17IJ9RPjqF87ltjIUIKDAtEFatEFaq+a6b7+ySrW7zvPqjXr\nEEJgsVhQq9VVtkgaEqwjIlTPtgOn6HpLUpntTmVcYNrCjazZeZQnJz7NB0snuJUD2R/YvHkzU557\nhj9PHOep3ml8+s4jBF+RstJqs5OZX8y5C4Vk5BXTtWkdwoOvL2lVLzacL7YddnlcKSWaKjBlNKkd\nw6nTZzEajS6HtwsheOONt3jiicfp8dhcVr//tE+KA2s1GuzVkdTZp9xgM+YyqmQDfFtK28tVsqWU\nJ3BU9KlSVq5cyaOPjOCFUT0Z+2AXt5Wi2WzFarVxZtNbbo/9+qdrWLt+0+UxHXlwBdv2/MGtt1RN\n+GxKwwQ27T1eqmL+40w2by/dwZIN+xk/4XGOLllLWJj70XL+wKxpU7i9poq1E4ajLSVHhkatonZ0\nKLWjyzdTJNWI4KLBhN1ud8mc5Jgx+/6fOECroWHteA4dOkSrVq1cvu6Scn564lPc9tCLLJ//d5Lq\n+nGFar+gan2UXcG/5u+VwGazMeWf/+BvYx5l6auP8bdBd3g8Uw3SBbBl1xG3r8svKKJ+/fqXjzUa\nDZ9++hkPPDnfIzk8IS25LruP/Df3gNVq49vNB7h70gK6PPERYY06cujIUabPmHnDKmWARsmpRAYH\nlqqU3SEqNAi1WsXRXNf8oKWkShb/AJrVi+PAgQMVN7wGIQSvvT6PxydO5vaHZ/kkKOqmQuBY/HNl\nqyJuCsWcm5tLn1492LJ2Gb989gydWnq+4hsQoGHc4K488g/3PPvsdjtG4/U5jwcNGkSxwUh+QbHH\nMrlDs0YJnMjMY/nW3xn3xgoaDJ3LvO8O8ZfHn+f02XRenj2HuDjX7e3+Smqz5hzO9Dzd55XUjQ1j\nyynXYqDsUlbJ4h9As8QIft2/r+KGZTB27N/o3eceVm8uu3CBgpMbMPLPr9m3bx8D+vclPEgwcfhd\nfL/1NzqlNaRJPc8f38Y9eAdvLd5Q5vs7fzvBjn1HCQjQEqDVEBigITevkMZJDa7Le2yxWIiICOfP\n9ByfrpRfIrVhAucvFPLuuhP06NOftS++R2pqqs/HrWpSUlL4/P/yvdJXcu0Y9p7Lw97ajtFqx+CM\n/DNa7Y4CrlYbJRZHIVe73Y66CtJ+AjSrH897W/ZWqo9Ot97Oj98tYuxQLwlVSXLyirBUopisb/jf\nCzDxOevWraVunUSCg4NZuTuX4yf/5MCxDF6beL/HfUZHhGCxWJFSlmoOmffpOvLMOurUScRiLsZk\ndDjMPz3p6tqKVquVIYMeoHVKIk2TanssjzskN6iJHRVrN/x4w0VmukNKSgqHTnvnEb3EaOaj/Sf5\ncNcJVM51AbVKoFapHJva4WKnVqswWWzYbN4tuloWzevV4MD/Vc6vvEuXLrw4fUqZv+WqoKDIwKsL\n1/LZip84cz6Ph0b5U9SfkxvNK8PfmTTpGSZN+m+B1Dlz5pB7eFOl+gzQqpCAxWIr1e3MYLIwdtxE\n7r333nL7ycnJ4fvVa9j99YwqcbECCA4KxGgyYbFY/LNMvJeIj4/HapdkXzQQG+5eMM61aNQqxvZt\nz1tje5WrvMwWK0F9Z/L4/O/IKzKQfbEEhKDE7AixvhyabbYyrl875jzWs8KxS0wWzFaH66XFub+0\nma02snMvkJeXR2RkpEefrVGjRpitdo6fPl9li4AFRQZWbf2dDb8cZsvuPziVnkvTurFMeaATC388\nTN26vo9OdBs/m8Tc8Ir5SqSU7Px5B60SPE/LaTZbaT30JW5JrYdGU7oyzS8oJjy84nSHNWrUYMaM\nGbS+/wUsFivhoXp+/mIaDRJ9Z+Pdf/g0qcmNb2qlbLfbmT//HQQSswcZzq4lPDiQi8WmCmeUKpXg\n0V5tQML6vccpNlqY98S9RIbqiQjROfdBzP73Bv44m1vhuCcz8kh+9E30QTo0ajVardZZ8UONRqNB\no9aQ0qQxJSUlHitmIQR//etYBkx4m7nPDKJ7x2ZenSRYrVbW/nSQZRv2cfB4On+m55KdV0jN6FBa\nNqjB+J4tubdDE2o5vWM+3fyHI0m+36EoZp+xYsUK1q9fxwffzSq33cIV21mwYjt2O5cLTl6qIJye\nnU/92nGsen9Sme5Tmdn5LmdauzSjX7JkCc9MfJy4KN96Quz+/SRt2rbz6RjVzcsvzWLpp++zdcYg\nEipwh3OFyGAdp/IqfrzWqNW8//e+AJzNzqdZ40TGDrj1unax4cFkZV2osL/cQgMtUpPZvd99zwt3\nmDptOg0aJjFl3lzGTF3AoF7taN20HmnJdagZG4FGrUatVqHVqK/6zUspKSwuYeevJ9h54AR/nMrk\nQn4h6Vn5mExm6nSfRM7FIiKCdXRISaRns9q0va8dt6YkElJG7IDVbve/LIVCIFT/QyHZVU2PHj3o\n2LEjo2ctZvSATmg1alo0rn25eu8lFq/6hYvFJu67q63ThqhCo3bsg3QBDO9/W5lJ5wGeH92HoUMG\n8fMvu6hZ07VkNmFhoSTWqUetLo/TKrUBcyc9SNvmZWcO85RdB8/Qqcdgr/frL+zatYs3X3+NnS8N\nJjHGOze56BAd+8+6lwNFq1FhKmO2HhykZevvZ0ga+SaOdUKBSuWo4+dY3BcIwGy1odFVTWDPsGHD\nGDZsGPv372fZsmV8+eMunn9zOdk5udjsdqxWKyqViuSGieh1gZzJyCH7gmNx1W610rJhTRrUiCQx\nNIi0ZgkM69SI5NrRpNWPJy7C9UVtq82ORuOPakeZMfsMnU7Ht8tX8viEcby8eCclJSWcz0xn+bwx\nNG343zLwfW5rhjCSwgAAD+tJREFUzgfLtvPPseXbiMtieP/b2PDzYZYuXcq4ceNcuqZ37z707t2H\nzMxMGjVK8pnL1a4DJ3n8H+VWV7+heXnmNKYObOs1pQwQHRpEgcG9motajRpzGSWpxt53K7c0SXQ+\nhdmx2SU2mx0Jl4/tdsnRM9ms2lu19e7S0tJISys97stgMHDw4EEMBgN169YlNjaWAwcOMP4vg9kx\n2ztuHeXlmK4+hLL452t0Oh3vf/DR5eNPP11ItzFPsmjWCLq1d1S9HtyrLZPmfU2J0UyQzjNbbPsW\n9di7x/2iLO++O5/+d7amVWo9j8Ytj+Onz5N1ocA/k8R4CbvNRrwbMzRXiAvXU2hwLw1lgEaN2Vp6\nvoi4yFD63ta0wj52Hz7Dmv0Zbo3rS/R6PW3aXH1TDwkJoajEe9VGQnQBFBV5VtTAt/jXjNm/bhM+\nYPjwEcx48SVeW/Tj5XNxUWHUTYjlmblLPO43PjqcnCz33LUyMjKY/87bzJxQcSpHT1jw7VYeeuhh\n/7PheZHAwEBMbhRPdQWr3V4tMzldgBZjGZVr/IWQkBAK3XyaKI9QfQAFBQVe689r+FmAyU2vmAFu\nv/12Tp69uvLIqnfGs3DZZjb9csijPmMjw8jOcU8xT31hCv3vbEWdWt4vqWM0mVm4fBuPPDrK6337\nEwGBgV7xxLiSxVsO0ampey5cNru90smMdAEav1fMn326kGZ1vedFFBkcSE6OX1WacyBUrm1VxP+E\nYtbpdOQVFLH/yJnLM6OGiXEM7NaKuR9/73Z/UkoW/ecnpHTvDhoXF8ua7YdocPckRk35mM+/+4nz\nORcrvtAFXv1oFW3btb+pzRgAF/PzCdd7191q9b6T7DpyltlLNrN060FyCwwVXmOx2iudpwP81ebq\n4Ndff+WN1+fyrzHdvNZnx0ZxbFy3xmv9eQfhNcVcRvHqKCHEOiHEUee+Qt/H/wnFXK9ePUb+5VEG\nPruQpH7TeOq1r9m06widWzfmxJnzbveXk1fI59/9xPKV37l13YuzXubsuQzWrN9Eqy4D+OrHU6Tc\n8xytBk7l6Vc+Z9Xm/RQVu//YeOJMFm8tWscbb73j9rU3GseOH68wY5y7fP7EPbRvGM/ybYcY/cYK\npn62scJrbHZ7mX7urlJitqDXB1XcsBowm80Mf2gws4d1pk5sxT77rtK7dRKr167FZvPuU0+lEHhz\nxrwAuDayaDLwg5SyEfCD87hcXMnH/DFwD5AlpWzmPPcAMA1IAdpJKUtdBRNC9ATeBNQ48jTPrmg8\nX6BWq3nl1bnMeeVVfvvtN5Yt+5ZJ73zD74cOo9cF8NE3m7ijbQoNEuNcClsN0GpQqVTExsa6LYsQ\nguTkZJKTk5kwYQJWq5Vdu3axbt1aXl20hkFPzad1syS6tW9Mt45NadusAZpyZmY2m51RL3zCs5Of\n88+IKi+SnZ3NwT+OM+YjC0Jwlf/5Q7c25tn+nnmj3N8xmfs7JgMw/oO1LNt+iPiIYNQqFUKASgjM\nVhsFBhMFBhOFBhO/HDlH4wa1Kui5fAxGM0Eu5lquamZMn0rtEBjZrYVX+02MDaN2TBgrVqxwqWxW\n1eEd+3FpxauB/jhy2gMsBDYBz1IOrnhlLADeAT694twB4D7gvbIuEkKogfnAXcBZYKcQYoWU8qAL\nY/oEIQQtWrSgRYsWvPDCVI4dO8Znn33KxgOHmTr/FdQCurRNpkvbRuUq6gCtBrOXErFoNBo6dOhA\nhw4dmDLlBYqLi9myZQvr1q5h3Mtfc+rP03Rul0r3dk3o1rEpyQ2uLsz6+oJVSG0YEyc+7RV5/JmY\nmBj279+PxWJx5rpWoVKp2LFjB1++9zrP9q/8GNGhevKLjKz/9fRlpS+lRKtRExIUSHBQAKGhwTx4\nV2vu71q5dOMlJgtBQf43Y965cycf/N+/2PP6CJ/k13h9ZBcGj/oLF3JzeXSUP6yJ+HxhL15KmQEg\npcxw1kAtF1cS5V93B5BSHgIq+qO1A445E+YjhFiC485RbYr5WpKSkpg+3VHtSkrJ0aNH2bhxIxs3\n/lCuog7QajCZzD5JDBMcHEzPnj3p2dPxNJSVlcWGDRtYt3Y1r419C6vVTLcOTenWIZn46HBeW7iW\nnbv2XJfV7mbk0o31WrZu3UqdaO+40KUmRlMrJpwf33XNP70yGIwW9PrK5fnwNkajkREPD+GNR++k\nZpRv6j/e0bwum14cTK8pzxGkD2Lo0Id8Mo57uGyWihFCXGkheN9Zr9Sr+NKPOQE4c8XxWaB9WY19\nWSXbFYQQNG7cmMaNGzNmzBiklBw7doyNGzeyaeMPTHv3VYS006VdCl3aNAIcyfl9HcUUFxfH4MGD\nGTx4MFJKjh8/zrp161i5bjU/7VjGm2+9c9ObMCpCSonWC1VFLhSW8NK3vxARWjWzWH+Mgntt7quk\nxusZdLtvU8Um145hxfMDuGvCOOrVq0+nTp18Ol6FuO5hkyOldNdmdl4IUdM5W64JVOjO5ctfRWn/\nKWUuQfuiSnZlEELQqFEjGjVqxOjRoy8rxU2bNrFpw3pat2pZLTIlJSWRlJTE2LFjq3x8f6VFixZ8\n/FZ2xQ0roNdLS0moEcXi6cO8IFXFqFXCvxbBgD8OH6Rdw6oppNC8Xhwfj+/JgwMHcPDI0WqsqCPw\nsR/ECmAEMNu5X17RBb6U5iyQeMVxbSDdh+P5lEtKcdSoUfx78RJ27t7jd7Od/1U6duzI6ewCTmVV\nzvXw7IVCJg/vVmUzZo1ajbWM6MHq4omJzzDvP7spNnov2q88erdJokdaHZ6fXO5amO/xUoCJs3j1\nT0ATIcRZIcSjOBTyXUKIozjW3Cp0gvClYt4JNBJC1BdCBACDcdw5FBS8ikajYfiI4cxattPjPs7m\nFpBbYCAtqXKeFu6g0aj8rppHq1at6NzlDmYs2VZlY84Z3pmvv1zCzp2e//0qj3BxKx8p5RApZU0p\npVZKWVtK+ZGUMldK2U1K2ci5rzD1YIWKubQ7gBBigBDiLNAR+E4IscbZtpYQ4nungFZgPLAGOAR8\nKaX8vcJPpqDgAS9Mm8HqX8/y4+9nKm58Dc8v3kzKEx8zok97wkOqzksiMjSIvHzvlMfyJm/N/z+W\n70vnjeVVoyijQoOYOeRWnnp8fPUE3AhuvJDsMu4A3zpfB0op46WUPZxt06WUva+49nspZWMpZUMp\nZflJkhUUKkF4eDgffLyAh+ev4Wyue0Vav9pxjLefGsh7z3hejswTYiNCyMmtOG9zVRMfH8/6jT8y\n7/v9LN/hfrV4TxjZrQU5GWfYtq3qZur/xdXZslKMVUHBbXr37s34Jyby4BsfsOmFgQRoXXMhNFos\n1K8VVamxLVYbJSYLJSYLBqP58mvHsYUS83/fMzrPXywykp17oVrr8ZVFnTp1+Prb5fTt3YPk2jE0\nqe39/C5Xolar6NumAevWruW2227z6VilIvzL3VRRzAo3Fc9Ofo6ftm5h0qItTOxzC0aLFZPFUena\naLZistocxxYrRovjdYnJwn+2HeSn3045lKfJRonZSonZhsFkocRkdSjWqxSuGUOJiRKTmRKjCbtd\nog/SEaQLRK8PIkinIyhIhz5IT1BQkGPT69Hrg9EFhTle1w7hjTfu9TulfIn27dvz4ktzGDh7Opte\nHExMmG99rjsl1+K97Vt8OkaZ+NnfQFHMCjcVKpWKhYs+5+477+D2md+iCwwkMCCAwMBAAgMD0ekC\nna916HQ6AnXBNE9rRUl4Yy6GhaPXB1ND/19lqnfhdVBQEFqt1m8VbGUYPWYMf/55krqPzqNGdDg1\no8KIiwgmLEhLqE5DaKCGEJ2GyJAgakaFUCsqhFpRoSREh7r9fWg1Kuz2qqlAfjVVa6ZwBUUxK9x0\nREZGsnPv/uoW46Zh1kuz+cc/XyAjI4PMzEzOnz9PQUEBhYWFFBUVUVBwkdPZWazZc5b09EOcTc/A\narXQPrkOtSKDkUhnXhMcYe7S+dqZ60Q6z2fkXiQ6sVH1fEg/u6kqillBQaFC9Ho9DRs2pGHDhi61\nP3fuHDt27CA3N/eqvCalbVe+n5rq24jDslEUs4KCwk1OQkICAwcOrG4xXEeZMSsoKCj4EUIpxqqg\noKDghyiKWUFBQcG/UEwZCgoKCv6GopgVFBQU/AjFj1lBQUHB7xDK4p+CgoKCn6HYmCtm9+7dOUKI\nPyvZTQyQ4w15qhBF5qpBkblqqAqZvVRXTVHMFSKljK1sH0KIXR7U5qpWFJmrBkXmquGGkVnxY1ZQ\nUFDwR5QZs4KCgoJ/odiYq4z3q1sAD1BkrhoUmauGG0Rm/zNliGqpsaWgoKDgJ7S5JU3u2rLKpbYi\nJGF3VdjNb+YZs4KCgoJr+Jkpw7/m715CCBEhhPhaCHFYCHFICNGxumUqDyFEEyHEviu2AiHEE9Ut\nV0UIIZ4UQvwuhDgghPhcCKGrbpkqQgjxd6e8v/vrdyyE+FgIkSWEOHDFuSghxDohxFHnPrI6ZbyW\nMmR+wPk924UQfu6d4V/FWG9KxQy8CayWUiYDacChapanXKSUR6SULaWULYHWgAH4tprFKhchRALw\nONBGStkMUAODq1eq8hFCNAMeA9rh+F3cI4SoppIZ5bIA6HnNucnAD1LKRsAPzmN/YgHXy3wAuA/Y\nXOXSuIXTxuzKVkXcdIpZCBEGdAY+ApBSmqWU+dUrlVt0A45LKSsbYFMVaIAgIYQG0APp1SxPRaQA\nO6SUBimlFfgRGFDNMl2HlHIzcOGa0/2Bhc7XC4F7q1SoCihNZinlISnlkWoSyXUEimKuAhoA2cAn\nQoi9QogPhRDB1S2UGwwGPq9uISpCSnkOmAucBjKAi1LKtdUrVYUcADoLIaKFEHqgN5BYzTK5SryU\nMgPAuY+rZnluMvzLlHEzLv5pgFuACVLKn4UQb+J47JtSvWJVjBAiAOgHPFfdslSE08bZH6gP5ANf\nCSEellL+u3olKxsp5SEhxBxgHVAE7Aes1SuVQnWze8/+NSIoJsbF5lUSFn8zKuazwFkp5c/O46/x\nP3tcWfQC9kgpz1e3IC7QHTgppcwGEEIsBToBfquYAaSUH+E0cwkhXsLxe7kROC+EqCmlzBBC1ASy\nqlugmwUp5bW28WrnpjNlSCkzgTNCiCbOU92Ag9UokjsM4QYwYzg5DXQQQuiFEALH9+zXi6wAQog4\n574OjoWpG+X7XgGMcL4eASyvRlkUfMxNGWAihGgJfAgEACeAv0gp86pXqvJx2jzPAA2klBerWx5X\nEEJMBwbhMAfsBUZJKU3VK1X5CCG2ANGABXhKSvlDNYt0HUKIz4E7cGRnOw9MBZYBXwJ1cNwUH5BS\nXrtAWG2UIfMF4G0gFoe5a5+Uskd1yXgjcVMqZgUFBYUbmZvOlKGgoKBwo6MoZgUFBQU/Q1HMCgoK\nCn6GopgVFBQU/AxFMSsoKCj4GYpiVlBQUPAzFMWsoKCg4GcoillBQUHBz/h/LDzGZHqpfmcAAAAA\nSUVORK5CYII=\n", - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "tracts.plot(column='CRIME', cmap='OrRd', edgecolor='k', legend=True)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "All the 49 neighbourhoods are colored along a white-to-dark-red gradient, but the human eye can have a hard time comparing the color of shapes that are distant one to the other. In this case, it is especially hard to rank the peripheral districts colored in beige.\n", - "\n", - "Instead, we'll classify them in color bins." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Classification by quantiles\n", - ">QUANTILES will create attractive maps that place an equal number of observations in each class: If you have 30 counties and 6 data classes, you’ll have 5 counties in each class. The problem with quantiles is that you can end up with classes that have very different numerical ranges (e.g., 1-4, 4-9, 9-250)." - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": { - "ExecuteTime": { - "end_time": "2017-12-15T21:30:30.408917Z", - "start_time": "2017-12-15T21:30:30.088920Z" - } - }, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 5, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAVgAAAD8CAYAAAAylrwMAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n", - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# Splitting the data in three shows some spatial clustering around the center\n", - "tracts.plot(column='CRIME', scheme='quantiles', k=3, cmap='OrRd', edgecolor='k', legend=True)" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": { - "ExecuteTime": { - "end_time": "2017-12-15T21:28:00.376417Z", - "start_time": "2017-12-15T21:27:57.039Z" - } - }, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 6, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAVgAAAD8CAYAAAAylrwMAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nJ6EKrIqKioqT+H/x/qL4/AodTQAAAABJRU5ErkJggg==\n", - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# We can also see where the top and bottom halves are located\n", - "tracts.plot(column='CRIME', scheme='quantiles', k=2, cmap='OrRd', edgecolor='k', legend=True)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Classification by equal intervals\n", - ">EQUAL INTERVAL divides the data into equal size classes (e.g., 0-10, 10-20, 20-30, etc.) and works best on data that is generally spread across the entire range. CAUTION: Avoid equal interval if your data are skewed to one end or if you have one or two really large outlier values." - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": { - "ExecuteTime": { - "end_time": "2017-12-15T21:28:00.376417Z", - "start_time": "2017-12-15T21:27:57.045Z" - } - }, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 7, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAVgAAAD8CAYAAAAylrwMAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nSUVORK5CYII=\n", - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "tracts.plot(column='CRIME', scheme='equal_interval', k=4, cmap='OrRd', edgecolor='k', legend=True)" - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "metadata": { - "ExecuteTime": { - "end_time": "2017-12-15T21:28:00.386417Z", - "start_time": "2017-12-15T21:27:57.048Z" - } - }, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 15, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAVgAAAD8CAYAAAAylrwMAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n", - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# No legend here as we'd be out of space\n", - "tracts.plot(column='CRIME', scheme='equal_interval', k=12, cmap='OrRd', edgecolor='k')" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Classificaton by natural breaks\n", - ">NATURAL BREAKS is a kind of “optimal” classification scheme that finds class breaks that will minimize within-class variance and maximize between-class differences. One drawback of this approach is each dataset generates a unique classification solution, and if you need to make comparison across maps, such as in an atlas or a series (e.g., one map each for 1980, 1990, 2000) you might want to use a single scheme that can be applied across all of the maps." - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": { - "ExecuteTime": { - "end_time": "2017-12-15T21:28:00.376417Z", - "start_time": "2017-12-15T21:27:57.042Z" - } - }, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 9, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAVgAAAD8CAYAAAAylrwMAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nxYsXLx7i/wECuIO28SjMHwAAAABJRU5ErkJggg==\n", - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# Compare this to the previous 3-bin figure with quantiles\n", - "tracts.plot(column='CRIME', scheme='fisher_jenks', k=3, cmap='OrRd', edgecolor='k', legend=True)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Other classification schemes in PySAL\n", - "\n", - "Geopandas includes only the most used classifiers found in PySAL. In order to use the others, you will need to add them as additional columns to your GeoDataFrame.\n", - "\n", - ">The max-p algorithm determines the number of regions (p) endogenously based on a set of areas, a matrix of attributes on each area and a floor constraint. The floor constraint defines the minimum bound that a variable must reach for each region; for example, a constraint might be the minimum population each region must have. max-p further enforces a contiguity constraint on the areas within regions." - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
AREAPERIMETERCOLUMBUS_COLUMBUS_IPOLYIDNEIGHOVALINCCRIMEOPEN...XYNSANSBEWCPTHOUSNEIGNOgeometryMax_P
00.3094412.440629251580.46700319.53115.7259802.850747...38.79999944.0700001.01.01.00.01000.01005.0POLYGON ((8.624129295349121 14.23698043823242,...0
10.2593292.236939312144.56700121.23218.8017545.296720...35.61999942.3800011.01.00.00.01000.01001.0POLYGON ((8.252790451049805 14.23694038391113,...0
20.1924682.187547463626.35000015.95630.6267814.534649...39.82000041.1800001.01.01.00.01000.01006.0POLYGON ((8.653305053710938 14.00809001922607,...2
30.0838411.427635524233.2000014.47732.3877600.394427...36.50000040.5200001.01.00.00.01000.01002.0POLYGON ((8.459499359130859 13.82034969329834,...2
40.4888882.997133675723.22500011.25250.7315100.405664...40.00999838.0000001.01.01.00.01000.01007.0POLYGON ((8.685274124145508 13.63951969146729,...3
\n", - "

5 rows × 22 columns

\n", - "
" - ], - "text/plain": [ - " AREA PERIMETER COLUMBUS_ COLUMBUS_I POLYID NEIG HOVAL \\\n", - "0 0.309441 2.440629 2 5 1 5 80.467003 \n", - "1 0.259329 2.236939 3 1 2 1 44.567001 \n", - "2 0.192468 2.187547 4 6 3 6 26.350000 \n", - "3 0.083841 1.427635 5 2 4 2 33.200001 \n", - "4 0.488888 2.997133 6 7 5 7 23.225000 \n", - "\n", - " INC CRIME OPEN ... X Y NSA NSB EW \\\n", - "0 19.531 15.725980 2.850747 ... 38.799999 44.070000 1.0 1.0 1.0 \n", - "1 21.232 18.801754 5.296720 ... 35.619999 42.380001 1.0 1.0 0.0 \n", - "2 15.956 30.626781 4.534649 ... 39.820000 41.180000 1.0 1.0 1.0 \n", - "3 4.477 32.387760 0.394427 ... 36.500000 40.520000 1.0 1.0 0.0 \n", - "4 11.252 50.731510 0.405664 ... 40.009998 38.000000 1.0 1.0 1.0 \n", - "\n", - " CP THOUS NEIGNO geometry \\\n", - "0 0.0 1000.0 1005.0 POLYGON ((8.624129295349121 14.23698043823242,... \n", - "1 0.0 1000.0 1001.0 POLYGON ((8.252790451049805 14.23694038391113,... \n", - "2 0.0 1000.0 1006.0 POLYGON ((8.653305053710938 14.00809001922607,... \n", - "3 0.0 1000.0 1002.0 POLYGON ((8.459499359130859 13.82034969329834,... \n", - "4 0.0 1000.0 1007.0 POLYGON ((8.685274124145508 13.63951969146729,... \n", - "\n", - " Max_P \n", - "0 0 \n", - "1 0 \n", - "2 2 \n", - "3 2 \n", - "4 3 \n", - "\n", - "[5 rows x 22 columns]" - ] - }, - "execution_count": 10, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "def max_p(values, k):\n", - " \"\"\"\n", - " Given a list of values and `k` bins,\n", - " returns a list of their Maximum P bin number.\n", - " \"\"\"\n", - " from pysal.esda.mapclassify import Max_P_Classifier\n", - " binning = Max_P_Classifier(values, k=k)\n", - " return binning.yb\n", - "\n", - "tracts['Max_P'] = max_p(tracts['CRIME'].values, k=5)\n", - "tracts.head()" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 11, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAVgAAAD8CAYAAAAylrwMAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n", - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "tracts.plot(column='Max_P', cmap='OrRd', edgecolor='k', categorical=True, legend=True)" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.6.1" - } - }, - "nbformat": 4, - "nbformat_minor": 1 -} diff --git a/examples/create_geopandas_from_pandas.py b/examples/create_geopandas_from_pandas.py deleted file mode 100644 index ca32e66..0000000 --- a/examples/create_geopandas_from_pandas.py +++ /dev/null @@ -1,91 +0,0 @@ -""" -Creating a GeoDataFrame from a DataFrame with coordinates ---------------------------------------------------------- - -This example shows how to create a ``GeoDataFrame`` when starting from -a *regular* ``DataFrame`` that has coordinates either WKT -(`well-known text `_) -format, or in -two columns. - -""" -import pandas as pd -import geopandas -import matplotlib.pyplot as plt - -############################################################################### -# From longitudes and latitudes -# ============================= -# -# First, let's consider a ``DataFrame`` containing cities and their respective -# longitudes and latitudes. - -df = pd.DataFrame( - {'City': ['Buenos Aires', 'Brasilia', 'Santiago', 'Bogota', 'Caracas'], - 'Country': ['Argentina', 'Brazil', 'Chile', 'Colombia', 'Venezuela'], - 'Latitude': [-34.58, -15.78, -33.45, 4.60, 10.48], - 'Longitude': [-58.66, -47.91, -70.66, -74.08, -66.86]}) - -############################################################################### -# A ``GeoDataFrame`` needs a ``shapely`` object. We use geopandas -# ``points_from_xy()`` to transform **Longitude** and **Latitude** into a list -# of ``shapely.Point`` objects and set it as a ``geometry`` while creating the -# ``GeoDataFrame``. (note that ``points_from_xy()`` is an enhanced wrapper for -# ``[Point(x, y) for x, y in zip(df.Longitude, df.Latitude)]``) - -gdf = geopandas.GeoDataFrame( - df, geometry=geopandas.points_from_xy(df.Longitude, df.Latitude)) - - -############################################################################### -# ``gdf`` looks like this : - -print(gdf.head()) - -############################################################################### -# Finally, we plot the coordinates over a country-level map. - -world = geopandas.read_file(geopandas.datasets.get_path('naturalearth_lowres')) - -# We restrict to South America. -ax = world[world.continent == 'South America'].plot( - color='white', edgecolor='black') - -# We can now plot our ``GeoDataFrame``. -gdf.plot(ax=ax, color='red') - -plt.show() - -############################################################################### -# From WKT format -# =============== -# Here, we consider a ``DataFrame`` having coordinates in WKT format. - -df = pd.DataFrame( - {'City': ['Buenos Aires', 'Brasilia', 'Santiago', 'Bogota', 'Caracas'], - 'Country': ['Argentina', 'Brazil', 'Chile', 'Colombia', 'Venezuela'], - 'Coordinates': ['POINT(-58.66 -34.58)', 'POINT(-47.91 -15.78)', - 'POINT(-70.66 -33.45)', 'POINT(-74.08 4.60)', - 'POINT(-66.86 10.48)']}) - -############################################################################### -# We use ``shapely.wkt`` sub-module to parse wkt format: -from shapely import wkt - -df['Coordinates'] = df['Coordinates'].apply(wkt.loads) - -############################################################################### -# The ``GeoDataFrame`` is constructed as follows : - -gdf = geopandas.GeoDataFrame(df, geometry='Coordinates') - -print(gdf.head()) - -################################################################################# -# Again, we can plot our ``GeoDataFrame``. -ax = world[world.continent == 'South America'].plot( - color='white', edgecolor='black') - -gdf.plot(ax=ax, color='red') - -plt.show() diff --git a/examples/overlays.ipynb b/examples/overlays.ipynb deleted file mode 100644 index 5b6b935..0000000 --- a/examples/overlays.ipynb +++ /dev/null @@ -1,721 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Spatial overlays allow you to compare two GeoDataFrames containing polygon or multipolygon geometries \n", - "and create a new GeoDataFrame with the new geometries representing the spatial combination *and*\n", - "merged properties. This allows you to answer questions like\n", - "\n", - "> What are the demographics of the census tracts within 1000 ft of the highway?\n", - "\n", - "The basic idea is demonstrated by the graphic below but keep in mind that overlays operate at the dataframe level, \n", - "not on individual geometries, and the properties from both are retained" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": { - "ExecuteTime": { - "end_time": "2017-12-15T21:09:34.256318Z", - "start_time": "2017-12-15T21:09:34.226318Z" - } - }, - "outputs": [ - { - "data": { - "text/html": [ - "" - ], - "text/plain": [ - "" - ] - }, - "execution_count": 1, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "from IPython.core.display import Image\n", - "Image(url=\"http://docs.qgis.org/testing/en/_images/overlay_operations.png\")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Now we can load up two GeoDataFrames containing (multi)polygon geometries..." - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": { - "ExecuteTime": { - "end_time": "2017-12-15T21:09:36.236298Z", - "start_time": "2017-12-15T21:09:34.256318Z" - } - }, - "outputs": [], - "source": [ - "%matplotlib inline\n", - "from shapely.geometry import Point\n", - "from geopandas import datasets, GeoDataFrame, read_file\n", - "from geopandas.tools import overlay\n", - "\n", - "# NYC Boros\n", - "zippath = datasets.get_path('nybb')\n", - "polydf = read_file(zippath)\n", - "\n", - "# Generate some circles\n", - "b = [int(x) for x in polydf.total_bounds]\n", - "N = 10\n", - "polydf2 = GeoDataFrame([\n", - " {'geometry': Point(x, y).buffer(10000), 'value1': x + y, 'value2': x - y}\n", - " for x, y in zip(range(b[0], b[2], int((b[2] - b[0]) / N)),\n", - " range(b[1], b[3], int((b[3] - b[1]) / N)))])" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "The first dataframe contains multipolygons of the NYC boros" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": { - "ExecuteTime": { - "end_time": "2017-12-15T21:09:36.526295Z", - "start_time": "2017-12-15T21:09:36.236298Z" - } - }, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 3, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAS0AAAD8CAYAAAAi9vLQAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\nAAALEgAACxIB0t1+/AAAIABJREFUeJzsnXd4m9XZh+8jybK8955JHGdvZ0BYAUqAMAshtMxSSgst\nhZZCgdJCKaOlLauFr6WQMsqGACEkQAiBJCRx9nScON57b1vWOt8fkhXvKQ/Z574uX5GOzvvqKIl+\nPuN5np+QUqJQKBTugmakB6BQKBT9QYmWQqFwK5RoKRQKt0KJlkKhcCuUaCkUCrdCiZZCoXArehUt\nIUScEGKzECJNCHFUCHGXo32uEGKnEOKAEGKPEGJRm2seEEKcFEIcF0Isb9O+QAhx2PHa80II4Wj3\nFEK862hPFUIktrnmJiFEhuPnJld+eIVC4YZIKXv8AaKA+Y7HfsAJYDrwJXCRo/1i4BvH4+nAQcAT\nmABkAlrHa7uAJYAANrS5/g7gX47H1wLvOh4HA1mOP4Mcj4N6G7P6UT/qZ+z+9DrTklIWSyn3OR7X\nA8eAGEAC/o5uAUCR4/HlwDtSyhYpZTZwElgkhIgC/KWUO6WUEngduKLNNa85Hn8AnOeYhS0HNkop\nq6SU1cBG4MLexqxQKMYuuv50dizb5gGpwN3AF0KIv2FfZp7u6BYD7GxzWYGjzex43LG99Zp8ACml\nRQhRC4S0be/imi4JDQ2ViYmJ/flYCoVigOzdu7dCShk2nO/ZZ9ESQvgCHwJ3SynrhBCPAb+SUn4o\nhLgGeAU4f4jG2dvYbgNuA4iPj2fPnj0jMQyFYtwhhMgd7vfs0+mhEMIDu2C9KaVc42i+CWh9/D7Q\nuhFfCMS1uTzW0VboeNyxvd01Qggd9uVmZQ/3aoeU8iUpZYqUMiUsbFhFX6FQDDN9OT0U2GdRx6SU\nT7d5qQg42/H4XCDD8XgtcK3jRHACMBnYJaUsBuqEEEsc97wR+KTNNa0ng1cDXzv2vb4ALhBCBAkh\ngoALHG0KhWKc0pfl4VLgBuCwEOKAo+1B4CfAc46ZkRHH8kxKeVQI8R6QBliAn0sprY7r7gBeBbyw\nnx5ucLS/ArwhhDgJVGE/QURKWSWE+BOw29HvUSll1QA/q0KhGAMI+4Rm7JCSkiLVnpZCMTwIIfZK\nKVOG8z1VRLxCoXArlGgpFAq3QomWQqFwK5RoKRQKt0KJlmJc8PLWLD7eX4jJYhvpoSgGSb/SeBQK\nd+UfX5+kttnMkxuOcU1KHJfPjSYp3G+kh6UYAGqmpRjz1DaZqW02A1Ba18I/vj7J+U9v4fJ/buOd\nXXk0tFj6fc9mk5XsikZXD1XRB5RoKcY8+/Kru2w/WFDL/WsOs/Cxr/j1ewdIzaqkr3GLb6bmYjRb\ne++ocDlqeagY82w/WdHj681mK2v2FbJmXyFTIvxYmRLLFfNiCPX17LJ/UU0znx0u5sujpXh6aLj7\n/MksSAgeiqErukCJlmJMYzRb+eJoaZ/7Hy+t57HPjvHnDemcOzWcqxfEsmxqOB7aU4uSDUdK2J9X\n43y+J6eae5dPYcXsKCL8DS4dv6IzSrQUY5pDBbXkVTX1+zqLTfJlWilfppUS6qtn1cI4rpofi01K\nXtue065vs9nKo+vSCPT24PvzY7u+ocJlKNFSjGnSS+oGfY+KBhMvbM7khc2ZxAZ5UVDd3GW/13fk\nKtEaBtRGvGJMs+VEuUvv151gAVQ3mVz6XoquUaKlGLOYLDZSs4avklFxrZHGAYRPKPqHEi3FmCU1\nu5L6YRQRk8XGr949wObjZVhtY6vk02hC7WkpxixbM3oOdRgKWjfvowIMrFoYxzUpcQgBAkFkgDpZ\ndAVKtBRjlq/Ty0bsvYtrjTz7VQbPbcogOdyPE2X1nDslnMvmRnPu1HD8DB4jNjZ3Z8AO047X7hRC\npDvan2rTrhymFSNKflUTJ8saRnoYSGmP/ZISNqWXcdc7B1jwp6+45dXdfLy/kNom80gP0e3oy0zL\nAtwjpdwnhPAD9gohNgIR2E1W50gpW4QQ4QBCiOnYa7zPAKKBr4QQyY468f+HvbZ8KrAeu/HqBuDH\nQLWUMkkIcS3wF2CVECIYeBhIwW4Ou1cIsdZh3KpQdMunh4p67zRCmKw2vk4v4+v0MrQawVmTQ1kx\nO5rvTY8gwEvNwHpjMA7TtwN/llK2OF5rnYsrh2nFiCKl5OP9nZzmRiVWm2Tz8XJ+8/5BFj72FZuO\n9T16f7zSr9PDDg7TycCZjuXct0KIhY5u3blCx9BHh2lgwA7TCsWx4npOlI780rC/hPt7smRiCF+l\nlZJZ3qBqf3VDn0Wro8M09qVlMLAEuBd4r3WPargRQtwmhNgjhNhTXu7aYEKF+1HV2MKUiFO1sjy0\ngsUTgtHrRneEz8LEYB79NI1H16Xx8tasET1IGM0MxmG6AFgj7ewCbEAoymFaMUJYrDaeWH+Ml7Zm\n89TVs4kL9iLcz5OYQC9Ss6uYGe0/0kPskeuXxJNf3UReVRNv78onrahWxXt1wWAcpj8Gljn6JAN6\noALlMK0YId7elcdLW7LYcqKckjojf7xsBr88L4mVC+KID/bGbB29y627z5/MvLggZ5pQYog3P1qa\n2K6+V71RnTTC4BymVwOrhRBHABNwk0NolMO0YtixWG383zeZzud/+Tyd4hojzWYrQsBfvj+b13fm\njNwAuyEhxBudRnD53BiufyXVWZFCr9PwxPp0/nTFTHRae1+tRlBaZxz35W96FS0p5Tagu72q67u5\n5nHg8S7a9wAzu2g3Aiu7uddq7AKpUHTLrpwqimqNzudZ5adKIUsJZquN9OL6kRhat5w/LYKqxhb+\n+cP5PLz2KNszKwEweGgI9fWkstHUro6XViOoajQp0RrpASgUrqCoxtjta1qNINDbA8so2x86XlrH\n09fMpaKhhY1pp0IdPvjZ6cyMCaDFYkWrOTVf8NRpmRblT7PJipdeOxJDHhUo0VKMCdYfLu72tSvn\nxbDp2Og7icuvaua21/cwIzrA2ZYc4cvMGPtzT11nYTKarVj7WMd+rDK6z4AVij6wN7e62/CAGdH+\nXDo7ijWjJNjUz6AjNsjL+by6ycy2NjXsA731zsfNps7GGQYPLb6e43uuoURL4dZIKfnjp0e7fM1D\nK7jz3CTufHv/MI+qe3574VS+uPssFiUGE+yjZ1KYT7vXD+TVOE85rVI6HX9MFhs1qsggoERL4eZ8\nfqSEQwW1ndrnxAVy45IENhwpoc44egrzPfTxEfbn1fDU1bN58OJpnDYppN3rb/5kMR5aDcdL6tmc\nXobBw75E1Os0eOt1PPjR4S5nYOMJJVoKt6XFYuWvXxzv8rVJYT6E+nnyyYHRlzidml1JYqgPV86L\nYXIbl2s/Tx3JEb7ctHoX8cHeXDonut11Oo3grVR7LNp4RomWwm35cG8hWd24PF80M5KnN54Y5hH1\njRpHORqtRuDlmElNjfRj62+XYTRZ2ZFVSUF1E5UNLRxpM4tsTZJ7eVsWWeXul1vpKsb3jp7CbWk2\nWXlpS2aXr62YFcnqbTmYraPrlE2rEXzy86XtKpg2O/asFiYGE+itp8lkITbIi08OFPGb5VMIaWMY\n22iy4uWhZfXNC5kY5jvs4x8tqJmWwu04UljLZf/cRk5lZz9DrUZwVnIYO7IqR2BkPWPQaQj382zn\nXP2DRfFMCPUhp9I+Y/TQarh2YRwvfHOSRz9Na3e9TmMv2dw6OxuvKNFSuB2fHS4mo5uqpCsXxLBm\n3+gIb+hIo8nK2oPt99j0Og1XzY/h8StmAXbRKqxuRkr4+EBhu/paBg8tiycEE+7vyXhGiZbC7fAz\ndL2r4anTkBTuR2r26E1P9dRpOp3+/eLcycSHeAP2EI7vHOk8VY0m9ufVYGsTye/v5THqlr3DjRIt\nhduR1M1+zqqFcfz3u5zhHUw/MHho+MfXJ0kr7hyi0YoQgjvOmeR8fsW8GNpK1L3Lpzhjt8YrSrQU\nbsfRoq6t7ieH+1JY070D9EhjNNu4/ZxJzrSdk2UNrD1YhKVDyZyzk8OICbRHzZfVG7HYTr3uodUw\naRxvwoMSLYWbYbbaeDM1t1P7lAg/0ktGVxWHrtifV+MMGA3x0RPo5eE8QWwlxNeTlSn2eplv7szr\nMgdxPKNES+FW7MispKKhczrLqoVxrDvUfdL0cLAgIajXPvPiA52Pg3z0nJUc1qUH4t3nJzM/PtAp\ncIpTqDgthVuxJ6fzJruPXovFaqO2eWQre5osNjy0oseN8uQ2teu7o7Va6TOr5o778IauUKKlcCt2\ndnEyuHhiCHtyR94Ks7bZTKivJ8W13df2qu5D0nN9iwWrVZIQ4tNr3/HIoBymHa/fI4SQQojQNm3K\nYVrhco4U1rKrC9Hy1Gkoq28ZgRGdQqcRTIvy61GwwL6n1Rv+Bg+CfPS99huv9GVPq9Vhejp2u7Cf\nO1ykEULEYTebyGvt3MFh+kLgRSFE6xy31WF6suOn1XjV6TANPIPdYZo2DtOLgUXAww6DC8U45O9f\ndp0cXdlgIniEv+RLJoaw+Xjv9nXv7cmnrL5nYVP0zGAcpsEuMPdBu1AS5TCtcCktFiuv78jpVhSK\napsJ9xvZKPGKhhY8tb3PAeqNFv63I5fKhpGdGbozA3aYFkJcDhRKKQ926KYcphUu5e9fnuAPn3Rd\n6A/sQjDSM630knoWTgjuU98Vs6M5XlrPtyeUsfBA6PNGfFuHaexLxgexLw1HHCHEbcBtAPHx8SM8\nGoUrabFY2XCk51CGhhYLgd6dwwaGG58+lkG+6539pJfUc3ZyGGcnK3Ph/jJQh+lJwATgoBAiB7vz\n8z4hRCTKYVrhQmw2ej32t9oknqPA8t7uSdj7MrU1CHZf3sifeLojA3KYllIellKGSykTpZSJ2Jdt\n86WUJSiHaYUL+c/WLE6U9l7wbjS4g503Nbxf46g3Wth0rLRTGo+iZwbsMC2lXN9VZymlcphWuIQD\n+TU8vymjT31HWrQmhvkwOzaQ8n6EXuh1Gn7y+h5CfD158OKpXDkvtveLFIN2mG7tk9jhuXKYVgwK\nm01y/4eH+myw6urV4YRQH5bPiGR3ThV7uwhcFcK+bG1ylJm5cUkCiaHe/XqPYG89kyN82ZpRQXGt\nESklQvT4VVOgIuIVo5R1h4v7lQDdYnHtVCu7opF/b8nksStmUt1kIqu8fS16Lw8t06P80WoEu3Oq\nuHh2FAfzuy45E+KjZ9nUcM6ZEkaIjyfpJXXsz6th7cEifrQ0kcUTgrn97ElKsPqIEi3FqMNqkzzd\nTSBpV2g1AtsQuC5LCS9uzuSJ78/i718eJ7OsgUbHzKrJZGVPbjUPXzqd86dFEO5nIMT3VFkcjYB7\nLpjC1Eg/TpsUgrf+1FfttEkh/GgpxAR58dymDN7/2WlKsPqBEi3FqGPtwcIu67/3hH831UwHS2FN\nMx5awdpfnIHVJsmuaOTqf213OupMj/Jn8US7d+H8+CAWJASxN7eaFbOj+fmypB7vfd/yKUyJ8OPr\nY2Xc895B7liWxKWzo5SA9cLInxMrFG1oMll46vO+z7LAPjOraDAxOzagz9dohL2UTEpCEAFePcd4\nrT9sjxPTagRhfp7twiv+/Hl6u3LIV8yzxz73pbqoEIIr5sVw53mT+cMl03lpSyZX/d92Ptxb0Ou1\n4xk101KMKv6zJbvXpOOueH5TBs9cM4fffXykV0fpG09L4PK50cyPt6exNputvLg5k39uPtll/yvm\nnkrCCPDy4OUbF/LpoSKsNsmkMF9sUqJxnFXdsCSBM5NCya3q30zx9KRQPr5jKY98epRREL0xqlGi\npRg1VDS0dOtl2BsWm2R7ZiVPXjmLL4+VkppVRUldZ/G7/6Kp/OzsSZworafFYsPgocVbr+OeC5KR\nSEpqW5ge7c+zX52g3mjh0jnRpCS2T8+ZFRvArB5mdYmhPiSG9r+sjE6r4TGHK4+ie5RoKUYN//z6\npHOjeyB8l1nJitnRfHKgiEWJQZ1E6+zkMH561kQAXtqSxeVzozlzsj2DQgjBvcunOvsunxFBeX2L\ns1b7YJBS8r+duQR66ztZ3Sv6jxItxaigoLqpy9rv/cFitbE1w56EvCunmkWJQTS0WEkrriM2yIun\nrp7t3OT+/YrpBDjyFXMrG/nmeDkrZkc5jVRjg7yJDepf3JXRbEWrEXi0qfZQWmfk8yMl9mWfhJ1Z\nlVy9IJZZMQHo+lAVQtEZJVqKUcEzGzMG7ecX5m8gLviU0OzKqSbcT89bty4mKdyXcP9TdvTFdc2c\nLK9nQUIwP35tDyfLGnh7Vx4v35TSL7EqqzeyLaOCpUmh/GVDOosmBHPtInvSfl5lE5e9sM150gjw\nZmoeb6bm4aPXMi8+iOhAAzYJM6L9WZkSh2+HpOu8yiYeX59GbJA3D62Ypk4WUaKlGAUcL6lnzf7B\nnZhF+ht4+NLpvLY9p117Wb0JCe0EC2BqpD8ANU0mTjrcqtNL6jnzqc0kBHvzi3Mnc/WC7tNqqhpN\nzhSjV7fn4K23R8cX1DQ7RSsu2At9N7OpRpOVbScrnM8/2AuPfXaMgw9f0E64NBr44mipY8x+rEyJ\n63Sv8YYSLcWI8+cNxxhMbOiMaH9ev2URGiE6uTcvSAhiycSQblNkOqYJSQk5lU385v2DZJTVc/d5\nyXjpO1eZ0ArBxwcKnbOo1nSegqompJTUNVt45btsyvtR7M9Tp8G7TUWL1riwVv71bSZXzosZ98tK\nJVqKEWVXdlWfyhR3h0bAs6vmcrKsgR++nIp3G4FZNCGYF6+bT1WjiTvf3kdNk5nzp0WwICGIpUmh\n6HUaQh3Jyk+sT+90739/m4XJYuPhS2d0em3DkeJ2y75W/L08SM2uorTO2Odk71aaTFa+TCtl/eFi\nciobqWkyk9cmdCKzvJGdWVWcMTm0h7uMfZRoKUYMKSVPfd5ZLPrDWQ435ltf34PVJql3xGh567X8\n9erZ+Oh1XP7CNmd5m9Z8xnOmhPHidfPx1uv40dIJrDtUzOHC2k4zvsYWCxarrd3spqTWyJ7cavRa\nDaYOZWXSS+q59qWdA7b++tn/9nbZrtdqSI70pcUy8NPVsYISLcWIsf5wyaCsvwK8PHhoxXRe2ZZN\nboe0n99eOJWEEB8e/TSty3pc3xwv58n16fzpipl4aDWs/cUZGM1WDubXsCu7Ck8PDb6eOppMFprM\nVvwdotVisXL5C9soret52dfRNXqwmKw2UhKCOW9ahEvv646M78WxYsSw2WS3Eeh9YWKYDxt/dRZJ\n4b4E+uiJbLPRHuKj57I50by0JZPXd+R0utZDK5gW5U9KYhBGs9WZhmPw0LJ4Ygg/PXsSKxfEMTMm\ngL98fpyaxlPLQE+dlvuWT3WGRgwnr+/I6bHaaYmjvM1YR820FCPCF0dLOFZcN+Drz0wKJdzfQGZ5\nAzcsSeCGJQl8e6KcrSfKufO8JD7cW9jlPhXAnNhAKhtN3P3uAZLCfHnjx4uJDLCLXrPJyjfHy/jd\nx0fwN+j428o5xIe0D4G4akEs8+IDiQ704s6397MxrXTAn6M/2CTc8b99rL/rzE5GHrVNZpY/u4XT\nJobwt2vmdAqdGEuomZZi2DGarbzaITShv2zNqEBK2W6GdXZyGA9ePI01+wp5dF1at9fuya0mu6IR\nKSGjrMG52b32YBHTH/6c29/cR1WjiZzKJv6yIZ0tXbjmTAzzBewnfMNJSZ2Rv35xvNOM6v29+dQ2\nm/n8aAlX/9928vuZ++hODNhhWgjxVyFEuhDikBDiIyFEYJtrlMO0ols+O1RMahdO0f0hq6KRkjoj\nPp46HlhziNOf3MT2zApue2Mvf/y0e8Hqim0Z5UgpCfHRd9qIL6o1cuPqXfzq3QPUNrc/LTR4aFnU\nR9swV/J1emmnA4Dv2sR8pZfUc8k/trHp2PDMAIebwThMbwRmSilnAyeAB0A5TCu6R0qJ0Wzt1im6\nP4T46An00pNWVMfbu/IpqjXyw/+k8tUAvqgvbc3CapNoNd1Hm3+0v5Dzn/6WdYeK2s1yzJbhN6Uo\nrWvhk/1F7do6WpHVNpv58Wt7eO6rjHalc8YCA3aYllJ+6TBWBdjJKXsw5TCt6JLM8gYe/+wYRQMo\nPdORJ78/i9yqRrQaQdAgPQ+tNslZT23m2pd29tivvL6FX7y1n5v+u5t8RxCpKz7LQPjL5+ntloBB\n3ZjVPvPVCX7y+h7qjZ1jytyVATtMd3jpFk456yiHaUUnmkwWGlqsrNk3+AJ3vzo/GZuE+z44xJRI\nP/59Q8qg7me29k98qhtN6HUahBBMj/Ib1HsPlMpGEze8kkp1owmA1duyu+27Kb2My/75HUcKu65h\n7270WbTaOkxLKevatP8O+xLyTdcPr89ju00IsUcIsae8XFmNj0ZOljWw4UjxoErPAMyJDeCalFj+\ntC6NRy6dwZupudz1zn4XjbJvLJ4QTITjAKBtgvZwk1PZxK/fs7v6RQX0XEKntUz0pweLeuznDgzU\nYbq1/WbgEuA6eWqhrxymFe2oM5qx2CQ7MysHdR+dRvD4lbN4bP0xfr4sif/tzOV3Hx0ZUKXTgRAT\n6MVbP1nMAxdPc7YtmRjCillRRAUY+MGieHrYFhsSNh8v5/qXU9Fqe39jo9nGnW/v56nP04f91NOV\nDMhh2tF+IXAfcJmUsu35qnKYVrQjs6yBPTlVHCwY3PLkznMnU1DdTGVDCwFeOtbs7/T7a0gprGnu\nlG9o8NDywnXzefG6+Xx1rHRETGO3naxgy4lywv36FvD64jeZ3LR6l9vuc/VlptXqMH2uEOKA4+di\n4J+AH7DR0fYvsDtMA60O05/T2WH6Zeyb85m0d5gOcThM/xq433GvKqDVYXo3ymHa7TBZbORVNXUb\n6NlX5sYFsnJBDL//5Ah/vGwGT24Y3P0Gyp/WpZFZfiotSErJ7pwqbv7v7n65S7uaeqMFrUYwoY9l\nnredrGDlv3ZQWNPce+dRhhhrYf8pKSlyz549Iz0MBfZTuZNlDfzsf3vblVjpL9EBBj7++VL+uC6N\npZNCKaxp4oXNA6sl7wo8tIKLZ0Vx0cxIDhfW8vLWbFpGIPShK7z1WsxWW58LKob66nnhh/OdNmj9\nRQixV0o5uJOQfjJ2Y/0VI45GwJr9BYMSLA+t4KUbU9h8vAyrVbJoQhAXPXfEhaPsP2ar5JMDRXxy\nYPRtajeZrPjotZitfTvwqGgwcd3LqTzx/Vlc4yYFBlUaj2LIsNgkG48OLir7Z2dPItTXk5e3ZvP7\nS6bx8Nqjgy7LPNbp7wmtxSa574NDPLL2qFuUvlGipRgSpJSsPVBE1iBmWYsSg/nluZO5f80h/n7N\nHHZmVfHdycGdQCq659XtOaz6907KurBeG00o0VIMGRuOFA/4Wm+9lr+unM03J8q5an4sYX6ePLL2\nqAtHp+iKA/k1vL0rv/eOI4ja01IMCSdKG9g+iLis+5ZPISHEB5uEuCAvfv/JUepbenaOVriGin7U\ntR8J1ExLMSQU1Ta3q9feH6ZF+XPDaYlYrDYmhPrwz80n+fZ4GQYP9d91OCgd5ctDNdNSDAkhPnqg\n/+HhWo3gL1fNQqsRSGkPm/jsUPGIJSaPR+pGedCp+tWlGBI0AzQVXTEritmx9tJsQgjeTM0lo6xz\njXewC1xs0OBt6xXtqWwwjfQQekSJlsLlSCnJLG+gtrn///kXdiiqt/5Q95v5UyP9Rv1Sxh0pGeWz\nWrU8VAwJB/JrBhRPNalNGkpFQwsVjSbuOi+J8gYTBp2WioYWNqeXMSHMh4YWi4rZGgISQr27Nbcd\nDSjRUrgce50p/35f52/Q0VaCQn09efL7s7j+5VRnmoyvp447z02irM7I27tH99G8u3L3ecmjVrBA\nLQ8VQ8RAEnFnxQawpE0OnMVq49fvHWiX19fQYuE/W7N5IzWP6xYnuGSsilNMi/LnvGnhIz2MHlGi\npXA5VY0mZ0XN/lBSa2xXp72m2URxTef9lYqGFkwWG/vzqztZaSkGx13nJY3qWRYo0VIMAVtOlHNo\nAKV9syoa27nKhPoa2s28OrInp5qrF8TiM8B4MEV7pkb6ccH0yJEeRq+oPS2Fy7Ha5ICOzaWEd3bn\nszQp1NkW6tvzTOrlrVksmxJObLAXGuDNXfmYRkmZGHdBI2ByuB8PXDwNzXCXXh0ASrQULsVmkySG\neuNnGNh/rY7OOlqNBg+t6PaU0Cbtxg1gL8d821kTePGbrAG993hiWpQ/l82JZmlSCMkRfhg83Ge2\nqkRL4VI0GsGChOAB7WkBTA73dT42ma3syq4kLtibrPLeq0VYbBI/gwf3XTiFL46WcjC/ZkBjGKvo\ntRpWLYzjhtMSSI4YGRchVzAYh+lgIcRGh/PzxrYmqsphenxTVmcccNrNVEeohJSSdYeLya9u7pNg\ntbL+cAnl9S1KsLrgHz+cx5+umOnWggWDc5i+H9gkpZwMbHI8Vw7TCnZkDay6gxD2zWCA4lojj3/W\nP3t7gMOFtXi70VJnONmfNzaEfMAO07R3hX6N9m7RymF6nPL4Z2k8s/HEgK6dFumPn8G+p/X0l8ep\nbOxf4m5UgIHFE4JpMlkdCduKtuzNHRueMINxmI5w2IIBlAARjsfKYXocsz+vhpzKpt47dsG5U+1B\njY0tFj47XNKva330WubFB7Int5rcqiaiAw0DGsNY5khhnVv7HbYyaIdpAMfMacT+NpTD9OjB38uj\n907dcMmcKAC2Z1bSbO5frfJAbz35Vc1YbZKs8gaKughKHe80m62c7KZihjsxGIfpUseSD8efZY52\n5TA9TmlosbAre2BLkPOnRTA10r4JnzqAPbEQX73TaTqnsolJYX3z/xtvpBUPzjB3NNBryEN3DtOc\ncoX+s+PPtm7RbwkhngaiOeUwbRVC1AkhlmBfXt4I/KPDvXbQxmFaCPEF8ESbzfcLgAcG/GkVQ0p6\ncR0NPZREnhcfyJzYQGbGBGC22qhqNBEb5MU5U8IJcMzQKhtaODyAaPpDBbUkhnhT4ZhINJtVgGlX\ntIyBv5e+xGm1OkwfFkIccLQ9iF2s3hNC/BjIBa4Bu8O0EKLVYdpCZ4fpVwEv7O7SbR2m33A4TFdh\nP31ESlmjwAKUAAAgAElEQVQlhGh1mAblMD2q6am2+L9vWMDyGT2niORXNXEgv4bQPtq7d6TtXtrh\nwlpmRPuTX91EXbOqLd+K2ToOREtKuY3u6+ae1801jwOPd9G+B5jZRbsRWNnNvVYDq3sbp2LkabHY\n0Ah7lHorsUFe3LAkwZmak1Faj03Cntwq9uZWU1bfQn2zmUcum0FCiA9v7MxlYh+t3XvjaFEd4X6e\nhId7crJs4FZmYwnjOJlpKRR94rI50by+I5e9udXO5788L4mEEB88tBrWHyrizxuOkVfdeZP8ifXH\n+O+PFnHxzEhe3pbdY+pOfyirb3GLfLrhwtjPA47RiBItRZ85WVZPk8nqrOHeESEEz66ay7NfZbBs\nahhzYgOJC/YG7HtVBwtquxQsgN051dz9zgE8dRo0wjWC1UpJrZGpkX6kl9S77J7uSoPJ/ZfKSrQU\nfaK2yczvPjrCwsTgbkULIC7Ym7+tnN2pJtPaA0WsO1TU43tsPl42ZHFEUkK4nydl9aPb02+oMZrc\nf6al6mkp+oS/l44fLU3knguSe+3bUbCsNolBr6Wwl9ipoQx8PF5aj9FsZXZMwJC9hztgGgM19dVM\nS9EnhBBcODNqQNd+uLeAV7/Lce2ABkCd0YKhHwUDp0f54a3XodGIAcefjTbGQq0xNdNSuASrTbLq\n3zuY/6eNPPdVhjNeq7S2mSNFtRwvHR37SQfya0hJ6DnnXqeBRYlBpBXXsye3ekwsqVoxWtz/syjR\nUvTKB3sLeOrzdGw9LN+e3nic1OwqqhpNPPPVCbSOJeK+vBq8PLR4jxJLe5PFRmUPtb70WkFyhD+7\ncqqdbT3Fn7kb4yW4VDHOuWp+DMdL67sNHVh3qIgXNmcC9sTllSlxeOm1ZJc3sD2zgjd25g3ncHsl\np7IRX08tDS2dZx3JEX4cKWqXWktxnREvD82YiLKvH+WW931BiZaiV4QQzrzAjtQ0mbj3/UNoBFy3\nOIGfnTOJmEAvKhtaeHVHLt+eGH0J7FLCjOgAUrOr0GnAYoPoQAPhfgYOdFE8UEpICPEZEyETNU1K\ntBTjnAAvDx6+dDoTw3yZHx+ITqshp6KRXdlVvLY9Z6SH1y378qqZEe1Hi0Vi0GnIqWyiqKb7Inm+\nnmPjq2K2uf9scWz8SyhGDCEE1y6Kdz7ffrKCr9PLKKjuv1nrcGK2So6XNGDpY5hFWX0LUyL8Rs2B\nwkAZC/W0lGgpXMaGw8Xc/uY+tBrhFl+OvgoWQF5VE4sSg4dwNMODWYU8KBSnaD1lcwfBGgj786vR\nunka4/Ro9w+uVaKlcBnLZ9pLz+jGaIKy2SqduZTuygXTI3rvNMpRoqVwGR4aDT9cHM/EMVw1NMR3\nYLW+RgvJke5tHwZKtBQuJKeykbvPn8z1SxKcTtFhjoJ+8W4+Q2mlqrHFrfe2Ojp4uyNKtBQuwx5Q\n2siqhXHcfs4kFk0IZlZMABH+nlw1P7b3G7gB2RVNVDUNzD17NBA2wKqwo4m+OEyvFkKUCSGOtGmb\nK4TYKYQ44HDBWdTmNeUuPU6JDvSiuNaIp05LoJee1Tcv5O8r5/DQium8tye/9xu4CXlVTd2W8h3t\neOrc38i2LzOtV+lskPoU8Ecp5VzgD47nyl16nONv8MDPoOO93fksmRiClJLjpfXMjQskKdx3pIfn\nMsxWm9v6KuZVDcyTcjTRF4fpLdjNJto1A615HQFAa3U35S49zjlvWgQXzIhACHhkbRpfpZVy0+pd\nHBmAw85oZV5cYJe1wXQawdQeNrpnxvjjbxjZ0EjvfpTmGa0M9G/wbuALIcTfsAvf6Y72GGBnm36t\njtBm+uguLYTot7u0EOI24DaA+Pj4rroohonNx8uoajBxvLSeAC8PXt6WPdJDcikBXh6IHtaGc2ID\nO+Uohvt5cv2SBHZkVnL2lHD0Wg3rDxf325DWFXx2qJhbzpgw7O/rSgYqWrcDv5JSfiiEuAa7Bdj5\nrhtW/5BSvgS8BJCSkjI2IxvdgHqjmaKaZp5cn44A6nvwQHRHpkf5ER3gxVfpZV2+brFJZ5T9hFAf\nyuqMNJqsnDctgtd35I6KEjdr9he4vWgN9PTwJqDVafp97HtOMALu0orRQ3l9C4fya2k2W8ecYAHE\nBHkzNarnOCerIyFZr9UQFehlvy7QMCoEC+y2ahY39z4cqGgVAWc7Hp8LZDgerwWudZwITuCUu3Qx\nUCeEWOLYr7qR9o7UrSeDTndp4AvgAiFEkGMD/gJHm2KUIaVka0Y5H+0v5Iu0ErdP44n0N+Cp6/zV\n2JhWyqGCWqIDut+EF0Kg0wh8DTryHZveNgnaUZIlICVkV7i3B2RfQh7exm5XP0UIUeBwlP4J8Hch\nxEHgCRz7SVLKo0Cru/TndHaXfhn75nwm7d2lQxzu0r8G7nfcqwpodZfejXKXHrWkFddxorSBf3x9\nckzUayqpMzIprOvTzi0ZFdx1/mRCfT3x9dR1OhXNKm8gKdyXmiYT0Y6ZVmZ5A9N6maENB3qthmtS\nYonoQXTdAWGf1IwdUlJS5J49e0Z6GKMSm00iRGe3nMFy59v7+eJICSY3XXaE+npS2dhC269CfLA3\nTSYLFQ2dA0lXLYzjj5fNoKyuhStf/K5d+WZPnYYLZkTy6cEi/nvzQv60Lo3FE4MJ8tbz4jeZw/Fx\n2uHnqeP60xKYGxdISkKQy9OQhBB7pZQpLr1pL6jSNOOAFouVd3bl88xXJ4jwMxDg7cHKBbFcvSB2\nUALW0GLhWHEdCcHebitYAL6eWr4/fyIvbclytuVVNXHaxBAqGio79Z8dG4DBQ8uH+wo61Ztvsdi4\nZHYUF86I5JwpYSxNOgujxYqnTsP2zMouK6O6gmlR/tQ1mymsOVXH7ILpETx19WwCvfVD8p4jhRKt\nIaa22QwSvD215FY2kRjijU7r+uyptKI6vjtZgcUm0QiYExdIcW0zeZXNvJma6zQpbV2+7cquIqey\nkZ+ePQl/w8Dy0ZpNVnz0Ol745qTLPsdIkFPZxFfHSvE36KgznjpAKKkzcvWCWD7YW9Cuf0W9XaiW\nJoXyr28zabHYCPXVE+FvIC7Im5hAL2Y6/BX1OoHesT/26o8W8smBIp7flNGjucZAOFZcxyWzo5gQ\n6sO2kxUA/HBx/JgTLFCiNWRIKXl5azabj5exN7ea1Tcv5LHPjnHF3GhuO2siYF+mvbw1i5omM79Z\nPmVA79FisfGvbzN5YfPJflvJv7A5k/yqZp5ZNbdfG8UF1U08uT6dr9PLMHhoGAs7DFnljSybEsYV\n82K4650DABRWN/P6LYvYm1tNdkUjXh5aFk0IJsoRDb9oQjBb7luGv8EDrz4EbQZ667np9ER+uDie\nl7Zk8dKWLPsvNRex7lAxK2bZhSu7ohGDh/sHknaF2tMaIp7ZeILnNmV0ag/y9iAhxIfEEG+uSYlD\no4EQH08mR3TeqG02WTmQX8OXaSXUNVs4b1o450+z10P6cF8BeVVNfH2sbFAlgB+/ciaXz43pVw30\n3310mDdTR5fDjqu4dmEcQsDbu+xxzZfOiWZqpB+rt2Xz2i2LnDMoV1BaZ+S5TRm8sysPVx64/nBx\nPG+l5vH53Wd2a0jiKtSe1hjhP1uyuhQsgOomM9VNNRzIr2FjWin3XDCFq1MCaLFY0Ws1FNY0sz2z\nkoKqJt7dk09p3an4ng/3FRDk7YHZKp1mqINlXlxQvwSryWQhq9y9j8x74p3d+Ty0YhpTI/1IL6nn\n04NF/OTMpayYFUViaNd1wopqmp0nha0cKaxlepQ/Go1gb24VCxI6l7OJ8DfwxJWzuOm0RB76+DC7\n23gtDgYPjSDUV09xjXHIRWskUKLlYj49WMTj64/1qW+jycqj69J45qsTTAz1IT7Ehy0nyqkzmrtd\nclW7OKSgtN5IstW3z/tsVY0mdmR13pweSzz22THeunUxr+3IIdLfgEaIbgWroLqJFc9v45OfL23X\n54O9BZTVG3nu2nnsza1mTmxgt3/HUyL9eP9np7M7p4oH1xwmo6xhwGOPCjCwIDGYO8+bzPt7Clg2\nNXzA9xqtKNFyIbVNZp76Ir3f19UbLRwsqOVgwfAnFccEevXrYGDNvrGflCCE3T7+3zf0vurZdKyM\nMyaHEtkh9um8aeHc8MouUrM2Ud9iYcnEEGbHBvZ4r4WJwXz5q7O45/2DfHKgqN9BupH+Bu6/aCqX\nzYnGbLURF+yFlNLlIS4jjRItF1HdaOKm/+4iv2p0W2d1pD9fDCklHx9wL9HSCPq1X+TloeWvK2dz\n7tTua6nvzKrkv99ls3xGJPlVTTx48bROm96nTwrF4KFxnhIezK/pVbSsNolNSv529RwumR3FA2sO\nt9se6I4JoT7ceuYErpof6xyHh1bDJbOje73WHVGVS13E/32byaERmCkNliZT3/fGjhTWud1+1h8u\nmc6Pz5jQ59PRF66b1+uX/aN9hVQ2mAjy1vPgxdOI6bCfBZBb2YjRfCp2rbXyw8/f2sfe3M57VzaH\nsnpoNWg0gnOnRvD1PecwJ7b7jf+oAAOPXTGTjb86i+sWJ4zZ08KOKNFyEVtGof17X8ivaiavsm+F\n4fbnu2ajeDh55NM0MssbeP7aecyN636mExfsxS1LJ7QTmlaklJxss8+0fGYEf7x8BksmhvD4+mMU\n1XSeXadmt884++xwMfVGM1nljazZ1z7uy76E65yf6OOpw9/LHkOn77CEv+OcSWz+zTlcvyRhSOL+\nRjPj69MOIfVG96xqYJOS+JC+mU6U1nUufOcOfHO8nLvf3c+SiSE8tGIa4R3qpMcEevHh7afzh0un\nc5HDBq2VeqOZu989wGX/3EZreNAXR0pZ8fw2pv3hc/bmVjtPDndlVzkrKCyfEcmkNq5ENU1mvv/i\ndlYuiGHDkRKMjlpaUkr+l5rHrEe+dASqnqqx9e7uPLZmVPDIpdM58sflfM9h/xXqq+eX500eNzOr\njqg9LRcgpUTjpvLfn5OqKhdHcQ8nZqvkX99mEu7nyXPXzmNLRjmvbM3GZLVx7/IphPvZN9Lbblof\nLqjlF2/vI7eyiZtOS6CgupnYIC+uWxLPsqnheOo0JIR409BiYUdmpVNUAI4W1XZysK43Wgj01mOy\n2DheUk+Ev4E73tzLvrwa9FoN2eWN5Fc1kxTuy+bjZTz40RGSI3yds6nnrp3LdS+nMi8uaNwKFijR\nchkNbjrT+t+OXH50eiLh/r1n/nvr3f+/S1l9C/e8d4Bnr53H0kmhRPh3Hdi7Ob2Mn/1vLy0OG/mi\nWiOxQV4IIZgZHYCPp46C6mZe35HLw5dOZ07cqb2nnIpGUrMqqesQ7Z4U7svMmAASQ72JDfLi86Ml\n7Muz5yIuSAjiiStncv+aw2g1go8PFGK1Se6/aKpz+WfQablhSQIe42w52JHx/eldhBCiy//47kB9\ni4VbXtvdpyJ1wT5jI4+tqNbINf/ewZ/WpXX575ZV3sBPXt/jFCyw53a2zsKK64y8lZqHn0HHXedN\nRgjhnKkBFFY38enBok4xddtOVvDhvgKWT4/EZLUxOdz+3n4GHZfOieZIUR3v7y3gnd35GM02fn/J\nNJZNORVnJbGXbv5oX4HbF/IbDEq0XMRIGxYMhiOFdfz4tT1U97L8S3ZTYW6lo6lDdxb3e3Or2y3t\n4oK9uOv8yc7nMYFe/P6S6cyPDyKoCyGvbDJ3uaHvoRXct3wql8+NYX9eDQsTg5gY5oOvp46rFsTw\nYYcN+hazrd1yVSPgo/1FfH28nPJRUgl1JFCi5SJclVYzUhzMr+HOt/f3+Bt8shvbgGk1gr9cNRuf\nNsJl7uazLk0K5cbTEvjJmRN4/2enseXeZVyTEtdl347UG828vj0Hq5R4aNufBpqtktI6I/Eh3syP\nD0IIwfIZkYT7GzhZ1sCHHapJHC+p4+1dec5wiPL6FoSwi2hlF3W+xgtKtFzA4YJadma5f1HVbScr\nekyETgjxZkGCe1lPLp8RQbifJ1ab5HcfHeZX30umNbJgZ1Ylj36a1sneLDrQi0cvn8nvVkxnYWJw\nrxHlJouN93bnY7HaMJpt/Ov6+ay78wxSHzyfh1ZMY2bMqfy/h9cepc5odkbQz4sL5M5lSby/p4BG\nk/3kUK/TcPGsSLIrmnjis2POWVWLxYZOI5gU5su7u8eO+W1/GZDDtKP9TiFEuhDiqBDiqTbt485h\nuqjWvaLge+LV7TlUdrP0EELw7Kq5brUUjgvydoYX1BktvLQliwcumgbYReCzw0U8sf5Yt7OurpBS\nYjRbOVpUy+dHirHYbDzy6VFueGUXFz67hSaTjcgAL4J99Nx65kQevHgas2IC8NFr8fXU4d3m5O+C\nGZGcPz2C5Ag/pkXZxe3cKeF8fqSEyRF+rL/rTCIchyTFtUYO5NfwzfFyPthbwGPr0th8vMw5ptSs\nSn793gF++fb+fn0ed2NADtNCiGXYTVbnSClnAH9ztI9Lh+mSWveMX+qK7IrGdhU8OxIX7M0PFruH\nt2SgtwdWKdsV9iurbyGvqskZaFpa18Lpk0K6PZF7csMxOpZvEkLw5w3p/PbDQ4T5GahsMNFkspKa\nXckFMyIJ9tGz7lARZXVGvkor5fRJoaxaGEeIrydfp5d1CiI1W23Migng2VVzeOTS6SybGs7qmxfy\n92vmEBfszd7cKu56Zz/NZitr7jid702PoNls5eVt2dzz3kFSHtvI3Ec3suqlnazZV8jag0V8vN+9\n0q36w0Adpm8H/iylbHH0aTWCG5cO015jLGbmP1uzeoySv2/5VOb0EF0+Wvj+vFjnLAtORZyX1Bmd\nMWdhfp78+IyJPd7n2xPlNJvaG6teNT+W/9yYwoRQH/759Um0GsG8+CDuXT6Fl7Zk8ou39vPennw+\nP1rifJ+8qiaCvD3aLTctVhuPfZbGY5+l8eBHR7h56QTOnRrOOY5Tw9zKRm7+724+OVBERmk93nod\nJ9rUT6tqNFHRYOpUTPDV7Tlj9oRxoPP8ZOBMIcTjgBH4jZRyN+PUYfrM5FD0Og0my9j4T2KTsOL5\nrWz77bkEeHcuxazVCF69eSH3fnCILSfKR219+Nd35PDElbNYd6gYm02y7pdnsuVEOaG+nkgkZquN\nS2ZH46HVsDWjnIzSBuYnBLVL97l2YTzhfp6dKpPOcuQE1jWZ8DVo+cGiOGICvQn20XN2cjgRAYZ2\novnnDfbqHw9cPI0mk8UZ82ay2lh3sAhvTx2XzYlGSklYm4j9e9476My2iA3yoslkoby+95PDo0V1\n/GHtUR69bMaYS/MZqGjpgGBgCbAQeE8I0fOvqyFkpB2mowK8eOyKmdz3waHhfusho77FQm5VI7O9\nu55RBfnoefmmFCxWG3lVTZwobeDtXXnsz6tutxwbLrw8tDx6+QzubfNvYLFJnthwjL+tnIPZasPX\nU8fiicFklDawI6sSf4MHGaUnOFhQw3cn7TXCHloxrZ1oJQR7U91kwmy1Eeitp6KhhdA2jjb+3np+\nvmwyWg0EeNnDHxYkBrEg0b6T4aXXYrbaqGo0oRF2U4zFT2zioRXTWLUwHm+9jj0Pfc9ZP611FvZ1\neikL4oOd9eVDfPScMyUcm5Q0dZj1dcdbqXkkh/ty81L3dpTuyEBFqwBY41jq7RJC2IBQBucwXdCF\nw/Q5Ha75ZoDjHXKumh/LX7843qffgu5CX8qi6LQaJob5MjHMlwtnRiKlZF9eNc9+lcHWjIphGKWd\nZrOVI4W1/OmKmfz183SeWTWXdYeK+Wh/IT99Yy9+Bh16raZXQ4m04rp2z4vrjPgZdPgbPNiWUcH1\nr6TiZ9ARG+TNw5dOZ8nEkF6Dbnc7chIXTQgmws9AQog3nx4sZtVC+6pACEHritFmk3y4r4BjxfUc\nyK9le2YlCxODWDY1nA1Hip2b8n0lp4/J8O7EQOeNHwPLAIQQyYAeqGAcO0xrNYJlU8JGehguIybQ\nq5MRaV8QQrAgIZjXb1nEQyumMZzGyq/tyOU/W7J46ydLaGix0Gyy8uSVs9AIe95fXxxwtnUQWo3A\nHooOBHh5oNdpqDfardMeWXu00yZ9KzabxGSxsTm9jF05VbRY7BHwGo3gqavmsHyGPU/RYrXx/KYM\nfv7mPn7w0k7O+utm3tiZy8wYf57flEG4nydv3rqEo0V1fLy/CItVkhzR93+X/pTSdhd6/UQOh+lz\ngFAhRAH2E73VwGpHGIQJuMkhNEeFEK0O0xY6O0y/Cnhhd5du6zD9hsNhugr76SNSyiohRKvDNLiB\nw7S7B5i24m/Q8doti5jQTYnhviCE4NYzJxIf7M0db+7rlDw8VORVNfHLt/dz7/IpfH28jPzqJm5Y\nksBrO3L7dH1ZfQu5lY0khNg/e1SAl3PTflZsAH+8bAb//S6bqAAvfv295Hab6marjaKaZsL9DFz/\nSirpxXW0WGxYbBKtRnD7OZMAmB7tz/Roe3jDmn2FPL3xRLsxfG96BK9sy3aO58Jnt5DlsLL/th8l\nkCaF+eCpG1v7WaDceFxGVnkD5z397Ziw0/rvzQtdWlv8H5sy+HuHL6armRrph04rOFJoX94tmRjM\nzacl8psPDnHjaQn8e0tWn6u0rr45pcfKpV2RXdHIb94/yL68ap68chY1zWYaWyyE+xvw0WuxSbh6\nQWy7az7aX8DX6eXkVzW1M3FNCveltM44oHJHGgErZkeTkhCERtj3Hoeygqly43FTGlos/OKt/WNC\nsP62co7LzRBuXppIVkUj6w4V9dubsa8UVDdz65kTnKK1M6uKvMomfnzGBErrjIT46J2Gtb2xO6e6\nk2jVG8349WBqG+HvyZXzYiisbub+NYd7FH4pJe/vLeDj/YVoNaJdWAbQruBgT/h56vAz6CiuMyKl\nfSn4zm1LXGpzNhpRojVIzFYbj61L67SB647ceFpCp9mAK/AzePCLc5M4mF/jXOa4moYWC0eL6vD1\n1BHm50l2RSNFtUZ2ZlWy+uaFHC2q67NobTpWym8vnOp8vjunihtf2cWFMyN5ZtXcLq/x1uu4fkkC\nob567v3gEMdK6roUrdYZWWvJZZ1G9Lp0jgn0IiUxiNggLyL9DcQEeREb5E1SmC8ajaDeaOZEaQNJ\nYb5dhqiMNZRoDZJms5V3xkAeWKC3B7/+XvKQ3V+v1XDVglg+3FcwZHXm58QGkBjizX+2ZjvbtBpB\ni8VGdZMJg4cGb70Os8XGxDCfbt2PCqqbMVtteGg1NJks3PLf3TSbrXy0v5CfnDnRuR/VFRfOjOKC\n6e2rn5qtNqSE9/fm8/uPj7Qz2uhKsPwMOqZH+XPm5FAunBnJpDDfHvMf/QwebpcTOhiUaA0Sg879\no+H9DDre++lpBHoPXb2sgupm1h4oGlJjjE8PFnPNwjgumhlJi8VGYogPs2L92ZlVyZXzYliQEMSM\n6AD8vXRICfP/tLHLmKcmk12grkmJI7Oskfo2Byw+nr3/e2vaHJk+vymD13fkYLFJarrxrPQz6Dht\nYghLJoawMDGYGdH+7e6haI8SrUFS3eTeJUKEgOevnTfktbK+OlbK8dJ6NAIunBnJ+sMlA7pPmJ8n\nfp46Z4G+OqMZk8VGi8VGSZ2Rj/YXMCc2kPL6Fj4/Usx/t2cTF+TNlvuWdbrX+dMiWHuwqMv3SSuy\nL/dbwz60GsGtZ0xwnir2hMli45vjZazZV8iXaSWdLMxmxviTFOZLcqQfZ00OIznCzxlEqugdJVqD\nZF8XdlDuxOVzojlniOLLdmVXkVFWz8zoAC5yLHPmxAWwwSFYAV4enXLmemLlglh8PHXMiglgyaQQ\novwNmG02jCYbdUYzQT56Z1yS0Wxlc3oZWRWNlNe3kFXewMSw9vFNp00K6VK0dBrBrWfao8i99Foe\nWjGN6dH+nD4ptF2/7ZkVfHm01L7XFGCgrtnC2oOFHCqo7TSDiwv24uJZUVw1P9btiymONEq0Bsmm\n9LLeO41STpsYwlNXz+lyvySjtJ7yhpZOX9S+YLNJ7nxnP58dKu70fhabjbOnhKHXafj4QGG/ROv9\nDkXy2jIlwo8vfnWW87nBQ8tFs6J6vF9eVedo8XA/T35zwRRig05VNb31zPYZanVGM4+sPdqr27Y9\n4Dic65bEc/bkMLXkcxFKtAZJzhCdhg0106P8+fs1c9B180VqMlk7ee31lYyyhk6CBbAjq5IdWfYc\nv/46P/fGyfKGXsMSOnJNShxrDxRx4cxIksJ9mRzuy5y4wB6NI3ZmVXLPewcp7MLrsJXoAAM/PzeJ\nS+dE49+P8Sj6hhKtQWA0W9nfJijQXZge5c+rP1rYowPPYErPTAj16bXqxUAFS6cRTIn04+zkMIpr\njRg8NPgbPLDYJC0WG/1ZeE0I9eG7+8/tU98Wi5WnvzzBS1uzuo3Hi/Q38KOlidx0euK4tvgaapRo\nDYKTZQ19jrIeLSSF+/LOT5cM6QxAr9Pw1q2L2Z5ZyTfHy5w2WX3BU6dhcoQvUyP9iQ6wxyRF+BuI\nDDCg02iIDfIadkHYl1fN/R8e4kRp10Gfk8J8uP2cJC6fGz3u7b2GAyVag+BoUddxPqOVmEAv3rx1\n8bAsWVISg0lJDOaX503myQ3HeGVrtjMmyd+gY1K4LwnB3kQEGIgJ9CLU15PYIC+SI/zw1Gl6rcs+\nHDS2WPjbl8d5dXtOl7OraVH+3HHOJC6eFdWpGqli6FCiNQg2ppWO9BD6jJ+njmevndvv0iau4Ffn\nJ3P/hVMxOYIs24qSyWIb0eN+s9VGk8lKgJcHZXVGhBAUVDeRX93MU5+nU1Ddee9qyUS7GA/kkEIx\neJRoDZDaZjNbhrFe1GCYGOrDY1fOZGFicL+vbWixDLq8SetyzrOLQNyRFCybTXLdy6nszqki3M+T\n8voWNKLrtJpQX09OnxTCtQvjOD1JidVIokRrgHxxtMQtyisLAX+/Zg7z4geW5lFU0+zWcUU2m2Tr\nyQryqpq4fnG8c4YnpWT1d9nsyrZXO2oteGjrsA6cHuXPT86awMWzoroUXcXwo0RrgGS0MRcYrYT6\n6nklFiMAAA7bSURBVHngomkDFixwT1dpk8VGvdFMWnEd/9mazRZHDaqP9hVwxbwYSmqNHCmqc7Z3\nRAi4dHY0Pz17ItOj/EfF/priFEq0Bkhf63SPJPcun8JVQ1C1YbQipeR/qXk8ti7NmebTln15NT2e\nZEb6G7gmJZbvz48lcRAFEBVDixKtAWCzSXZkVo70MHrkoRXTuHxul+ZFYxKL1cYfP03jjZ19q1Da\nip+njnOmhrMqJY7FE4NVyIIb0Jdyy6uBS4AyKeXMDq/dg92oNUxKWeFoewC7AasV+KWU8gtH+wJO\nlVteD9wlpZRCCE/sPogLsBtarJJS5jiuuQl4yPF2j0kpW/0Rh4XGFgtrDxbhZ9A5N7G99Foe/uTo\nkNWFcgVz4gL58RkTxsWyJreykYfXHiWtj/WyzkgKdeZaTon0Y05coIpadzP6MtN6FfgndmFxIoSI\nw242kdemra3DdDTwlRAi2VEnvtVhOhW7aF2IvU6802FaCHEtdofpVW0cplOwWwvsFUKsdRi3DjlG\ns5XvPf0tRW3coyeG+VBaa6RxlC4N44O9CfLR8+5tS8aFYEkpue31vRzvw/7iuVPD+fX3ksd8Vc/x\nQK+iJaXcIoRI7OKlZ4D7OOWqA20cpoFsh1nFIiFEDg6HaQAhRKvD9AbHNY84rv8A+GdHh2nHNa0O\n02/37yP2n5e3ZvHB3oJ2ggUMaS2oweJv0PHmrYuJDDCMmyVOVaOpV8E6c3Iov7lgils4Yiv6xoD2\ntIQQlwOFUsqDHX6ju73DdGFNM2/tyhvVAtUVd52fTFywd+8dxxA9pfOcPimEX5ybxGkTQ8bFrHM8\n0W/REkJ4Aw9iXxqOClzhMJ1b2YjRbOPnb+1zG8HSCFiaFMrUSD+uXzI4sR4rLJsSxt3nJ6uZ1Rhm\nIDOtScAEoHWWFQvsE0Iswk0dpgtrmrnyxe1Of7vRxNRIP24/ZxILE4P55EARf/k8HbDHYN1yxgTu\nOCdphEc4crStxXX6pBB+sSxJRauPA/otWlLKw4DTZsSxX5UipawQQqwF3hJCPI19I77VYdoqhKgT\nQizBvhF/I/APxy1aHaZ30MZhWgjxBfCEw10a7DO7BwbyIXvjP1uyRqVgBXp78Pdr5jgDHG8/ZxLH\nS+rYdrKS9b88o8fSMuOBmiYzp00M4Q+XTmdaVPdmE4qxxYAcpqWUr3TVV0rplg7TtyydwJupuUPm\nyTdQHr9iFtMi20dkT4n056JZUeNesMB+mvv2bUtGehiKYaYvp4c/6OX1xA7PHwce76LfHmBmF+1G\nYGU3914NrO5tjIMlPsSbqZH+HC4cXaVmLDZbuxK9x0vqOVZc57RXH++oQnvjk/FxNt4HRptvXFK4\nb7s65SW1Rm57Yw8/PXtiD1cpFGMflcbj4FffS2ZjWmmPtb+HA61GcNNpifxoaSJ+Bh0vbD6Jp07D\nmn2FLJ4QzIxoFRypGN8o0XIQ4OXBvPjAERUtvU7DY5fP5JqF9gPYOqOZFzafpMlkJSrAwIMXTxux\nsSkUowW1PGxDdKDXiL23n6eOD392ulOwAPwNHiyfEYmfQceL180fUgdohcJdUDOtNnxzfGQ8DOfE\nBfLklbOYHt352P53K6Zx9/mT++RsrFCMB5RoOahtNpNR1rXbylBxwfQIVqbEcUZSKF76rk/CQn09\nCfX1HNZxKRSjGSVaDuqazWiEwNqdqZ0L8dRpeOrq2Vw2J1rlxSkU/USJloO4YG8CvTyoHMLI+Lhg\nL56/dh4hPp7Eh4yv5GaFwlWojfg2PHftPJf71505OZR7l09hYWIQH92xlHnxQUqwFIpBMO5nWjab\nRAh4blMGG9NKXeoY/dgVM7l+SQIAd5wzSS0FFQoXMO5F60BBDe/uyufdPfm9d+4Ht54xwSlYgBIs\nhcJFjGvRyiit56bVu6g3WgZ9LyFwWqefOTlUBYIqFEPEuBatV7fnDEqwVsyKYvnMSObHB7Izq4p7\nPzhIdIB9s13j4r0xhUJhZ9yKltFsJTV74JVurpofy99WznYu+65e4E24nychvnqCfFTkukIxVIxb\n0frPlixODjCYNMLfkwcvntppn+qs5DBXDE2hUPTAuBWtgZ4RzosP5I0fL8bXc9z+1SkUI0qvcVpC\niNVCiDIhxJE2bX8VQqQLIQ4JIT4SQgS2ee0BIcRJIcRxIcTyNu0LhBCHHa8977AJQwjhKYR419Ge\n2tauTAhxkxAiw/Fzk6s+NMCkMN9+9Q/z8/z/9s4+xqqjCuC/aReWUqj7wcKCLWVJoU2ppZYXLaaL\nH00/QGy0pgohbRX+adFGTbSUYA3aaLKa/qHRSNvQaAw1rJrWj3/4aBT9h+huA3WhbFkWW6Dsglsp\npCBVe/xjzuybvbxlyXv3vbd39/ySm503d+6cc8/MPffembtzaJ03jafuX2gOyzCqSLHBWncA6zXk\nVxt+7fZ1WQrWeveCGTRfNYm+0/++YN+0KRNZfvMsPpe7htmNk3nz1DnmTZ9iny0YxihgxCctEfkz\nfu32OG+7iIRpt93kI+0MBmsVkcNACNY6Ew3WKiKCd4Cfjo4J4e5/DdyRDNaqjioEa02Fmssv4yer\nbmViIrDpkvlN7PrGx9l47wJunHUVU2prmD9jqjkswxglpPGesxrYqumqBGstlkXX1rNu6Q20/+0I\n65Zez/uumMgNzVO50l7/DGPUUtLV6ZzbgI+6syUddYrWo+gI02tub2HN7S3lUMswjDJQ9D9MO+e+\nACwHVukrH5QWrJUCwVoL1XUBIvKMiOREJNfUZJ8dGMZYpiin5Zy7B3gMuFdEzka7fges0BnBFvLB\nWo8Dp51zt+l41YPAb6NjwszgYLBWYBtwl3OuXgO23qV5hmGMY4oK1oqfLawFdugA9W4ReTirwVoN\nw8gOTiqwUmclyeVy0tHRUW01DGNc4JzrFJFcJWXaIoCGYWQKc1qGYWQKc1qGYWQKc1qGYWQKc1qG\nYWSKMTd76Jw7CbxeAVHTgH9WQI7JH706VFv+aNDhehGZWkmBY+6f7ESkIp/EO+c6Kj3Va/JHlw7V\nlj8adHDOVfz7Ins9NAwjU5jTMgwjU5jTKp5nTH7VqbYO1ZYP1deh4vLH3EC8YRhjG3vSMgwjW4jI\nuNqArwBdwD7gq5r3A+AA8ArwAlCn+XOAc8Ae3TZF9SwC/o5fUvpH5J9aa/Erufbg18OfEx3zEHAQ\nOIlfiTXWYSN+vbAga1l03Hqtrxu4OwUdTgLnVYcgf2sk+x/AnjRtADwHnFCZB3Vbi19G+6D+rS/j\nOb+NX3nkaJR/i+a/C/QB0zX/TqBT5XQCn4iO+ZPqFOwxvQzyU7F5gX73NnAa6NL8FqADOAucAXaG\nNgBWRfL3AO8Bt5Rog9DuD0X5LVq2R4+dOOI1XG0nUmGHdRPeYU3Gf+6xE7gOv1ZXjZZpA9qiztM1\nTF1/BW4DHH6ZnaWavzZ0MvwyO1s13QD0Ah/BL91zGP+NTdBhI/D1AnJuBPZqh2gBDgGXl6DDEeBV\nfOCRXu2A1yVkPgV8K00bAEvwSxy9q3rUA6eAb2u5xyO7p33OvcAngY+q/HBhHgCe1/RuYJumPwjM\nivrMsYTTyhWwRZryU7F5Qn4DsAx/09iv+9rx69k9DmzC37DbCsj8AHAoBRuEdu+NbNAOrND0JuCR\nEa/jajuSSm7A/cDm6PcTwGOJMp8Btlys8wAzgQPR75XA05reBizWdA3+wz8XygQdNL0y6MDwTms9\nPvIRcf0l6LAj2EB1aI9toOWOAPPKYINHgbeiY06FTqr1dZfpnJ+OzuUtzXP4J5+rdd9y4J0C5+n0\nmNoRLtjU5Kds88Eyum+Ltq/TMt1a72Lgj6ENEnK/B3w3+l20DaJ+tzLSITwwLEYd98W28Tam1QW0\nOucanXOT8XeeaxJlVpNfoBCgxTm3xzm3yznXqnnv5xIDdeAfyeNAHV1AK35J6TkJHR7VWJLP6Wqt\nQ+pLyCpWh/3BBkA/8KGEDVqBfhE5WAYbNOODnARqgSs13QfMKNM5x3X9R/Ma8a9Wob69wCQu5LPA\nyyJyPsr7udrjiRC/swzy0+53gT68Q2nE3zRmiF9Z+CjQRL4NYj4P/DKRV4oNgt6NwCnJR/a6pOA1\nY+6L+IshIq9qnMbtwDv49/GwsmqhQB3HgdkiMuCcWwS86JxbkJIO38GPK21THX4KPImP8fgk/hVt\ndSmyhuEk/hV4O77TvElkA/wdMO6gqdugECIizjlJu95S0PNsww8fBFaJyDHn3FTgN8ADDI0JmgYV\nsfkwDGkD59yHgbMi0hVlV8IGwzLenrQQkc0iskhElgD/Al6DwoE6xMdvHNB0J35sZT4lBuoQkc3A\nH4ANQQcR6ReR/4nIe8Cz+CegIfUlZBWtQ7AB3mGeiGxQA9xHPiRc2jboAyZEx5zH3zzQ2JgnynXO\n0TETNG8AEOdcqG8hMBi5V/NfAB4UkUORPY7p3zPA8xRop1Lll6vfKc34G/MAUAf0q+2vxt/QTjCU\nFSSeslKwQdB7AKjTssnzGZ6R3h/H2kZ+pmM2fiC0Dh8Edj/QlCjbRH4AeK4atEF/JwdEl2n+lxg6\nGNmu6Qb84Hs9PuDHYfwAZ9BhZiT3a/igt+CjdceD0r0MPyh9qTrMUz3ewDusMFt6D7CrjDZYiA5E\nU3gg/vtlPOd64GaVH/TvZuhA+HZN16n8+xK2qAGmaXoCPrjww2WQX65+V49OxOi+XwG/Jz8Q/2Jo\nA91/mcqem6IN6jXdEOkQD8SvHfEarrYTqYLT+gveQe0F7tC8Hm3MIVPM+PGMfZr3MvCpqJ4cfnzq\nEPBj8lPPk7QherSDxQ2+WvPPaWeIdfgFfir7FfyMTuzENqicbnS2qEQdzuEvnjeCfN33s9ABo7xU\nbIC/Wx/H3+X/ix9P+zLwEn4afGfoyGU65zOR7KPAGuBW8p8c9APNWv6b5IcPBqf18eNvndpG+4Af\nkncuacovV787g79RhODJ67T+8MnDS4k2+Bg+aE3cH0qxQY9uX4zy52rZHj22dqRr2L6INwwjU4y7\nMS3DMLKNOS3DMDKFOS3DMDKFOS3DMDKFOS3DMDKFOS3DMDKFOS3DMDKFOS3DMDLF/wGms8Jolysl\nyQAAAABJRU5ErkJggg==\n", - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "polydf.plot()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "And the second GeoDataFrame is a sequentially generated set of circles in the same geographic space. We'll plot these with a [different color palette](https://matplotlib.org/examples/color/colormaps_reference.html)." - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": { - "ExecuteTime": { - "end_time": "2017-12-15T21:09:36.756293Z", - "start_time": "2017-12-15T21:09:36.526295Z" - } - }, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 4, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAARoAAAD8CAYAAACo2WuRAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\nAAALEgAACxIB0t1+/AAAIABJREFUeJzt3Xl8HXW5+PHPc7Lve9p0TZekpYVSaaAFZFGgICoIAhZR\nyhXZRVC8Cvd6L/zK1R8IwrUuFBAuykUEQQF/UqGylCoUSKB0o0u6N03bNEmz7+f5/XEmeNomzUnO\nTHJy8rxfr/PK8D3zfWamaR9mvjPzfURVMcYYL/mGegeMMdHPEo0xxnOWaIwxnrNEY4zxnCUaY4zn\nLNEYYzxnicYY4zlLNMYYz1miMcZ4Lnaod8Btubm5WlhYONS7YcyIUFZWdkBV8/paL+oSTWFhIaWl\npUO9G8aMCCKyI5T17NLJGOM5SzTGGM9ZojHGeM4SjTHGc5ZojDGes0RjjPGcJRpjjOcs0RhjPBd1\nD+wZY6CzuZOW3Y20VbXQ2dSBdim+eB9x6fEkjkomcUwKvtjBO8+wRGNMFGk/2EbtB1U072yAXuoO\n1K2twRfvI216FpnH5eCLj/F8vyzRGBMFVJW6NdXUflDVa4IJ5m/3U7e6msbyOvLOGEPS6BRP98/G\naIwZ5tSvHPh7JbVloSWZYF3Nnez9604at9V7s3MOSzTGDHM1pftpLK8beACFquUVtFQ2ubdTh7FE\nY8ww1lzRSP26mvADKVQt34O/vSv8WD3oM9GIyHgReUNE1ovIOhG5xWl/RkRWOZ/tIrLKaS8UkZag\n75YExZojImtEpFxEFouIOO0JTrxyEXlXRAqD+iwUkc3OZ6HbfwDGDFfqV2re3edavK6WTg6urnYt\nXrBQBoM7gdtU9QMRSQPKRGSZqn6lewUR+SkQfO62RVVn9xDrIeAa4F3gZeA8YClwNVCrqlNFZAFw\nL/AVEckG7gRKCFx9lonIS6pa2+8jNSbKtOxupKOu3dWY9RtqyZyd6/qt7z6jqWqlqn7gLDcAHwNj\nu793zkouA54+WhwRKQDSVXWlBgp+/xb4kvP1hcBvnOXngLOcuOcCy1S1xkkuywgkJ2NGPC8GcLXD\nT8vuRtfj9ittOZc0nyJwRtLtNGCfqm4OapvkXDYtF5HTnLaxwO6gdXbzz4Q1FtgFoKqdBM6OcoLb\ne+gTvF/XikipiJRWVVX155CMGbZa9zUPm7ghJxoRSQWeB25V1eBUejmHns1UAhOcS6fvAr8TkXQ3\ndrY3qvqIqpaoakleXp/Tlxoz7Pk7/XQ1dXoS2+3LMQgx0YhIHIEk85Sq/jGoPRa4GHimu01V21S1\n2lkuA7YAxUAFMC4o7DinDefn+KCYGUB1cHsPfYwZsfzt/mEVO5S7TgI8Bnysqg8c9vXZwAZV3R20\nfp6IxDjLk4EiYKuqVgL1IjLPiXkl8KLT7SWg+47SJcDrzjjOK8B8EckSkSxgvtNmzIgmMTKsYody\n1+lU4OvAmu5b2MC/qerLwAKOHAQ+HVgkIh2AH7heVbtv9N8IPAEkEbjbtNRpfwx4UkTKgRonLqpa\nIyJ3A+876y0KimXMiOWL9yFxPrTD/bOP2JQ412NK4MQhepSUlKiVWzEjQeXSHbTudX/gNmfeKNKP\nyQ5pXREpU9WSvtazJ4ONGaaSJ6R6EjdpnPtxLdEYM0ylTslAYt0dT0kal0JcWryrMcGmiTAmInU2\nd9BW1UJXaye+WB9xmQnEZyfivLUDQExiLBkzczj40QHXtpv1KW8eD7FEY0yE6Gzq4MDbFRz8YD8t\nFUc+nRubGkf6sbnknjqWlImBR9MyZuXQvKuB9pq2sLefMSuHhNyksOP0xBKNMUNM/UrV8l1UvrwN\nf1vvb093NnZQs7KSmpWVZMzKY/ylxcRlJJB/1ngq/7KdruaBP8CXPDHNs7MZsDEaY4ZUV1snWx9Z\nTcWfyo+aZA5Xt7qKDfe8R+PWOuJS4yj4fCHxWQkD2oe04kzyzxyL+Lx7NscSjTFDxN/exdYlq6lf\nP7CpGTqbOtjyqw9p2u4kmy8UkjErJ+QH7mJT48j/7FhyTy3wNMmAXToZM2R2/3EzjVsOhhXD3+5n\n66/XMP0HJxGXFk/2nHwyZmTTWF5H064G2g+0ol3/fFbOlxBD4uhkUialkzIxzfME080SjTFDoLG8\nluq397gSq7O+nT0vlTPxihkAxCTFknFcDhnH5aCq+Fu78HcpvjgfMQneVzzoiV06GTMEKl/e5mq8\nmvf20lZ15FPCIkJMUixxqXFDlmTAEo0xg66tqpnG8vAumY6gUP1upbsxXWSJxphBNtDB3z7jrvMm\nrhss0RgzyJo9mCoToKWyCe3ybp6acFiiMWaQddSF/xRvj/xKR0OHN7HDZInGmEGmfg+nZvHbGY0x\nBohNdn9iqW4xHsYOhyUaYwZZ4uhkT+LGZSYQkxiZj8ZZojFmkKUWZXkSN63Ym7husERjzCBLnZJJ\n3ABfgDyarDmjXI/plnBqb98lIhVBNbbPD+pzh1NHe6OInBvUbrW3zYgnPmHUWRNdjZk0Lo206aHN\n8zsUBlx72/nuQVW9P3hlEZlBoIrBTGAM8DcRKVbVLqz2tolSqsqudTvYXLqRvVsqaaxtQFVJzUwl\nf9JoppxQxKTjp+CLCfy/PffUMVS/s6fHCa76TWD8pcWHzL4XafpMNE49pkpnuUFEDqm93YMLgd+r\nahuwzSmhcpKIbMepvQ0gIt21t5c6fe5y+j8H/OLw2ttOn+7a20et823MYFFVPnrtQ958chkHdvVc\njnnDO+t563evk5GfyRlXnEXJ+XPxxfgo/Jdj2fRAaVgTVgGMuWAKKZMyworhtXBrb98sIqtF5HGn\nwBv0Xi/bs9rbxgyFxtoGnvj+ozz349/1mmSC1e0/yEsPPs+jt/yS2r01JOYnM+WG2cSEUUdp1LmF\n5H92woD7D5Zwam8/BEwGZhM44/mpJ3sY2r5dKyKlIlJaVdX3L9yYcB3cV8sjN/+CLWWb+t131/od\nPPytn7N/+15SJqYz7Xsl/T4jiUmKZeKVMxjz+ckRfcnUbcC1t1V1n6p2qaofeBQ4yVm9t3rZntXe\nVtVHVLVEVUvy8ryb99QYgLaWNn57+6+p2TPwlxgbaxp44geP0ljbQEJOEkW3nMDEK2eQNC7tqP1i\nUuLIP2sCx/xwHtklowe8/cHW5xhNb7W3RaTAGb8BuAhY6yy/BPxORB4gMBhcBLynql0iUi8i8whc\nel0J/Dyoz0LgHYJqb4vIK8CPgy7L5gN3DPxwjQnf0of+zP4d+8KOU19Vx4sPPM8Vd1+F+ITsktFk\nl4ymdX8zTVsO0rq/ma4Wp9xKViLJE9JImZSBL3b4PZUy4NrbwOUiMpvA3aDtwHUAqrpORJ4F1hO4\nY3WTc8cJrPa2Geb2bauk7C/v9r1iiD7+x1q2ripn8uypn7Ql5ieTmO/N08NDJZS7Tn8HeroIfPko\nfX4E/KiH9lLg2B7aW4FLe4n1OPB4X/tpzGB4+/kVuF2v/h/PLj8k0USj4XcOZswQ6erqYt3y1a7H\n3fz+RlqbWl2PG0ks0RgTov3b9nqSEPxdfnat3+F63EhiicaYEFXvdq/G9RGxK7yLHQks0RgTotZm\n7y5v7NLJGANAbLx3k0rFxUfmPDJusURjTIgy8zM9i53hYexIYInGmBAVFI395O1rt42bHvnvK4XD\nEo0xIUpISmDKCUWuxy2YOpbMUZE7O54bLNEY0w8nXXCK6zHnXuh+zEgT3SNQxoRI/X7a91XRUV2N\ntnfgS0okPj+P2OysQ96OnnbyMUyYWcjOddtd2W7ehHxmz5/jSqxIZonGjGgtW7dT+8YKGlatwd/U\nfMT3sTlZpM/5FFlnnU58Xi4+n4+L/vUyHrr+v2lvbQ9r274YHxf/4CvExkX/P0Nx+72NoVZSUqKl\npaVDvRsmwnXW1bP3f5+loWxV3ysDxPjIPucz5F30BXxxcWx692Oe+o8n6Ors6rtvD0SEL9++gNnn\nDO+zGREpU9WSvtazMRoz4rRs28HWu+4JPckAdPmp+etr7PjxA3QcrKN47jFcec83Sc5I6ff245MS\nWHDnlcM+yfSHJRozorTu3M3O+39OV139wPrv2MXO+xbT2djIlBOKuPnXt3H82SeEPMvd9FNm8q1H\nv8vM048b0PaHK7t0MiNGV0sL2+68h44DA58Zr1vKcTMYf+sNnySYA7ur+PCVUspLN7Jv6146OwIT\njsfExpA3cRRT5xQx+5w5jJ4yJuxtR5JQL52ifxTKGMeBF152JckANK1ZT/27pWTMOxGA3HF5nHP1\n5zjn6s/h9/tpa25D/UpiSqJnD/kNJ/YnYEaEzrp6at9Y4WrMAy8uRf3+I9p9Ph9JqUkkpydbknHY\nn4IZEereeR/tDK9+0uHa9+2npXyrqzGjlSUaMyI0rV3vSdzGNd7EjTaWaMyI0Lpzd98rRVDcaNNn\nohGR8SLyhoisF5F1InKL036fiGxwKlX+SUQynfZCEWkRkVXOZ0lQrDkiskZEykVksVPKBRFJEJFn\nnPZ3nYqY3X0Wishm57PQ7T8AE/20s4uuxiZPYncO8Db5SBPKGU0ncJuqzgDmATeJyAxgGXCsqs4C\nNnFovaUtqjrb+Vwf1P4QcA2BWk9FBOpoA1wN1KrqVOBB4F4AEckG7gTmEihQd2dQjSdjQhKoceiR\nroE9GTzS9JloVLVSVT9wlhuAj4GxqvqqUycbYCWHVqE8gogUAOmqulIDD+/8FviS8/WFwG+c5eeA\ns5yznXOBZapao6q1BJLbeRjTDxIbiyTEexI7Ji3Vk7jRpl9jNM4lzacIVJoM9g3+WQwOYJJz2bRc\nRE5z2sYCwRe0u5227u92ATjJqw7ICW7voU/wflntbdMrESFhTIEnsb2KG21CTjQikkqg/vatqlof\n1P7vBC6vnnKaKoEJqjob+C6B8rjp7u3ykaz2tulLyjHFnsRN9ihutAkp0YhIHIEk85Sq/jGo/Srg\nC8AVzuUQqtqmqtXOchmwBSgGKjj08mqc04bzc7wTMxbIAKqD23voY0zIMk4+yfWYMSnJpM6a6Xrc\naBTKXSchUBv7Y1V9IKj9POD7wAWq2hzUniciMc7yZAKDvltVtRKoF5F5TswrgRedbi8B3XeULgFe\ndxLXK8B8EclyBoHnO23G9EvC2AJSZ7v7ImPWOZ/BF+ddZYRoEsq7TqcCXwfWiEj3e/X/BiwGEoBl\nzl3qlc4dptOBRSLSAfiB61W1xul3I/AEkERgTKd7XOcx4EkRKQdqgAUAqlojIncD7zvrLQqKZUa4\n1sZGNv99BTtWfUj1zp20NjQQExdLWl4+BdOnU3TKqYwunvbJi4+jFlxM08cb0bbwJqwCiB+VR855\nZ4UdZ6Swt7fNsNPSUM/fn/gfPnzpRTpaj154bfS06Zx5zbVMmTsPgPr3yqhY8j9hbd+XmMjEO75D\n4vgj7kuMODbxlYlK28tKefhrX+W9Z5/pM8kA7N24gd9/77v8+Uf/RUdbG+knzWH0VV+FEOePOZwv\nKYnxt95gSaafbJoIM2ysf/01Xlx0F/4BPCS3+q8vU1Oxm8vvf4Cs008hPi+XPY8/SWd1bcgxEicX\nMvaahcSPsjub/WWXTmZY2LX6I/73lpvxh/kG9tSTT+Gye36C+Hz429qpfeMtal9fcdR5ahILJ5A9\n/zOknzQH8dlFQDCb+MpEjfaWFl5YdFfYSQag/J23KXvhT5Rc/GV8CfHknHc22eeeRduuClq2bqej\nugbt6MCXmEj8qDySpk4mPi/XhaMY2SzRmIj33rO/p37fPtfiLf/1Ixx37nkkpAQmFhcREieMI3HC\nUd+iMWGw80AT0fydnZQ+/5yrMVsbGlj916V9r2hcY4nGRLSdH62iqTb0AdtQbXjjdddjmt5ZojER\nbdfq1Z7ErVi/zpUxHxMaSzQmotVWeDODXVdHB/X793sS2xzJEo2JaG1N3syMB9DW7F1scyhLNCai\nxSYkeBc73rvY5lCWaExEyxzt0cRSIqSPGuVNbHMESzQmoo2ZMcOTuKOmTiXOw7MlcyhLNCaiTSo5\nkbjERNfjFn/6tL5XMq6xRGMiWnxyMrM+d76rMX2xscz+4oWuxjRHZ4nGDBl/RxPtteto2fsPWipX\n0Fb9EV2tR85rduqVC4lPTnZtuyddchnpNrf0oLJ3ncygUn8HLZXLaal4nY66TcCRswfEpIwjqeAM\nksfNxxeXSlpuHud+5zb+/KO7w95+3qRJnH71N8OOY/rHEo0ZNG3VH1H/8cN0tRz9Bcmupt00lj9F\n0/YXSCv6Okljz2bWeZ+jZtdO/vHb3xy179Gk5eVx2b33ezLmY47OLp2M51SVpu0vUPvB3X0mmUP6\ndTZR//ES6tb9HPV3cMY3r+Wcm2/BFxPT730YXTyNhQ89TGaB1WEaCuHU3s4WkWVOTexlwaVqReQO\np472RhE5N6jdam+PQM07XqRh85P0dJkUitbK5dSt/TmgnHTZV7jq4V8z/vjjQ+qbkJLCGddcy8KH\nHiZj1OgBbd+Er88Z9pxStgWq+oGIpAFlBErZXgXUqOo9InI7kKWqP3Dqcj9NoFb2GOBvQLGqdonI\ne8C3CVS6fBlYrKpLReRGYJaqXi8iC4CLVPUrTu3tUqCEwN/SMmCOUx63RzbDXmRpq1lDbdn/YaBJ\nJlha0UJSCi/45L8r1q1j3WvL2PHhh1Tv3EFXe6C6QUp2DmOOOYapJ5/CjLPOJjHVytZ6xbUZ9px6\nTJXOcoOIfEygLO2FwJnOar8B3gR+4LT/XlXbgG1OCZWTRGQ7Tu1tZwe7a28vdfrc5cR6DvjF4bW3\nnT7dtbef7mu/zdBTfwf165fgRpIBaNjyNImjTiYmKXDHaOzMmYydGSjgpqp0tbfji40d0KWV8VY4\ntbdHOUkIYC/Q/Tx3b/WyPau9bSJTy94VdLXsdS+gv52mHS/0+JWIEJuQYEkmQoVdexvAqSo5ZLOc\ni8i1IlIqIqVVVVVDtRvmMC0V7k8u1VL5FurvcD2u8VY4tbf3OeM33eM43ZN79FYv27Pa26r6iKqW\nqGpJnj2IFRH8nc10HNzoelztbHaevzHDyYBrb3NoveyFHFpHe4FzJ2kSgdrb71nt7ZGls3EXgYrI\n7uto2OFJXOOdcGpv3wM8KyJXAzuAywBUdZ2IPAusBzqBm1S1u+KX1d4eIfxt7s/z+0nsdu9iG2+E\nctfp70Bv9UN7rHKuqj8CftRDeylwbA/trcClvcR6HHi8r/00kcbDIbsoK3o4EtiTwcYTvrh072LH\nexfbeMMSjfFEbOr4vlcaaOwU72Ibb1iiMZ7wxacTm1roRWDiMqe7H9d4yhKN8UzSmDNcj5mYPxdf\nbJLrcY23LNEYzySNPcflsRofKYVfcjGeGSw2H43plwN7ytm8+g0qt6+mrrqCjvZW4hNTyMwZx5hJ\nx1M0+7Nk5U0AwBebRNq0q6hbu9iVbSdPOJ+4tEJXYpnBZYnGhKRyx1pWvLiYXeU9vxlfXbmFLWuX\ns+LPi5k88zROu+Db5BZMIangDNprN9BS8WpY24/LmEZa0dfCimGGjiUac1Tq9/OPlx/i3WWPh/z8\nytZ1K9j+8TucdsG3mfOZK0if/k3QTlr2DOzdp7jM6WTNvgPxxQ2ovxl6lmhMr/z+LpY++Z9sKFva\n98pH9O1k+QsP0HBwL2dedBvpM24kLn0KDZufRLtaQ4ziI3nC+aQVfc2SzDBnicb0asVLiweUZIJ9\n8ObvSMscTclnv0by+PNIyJ9L046XaN3zJv6O+h77iC+BhFEnk1J4IXGpE8LavokMlmhMj3ZtLqP0\n9SddibXipcUUHnMyuQVTiEnIIr14IWlTv0ZHwxY6G7bjbzuI4scXl05s6njiM4qRGKsiGU0s0Zgj\nqCpv/umnrsXz+zt568WfcfH1/7z7JL4Y4jOKic8odm07JnLZczTmCBVbV7F/9wZXY25b/3dq9+90\nNaYZPizRmCNsXvU3T+Ju8iiuiXyWaMwRKrZ95EncPdtW9b2SiUqWaMwRDlbt6nulgcQ9sLvvlUxU\nskRjjtDe1uxR3BZP4prIZ4nGHCEuzpva1HHxVvN6pLJEY46QketN6az0bKt7PVJZojFHKCg8zpO4\nYwpneRLXRL5Qyq08LiL7RWRtUNszIrLK+Wzvro4gIoUi0hL03ZKgPnNEZI2IlIvIYqfkCk5Zlmec\n9nedapjdfRaKyGbnsxAzKKYed6Y3cY//rCdxTeQL5YzmCQL1rj+hql9R1dmqOptAYbk/Bn29pfs7\nVb0+qP0h4BoCdZ6KgmJeDdSq6lTgQeBeABHJBu4E5gInAXc6tZ2MxyZOn0dW/kRXY46dPJv8sfYU\n8EjVZ6JR1bcI1Fo6gnNWchnw9NFiOJUs01V1pVMY7rdA91RpFwK/cZafA85y4p4LLFPVGlWtBZZx\nWMIz/aPqp6G1ksqDH7Kr+m12V6+kquFj2jsbD1nP54vhtC/e7Oq2T7/wFlfjmeEl3HedTgP2qerm\noLZJzqVUHfBDVV0BjAWCH6LY7bTh/NwFoKqdIlIH5AS399DH9ENLew3bqt6gsraMts6e35jOSJ7I\nhJxTGZN1IjG+OKbO+gwzTvw869//S9jbP/GshYyZdHzYcczwFW6iuZxDz2YqgQmqWi0ic4AXRGRm\nmNvok4hcC1wLMGGCTSvQza9dlO/9K1v3L8OvnUddt655B2uad7Bl3zJmTbiC7NSpnLPghzTW7Wfn\npveP2vdoimefw6e/+K0B9zfRYcB3nUQkFrgYeKa7TVXbVLXaWS4DtgDFQAUwLqj7OKcN5+f4oJgZ\nQHVwew99DqGqj6hqiaqW5OXlDfSQokpHVwvvb/kl5fuW9plkgjW3V7Gy/Gdsr1pObFwCF123mBkn\nfn5A+3DCmV/l81f9GJ8vZkD9TfQI5/b22cAGVf3kkkhE8kQkxlmeTGDQd6uqVgL1IjLPGX+5EnjR\n6fYS0H1H6RLgdWcc5xVgvohkOYPA850204cufwelW5dQ3bhpgBGU9RV/YOeBvxMbl8B5X1vEBVff\n98mk433JG1vMJTc9xGcu/p4lGQOEcOkkIk8DZwK5IrIbuFNVHwMWcOQg8OnAIhHpAPzA9araPZB8\nI4E7WEnAUucD8BjwpIiUExh0XgCgqjUicjfQfd6+KCiWOYoNe/5EbdOWsOOs2/0s6cnjyUyeSNHx\nZzHluDPZsWElm1e/TuX2NdQdqKCjo5X4+GQy88YzZtIsimefzbipc3CeXjAGANEoK5heUlKipaU9\nz9Q/Ehxs3sHbm+5zLV560nhOLf5XRHo++VVVSyojmIiUqWpJX+vZk8FRZsted68u61t2sb9+Xa/f\nW5IxobBEE0XaOhvYX7+27xX7aXfNStdjmpHFEk0UqW7YiOL3Jq66H9eMHJZookhDyx5P4nb6W2lu\nr/YkthkZLNFEkbbOBs9it3sY20Q/SzRRJbruIJroYYkmisTHpg7L2Cb6WaKJImmJYzyJG+OLJyk+\nx5PYZmSwRBNFctKKAfefa8lOLcIn9iqBGThLNFEkMS6T3LRprscdlz3X9ZhmZLFEE2WmjnJ3brDU\nhNGMzpjtakwz8oQ7H43xWEdnO6s3vM3aTe+ws3IzB+ur8Pu7SEnOoCCvkGOmzGHOsZ8lIy0bgOzU\nqYzNmktF7bsubF04dvyCXt9zMiZU9lJlhOrq6mT5ey/ylzefoK7h6A/LxcTE8uk5X+BLZ19DWmoW\nnV1trCx/kPqW8CpDTiu4kCmjzgkrholu9lLlMHawvor7fv0tfvfnn/aZZKA7Kb3Af/7sCtaXv09s\nTAInTrmJjKSBzzZYNPrzTM4/e8D9jQlmiSbCVB/cy/9dch3lO1b3u29D00F+9sR3KVv7Bgmxacwr\nupWJuWfQnztRCbHpzJl0LUWjP2dvZhvX2BhNBGlrb+FnT9xG9cG9A47R5e/i0WfuIitjFJPHz2Dm\nuEuZkHMqW/e/xt66D+nyt/fYLzk+j/E5pzAx9zRiY6x0rXGXjdFEkKf//CCvvfMHV2KNyhnPXbc8\nSVxs/CdtXf4O6pp30ti2l47OZkR8JMZlkp40jpSEfDuDMf0W6hiNndFEiKqaCt549499rxiifdW7\nWP7eC5x9ymWftMX44shOnUJ26hTXtmNMKGyMJkK8sfKP+P1drsZ87e0/EG1nrGZ4skQTIT5Y96br\nMatqKti9t9z1uMb0V5+JRkQeF5H9IrI2qO0uEakQkVXO5/yg7+4QkXIR2Sgi5wa1zxGRNc53i52y\nK4hIgog847S/KyKFQX0Wishm59NdkiXqHKw/wIHaSk9iD+TulTFuC+WM5gl6rnn9oKrOdj4vA4jI\nDALlUmY6fX7VXecJeAi4hkCtp6KgmFcDtao6FXgQuNeJlQ3cCcwFTgLudOo7RZ2qWm9mxgOoqvEu\ntjGh6jPRqOpbBOotheJC4PdOxcptQDlwkogUAOmqutIpDvdb4EtBfX7jLD8HnOWc7ZwLLFPVGlWt\nBZbRc8Ib9trbWzyL3dbe6llsY0IVzhjNzSKy2rm06j7TGAvsClpnt9M21lk+vP2QPqraCdQBOUeJ\ndQQRuVZESkWktKqqKoxDGhrxcd49t5IQb8/EmKE30ETzEDAZmA1UAj91bY8GYLjX3s7L9mbCKoDc\nLO9iGxOqASUaVd2nql0aqMHxKIExFIAKYHzQquOctgpn+fD2Q/qISCyQAVQfJVbUyUjLJTtzlCex\np0481pO4xvTHgBKNM+bS7SKg+47US8AC507SJAKDvu+paiVQLyLznPGXK4EXg/p031G6BHjdGcd5\nBZgvIlnOpdl8py3qiAgnzDzT9bi5WWMYX1Dselxj+qvPJ4NF5GngTCBXRHYTuBN0pojMJjDt/nbg\nOgBVXScizwLrgU7gJlXtfgrtRgJ3sJKApc4H4DHgSREpJzDovMCJVSMidwPvO+stUtVQB6WHnc/M\nvdh5wM69Qm2fPfnL9lqBiQj2rpPHWlq72LmjmarqNtrb/MQn+MjNSWDihGSSkg6dh/d/X7yPN9/9\nkyvbzc0aw6JbnyI+LsGVeMb0xN51GkKqyvqPG1j+VhUbNjbg7+EkxeeD4uI0zjgtl2NnpiMiXHLe\njWzYUsbn89CtAAAKPklEQVTeAzvD2n6ML4arL/tPSzImYliicVlNTTtPPb2TjZsaj7qe3w8bNjSw\nYUMDxUWpXHH5eHJyUrjlqp/yk0dupLZ+YLfpRXx845L/oGjirAH1N8YL9q6Ti7Ztb+Le+zf2mWQO\nt2lzI/fev4ktWxvJyx7L7dc/TOG4Y/q9/eSkNG6+8ifMnT2/332N8ZIlGpdUVLTwy4e20NQ0sDew\nm5u7+NWSreza1UxO5mhuv+5hLv3ct0hNzuyzr88XwyknnM+iW55i1rRTBrR9Y7xkg8EuaGvr4p6f\nbKTqQM+z1/VHTk48d3x/GomJgYHitvZWVn38Fms3rWTnnk3UOlUQUpMzKMgvZPrkOZw462yyM/LD\n3rYx/WWDwYPo1b/tdyXJAFRXt/PXV/fxpQsCT/QmxCcy9/j5zD3eLofM8GWXTmFqaenizeXuvl/1\n1ooDNDV1uhrTmKFkiSZMqz46SFubew/ZAbS3+1n1UZ2rMY0ZSpZowrRhY4NHces9iWvMULBEE6Y9\ne7yZ78WruMYMBUs0YWpo9GYspb7BxmhM9LBEEyavXlm0dyFNNLFEE6bUNG+eEEjzKK4xQ8ESTZjG\nFHgzVeaYgiRP4hozFCzRhOmY6WnDKq4xQ8ESTZiOPz6TxER3/xjj433MPj7D1ZjGDCVLNGFKSozh\nzDPcnRD9jNNzSU62MRoTPexvcw/27TvI315bTWnpFrZv309dfTM+n4/c3DSKigo4Zd40zjhjJsnJ\ngYml5p89irIPDlJV1Rb2tnNz4jlvvjcTlRszVOzt7SAHDtSz5OFXeeXVVXR1Hf21grTURL761dO5\nfMGniY+PZc+eFh5cvJmWloG/jpCY4OPWb09l3LjkAccwZjCF+vb2QGtv3yciG5wCcn8SkUynvVBE\nWoJqci8J6hPRtbfffmcjV3z9Z7y89IM+kwxAQ2MrDz/yKtdc9xAVFTWMGZPEt26YSmpKTJ99e5KS\nEsNNN06xJGOi0kBrby8DjlXVWcAm4I6g77YE1eS+Pqg9YmtvL/vbR/zg9idpaOh/adrNmyu57oYl\n7NhZxcSJyfzg+9OYcUz/7hhNn5bG7f86jUmFKf3evjHDwYBqb6vqq075WoCVHFoc7giRXHt7zdqd\nLLr7DyGdxfSmpqaR2773GxobW8nKjOeG6ybzrRuncOzMdHy9/An7fDBzRjo3Xj+Zm26YTFZW/IC3\nb0ykc2Mw+BvAM0H/PUlEVhGoof1DVV1BP2pvi0i/a28PVFtbB4vufjasJNNtz54aFv/8L/zbHYFa\nStOnpTF9WhptbV3s2NlMdXU7be1+EuJ95OTEM3FCMgkJA7vMMma4CSvRiMi/EygU95TTVAlMUNVq\nEZkDvCAiM8Pcx1D241rgWoAJEyaE3O+FF9+josK9mnT/7y9lXL7g00ya9M+7RgkJMRQXpQUuFo0Z\noQb8HI2IXAV8AbjCuRxCVdtUtdpZLgO2AMV4XHtbVR9R1RJVLcnLC+2ZFlXlueffCWnd/nju+ZWu\nxzRmuBto7e3zgO8DF6hqc1B7nojEOMuTCfx/fGsk1t7esmWvq2cz3d5asZ5oe2TAmHANtPb2HUAC\nsMy5S73SucN0OrBIRDoAP3B9UL3siKq9vXZteNUge1Nd3cDevQcpKPDkBpkxw1KfiUZVL++h+bFe\n1n0eeL6X70qBY3tobwUu7aXP48Djfe3jQOyprPUiLAAVe2os0RgTZMS+69Ta6k55lJ60tXZ4FtuY\n4WjEJpqkpAQPY9szMcYEG7GJZuzY7GEZ25jhaMQmmuOODf15m/7Iz88gP9/mkjEm2IhNNIWF+Uyc\n6O48MgBnnjETsZnFjTnEiE00IsJll57iakyfT/jyxfNcjWlMNBixiQbgi18oYVJhvmvxLr5oLuPH\n57oWz5hoMaITTWxsDHfeeRnx8eG/WzqpMJ8brnf95XJjosKITjQAxUVj+K9FlxMXN/A3qUeNyuT+\n+xfabW1jejHiEw3Apz99DP/9wL+Qk9P/EifHHTeBR5ZcR8FoexLYmN5YonF86lOTeerJW7jkkpND\nupTKzUnjtu98kV/94lry8ux2tjFHY5OT96Curpk33lxL2Qdb2L69irqDTfhifOTlplNUVMC8ecXM\nm1vsytiOMcNZqJOTW6IxxgyYa1UQjDEmXJZojDGes0RjjPGcJRpjjOcs0RhjPGeJxhjjOUs0xhjP\nWaIxxnjOEo0xxnNR92SwiFQBO3r5Ohc4MIi7MxTsGKPDcDnGiara51SVUZdojkZESkN5XHo4s2OM\nDtF2jHbpZIzxnCUaY4znRlqieWSod2AQ2DFGh6g6xhE1RmOMGRoj7YzGGDMEhkWiEZFbRGStiKwT\nkVudtmwRWSYim52fWUHr3yEi5SKyUUTODWqfIyJrnO8Wi1PpTUQSROQZp/1dESkM6rPQ2cZmEVk4\nBMd5l4hUiMgq53P+cDpOEXlcRPaLyNqgtiH93YnIJGfdcqdvWLPK9+cYRaRQRFqCfp9LhsMxhk1V\nI/oDHAusBZKBWOBvwFTgJ8Dtzjq3A/c6yzOAj4AEYBKwBYhxvnsPmAcIsBT4nNN+I7DEWV4APOMs\nZwNbnZ9ZznLWIB/nXcD3elh/WBwncDpwArA2qG1If3fAs8ACZ3kJcMMgHmNh8HqHxYnYYwz778FQ\nbjzEX+KlwGNB//0fwPeBjUCB01YAbHSW7wDuCFr/FeBkZ50NQe2XAw8Hr+MsxxJ4UEqC13G+exi4\nfJCP8y56TjTD5jgP/8c1lL8757sDQKzTfjLwyiAe4yHrBa0f8ccYzmc4XDqtBU4TkRwRSQbOB8YD\no1S10llnLzDKWR4L7Arqv9tpG+ssH95+SB9V7QTqgJyjxPJCb8cJcLOIrHZO0bsvM4brccLQ/u5y\ngIPOuofHclNvxwgwyblsWi4ipwUdx3A7xpBFfKJR1Y+Be4FXgb8Cq4Cuw9ZRYFjfPjvKcT4ETAZm\nA5XAT4dqH70QDb+7vhx2jJXABFWdDXwX+J2IpA/Zzg2SiE80AKr6mKrOUdXTgVpgE7BPRAoAnJ/7\nndUr+OeZAMA4p63CWT68/ZA+IhILZADVR4nliZ6OU1X3qWqXqvqBR4GTDt/nw/Yt4o+Tof3dVQOZ\nzrqHx3JTj8eoqm2qWu0slxEYhypmeB5j6Ibyuq0f17/5zs8JwAYgE7iPQwfbfuIsz+TQAcWt9D6g\neL7TfhOHDrY96yxnA9sIDLRlOcvZg3ycBUHffwf4/XA7To4cvxjS3x3wBw4dKL1xEI8xL+iYJhNI\nANnD4RjD+vMZyo3345e4Aljv/CU8y2nLAV4DNhO4Q5MdtP6/E/g/xUackXunvYTAWMgW4Bf884HF\nROcXU+78sicH9fmG014O/MsQHOeTwBpgNfAShyaeiD9O4GkClwsdBMYKrh7q353zD/w9p/0PQMJg\nHSPwZWAdgUvjD4AvDodjDPdjTwYbYzw3LMZojDHDmyUaY4znLNEYYzxnicYY4zlLNMYYz1miMcZ4\nzhKNMcZzlmiMMZ77/2SB+rI5WiaWAAAAAElFTkSuQmCC\n", - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "polydf2.plot(cmap='tab20b')" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "The `geopandas.tools.overlay` function takes three arguments:\n", - "\n", - "* df1\n", - "* df2\n", - "* how\n", - "\n", - "Where `how` can be one of:\n", - "\n", - " ['intersection',\n", - " 'union',\n", - " 'identity',\n", - " 'symmetric_difference',\n", - " 'difference']\n", - "\n", - "So let's identify the areas (and attributes) where both dataframes intersect using the `overlay` tool. " - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": { - "ExecuteTime": { - "end_time": "2017-12-15T21:09:39.796263Z", - "start_time": "2017-12-15T21:09:36.756293Z" - } - }, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 5, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAARwAAAD8CAYAAAClxxvWAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nAAAASUVORK5CYII=\n", - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "from geopandas.tools import overlay\n", - "newdf = overlay(polydf, polydf2, how=\"intersection\")\n", - "newdf.plot(cmap='tab20b')" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "And take a look at the attributes; we see that the attributes from both of the original GeoDataFrames are retained. " - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": { - "ExecuteTime": { - "end_time": "2017-12-15T21:09:40.416257Z", - "start_time": "2017-12-15T21:09:39.796263Z" - } - }, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
BoroCodeBoroNameShape_LengShape_Areageometry
05Staten Island330470.0103321.623820e+09(POLYGON ((970217.0223999023 145643.3322143555...
14Queens896344.0477633.045213e+09(POLYGON ((1029606.076599121 156073.8142089844...
23Brooklyn741080.5231661.937479e+09(POLYGON ((1021176.479003906 151374.7969970703...
31Manhattan359299.0964716.364715e+08(POLYGON ((981219.0557861328 188655.3157958984...
42Bronx464392.9918241.186925e+09(POLYGON ((1012821.805786133 229228.2645874023...
\n", - "
" - ], - "text/plain": [ - " BoroCode BoroName Shape_Leng Shape_Area \\\n", - "0 5 Staten Island 330470.010332 1.623820e+09 \n", - "1 4 Queens 896344.047763 3.045213e+09 \n", - "2 3 Brooklyn 741080.523166 1.937479e+09 \n", - "3 1 Manhattan 359299.096471 6.364715e+08 \n", - "4 2 Bronx 464392.991824 1.186925e+09 \n", - "\n", - " geometry \n", - "0 (POLYGON ((970217.0223999023 145643.3322143555... \n", - "1 (POLYGON ((1029606.076599121 156073.8142089844... \n", - "2 (POLYGON ((1021176.479003906 151374.7969970703... \n", - "3 (POLYGON ((981219.0557861328 188655.3157958984... \n", - "4 (POLYGON ((1012821.805786133 229228.2645874023... " - ] - }, - "execution_count": 6, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "polydf.head()" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": { - "ExecuteTime": { - "end_time": "2017-12-15T21:09:40.446256Z", - "start_time": "2017-12-15T21:09:40.416257Z" - } - }, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
geometryvalue1value2
0POLYGON ((923175 120121, 923126.847266722 1191...1033296793054
1POLYGON ((938595 135393, 938546.847266722 1344...1063988793202
2POLYGON ((954015 150665, 953966.847266722 1496...1094680793350
3POLYGON ((969435 165937, 969386.847266722 1649...1125372793498
4POLYGON ((984855 181209, 984806.847266722 1802...1156064793646
\n", - "
" - ], - "text/plain": [ - " geometry value1 value2\n", - "0 POLYGON ((923175 120121, 923126.847266722 1191... 1033296 793054\n", - "1 POLYGON ((938595 135393, 938546.847266722 1344... 1063988 793202\n", - "2 POLYGON ((954015 150665, 953966.847266722 1496... 1094680 793350\n", - "3 POLYGON ((969435 165937, 969386.847266722 1649... 1125372 793498\n", - "4 POLYGON ((984855 181209, 984806.847266722 1802... 1156064 793646" - ] - }, - "execution_count": 7, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "polydf2.head()" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": { - "ExecuteTime": { - "end_time": "2017-12-15T21:09:40.586255Z", - "start_time": "2017-12-15T21:09:40.446256Z" - } - }, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
BoroCodeBoroNameShape_LengShape_Areavalue1value2geometry
05Staten Island330470.0103321.623820e+091033296793054POLYGON ((916755.4256330276 129447.9617643995,...
15Staten Island330470.0103321.623820e+091063988793202POLYGON ((938595 135393, 938546.847266722 1344...
25Staten Island330470.0103321.623820e+091125372793498POLYGON ((961436.3049926758 175473.0296020508,...
35Staten Island330470.0103321.623820e+091094680793350POLYGON ((954015 150665, 953966.847266722 1496...
42Bronx464392.9918241.186925e+091309524794386POLYGON ((1043287.193237305 260300.0289916992,...
\n", - "
" - ], - "text/plain": [ - " BoroCode BoroName Shape_Leng Shape_Area value1 value2 \\\n", - "0 5 Staten Island 330470.010332 1.623820e+09 1033296 793054 \n", - "1 5 Staten Island 330470.010332 1.623820e+09 1063988 793202 \n", - "2 5 Staten Island 330470.010332 1.623820e+09 1125372 793498 \n", - "3 5 Staten Island 330470.010332 1.623820e+09 1094680 793350 \n", - "4 2 Bronx 464392.991824 1.186925e+09 1309524 794386 \n", - "\n", - " geometry \n", - "0 POLYGON ((916755.4256330276 129447.9617643995,... \n", - "1 POLYGON ((938595 135393, 938546.847266722 1344... \n", - "2 POLYGON ((961436.3049926758 175473.0296020508,... \n", - "3 POLYGON ((954015 150665, 953966.847266722 1496... \n", - "4 POLYGON ((1043287.193237305 260300.0289916992,... " - ] - }, - "execution_count": 8, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "newdf.head()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Now let's look at the other `how` operations:" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": { - "ExecuteTime": { - "end_time": "2017-12-15T21:09:44.026220Z", - "start_time": "2017-12-15T21:09:40.586255Z" - } - }, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 9, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAARoAAAD8CAYAAACo2WuRAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nxudoodFoND5HC41Go/E5/w/hJcoDL8piaQAAAABJRU5ErkJggg==\n", - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "newdf = overlay(polydf, polydf2, how=\"union\")\n", - "newdf.plot(cmap='tab20b')" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": { - "ExecuteTime": { - "end_time": "2017-12-15T21:09:47.366187Z", - "start_time": "2017-12-15T21:09:44.026220Z" - } - }, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 10, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAS0AAAD8CAYAAAAi9vLQAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nhTJaCoViWPH/2UAwmuqzL+4AAAAASUVORK5CYII=\n", - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "newdf = overlay(polydf, polydf2, how=\"identity\")\n", - "newdf.plot(cmap='tab20b')" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": { - "ExecuteTime": { - "end_time": "2017-12-15T21:09:50.556155Z", - "start_time": "2017-12-15T21:09:47.366187Z" - } - }, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 11, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAARoAAAD8CAYAAACo2WuRAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n", - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "newdf = overlay(polydf, polydf2, how=\"symmetric_difference\")\n", - "newdf.plot(cmap='tab20b')" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "metadata": { - "ExecuteTime": { - "end_time": "2017-12-15T21:09:53.566125Z", - "start_time": "2017-12-15T21:09:50.556155Z" - } - }, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 12, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAS0AAAD8CAYAAAAi9vLQAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nKpzRcjgcUYUzWg6HI6pwRsvhcEQV/w+iixtNUc2vPQAAAABJRU5ErkJggg==\n", - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "newdf = overlay(polydf, polydf2, how=\"difference\")\n", - "newdf.plot(cmap='tab20b')" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.6.1" - } - }, - "nbformat": 4, - "nbformat_minor": 1 -} diff --git a/examples/plot_clip.py b/examples/plot_clip.py deleted file mode 100644 index 9a4b89d..0000000 --- a/examples/plot_clip.py +++ /dev/null @@ -1,116 +0,0 @@ -""" -Clip Vector Data with GeoPandas -================================================================== - -Learn how to clip geometries to the boundary of a polygon geometry -using GeoPandas. - -.. currentmodule:: geopandas - -""" - -############################################################################### -# -# The example below shows you how to clip a set of vector geometries -# to the spatial extent / shape of another vector object. Both sets of geometries -# must be opened with GeoPandas as GeoDataFrames and be in the same Coordinate -# Reference System (CRS) for the :func:`clip` function in GeoPandas to work. -# -# This example uses GeoPandas example data ``'naturalearth_cities'`` and -# ``'naturalearth_lowres'``, alongside a custom rectangle geometry made with -# shapely and then turned into a GeoDataFrame. -# -# .. note:: -# The object to be clipped will be clipped to the full extent of the clip -# object. If there are multiple polygons in clip object, the input data will -# be clipped to the total boundary of all polygons in clip object. - -############################################################################### -# Import Packages -# --------------- -# -# To begin, import the needed packages. - -import matplotlib.pyplot as plt -import geopandas -from shapely.geometry import Polygon - -############################################################################### -# Get or Create Example Data -# -------------------------- -# -# Below, the example GeoPandas data is imported and opened as a GeoDataFrame. -# Additionally, a polygon is created with shapely and then converted into a -# GeoDataFrame with the same CRS as the GeoPandas world dataset. - -capitals = geopandas.read_file(geopandas.datasets.get_path("naturalearth_cities")) -world = geopandas.read_file(geopandas.datasets.get_path("naturalearth_lowres")) - -# Create a subset of the world data that is just the South American continent -south_america = world[world["continent"] == "South America"] - -# Create a custom polygon -polygon = Polygon([(0, 0), (0, 90), (180, 90), (180, 0), (0, 0)]) -poly_gdf = geopandas.GeoDataFrame([1], geometry=[polygon], crs=world.crs) - -############################################################################### -# Plot the Unclipped Data -# ----------------------- - -fig, (ax1, ax2) = plt.subplots(2, 1, figsize=(12, 8)) -world.plot(ax=ax1) -poly_gdf.boundary.plot(ax=ax1, color="red") -south_america.boundary.plot(ax=ax2, color="green") -capitals.plot(ax=ax2, color="purple") -ax1.set_title("All Unclipped World Data", fontsize=20) -ax2.set_title("All Unclipped Capital Data", fontsize=20) -ax1.set_axis_off() -ax2.set_axis_off() -plt.show() - -############################################################################### -# Clip the Data -# -------------- -# -# When you call :func:`clip`, the first object called is the object that will -# be clipped. The second object called is the clip extent. The returned output -# will be a new clipped GeoDataframe. All of the attributes for each returned -# geometry will be retained when you clip. -# -# .. note:: -# Recall that the data must be in the same CRS in order to use the -# :func:`clip` function. If the data are not in the same CRS, be sure to use -# the GeoPandas :meth:`~GeoDataFrame.to_crs` method to ensure both datasets -# are in the same CRS. - -############################################################################### -# Clip the World Data -# -------------------- - -world_clipped = geopandas.clip(world, polygon) - -# Plot the clipped data -# The plot below shows the results of the clip function applied to the world -# sphinx_gallery_thumbnail_number = 2 -fig, ax = plt.subplots(figsize=(12, 8)) -world_clipped.plot(ax=ax, color="purple") -world.boundary.plot(ax=ax) -poly_gdf.boundary.plot(ax=ax, color="red") -ax.set_title("World Clipped", fontsize=20) -ax.set_axis_off() -plt.show() - -############################################################################### -# Clip the Capitals Data -# ---------------------- - -capitals_clipped = geopandas.clip(capitals, south_america) - -# Plot the clipped data -# The plot below shows the results of the clip function applied to the capital cities -fig, ax = plt.subplots(figsize=(12, 8)) -capitals_clipped.plot(ax=ax, color="purple") -south_america.boundary.plot(ax=ax, color="green") -ax.set_title("Capitals Clipped", fontsize=20) -ax.set_axis_off() -plt.show() diff --git a/examples/plotting_basemap_background.py b/examples/plotting_basemap_background.py deleted file mode 100644 index 5be6891..0000000 --- a/examples/plotting_basemap_background.py +++ /dev/null @@ -1,61 +0,0 @@ -""" -Adding a background map to plots --------------------------------- - -This example shows how you can add a background basemap to plots created -with the geopandas ``.plot()`` method. This makes use of the -`contextily `__ package to retrieve -web map tiles from several sources (OpenStreetMap, Stamen). - -""" -# sphinx_gallery_thumbnail_number = 3 -import geopandas - -############################################################################### -# Let's use the NYC borough boundary data that is available in geopandas -# datasets. Plotting this gives the following result: - -df = geopandas.read_file(geopandas.datasets.get_path('nybb')) -ax = df.plot(figsize=(10, 10), alpha=0.5, edgecolor='k') - -############################################################################### -# Convert the data to Web Mercator -# ================================ -# -# Web map tiles are typically provided in -# `Web Mercator `__ -# (`EPSG 3857 `__), so we need to make sure to convert -# our data first to the same CRS to combine our polygons and background tiles -# in the same map: - -df = df.to_crs(epsg=3857) - -############################################################################### - -import contextily as ctx - -############################################################################### -# Add background tiles to plot -# ============================ -# -# We can use `add_basemap` function of contextily to easily add a background -# map to our plot. : - -ax = df.plot(figsize=(10, 10), alpha=0.5, edgecolor='k') -ctx.add_basemap(ax) - -############################################################################### -# We can control the detail of the map tiles using the optional `zoom` keyword -# (be careful to not specify a too high `zoom` level, -# as this can result in a large download).: - -ax = df.plot(figsize=(10, 10), alpha=0.5, edgecolor='k') -ctx.add_basemap(ax, zoom=12) - -############################################################################### -# By default, contextily uses the Stamen Terrain style. We can specify a -# different style using ``ctx.providers``: - -ax = df.plot(figsize=(10, 10), alpha=0.5, edgecolor='k') -ctx.add_basemap(ax, url=ctx.providers.Stamen.TonerLite) -ax.set_axis_off() diff --git a/examples/plotting_with_folium.ipynb b/examples/plotting_with_folium.ipynb deleted file mode 100644 index 5b3877e..0000000 --- a/examples/plotting_with_folium.ipynb +++ /dev/null @@ -1,478 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Plotting with folium\n", - "\n", - "__What is Folium?__\n", - "\n", - "It builds on the data wrangling and a Python wrapper for leaflet.js. It makes it easy to visualize data in Python with minimal instructions.\n", - "\n", - "Folium expands on the data wrangling properties utilized in Python language and the mapping characteristics of the Leaflet.js library. Folium enables us to make an intuitive map and are is visualized in a Leaflet map after manipulating data in Python. Folium results are intuitive which makes this library helpful for dashboard building and easier to work with.\n", - "\n", - "Let's see the implementation of both GeoPandas and Folium:" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [], - "source": [ - "# Importing Libraries\n", - "import pandas as pd\n", - "import geopandas\n", - "import folium\n", - "import matplotlib.pyplot as plt\n", - "\n", - "from shapely.geometry import Point" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": { - "scrolled": true - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "RangeIndex: 63 entries, 0 to 62\n", - "Data columns (total 6 columns):\n", - "Year 63 non-null int64\n", - "Name 63 non-null object\n", - "Country 63 non-null object\n", - "Latitude 63 non-null float64\n", - "Longitude 63 non-null float64\n", - "Type 63 non-null object\n", - "dtypes: float64(2), int64(1), object(3)\n", - "memory usage: 3.0+ KB\n" - ] - } - ], - "source": [ - "df1 = pd.read_csv('volcano_data_2010.csv')\n", - "df = df1.loc[:, (\"Year\", \"Name\", \"Country\", \"Latitude\", \"Longitude\", \"Type\")]\n", - "df.info()" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": { - "scrolled": false - }, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
YearNameCountryLatitudeLongitudeTypegeometry
02010TungurahuaEcuador-1.467-78.442StratovolcanoPOINT (-78.44199999999999 -1.467)
12010EyjafjallajokullIceland63.630-19.620StratovolcanoPOINT (-19.62 63.63)
22010PacayaGuatemala14.381-90.601Complex volcanoPOINT (-90.601 14.381)
32010SariganUnited States16.708145.780StratovolcanoPOINT (145.78 16.708)
42010Karangetang [Api Siau]Indonesia2.780125.480StratovolcanoPOINT (125.48 2.78)
\n", - "
" - ], - "text/plain": [ - " Year Name Country Latitude Longitude \\\n", - "0 2010 Tungurahua Ecuador -1.467 -78.442 \n", - "1 2010 Eyjafjallajokull Iceland 63.630 -19.620 \n", - "2 2010 Pacaya Guatemala 14.381 -90.601 \n", - "3 2010 Sarigan United States 16.708 145.780 \n", - "4 2010 Karangetang [Api Siau] Indonesia 2.780 125.480 \n", - "\n", - " Type geometry \n", - "0 Stratovolcano POINT (-78.44199999999999 -1.467) \n", - "1 Stratovolcano POINT (-19.62 63.63) \n", - "2 Complex volcano POINT (-90.601 14.381) \n", - "3 Stratovolcano POINT (145.78 16.708) \n", - "4 Stratovolcano POINT (125.48 2.78) " - ] - }, - "execution_count": 3, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "geometry = geopandas.points_from_xy(df.Longitude, df.Latitude)\n", - "geo_df = geopandas.GeoDataFrame(df[['Year','Name','Country', 'Latitude', 'Longitude', 'Type']], geometry=geometry)\n", - "\n", - "geo_df.head()" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array(['Stratovolcano', 'Complex volcano', 'Shield volcano',\n", - " 'Subglacial volcano', 'Lava dome', 'Caldera'], dtype=object)" - ] - }, - "execution_count": 4, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "world = geopandas.read_file(geopandas.datasets.get_path('naturalearth_lowres'))\n", - "df.Type.unique()" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "Text(0.5, 1.0, 'Volcanoes')" - ] - }, - "execution_count": 5, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "fig, ax = plt.subplots(figsize=(24,18))\n", - "world.plot(ax=ax, alpha=0.4, color='grey')\n", - "geo_df.plot(column='Type', ax=ax, legend=True)\n", - "plt.title('Volcanoes')" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "We will be using different icons to differentiate the types of Volcanoes using Folium.\n", - "But before we start, we can see a few different tiles to choose from folium." - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
" - ], - "text/plain": [ - "" - ] - }, - "execution_count": 6, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# Stamen Terrain\n", - "map = folium.Map(location = [13.406,80.110], tiles = \"Stamen Terrain\", zoom_start = 9)\n", - "map" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
" - ], - "text/plain": [ - "" - ] - }, - "execution_count": 7, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# OpenStreetMap\n", - "map = folium.Map(location = [13.406,80.110], tiles='OpenStreetMap' , zoom_start = 9)\n", - "map" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
" - ], - "text/plain": [ - "" - ] - }, - "execution_count": 8, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# Stamen Toner\n", - "map = folium.Map(location = [13.406,80.110], tiles='Stamen Toner', zoom_start = 9)\n", - "map" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "We can use other tiles for the visualization, these are just a few examples.\n", - "\n", - "### Markers\n", - "Now, let's look at different volcanoes on the map using different Markers to represent the volcanoes." - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": {}, - "outputs": [], - "source": [ - "#use terrain map layer to actually see volcano terrain\n", - "map = folium.Map(location = [4,10], tiles = \"Stamen Terrain\", zoom_start = 3)" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": {}, - "outputs": [], - "source": [ - "# insert multiple markers, iterate through list\n", - "# add a different color marker associated with type of volcano\n", - "\n", - "geo_df_list = [[point.xy[1][0], point.xy[0][0]] for point in geo_df.geometry ]\n", - "\n", - "i = 0\n", - "for coordinates in geo_df_list:\n", - " #assign a color marker for the type of volcano, Strato being the most common\n", - " if geo_df.Type[i] == \"Stratovolcano\":\n", - " type_color = \"green\"\n", - " elif geo_df.Type[i] == \"Complex volcano\":\n", - " type_color = \"blue\"\n", - " elif geo_df.Type[i] == \"Shield volcano\":\n", - " type_color = \"orange\"\n", - " elif geo_df.Type[i] == \"Lava dome\":\n", - " type_color = \"pink\"\n", - " else:\n", - " type_color = \"purple\"\n", - "\n", - "\n", - " #now place the markers with the popup labels and data\n", - " map.add_child(folium.Marker(location = coordinates,\n", - " popup =\n", - " \"Year: \" + str(geo_df.Year[i]) + '
' +\n", - " \"Name: \" + str(geo_df.Name[i]) + '
' +\n", - " \"Country: \" + str(geo_df.Country[i]) + '
'\n", - " \"Type: \" + str(geo_df.Type[i]) + '
'\n", - " \"Coordinates: \" + str(geo_df_list[i]),\n", - " icon = folium.Icon(color = \"%s\" % type_color)))\n", - " i = i + 1" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
" - ], - "text/plain": [ - "" - ] - }, - "execution_count": 11, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "map" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Heatmaps\n", - "\n", - "Folium is well known for it's heatmap which create a heatmap layer. To plot a heat map in folium, one needs a list of Latitude, Longitude." - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
" - ], - "text/plain": [ - "" - ] - }, - "execution_count": 12, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# In this example, with the hep of heat maps, we are able to perceive the density of volcanoes\n", - "# which is more in some part of the world compared to others.\n", - "\n", - "from folium import plugins\n", - "\n", - "map = folium.Map(location = [15,30], tiles='Cartodb dark_matter', zoom_start = 2)\n", - "\n", - "heat_data = [[point.xy[1][0], point.xy[0][0]] for point in geo_df.geometry ]\n", - "\n", - "heat_data\n", - "plugins.HeatMap(heat_data).add_to(map)\n", - "\n", - "map" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.7.3" - } - }, - "nbformat": 4, - "nbformat_minor": 2 -} diff --git a/examples/plotting_with_geoplot.py b/examples/plotting_with_geoplot.py deleted file mode 100644 index f9ac7da..0000000 --- a/examples/plotting_with_geoplot.py +++ /dev/null @@ -1,105 +0,0 @@ -""" -Plotting with Geoplot and GeoPandas ------------------------------------ - -`Geoplot `_ is a Python -library providing a selection of easy-to-use geospatial visualizations. It is -built on top of the lower-level `CartoPy `_, -covered in a separate section of this tutorial, and is designed to work with -GeoPandas input. - -This example is a brief tour of the `geoplot` API. For more details on the -library refer to `its documentation -`_. - -First we'll load in the data using GeoPandas. -""" -import geopandas -import geoplot - -world = geopandas.read_file( - geopandas.datasets.get_path('naturalearth_lowres') -) -boroughs = geopandas.read_file( - geoplot.datasets.get_path('nyc_boroughs') -) -collisions = geopandas.read_file( - geoplot.datasets.get_path('nyc_injurious_collisions') -) - -############################################################################### -# Plotting with Geoplot -# ===================== -# -# We start out by replicating the basic GeoPandas world plot using Geoplot. -geoplot.polyplot(world, figsize=(8, 4)) - -############################################################################### -# Geoplot can re-project data into any of the map projections provided by -# CartoPy (see the list -# `here `_). - -# use the Orthographic map projection (e.g. a world globe) -ax = geoplot.polyplot( - world, projection=geoplot.crs.Orthographic(), figsize=(8, 4) -) -ax.outline_patch.set_visible(True) - -############################################################################### -# ``polyplot`` is trivial and can only plot the geometries you pass to it. If -# you want to use color as a visual variable, specify a ``choropleth``. Here -# we sort GDP per person by country into five buckets by color, using -# "quantiles" binning from the `Mapclassify `_ -# library. - -import mapclassify -gpd_per_person = world['gdp_md_est'] / world['pop_est'] -scheme = mapclassify.Quantiles(gpd_per_person, k=5) - -# Note: this code sample requires geoplot>=0.4.0. -geoplot.choropleth( - world, hue=gpd_per_person, scheme=scheme, - cmap='Greens', figsize=(8, 4) -) - -############################################################################### -# If you want to use size as a visual variable, use a ``cartogram``. Here are -# population estimates for countries in Africa. - -africa = world.query('continent == "Africa"') -ax = geoplot.cartogram( - africa, scale='pop_est', limits=(0.2, 1), - edgecolor='None', figsize=(7, 8) -) -geoplot.polyplot(africa, edgecolor='gray', ax=ax) - -############################################################################### -# If we have data in the shape of points in space, we may generate a -# three-dimensional heatmap on it using ``kdeplot``. - -ax = geoplot.kdeplot( - collisions.head(1000), clip=boroughs.geometry, - shade=True, cmap='Reds', - projection=geoplot.crs.AlbersEqualArea()) -geoplot.polyplot(boroughs, ax=ax, zorder=1) - -############################################################################### -# Alternatively, we may partition the space into neighborhoods automatically, -# using Voronoi tessellation. This is a good way of visually verifying whether -# or not a certain data column is spatially correlated. - -ax = geoplot.voronoi( - collisions.head(1000), projection=geoplot.crs.AlbersEqualArea(), - clip=boroughs.simplify(0.001), - hue='NUMBER OF PERSONS INJURED', cmap='Reds', - legend=True, - edgecolor='white' -) -geoplot.polyplot(boroughs, edgecolor='black', zorder=1, ax=ax) - -############################################################################### -# These are just some of the plots you can make with Geoplot. There are -# many other possibilities not covered in this brief introduction. For more -# examples, refer to the -# `Gallery `_ in -# the Geoplot documentation. diff --git a/examples/polygon_plotting_with_folium.ipynb b/examples/polygon_plotting_with_folium.ipynb deleted file mode 100644 index 556b8fd..0000000 --- a/examples/polygon_plotting_with_folium.ipynb +++ /dev/null @@ -1,574 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# An example of polygon plotting with folium \n", - "We are going to demonstrate polygon plotting in this example with the help of folium" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [], - "source": [ - "import geopandas as gpd\n", - "import folium\n", - "import matplotlib.pyplot as plt" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "We make use of nybb dataset" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": { - "scrolled": true - }, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
BoroCodeBoroNameShape_LengShape_Areageometry
05Staten Island330470.0103321.623820e+09(POLYGON ((970217.0223999023 145643.3322143555...
14Queens896344.0477633.045213e+09(POLYGON ((1029606.076599121 156073.8142089844...
23Brooklyn741080.5231661.937479e+09(POLYGON ((1021176.479003906 151374.7969970703...
31Manhattan359299.0964716.364715e+08(POLYGON ((981219.0557861328 188655.3157958984...
42Bronx464392.9918241.186925e+09(POLYGON ((1012821.805786133 229228.2645874023...
\n", - "
" - ], - "text/plain": [ - " BoroCode BoroName Shape_Leng Shape_Area \\\n", - "0 5 Staten Island 330470.010332 1.623820e+09 \n", - "1 4 Queens 896344.047763 3.045213e+09 \n", - "2 3 Brooklyn 741080.523166 1.937479e+09 \n", - "3 1 Manhattan 359299.096471 6.364715e+08 \n", - "4 2 Bronx 464392.991824 1.186925e+09 \n", - "\n", - " geometry \n", - "0 (POLYGON ((970217.0223999023 145643.3322143555... \n", - "1 (POLYGON ((1029606.076599121 156073.8142089844... \n", - "2 (POLYGON ((1021176.479003906 151374.7969970703... \n", - "3 (POLYGON ((981219.0557861328 188655.3157958984... \n", - "4 (POLYGON ((1012821.805786133 229228.2645874023... " - ] - }, - "execution_count": 2, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "path = gpd.datasets.get_path('nybb')\n", - "df = gpd.read_file(path)\n", - "df.head()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Plot from the original dataset" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "df.plot(figsize=(6, 6))\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "One thing to notice is that the values of the geometry do not directly represent the values of latitude of longitude in geographic coordinate system\n" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'init': 'epsg:2263'}\n" - ] - } - ], - "source": [ - "print(df.crs)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "As folium(i.e. leaflet.js) by default takes input of values of latitude and longitude, we need to project the geometry first" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'init': 'epsg:4326', 'no_defs': True}\n" - ] - }, - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
BoroCodeBoroNameShape_LengShape_Areageometry
05Staten Island330470.0103321.623820e+09(POLYGON ((-74.05050806403247 40.5664220341607...
14Queens896344.0477633.045213e+09(POLYGON ((-73.83668274106707 40.5949466970158...
23Brooklyn741080.5231661.937479e+09(POLYGON ((-73.86706149472118 40.5820879767934...
31Manhattan359299.0964716.364715e+08(POLYGON ((-74.01092841268031 40.6844914725429...
42Bronx464392.9918241.186925e+09(POLYGON ((-73.89680883223774 40.7958084451597...
\n", - "
" - ], - "text/plain": [ - " BoroCode BoroName Shape_Leng Shape_Area \\\n", - "0 5 Staten Island 330470.010332 1.623820e+09 \n", - "1 4 Queens 896344.047763 3.045213e+09 \n", - "2 3 Brooklyn 741080.523166 1.937479e+09 \n", - "3 1 Manhattan 359299.096471 6.364715e+08 \n", - "4 2 Bronx 464392.991824 1.186925e+09 \n", - "\n", - " geometry \n", - "0 (POLYGON ((-74.05050806403247 40.5664220341607... \n", - "1 (POLYGON ((-73.83668274106707 40.5949466970158... \n", - "2 (POLYGON ((-73.86706149472118 40.5820879767934... \n", - "3 (POLYGON ((-74.01092841268031 40.6844914725429... \n", - "4 (POLYGON ((-73.89680883223774 40.7958084451597... " - ] - }, - "execution_count": 5, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "df = df.to_crs(epsg=4326)\n", - "print(df.crs)\n", - "df.head()" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "df.plot(figsize=(6, 6))\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Initialize folium map object" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
" - ], - "text/plain": [ - "" - ] - }, - "execution_count": 7, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "m = folium.Map(location=[40.70, -73.94], zoom_start=10, tiles='CartoDB positron')\n", - "m" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Overlay the boundaries of boroughs on map with borough name as popup" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
" - ], - "text/plain": [ - "" - ] - }, - "execution_count": 8, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "for _, r in df.iterrows():\n", - " #without simplifying the representation of each borough, the map might not be displayed \n", - " #sim_geo = gpd.GeoSeries(r['geometry'])\n", - " sim_geo = gpd.GeoSeries(r['geometry']).simplify(tolerance=0.001)\n", - " geo_j = sim_geo.to_json()\n", - " geo_j = folium.GeoJson(data=geo_j,\n", - " style_function=lambda x: {'fillColor': 'orange'})\n", - " folium.Popup(r['BoroName']).add_to(geo_j)\n", - " geo_j.add_to(m)\n", - "m" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Add marker showing the area and length of each borough" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
BoroCodeBoroNameShape_LengShape_Areageometrylatlon
05Staten Island330470.0103321.623820e+09(POLYGON ((-74.05050806403247 40.5664220341607...40.580858-74.153369
14Queens896344.0477633.045213e+09(POLYGON ((-73.83668274106707 40.5949466970158...40.707604-73.818485
23Brooklyn741080.5231661.937479e+09(POLYGON ((-73.86706149472118 40.5820879767934...40.644734-73.947677
31Manhattan359299.0964716.364715e+08(POLYGON ((-74.01092841268031 40.6844914725429...40.777276-73.967159
42Bronx464392.9918241.186925e+09(POLYGON ((-73.89680883223774 40.7958084451597...40.852627-73.866524
\n", - "
" - ], - "text/plain": [ - " BoroCode BoroName Shape_Leng Shape_Area \\\n", - "0 5 Staten Island 330470.010332 1.623820e+09 \n", - "1 4 Queens 896344.047763 3.045213e+09 \n", - "2 3 Brooklyn 741080.523166 1.937479e+09 \n", - "3 1 Manhattan 359299.096471 6.364715e+08 \n", - "4 2 Bronx 464392.991824 1.186925e+09 \n", - "\n", - " geometry lat lon \n", - "0 (POLYGON ((-74.05050806403247 40.5664220341607... 40.580858 -74.153369 \n", - "1 (POLYGON ((-73.83668274106707 40.5949466970158... 40.707604 -73.818485 \n", - "2 (POLYGON ((-73.86706149472118 40.5820879767934... 40.644734 -73.947677 \n", - "3 (POLYGON ((-74.01092841268031 40.6844914725429... 40.777276 -73.967159 \n", - "4 (POLYGON ((-73.89680883223774 40.7958084451597... 40.852627 -73.866524 " - ] - }, - "execution_count": 9, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "df['lat'] = df.centroid.y\n", - "df['lon'] = df.centroid.x\n", - "df.head()" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
" - ], - "text/plain": [ - "" - ] - }, - "execution_count": 10, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "for _, r in df.iterrows():\n", - " folium.Marker(location=[r['lat'], r['lon']], popup='length: {}
area: {}'.format(r['Shape_Leng'], r['Shape_Area'])).add_to(m)\n", - " \n", - "m" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.6.8" - } - }, - "nbformat": 4, - "nbformat_minor": 2 -} diff --git a/examples/spatial_joins.ipynb b/examples/spatial_joins.ipynb deleted file mode 100644 index 61a0f41..0000000 --- a/examples/spatial_joins.ipynb +++ /dev/null @@ -1,1126 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Spatial Joins\n", - "\n", - "A *spatial join* uses [binary predicates](http://shapely.readthedocs.io/en/latest/manual.html#binary-predicates) \n", - "such as `intersects` and `crosses` to combine two `GeoDataFrames` based on the spatial relationship \n", - "between their geometries.\n", - "\n", - "A common use case might be a spatial join between a point layer and a polygon layer where you want to retain the point geometries and grab the attributes of the intersecting polygons.\n" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": { - "ExecuteTime": { - "end_time": "2017-12-15T21:26:04.391570Z", - "start_time": "2017-12-15T21:26:04.361570Z" - } - }, - "outputs": [ - { - "data": { - "text/html": [ - "" - ], - "text/plain": [ - "" - ] - }, - "execution_count": 1, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "from IPython.core.display import Image \n", - "Image(url='https://web.natur.cuni.cz/~langhamr/lectures/vtfg1/mapinfo_1/about_gis/Image23.gif') " - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "\n", - "## Types of spatial joins\n", - "\n", - "We currently support the following methods of spatial joins. We refer to the *left_df* and *right_df* which are the correspond to the two dataframes passed in as args.\n", - "\n", - "### Left outer join\n", - "\n", - "In a LEFT OUTER JOIN (`how='left'`), we keep *all* rows from the left and duplicate them if necessary to represent multiple hits between the two dataframes. We retain attributes of the right if they intersect and lose right rows that don't intersect. A left outer join implies that we are interested in retaining the geometries of the left. \n", - "\n", - "This is equivalent to the PostGIS query:\n", - "```\n", - "SELECT pts.geom, pts.id as ptid, polys.id as polyid \n", - "FROM pts\n", - "LEFT OUTER JOIN polys\n", - "ON ST_Intersects(pts.geom, polys.geom);\n", - "\n", - " geom | ptid | polyid \n", - "--------------------------------------------+------+--------\n", - " 010100000040A9FBF2D88AD03F349CD47D796CE9BF | 4 | 10\n", - " 010100000048EABE3CB622D8BFA8FBF2D88AA0E9BF | 3 | 10\n", - " 010100000048EABE3CB622D8BFA8FBF2D88AA0E9BF | 3 | 20\n", - " 0101000000F0D88AA0E1A4EEBF7052F7E5B115E9BF | 2 | 20\n", - " 0101000000818693BA2F8FF7BF4ADD97C75604E9BF | 1 | \n", - "(5 rows)\n", - "```\n", - "\n", - "### Right outer join\n", - "\n", - "In a RIGHT OUTER JOIN (`how='right'`), we keep *all* rows from the right and duplicate them if necessary to represent multiple hits between the two dataframes. We retain attributes of the left if they intersect and lose left rows that don't intersect. A right outer join implies that we are interested in retaining the geometries of the right. \n", - "\n", - "This is equivalent to the PostGIS query:\n", - "```\n", - "SELECT polys.geom, pts.id as ptid, polys.id as polyid \n", - "FROM pts\n", - "RIGHT OUTER JOIN polys\n", - "ON ST_Intersects(pts.geom, polys.geom);\n", - "\n", - " geom | ptid | polyid \n", - "----------+------+--------\n", - " 01...9BF | 4 | 10\n", - " 01...9BF | 3 | 10\n", - " 02...7BF | 3 | 20\n", - " 02...7BF | 2 | 20\n", - " 00...5BF | | 30\n", - "(5 rows)\n", - "```\n", - "\n", - "### Inner join\n", - "\n", - "In an INNER JOIN (`how='inner'`), we keep rows from the right and left only where their binary predicate is `True`. We duplicate them if necessary to represent multiple hits between the two dataframes. We retain attributes of the right and left only if they intersect and lose all rows that do not. An inner join implies that we are interested in retaining the geometries of the left. \n", - "\n", - "This is equivalent to the PostGIS query:\n", - "```\n", - "SELECT pts.geom, pts.id as ptid, polys.id as polyid \n", - "FROM pts\n", - "INNER JOIN polys\n", - "ON ST_Intersects(pts.geom, polys.geom);\n", - "\n", - " geom | ptid | polyid \n", - "--------------------------------------------+------+--------\n", - " 010100000040A9FBF2D88AD03F349CD47D796CE9BF | 4 | 10\n", - " 010100000048EABE3CB622D8BFA8FBF2D88AA0E9BF | 3 | 10\n", - " 010100000048EABE3CB622D8BFA8FBF2D88AA0E9BF | 3 | 20\n", - " 0101000000F0D88AA0E1A4EEBF7052F7E5B115E9BF | 2 | 20\n", - "(4 rows) \n", - "```" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Spatial Joins between two GeoDataFrames\n", - "\n", - "Let's take a look at how we'd implement these using `GeoPandas`. First, load up the NYC test data into `GeoDataFrames`:" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": { - "ExecuteTime": { - "end_time": "2017-12-15T21:26:07.191542Z", - "start_time": "2017-12-15T21:26:04.391570Z" - } - }, - "outputs": [], - "source": [ - "%matplotlib inline\n", - "from shapely.geometry import Point\n", - "from geopandas import datasets, GeoDataFrame, read_file\n", - "from geopandas.tools import overlay\n", - "\n", - "# NYC Boros\n", - "zippath = datasets.get_path('nybb')\n", - "polydf = read_file(zippath)\n", - "\n", - "# Generate some points\n", - "b = [int(x) for x in polydf.total_bounds]\n", - "N = 8\n", - "pointdf = GeoDataFrame([\n", - " {'geometry': Point(x, y), 'value1': x + y, 'value2': x - y}\n", - " for x, y in zip(range(b[0], b[2], int((b[2] - b[0]) / N)),\n", - " range(b[1], b[3], int((b[3] - b[1]) / N)))])\n", - "\n", - "# Make sure they're using the same projection reference\n", - "pointdf.crs = polydf.crs" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": { - "ExecuteTime": { - "end_time": "2017-12-15T21:26:07.211542Z", - "start_time": "2017-12-15T21:26:07.191542Z" - } - }, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
geometryvalue1value2
0POINT (913175 120121)1033296793054
1POINT (932450 139211)1071661793239
2POINT (951725 158301)1110026793424
3POINT (971000 177391)1148391793609
4POINT (990275 196481)1186756793794
5POINT (1009550 215571)1225121793979
6POINT (1028825 234661)1263486794164
7POINT (1048100 253751)1301851794349
8POINT (1067375 272841)1340216794534
\n", - "
" - ], - "text/plain": [ - " geometry value1 value2\n", - "0 POINT (913175 120121) 1033296 793054\n", - "1 POINT (932450 139211) 1071661 793239\n", - "2 POINT (951725 158301) 1110026 793424\n", - "3 POINT (971000 177391) 1148391 793609\n", - "4 POINT (990275 196481) 1186756 793794\n", - "5 POINT (1009550 215571) 1225121 793979\n", - "6 POINT (1028825 234661) 1263486 794164\n", - "7 POINT (1048100 253751) 1301851 794349\n", - "8 POINT (1067375 272841) 1340216 794534" - ] - }, - "execution_count": 3, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "pointdf" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": { - "ExecuteTime": { - "end_time": "2017-12-15T21:26:07.921534Z", - "start_time": "2017-12-15T21:26:07.211542Z" - } - }, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
BoroCodeBoroNameShape_LengShape_Areageometry
05Staten Island330470.0103321.623820e+09(POLYGON ((970217.0223999023 145643.3322143555...
14Queens896344.0477633.045213e+09(POLYGON ((1029606.076599121 156073.8142089844...
23Brooklyn741080.5231661.937479e+09(POLYGON ((1021176.479003906 151374.7969970703...
31Manhattan359299.0964716.364715e+08(POLYGON ((981219.0557861328 188655.3157958984...
42Bronx464392.9918241.186925e+09(POLYGON ((1012821.805786133 229228.2645874023...
\n", - "
" - ], - "text/plain": [ - " BoroCode BoroName Shape_Leng Shape_Area \\\n", - "0 5 Staten Island 330470.010332 1.623820e+09 \n", - "1 4 Queens 896344.047763 3.045213e+09 \n", - "2 3 Brooklyn 741080.523166 1.937479e+09 \n", - "3 1 Manhattan 359299.096471 6.364715e+08 \n", - "4 2 Bronx 464392.991824 1.186925e+09 \n", - "\n", - " geometry \n", - "0 (POLYGON ((970217.0223999023 145643.3322143555... \n", - "1 (POLYGON ((1029606.076599121 156073.8142089844... \n", - "2 (POLYGON ((1021176.479003906 151374.7969970703... \n", - "3 (POLYGON ((981219.0557861328 188655.3157958984... \n", - "4 (POLYGON ((1012821.805786133 229228.2645874023... " - ] - }, - "execution_count": 4, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "polydf" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": { - "ExecuteTime": { - "end_time": "2017-12-15T21:26:08.271531Z", - "start_time": "2017-12-15T21:26:07.921534Z" - } - }, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 5, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAS0AAAD8CAYAAAAi9vLQAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nSMoAAAAASUVORK5CYII=\n", - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "pointdf.plot()" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": { - "ExecuteTime": { - "end_time": "2017-12-15T21:26:10.561508Z", - "start_time": "2017-12-15T21:26:08.271531Z" - } - }, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 6, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAS0AAAD8CAYAAAAi9vLQAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nyQAAAABJRU5ErkJggg==\n", - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "polydf.plot()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Joins" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": { - "ExecuteTime": { - "end_time": "2017-12-15T21:26:12.951484Z", - "start_time": "2017-12-15T21:26:10.561508Z" - } - }, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
geometryvalue1value2index_rightBoroCodeBoroNameShape_LengShape_Area
0POINT (913175 120121)1033296793054NaNNaNNaNNaNNaN
1POINT (932450 139211)10716617932390.05.0Staten Island330470.0103321.623820e+09
2POINT (951725 158301)11100267934240.05.0Staten Island330470.0103321.623820e+09
3POINT (971000 177391)1148391793609NaNNaNNaNNaNNaN
4POINT (990275 196481)1186756793794NaNNaNNaNNaNNaN
5POINT (1009550 215571)12251217939791.04.0Queens896344.0477633.045213e+09
6POINT (1028825 234661)12634867941644.02.0Bronx464392.9918241.186925e+09
7POINT (1048100 253751)1301851794349NaNNaNNaNNaNNaN
8POINT (1067375 272841)1340216794534NaNNaNNaNNaNNaN
\n", - "
" - ], - "text/plain": [ - " geometry value1 value2 index_right BoroCode \\\n", - "0 POINT (913175 120121) 1033296 793054 NaN NaN \n", - "1 POINT (932450 139211) 1071661 793239 0.0 5.0 \n", - "2 POINT (951725 158301) 1110026 793424 0.0 5.0 \n", - "3 POINT (971000 177391) 1148391 793609 NaN NaN \n", - "4 POINT (990275 196481) 1186756 793794 NaN NaN \n", - "5 POINT (1009550 215571) 1225121 793979 1.0 4.0 \n", - "6 POINT (1028825 234661) 1263486 794164 4.0 2.0 \n", - "7 POINT (1048100 253751) 1301851 794349 NaN NaN \n", - "8 POINT (1067375 272841) 1340216 794534 NaN NaN \n", - "\n", - " BoroName Shape_Leng Shape_Area \n", - "0 NaN NaN NaN \n", - "1 Staten Island 330470.010332 1.623820e+09 \n", - "2 Staten Island 330470.010332 1.623820e+09 \n", - "3 NaN NaN NaN \n", - "4 NaN NaN NaN \n", - "5 Queens 896344.047763 3.045213e+09 \n", - "6 Bronx 464392.991824 1.186925e+09 \n", - "7 NaN NaN NaN \n", - "8 NaN NaN NaN " - ] - }, - "execution_count": 7, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "from geopandas.tools import sjoin\n", - "join_left_df = sjoin(pointdf, polydf, how=\"left\")\n", - "join_left_df\n", - "# Note the NaNs where the point did not intersect a boro" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": { - "ExecuteTime": { - "end_time": "2017-12-15T21:26:13.871475Z", - "start_time": "2017-12-15T21:26:12.951484Z" - } - }, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
index_leftvalue1value2BoroCodeBoroNameShape_LengShape_Areageometry
index_right
01.01071661.0793239.05Staten Island330470.0103321.623820e+09(POLYGON ((970217.0223999023 145643.3322143555...
02.01110026.0793424.05Staten Island330470.0103321.623820e+09(POLYGON ((970217.0223999023 145643.3322143555...
15.01225121.0793979.04Queens896344.0477633.045213e+09(POLYGON ((1029606.076599121 156073.8142089844...
46.01263486.0794164.02Bronx464392.9918241.186925e+09(POLYGON ((1012821.805786133 229228.2645874023...
2NaNNaNNaN3Brooklyn741080.5231661.937479e+09(POLYGON ((1021176.479003906 151374.7969970703...
3NaNNaNNaN1Manhattan359299.0964716.364715e+08(POLYGON ((981219.0557861328 188655.3157958984...
\n", - "
" - ], - "text/plain": [ - " index_left value1 value2 BoroCode BoroName \\\n", - "index_right \n", - "0 1.0 1071661.0 793239.0 5 Staten Island \n", - "0 2.0 1110026.0 793424.0 5 Staten Island \n", - "1 5.0 1225121.0 793979.0 4 Queens \n", - "4 6.0 1263486.0 794164.0 2 Bronx \n", - "2 NaN NaN NaN 3 Brooklyn \n", - "3 NaN NaN NaN 1 Manhattan \n", - "\n", - " Shape_Leng Shape_Area \\\n", - "index_right \n", - "0 330470.010332 1.623820e+09 \n", - "0 330470.010332 1.623820e+09 \n", - "1 896344.047763 3.045213e+09 \n", - "4 464392.991824 1.186925e+09 \n", - "2 741080.523166 1.937479e+09 \n", - "3 359299.096471 6.364715e+08 \n", - "\n", - " geometry \n", - "index_right \n", - "0 (POLYGON ((970217.0223999023 145643.3322143555... \n", - "0 (POLYGON ((970217.0223999023 145643.3322143555... \n", - "1 (POLYGON ((1029606.076599121 156073.8142089844... \n", - "4 (POLYGON ((1012821.805786133 229228.2645874023... \n", - "2 (POLYGON ((1021176.479003906 151374.7969970703... \n", - "3 (POLYGON ((981219.0557861328 188655.3157958984... " - ] - }, - "execution_count": 8, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "join_right_df = sjoin(pointdf, polydf, how=\"right\")\n", - "join_right_df\n", - "# Note Staten Island is repeated" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": { - "ExecuteTime": { - "end_time": "2017-12-15T21:26:13.961474Z", - "start_time": "2017-12-15T21:26:13.881475Z" - } - }, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
geometryvalue1value2index_rightBoroCodeBoroNameShape_LengShape_Area
1POINT (932450 139211)107166179323905Staten Island330470.0103321.623820e+09
2POINT (951725 158301)111002679342405Staten Island330470.0103321.623820e+09
5POINT (1009550 215571)122512179397914Queens896344.0477633.045213e+09
6POINT (1028825 234661)126348679416442Bronx464392.9918241.186925e+09
\n", - "
" - ], - "text/plain": [ - " geometry value1 value2 index_right BoroCode \\\n", - "1 POINT (932450 139211) 1071661 793239 0 5 \n", - "2 POINT (951725 158301) 1110026 793424 0 5 \n", - "5 POINT (1009550 215571) 1225121 793979 1 4 \n", - "6 POINT (1028825 234661) 1263486 794164 4 2 \n", - "\n", - " BoroName Shape_Leng Shape_Area \n", - "1 Staten Island 330470.010332 1.623820e+09 \n", - "2 Staten Island 330470.010332 1.623820e+09 \n", - "5 Queens 896344.047763 3.045213e+09 \n", - "6 Bronx 464392.991824 1.186925e+09 " - ] - }, - "execution_count": 9, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "join_inner_df = sjoin(pointdf, polydf, how=\"inner\")\n", - "join_inner_df\n", - "# Note the lack of NaNs; dropped anything that didn't intersect" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "We're not limited to using the `intersection` binary predicate. Any of the `Shapely` geometry methods that return a Boolean can be used by specifying the `op` kwarg." - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": { - "ExecuteTime": { - "end_time": "2017-12-15T21:26:14.191472Z", - "start_time": "2017-12-15T21:26:13.961474Z" - } - }, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
geometryvalue1value2index_rightBoroCodeBoroNameShape_LengShape_Area
0POINT (913175 120121)1033296793054NaNNaNNaNNaNNaN
1POINT (932450 139211)10716617932390.05.0Staten Island330470.0103321.623820e+09
2POINT (951725 158301)11100267934240.05.0Staten Island330470.0103321.623820e+09
3POINT (971000 177391)1148391793609NaNNaNNaNNaNNaN
4POINT (990275 196481)1186756793794NaNNaNNaNNaNNaN
5POINT (1009550 215571)12251217939791.04.0Queens896344.0477633.045213e+09
6POINT (1028825 234661)12634867941644.02.0Bronx464392.9918241.186925e+09
7POINT (1048100 253751)1301851794349NaNNaNNaNNaNNaN
8POINT (1067375 272841)1340216794534NaNNaNNaNNaNNaN
\n", - "
" - ], - "text/plain": [ - " geometry value1 value2 index_right BoroCode \\\n", - "0 POINT (913175 120121) 1033296 793054 NaN NaN \n", - "1 POINT (932450 139211) 1071661 793239 0.0 5.0 \n", - "2 POINT (951725 158301) 1110026 793424 0.0 5.0 \n", - "3 POINT (971000 177391) 1148391 793609 NaN NaN \n", - "4 POINT (990275 196481) 1186756 793794 NaN NaN \n", - "5 POINT (1009550 215571) 1225121 793979 1.0 4.0 \n", - "6 POINT (1028825 234661) 1263486 794164 4.0 2.0 \n", - "7 POINT (1048100 253751) 1301851 794349 NaN NaN \n", - "8 POINT (1067375 272841) 1340216 794534 NaN NaN \n", - "\n", - " BoroName Shape_Leng Shape_Area \n", - "0 NaN NaN NaN \n", - "1 Staten Island 330470.010332 1.623820e+09 \n", - "2 Staten Island 330470.010332 1.623820e+09 \n", - "3 NaN NaN NaN \n", - "4 NaN NaN NaN \n", - "5 Queens 896344.047763 3.045213e+09 \n", - "6 Bronx 464392.991824 1.186925e+09 \n", - "7 NaN NaN NaN \n", - "8 NaN NaN NaN " - ] - }, - "execution_count": 10, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "sjoin(pointdf, polydf, how=\"left\", op=\"within\")" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.6.1" - } - }, - "nbformat": 4, - "nbformat_minor": 1 -} diff --git a/geopandas/__init__.py b/geopandas/__init__.py index 79bffdd..0ce113d 100644 --- a/geopandas/__init__.py +++ b/geopandas/__init__.py @@ -8,7 +8,7 @@ from geopandas.io.file import _read_file as read_file # noqa from geopandas.io.arrow import _read_parquet as read_parquet # noqa from geopandas.io.arrow import _read_feather as read_feather # noqa from geopandas.io.sql import _read_postgis as read_postgis # noqa -from geopandas.tools import sjoin # noqa +from geopandas.tools import sjoin, sjoin_nearest # noqa from geopandas.tools import overlay # noqa from geopandas.tools._show_versions import show_versions # noqa from geopandas.tools import clip # noqa @@ -23,7 +23,6 @@ import geopandas as gpd # noqa import pandas as pd # noqa import numpy as np # noqa -from ._version import get_versions +from . import _version -__version__ = get_versions()["version"] -del get_versions +__version__ = _version.get_versions()["version"] diff --git a/geopandas/_compat.py b/geopandas/_compat.py index fa86961..b9142e6 100644 --- a/geopandas/_compat.py +++ b/geopandas/_compat.py @@ -1,19 +1,26 @@ -from distutils.version import LooseVersion +import contextlib +from packaging.version import Version import importlib import os import warnings +import numpy as np import pandas as pd +import pyproj import shapely +import shapely.geos + # ----------------------------------------------------------------------------- # pandas compat # ----------------------------------------------------------------------------- -PANDAS_GE_024 = str(pd.__version__) >= LooseVersion("0.24.0") -PANDAS_GE_025 = str(pd.__version__) >= LooseVersion("0.25.0") -PANDAS_GE_10 = str(pd.__version__) >= LooseVersion("0.26.0.dev") -PANDAS_GE_11 = str(pd.__version__) >= LooseVersion("1.1.0.dev") +PANDAS_GE_10 = Version(pd.__version__) >= Version("1.0.0") +PANDAS_GE_11 = Version(pd.__version__) >= Version("1.1.0") +PANDAS_GE_115 = Version(pd.__version__) >= Version("1.1.5") +PANDAS_GE_12 = Version(pd.__version__) >= Version("1.2.0") +PANDAS_GE_13 = Version(pd.__version__) >= Version("1.3.0") +PANDAS_GE_14 = Version(pd.__version__) >= Version("1.4.0rc0") # ----------------------------------------------------------------------------- @@ -21,16 +28,38 @@ PANDAS_GE_11 = str(pd.__version__) >= LooseVersion("1.1.0.dev") # ----------------------------------------------------------------------------- -SHAPELY_GE_17 = str(shapely.__version__) >= LooseVersion("1.7.0") +SHAPELY_GE_17 = Version(shapely.__version__) >= Version("1.7.0") +SHAPELY_GE_18 = Version(shapely.__version__) >= Version("1.8") +SHAPELY_GE_20 = Version(shapely.__version__) >= Version("2.0") + +GEOS_GE_390 = shapely.geos.geos_version >= (3, 9, 0) + HAS_PYGEOS = None USE_PYGEOS = None PYGEOS_SHAPELY_COMPAT = None +PYGEOS_GE_09 = None +PYGEOS_GE_010 = None + +INSTALL_PYGEOS_ERROR = "To use PyGEOS within GeoPandas, you need to install PyGEOS: \ +'conda install pygeos' or 'pip install pygeos'" + try: import pygeos # noqa - HAS_PYGEOS = True + # only automatically use pygeos if version is high enough + if Version(pygeos.__version__) >= Version("0.8"): + HAS_PYGEOS = True + PYGEOS_GE_09 = Version(pygeos.__version__) >= Version("0.9") + PYGEOS_GE_010 = Version(pygeos.__version__) >= Version("0.10") + else: + warnings.warn( + "The installed version of PyGEOS is too old ({0} installed, 0.8 required)," + " and thus GeoPandas will not use PyGEOS.".format(pygeos.__version__), + UserWarning, + ) + HAS_PYGEOS = False except ImportError: HAS_PYGEOS = False @@ -65,9 +94,9 @@ def set_use_pygeos(val=None): import pygeos # noqa # validate the pygeos version - if not str(pygeos.__version__) >= LooseVersion("0.6"): + if not Version(pygeos.__version__) >= Version("0.8"): raise ImportError( - "PyGEOS >= 0.6 is required, version {0} is installed".format( + "PyGEOS >= 0.8 is required, version {0} is installed".format( pygeos.__version__ ) ) @@ -93,15 +122,56 @@ def set_use_pygeos(val=None): PYGEOS_SHAPELY_COMPAT = True except ImportError: - raise ImportError( - "To use the PyGEOS speed-ups within GeoPandas, you need to install " - "PyGEOS: 'conda install pygeos' or 'pip install pygeos'" - ) + raise ImportError(INSTALL_PYGEOS_ERROR) set_use_pygeos() +# compat related to deprecation warnings introduced in Shapely 1.8 +# -> creating a numpy array from a list-like of Multi-part geometries, +# although doing the correct thing (not expanding in its parts), still raises +# the warning about iteration being deprecated +# This adds a context manager to explicitly ignore this warning + + +try: + from shapely.errors import ShapelyDeprecationWarning as shapely_warning +except ImportError: + shapely_warning = None + + +if shapely_warning is not None and not SHAPELY_GE_20: + + @contextlib.contextmanager + def ignore_shapely2_warnings(): + with warnings.catch_warnings(): + warnings.filterwarnings( + "ignore", "Iteration|The array interface|__len__", shapely_warning + ) + yield + + +elif (Version(np.__version__) >= Version("1.21")) and not SHAPELY_GE_20: + + @contextlib.contextmanager + def ignore_shapely2_warnings(): + with warnings.catch_warnings(): + # warning from numpy for existing Shapely releases (this is fixed + # with Shapely 1.8) + warnings.filterwarnings( + "ignore", "An exception was ignored while fetching", DeprecationWarning + ) + yield + + +else: + + @contextlib.contextmanager + def ignore_shapely2_warnings(): + yield + + def import_optional_dependency(name: str, extra: str = ""): """ Import an optional dependency. @@ -151,3 +221,10 @@ try: HAS_RTREE = True except ImportError: HAS_RTREE = False + +# ----------------------------------------------------------------------------- +# pyproj compat +# ----------------------------------------------------------------------------- + +PYPROJ_LT_3 = Version(pyproj.__version__) < Version("3") +PYPROJ_GE_31 = Version(pyproj.__version__) >= Version("3.1") diff --git a/geopandas/_config.py b/geopandas/_config.py index 1dd0d11..99a2fca 100644 --- a/geopandas/_config.py +++ b/geopandas/_config.py @@ -16,13 +16,13 @@ class Options(object): """Provide attribute-style access to configuration dict.""" def __init__(self, options): - super(Options, self).__setattr__("_options", options) + super().__setattr__("_options", options) # populate with default values config = {} for key, option in options.items(): config[key] = option.default_value - super(Options, self).__setattr__("_config", config) + super().__setattr__("_config", config) def __setattr__(self, key, value): # you can't set new keys @@ -59,30 +59,13 @@ class Options(object): doc_text = "\n".join(textwrap.wrap(option.doc, width=70)) else: doc_text = u"No description available." - doc_text = indent(doc_text, prefix=" ") + doc_text = textwrap.indent(doc_text, prefix=" ") description += doc_text + "\n" space = "\n " description = description.replace("\n", space) return "{}({}{})".format(cls, space, description) -def indent(text, prefix, predicate=None): - """ - This is the python 3 textwrap.indent function, which is not available in - python 2. - """ - if predicate is None: - - def predicate(line): - return line.strip() - - def prefixed_lines(): - for line in text.splitlines(True): - yield (prefix + line if predicate(line) else line) - - return "".join(prefixed_lines()) - - def _validate_display_precision(value): if value is not None: if not isinstance(value, int) or not (0 <= value <= 16): diff --git a/geopandas/_decorator.py b/geopandas/_decorator.py new file mode 100644 index 0000000..6c263c7 --- /dev/null +++ b/geopandas/_decorator.py @@ -0,0 +1,51 @@ +from textwrap import dedent +from typing import Callable, Union + + +# doc decorator function ported with modifications from Pandas +# https://github.com/pandas-dev/pandas/blob/master/pandas/util/_decorators.py + + +def doc(*docstrings: Union[str, Callable], **params) -> Callable: + """ + A decorator take docstring templates, concatenate them and perform string + substitution on it. + This decorator will add a variable "_docstring_components" to the wrapped + callable to keep track the original docstring template for potential usage. + If it should be consider as a template, it will be saved as a string. + Otherwise, it will be saved as callable, and later user __doc__ and dedent + to get docstring. + + Parameters + ---------- + *docstrings : str or callable + The string / docstring / docstring template to be appended in order + after default docstring under callable. + **params + The string which would be used to format docstring template. + """ + + def decorator(decorated: Callable) -> Callable: + # collecting docstring and docstring templates + docstring_components: list[Union[str, Callable]] = [] + if decorated.__doc__: + docstring_components.append(dedent(decorated.__doc__)) + + for docstring in docstrings: + if hasattr(docstring, "_docstring_components"): + docstring_components.extend(docstring._docstring_components) + elif isinstance(docstring, str) or docstring.__doc__: + docstring_components.append(docstring) + + # formatting templates and concatenating docstring + decorated.__doc__ = "".join( + component.format(**params) + if isinstance(component, str) + else dedent(component.__doc__ or "") + for component in docstring_components + ) + + decorated._docstring_components = docstring_components + return decorated + + return decorator diff --git a/geopandas/_vectorized.py b/geopandas/_vectorized.py index 4d37d56..611551f 100644 --- a/geopandas/_vectorized.py +++ b/geopandas/_vectorized.py @@ -7,6 +7,7 @@ Uses PyGEOS if available/set, otherwise loops through Shapely geometries. import warnings import numpy as np +import pandas as pd import shapely.geometry import shapely.geos @@ -24,6 +25,7 @@ except ImportError: _names = { + "MISSING": None, "NAG": None, "POINT": "Point", "LINESTRING": "LineString", @@ -43,9 +45,9 @@ else: type_mapping, geometry_type_ids, geometry_type_values = None, None, None -def _isna(value): +def isna(value): """ - Check if scalar value is NA-like (None or np.nan). + Check if scalar value is NA-like (None, np.nan or pd.NA). Custom version that only works for scalars (returning True or False), as `pd.isna` also works for array-like input returning a boolean array. @@ -54,6 +56,8 @@ def _isna(value): return True elif isinstance(value, float) and np.isnan(value): return True + elif compat.PANDAS_GE_10 and value is pd.NA: + return True else: return False @@ -101,7 +105,8 @@ def from_shapely(data): if compat.USE_PYGEOS and compat.PYGEOS_SHAPELY_COMPAT: if not isinstance(data, np.ndarray): arr = np.empty(len(data), dtype=object) - arr[:] = data + with compat.ignore_shapely2_warnings(): + arr[:] = data else: arr = data try: @@ -120,15 +125,12 @@ def from_shapely(data): else: out.append(geom) elif hasattr(geom, "__geo_interface__"): - geom = shapely.geometry.asShape(geom) - # asShape returns GeometryProxy -> trigger actual materialization - # with one of its methods - geom.wkb + geom = shapely.geometry.shape(geom) if compat.USE_PYGEOS: out.append(_shapely_to_pygeos(geom)) else: out.append(geom) - elif _isna(geom): + elif isna(geom): out.append(None) else: raise TypeError("Input must be valid geometry objects: {0}".format(geom)) @@ -139,14 +141,16 @@ def from_shapely(data): # numpy can expand geometry collections into 2D arrays, use this # two-step construction to avoid this aout = np.empty(len(data), dtype=object) - aout[:] = out + with compat.ignore_shapely2_warnings(): + aout[:] = out return aout def to_shapely(data): if compat.USE_PYGEOS: out = np.empty(len(data), dtype=object) - out[:] = [_pygeos_to_shapely(geom) for geom in data] + with compat.ignore_shapely2_warnings(): + out[:] = [_pygeos_to_shapely(geom) for geom in data] return out else: return data @@ -164,20 +168,21 @@ def from_wkb(data): out = [] for geom in data: - if geom is not None and len(geom): - geom = shapely.wkb.loads(geom) + if not isna(geom) and len(geom): + geom = shapely.wkb.loads(geom, hex=isinstance(geom, str)) else: geom = None out.append(geom) aout = np.empty(len(data), dtype=object) - aout[:] = out + with compat.ignore_shapely2_warnings(): + aout[:] = out return aout -def to_wkb(data, hex=False): +def to_wkb(data, hex=False, **kwargs): if compat.USE_PYGEOS: - return pygeos.to_wkb(data, hex=hex) + return pygeos.to_wkb(data, hex=hex, **kwargs) else: if hex: out = [geom.wkb_hex if geom is not None else None for geom in data] @@ -198,7 +203,7 @@ def from_wkt(data): out = [] for geom in data: - if geom is not None and len(geom): + if not isna(geom) and len(geom): if isinstance(geom, bytes): geom = geom.decode("utf-8") geom = shapely.wkt.loads(geom) @@ -207,7 +212,8 @@ def from_wkt(data): out.append(geom) aout = np.empty(len(data), dtype=object) - aout[:] = out + with compat.ignore_shapely2_warnings(): + aout[:] = out return aout @@ -244,7 +250,8 @@ def points_from_xy(x, y, z=None): else: out = _points_from_xy(x, y, z) aout = np.empty(len(x), dtype=object) - aout[:] = out + with compat.ignore_shapely2_warnings(): + aout[:] = out return aout @@ -262,7 +269,7 @@ def _binary_method(op, left, right, **kwargs): def _binary_geo(op, left, right): # type: (str, np.array[geoms], [np.array[geoms]/BaseGeometry]) -> np.array[geoms] - """ Apply geometry-valued operation + """Apply geometry-valued operation Supports: @@ -280,10 +287,11 @@ def _binary_geo(op, left, right): # intersection can return empty GeometryCollections, and if the # result are only those, numpy will coerce it to empty 2D array data = np.empty(len(left), dtype=object) - data[:] = [ - getattr(s, op)(right) if s is not None and right is not None else None - for s in left - ] + with compat.ignore_shapely2_warnings(): + data[:] = [ + getattr(s, op)(right) if s is not None and right is not None else None + for s in left + ] return data elif isinstance(right, np.ndarray): if len(left) != len(right): @@ -292,12 +300,13 @@ def _binary_geo(op, left, right): ) raise ValueError(msg) data = np.empty(len(left), dtype=object) - data[:] = [ - getattr(this_elem, op)(other_elem) - if this_elem is not None and other_elem is not None - else None - for this_elem, other_elem in zip(left, right) - ] + with compat.ignore_shapely2_warnings(): + data[:] = [ + getattr(this_elem, op)(other_elem) + if this_elem is not None and other_elem is not None + else None + for this_elem, other_elem in zip(left, right) + ] return data else: raise TypeError("Type not known: {0} vs {1}".format(type(left), type(right))) @@ -431,7 +440,8 @@ def _affinity_method(op, left, *args, **kwargs): res = getattr(shapely.affinity, op)(geom, *args, **kwargs) out.append(res) data = np.empty(len(left), dtype=object) - data[:] = out + with compat.ignore_shapely2_warnings(): + data[:] = out return from_shapely(data) @@ -474,23 +484,28 @@ def is_simple(data): def is_ring(data): - if compat.USE_PYGEOS: - return pygeos.is_ring(pygeos.get_exterior_ring(data)) - else: - # operates on the exterior, so can't use _unary_op() - # XXX needed to change this because there is now a geometry collection - # in the shapely ones that was something else before? - return np.array( - [ - geom.exterior.is_ring - if geom is not None - and hasattr(geom, "exterior") - and geom.exterior is not None - else False - for geom in data - ], - dtype=bool, + if "Polygon" in geom_type(data): + warnings.warn( + "is_ring currently returns True for Polygons, which is not correct. " + "This will be corrected to False in a future release.", + FutureWarning, + stacklevel=3, ) + if compat.USE_PYGEOS: + return pygeos.is_ring(data) | pygeos.is_ring(pygeos.get_exterior_ring(data)) + else: + # for polygons operates on the exterior, so can't use _unary_op() + results = [] + for geom in data: + if geom is None: + results.append(False) + elif geom.type == "Polygon": + results.append(geom.exterior.is_ring) + elif geom.type in ["LineString", "LinearRing"]: + results.append(geom.is_ring) + else: + results.append(False) + return np.array(results, dtype=bool) def is_closed(data): @@ -539,7 +554,8 @@ def _unary_geo(op, left, *args, **kwargs): """Unary operation that returns new geometries""" # ensure 1D output, see note above data = np.empty(len(left), dtype=object) - data[:] = [getattr(geom, op, None) for geom in left] + with compat.ignore_shapely2_warnings(): + data[:] = [getattr(geom, op, None) for geom in left] return data @@ -597,7 +613,8 @@ def interiors(data): "geometry types, None is returned." ) data = np.empty(len(data), dtype=object) - data[:] = inner_rings + with compat.ignore_shapely2_warnings(): + data[:] = inner_rings return data @@ -607,9 +624,11 @@ def representative_point(data): else: # method and not a property -> can't use _unary_geo out = np.empty(len(data), dtype=object) - out[:] = [ - geom.representative_point() if geom is not None else None for geom in data - ] + with compat.ignore_shapely2_warnings(): + out[:] = [ + geom.representative_point() if geom is not None else None + for geom in data + ] return out @@ -761,22 +780,31 @@ def buffer(data, distance, resolution=16, **kwargs): "length of the GeoSeries" ) - out[:] = [ - geom.buffer(dist, resolution, **kwargs) if geom is not None else None - for geom, dist in zip(data, distance) - ] + with compat.ignore_shapely2_warnings(): + out[:] = [ + geom.buffer(dist, resolution, **kwargs) + if geom is not None + else None + for geom, dist in zip(data, distance) + ] return out - out[:] = [ - geom.buffer(distance, resolution, **kwargs) if geom is not None else None - for geom in data - ] + with compat.ignore_shapely2_warnings(): + out[:] = [ + geom.buffer(distance, resolution, **kwargs) + if geom is not None + else None + for geom in data + ] return out def interpolate(data, distance, normalized=False): if compat.USE_PYGEOS: - return pygeos.line_interpolate_point(data, distance, normalize=normalized) + try: + return pygeos.line_interpolate_point(data, distance, normalized=normalized) + except TypeError: # support for pygeos<0.9 + return pygeos.line_interpolate_point(data, distance, normalize=normalized) else: out = np.empty(len(data), dtype=object) if isinstance(distance, np.ndarray): @@ -785,13 +813,17 @@ def interpolate(data, distance, normalized=False): "Length of distance sequence does not match " "length of the GeoSeries" ) - out[:] = [ - geom.interpolate(dist, normalized=normalized) - for geom, dist in zip(data, distance) - ] + with compat.ignore_shapely2_warnings(): + out[:] = [ + geom.interpolate(dist, normalized=normalized) + for geom, dist in zip(data, distance) + ] return out - out[:] = [geom.interpolate(distance, normalized=normalized) for geom in data] + with compat.ignore_shapely2_warnings(): + out[:] = [ + geom.interpolate(distance, normalized=normalized) for geom in data + ] return out @@ -802,16 +834,48 @@ def simplify(data, tolerance, preserve_topology=True): else: # method and not a property -> can't use _unary_geo out = np.empty(len(data), dtype=object) - out[:] = [ - geom.simplify(tolerance, preserve_topology=preserve_topology) - for geom in data - ] + with compat.ignore_shapely2_warnings(): + out[:] = [ + geom.simplify(tolerance, preserve_topology=preserve_topology) + for geom in data + ] + return out + + +def _shapely_normalize(geom): + """ + Small helper function for now because it is not yet available in Shapely. + """ + from shapely.geos import lgeos + from shapely.geometry.base import geom_factory + from ctypes import c_void_p, c_int + + lgeos._lgeos.GEOSNormalize_r.restype = c_int + lgeos._lgeos.GEOSNormalize_r.argtypes = [c_void_p, c_void_p] + + geom_cloned = lgeos.GEOSGeom_clone(geom._geom) + lgeos._lgeos.GEOSNormalize_r(lgeos.geos_handle, geom_cloned) + return geom_factory(geom_cloned) + + +def normalize(data): + if compat.USE_PYGEOS: + return pygeos.normalize(data) + else: + out = np.empty(len(data), dtype=object) + with compat.ignore_shapely2_warnings(): + out[:] = [ + _shapely_normalize(geom) if geom is not None else None for geom in data + ] return out def project(data, other, normalized=False): if compat.USE_PYGEOS: - return pygeos.line_locate_point(data, other, normalize=normalized) + try: + return pygeos.line_locate_point(data, other, normalized=normalized) + except TypeError: # support for pygeos<0.9 + return pygeos.line_locate_point(data, other, normalize=normalized) else: return _binary_op("project", data, other, normalized=normalized) @@ -827,7 +891,11 @@ def unary_union(data): if compat.USE_PYGEOS: return _pygeos_to_shapely(pygeos.union_all(data)) else: - return shapely.ops.unary_union(data) + data = [g for g in data if g is not None] + if data: + return shapely.ops.unary_union(data) + else: + return None # @@ -849,6 +917,14 @@ def get_y(data): return _unary_op("y", data, null_value=np.nan) +def get_z(data): + if compat.USE_PYGEOS: + return pygeos.get_z(data) + else: + data = [geom.z if geom.has_z else np.nan for geom in data] + return np.array(data, dtype=np.dtype(float)) + + def bounds(data): if compat.USE_PYGEOS: return pygeos.bounds(data) @@ -886,6 +962,9 @@ def transform(data, func): result = np.empty(n, dtype=object) for i in range(n): geom = data[i] - result[i] = transform(func, geom) + if isna(geom): + result[i] = geom + else: + result[i] = transform(func, geom) return result diff --git a/geopandas/_version.py b/geopandas/_version.py index 6514cbd..9596c7f 100644 --- a/geopandas/_version.py +++ b/geopandas/_version.py @@ -5,7 +5,7 @@ # that just contains the computed version number. # This file is released into the public domain. Generated by -# versioneer-0.16 (https://github.com/warner/python-versioneer) +# versioneer-0.21 (https://github.com/python-versioneer/python-versioneer) """Git implementation of _version.py.""" @@ -14,6 +14,7 @@ import os import re import subprocess import sys +from typing import Callable, Dict def get_keywords(): @@ -24,7 +25,8 @@ def get_keywords(): # get_keywords(). git_refnames = "$Format:%d$" git_full = "$Format:%H$" - keywords = {"refnames": git_refnames, "full": git_full} + git_date = "$Format:%ci$" + keywords = {"refnames": git_refnames, "full": git_full, "date": git_date} return keywords @@ -50,12 +52,12 @@ class NotThisMethod(Exception): """Exception raised if a method is not valid for the current scenario.""" -LONG_VERSION_PY = {} -HANDLERS = {} +LONG_VERSION_PY: Dict[str, str] = {} +HANDLERS: Dict[str, Dict[str, Callable]] = {} def register_vcs_handler(vcs, method): # decorator - """Decorator to mark a method as the handler for a particular VCS.""" + """Create decorator to mark a method as the handler of a VCS.""" def decorate(f): """Store f in HANDLERS[vcs][method].""" @@ -67,63 +69,71 @@ def register_vcs_handler(vcs, method): # decorator return decorate -def run_command(commands, args, cwd=None, verbose=False, hide_stderr=False): +def run_command(commands, args, cwd=None, verbose=False, hide_stderr=False, env=None): """Call the given command(s).""" assert isinstance(commands, list) - p = None - for c in commands: + process = None + for command in commands: try: - dispcmd = str([c] + args) + dispcmd = str([command] + args) # remember shell=False, so use git.cmd on windows, not just git - p = subprocess.Popen( - [c] + args, + process = subprocess.Popen( + [command] + args, cwd=cwd, + env=env, stdout=subprocess.PIPE, stderr=(subprocess.PIPE if hide_stderr else None), ) break - except EnvironmentError: + except OSError: e = sys.exc_info()[1] if e.errno == errno.ENOENT: continue if verbose: print("unable to run %s" % dispcmd) print(e) - return None + return None, None else: if verbose: print("unable to find command, tried %s" % (commands,)) - return None - stdout = p.communicate()[0].strip() - if sys.version_info[0] >= 3: - stdout = stdout.decode() - if p.returncode != 0: + return None, None + stdout = process.communicate()[0].strip().decode() + if process.returncode != 0: if verbose: print("unable to run %s (error)" % dispcmd) - return None - return stdout + print("stdout was %s" % stdout) + return None, process.returncode + return stdout, process.returncode def versions_from_parentdir(parentdir_prefix, root, verbose): """Try to determine the version from the parent directory name. - Source tarballs conventionally unpack into a directory that includes - both the project name and a version string. + Source tarballs conventionally unpack into a directory that includes both + the project name and a version string. We will also support searching up + two directory levels for an appropriately named parent directory """ - dirname = os.path.basename(root) - if not dirname.startswith(parentdir_prefix): - if verbose: - print( - "guessing rootdir is '%s', but '%s' doesn't start with " - "prefix '%s'" % (root, dirname, parentdir_prefix) - ) - raise NotThisMethod("rootdir doesn't start with parentdir_prefix") - return { - "version": dirname[len(parentdir_prefix) :], - "full-revisionid": None, - "dirty": False, - "error": None, - } + rootdirs = [] + + for _ in range(3): + dirname = os.path.basename(root) + if dirname.startswith(parentdir_prefix): + return { + "version": dirname[len(parentdir_prefix) :], + "full-revisionid": None, + "dirty": False, + "error": None, + "date": None, + } + rootdirs.append(root) + root = os.path.dirname(root) # up a level + + if verbose: + print( + "Tried directories %s but none started with prefix %s" + % (str(rootdirs), parentdir_prefix) + ) + raise NotThisMethod("rootdir doesn't start with parentdir_prefix") @register_vcs_handler("git", "get_keywords") @@ -135,18 +145,21 @@ def git_get_keywords(versionfile_abs): # _version.py. keywords = {} try: - f = open(versionfile_abs, "r") - for line in f.readlines(): - if line.strip().startswith("git_refnames ="): - mo = re.search(r'=\s*"(.*)"', line) - if mo: - keywords["refnames"] = mo.group(1) - if line.strip().startswith("git_full ="): - mo = re.search(r'=\s*"(.*)"', line) - if mo: - keywords["full"] = mo.group(1) - f.close() - except EnvironmentError: + with open(versionfile_abs, "r") as fobj: + for line in fobj: + if line.strip().startswith("git_refnames ="): + mo = re.search(r'=\s*"(.*)"', line) + if mo: + keywords["refnames"] = mo.group(1) + if line.strip().startswith("git_full ="): + mo = re.search(r'=\s*"(.*)"', line) + if mo: + keywords["full"] = mo.group(1) + if line.strip().startswith("git_date ="): + mo = re.search(r'=\s*"(.*)"', line) + if mo: + keywords["date"] = mo.group(1) + except OSError: pass return keywords @@ -154,18 +167,31 @@ def git_get_keywords(versionfile_abs): @register_vcs_handler("git", "keywords") def git_versions_from_keywords(keywords, tag_prefix, verbose): """Get version information from git keywords.""" - if not keywords: - raise NotThisMethod("no keywords at all, weird") + if "refnames" not in keywords: + raise NotThisMethod("Short version file found") + date = keywords.get("date") + if date is not None: + # Use only the last line. Previous lines may contain GPG signature + # information. + date = date.splitlines()[-1] + + # git-2.2.0 added "%cI", which expands to an ISO-8601 -compliant + # datestamp. However we prefer "%ci" (which expands to an "ISO-8601 + # -like" string, which we must then edit to make compliant), because + # it's been around since git-1.5.3, and it's too difficult to + # discover which version we're using, or to work around using an + # older one. + date = date.strip().replace(" ", "T", 1).replace(" ", "", 1) refnames = keywords["refnames"].strip() if refnames.startswith("$Format"): if verbose: print("keywords are unexpanded, not using") raise NotThisMethod("unexpanded keywords, not a git-archive tarball") - refs = set([r.strip() for r in refnames.strip("()").split(",")]) + refs = {r.strip() for r in refnames.strip("()").split(",")} # starting in git-1.8.3, tags are listed as "tag: foo-1.0" instead of # just "foo-1.0". If we see a "tag: " prefix, prefer those. TAG = "tag: " - tags = set([r[len(TAG) :] for r in refs if r.startswith(TAG)]) + tags = {r[len(TAG) :] for r in refs if r.startswith(TAG)} if not tags: # Either we're using git < 1.8.3, or there really are no tags. We use # a heuristic: assume all version tags have a digit. The old git %d @@ -174,7 +200,7 @@ def git_versions_from_keywords(keywords, tag_prefix, verbose): # between branches and tags. By ignoring refnames without digits, we # filter out many common branch names like "release" and # "stabilization", as well as "HEAD" and "master". - tags = set([r for r in refs if re.search(r"\d", r)]) + tags = {r for r in refs if re.search(r"\d", r)} if verbose: print("discarding '%s', no digits" % ",".join(refs - tags)) if verbose: @@ -183,6 +209,11 @@ def git_versions_from_keywords(keywords, tag_prefix, verbose): # sorting will prefer e.g. "2.0" over "2.0rc1" if ref.startswith(tag_prefix): r = ref[len(tag_prefix) :] + # Filter out refs that exactly match prefix or that don't start + # with a number once the prefix is stripped (mostly a concern + # when prefix is '') + if not re.match(r"\d", r): + continue if verbose: print("picking %s" % r) return { @@ -190,6 +221,7 @@ def git_versions_from_keywords(keywords, tag_prefix, verbose): "full-revisionid": keywords["full"].strip(), "dirty": False, "error": None, + "date": date, } # no suitable tags, so version is "0+unknown", but full hex is still there if verbose: @@ -199,28 +231,33 @@ def git_versions_from_keywords(keywords, tag_prefix, verbose): "full-revisionid": keywords["full"].strip(), "dirty": False, "error": "no suitable tags", + "date": None, } @register_vcs_handler("git", "pieces_from_vcs") -def git_pieces_from_vcs(tag_prefix, root, verbose, run_command=run_command): +def git_pieces_from_vcs(tag_prefix, root, verbose, runner=run_command): """Get version from 'git describe' in the root of the source tree. This only gets called if the git-archive 'subst' keywords were *not* expanded, and _version.py hasn't already been rewritten with a short version string, meaning we're inside a checked out source tree. """ - if not os.path.exists(os.path.join(root, ".git")): - if verbose: - print("no .git in %s" % root) - raise NotThisMethod("no .git directory") - GITS = ["git"] + TAG_PREFIX_REGEX = "*" if sys.platform == "win32": GITS = ["git.cmd", "git.exe"] + TAG_PREFIX_REGEX = r"\*" + + _, rc = runner(GITS, ["rev-parse", "--git-dir"], cwd=root, hide_stderr=True) + if rc != 0: + if verbose: + print("Directory %s not under git control" % root) + raise NotThisMethod("'git rev-parse --git-dir' returned error") + # if there is a tag matching tag_prefix, this yields TAG-NUM-gHEX[-dirty] # if there isn't one, this yields HEX[-dirty] (no NUM) - describe_out = run_command( + describe_out, rc = runner( GITS, [ "describe", @@ -229,7 +266,7 @@ def git_pieces_from_vcs(tag_prefix, root, verbose, run_command=run_command): "--always", "--long", "--match", - "%s*" % tag_prefix, + "%s%s" % (tag_prefix, TAG_PREFIX_REGEX), ], cwd=root, ) @@ -237,7 +274,7 @@ def git_pieces_from_vcs(tag_prefix, root, verbose, run_command=run_command): if describe_out is None: raise NotThisMethod("'git describe' failed") describe_out = describe_out.strip() - full_out = run_command(GITS, ["rev-parse", "HEAD"], cwd=root) + full_out, rc = runner(GITS, ["rev-parse", "HEAD"], cwd=root) if full_out is None: raise NotThisMethod("'git rev-parse' failed") full_out = full_out.strip() @@ -247,6 +284,38 @@ def git_pieces_from_vcs(tag_prefix, root, verbose, run_command=run_command): pieces["short"] = full_out[:7] # maybe improved later pieces["error"] = None + branch_name, rc = runner(GITS, ["rev-parse", "--abbrev-ref", "HEAD"], cwd=root) + # --abbrev-ref was added in git-1.6.3 + if rc != 0 or branch_name is None: + raise NotThisMethod("'git rev-parse --abbrev-ref' returned error") + branch_name = branch_name.strip() + + if branch_name == "HEAD": + # If we aren't exactly on a branch, pick a branch which represents + # the current commit. If all else fails, we are on a branchless + # commit. + branches, rc = runner(GITS, ["branch", "--contains"], cwd=root) + # --contains was added in git-1.5.4 + if rc != 0 or branches is None: + raise NotThisMethod("'git branch --contains' returned error") + branches = branches.split("\n") + + # Remove the first line if we're running detached + if "(" in branches[0]: + branches.pop(0) + + # Strip off the leading "* " from the list of branches. + branches = [branch[2:] for branch in branches] + if "master" in branches: + branch_name = "master" + elif not branches: + branch_name = None + else: + # Pick the first branch that is returned. Good or bad. + branch_name = branches[0] + + pieces["branch"] = branch_name + # parse describe_out. It will be like TAG-NUM-gHEX[-dirty] or HEX[-dirty] # TAG might have hyphens. git_describe = describe_out @@ -263,7 +332,7 @@ def git_pieces_from_vcs(tag_prefix, root, verbose, run_command=run_command): # TAG-NUM-gHEX mo = re.search(r"^(.+)-(\d+)-g([0-9a-f]+)$", git_describe) if not mo: - # unparseable. Maybe git-describe is misbehaving? + # unparsable. Maybe git-describe is misbehaving? pieces["error"] = "unable to parse git-describe output: '%s'" % describe_out return pieces @@ -289,9 +358,16 @@ def git_pieces_from_vcs(tag_prefix, root, verbose, run_command=run_command): else: # HEX: no tags pieces["closest-tag"] = None - count_out = run_command(GITS, ["rev-list", "HEAD", "--count"], cwd=root) + count_out, rc = runner(GITS, ["rev-list", "HEAD", "--count"], cwd=root) pieces["distance"] = int(count_out) # total number of commits + # commit date: see ISO-8601 comment in git_versions_from_keywords() + date = runner(GITS, ["show", "-s", "--format=%ci", "HEAD"], cwd=root)[0].strip() + # Use only the last line. Previous lines may contain GPG signature + # information. + date = date.splitlines()[-1] + pieces["date"] = date.strip().replace(" ", "T", 1).replace(" ", "", 1) + return pieces @@ -326,19 +402,66 @@ def render_pep440(pieces): return rendered -def render_pep440_pre(pieces): - """TAG[.post.devDISTANCE] -- No -dirty. +def render_pep440_branch(pieces): + """TAG[[.dev0]+DISTANCE.gHEX[.dirty]] . + + The ".dev0" means not master branch. Note that .dev0 sorts backwards + (a feature branch will appear "older" than the master branch). Exceptions: - 1: no tags. 0.post.devDISTANCE + 1: no tags. 0[.dev0]+untagged.DISTANCE.gHEX[.dirty] """ if pieces["closest-tag"]: rendered = pieces["closest-tag"] - if pieces["distance"]: - rendered += ".post.dev%d" % pieces["distance"] + if pieces["distance"] or pieces["dirty"]: + if pieces["branch"] != "master": + rendered += ".dev0" + rendered += plus_or_dot(pieces) + rendered += "%d.g%s" % (pieces["distance"], pieces["short"]) + if pieces["dirty"]: + rendered += ".dirty" else: # exception #1 - rendered = "0.post.dev%d" % pieces["distance"] + rendered = "0" + if pieces["branch"] != "master": + rendered += ".dev0" + rendered += "+untagged.%d.g%s" % (pieces["distance"], pieces["short"]) + if pieces["dirty"]: + rendered += ".dirty" + return rendered + + +def pep440_split_post(ver): + """Split pep440 version string at the post-release segment. + + Returns the release segments before the post-release and the + post-release version number (or -1 if no post-release segment is present). + """ + vc = str.split(ver, ".post") + return vc[0], int(vc[1] or 0) if len(vc) == 2 else None + + +def render_pep440_pre(pieces): + """TAG[.postN.devDISTANCE] -- No -dirty. + + Exceptions: + 1: no tags. 0.post0.devDISTANCE + """ + if pieces["closest-tag"]: + if pieces["distance"]: + # update the post release segment + tag_version, post_version = pep440_split_post(pieces["closest-tag"]) + rendered = tag_version + if post_version is not None: + rendered += ".post%d.dev%d" % (post_version + 1, pieces["distance"]) + else: + rendered += ".post0.dev%d" % (pieces["distance"]) + else: + # no commits, use the tag as the version + rendered = pieces["closest-tag"] + else: + # exception #1 + rendered = "0.post0.dev%d" % pieces["distance"] return rendered @@ -369,6 +492,35 @@ def render_pep440_post(pieces): return rendered +def render_pep440_post_branch(pieces): + """TAG[.postDISTANCE[.dev0]+gHEX[.dirty]] . + + The ".dev0" means not master branch. + + Exceptions: + 1: no tags. 0.postDISTANCE[.dev0]+gHEX[.dirty] + """ + if pieces["closest-tag"]: + rendered = pieces["closest-tag"] + if pieces["distance"] or pieces["dirty"]: + rendered += ".post%d" % pieces["distance"] + if pieces["branch"] != "master": + rendered += ".dev0" + rendered += plus_or_dot(pieces) + rendered += "g%s" % pieces["short"] + if pieces["dirty"]: + rendered += ".dirty" + else: + # exception #1 + rendered = "0.post%d" % pieces["distance"] + if pieces["branch"] != "master": + rendered += ".dev0" + rendered += "+g%s" % pieces["short"] + if pieces["dirty"]: + rendered += ".dirty" + return rendered + + def render_pep440_old(pieces): """TAG[.postDISTANCE[.dev0]] . @@ -439,6 +591,7 @@ def render(pieces, style): "full-revisionid": pieces.get("long"), "dirty": None, "error": pieces["error"], + "date": None, } if not style or style == "default": @@ -446,10 +599,14 @@ def render(pieces, style): if style == "pep440": rendered = render_pep440(pieces) + elif style == "pep440-branch": + rendered = render_pep440_branch(pieces) elif style == "pep440-pre": rendered = render_pep440_pre(pieces) elif style == "pep440-post": rendered = render_pep440_post(pieces) + elif style == "pep440-post-branch": + rendered = render_pep440_post_branch(pieces) elif style == "pep440-old": rendered = render_pep440_old(pieces) elif style == "git-describe": @@ -464,6 +621,7 @@ def render(pieces, style): "full-revisionid": pieces["long"], "dirty": pieces["dirty"], "error": None, + "date": pieces.get("date"), } @@ -487,7 +645,7 @@ def get_versions(): # versionfile_source is the relative path from the top of the source # tree (where the .git directory might live) to this file. Invert # this to find the root from __file__. - for i in cfg.versionfile_source.split("/"): + for _ in cfg.versionfile_source.split("/"): root = os.path.dirname(root) except NameError: return { @@ -495,6 +653,7 @@ def get_versions(): "full-revisionid": None, "dirty": None, "error": "unable to find root of source tree", + "date": None, } try: @@ -514,4 +673,5 @@ def get_versions(): "full-revisionid": None, "dirty": None, "error": "unable to compute version", + "date": None, } diff --git a/geopandas/array.py b/geopandas/array.py index 75c44e8..553fb69 100644 --- a/geopandas/array.py +++ b/geopandas/array.py @@ -6,7 +6,11 @@ import inspect import numpy as np import pandas as pd -from pandas.api.extensions import ExtensionArray, ExtensionDtype +from pandas.api.extensions import ( + ExtensionArray, + ExtensionDtype, + register_extension_dtype, +) import shapely import shapely.affinity @@ -14,7 +18,7 @@ import shapely.geometry from shapely.geometry.base import BaseGeometry import shapely.ops import shapely.wkt -from pyproj import CRS +from pyproj import CRS, Transformer try: import pygeos @@ -23,6 +27,7 @@ except ImportError: from . import _compat as compat from . import _vectorized as vectorized +from .sindex import _get_sindex_class class GeometryDtype(ExtensionDtype): @@ -48,27 +53,7 @@ class GeometryDtype(ExtensionDtype): return GeometryArray -if compat.PANDAS_GE_024: - from pandas.api.extensions import register_extension_dtype - - register_extension_dtype(GeometryDtype) - - -def _isna(value): - """ - Check if scalar value is NA-like (None, np.nan or pd.NA). - - Custom version that only works for scalars (returning True or False), - as `pd.isna` also works for array-like input returning a boolean array. - """ - if value is None: - return True - elif isinstance(value, float) and np.isnan(value): - return True - elif compat.PANDAS_GE_10 and value is pd.NA: - return True - else: - return False +register_extension_dtype(GeometryDtype) def _check_crs(left, right, allow_none=False): @@ -142,7 +127,7 @@ def _shapely_to_geom(geom): def _is_scalar_geometry(geom): if compat.USE_PYGEOS: - return isinstance(geom, pygeos.Geometry) + return isinstance(geom, (pygeos.Geometry, BaseGeometry)) else: return isinstance(geom, BaseGeometry) @@ -192,13 +177,13 @@ def from_wkb(data, crs=None): return GeometryArray(vectorized.from_wkb(data), crs=crs) -def to_wkb(geoms, hex=False): +def to_wkb(geoms, hex=False, **kwargs): """ Convert GeometryArray to a numpy object array of WKB objects. """ if not isinstance(geoms, GeometryArray): raise ValueError("'geoms' must be a GeometryArray") - return vectorized.to_wkb(geoms.data, hex=hex) + return vectorized.to_wkb(geoms.data, hex=hex, **kwargs) def from_wkt(data, crs=None): @@ -231,6 +216,9 @@ def points_from_xy(x, y, z=None, crs=None): """ Generate GeometryArray of shapely Point geometries from x, y(, z) coordinates. + In case of geographic coordinates, it is assumed that longitude is captured by + ``x`` coordinates and latitude by ``y``. + Parameters ---------- x, y, z : iterable @@ -241,10 +229,27 @@ def points_from_xy(x, y, z=None, crs=None): Examples -------- + >>> import pandas as pd + >>> df = pd.DataFrame({'x': [0, 1, 2], 'y': [0, 1, 2], 'z': [0, 1, 2]}) + >>> df + x y z + 0 0 0 0 + 1 1 1 1 + 2 2 2 2 >>> geometry = geopandas.points_from_xy(x=[1, 0], y=[0, 1]) >>> geometry = geopandas.points_from_xy(df['x'], df['y'], df['z']) >>> gdf = geopandas.GeoDataFrame( - df, geometry=geopandas.points_from_xy(df['x'], df['y'])) + ... df, geometry=geopandas.points_from_xy(df['x'], df['y'])) + + Having geographic coordinates: + + >>> df = pd.DataFrame({'longitude': [-140, 0, 123], 'latitude': [-65, 1, 48]}) + >>> df + longitude latitude + 0 -140 -65 + 1 0 1 + 2 123 48 + >>> geometry = geopandas.points_from_xy(df.longitude, df.latitude, crs="EPSG:4326") Returns ------- @@ -279,6 +284,37 @@ class GeometryArray(ExtensionArray): self._crs = None self.crs = crs + self._sindex = None + + @property + def sindex(self): + if self._sindex is None: + self._sindex = _get_sindex_class()(self.data) + return self._sindex + + @property + def has_sindex(self): + """Check the existence of the spatial index without generating it. + + Use the `.sindex` attribute on a GeoDataFrame or GeoSeries + to generate a spatial index if it does not yet exist, + which may take considerable time based on the underlying index + implementation. + + Note that the underlying spatial index may not be fully + initialized until the first use. + + See Also + --------- + GeoDataFrame.has_sindex + + Returns + ------- + bool + `True` if the spatial index has been generated or + `False` if not. + """ + return self._sindex is not None @property def crs(self): @@ -327,10 +363,12 @@ class GeometryArray(ExtensionArray): # for pandas >= 1.0, validate and convert IntegerArray/BooleanArray # to numpy array, pass-through non-array-like indexers idx = pd.api.indexers.check_array_indexer(self, idx) - if isinstance(idx, (Iterable, slice)): return GeometryArray(self.data[idx], crs=self.crs) else: - raise TypeError("Index type not supported", idx) + if isinstance(idx, (Iterable, slice)): + return GeometryArray(self.data[idx], crs=self.crs) + else: + raise TypeError("Index type not supported", idx) def __setitem__(self, key, value): if compat.PANDAS_GE_10: @@ -345,8 +383,8 @@ class GeometryArray(ExtensionArray): if isinstance(key, numbers.Integral): raise ValueError("cannot set a single element with an array") self.data[key] = value.data - elif isinstance(value, BaseGeometry) or _isna(value): - if _isna(value): + elif isinstance(value, BaseGeometry) or vectorized.isna(value): + if vectorized.isna(value): # internally only use None as missing value indicator # but accept others value = None @@ -356,7 +394,8 @@ class GeometryArray(ExtensionArray): raise TypeError("should be valid geometry") if isinstance(key, (slice, list, np.ndarray)): value_array = np.empty(1, dtype=object) - value_array[:] = [value] + with compat.ignore_shapely2_warnings(): + value_array[:] = [value] self.data[key] = value_array else: self.data[key] = value @@ -365,6 +404,9 @@ class GeometryArray(ExtensionArray): "Value should be either a BaseGeometry or None, got %s" % str(value) ) + # invalidate spatial index + self._sindex = None + # TODO: use this once pandas-dev/pandas#33457 is fixed # if hasattr(value, "crs"): # if value.crs and (value.crs != self.crs): @@ -373,16 +415,26 @@ class GeometryArray(ExtensionArray): # "and CRS of existing geometries." # ) - if compat.USE_PYGEOS: - - def __getstate__(self): + def __getstate__(self): + if compat.USE_PYGEOS: return (pygeos.to_wkb(self.data), self._crs) + else: + return self.__dict__ - def __setstate__(self, state): - geoms = pygeos.from_wkb(state[0]) + def __setstate__(self, state): + if not isinstance(state, dict): + # pickle file saved with pygeos + geoms = vectorized.from_wkb(state[0]) self._crs = state[1] + self._sindex = None # pygeos.STRtree could not be pickled yet self.data = geoms self.base = None + else: + if compat.USE_PYGEOS: + state["data"] = vectorized.from_shapely(state["data"]) + if "_crs" not in state: + state["_crs"] = None + self.__dict__.update(state) # ------------------------------------------------------------------------- # Geometry related methods @@ -514,24 +566,6 @@ class GeometryArray(ExtensionArray): return self.geom_equals_exact(other, 0.5 * 10 ** (-decimal)) # return _binary_predicate("almost_equals", self, other, decimal=decimal) - def equals_exact(self, other, tolerance): - warnings.warn( - "GeometryArray.equals_exact() is now GeometryArray.geom_equals_exact(). " - "GeometryArray.equals_exact() will be deprecated in the future.", - FutureWarning, - stacklevel=2, - ) - return self._binary_method("equals_exact", self, other, tolerance=tolerance) - - def almost_equals(self, other, decimal): - warnings.warn( - "GeometryArray.almost_equals() is now GeometryArray.geom_almost_equals(). " - "GeometryArray.almost_equals() will be deprecated in the future.", - FutureWarning, - stacklevel=2, - ) - return self.geom_equals_exact(other, 0.5 * 10 ** (-decimal)) - # # Binary operations that return new geometries # @@ -644,6 +678,187 @@ class GeometryArray(ExtensionArray): crs=self.crs, ) + def to_crs(self, crs=None, epsg=None): + """Returns a ``GeometryArray`` with all geometries transformed to a new + coordinate reference system. + + Transform all geometries in a GeometryArray to a different coordinate + reference system. The ``crs`` attribute on the current GeometryArray must + be set. Either ``crs`` or ``epsg`` may be specified for output. + + This method will transform all points in all objects. It has no notion + or projecting entire geometries. All segments joining points are + assumed to be lines in the current projection, not geodesics. Objects + crossing the dateline (or other projection boundary) will have + undesirable behavior. + + Parameters + ---------- + crs : pyproj.CRS, optional if `epsg` is specified + The value can be anything accepted + by :meth:`pyproj.CRS.from_user_input() `, + such as an authority string (eg "EPSG:4326") or a WKT string. + epsg : int, optional if `crs` is specified + EPSG code specifying output projection. + + Returns + ------- + GeometryArray + + Examples + -------- + >>> from shapely.geometry import Point + >>> from geopandas.array import from_shapely, to_wkt + >>> a = from_shapely([Point(1, 1), Point(2, 2), Point(3, 3)], crs=4326) + >>> to_wkt(a) + array(['POINT (1 1)', 'POINT (2 2)', 'POINT (3 3)'], dtype=object) + >>> a.crs # doctest: +SKIP + + Name: WGS 84 + Axis Info [ellipsoidal]: + - Lat[north]: Geodetic latitude (degree) + - Lon[east]: Geodetic longitude (degree) + Area of Use: + - name: World + - bounds: (-180.0, -90.0, 180.0, 90.0) + Datum: World Geodetic System 1984 + - Ellipsoid: WGS 84 + - Prime Meridian: Greenwich + + >>> a = a.to_crs(3857) + >>> to_wkt(a) + array(['POINT (111319.490793 111325.142866)', + 'POINT (222638.981587 222684.208506)', + 'POINT (333958.47238 334111.171402)'], dtype=object) + >>> a.crs # doctest: +SKIP + + Name: WGS 84 / Pseudo-Mercator + Axis Info [cartesian]: + - X[east]: Easting (metre) + - Y[north]: Northing (metre) + Area of Use: + - name: World - 85°S to 85°N + - bounds: (-180.0, -85.06, 180.0, 85.06) + Coordinate Operation: + - name: Popular Visualisation Pseudo-Mercator + - method: Popular Visualisation Pseudo Mercator + Datum: World Geodetic System 1984 + - Ellipsoid: WGS 84 + - Prime Meridian: Greenwich + + """ + if self.crs is None: + raise ValueError( + "Cannot transform naive geometries. " + "Please set a crs on the object first." + ) + if crs is not None: + crs = CRS.from_user_input(crs) + elif epsg is not None: + crs = CRS.from_epsg(epsg) + else: + raise ValueError("Must pass either crs or epsg.") + + # skip if the input CRS and output CRS are the exact same + if self.crs.is_exact_same(crs): + return self + + transformer = Transformer.from_crs(self.crs, crs, always_xy=True) + + new_data = vectorized.transform(self.data, transformer.transform) + return GeometryArray(new_data, crs=crs) + + def estimate_utm_crs(self, datum_name="WGS 84"): + """Returns the estimated UTM CRS based on the bounds of the dataset. + + .. versionadded:: 0.9 + + .. note:: Requires pyproj 3+ + + Parameters + ---------- + datum_name : str, optional + The name of the datum to use in the query. Default is WGS 84. + + Returns + ------- + pyproj.CRS + + Examples + -------- + >>> world = geopandas.read_file( + ... geopandas.datasets.get_path("naturalearth_lowres") + ... ) + >>> germany = world.loc[world.name == "Germany"] + >>> germany.geometry.values.estimate_utm_crs() # doctest: +SKIP + + Name: WGS 84 / UTM zone 32N + Axis Info [cartesian]: + - E[east]: Easting (metre) + - N[north]: Northing (metre) + Area of Use: + - name: World - N hemisphere - 6°E to 12°E - by country + - bounds: (6.0, 0.0, 12.0, 84.0) + Coordinate Operation: + - name: UTM zone 32N + - method: Transverse Mercator + Datum: World Geodetic System 1984 + - Ellipsoid: WGS 84 + - Prime Meridian: Greenwich + """ + try: + from pyproj.aoi import AreaOfInterest + from pyproj.database import query_utm_crs_info + except ImportError: + raise RuntimeError("pyproj 3+ required for estimate_utm_crs.") + + if not self.crs: + raise RuntimeError("crs must be set to estimate UTM CRS.") + + minx, miny, maxx, maxy = self.total_bounds + if self.crs.is_geographic: + x_center = np.mean([minx, maxx]) + y_center = np.mean([miny, maxy]) + # ensure using geographic coordinates + else: + transformer = Transformer.from_crs(self.crs, "EPSG:4326", always_xy=True) + if compat.PYPROJ_GE_31: + minx, miny, maxx, maxy = transformer.transform_bounds( + minx, miny, maxx, maxy + ) + y_center = np.mean([miny, maxy]) + # crossed the antimeridian + if minx > maxx: + # shift maxx from [-180,180] to [0,360] + # so both numbers are positive for center calculation + # Example: -175 to 185 + maxx += 360 + x_center = np.mean([minx, maxx]) + # shift back to [-180,180] + x_center = ((x_center + 180) % 360) - 180 + else: + x_center = np.mean([minx, maxx]) + else: + lon, lat = transformer.transform( + (minx, maxx, minx, maxx), (miny, miny, maxy, maxy) + ) + x_center = np.mean(lon) + y_center = np.mean(lat) + + utm_crs_list = query_utm_crs_info( + datum_name=datum_name, + area_of_interest=AreaOfInterest( + west_lon_degree=x_center, + south_lat_degree=y_center, + east_lon_degree=x_center, + north_lat_degree=y_center, + ), + ) + try: + return CRS.from_epsg(utm_crs_list[0].code) + except IndexError: + raise RuntimeError("Unable to determine UTM CRS") + # # Coordinate related properties # @@ -652,7 +867,14 @@ class GeometryArray(ExtensionArray): def x(self): """Return the x location of point geometries in a GeoSeries""" if (self.geom_type[~self.isna()] == "Point").all(): - return vectorized.get_x(self.data) + empty = self.is_empty + if empty.any(): + nonempty = ~empty + coords = np.full_like(nonempty, dtype=float, fill_value=np.nan) + coords[nonempty] = vectorized.get_x(self.data[nonempty]) + return coords + else: + return vectorized.get_x(self.data) else: message = "x attribute access only provided for Point geometries" raise ValueError(message) @@ -661,11 +883,34 @@ class GeometryArray(ExtensionArray): def y(self): """Return the y location of point geometries in a GeoSeries""" if (self.geom_type[~self.isna()] == "Point").all(): - return vectorized.get_y(self.data) + empty = self.is_empty + if empty.any(): + nonempty = ~empty + coords = np.full_like(nonempty, dtype=float, fill_value=np.nan) + coords[nonempty] = vectorized.get_y(self.data[nonempty]) + return coords + else: + return vectorized.get_y(self.data) else: message = "y attribute access only provided for Point geometries" raise ValueError(message) + @property + def z(self): + """Return the z location of point geometries in a GeoSeries""" + if (self.geom_type[~self.isna()] == "Point").all(): + empty = self.is_empty + if empty.any(): + nonempty = ~empty + coords = np.full_like(nonempty, dtype=float, fill_value=np.nan) + coords[nonempty] = vectorized.get_z(self.data[nonempty]) + return coords + else: + return vectorized.get_z(self.data) + else: + message = "z attribute access only provided for Point geometries" + raise ValueError(message) + @property def bounds(self): return vectorized.bounds(self.data) @@ -723,7 +968,7 @@ class GeometryArray(ExtensionArray): return GeometryArray(result, crs=self.crs) def _fill(self, idx, value): - """ Fill index locations with value + """Fill index locations with value Value should be a BaseGeometry """ @@ -732,11 +977,14 @@ class GeometryArray(ExtensionArray): "Value should be either a BaseGeometry or None, got %s" % str(value) ) # self.data[idx] = value - self.data[idx] = np.array([value], dtype=object) + value_arr = np.empty(1, dtype=object) + with compat.ignore_shapely2_warnings(): + value_arr[:] = [value] + self.data[idx] = value_arr return self def fillna(self, value=None, method=None, limit=None): - """ Fill NA/NaN values using the specified method. + """Fill NA/NaN values using the specified method. Parameters ---------- @@ -768,7 +1016,7 @@ class GeometryArray(ExtensionArray): if mask.any(): # fill with value - if _isna(value): + if vectorized.isna(value): value = None elif not isinstance(value, BaseGeometry): raise NotImplementedError( @@ -810,7 +1058,7 @@ class GeometryArray(ExtensionArray): pd_dtype = pd.api.types.pandas_dtype(dtype) if isinstance(pd_dtype, pd.StringDtype): # ensure to return a pandas string array instead of numpy array - return pd.array(string_values, dtype="string") + return pd.array(string_values, dtype=pd_dtype) return string_values.astype(dtype, copy=False) else: return np.array(self, dtype=dtype, copy=copy) @@ -824,6 +1072,38 @@ class GeometryArray(ExtensionArray): else: return np.array([g is None for g in self.data], dtype="bool") + def value_counts( + self, + dropna: bool = True, + ): + """ + Compute a histogram of the counts of non-null values. + + Parameters + ---------- + dropna : bool, default True + Don't include counts of NaN + + Returns + ------- + pd.Series + """ + + # note ExtensionArray usage of value_counts only specifies dropna, + # so sort, normalize and bins are not arguments + values = to_wkb(self) + from pandas import Series, Index + + result = Series(values).value_counts(dropna=dropna) + # value_counts converts None to nan, need to convert back for from_wkb to work + # note result.index already has object dtype, not geometry + # Can't use fillna(None) or Index.putmask, as this gets converted back to nan + # for object dtypes + result.index = Index( + from_wkb(np.where(result.index.isna(), None, result.index)) + ) + return result + def unique(self): """Compute the ExtensionArray of unique values. @@ -840,6 +1120,41 @@ class GeometryArray(ExtensionArray): def nbytes(self): return self.data.nbytes + def shift(self, periods=1, fill_value=None): + """ + Shift values by desired number. + + Newly introduced missing values are filled with + ``self.dtype.na_value``. + + Parameters + ---------- + periods : int, default 1 + The number of periods to shift. Negative values are allowed + for shifting backwards. + + fill_value : object, optional (default None) + The scalar value to use for newly introduced missing values. + The default is ``self.dtype.na_value``. + + Returns + ------- + GeometryArray + Shifted. + + Notes + ----- + If ``self`` is empty or ``periods`` is 0, a copy of ``self`` is + returned. + + If ``periods > len(self)``, then an array of size + len(self) is returned, with all values filled with + ``self.dtype.na_value``. + """ + shifted = super().shift(periods, fill_value) + shifted.crs = self.crs + return shifted + # ------------------------------------------------------------------------- # ExtensionArray specific # ------------------------------------------------------------------------- @@ -876,7 +1191,7 @@ class GeometryArray(ExtensionArray): Returns ------- values : ndarray - An array suitable for factoraization. This should maintain order + An array suitable for factorization. This should maintain order and be a supported dtype (Float64, Int64, UInt64, String, Object). By default, the extension array is cast to object dtype. na_value : object @@ -905,7 +1220,7 @@ class GeometryArray(ExtensionArray): pandas.factorize ExtensionArray.factorize """ - return from_wkb(values) + return from_wkb(values, crs=original.crs) def _values_for_argsort(self): # type: () -> np.ndarray @@ -952,21 +1267,30 @@ class GeometryArray(ExtensionArray): precision = geopandas.options.display_precision if precision is None: - # dummy heuristic based on 10 first geometries that should - # work in most cases - xmin, ymin, xmax, ymax = self[~self.isna()][:10].total_bounds - if ( - (-180 <= xmin <= 180) - and (-180 <= xmax <= 180) - and (-90 <= ymin <= 90) - and (-90 <= ymax <= 90) - ): - # geographic coordinates - precision = 5 + if self.crs: + if self.crs.is_projected: + precision = 3 + else: + precision = 5 else: - # typically projected coordinates - # (in case of unit meter: mm precision) - precision = 3 + # fallback + # dummy heuristic based on 10 first geometries that should + # work in most cases + with warnings.catch_warnings(): + warnings.simplefilter("ignore", category=RuntimeWarning) + xmin, ymin, xmax, ymax = self[~self.isna()][:10].total_bounds + if ( + (-180 <= xmin <= 180) + and (-180 <= xmax <= 180) + and (-90 <= ymin <= 90) + and (-90 <= ymax <= 90) + ): + # geographic coordinates + precision = 5 + else: + # typically projected coordinates + # (in case of unit meter: mm precision) + precision = 3 return lambda geom: shapely.wkt.dumps(geom, rounding_precision=precision) return repr @@ -1010,13 +1334,15 @@ class GeometryArray(ExtensionArray): def _binop(self, other, op): def convert_values(param): - if isinstance(param, ExtensionArray) or pd.api.types.is_list_like(param): + if not _is_scalar_geometry(param) and ( + isinstance(param, ExtensionArray) or pd.api.types.is_list_like(param) + ): ovalues = param else: # Assume its an object ovalues = [param] * len(self) return ovalues - if isinstance(other, (pd.Series, pd.Index)): + if isinstance(other, (pd.Series, pd.Index, pd.DataFrame)): # rely on pandas to unbox and dispatch to us return NotImplemented @@ -1038,3 +1364,18 @@ class GeometryArray(ExtensionArray): def __ne__(self, other): return self._binop(other, operator.ne) + + def __contains__(self, item): + """ + Return for `item in self`. + """ + if vectorized.isna(item): + if ( + item is self.dtype.na_value + or isinstance(item, self.dtype.type) + or item is None + ): + return self.isna().any() + else: + return False + return (self == item).any() diff --git a/geopandas/base.py b/geopandas/base.py index 7bb014f..2edf647 100644 --- a/geopandas/base.py +++ b/geopandas/base.py @@ -2,20 +2,12 @@ from warnings import warn import numpy as np import pandas as pd -from pandas import DataFrame, MultiIndex, Series +from pandas import DataFrame, Series from shapely.geometry import box from shapely.geometry.base import BaseGeometry -from shapely.ops import cascaded_union - -import geopandas as gpd from .array import GeometryArray, GeometryDtype -from .sindex import get_sindex_class, has_sindex - -# for backwards compat -# this will be static (will NOT follow USE_PYGEOS changes) -HAS_SINDEX = has_sindex() def is_geometry_type(data): @@ -31,11 +23,11 @@ def is_geometry_type(data): return False -def _delegate_binary_method(op, this, other, *args, **kwargs): +def _delegate_binary_method(op, this, other, align, *args, **kwargs): # type: (str, GeoSeries, GeoSeries) -> GeoSeries/Series this = this.geometry if isinstance(other, GeoPandasBase): - if not this.index.equals(other.index): + if align and not this.index.equals(other.index): warn("The indices of the two GeoSeries are different.") this, other = this.align(other.geometry) else: @@ -52,19 +44,19 @@ def _delegate_binary_method(op, this, other, *args, **kwargs): return data, this.index -def _binary_geo(op, this, other): +def _binary_geo(op, this, other, align): # type: (str, GeoSeries, GeoSeries) -> GeoSeries """Binary operation on GeoSeries objects that returns a GeoSeries""" from .geoseries import GeoSeries - geoms, index = _delegate_binary_method(op, this, other) + geoms, index = _delegate_binary_method(op, this, other, align) return GeoSeries(geoms.data, index=index, crs=this.crs) -def _binary_op(op, this, other, *args, **kwargs): +def _binary_op(op, this, other, align, *args, **kwargs): # type: (str, GeoSeries, GeoSeries, args/kwargs) -> Series[bool/float] """Binary operation on GeoSeries objects that returns a Series""" - data, index = _delegate_binary_method(op, this, other, *args, **kwargs) + data, index = _delegate_binary_method(op, this, other, align, *args, **kwargs) return Series(data, index=index) @@ -91,41 +83,53 @@ def _delegate_geo_method(op, this, *args, **kwargs): class GeoPandasBase(object): - _sindex = None - _sindex_generated = False - - def _generate_sindex(self): - sindex_cls = get_sindex_class() - if sindex_cls is not None: - _sindex = sindex_cls(self.geometry) - if not _sindex.is_empty: - self._sindex = _sindex - else: - warn( - "Generated spatial index is empty and returned `None`. " - "Future versions of GeoPandas will return zero-length spatial " - "index instead of `None`. Use `len(gdf.sindex) > 0` " - "or `if gdf.sindex` instead of `if gd.sindex is not None` " - "to check for empty spatial indexes.", - FutureWarning, - stacklevel=3, - ) - self._sindex = None - self._sindex_generated = True - - def _invalidate_sindex(self): - """ - Indicates that the spatial index should be re-built next - time it's requested. - - """ - self._sindex = None - self._sindex_generated = False - @property def area(self): """Returns a ``Series`` containing the area of each geometry in the - ``GeoSeries``.""" + ``GeoSeries`` expressed in the units of the CRS. + + Examples + -------- + + >>> from shapely.geometry import Polygon, LineString, Point + >>> s = geopandas.GeoSeries( + ... [ + ... Polygon([(0, 0), (1, 1), (0, 1)]), + ... Polygon([(10, 0), (10, 5), (0, 0)]), + ... Polygon([(0, 0), (2, 2), (2, 0)]), + ... LineString([(0, 0), (1, 1), (0, 1)]), + ... Point(0, 1) + ... ] + ... ) + >>> s + 0 POLYGON ((0.00000 0.00000, 1.00000 1.00000, 0.... + 1 POLYGON ((10.00000 0.00000, 10.00000 5.00000, ... + 2 POLYGON ((0.00000 0.00000, 2.00000 2.00000, 2.... + 3 LINESTRING (0.00000 0.00000, 1.00000 1.00000, ... + 4 POINT (0.00000 1.00000) + dtype: geometry + + >>> s.area + 0 0.5 + 1 25.0 + 2 2.0 + 3 0.0 + 4 0.0 + dtype: float64 + + See also + -------- + GeoSeries.length : measure length + + Notes + ----- + Area may be invalid for a geographic CRS using degrees as units; + use :meth:`GeoSeries.to_crs` to project geometries to a planar + CRS before using this function. + + Every operation in GeoPandas is planar, i.e. the potential third + dimension is not taken into account. + """ return _delegate_property("area", self) @property @@ -139,6 +143,27 @@ class GeoPandasBase(object): can be anything accepted by :meth:`pyproj.CRS.from_user_input() `, such as an authority string (eg "EPSG:4326") or a WKT string. + + Examples + -------- + + >>> s.crs # doctest: +SKIP + + Name: WGS 84 + Axis Info [ellipsoidal]: + - Lat[north]: Geodetic latitude (degree) + - Lon[east]: Geodetic longitude (degree) + Area of Use: + - name: World + - bounds: (-180.0, -90.0, 180.0, 90.0) + Datum: World Geodetic System 1984 + - Ellipsoid: WGS 84 + - Prime Meridian: Greenwich + + See also + -------- + GeoSeries.set_crs : assign CRS + GeoSeries.to_crs : re-project to another CRS """ return self.geometry.values.crs @@ -149,8 +174,22 @@ class GeoPandasBase(object): @property def geom_type(self): - """Returns a ``Series`` of strings specifying the `Geometry Type` of each - object.""" + """ + Returns a ``Series`` of strings specifying the `Geometry Type` of each + object. + + Examples + -------- + >>> from shapely.geometry import Point, Polygon, LineString + >>> d = {'geometry': [Point(2, 1), Polygon([(0, 0), (1, 1), (1, 0)]), + ... LineString([(0, 0), (1, 1)])]} + >>> gdf = geopandas.GeoDataFrame(d, crs="EPSG:4326") + >>> gdf.geom_type + 0 Point + 1 Polygon + 2 LineString + dtype: object + """ return _delegate_property("geom_type", self) @property @@ -160,13 +199,97 @@ class GeoPandasBase(object): @property def length(self): - """Returns a ``Series`` containing the length of each geometry.""" + """Returns a ``Series`` containing the length of each geometry + expressed in the units of the CRS. + + In the case of a (Multi)Polygon it measures the length + of its exterior (i.e. perimeter). + + Examples + -------- + + >>> from shapely.geometry import Polygon, LineString, MultiLineString, Point, \ +GeometryCollection + >>> s = geopandas.GeoSeries( + ... [ + ... LineString([(0, 0), (1, 1), (0, 1)]), + ... LineString([(10, 0), (10, 5), (0, 0)]), + ... MultiLineString([((0, 0), (1, 0)), ((-1, 0), (1, 0))]), + ... Polygon([(0, 0), (1, 1), (0, 1)]), + ... Point(0, 1), + ... GeometryCollection([Point(1, 0), LineString([(10, 0), (10, 5), (0,\ + 0)])]) + ... ] + ... ) + >>> s + 0 LINESTRING (0.00000 0.00000, 1.00000 1.00000, ... + 1 LINESTRING (10.00000 0.00000, 10.00000 5.00000... + 2 MULTILINESTRING ((0.00000 0.00000, 1.00000 0.0... + 3 POLYGON ((0.00000 0.00000, 1.00000 1.00000, 0.... + 4 POINT (0.00000 1.00000) + 5 GEOMETRYCOLLECTION (POINT (1.00000 0.00000), L... + dtype: geometry + + >>> s.length + 0 2.414214 + 1 16.180340 + 2 3.000000 + 3 3.414214 + 4 0.000000 + 5 16.180340 + dtype: float64 + + See also + -------- + GeoSeries.area : measure area of a polygon + + Notes + ----- + Length may be invalid for a geographic CRS using degrees as units; + use :meth:`GeoSeries.to_crs` to project geometries to a planar + CRS before using this function. + + Every operation in GeoPandas is planar, i.e. the potential third + dimension is not taken into account. + + """ return _delegate_property("length", self) @property def is_valid(self): """Returns a ``Series`` of ``dtype('bool')`` with value ``True`` for - geometries that are valid.""" + geometries that are valid. + + Examples + -------- + + An example with one invalid polygon (a bowtie geometry crossing itself) + and one missing geometry: + + >>> from shapely.geometry import Polygon + >>> s = geopandas.GeoSeries( + ... [ + ... Polygon([(0, 0), (1, 1), (0, 1)]), + ... Polygon([(0,0), (1, 1), (1, 0), (0, 1)]), # bowtie geometry + ... Polygon([(0, 0), (2, 2), (2, 0)]), + ... None + ... ] + ... ) + >>> s + 0 POLYGON ((0.00000 0.00000, 1.00000 1.00000, 0.... + 1 POLYGON ((0.00000 0.00000, 1.00000 1.00000, 1.... + 2 POLYGON ((0.00000 0.00000, 2.00000 2.00000, 2.... + 3 None + dtype: geometry + + >>> s.is_valid + 0 True + 1 False + 2 True + 3 False + dtype: bool + + """ return _delegate_property("is_valid", self) @property @@ -181,8 +304,8 @@ class GeoPandasBase(object): value: >>> from shapely.geometry import Point - >>> d = {'geometry': [Point(), Point(2,1), None]} - >>> gdf = gpd.GeoDataFrame(d, crs="EPSG:4326") + >>> d = {'geometry': [Point(), Point(2, 1), None]} + >>> gdf = geopandas.GeoDataFrame(d, crs="EPSG:4326") >>> gdf geometry 0 GEOMETRYCOLLECTION EMPTY @@ -206,19 +329,92 @@ class GeoPandasBase(object): geometries that do not cross themselves. This is meaningful only for `LineStrings` and `LinearRings`. + + Examples + -------- + >>> from shapely.geometry import LineString + >>> s = geopandas.GeoSeries( + ... [ + ... LineString([(0, 0), (1, 1), (1, -1), (0, 1)]), + ... LineString([(0, 0), (1, 1), (1, -1)]), + ... ] + ... ) + >>> s + 0 LINESTRING (0.00000 0.00000, 1.00000 1.00000, ... + 1 LINESTRING (0.00000 0.00000, 1.00000 1.00000, ... + dtype: geometry + + >>> s.is_simple + 0 False + 1 True + dtype: bool """ return _delegate_property("is_simple", self) @property def is_ring(self): """Returns a ``Series`` of ``dtype('bool')`` with value ``True`` for - features that are closed.""" + features that are closed. + + When constructing a LinearRing, the sequence of coordinates may be + explicitly closed by passing identical values in the first and last indices. + Otherwise, the sequence will be implicitly closed by copying the first tuple + to the last index. + + Examples + -------- + >>> from shapely.geometry import LineString, LinearRing + >>> s = geopandas.GeoSeries( + ... [ + ... LineString([(0, 0), (1, 1), (1, -1)]), + ... LineString([(0, 0), (1, 1), (1, -1), (0, 0)]), + ... LinearRing([(0, 0), (1, 1), (1, -1)]), + ... ] + ... ) + >>> s + 0 LINESTRING (0.00000 0.00000, 1.00000 1.00000, ... + 1 LINESTRING (0.00000 0.00000, 1.00000 1.00000, ... + 2 LINEARRING (0.00000 0.00000, 1.00000 1.00000, ... + dtype: geometry + + >>> s.is_ring + 0 False + 1 True + 2 True + dtype: bool + + """ return _delegate_property("is_ring", self) @property def has_z(self): """Returns a ``Series`` of ``dtype('bool')`` with value ``True`` for - features that have a z-component.""" + features that have a z-component. + + Notes + ------ + Every operation in GeoPandas is planar, i.e. the potential third + dimension is not taken into account. + + Examples + -------- + >>> from shapely.geometry import Point + >>> s = geopandas.GeoSeries( + ... [ + ... Point(0, 1), + ... Point(0, 1, 2), + ... ] + ... ) + >>> s + 0 POINT (0.00000 1.00000) + 1 POINT Z (0.00000 1.00000 2.00000) + dtype: geometry + + >>> s.has_z + 0 False + 1 True + dtype: bool + """ return _delegate_property("has_z", self) # @@ -228,13 +424,72 @@ class GeoPandasBase(object): @property def boundary(self): """Returns a ``GeoSeries`` of lower dimensional objects representing - each geometries's set-theoretic `boundary`.""" + each geometries's set-theoretic `boundary`. + + Examples + -------- + + >>> from shapely.geometry import Polygon, LineString, Point + >>> s = geopandas.GeoSeries( + ... [ + ... Polygon([(0, 0), (1, 1), (0, 1)]), + ... LineString([(0, 0), (1, 1), (1, 0)]), + ... Point(0, 0), + ... ] + ... ) + >>> s + 0 POLYGON ((0.00000 0.00000, 1.00000 1.00000, 0.... + 1 LINESTRING (0.00000 0.00000, 1.00000 1.00000, ... + 2 POINT (0.00000 0.00000) + dtype: geometry + + >>> s.boundary + 0 LINESTRING (0.00000 0.00000, 1.00000 1.00000, ... + 1 MULTIPOINT (0.00000 0.00000, 1.00000 0.00000) + 2 GEOMETRYCOLLECTION EMPTY + dtype: geometry + + See also + -------- + GeoSeries.exterior : outer boundary (without interior rings) + + """ return _delegate_property("boundary", self) @property def centroid(self): """Returns a ``GeoSeries`` of points representing the centroid of each - geometry.""" + geometry. + + Note that centroid does not have to be on or within original geometry. + + Examples + -------- + + >>> from shapely.geometry import Polygon, LineString, Point + >>> s = geopandas.GeoSeries( + ... [ + ... Polygon([(0, 0), (1, 1), (0, 1)]), + ... LineString([(0, 0), (1, 1), (1, 0)]), + ... Point(0, 0), + ... ] + ... ) + >>> s + 0 POLYGON ((0.00000 0.00000, 1.00000 1.00000, 0.... + 1 LINESTRING (0.00000 0.00000, 1.00000 1.00000, ... + 2 POINT (0.00000 0.00000) + dtype: geometry + + >>> s.centroid + 0 POINT (0.33333 0.66667) + 1 POINT (0.70711 0.50000) + 2 POINT (0.00000 0.00000) + dtype: geometry + + See also + -------- + GeoSeries.representative_point : point guaranteed to be within each geometry + """ return _delegate_property("centroid", self) @property @@ -245,7 +500,42 @@ class GeoPandasBase(object): The convex hull of a geometry is the smallest convex `Polygon` containing all the points in each geometry, unless the number of points in the geometric object is less than three. For two points, the convex - hull collapses to a `LineString`; for 1, a `Point`.""" + hull collapses to a `LineString`; for 1, a `Point`. + + Examples + -------- + + >>> from shapely.geometry import Polygon, LineString, Point, MultiPoint + >>> s = geopandas.GeoSeries( + ... [ + ... Polygon([(0, 0), (1, 1), (0, 1)]), + ... LineString([(0, 0), (1, 1), (1, 0)]), + ... MultiPoint([(0, 0), (1, 1), (0, 1), (1, 0), (0.5, 0.5)]), + ... MultiPoint([(0, 0), (1, 1)]), + ... Point(0, 0), + ... ] + ... ) + >>> s + 0 POLYGON ((0.00000 0.00000, 1.00000 1.00000, 0.... + 1 LINESTRING (0.00000 0.00000, 1.00000 1.00000, ... + 2 MULTIPOINT (0.00000 0.00000, 1.00000 1.00000, ... + 3 MULTIPOINT (0.00000 0.00000, 1.00000 1.00000) + 4 POINT (0.00000 0.00000) + dtype: geometry + + >>> s.convex_hull + 0 POLYGON ((0.00000 0.00000, 0.00000 1.00000, 1.... + 1 POLYGON ((0.00000 0.00000, 1.00000 1.00000, 1.... + 2 POLYGON ((0.00000 0.00000, 0.00000 1.00000, 1.... + 3 LINESTRING (0.00000 0.00000, 1.00000 1.00000) + 4 POINT (0.00000 0.00000) + dtype: geometry + + See also + -------- + GeoSeries.envelope : bounding rectangle geometry + + """ return _delegate_property("convex_hull", self) @property @@ -255,7 +545,38 @@ class GeoPandasBase(object): The envelope of a geometry is the bounding rectangle. That is, the point or smallest rectangular polygon (with sides parallel to the - coordinate axes) that contains the geometry.""" + coordinate axes) that contains the geometry. + + Examples + -------- + + >>> from shapely.geometry import Polygon, LineString, Point, MultiPoint + >>> s = geopandas.GeoSeries( + ... [ + ... Polygon([(0, 0), (1, 1), (0, 1)]), + ... LineString([(0, 0), (1, 1), (1, 0)]), + ... MultiPoint([(0, 0), (1, 1)]), + ... Point(0, 0), + ... ] + ... ) + >>> s + 0 POLYGON ((0.00000 0.00000, 1.00000 1.00000, 0.... + 1 LINESTRING (0.00000 0.00000, 1.00000 1.00000, ... + 2 MULTIPOINT (0.00000 0.00000, 1.00000 1.00000) + 3 POINT (0.00000 0.00000) + dtype: geometry + + >>> s.envelope + 0 POLYGON ((0.00000 0.00000, 1.00000 0.00000, 1.... + 1 POLYGON ((0.00000 0.00000, 1.00000 0.00000, 1.... + 2 POLYGON ((0.00000 0.00000, 1.00000 0.00000, 1.... + 3 POINT (0.00000 0.00000) + dtype: geometry + + See also + -------- + GeoSeries.convex_hull : convex hull geometry + """ return _delegate_property("envelope", self) @property @@ -263,7 +584,36 @@ class GeoPandasBase(object): """Returns a ``GeoSeries`` of LinearRings representing the outer boundary of each polygon in the GeoSeries. - Applies to GeoSeries containing only Polygons. + Applies to GeoSeries containing only Polygons. Returns ``None``` for + other geometry types. + + Examples + -------- + + >>> from shapely.geometry import Polygon, Point + >>> s = geopandas.GeoSeries( + ... [ + ... Polygon([(0, 0), (1, 1), (0, 1)]), + ... Polygon([(1, 0), (2, 1), (0, 0)]), + ... Point(0, 1) + ... ] + ... ) + >>> s + 0 POLYGON ((0.00000 0.00000, 1.00000 1.00000, 0.... + 1 POLYGON ((1.00000 0.00000, 2.00000 1.00000, 0.... + 2 POINT (0.00000 1.00000) + dtype: geometry + + >>> s.exterior + 0 LINEARRING (0.00000 0.00000, 1.00000 1.00000, ... + 1 LINEARRING (1.00000 0.00000, 2.00000 1.00000, ... + 2 None + dtype: geometry + + See also + -------- + GeoSeries.boundary : complete set-theoretic boundary + GeoSeries.interiors : list of inner rings of each polygon """ # TODO: return empty geometry for non-polygons return _delegate_property("exterior", self) @@ -279,12 +629,66 @@ class GeoPandasBase(object): ---------- inner_rings: Series of List Inner rings of each polygon in the GeoSeries. + + Examples + -------- + + >>> from shapely.geometry import Polygon + >>> s = geopandas.GeoSeries( + ... [ + ... Polygon( + ... [(0, 0), (0, 5), (5, 5), (5, 0)], + ... [[(1, 1), (2, 1), (1, 2)], [(1, 4), (2, 4), (2, 3)]], + ... ), + ... Polygon([(1, 0), (2, 1), (0, 0)]), + ... ] + ... ) + >>> s + 0 POLYGON ((0.00000 0.00000, 0.00000 5.00000, 5.... + 1 POLYGON ((1.00000 0.00000, 2.00000 1.00000, 0.... + dtype: geometry + + >>> s.interiors + 0 [LINEARRING (1 1, 2 1, 1 2, 1 1), LINEARRING (... + 1 [] + dtype: object + + See also + -------- + GeoSeries.exterior : outer boundary """ return _delegate_property("interiors", self) def representative_point(self): """Returns a ``GeoSeries`` of (cheaply computed) points that are guaranteed to be within each geometry. + + Examples + -------- + + >>> from shapely.geometry import Polygon, LineString, Point + >>> s = geopandas.GeoSeries( + ... [ + ... Polygon([(0, 0), (1, 1), (0, 1)]), + ... LineString([(0, 0), (1, 1), (1, 0)]), + ... Point(0, 0), + ... ] + ... ) + >>> s + 0 POLYGON ((0.00000 0.00000, 1.00000 1.00000, 0.... + 1 LINESTRING (0.00000 0.00000, 1.00000 1.00000, ... + 2 POINT (0.00000 0.00000) + dtype: geometry + + >>> s.representative_point() + 0 POINT (0.25000 0.50000) + 1 POINT (1.00000 1.00000) + 2 POINT (0.00000 0.00000) + dtype: geometry + + See also + -------- + GeoSeries.centroid : geometric centroid """ return _delegate_geo_method("representative_point", self) @@ -294,176 +698,1078 @@ class GeoPandasBase(object): @property def cascaded_union(self): - """Deprecated: Return the unary_union of all geometries""" - return cascaded_union(np.asarray(self.geometry.values)) + """Deprecated: use `unary_union` instead""" + warn( + "The 'cascaded_union' attribute is deprecated, use 'unary_union' instead", + FutureWarning, + stacklevel=2, + ) + return self.geometry.values.unary_union() @property def unary_union(self): """Returns a geometry containing the union of all geometries in the - ``GeoSeries``.""" + ``GeoSeries``. + + Examples + -------- + + >>> from shapely.geometry import box + >>> s = geopandas.GeoSeries([box(0,0,1,1), box(0,0,2,2)]) + >>> s + 0 POLYGON ((1.00000 0.00000, 1.00000 1.00000, 0.... + 1 POLYGON ((2.00000 0.00000, 2.00000 2.00000, 0.... + dtype: geometry + + >>> union = s.unary_union + >>> print(union) + POLYGON ((0 1, 0 2, 2 2, 2 0, 1 0, 0 0, 0 1)) + """ return self.geometry.values.unary_union() # # Binary operations that return a pandas Series # - def contains(self, other): + def contains(self, other, align=True): """Returns a ``Series`` of ``dtype('bool')`` with value ``True`` for - each geometry that contains `other`. + each aligned geometry that contains `other`. - An object is said to contain `other` if its `interior` contains the - `boundary` and `interior` of the other object and their boundaries do - not touch at all. + An object is said to contain `other` if at least one point of `other` lies in + the interior and no points of `other` lie in the exterior of the object. + (Therefore, any given polygon does not contain its own boundary – there is not + any point that lies in the interior.) + If either object is empty, this operation returns ``False``. This is the inverse of :meth:`within` in the sense that the expression ``a.contains(b) == b.within(a)`` always evaluates to ``True``. + The operation works on a 1-to-1 row-wise manner: + + .. image:: ../../../_static/binary_op-01.svg + :align: center + Parameters ---------- other : GeoSeries or geometric object - The GeoSeries (elementwise) or geometric object to test if is - contained. - """ - return _binary_op("contains", self, other) + The GeoSeries (elementwise) or geometric object to test if it + is contained. + align : bool (default True) + If True, automatically aligns GeoSeries based on their indices. + If False, the order of elements is preserved. - def geom_equals(self, other): + Returns + ------- + Series (bool) + + Examples + -------- + >>> from shapely.geometry import Polygon, LineString, Point + >>> s = geopandas.GeoSeries( + ... [ + ... Polygon([(0, 0), (1, 1), (0, 1)]), + ... LineString([(0, 0), (0, 2)]), + ... LineString([(0, 0), (0, 1)]), + ... Point(0, 1), + ... ], + ... index=range(0, 4), + ... ) + >>> s2 = geopandas.GeoSeries( + ... [ + ... Polygon([(0, 0), (2, 2), (0, 2)]), + ... Polygon([(0, 0), (1, 2), (0, 2)]), + ... LineString([(0, 0), (0, 2)]), + ... Point(0, 1), + ... ], + ... index=range(1, 5), + ... ) + + >>> s + 0 POLYGON ((0.00000 0.00000, 1.00000 1.00000, 0.... + 1 LINESTRING (0.00000 0.00000, 0.00000 2.00000) + 2 LINESTRING (0.00000 0.00000, 0.00000 1.00000) + 3 POINT (0.00000 1.00000) + dtype: geometry + + >>> s2 + 1 POLYGON ((0.00000 0.00000, 2.00000 2.00000, 0.... + 2 POLYGON ((0.00000 0.00000, 1.00000 2.00000, 0.... + 3 LINESTRING (0.00000 0.00000, 0.00000 2.00000) + 4 POINT (0.00000 1.00000) + dtype: geometry + + We can check if each geometry of GeoSeries contains a single + geometry: + + .. image:: ../../../_static/binary_op-03.svg + :align: center + + >>> point = Point(0, 1) + >>> s.contains(point) + 0 False + 1 True + 2 False + 3 True + dtype: bool + + We can also check two GeoSeries against each other, row by row. + The GeoSeries above have different indices. We can either align both GeoSeries + based on index values and compare elements with the same index using + ``align=True`` or ignore index and compare elements based on their matching + order using ``align=False``: + + .. image:: ../../../_static/binary_op-02.svg + + >>> s2.contains(s, align=True) + 0 False + 1 False + 2 False + 3 True + 4 False + dtype: bool + + >>> s2.contains(s, align=False) + 1 True + 2 False + 3 True + 4 True + dtype: bool + + Notes + ----- + This method works in a row-wise manner. It does not check if an element + of one GeoSeries ``contains`` *any* element of the other one. + + See also + -------- + GeoSeries.within + """ + return _binary_op("contains", self, other, align) + + def geom_equals(self, other, align=True): """Returns a ``Series`` of ``dtype('bool')`` with value ``True`` for - each geometry equal to `other`. + each aligned geometry equal to `other`. An object is said to be equal to `other` if its set-theoretic `boundary`, `interior`, and `exterior` coincides with those of the other. + The operation works on a 1-to-1 row-wise manner: + + .. image:: ../../../_static/binary_op-01.svg + :align: center + Parameters ---------- other : GeoSeries or geometric object The GeoSeries (elementwise) or geometric object to test for equality. - """ - return _binary_op("geom_equals", self, other) + align : bool (default True) + If True, automatically aligns GeoSeries based on their indices. + If False, the order of elements is preserved. - def geom_almost_equals(self, other, decimal=6): + Returns + ------- + Series (bool) + + Examples + -------- + >>> from shapely.geometry import Polygon, LineString, Point + >>> s = geopandas.GeoSeries( + ... [ + ... Polygon([(0, 0), (2, 2), (0, 2)]), + ... Polygon([(0, 0), (1, 2), (0, 2)]), + ... LineString([(0, 0), (0, 2)]), + ... Point(0, 1), + ... ], + ... ) + >>> s2 = geopandas.GeoSeries( + ... [ + ... Polygon([(0, 0), (2, 2), (0, 2)]), + ... Polygon([(0, 0), (1, 2), (0, 2)]), + ... Point(0, 1), + ... LineString([(0, 0), (0, 2)]), + ... ], + ... index=range(1, 5), + ... ) + + >>> s + 0 POLYGON ((0.00000 0.00000, 2.00000 2.00000, 0.... + 1 POLYGON ((0.00000 0.00000, 1.00000 2.00000, 0.... + 2 LINESTRING (0.00000 0.00000, 0.00000 2.00000) + 3 POINT (0.00000 1.00000) + dtype: geometry + + >>> s2 + 1 POLYGON ((0.00000 0.00000, 2.00000 2.00000, 0.... + 2 POLYGON ((0.00000 0.00000, 1.00000 2.00000, 0.... + 3 POINT (0.00000 1.00000) + 4 LINESTRING (0.00000 0.00000, 0.00000 2.00000) + dtype: geometry + + We can check if each geometry of GeoSeries contains a single + geometry: + + .. image:: ../../../_static/binary_op-03.svg + :align: center + + >>> polygon = Polygon([(0, 0), (2, 2), (0, 2)]) + >>> s.geom_equals(polygon) + 0 True + 1 False + 2 False + 3 False + dtype: bool + + We can also check two GeoSeries against each other, row by row. + The GeoSeries above have different indices. We can either align both GeoSeries + based on index values and compare elements with the same index using + ``align=True`` or ignore index and compare elements based on their matching + order using ``align=False``: + + .. image:: ../../../_static/binary_op-02.svg + + >>> s.geom_equals(s2) + 0 False + 1 False + 2 False + 3 True + 4 False + dtype: bool + + >>> s.geom_equals(s2, align=False) + 0 True + 1 True + 2 False + 3 False + dtype: bool + + Notes + ----- + This method works in a row-wise manner. It does not check if an element + of one GeoSeries is equal to *any* element of the other one. + + See also + -------- + GeoSeries.geom_almost_equals + GeoSeries.geom_equals_exact + + """ + return _binary_op("geom_equals", self, other, align) + + def geom_almost_equals(self, other, decimal=6, align=True): """Returns a ``Series`` of ``dtype('bool')`` with value ``True`` if - each geometry is approximately equal to `other`. + each aligned geometry is approximately equal to `other`. Approximate equality is tested at all points to the specified `decimal` - place precision. See also :meth:`geom_equals`. + place precision. + + The operation works on a 1-to-1 row-wise manner: + + .. image:: ../../../_static/binary_op-01.svg + :align: center Parameters ---------- other : GeoSeries or geometric object The GeoSeries (elementwise) or geometric object to compare to. decimal : int - Decimal place presion used when testing for approximate equality. + Decimal place precision used when testing for approximate equality. + align : bool (default True) + If True, automatically aligns GeoSeries based on their indices. + If False, the order of elements is preserved. + + Returns + ------- + Series (bool) + + Examples + -------- + >>> from shapely.geometry import Point + >>> s = geopandas.GeoSeries( + ... [ + ... Point(0, 1.1), + ... Point(0, 1.01), + ... Point(0, 1.001), + ... ], + ... ) + + >>> s + 0 POINT (0.00000 1.10000) + 1 POINT (0.00000 1.01000) + 2 POINT (0.00000 1.00100) + dtype: geometry + + + >>> s.geom_almost_equals(Point(0, 1), decimal=2) + 0 False + 1 False + 2 True + dtype: bool + + >>> s.geom_almost_equals(Point(0, 1), decimal=1) + 0 False + 1 True + 2 True + dtype: bool + + Notes + ----- + This method works in a row-wise manner. It does not check if an element + of one GeoSeries is equal to *any* element of the other one. + + See also + -------- + GeoSeries.geom_equals + GeoSeries.geom_equals_exact + """ - return _binary_op("geom_almost_equals", self, other, decimal=decimal) + return _binary_op( + "geom_almost_equals", self, other, decimal=decimal, align=align + ) - def geom_equals_exact(self, other, tolerance): - """Return True for all geometries that equal *other* to a given - tolerance, else False""" - return _binary_op("geom_equals_exact", self, other, tolerance=tolerance) + def geom_equals_exact(self, other, tolerance, align=True): + """Return True for all geometries that equal aligned *other* to a given + tolerance, else False. - def crosses(self, other): + The operation works on a 1-to-1 row-wise manner: + + .. image:: ../../../_static/binary_op-01.svg + :align: center + + Parameters + ---------- + other : GeoSeries or geometric object + The GeoSeries (elementwise) or geometric object to compare to. + tolerance : float + Decimal place precision used when testing for approximate equality. + align : bool (default True) + If True, automatically aligns GeoSeries based on their indices. + If False, the order of elements is preserved. + + Returns + ------- + Series (bool) + + Examples + -------- + >>> from shapely.geometry import Point + >>> s = geopandas.GeoSeries( + ... [ + ... Point(0, 1.1), + ... Point(0, 1.0), + ... Point(0, 1.2), + ... ] + ... ) + + >>> s + 0 POINT (0.00000 1.10000) + 1 POINT (0.00000 1.00000) + 2 POINT (0.00000 1.20000) + dtype: geometry + + + >>> s.geom_equals_exact(Point(0, 1), tolerance=0.1) + 0 False + 1 True + 2 False + dtype: bool + + >>> s.geom_equals_exact(Point(0, 1), tolerance=0.15) + 0 True + 1 True + 2 False + dtype: bool + + Notes + ----- + This method works in a row-wise manner. It does not check if an element + of one GeoSeries is equal to *any* element of the other one. + + See also + -------- + GeoSeries.geom_equals + GeoSeries.geom_almost_equals + """ + return _binary_op( + "geom_equals_exact", self, other, tolerance=tolerance, align=align + ) + + def crosses(self, other, align=True): """Returns a ``Series`` of ``dtype('bool')`` with value ``True`` for - each geometry that cross `other`. + each aligned geometry that cross `other`. An object is said to cross `other` if its `interior` intersects the `interior` of the other but does not contain it, and the dimension of the intersection is less than the dimension of the one or the other. + The operation works on a 1-to-1 row-wise manner: + + .. image:: ../../../_static/binary_op-01.svg + :align: center + Parameters ---------- other : GeoSeries or geometric object The GeoSeries (elementwise) or geometric object to test if is crossed. - """ - return _binary_op("crosses", self, other) + align : bool (default True) + If True, automatically aligns GeoSeries based on their indices. + If False, the order of elements is preserved. - def disjoint(self, other): + Returns + ------- + Series (bool) + + Examples + -------- + >>> from shapely.geometry import Polygon, LineString, Point + >>> s = geopandas.GeoSeries( + ... [ + ... Polygon([(0, 0), (2, 2), (0, 2)]), + ... LineString([(0, 0), (2, 2)]), + ... LineString([(2, 0), (0, 2)]), + ... Point(0, 1), + ... ], + ... ) + >>> s2 = geopandas.GeoSeries( + ... [ + ... LineString([(1, 0), (1, 3)]), + ... LineString([(2, 0), (0, 2)]), + ... Point(1, 1), + ... Point(0, 1), + ... ], + ... index=range(1, 5), + ... ) + + >>> s + 0 POLYGON ((0.00000 0.00000, 2.00000 2.00000, 0.... + 1 LINESTRING (0.00000 0.00000, 2.00000 2.00000) + 2 LINESTRING (2.00000 0.00000, 0.00000 2.00000) + 3 POINT (0.00000 1.00000) + dtype: geometry + + >>> s2 + 1 LINESTRING (1.00000 0.00000, 1.00000 3.00000) + 2 LINESTRING (2.00000 0.00000, 0.00000 2.00000) + 3 POINT (1.00000 1.00000) + 4 POINT (0.00000 1.00000) + dtype: geometry + + We can check if each geometry of GeoSeries crosses a single + geometry: + + .. image:: ../../../_static/binary_op-03.svg + :align: center + + >>> line = LineString([(-1, 1), (3, 1)]) + >>> s.crosses(line) + 0 True + 1 True + 2 True + 3 False + dtype: bool + + We can also check two GeoSeries against each other, row by row. + The GeoSeries above have different indices. We can either align both GeoSeries + based on index values and compare elements with the same index using + ``align=True`` or ignore index and compare elements based on their matching + order using ``align=False``: + + .. image:: ../../../_static/binary_op-02.svg + + >>> s.crosses(s2, align=True) + 0 False + 1 True + 2 False + 3 False + 4 False + dtype: bool + + >>> s.crosses(s2, align=False) + 0 True + 1 True + 2 False + 3 False + dtype: bool + + Notice that a line does not cross a point that it contains. + + Notes + ----- + This method works in a row-wise manner. It does not check if an element + of one GeoSeries ``crosses`` *any* element of the other one. + + See also + -------- + GeoSeries.disjoint + GeoSeries.intersects + + """ + return _binary_op("crosses", self, other, align) + + def disjoint(self, other, align=True): """Returns a ``Series`` of ``dtype('bool')`` with value ``True`` for - each geometry disjoint to `other`. + each aligned geometry disjoint to `other`. An object is said to be disjoint to `other` if its `boundary` and `interior` does not intersect at all with those of the other. + The operation works on a 1-to-1 row-wise manner: + + .. image:: ../../../_static/binary_op-01.svg + :align: center + Parameters ---------- other : GeoSeries or geometric object The GeoSeries (elementwise) or geometric object to test if is disjoint. - """ - return _binary_op("disjoint", self, other) + align : bool (default True) + If True, automatically aligns GeoSeries based on their indices. + If False, the order of elements is preserved. - def intersects(self, other): + Returns + ------- + Series (bool) + + Examples + -------- + >>> from shapely.geometry import Polygon, LineString, Point + >>> s = geopandas.GeoSeries( + ... [ + ... Polygon([(0, 0), (2, 2), (0, 2)]), + ... LineString([(0, 0), (2, 2)]), + ... LineString([(2, 0), (0, 2)]), + ... Point(0, 1), + ... ], + ... ) + >>> s2 = geopandas.GeoSeries( + ... [ + ... Polygon([(-1, 0), (-1, 2), (0, -2)]), + ... LineString([(0, 0), (0, 1)]), + ... Point(1, 1), + ... Point(0, 0), + ... ], + ... ) + + >>> s + 0 POLYGON ((0.00000 0.00000, 2.00000 2.00000, 0.... + 1 LINESTRING (0.00000 0.00000, 2.00000 2.00000) + 2 LINESTRING (2.00000 0.00000, 0.00000 2.00000) + 3 POINT (0.00000 1.00000) + dtype: geometry + + >>> s2 + 0 POLYGON ((-1.00000 0.00000, -1.00000 2.00000, ... + 1 LINESTRING (0.00000 0.00000, 0.00000 1.00000) + 2 POINT (1.00000 1.00000) + 3 POINT (0.00000 0.00000) + dtype: geometry + + We can check each geometry of GeoSeries to a single + geometry: + + .. image:: ../../../_static/binary_op-03.svg + :align: center + + >>> line = LineString([(0, 0), (2, 0)]) + >>> s.disjoint(line) + 0 False + 1 False + 2 False + 3 True + dtype: bool + + We can also check two GeoSeries against each other, row by row. + We can either align both GeoSeries + based on index values and compare elements with the same index using + ``align=True`` or ignore index and compare elements based on their matching + order using ``align=False``: + + .. image:: ../../../_static/binary_op-02.svg + + >>> s.disjoint(s2) + 0 True + 1 False + 2 False + 3 True + dtype: bool + + Notes + ----- + This method works in a row-wise manner. It does not check if an element + of one GeoSeries is equal to *any* element of the other one. + + See also + -------- + GeoSeries.intersects + GeoSeries.touches + + """ + return _binary_op("disjoint", self, other, align) + + def intersects(self, other, align=True): """Returns a ``Series`` of ``dtype('bool')`` with value ``True`` for - each geometry that intersects `other`. + each aligned geometry that intersects `other`. An object is said to intersect `other` if its `boundary` and `interior` intersects in any way with those of the other. + The operation works on a 1-to-1 row-wise manner: + + .. image:: ../../../_static/binary_op-01.svg + :align: center + Parameters ---------- other : GeoSeries or geometric object The GeoSeries (elementwise) or geometric object to test if is intersected. - """ - return _binary_op("intersects", self, other) + align : bool (default True) + If True, automatically aligns GeoSeries based on their indices. + If False, the order of elements is preserved. - def overlaps(self, other): - """Returns True for all geometries that overlap *other*, else False. + Returns + ------- + Series (bool) + + Examples + -------- + >>> from shapely.geometry import Polygon, LineString, Point + >>> s = geopandas.GeoSeries( + ... [ + ... Polygon([(0, 0), (2, 2), (0, 2)]), + ... LineString([(0, 0), (2, 2)]), + ... LineString([(2, 0), (0, 2)]), + ... Point(0, 1), + ... ], + ... ) + >>> s2 = geopandas.GeoSeries( + ... [ + ... LineString([(1, 0), (1, 3)]), + ... LineString([(2, 0), (0, 2)]), + ... Point(1, 1), + ... Point(0, 1), + ... ], + ... index=range(1, 5), + ... ) + + >>> s + 0 POLYGON ((0.00000 0.00000, 2.00000 2.00000, 0.... + 1 LINESTRING (0.00000 0.00000, 2.00000 2.00000) + 2 LINESTRING (2.00000 0.00000, 0.00000 2.00000) + 3 POINT (0.00000 1.00000) + dtype: geometry + + >>> s2 + 1 LINESTRING (1.00000 0.00000, 1.00000 3.00000) + 2 LINESTRING (2.00000 0.00000, 0.00000 2.00000) + 3 POINT (1.00000 1.00000) + 4 POINT (0.00000 1.00000) + dtype: geometry + + We can check if each geometry of GeoSeries crosses a single + geometry: + + .. image:: ../../../_static/binary_op-03.svg + :align: center + + >>> line = LineString([(-1, 1), (3, 1)]) + >>> s.intersects(line) + 0 True + 1 True + 2 True + 3 True + dtype: bool + + We can also check two GeoSeries against each other, row by row. + The GeoSeries above have different indices. We can either align both GeoSeries + based on index values and compare elements with the same index using + ``align=True`` or ignore index and compare elements based on their matching + order using ``align=False``: + + .. image:: ../../../_static/binary_op-02.svg + + >>> s.intersects(s2, align=True) + 0 False + 1 True + 2 True + 3 False + 4 False + dtype: bool + + >>> s.intersects(s2, align=False) + 0 True + 1 True + 2 True + 3 True + dtype: bool + + Notes + ----- + This method works in a row-wise manner. It does not check if an element + of one GeoSeries ``crosses`` *any* element of the other one. + + See also + -------- + GeoSeries.disjoint + GeoSeries.crosses + GeoSeries.touches + GeoSeries.intersection + """ + return _binary_op("intersects", self, other, align) + + def overlaps(self, other, align=True): + """Returns True for all aligned geometries that overlap *other*, else False. + + Geometries overlaps if they have more than one but not all + points in common, have the same dimension, and the intersection of the + interiors of the geometries has the same dimension as the geometries + themselves. + + The operation works on a 1-to-1 row-wise manner: + + .. image:: ../../../_static/binary_op-01.svg + :align: center Parameters ---------- other : GeoSeries or geometric object The GeoSeries (elementwise) or geometric object to test if overlaps. - """ - return _binary_op("overlaps", self, other) + align : bool (default True) + If True, automatically aligns GeoSeries based on their indices. + If False, the order of elements is preserved. - def touches(self, other): + Returns + ------- + Series (bool) + + Examples + -------- + >>> from shapely.geometry import Polygon, LineString, MultiPoint, Point + >>> s = geopandas.GeoSeries( + ... [ + ... Polygon([(0, 0), (2, 2), (0, 2)]), + ... Polygon([(0, 0), (2, 2), (0, 2)]), + ... LineString([(0, 0), (2, 2)]), + ... MultiPoint([(0, 0), (0, 1)]), + ... ], + ... ) + >>> s2 = geopandas.GeoSeries( + ... [ + ... Polygon([(0, 0), (2, 0), (0, 2)]), + ... LineString([(0, 1), (1, 1)]), + ... LineString([(1, 1), (3, 3)]), + ... Point(0, 1), + ... ], + ... index=range(1, 5), + ... ) + + >>> s + 0 POLYGON ((0.00000 0.00000, 2.00000 2.00000, 0.... + 1 POLYGON ((0.00000 0.00000, 2.00000 2.00000, 0.... + 2 LINESTRING (0.00000 0.00000, 2.00000 2.00000) + 3 MULTIPOINT (0.00000 0.00000, 0.00000 1.00000) + dtype: geometry + + >>> s2 + 1 POLYGON ((0.00000 0.00000, 2.00000 0.00000, 0.... + 2 LINESTRING (0.00000 1.00000, 1.00000 1.00000) + 3 LINESTRING (1.00000 1.00000, 3.00000 3.00000) + 4 POINT (0.00000 1.00000) + dtype: geometry + + We can check if each geometry of GeoSeries overlaps a single + geometry: + + .. image:: ../../../_static/binary_op-03.svg + :align: center + + >>> polygon = Polygon([(0, 0), (1, 0), (1, 1), (0, 1)]) + >>> s.overlaps(polygon) + 0 True + 1 True + 2 False + 3 False + dtype: bool + + We can also check two GeoSeries against each other, row by row. + The GeoSeries above have different indices. We can either align both GeoSeries + based on index values and compare elements with the same index using + ``align=True`` or ignore index and compare elements based on their matching + order using ``align=False``: + + .. image:: ../../../_static/binary_op-02.svg + + >>> s.overlaps(s2) + 0 False + 1 True + 2 False + 3 False + 4 False + dtype: bool + + >>> s.overlaps(s2, align=False) + 0 True + 1 False + 2 True + 3 False + dtype: bool + + Notes + ----- + This method works in a row-wise manner. It does not check if an element + of one GeoSeries ``overlaps`` *any* element of the other one. + + See also + -------- + GeoSeries.crosses + GeoSeries.intersects + + """ + return _binary_op("overlaps", self, other, align) + + def touches(self, other, align=True): """Returns a ``Series`` of ``dtype('bool')`` with value ``True`` for - each geometry that touches `other`. + each aligned geometry that touches `other`. An object is said to touch `other` if it has at least one point in common with `other` and its interior does not intersect with any part - of the other. + of the other. Overlapping features therefore do not touch. + + The operation works on a 1-to-1 row-wise manner: + + .. image:: ../../../_static/binary_op-01.svg + :align: center Parameters ---------- other : GeoSeries or geometric object The GeoSeries (elementwise) or geometric object to test if is touched. + align : bool (default True) + If True, automatically aligns GeoSeries based on their indices. + If False, the order of elements is preserved. + + Returns + ------- + Series (bool) + + Examples + -------- + >>> from shapely.geometry import Polygon, LineString, MultiPoint, Point + >>> s = geopandas.GeoSeries( + ... [ + ... Polygon([(0, 0), (2, 2), (0, 2)]), + ... Polygon([(0, 0), (2, 2), (0, 2)]), + ... LineString([(0, 0), (2, 2)]), + ... MultiPoint([(0, 0), (0, 1)]), + ... ], + ... ) + >>> s2 = geopandas.GeoSeries( + ... [ + ... Polygon([(0, 0), (-2, 0), (0, -2)]), + ... LineString([(0, 1), (1, 1)]), + ... LineString([(1, 1), (3, 0)]), + ... Point(0, 1), + ... ], + ... index=range(1, 5), + ... ) + + >>> s + 0 POLYGON ((0.00000 0.00000, 2.00000 2.00000, 0.... + 1 POLYGON ((0.00000 0.00000, 2.00000 2.00000, 0.... + 2 LINESTRING (0.00000 0.00000, 2.00000 2.00000) + 3 MULTIPOINT (0.00000 0.00000, 0.00000 1.00000) + dtype: geometry + + >>> s2 + 1 POLYGON ((0.00000 0.00000, -2.00000 0.00000, 0... + 2 LINESTRING (0.00000 1.00000, 1.00000 1.00000) + 3 LINESTRING (1.00000 1.00000, 3.00000 0.00000) + 4 POINT (0.00000 1.00000) + dtype: geometry + + We can check if each geometry of GeoSeries touches a single + geometry: + + .. image:: ../../../_static/binary_op-03.svg + :align: center + + + >>> line = LineString([(0, 0), (-1, -2)]) + >>> s.touches(line) + 0 True + 1 True + 2 True + 3 True + dtype: bool + + We can also check two GeoSeries against each other, row by row. + The GeoSeries above have different indices. We can either align both GeoSeries + based on index values and compare elements with the same index using + ``align=True`` or ignore index and compare elements based on their matching + order using ``align=False``: + + .. image:: ../../../_static/binary_op-02.svg + + >>> s.touches(s2, align=True) + 0 False + 1 True + 2 True + 3 False + 4 False + dtype: bool + + >>> s.touches(s2, align=False) + 0 True + 1 False + 2 True + 3 False + dtype: bool + + Notes + ----- + This method works in a row-wise manner. It does not check if an element + of one GeoSeries ``touches`` *any* element of the other one. + + See also + -------- + GeoSeries.overlaps + GeoSeries.intersects + """ - return _binary_op("touches", self, other) + return _binary_op("touches", self, other, align) - def within(self, other): + def within(self, other, align=True): """Returns a ``Series`` of ``dtype('bool')`` with value ``True`` for - each geometry that is within `other`. + each aligned geometry that is within `other`. - An object is said to be within `other` if its `boundary` and `interior` - intersects only with the `interior` of the other (not its `boundary` or - `exterior`). + An object is said to be within `other` if at least one of its points is located + in the `interior` and no points are located in the `exterior` of the other. + If either object is empty, this operation returns ``False``. This is the inverse of :meth:`contains` in the sense that the expression ``a.within(b) == b.contains(a)`` always evaluates to ``True``. + The operation works on a 1-to-1 row-wise manner: + + .. image:: ../../../_static/binary_op-01.svg + :align: center + Parameters ---------- other : GeoSeries or geometric object The GeoSeries (elementwise) or geometric object to test if each geometry is within. + align : bool (default True) + If True, automatically aligns GeoSeries based on their indices. + If False, the order of elements is preserved. + Returns + ------- + Series (bool) + + + Examples + -------- + >>> from shapely.geometry import Polygon, LineString, Point + >>> s = geopandas.GeoSeries( + ... [ + ... Polygon([(0, 0), (2, 2), (0, 2)]), + ... Polygon([(0, 0), (1, 2), (0, 2)]), + ... LineString([(0, 0), (0, 2)]), + ... Point(0, 1), + ... ], + ... ) + >>> s2 = geopandas.GeoSeries( + ... [ + ... Polygon([(0, 0), (1, 1), (0, 1)]), + ... LineString([(0, 0), (0, 2)]), + ... LineString([(0, 0), (0, 1)]), + ... Point(0, 1), + ... ], + ... index=range(1, 5), + ... ) + + >>> s + 0 POLYGON ((0.00000 0.00000, 2.00000 2.00000, 0.... + 1 POLYGON ((0.00000 0.00000, 1.00000 2.00000, 0.... + 2 LINESTRING (0.00000 0.00000, 0.00000 2.00000) + 3 POINT (0.00000 1.00000) + dtype: geometry + + >>> s2 + 1 POLYGON ((0.00000 0.00000, 1.00000 1.00000, 0.... + 2 LINESTRING (0.00000 0.00000, 0.00000 2.00000) + 3 LINESTRING (0.00000 0.00000, 0.00000 1.00000) + 4 POINT (0.00000 1.00000) + dtype: geometry + + We can check if each geometry of GeoSeries is within a single + geometry: + + .. image:: ../../../_static/binary_op-03.svg + :align: center + + >>> polygon = Polygon([(0, 0), (2, 2), (0, 2)]) + >>> s.within(polygon) + 0 True + 1 True + 2 False + 3 False + dtype: bool + + We can also check two GeoSeries against each other, row by row. + The GeoSeries above have different indices. We can either align both GeoSeries + based on index values and compare elements with the same index using + ``align=True`` or ignore index and compare elements based on their matching + order using ``align=False``: + + .. image:: ../../../_static/binary_op-02.svg + + >>> s2.within(s) + 0 False + 1 False + 2 True + 3 False + 4 False + dtype: bool + + >>> s2.within(s, align=False) + 1 True + 2 False + 3 True + 4 True + dtype: bool + + Notes + ----- + This method works in a row-wise manner. It does not check if an element + of one GeoSeries is ``within`` *any* element of the other one. + + See also + -------- + GeoSeries.contains """ - return _binary_op("within", self, other) + return _binary_op("within", self, other, align) - def covers(self, other): + def covers(self, other, align=True): """ Returns a ``Series`` of ``dtype('bool')`` with value ``True`` for - each geometry that is entirely covering `other`. + each aligned geometry that is entirely covering `other`. An object A is said to cover another object B if no points of B lie in the exterior of A. + If either object is empty, this operation returns ``False``. + + The operation works on a 1-to-1 row-wise manner: + + .. image:: ../../../_static/binary_op-01.svg + :align: center See https://lin-ear-th-inking.blogspot.com/2007/06/subtleties-of-ogc-covers-spatial.html @@ -473,17 +1779,111 @@ class GeoPandasBase(object): ---------- other : Geoseries or geometric object The Geoseries (elementwise) or geometric object to check is being covered. - """ - return _binary_geo("covers", self, other) + align : bool (default True) + If True, automatically aligns GeoSeries based on their indices. + If False, the order of elements is preserved. - def covered_by(self, other): + Returns + ------- + Series (bool) + + Examples + -------- + >>> from shapely.geometry import Polygon, LineString, Point + >>> s = geopandas.GeoSeries( + ... [ + ... Polygon([(0, 0), (2, 0), (2, 2), (0, 2)]), + ... Polygon([(0, 0), (2, 2), (0, 2)]), + ... LineString([(0, 0), (2, 2)]), + ... Point(0, 0), + ... ], + ... ) + >>> s2 = geopandas.GeoSeries( + ... [ + ... Polygon([(0.5, 0.5), (1.5, 0.5), (1.5, 1.5), (0.5, 1.5)]), + ... Polygon([(0, 0), (2, 0), (2, 2), (0, 2)]), + ... LineString([(1, 1), (1.5, 1.5)]), + ... Point(0, 0), + ... ], + ... index=range(1, 5), + ... ) + + >>> s + 0 POLYGON ((0.00000 0.00000, 2.00000 0.00000, 2.... + 1 POLYGON ((0.00000 0.00000, 2.00000 2.00000, 0.... + 2 LINESTRING (0.00000 0.00000, 2.00000 2.00000) + 3 POINT (0.00000 0.00000) + dtype: geometry + + >>> s2 + 1 POLYGON ((0.50000 0.50000, 1.50000 0.50000, 1.... + 2 POLYGON ((0.00000 0.00000, 2.00000 0.00000, 2.... + 3 LINESTRING (1.00000 1.00000, 1.50000 1.50000) + 4 POINT (0.00000 0.00000) + dtype: geometry + + We can check if each geometry of GeoSeries covers a single + geometry: + + .. image:: ../../../_static/binary_op-03.svg + :align: center + + >>> poly = Polygon([(0, 0), (2, 0), (2, 2), (0, 2)]) + >>> s.covers(poly) + 0 True + 1 False + 2 False + 3 False + dtype: bool + + We can also check two GeoSeries against each other, row by row. + The GeoSeries above have different indices. We can either align both GeoSeries + based on index values and compare elements with the same index using + ``align=True`` or ignore index and compare elements based on their matching + order using ``align=False``: + + .. image:: ../../../_static/binary_op-02.svg + + >>> s.covers(s2, align=True) + 0 False + 1 False + 2 False + 3 False + 4 False + dtype: bool + + >>> s.covers(s2, align=False) + 0 True + 1 False + 2 True + 3 True + dtype: bool + + Notes + ----- + This method works in a row-wise manner. It does not check if an element + of one GeoSeries ``covers`` *any* element of the other one. + + See also + -------- + GeoSeries.covered_by + GeoSeries.overlaps + """ + return _binary_op("covers", self, other, align) + + def covered_by(self, other, align=True): """ Returns a ``Series`` of ``dtype('bool')`` with value ``True`` for - each geometry that is entirely covered by `other`. + each aligned geometry that is entirely covered by `other`. An object A is said to cover another object B if no points of B lie in the exterior of A. + The operation works on a 1-to-1 row-wise manner: + + .. image:: ../../../_static/binary_op-01.svg + :align: center + See https://lin-ear-th-inking.blogspot.com/2007/06/subtleties-of-ogc-covers-spatial.html for reference. @@ -492,74 +1892,649 @@ class GeoPandasBase(object): ---------- other : Geoseries or geometric object The Geoseries (elementwise) or geometric object to check is being covered. - """ - return _binary_geo("covered_by", self, other) + align : bool (default True) + If True, automatically aligns GeoSeries based on their indices. + If False, the order of elements is preserved. - def distance(self, other): - """Returns a ``Series`` containing the distance to `other`. + Returns + ------- + Series (bool) + + Examples + -------- + >>> from shapely.geometry import Polygon, LineString, Point + >>> s = geopandas.GeoSeries( + ... [ + ... Polygon([(0.5, 0.5), (1.5, 0.5), (1.5, 1.5), (0.5, 1.5)]), + ... Polygon([(0, 0), (2, 0), (2, 2), (0, 2)]), + ... LineString([(1, 1), (1.5, 1.5)]), + ... Point(0, 0), + ... ], + ... ) + >>> s2 = geopandas.GeoSeries( + ... [ + ... Polygon([(0, 0), (2, 0), (2, 2), (0, 2)]), + ... Polygon([(0, 0), (2, 2), (0, 2)]), + ... LineString([(0, 0), (2, 2)]), + ... Point(0, 0), + ... ], + ... index=range(1, 5), + ... ) + + >>> s + 0 POLYGON ((0.50000 0.50000, 1.50000 0.50000, 1.... + 1 POLYGON ((0.00000 0.00000, 2.00000 0.00000, 2.... + 2 LINESTRING (1.00000 1.00000, 1.50000 1.50000) + 3 POINT (0.00000 0.00000) + dtype: geometry + + >>> s2 + 1 POLYGON ((0.00000 0.00000, 2.00000 0.00000, 2.... + 2 POLYGON ((0.00000 0.00000, 2.00000 2.00000, 0.... + 3 LINESTRING (0.00000 0.00000, 2.00000 2.00000) + 4 POINT (0.00000 0.00000) + dtype: geometry + + We can check if each geometry of GeoSeries is covered by a single + geometry: + + .. image:: ../../../_static/binary_op-03.svg + :align: center + + >>> poly = Polygon([(0, 0), (2, 0), (2, 2), (0, 2)]) + >>> s.covered_by(poly) + 0 True + 1 True + 2 True + 3 True + dtype: bool + + We can also check two GeoSeries against each other, row by row. + The GeoSeries above have different indices. We can either align both GeoSeries + based on index values and compare elements with the same index using + ``align=True`` or ignore index and compare elements based on their matching + order using ``align=False``: + + .. image:: ../../../_static/binary_op-02.svg + + >>> s.covered_by(s2, align=True) + 0 False + 1 True + 2 True + 3 True + 4 False + dtype: bool + + >>> s.covered_by(s2, align=False) + 0 True + 1 False + 2 True + 3 True + dtype: bool + + Notes + ----- + This method works in a row-wise manner. It does not check if an element + of one GeoSeries is ``covered_by`` *any* element of the other one. + + See also + -------- + GeoSeries.covers + GeoSeries.overlaps + """ + return _binary_op("covered_by", self, other, align) + + def distance(self, other, align=True): + """Returns a ``Series`` containing the distance to aligned `other`. + + The operation works on a 1-to-1 row-wise manner: + + .. image:: ../../../_static/binary_op-01.svg + :align: center Parameters ---------- other : Geoseries or geometric object The Geoseries (elementwise) or geometric object to find the distance to. + align : bool (default True) + If True, automatically aligns GeoSeries based on their indices. + If False, the order of elements is preserved. + + + Returns + ------- + Series (float) + + Examples + -------- + >>> from shapely.geometry import Polygon, LineString, Point + >>> s = geopandas.GeoSeries( + ... [ + ... Polygon([(0, 0), (1, 0), (1, 1)]), + ... Polygon([(0, 0), (-1, 0), (-1, 1)]), + ... LineString([(1, 1), (0, 0)]), + ... Point(0, 0), + ... ], + ... ) + >>> s2 = geopandas.GeoSeries( + ... [ + ... Polygon([(0.5, 0.5), (1.5, 0.5), (1.5, 1.5), (0.5, 1.5)]), + ... Point(3, 1), + ... LineString([(1, 0), (2, 0)]), + ... Point(0, 1), + ... ], + ... index=range(1, 5), + ... ) + + >>> s + 0 POLYGON ((0.00000 0.00000, 1.00000 0.00000, 1.... + 1 POLYGON ((0.00000 0.00000, -1.00000 0.00000, -... + 2 LINESTRING (1.00000 1.00000, 0.00000 0.00000) + 3 POINT (0.00000 0.00000) + dtype: geometry + + >>> s2 + 1 POLYGON ((0.50000 0.50000, 1.50000 0.50000, 1.... + 2 POINT (3.00000 1.00000) + 3 LINESTRING (1.00000 0.00000, 2.00000 0.00000) + 4 POINT (0.00000 1.00000) + dtype: geometry + + We can check the distance of each geometry of GeoSeries to a single + geometry: + + .. image:: ../../../_static/binary_op-03.svg + :align: center + + >>> point = Point(-1, 0) + >>> s.distance(point) + 0 1.0 + 1 0.0 + 2 1.0 + 3 1.0 + dtype: float64 + + We can also check two GeoSeries against each other, row by row. + The GeoSeries above have different indices. We can either align both GeoSeries + based on index values and use elements with the same index using + ``align=True`` or ignore index and use elements based on their matching + order using ``align=False``: + + .. image:: ../../../_static/binary_op-02.svg + + >>> s.distance(s2, align=True) + 0 NaN + 1 0.707107 + 2 2.000000 + 3 1.000000 + 4 NaN + dtype: float64 + + >>> s.distance(s2, align=False) + 0 0.000000 + 1 3.162278 + 2 0.707107 + 3 1.000000 + dtype: float64 """ - return _binary_op("distance", self, other) + return _binary_op("distance", self, other, align) # # Binary operations that return a GeoSeries # - def difference(self, other): - """Returns a ``GeoSeries`` of the points in each geometry that + def difference(self, other, align=True): + """Returns a ``GeoSeries`` of the points in each aligned geometry that are not in `other`. + .. image:: ../../../_static/binary_geo-difference.svg + :align: center + + The operation works on a 1-to-1 row-wise manner: + + .. image:: ../../../_static/binary_op-01.svg + :align: center + Parameters ---------- other : Geoseries or geometric object The Geoseries (elementwise) or geometric object to find the difference to. - """ - return _binary_geo("difference", self, other) + align : bool (default True) + If True, automatically aligns GeoSeries based on their indices. + If False, the order of elements is preserved. - def symmetric_difference(self, other): + Returns + ------- + GeoSeries + + Examples + -------- + >>> from shapely.geometry import Polygon, LineString, Point + >>> s = geopandas.GeoSeries( + ... [ + ... Polygon([(0, 0), (2, 2), (0, 2)]), + ... Polygon([(0, 0), (2, 2), (0, 2)]), + ... LineString([(0, 0), (2, 2)]), + ... LineString([(2, 0), (0, 2)]), + ... Point(0, 1), + ... ], + ... ) + >>> s2 = geopandas.GeoSeries( + ... [ + ... Polygon([(0, 0), (1, 1), (0, 1)]), + ... LineString([(1, 0), (1, 3)]), + ... LineString([(2, 0), (0, 2)]), + ... Point(1, 1), + ... Point(0, 1), + ... ], + ... index=range(1, 6), + ... ) + + >>> s + 0 POLYGON ((0.00000 0.00000, 2.00000 2.00000, 0.... + 1 POLYGON ((0.00000 0.00000, 2.00000 2.00000, 0.... + 2 LINESTRING (0.00000 0.00000, 2.00000 2.00000) + 3 LINESTRING (2.00000 0.00000, 0.00000 2.00000) + 4 POINT (0.00000 1.00000) + dtype: geometry + + >>> s2 + 1 POLYGON ((0.00000 0.00000, 1.00000 1.00000, 0.... + 2 LINESTRING (1.00000 0.00000, 1.00000 3.00000) + 3 LINESTRING (2.00000 0.00000, 0.00000 2.00000) + 4 POINT (1.00000 1.00000) + 5 POINT (0.00000 1.00000) + dtype: geometry + + We can do difference of each geometry and a single + shapely geometry: + + .. image:: ../../../_static/binary_op-03.svg + :align: center + + >>> s.difference(Polygon([(0, 0), (1, 1), (0, 1)])) + 0 POLYGON ((0.00000 2.00000, 2.00000 2.00000, 1.... + 1 POLYGON ((0.00000 2.00000, 2.00000 2.00000, 1.... + 2 LINESTRING (1.00000 1.00000, 2.00000 2.00000) + 3 MULTILINESTRING ((2.00000 0.00000, 1.00000 1.0... + 4 POINT EMPTY + dtype: geometry + + We can also check two GeoSeries against each other, row by row. + The GeoSeries above have different indices. We can either align both GeoSeries + based on index values and compare elements with the same index using + ``align=True`` or ignore index and compare elements based on their matching + order using ``align=False``: + + .. image:: ../../../_static/binary_op-02.svg + + >>> s.difference(s2, align=True) + 0 None + 1 POLYGON ((0.00000 2.00000, 2.00000 2.00000, 1.... + 2 MULTILINESTRING ((0.00000 0.00000, 1.00000 1.0... + 3 LINESTRING EMPTY + 4 POINT (0.00000 1.00000) + 5 None + dtype: geometry + + >>> s.difference(s2, align=False) + 0 POLYGON ((0.00000 2.00000, 2.00000 2.00000, 1.... + 1 POLYGON ((0.00000 0.00000, 0.00000 2.00000, 1.... + 2 MULTILINESTRING ((0.00000 0.00000, 1.00000 1.0... + 3 LINESTRING (2.00000 0.00000, 0.00000 2.00000) + 4 POINT EMPTY + dtype: geometry + + See Also + -------- + GeoSeries.symmetric_difference + GeoSeries.union + GeoSeries.intersection + """ + return _binary_geo("difference", self, other, align) + + def symmetric_difference(self, other, align=True): """Returns a ``GeoSeries`` of the symmetric difference of points in - each geometry with `other`. + each aligned geometry with `other`. For each geometry, the symmetric difference consists of points in the geometry not in `other`, and points in `other` not in the geometry. + .. image:: ../../../_static/binary_geo-symm_diff.svg + :align: center + + The operation works on a 1-to-1 row-wise manner: + + .. image:: ../../../_static/binary_op-01.svg + :align: center + + Parameters ---------- other : Geoseries or geometric object The Geoseries (elementwise) or geometric object to find the symmetric difference to. - """ - return _binary_geo("symmetric_difference", self, other) + align : bool (default True) + If True, automatically aligns GeoSeries based on their indices. + If False, the order of elements is preserved. - def union(self, other): - """Returns a ``GeoSeries`` of the union of points in each geometry with + Returns + ------- + GeoSeries + + Examples + -------- + >>> from shapely.geometry import Polygon, LineString, Point + >>> s = geopandas.GeoSeries( + ... [ + ... Polygon([(0, 0), (2, 2), (0, 2)]), + ... Polygon([(0, 0), (2, 2), (0, 2)]), + ... LineString([(0, 0), (2, 2)]), + ... LineString([(2, 0), (0, 2)]), + ... Point(0, 1), + ... ], + ... ) + >>> s2 = geopandas.GeoSeries( + ... [ + ... Polygon([(0, 0), (1, 1), (0, 1)]), + ... LineString([(1, 0), (1, 3)]), + ... LineString([(2, 0), (0, 2)]), + ... Point(1, 1), + ... Point(0, 1), + ... ], + ... index=range(1, 6), + ... ) + + >>> s + 0 POLYGON ((0.00000 0.00000, 2.00000 2.00000, 0.... + 1 POLYGON ((0.00000 0.00000, 2.00000 2.00000, 0.... + 2 LINESTRING (0.00000 0.00000, 2.00000 2.00000) + 3 LINESTRING (2.00000 0.00000, 0.00000 2.00000) + 4 POINT (0.00000 1.00000) + dtype: geometry + + >>> s2 + 1 POLYGON ((0.00000 0.00000, 1.00000 1.00000, 0.... + 2 LINESTRING (1.00000 0.00000, 1.00000 3.00000) + 3 LINESTRING (2.00000 0.00000, 0.00000 2.00000) + 4 POINT (1.00000 1.00000) + 5 POINT (0.00000 1.00000) + dtype: geometry + + We can do symmetric difference of each geometry and a single + shapely geometry: + + .. image:: ../../../_static/binary_op-03.svg + :align: center + + >>> s.symmetric_difference(Polygon([(0, 0), (1, 1), (0, 1)])) + 0 POLYGON ((0.00000 2.00000, 2.00000 2.00000, 1.... + 1 POLYGON ((0.00000 2.00000, 2.00000 2.00000, 1.... + 2 GEOMETRYCOLLECTION (POLYGON ((0.00000 0.00000,... + 3 GEOMETRYCOLLECTION (POLYGON ((0.00000 0.00000,... + 4 POLYGON ((0.00000 1.00000, 1.00000 1.00000, 0.... + dtype: geometry + + We can also check two GeoSeries against each other, row by row. + The GeoSeries above have different indices. We can either align both GeoSeries + based on index values and compare elements with the same index using + ``align=True`` or ignore index and compare elements based on their matching + order using ``align=False``: + + .. image:: ../../../_static/binary_op-02.svg + + >>> s.symmetric_difference(s2, align=True) + 0 None + 1 POLYGON ((0.00000 2.00000, 2.00000 2.00000, 1.... + 2 MULTILINESTRING ((0.00000 0.00000, 1.00000 1.0... + 3 LINESTRING EMPTY + 4 MULTIPOINT (0.00000 1.00000, 1.00000 1.00000) + 5 None + dtype: geometry + + >>> s.symmetric_difference(s2, align=False) + 0 POLYGON ((0.00000 2.00000, 2.00000 2.00000, 1.... + 1 GEOMETRYCOLLECTION (POLYGON ((0.00000 0.00000,... + 2 MULTILINESTRING ((0.00000 0.00000, 1.00000 1.0... + 3 LINESTRING (2.00000 0.00000, 0.00000 2.00000) + 4 POINT EMPTY + dtype: geometry + + See Also + -------- + GeoSeries.difference + GeoSeries.union + GeoSeries.intersection + """ + return _binary_geo("symmetric_difference", self, other, align) + + def union(self, other, align=True): + """Returns a ``GeoSeries`` of the union of points in each aligned geometry with `other`. + .. image:: ../../../_static/binary_geo-union.svg + :align: center + + The operation works on a 1-to-1 row-wise manner: + + .. image:: ../../../_static/binary_op-01.svg + :align: center + + Parameters ---------- other : Geoseries or geometric object The Geoseries (elementwise) or geometric object to find the union with. - """ - return _binary_geo("union", self, other) + align : bool (default True) + If True, automatically aligns GeoSeries based on their indices. + If False, the order of elements is preserved. - def intersection(self, other): + Returns + ------- + GeoSeries + + Examples + -------- + >>> from shapely.geometry import Polygon, LineString, Point + >>> s = geopandas.GeoSeries( + ... [ + ... Polygon([(0, 0), (2, 2), (0, 2)]), + ... Polygon([(0, 0), (2, 2), (0, 2)]), + ... LineString([(0, 0), (2, 2)]), + ... LineString([(2, 0), (0, 2)]), + ... Point(0, 1), + ... ], + ... ) + >>> s2 = geopandas.GeoSeries( + ... [ + ... Polygon([(0, 0), (1, 1), (0, 1)]), + ... LineString([(1, 0), (1, 3)]), + ... LineString([(2, 0), (0, 2)]), + ... Point(1, 1), + ... Point(0, 1), + ... ], + ... index=range(1, 6), + ... ) + + >>> s + 0 POLYGON ((0.00000 0.00000, 2.00000 2.00000, 0.... + 1 POLYGON ((0.00000 0.00000, 2.00000 2.00000, 0.... + 2 LINESTRING (0.00000 0.00000, 2.00000 2.00000) + 3 LINESTRING (2.00000 0.00000, 0.00000 2.00000) + 4 POINT (0.00000 1.00000) + dtype: geometry + + >>> s2 + 1 POLYGON ((0.00000 0.00000, 1.00000 1.00000, 0.... + 2 LINESTRING (1.00000 0.00000, 1.00000 3.00000) + 3 LINESTRING (2.00000 0.00000, 0.00000 2.00000) + 4 POINT (1.00000 1.00000) + 5 POINT (0.00000 1.00000) + dtype: geometry + + We can do union of each geometry and a single + shapely geometry: + + .. image:: ../../../_static/binary_op-03.svg + :align: center + + >>> s.union(Polygon([(0, 0), (1, 1), (0, 1)])) + 0 POLYGON ((0.00000 0.00000, 0.00000 1.00000, 0.... + 1 POLYGON ((0.00000 0.00000, 0.00000 1.00000, 0.... + 2 GEOMETRYCOLLECTION (POLYGON ((0.00000 0.00000,... + 3 GEOMETRYCOLLECTION (POLYGON ((0.00000 0.00000,... + 4 POLYGON ((0.00000 1.00000, 1.00000 1.00000, 0.... + dtype: geometry + + We can also check two GeoSeries against each other, row by row. + The GeoSeries above have different indices. We can either align both GeoSeries + based on index values and compare elements with the same index using + ``align=True`` or ignore index and compare elements based on their matching + order using ``align=False``: + + .. image:: ../../../_static/binary_op-02.svg + + >>> s.union(s2, align=True) + 0 None + 1 POLYGON ((0.00000 0.00000, 0.00000 1.00000, 0.... + 2 MULTILINESTRING ((0.00000 0.00000, 1.00000 1.0... + 3 LINESTRING (2.00000 0.00000, 0.00000 2.00000) + 4 MULTIPOINT (0.00000 1.00000, 1.00000 1.00000) + 5 None + dtype: geometry + + >>> s.union(s2, align=False) + 0 POLYGON ((0.00000 0.00000, 0.00000 1.00000, 0.... + 1 GEOMETRYCOLLECTION (POLYGON ((0.00000 0.00000,... + 2 MULTILINESTRING ((0.00000 0.00000, 1.00000 1.0... + 3 LINESTRING (2.00000 0.00000, 0.00000 2.00000) + 4 POINT (0.00000 1.00000) + dtype: geometry + + + See Also + -------- + GeoSeries.symmetric_difference + GeoSeries.difference + GeoSeries.intersection + """ + return _binary_geo("union", self, other, align) + + def intersection(self, other, align=True): """Returns a ``GeoSeries`` of the intersection of points in each - geometry with `other`. + aligned geometry with `other`. + + .. image:: ../../../_static/binary_geo-intersection.svg + :align: center + + The operation works on a 1-to-1 row-wise manner: + + .. image:: ../../../_static/binary_op-01.svg + :align: center + Parameters ---------- other : Geoseries or geometric object The Geoseries (elementwise) or geometric object to find the intersection with. + align : bool (default True) + If True, automatically aligns GeoSeries based on their indices. + If False, the order of elements is preserved. + + Returns + ------- + GeoSeries + + Examples + -------- + >>> from shapely.geometry import Polygon, LineString, Point + >>> s = geopandas.GeoSeries( + ... [ + ... Polygon([(0, 0), (2, 2), (0, 2)]), + ... Polygon([(0, 0), (2, 2), (0, 2)]), + ... LineString([(0, 0), (2, 2)]), + ... LineString([(2, 0), (0, 2)]), + ... Point(0, 1), + ... ], + ... ) + >>> s2 = geopandas.GeoSeries( + ... [ + ... Polygon([(0, 0), (1, 1), (0, 1)]), + ... LineString([(1, 0), (1, 3)]), + ... LineString([(2, 0), (0, 2)]), + ... Point(1, 1), + ... Point(0, 1), + ... ], + ... index=range(1, 6), + ... ) + + >>> s + 0 POLYGON ((0.00000 0.00000, 2.00000 2.00000, 0.... + 1 POLYGON ((0.00000 0.00000, 2.00000 2.00000, 0.... + 2 LINESTRING (0.00000 0.00000, 2.00000 2.00000) + 3 LINESTRING (2.00000 0.00000, 0.00000 2.00000) + 4 POINT (0.00000 1.00000) + dtype: geometry + + >>> s2 + 1 POLYGON ((0.00000 0.00000, 1.00000 1.00000, 0.... + 2 LINESTRING (1.00000 0.00000, 1.00000 3.00000) + 3 LINESTRING (2.00000 0.00000, 0.00000 2.00000) + 4 POINT (1.00000 1.00000) + 5 POINT (0.00000 1.00000) + dtype: geometry + + We can also do intersection of each geometry and a single + shapely geometry: + + .. image:: ../../../_static/binary_op-03.svg + :align: center + + >>> s.intersection(Polygon([(0, 0), (1, 1), (0, 1)])) + 0 POLYGON ((0.00000 0.00000, 0.00000 1.00000, 1.... + 1 POLYGON ((0.00000 0.00000, 0.00000 1.00000, 1.... + 2 LINESTRING (0.00000 0.00000, 1.00000 1.00000) + 3 POINT (1.00000 1.00000) + 4 POINT (0.00000 1.00000) + dtype: geometry + + We can also check two GeoSeries against each other, row by row. + The GeoSeries above have different indices. We can either align both GeoSeries + based on index values and compare elements with the same index using + ``align=True`` or ignore index and compare elements based on their matching + order using ``align=False``: + + .. image:: ../../../_static/binary_op-02.svg + + >>> s.intersection(s2, align=True) + 0 None + 1 POLYGON ((0.00000 0.00000, 0.00000 1.00000, 1.... + 2 POINT (1.00000 1.00000) + 3 LINESTRING (2.00000 0.00000, 0.00000 2.00000) + 4 POINT EMPTY + 5 None + dtype: geometry + + >>> s.intersection(s2, align=False) + 0 POLYGON ((0.00000 0.00000, 0.00000 1.00000, 1.... + 1 LINESTRING (1.00000 1.00000, 1.00000 2.00000) + 2 POINT (1.00000 1.00000) + 3 POINT (1.00000 1.00000) + 4 POINT (0.00000 1.00000) + dtype: geometry + + + See Also + -------- + GeoSeries.difference + GeoSeries.symmetric_difference + GeoSeries.union """ - return _binary_geo("intersection", self, other) + return _binary_geo("intersection", self, other, align) # # Other operations @@ -571,6 +2546,18 @@ class GeoPandasBase(object): ``maxy`` values containing the bounds for each geometry. See ``GeoSeries.total_bounds`` for the limits of the entire series. + + Examples + -------- + >>> from shapely.geometry import Point, Polygon, LineString + >>> d = {'geometry': [Point(2, 1), Polygon([(0, 0), (1, 1), (1, 0)]), + ... LineString([(0, 1), (1, 2)])]} + >>> gdf = geopandas.GeoDataFrame(d, crs="EPSG:4326") + >>> gdf.bounds + minx miny maxx maxy + 0 2.0 1.0 2.0 1.0 + 1 0.0 0.0 1.0 1.0 + 2 0.0 1.0 1.0 2.0 """ bounds = GeometryArray(self.geometry.values).bounds return DataFrame( @@ -584,18 +2571,106 @@ class GeoPandasBase(object): See ``GeoSeries.bounds`` for the bounds of the geometries contained in the series. + + Examples + -------- + >>> from shapely.geometry import Point, Polygon, LineString + >>> d = {'geometry': [Point(3, -1), Polygon([(0, 0), (1, 1), (1, 0)]), + ... LineString([(0, 1), (1, 2)])]} + >>> gdf = geopandas.GeoDataFrame(d, crs="EPSG:4326") + >>> gdf.total_bounds + array([ 0., -1., 3., 2.]) """ return GeometryArray(self.geometry.values).total_bounds @property def sindex(self): - if not self._sindex_generated: - self._generate_sindex() - return self._sindex + """Generate the spatial index + + Creates R-tree spatial index based on ``pygeos.STRtree`` or + ``rtree.index.Index``. + + Note that the spatial index may not be fully + initialized until the first use. + + Examples + -------- + >>> from shapely.geometry import box + >>> s = geopandas.GeoSeries(geopandas.points_from_xy(range(5), range(5))) + >>> s + 0 POINT (0.00000 0.00000) + 1 POINT (1.00000 1.00000) + 2 POINT (2.00000 2.00000) + 3 POINT (3.00000 3.00000) + 4 POINT (4.00000 4.00000) + dtype: geometry + + Query the spatial index with a single geometry based on the bounding box: + + >>> s.sindex.query(box(1, 1, 3, 3)) + array([1, 2, 3]) + + Query the spatial index with a single geometry based on the predicate: + + >>> s.sindex.query(box(1, 1, 3, 3), predicate="contains") + array([2]) + + Query the spatial index with an array of geometries based on the bounding + box: + + >>> s2 = geopandas.GeoSeries([box(1, 1, 3, 3), box(4, 4, 5, 5)]) + >>> s2 + 0 POLYGON ((3.00000 1.00000, 3.00000 3.00000, 1.... + 1 POLYGON ((5.00000 4.00000, 5.00000 5.00000, 4.... + dtype: geometry + + >>> s.sindex.query_bulk(s2) + array([[0, 0, 0, 1], + [1, 2, 3, 4]]) + + Query the spatial index with an array of geometries based on the predicate: + + >>> s.sindex.query_bulk(s2, predicate="contains") + array([[0], + [2]]) + """ + return self.geometry.values.sindex + + @property + def has_sindex(self): + """Check the existence of the spatial index without generating it. + + Use the `.sindex` attribute on a GeoDataFrame or GeoSeries + to generate a spatial index if it does not yet exist, + which may take considerable time based on the underlying index + implementation. + + Note that the underlying spatial index may not be fully + initialized until the first use. + + Examples + -------- + + >>> from shapely.geometry import Point + >>> d = {'geometry': [Point(1, 2), Point(2, 1)]} + >>> gdf = geopandas.GeoDataFrame(d) + >>> gdf.has_sindex + False + >>> index = gdf.sindex + >>> gdf.has_sindex + True + + Returns + ------- + bool + `True` if the spatial index has been generated or + `False` if not. + """ + return self.geometry.values.has_sindex def buffer(self, distance, resolution=16, **kwargs): """Returns a ``GeoSeries`` of geometries representing all points within - a given `distance` of each geometric object. + a given ``distance`` of each geometric object. See http://shapely.readthedocs.io/en/latest/manual.html#object.buffer for details. @@ -605,9 +2680,38 @@ class GeoPandasBase(object): distance : float, np.array, pd.Series The radius of the buffer. If np.array or pd.Series are used then it must have same length as the GeoSeries. - resolution: int - Optional, the resolution of the buffer around each vertex. + resolution : int (optional, default 16) + The resolution of the buffer around each vertex. + + Examples + -------- + >>> from shapely.geometry import Point, LineString, Polygon + >>> s = geopandas.GeoSeries( + ... [ + ... Point(0, 0), + ... LineString([(1, -1), (1, 0), (2, 0), (2, 1)]), + ... Polygon([(3, -1), (4, 0), (3, 1)]), + ... ] + ... ) + >>> s + 0 POINT (0.00000 0.00000) + 1 LINESTRING (1.00000 -1.00000, 1.00000 0.00000,... + 2 POLYGON ((3.00000 -1.00000, 4.00000 0.00000, 3... + dtype: geometry + + >>> s.buffer(0.2) + 0 POLYGON ((0.20000 0.00000, 0.19904 -0.01960, 0... + 1 POLYGON ((0.80000 0.00000, 0.80096 0.01960, 0.... + 2 POLYGON ((2.80000 -1.00000, 2.80000 1.00000, 2... + dtype: geometry + + ``**kwargs`` accept further specification as ``join_style`` and ``cap_style``. + See the following illustration of different options. + + .. plot:: _static/code/buffer.py + """ + # TODO: update docstring based on pygeos after shapely 2.0 if isinstance(distance, pd.Series): if not self.index.equals(distance.index): raise ValueError( @@ -624,42 +2728,169 @@ class GeoPandasBase(object): """Returns a ``GeoSeries`` containing a simplified representation of each geometry. + The algorithm (Douglas-Peucker) recursively splits the original line + into smaller parts and connects these parts’ endpoints + by a straight line. Then, it removes all points whose distance + to the straight line is smaller than `tolerance`. It does not + move any points and it always preserves endpoints of + the original line or polygon. See http://shapely.readthedocs.io/en/latest/manual.html#object.simplify for details Parameters ---------- tolerance : float - All points in a simplified geometry will be no more than - `tolerance` distance from the original. - preserve_topology: bool + All parts of a simplified geometry will be no more than + `tolerance` distance from the original. It has the same units + as the coordinate reference system of the GeoSeries. + For example, using `tolerance=100` in a projected CRS with meters + as units means a distance of 100 meters in reality. + preserve_topology: bool (default True) False uses a quicker algorithm, but may produce self-intersecting or otherwise invalid geometries. + + Notes + ----- + Invalid geometric objects may result from simplification that does not + preserve topology and simplification may be sensitive to the order of + coordinates: two geometries differing only in order of coordinates may be + simplified differently. + + Examples + -------- + >>> from shapely.geometry import Point, LineString + >>> s = geopandas.GeoSeries( + ... [Point(0, 0).buffer(1), LineString([(0, 0), (1, 10), (0, 20)])] + ... ) + >>> s + 0 POLYGON ((1.00000 0.00000, 0.99518 -0.09802, 0... + 1 LINESTRING (0.00000 0.00000, 1.00000 10.00000,... + dtype: geometry + + >>> s.simplify(1) + 0 POLYGON ((1.00000 0.00000, 0.00000 -1.00000, -... + 1 LINESTRING (0.00000 0.00000, 0.00000 20.00000) + dtype: geometry """ return _delegate_geo_method("simplify", self, *args, **kwargs) - def relate(self, other): + def relate(self, other, align=True): """ Returns the DE-9IM intersection matrices for the geometries + The operation works on a 1-to-1 row-wise manner: + + .. image:: ../../../_static/binary_op-01.svg + :align: center + Parameters ---------- other : BaseGeometry or GeoSeries The other geometry to computed the DE-9IM intersection matrices from. + align : bool (default True) + If True, automatically aligns GeoSeries based on their indices. + If False, the order of elements is preserved. Returns ---------- spatial_relations: Series of strings The DE-9IM intersection matrices which describe the spatial relations of the other geometry. - """ - return _binary_op("relate", self, other) - def project(self, other, normalized=False): + Examples + -------- + >>> from shapely.geometry import Polygon, LineString, Point + >>> s = geopandas.GeoSeries( + ... [ + ... Polygon([(0, 0), (2, 2), (0, 2)]), + ... Polygon([(0, 0), (2, 2), (0, 2)]), + ... LineString([(0, 0), (2, 2)]), + ... LineString([(2, 0), (0, 2)]), + ... Point(0, 1), + ... ], + ... ) + >>> s2 = geopandas.GeoSeries( + ... [ + ... Polygon([(0, 0), (1, 1), (0, 1)]), + ... LineString([(1, 0), (1, 3)]), + ... LineString([(2, 0), (0, 2)]), + ... Point(1, 1), + ... Point(0, 1), + ... ], + ... index=range(1, 6), + ... ) + + >>> s + 0 POLYGON ((0.00000 0.00000, 2.00000 2.00000, 0.... + 1 POLYGON ((0.00000 0.00000, 2.00000 2.00000, 0.... + 2 LINESTRING (0.00000 0.00000, 2.00000 2.00000) + 3 LINESTRING (2.00000 0.00000, 0.00000 2.00000) + 4 POINT (0.00000 1.00000) + dtype: geometry + + >>> s2 + 1 POLYGON ((0.00000 0.00000, 1.00000 1.00000, 0.... + 2 LINESTRING (1.00000 0.00000, 1.00000 3.00000) + 3 LINESTRING (2.00000 0.00000, 0.00000 2.00000) + 4 POINT (1.00000 1.00000) + 5 POINT (0.00000 1.00000) + dtype: geometry + + We can relate each geometry and a single + shapely geometry: + + .. image:: ../../../_static/binary_op-03.svg + :align: center + + >>> s.relate(Polygon([(0, 0), (1, 1), (0, 1)])) + 0 212F11FF2 + 1 212F11FF2 + 2 F11F00212 + 3 F01FF0212 + 4 F0FFFF212 + dtype: object + + We can also check two GeoSeries against each other, row by row. + The GeoSeries above have different indices. We can either align both GeoSeries + based on index values and compare elements with the same index using + ``align=True`` or ignore index and compare elements based on their matching + order using ``align=False``: + + .. image:: ../../../_static/binary_op-02.svg + + >>> s.relate(s2, align=True) + 0 None + 1 212F11FF2 + 2 0F1FF0102 + 3 1FFF0FFF2 + 4 FF0FFF0F2 + 5 None + dtype: object + + >>> s.relate(s2, align=False) + 0 212F11FF2 + 1 1F20F1102 + 2 0F1FF0102 + 3 0F1FF0FF2 + 4 0FFFFFFF2 + dtype: object + + """ + return _binary_op("relate", self, other, align) + + def project(self, other, normalized=False, align=True): """ Return the distance along each geometry nearest to *other* + The operation works on a 1-to-1 row-wise manner: + + .. image:: ../../../_static/binary_op-01.svg + :align: center + + The project method is the inverse of interpolate. + + Parameters ---------- other : BaseGeometry or GeoSeries @@ -667,10 +2898,83 @@ class GeoPandasBase(object): normalized : boolean If normalized is True, return the distance normalized to the length of the object. + align : bool (default True) + If True, automatically aligns GeoSeries based on their indices. + If False, the order of elements is preserved. - The project method is the inverse of interpolate. + Returns + ------- + Series + + Examples + -------- + >>> from shapely.geometry import LineString, Point + >>> s = geopandas.GeoSeries( + ... [ + ... LineString([(0, 0), (2, 0), (0, 2)]), + ... LineString([(0, 0), (2, 2)]), + ... LineString([(2, 0), (0, 2)]), + ... ], + ... ) + >>> s2 = geopandas.GeoSeries( + ... [ + ... Point(1, 0), + ... Point(1, 0), + ... Point(2, 1), + ... ], + ... index=range(1, 4), + ... ) + + >>> s + 0 LINESTRING (0.00000 0.00000, 2.00000 0.00000, ... + 1 LINESTRING (0.00000 0.00000, 2.00000 2.00000) + 2 LINESTRING (2.00000 0.00000, 0.00000 2.00000) + dtype: geometry + + >>> s2 + 1 POINT (1.00000 0.00000) + 2 POINT (1.00000 0.00000) + 3 POINT (2.00000 1.00000) + dtype: geometry + + We can project each geometry on a single + shapely geometry: + + .. image:: ../../../_static/binary_op-03.svg + :align: center + + >>> s.project(Point(1, 0)) + 0 1.000000 + 1 0.707107 + 2 0.707107 + dtype: float64 + + We can also check two GeoSeries against each other, row by row. + The GeoSeries above have different indices. We can either align both GeoSeries + based on index values and project elements with the same index using + ``align=True`` or ignore index and project elements based on their matching + order using ``align=False``: + + .. image:: ../../../_static/binary_op-02.svg + + >>> s.project(s2, align=True) + 0 NaN + 1 0.707107 + 2 0.707107 + 3 NaN + dtype: float64 + + >>> s.project(s2, align=False) + 0 1.000000 + 1 0.707107 + 2 0.707107 + dtype: float64 + + See also + -------- + GeoSeries.interpolate """ - return _binary_op("project", self, other, normalized=normalized) + return _binary_op("project", self, other, normalized=normalized, align=align) def interpolate(self, distance, normalized=False): """ @@ -707,10 +3011,35 @@ class GeoPandasBase(object): ---------- matrix: List or tuple 6 or 12 items for 2D or 3D transformations respectively. + For 2D affine transformations, - the 6 parameter matrix is [a, b, d, e, xoff, yoff] + the 6 parameter matrix is ``[a, b, d, e, xoff, yoff]`` + For 3D affine transformations, - the 12 parameter matrix is [a, b, c, d, e, f, g, h, i, xoff, yoff, zoff] + the 12 parameter matrix is ``[a, b, c, d, e, f, g, h, i, xoff, yoff, zoff]`` + + Examples + -------- + >>> from shapely.geometry import Point, LineString, Polygon + >>> s = geopandas.GeoSeries( + ... [ + ... Point(1, 1), + ... LineString([(1, -1), (1, 0)]), + ... Polygon([(3, -1), (4, 0), (3, 1)]), + ... ] + ... ) + >>> s + 0 POINT (1.00000 1.00000) + 1 LINESTRING (1.00000 -1.00000, 1.00000 0.00000) + 2 POLYGON ((3.00000 -1.00000, 4.00000 0.00000, 3... + dtype: geometry + + >>> s.affine_transform([2, 3, 2, 4, 5, 2]) + 0 POINT (10.00000 8.00000) + 1 LINESTRING (4.00000 0.00000, 7.00000 4.00000) + 2 POLYGON ((8.00000 4.00000, 13.00000 10.00000, ... + dtype: geometry + """ # noqa (E501 link is longer than max line length) return _delegate_geo_method("affine_transform", self, matrix) @@ -726,6 +3055,29 @@ class GeoPandasBase(object): Amount of offset along each dimension. xoff, yoff, and zoff for translation along the x, y, and z dimensions respectively. + + Examples + -------- + >>> from shapely.geometry import Point, LineString, Polygon + >>> s = geopandas.GeoSeries( + ... [ + ... Point(1, 1), + ... LineString([(1, -1), (1, 0)]), + ... Polygon([(3, -1), (4, 0), (3, 1)]), + ... ] + ... ) + >>> s + 0 POINT (1.00000 1.00000) + 1 LINESTRING (1.00000 -1.00000, 1.00000 0.00000) + 2 POLYGON ((3.00000 -1.00000, 4.00000 0.00000, 3... + dtype: geometry + + >>> s.translate(2, 3) + 0 POINT (3.00000 4.00000) + 1 LINESTRING (3.00000 2.00000, 3.00000 3.00000) + 2 POLYGON ((5.00000 2.00000, 6.00000 3.00000, 5.... + dtype: geometry + """ # noqa (E501 link is longer than max line length) return _delegate_geo_method("translate", self, xoff, yoff, zoff) @@ -747,6 +3099,35 @@ class GeoPandasBase(object): object or a coordinate tuple (x, y). use_radians : boolean Whether to interpret the angle of rotation as degrees or radians + + Examples + -------- + >>> from shapely.geometry import Point, LineString, Polygon + >>> s = geopandas.GeoSeries( + ... [ + ... Point(1, 1), + ... LineString([(1, -1), (1, 0)]), + ... Polygon([(3, -1), (4, 0), (3, 1)]), + ... ] + ... ) + >>> s + 0 POINT (1.00000 1.00000) + 1 LINESTRING (1.00000 -1.00000, 1.00000 0.00000) + 2 POLYGON ((3.00000 -1.00000, 4.00000 0.00000, 3... + dtype: geometry + + >>> s.rotate(90) + 0 POINT (1.00000 1.00000) + 1 LINESTRING (1.50000 -0.50000, 0.50000 -0.50000) + 2 POLYGON ((4.50000 -0.50000, 3.50000 0.50000, 2... + dtype: geometry + + >>> s.rotate(90, origin=(0, 0)) + 0 POINT (-1.00000 1.00000) + 1 LINESTRING (1.00000 1.00000, 0.00000 1.00000) + 2 POLYGON ((1.00000 3.00000, 0.00000 4.00000, -1... + dtype: geometry + """ return _delegate_geo_method( "rotate", self, angle, origin=origin, use_radians=use_radians @@ -769,6 +3150,34 @@ class GeoPandasBase(object): The point of origin can be a keyword 'center' for the 2D bounding box center (default), 'centroid' for the geometry's 2D centroid, a Point object or a coordinate tuple (x, y, z). + + Examples + -------- + >>> from shapely.geometry import Point, LineString, Polygon + >>> s = geopandas.GeoSeries( + ... [ + ... Point(1, 1), + ... LineString([(1, -1), (1, 0)]), + ... Polygon([(3, -1), (4, 0), (3, 1)]), + ... ] + ... ) + >>> s + 0 POINT (1.00000 1.00000) + 1 LINESTRING (1.00000 -1.00000, 1.00000 0.00000) + 2 POLYGON ((3.00000 -1.00000, 4.00000 0.00000, 3... + dtype: geometry + + >>> s.scale(2, 3) + 0 POINT (1.00000 1.00000) + 1 LINESTRING (1.00000 -2.00000, 1.00000 1.00000) + 2 POLYGON ((2.50000 -3.00000, 4.50000 0.00000, 2... + dtype: geometry + + >>> s.scale(2, 3, origin=(0, 0)) + 0 POINT (2.00000 3.00000) + 1 LINESTRING (2.00000 -3.00000, 2.00000 0.00000) + 2 POLYGON ((6.00000 -3.00000, 8.00000 0.00000, 6... + dtype: geometry """ return _delegate_geo_method("scale", self, xfact, yfact, zfact, origin=origin) @@ -792,55 +3201,39 @@ class GeoPandasBase(object): object or a coordinate tuple (x, y). use_radians : boolean Whether to interpret the shear angle(s) as degrees or radians + + Examples + -------- + >>> from shapely.geometry import Point, LineString, Polygon + >>> s = geopandas.GeoSeries( + ... [ + ... Point(1, 1), + ... LineString([(1, -1), (1, 0)]), + ... Polygon([(3, -1), (4, 0), (3, 1)]), + ... ] + ... ) + >>> s + 0 POINT (1.00000 1.00000) + 1 LINESTRING (1.00000 -1.00000, 1.00000 0.00000) + 2 POLYGON ((3.00000 -1.00000, 4.00000 0.00000, 3... + dtype: geometry + + >>> s.skew(45, 30) + 0 POINT (1.00000 1.00000) + 1 LINESTRING (0.50000 -1.00000, 1.50000 0.00000) + 2 POLYGON ((2.00000 -1.28868, 4.00000 0.28868, 4... + dtype: geometry + + >>> s.skew(45, 30, origin=(0, 0)) + 0 POINT (2.00000 1.57735) + 1 LINESTRING (0.00000 -0.42265, 1.00000 0.57735) + 2 POLYGON ((2.00000 0.73205, 4.00000 2.30940, 4.... + dtype: geometry """ return _delegate_geo_method( "skew", self, xs, ys, origin=origin, use_radians=use_radians ) - def explode(self): - """ - Explode multi-part geometries into multiple single geometries. - - Single rows can become multiple rows. - This is analogous to PostGIS's ST_Dump(). The 'path' index is the - second level of the returned MultiIndex - - Returns - ------ - A GeoSeries with a MultiIndex. The levels of the MultiIndex are the - original index and a zero-based integer index that counts the - number of single geometries within a multi-part geometry. - - Examples - -------- - >>> gdf # gdf is GeoSeries of MultiPoints - 0 MULTIPOINT (0 0, 1 1) - 1 MULTIPOINT (2 2, 3 3, 4 4) - dtype: geometry - - >>> gdf.explode() - 0 0 POINT (0 0) - 1 POINT (1 1) - 1 0 POINT (2 2) - 1 POINT (3 3) - 2 POINT (4 4) - dtype: geometry - - """ - index = [] - geometries = [] - for idx, s in self.geometry.iteritems(): - if s.type.startswith("Multi") or s.type == "GeometryCollection": - geoms = s.geoms - idxs = [(idx, i) for i in range(len(geoms))] - else: - geoms = [s] - idxs = [(idx, 0)] - index.extend(idxs) - geometries.extend(geoms) - index = MultiIndex.from_tuples(index, names=self.index.names + [None]) - return gpd.GeoSeries(geometries, index=index).__finalize__(self) - @property def cx(self): """ @@ -850,6 +3243,31 @@ class GeoPandasBase(object): ``xmin``, ``xmax``, ``ymin``, and ``ymax`` can be provided, but input must include a comma separating x and y slices. That is, ``.cx[:, :]`` will return the full series/frame, but ``.cx[:]`` is not implemented. + + Examples + -------- + >>> from shapely.geometry import LineString, Point + >>> s = geopandas.GeoSeries( + ... [Point(0, 0), Point(1, 2), Point(3, 3), LineString([(0, 0), (3, 3)])] + ... ) + >>> s + 0 POINT (0.00000 0.00000) + 1 POINT (1.00000 2.00000) + 2 POINT (3.00000 3.00000) + 3 LINESTRING (0.00000 0.00000, 3.00000 3.00000) + dtype: geometry + + >>> s.cx[0:1, 0:1] + 0 POINT (0.00000 0.00000) + 3 LINESTRING (0.00000 0.00000, 3.00000 3.00000) + dtype: geometry + + >>> s.cx[:, 1:] + 1 POINT (1.00000 2.00000) + 2 POINT (3.00000 3.00000) + 3 LINESTRING (0.00000 0.00000, 3.00000 3.00000) + dtype: geometry + """ return _CoordinateIndexer(self) @@ -899,7 +3317,8 @@ class _CoordinateIndexer(object): # don't know how to handle step; should this raise? if xs.step is not None or ys.step is not None: warn("Ignoring step - full interval is used.") - xmin, ymin, xmax, ymax = obj.total_bounds + if xs.start is None or xs.stop is None or ys.start is None or ys.stop is None: + xmin, ymin, xmax, ymax = obj.total_bounds bbox = box( xs.start if xs.start is not None else xmin, ys.start if ys.start is not None else ymin, diff --git a/geopandas/conftest.py b/geopandas/conftest.py new file mode 100644 index 0000000..3ab031c --- /dev/null +++ b/geopandas/conftest.py @@ -0,0 +1,27 @@ +import pytest +import geopandas + + +@pytest.fixture(autouse=True) +def add_geopandas(doctest_namespace): + doctest_namespace["geopandas"] = geopandas + + +def pytest_configure(config): + config.addinivalue_line( + "markers", + "skip_no_sindex: skips the tests if there is no spatial index backend", + ) + + +try: + geopandas.sindex._get_sindex_class() + has_sindex_backend = True +except ImportError: + has_sindex_backend = False + + +def pytest_runtest_setup(item): + skip_no_sindex = any(mark for mark in item.iter_markers(name="skip_no_sindex")) + if skip_no_sindex and not has_sindex_backend: + pytest.skip("Skipped because there is no spatial index backend available") diff --git a/geopandas/datasets/__init__.py b/geopandas/datasets/__init__.py index a592b56..b56d202 100644 --- a/geopandas/datasets/__init__.py +++ b/geopandas/datasets/__init__.py @@ -18,6 +18,12 @@ def get_path(dataset): The name of the dataset. See ``geopandas.datasets.available`` for all options. + Examples + -------- + >>> geopandas.datasets.get_path("naturalearth_lowres") # doctest: +SKIP + '.../python3.8/site-packages/geopandas/datasets/\ +naturalearth_lowres/naturalearth_lowres.shp' + """ if dataset in _available_dir: return os.path.abspath(os.path.join(_module_path, dataset, dataset + ".shp")) diff --git a/geopandas/explore.py b/geopandas/explore.py new file mode 100644 index 0000000..7efab95 --- /dev/null +++ b/geopandas/explore.py @@ -0,0 +1,915 @@ +from statistics import mean + +import geopandas +from shapely.geometry import LineString +import numpy as np +import pandas as pd + +_MAP_KWARGS = [ + "location", + "prefer_canvas", + "no_touch", + "disable_3d", + "png_enabled", + "zoom_control", + "crs", + "zoom_start", + "left", + "top", + "position", + "min_zoom", + "max_zoom", + "min_lat", + "max_lat", + "min_lon", + "max_lon", + "max_bounds", +] + + +def _explore( + df, + column=None, + cmap=None, + color=None, + m=None, + tiles="OpenStreetMap", + attr=None, + tooltip=True, + popup=False, + highlight=True, + categorical=False, + legend=True, + scheme=None, + k=5, + vmin=None, + vmax=None, + width="100%", + height="100%", + categories=None, + classification_kwds=None, + control_scale=True, + marker_type=None, + marker_kwds={}, + style_kwds={}, + highlight_kwds={}, + missing_kwds={}, + tooltip_kwds={}, + popup_kwds={}, + legend_kwds={}, + map_kwds={}, + **kwargs, +): + """Interactive map based on GeoPandas and folium/leaflet.js + + Generate an interactive leaflet map based on :class:`~geopandas.GeoDataFrame` + + Parameters + ---------- + column : str, np.array, pd.Series (default None) + The name of the dataframe column, :class:`numpy.array`, + or :class:`pandas.Series` to be plotted. If :class:`numpy.array` or + :class:`pandas.Series` are used then it must have same length as dataframe. + cmap : str, matplotlib.Colormap, branca.colormap or function (default None) + The name of a colormap recognized by ``matplotlib``, a list-like of colors, + :class:`matplotlib.colors.Colormap`, a :class:`branca.colormap.ColorMap` or + function that returns a named color or hex based on the column + value, e.g.:: + + def my_colormap(value): # scalar value defined in 'column' + if value > 1: + return "green" + return "red" + + color : str, array-like (default None) + Named color or a list-like of colors (named or hex). + m : folium.Map (default None) + Existing map instance on which to draw the plot. + tiles : str, xyzservices.TileProvider (default 'OpenStreetMap Mapnik') + Map tileset to use. Can choose from the list supported by folium, query a + :class:`xyzservices.TileProvider` by a name from ``xyzservices.providers``, + pass :class:`xyzservices.TileProvider` object or pass custom XYZ URL. + The current list of built-in providers (when ``xyzservices`` is not available): + + ``["OpenStreetMap", "Stamen Terrain", “Stamen Toner", “Stamen Watercolor" + "CartoDB positron", “CartoDB dark_matter"]`` + + You can pass a custom tileset to Folium by passing a Leaflet-style URL + to the tiles parameter: ``http://{s}.yourtiles.com/{z}/{x}/{y}.png``. + Be sure to check their terms and conditions and to provide attribution with + the ``attr`` keyword. + attr : str (default None) + Map tile attribution; only required if passing custom tile URL. + tooltip : bool, str, int, list (default True) + Display GeoDataFrame attributes when hovering over the object. + ``True`` includes all columns. ``False`` removes tooltip. Pass string or list of + strings to specify a column(s). Integer specifies first n columns to be + included. Defaults to ``True``. + popup : bool, str, int, list (default False) + Input GeoDataFrame attributes for object displayed when clicking. + ``True`` includes all columns. ``False`` removes popup. Pass string or list of + strings to specify a column(s). Integer specifies first n columns to be + included. Defaults to ``False``. + highlight : bool (default True) + Enable highlight functionality when hovering over a geometry. + categorical : bool (default False) + If ``False``, ``cmap`` will reflect numerical values of the + column being plotted. For non-numerical columns, this + will be set to True. + legend : bool (default True) + Plot a legend in choropleth plots. + Ignored if no ``column`` is given. + scheme : str (default None) + Name of a choropleth classification scheme (requires ``mapclassify`` >= 2.4.0). + A :func:`mapclassify.classify` will be used + under the hood. Supported are all schemes provided by ``mapclassify`` (e.g. + ``'BoxPlot'``, ``'EqualInterval'``, ``'FisherJenks'``, ``'FisherJenksSampled'``, + ``'HeadTailBreaks'``, ``'JenksCaspall'``, ``'JenksCaspallForced'``, + ``'JenksCaspallSampled'``, ``'MaxP'``, ``'MaximumBreaks'``, + ``'NaturalBreaks'``, ``'Quantiles'``, ``'Percentiles'``, ``'StdMean'``, + ``'UserDefined'``). Arguments can be passed in ``classification_kwds``. + k : int (default 5) + Number of classes + vmin : None or float (default None) + Minimum value of ``cmap``. If ``None``, the minimum data value + in the column to be plotted is used. + vmax : None or float (default None) + Maximum value of ``cmap``. If ``None``, the maximum data value + in the column to be plotted is used. + width : pixel int or percentage string (default: '100%') + Width of the folium :class:`~folium.folium.Map`. If the argument + m is given explicitly, width is ignored. + height : pixel int or percentage string (default: '100%') + Height of the folium :class:`~folium.folium.Map`. If the argument + m is given explicitly, height is ignored. + categories : list-like + Ordered list-like object of categories to be used for categorical plot. + classification_kwds : dict (default None) + Keyword arguments to pass to mapclassify + control_scale : bool, (default True) + Whether to add a control scale on the map. + marker_type : str, folium.Circle, folium.CircleMarker, folium.Marker (default None) + Allowed string options are ('marker', 'circle', 'circle_marker'). Defaults to + folium.CircleMarker. + marker_kwds: dict (default {}) + Additional keywords to be passed to the selected ``marker_type``, e.g.: + + radius : float (default 2 for ``circle_marker`` and 50 for ``circle``)) + Radius of the circle, in meters (for ``circle``) or pixels + (for ``circle_marker``). + fill : bool (default True) + Whether to fill the ``circle`` or ``circle_marker`` with color. + icon : folium.map.Icon + the :class:`folium.map.Icon` object to use to render the marker. + draggable : bool (default False) + Set to True to be able to drag the marker around the map. + + style_kwds : dict (default {}) + Additional style to be passed to folium ``style_function``: + + stroke : bool (default True) + Whether to draw stroke along the path. Set it to ``False`` to + disable borders on polygons or circles. + color : str + Stroke color + weight : int + Stroke width in pixels + opacity : float (default 1.0) + Stroke opacity + fill : boolean (default True) + Whether to fill the path with color. Set it to ``False`` to + disable filling on polygons or circles. + fillColor : str + Fill color. Defaults to the value of the color option + fillOpacity : float (default 0.5) + Fill opacity. + + Plus all supported by :func:`folium.vector_layers.path_options`. See the + documentation of :class:`folium.features.GeoJson` for details. + + highlight_kwds : dict (default {}) + Style to be passed to folium highlight_function. Uses the same keywords + as ``style_kwds``. When empty, defaults to ``{"fillOpacity": 0.75}``. + tooltip_kwds : dict (default {}) + Additional keywords to be passed to :class:`folium.features.GeoJsonTooltip`, + e.g. ``aliases``, ``labels``, or ``sticky``. + popup_kwds : dict (default {}) + Additional keywords to be passed to :class:`folium.features.GeoJsonPopup`, + e.g. ``aliases`` or ``labels``. + legend_kwds : dict (default {}) + Additional keywords to be passed to the legend. + + Currently supported customisation: + + caption : string + Custom caption of the legend. Defaults to the column name. + + Additional accepted keywords when ``scheme`` is specified: + + colorbar : bool (default True) + An option to control the style of the legend. If True, continuous + colorbar will be used. If False, categorical legend will be used for bins. + scale : bool (default True) + Scale bins along the colorbar axis according to the bin edges (True) + or use the equal length for each bin (False) + fmt : string (default "{:.2f}") + A formatting specification for the bin edges of the classes in the + legend. For example, to have no decimals: ``{"fmt": "{:.0f}"}``. Applies + if ``colorbar=False``. + labels : list-like + A list of legend labels to override the auto-generated labels. + Needs to have the same number of elements as the number of + classes (`k`). Applies if ``colorbar=False``. + interval : boolean (default False) + An option to control brackets from mapclassify legend. + If True, open/closed interval brackets are shown in the legend. + Applies if ``colorbar=False``. + max_labels : int, default 10 + Maximum number of colorbar tick labels (requires branca>=0.5.0) + map_kwds : dict (default {}) + Additional keywords to be passed to folium :class:`~folium.folium.Map`, + e.g. ``dragging``, or ``scrollWheelZoom``. + + + **kwargs : dict + Additional options to be passed on to the folium object. + + Returns + ------- + m : folium.folium.Map + folium :class:`~folium.folium.Map` instance + + Examples + -------- + >>> df = geopandas.read_file(geopandas.datasets.get_path("naturalearth_lowres")) + >>> df.head(2) # doctest: +SKIP + pop_est continent name iso_a3 \ +gdp_md_est geometry + 0 920938 Oceania Fiji FJI 8374.0 MULTIPOLY\ +GON (((180.00000 -16.06713, 180.00000... + 1 53950935 Africa Tanzania TZA 150600.0 POLYGON (\ +(33.90371 -0.95000, 34.07262 -1.05982... + + >>> df.explore("pop_est", cmap="Blues") # doctest: +SKIP + """ + try: + import branca as bc + import folium + import matplotlib.cm as cm + import matplotlib.colors as colors + import matplotlib.pyplot as plt + from mapclassify import classify + except (ImportError, ModuleNotFoundError): + raise ImportError( + "The 'folium', 'matplotlib' and 'mapclassify' packages are required for " + "'explore()'. You can install them using " + "'conda install -c conda-forge folium matplotlib mapclassify' " + "or 'pip install folium matplotlib mapclassify'." + ) + + # xyservices is an optional dependency + try: + import xyzservices + + HAS_XYZSERVICES = True + except (ImportError, ModuleNotFoundError): + HAS_XYZSERVICES = False + + gdf = df.copy() + + # convert LinearRing to LineString + rings_mask = df.geom_type == "LinearRing" + if rings_mask.any(): + gdf.geometry[rings_mask] = gdf.geometry[rings_mask].apply( + lambda g: LineString(g) + ) + + if gdf.crs is None: + kwargs["crs"] = "Simple" + tiles = None + elif not gdf.crs.equals(4326): + gdf = gdf.to_crs(4326) + + # create folium.Map object + if m is None: + # Get bounds to specify location and map extent + bounds = gdf.total_bounds + location = kwargs.pop("location", None) + if location is None: + x = mean([bounds[0], bounds[2]]) + y = mean([bounds[1], bounds[3]]) + location = (y, x) + if "zoom_start" in kwargs.keys(): + fit = False + else: + fit = True + else: + fit = False + + # get a subset of kwargs to be passed to folium.Map + for i in _MAP_KWARGS: + if i in map_kwds: + raise ValueError( + f"'{i}' cannot be specified in 'map_kwds'. " + f"Use the '{i}={map_kwds[i]}' argument instead." + ) + map_kwds = { + **map_kwds, + **{i: kwargs[i] for i in kwargs.keys() if i in _MAP_KWARGS}, + } + + if HAS_XYZSERVICES: + # match provider name string to xyzservices.TileProvider + if isinstance(tiles, str): + try: + tiles = xyzservices.providers.query_name(tiles) + except ValueError: + pass + + if isinstance(tiles, xyzservices.TileProvider): + attr = attr if attr else tiles.html_attribution + map_kwds["min_zoom"] = tiles.get("min_zoom", 0) + map_kwds["max_zoom"] = tiles.get("max_zoom", 18) + tiles = tiles.build_url(scale_factor="{r}") + + m = folium.Map( + location=location, + control_scale=control_scale, + tiles=tiles, + attr=attr, + width=width, + height=height, + **map_kwds, + ) + + # fit bounds to get a proper zoom level + if fit: + m.fit_bounds([[bounds[1], bounds[0]], [bounds[3], bounds[2]]]) + + for map_kwd in _MAP_KWARGS: + kwargs.pop(map_kwd, None) + + nan_idx = None + + if column is not None: + if pd.api.types.is_list_like(column): + if len(column) != gdf.shape[0]: + raise ValueError( + "The GeoDataFrame and given column have different number of rows." + ) + else: + column_name = "__plottable_column" + gdf[column_name] = column + column = column_name + elif pd.api.types.is_categorical_dtype(gdf[column]): + if categories is not None: + raise ValueError( + "Cannot specify 'categories' when column has categorical dtype" + ) + categorical = True + elif gdf[column].dtype is np.dtype("O") or categories: + categorical = True + + nan_idx = pd.isna(gdf[column]) + + if categorical: + cat = pd.Categorical(gdf[column][~nan_idx], categories=categories) + N = len(cat.categories) + cmap = cmap if cmap else "tab20" + + # colormap exists in matplotlib + if cmap in plt.colormaps(): + + color = np.apply_along_axis( + colors.to_hex, 1, cm.get_cmap(cmap, N)(cat.codes) + ) + legend_colors = np.apply_along_axis( + colors.to_hex, 1, cm.get_cmap(cmap, N)(range(N)) + ) + + # colormap is matplotlib.Colormap + elif isinstance(cmap, colors.Colormap): + color = np.apply_along_axis(colors.to_hex, 1, cmap(cat.codes)) + legend_colors = np.apply_along_axis(colors.to_hex, 1, cmap(range(N))) + + # custom list of colors + elif pd.api.types.is_list_like(cmap): + if N > len(cmap): + cmap = cmap * (N // len(cmap) + 1) + color = np.take(cmap, cat.codes) + legend_colors = np.take(cmap, range(N)) + + else: + raise ValueError( + "'cmap' is invalid. For categorical plots, pass either valid " + "named matplotlib colormap or a list-like of colors." + ) + + elif callable(cmap): + # List of colors based on Branca colormaps or self-defined functions + color = list(map(lambda x: cmap(x), df[column])) + + else: + vmin = gdf[column].min() if vmin is None else vmin + vmax = gdf[column].max() if vmax is None else vmax + + # get bins + if scheme is not None: + + if classification_kwds is None: + classification_kwds = {} + if "k" not in classification_kwds: + classification_kwds["k"] = k + + binning = classify( + np.asarray(gdf[column][~nan_idx]), scheme, **classification_kwds + ) + color = np.apply_along_axis( + colors.to_hex, 1, cm.get_cmap(cmap, k)(binning.yb) + ) + + else: + + bins = np.linspace(vmin, vmax, 257)[1:] + binning = classify( + np.asarray(gdf[column][~nan_idx]), "UserDefined", bins=bins + ) + + color = np.apply_along_axis( + colors.to_hex, 1, cm.get_cmap(cmap, 256)(binning.yb) + ) + + # set default style + if "fillOpacity" not in style_kwds: + style_kwds["fillOpacity"] = 0.5 + if "weight" not in style_kwds: + style_kwds["weight"] = 2 + + # specify color + if color is not None: + if ( + isinstance(color, str) + and isinstance(gdf, geopandas.GeoDataFrame) + and color in gdf.columns + ): # use existing column + + def _style_color(x): + return { + "fillColor": x["properties"][color], + **style_kwds, + } + + style_function = _style_color + else: # assign new column + if isinstance(gdf, geopandas.GeoSeries): + gdf = geopandas.GeoDataFrame(geometry=gdf) + + if nan_idx is not None and nan_idx.any(): + nan_color = missing_kwds.pop("color", None) + + gdf["__folium_color"] = nan_color + gdf.loc[~nan_idx, "__folium_color"] = color + else: + gdf["__folium_color"] = color + + stroke_color = style_kwds.pop("color", None) + if not stroke_color: + + def _style_column(x): + return { + "fillColor": x["properties"]["__folium_color"], + "color": x["properties"]["__folium_color"], + **style_kwds, + } + + style_function = _style_column + else: + + def _style_stroke(x): + return { + "fillColor": x["properties"]["__folium_color"], + "color": stroke_color, + **style_kwds, + } + + style_function = _style_stroke + else: # use folium default + + def _style_default(x): + return {**style_kwds} + + style_function = _style_default + + if highlight: + if "fillOpacity" not in highlight_kwds: + highlight_kwds["fillOpacity"] = 0.75 + + def _style_highlight(x): + return {**highlight_kwds} + + highlight_function = _style_highlight + else: + highlight_function = None + + # define default for points + if marker_type is None: + marker_type = "circle_marker" + + marker = marker_type + if isinstance(marker_type, str): + if marker_type == "marker": + marker = folium.Marker(**marker_kwds) + elif marker_type == "circle": + marker = folium.Circle(**marker_kwds) + elif marker_type == "circle_marker": + marker_kwds["radius"] = marker_kwds.get("radius", 2) + marker_kwds["fill"] = marker_kwds.get("fill", True) + marker = folium.CircleMarker(**marker_kwds) + else: + raise ValueError( + "Only 'marker', 'circle', and 'circle_marker' are " + "supported as marker values" + ) + + # remove additional geometries + if isinstance(gdf, geopandas.GeoDataFrame): + non_active_geoms = [ + name + for name, val in (gdf.dtypes == "geometry").items() + if val and name != gdf.geometry.name + ] + gdf = gdf.drop(columns=non_active_geoms) + + # prepare tooltip and popup + if isinstance(gdf, geopandas.GeoDataFrame): + # add named index to the tooltip + if gdf.index.name is not None: + gdf = gdf.reset_index() + # specify fields to show in the tooltip + tooltip = _tooltip_popup("tooltip", tooltip, gdf, **tooltip_kwds) + popup = _tooltip_popup("popup", popup, gdf, **popup_kwds) + else: + tooltip = None + popup = None + + # add dataframe to map + folium.GeoJson( + gdf.__geo_interface__, + tooltip=tooltip, + popup=popup, + marker=marker, + style_function=style_function, + highlight_function=highlight_function, + **kwargs, + ).add_to(m) + + if legend: + # NOTE: overlaps will be resolved in branca #88 + caption = column if not column == "__plottable_column" else "" + caption = legend_kwds.pop("caption", caption) + if categorical: + categories = cat.categories.to_list() + legend_colors = legend_colors.tolist() + + if nan_idx.any() and nan_color: + categories.append(missing_kwds.pop("label", "NaN")) + legend_colors.append(nan_color) + + _categorical_legend(m, caption, categories, legend_colors) + elif column is not None: + + cbar = legend_kwds.pop("colorbar", True) + colormap_kwds = {} + if "max_labels" in legend_kwds: + colormap_kwds["max_labels"] = legend_kwds.pop("max_labels") + if scheme: + cb_colors = np.apply_along_axis( + colors.to_hex, 1, cm.get_cmap(cmap, binning.k)(range(binning.k)) + ) + if cbar: + if legend_kwds.pop("scale", True): + index = [vmin] + binning.bins.tolist() + else: + index = None + colorbar = bc.colormap.StepColormap( + cb_colors, + vmin=vmin, + vmax=vmax, + caption=caption, + index=index, + **colormap_kwds, + ) + else: + fmt = legend_kwds.pop("fmt", "{:.2f}") + if "labels" in legend_kwds: + categories = legend_kwds["labels"] + else: + categories = binning.get_legend_classes(fmt) + show_interval = legend_kwds.pop("interval", False) + if not show_interval: + categories = [c[1:-1] for c in categories] + + if nan_idx.any() and nan_color: + categories.append(missing_kwds.pop("label", "NaN")) + cb_colors = np.append(cb_colors, nan_color) + _categorical_legend(m, caption, categories, cb_colors) + + else: + if isinstance(cmap, bc.colormap.ColorMap): + colorbar = cmap + else: + + mp_cmap = cm.get_cmap(cmap) + cb_colors = np.apply_along_axis( + colors.to_hex, 1, mp_cmap(range(mp_cmap.N)) + ) + # linear legend + if mp_cmap.N > 20: + colorbar = bc.colormap.LinearColormap( + cb_colors, + vmin=vmin, + vmax=vmax, + caption=caption, + **colormap_kwds, + ) + + # steps + else: + colorbar = bc.colormap.StepColormap( + cb_colors, + vmin=vmin, + vmax=vmax, + caption=caption, + **colormap_kwds, + ) + + if cbar: + if nan_idx.any() and nan_color: + _categorical_legend( + m, "", [missing_kwds.pop("label", "NaN")], [nan_color] + ) + m.add_child(colorbar) + + return m + + +def _tooltip_popup(type, fields, gdf, **kwds): + """get tooltip or popup""" + import folium + + # specify fields to show in the tooltip + if fields is False or fields is None or fields == 0: + return None + else: + if fields is True: + fields = gdf.columns.drop(gdf.geometry.name).to_list() + elif isinstance(fields, int): + fields = gdf.columns.drop(gdf.geometry.name).to_list()[:fields] + elif isinstance(fields, str): + fields = [fields] + + for field in ["__plottable_column", "__folium_color"]: + if field in fields: + fields.remove(field) + + # Cast fields to str + fields = list(map(str, fields)) + if type == "tooltip": + return folium.GeoJsonTooltip(fields, **kwds) + elif type == "popup": + return folium.GeoJsonPopup(fields, **kwds) + + +def _categorical_legend(m, title, categories, colors): + """ + Add categorical legend to a map + + The implementation is using the code originally written by Michel Metran + (@michelmetran) and released on GitHub + (https://github.com/michelmetran/package_folium) under MIT license. + + Copyright (c) 2020 Michel Metran + + Parameters + ---------- + m : folium.Map + Existing map instance on which to draw the plot + title : str + title of the legend (e.g. column name) + categories : list-like + list of categories + colors : list-like + list of colors (in the same order as categories) + """ + + # Header to Add + head = """ + {% macro header(this, kwargs) %} + + + + {% endmacro %} + """ + import branca as bc + + # Add CSS (on Header) + macro = bc.element.MacroElement() + macro._template = bc.element.Template(head) + m.get_root().add_child(macro) + + body = f""" +
+
{title}
+
+
    """ + + # Loop Categories + for label, color in zip(categories, colors): + body += f""" +
  • {label}
    • """ + + body += """ +
+
+
+ """ + + # Add Body + body = bc.element.Element(body, "legend") + m.get_root().html.add_child(body) + + +def _explore_geoseries( + s, + color=None, + m=None, + tiles="OpenStreetMap", + attr=None, + highlight=True, + width="100%", + height="100%", + control_scale=True, + marker_type=None, + marker_kwds={}, + style_kwds={}, + highlight_kwds={}, + **kwargs, +): + """Interactive map based on GeoPandas and folium/leaflet.js + + Generate an interactive leaflet map based on :class:`~geopandas.GeoSeries` + + Parameters + ---------- + color : str, array-like (default None) + Named color or a list-like of colors (named or hex). + m : folium.Map (default None) + Existing map instance on which to draw the plot. + tiles : str, xyzservices.TileProvider (default 'OpenStreetMap Mapnik') + Map tileset to use. Can choose from the list supported by folium, query a + :class:`xyzservices.TileProvider` by a name from ``xyzservices.providers``, + pass :class:`xyzservices.TileProvider` object or pass custom XYZ URL. + The current list of built-in providers (when ``xyzservices`` is not available): + + ``["OpenStreetMap", "Stamen Terrain", “Stamen Toner", “Stamen Watercolor" + "CartoDB positron", “CartoDB dark_matter"]`` + + You can pass a custom tileset to Folium by passing a Leaflet-style URL + to the tiles parameter: ``http://{s}.yourtiles.com/{z}/{x}/{y}.png``. + Be sure to check their terms and conditions and to provide attribution with + the ``attr`` keyword. + attr : str (default None) + Map tile attribution; only required if passing custom tile URL. + highlight : bool (default True) + Enable highlight functionality when hovering over a geometry. + width : pixel int or percentage string (default: '100%') + Width of the folium :class:`~folium.folium.Map`. If the argument + m is given explicitly, width is ignored. + height : pixel int or percentage string (default: '100%') + Height of the folium :class:`~folium.folium.Map`. If the argument + m is given explicitly, height is ignored. + control_scale : bool, (default True) + Whether to add a control scale on the map. + marker_type : str, folium.Circle, folium.CircleMarker, folium.Marker (default None) + Allowed string options are ('marker', 'circle', 'circle_marker'). Defaults to + folium.Marker. + marker_kwds: dict (default {}) + Additional keywords to be passed to the selected ``marker_type``, e.g.: + + radius : float + Radius of the circle, in meters (for ``'circle'``) or pixels + (for ``circle_marker``). + icon : folium.map.Icon + the :class:`folium.map.Icon` object to use to render the marker. + draggable : bool (default False) + Set to True to be able to drag the marker around the map. + + style_kwds : dict (default {}) + Additional style to be passed to folium ``style_function``: + + stroke : bool (default True) + Whether to draw stroke along the path. Set it to ``False`` to + disable borders on polygons or circles. + color : str + Stroke color + weight : int + Stroke width in pixels + opacity : float (default 1.0) + Stroke opacity + fill : boolean (default True) + Whether to fill the path with color. Set it to ``False`` to + disable filling on polygons or circles. + fillColor : str + Fill color. Defaults to the value of the color option + fillOpacity : float (default 0.5) + Fill opacity. + + Plus all supported by :func:`folium.vector_layers.path_options`. See the + documentation of :class:`folium.features.GeoJson` for details. + + highlight_kwds : dict (default {}) + Style to be passed to folium highlight_function. Uses the same keywords + as ``style_kwds``. When empty, defaults to ``{"fillOpacity": 0.75}``. + + **kwargs : dict + Additional options to be passed on to the folium. + + Returns + ------- + m : folium.folium.Map + folium :class:`~folium.folium.Map` instance + + """ + return _explore( + s, + color=color, + m=m, + tiles=tiles, + attr=attr, + highlight=highlight, + width=width, + height=height, + control_scale=control_scale, + marker_type=marker_type, + marker_kwds=marker_kwds, + style_kwds=style_kwds, + highlight_kwds=highlight_kwds, + **kwargs, + ) diff --git a/geopandas/geodataframe.py b/geopandas/geodataframe.py index 7849d20..1b19b43 100644 --- a/geopandas/geodataframe.py +++ b/geopandas/geodataframe.py @@ -4,23 +4,39 @@ import warnings import numpy as np import pandas as pd from pandas import DataFrame, Series +from pandas.core.accessor import CachedAccessor from shapely.geometry import mapping, shape from shapely.geometry.base import BaseGeometry - from pyproj import CRS -from geopandas.array import GeometryArray, from_shapely, GeometryDtype +from geopandas.array import GeometryArray, GeometryDtype, from_shapely, to_wkb, to_wkt from geopandas.base import GeoPandasBase, is_geometry_type -from geopandas.geoseries import GeoSeries +from geopandas.geoseries import GeoSeries, _geoseries_constructor_with_fallback import geopandas.io -from geopandas.plotting import plot_dataframe +from geopandas.explore import _explore +from . import _compat as compat +from ._decorator import doc DEFAULT_GEO_COLUMN_NAME = "geometry" +def _geodataframe_constructor_with_fallback(*args, **kwargs): + """ + A flexible constructor for GeoDataFrame._constructor, which falls back + to returning a DataFrame (if a certain operation does not preserve the + geometry column) + """ + df = GeoDataFrame(*args, **kwargs) + geometry_cols_mask = df.dtypes == "geometry" + if len(geometry_cols_mask) == 0 or geometry_cols_mask.sum() == 0: + df = pd.DataFrame(df) + + return df + + def _ensure_geometry(data, crs=None): """ Ensure the data is of geometry dtype or converted to it. @@ -32,7 +48,9 @@ def _ensure_geometry(data, crs=None): """ if is_geometry_type(data): if isinstance(data, Series): - return GeoSeries(data) + data = GeoSeries(data) + if data.crs is None: + data.crs = crs return data else: if isinstance(data, Series): @@ -43,6 +61,14 @@ def _ensure_geometry(data, crs=None): return out +crs_mismatch_error = ( + "CRS mismatch between CRS of the passed geometries " + "and 'crs'. Use 'GeoDataFrame.set_crs(crs, " + "allow_override=True)' to overwrite CRS or " + "'GeoDataFrame.to_crs(crs)' to reproject geometries. " +) + + class GeoDataFrame(GeoPandasBase, DataFrame): """ A GeoDataFrame object is a pandas.DataFrame that has a column @@ -64,8 +90,8 @@ class GeoDataFrame(GeoPandasBase, DataFrame): Constructing GeoDataFrame from a dictionary. >>> from shapely.geometry import Point - >>> d = {'col1': ['name1', 'name2'], 'geometry': [Point(1,2), Point(2,1)]} - >>> gdf = gpd.GeoDataFrame(d, crs="EPSG:4326") + >>> d = {'col1': ['name1', 'name2'], 'geometry': [Point(1, 2), Point(2, 1)]} + >>> gdf = geopandas.GeoDataFrame(d, crs="EPSG:4326") >>> gdf col1 geometry 0 name1 POINT (1.00000 2.00000) @@ -77,20 +103,35 @@ class GeoDataFrame(GeoPandasBase, DataFrame): col1 object geometry geometry dtype: object + + Constructing GeoDataFrame from a pandas DataFrame with a column of WKT geometries: + + >>> import pandas as pd + >>> d = {'col1': ['name1', 'name2'], 'wkt': ['POINT (1 2)', 'POINT (2 1)']} + >>> df = pd.DataFrame(d) + >>> gs = geopandas.GeoSeries.from_wkt(df['wkt']) + >>> gdf = geopandas.GeoDataFrame(df, geometry=gs, crs="EPSG:4326") + >>> gdf + col1 wkt geometry + 0 name1 POINT (1 2) POINT (1.00000 2.00000) + 1 name2 POINT (2 1) POINT (2.00000 1.00000) + + See also + -------- + GeoSeries : Series object designed to store shapely geometry objects """ _metadata = ["_crs", "_geometry_column_name"] _geometry_column_name = DEFAULT_GEO_COLUMN_NAME - def __init__(self, *args, **kwargs): - crs = kwargs.pop("crs", None) - geometry = kwargs.pop("geometry", None) - super(GeoDataFrame, self).__init__(*args, **kwargs) + def __init__(self, data=None, *args, geometry=None, crs=None, **kwargs): + with compat.ignore_shapely2_warnings(): + super().__init__(data, *args, **kwargs) # need to set this before calling self['geometry'], because # getitem accesses crs - self._crs = crs if crs is not None else None + self._crs = CRS.from_user_input(crs) if crs else None # set_geometry ensures the geometry data have the proper dtype, # but is not called if `geometry=None` ('geometry' column present @@ -98,7 +139,23 @@ class GeoDataFrame(GeoPandasBase, DataFrame): # but within a try/except because currently non-geometries are # allowed in that case # TODO do we want to raise / return normal DataFrame in this case? + + # if gdf passed in and geo_col is set, we use that for geometry + if geometry is None and isinstance(data, GeoDataFrame): + self._geometry_column_name = data._geometry_column_name + if crs is not None and data.crs != crs: + raise ValueError(crs_mismatch_error) + if geometry is None and "geometry" in self.columns: + # Check for multiple columns with name "geometry". If there are, + # self["geometry"] is a gdf and constructor gets recursively recalled + # by pandas internals trying to access this + if (self.columns == "geometry").sum() > 1: + raise ValueError( + "GeoDataFrame does not support multiple columns " + "using the geometry column name 'geometry'." + ) + # only if we have actual geometry values -> call set_geometry index = self.index try: @@ -108,17 +165,7 @@ class GeoDataFrame(GeoPandasBase, DataFrame): and crs and not self["geometry"].values.crs == crs ): - warnings.warn( - "CRS mismatch between CRS of the passed geometries " - "and 'crs'. Use 'GeoDataFrame.set_crs(crs, " - "allow_override=True)' to overwrite CRS or " - "'GeoDataFrame.to_crs(crs)' to reproject geometries. " - "CRS mismatch will raise an error in the future versions " - "of GeoPandas.", - FutureWarning, - stacklevel=2, - ) - # TODO: raise error in 0.9 or 0.10. + raise ValueError(crs_mismatch_error) self["geometry"] = _ensure_geometry(self["geometry"].values, crs) except TypeError: pass @@ -137,19 +184,9 @@ class GeoDataFrame(GeoPandasBase, DataFrame): and crs and not geometry.crs == crs ): - warnings.warn( - "CRS mismatch between CRS of the passed geometries " - "and 'crs'. Use 'GeoDataFrame.set_crs(crs, " - "allow_override=True)' to overwrite CRS or " - "'GeoDataFrame.to_crs(crs)' to reproject geometries. " - "CRS mismatch will raise an error in the future versions " - "of GeoPandas.", - FutureWarning, - stacklevel=2, - ) - # TODO: raise error in 0.9 or 0.10. + raise ValueError(crs_mismatch_error) + self.set_geometry(geometry, inplace=True) - self._invalidate_sindex() if geometry is None and crs: warnings.warn( @@ -164,7 +201,7 @@ class GeoDataFrame(GeoPandasBase, DataFrame): if attr == "geometry": object.__setattr__(self, attr, val) else: - super(GeoDataFrame, self).__setattr__(attr, val) + super().__setattr__(attr, val) def _get_geometry(self): if self._geometry_column_name not in self: @@ -193,7 +230,7 @@ class GeoDataFrame(GeoPandasBase, DataFrame): Parameters ---------- col : column label or array - drop : boolean, default True + drop : boolean, default False Delete column to be used as the new geometry inplace : boolean, default False Modify the GeoDataFrame in place (do not create a new object) @@ -206,18 +243,47 @@ class GeoDataFrame(GeoPandasBase, DataFrame): Examples -------- - >>> df1 = df.set_geometry([Point(0,0), Point(1,1), Point(2,2)]) - >>> df2 = df.set_geometry('geom1') + >>> from shapely.geometry import Point + >>> d = {'col1': ['name1', 'name2'], 'geometry': [Point(1, 2), Point(2, 1)]} + >>> gdf = geopandas.GeoDataFrame(d, crs="EPSG:4326") + >>> gdf + col1 geometry + 0 name1 POINT (1.00000 2.00000) + 1 name2 POINT (2.00000 1.00000) + + Passing an array: + + >>> df1 = gdf.set_geometry([Point(0,0), Point(1,1)]) + >>> df1 + col1 geometry + 0 name1 POINT (0.00000 0.00000) + 1 name2 POINT (1.00000 1.00000) + + Using existing column: + + >>> gdf["buffered"] = gdf.buffer(2) + >>> df2 = gdf.set_geometry("buffered") + >>> df2.geometry + 0 POLYGON ((3.00000 2.00000, 2.99037 1.80397, 2.... + 1 POLYGON ((4.00000 1.00000, 3.99037 0.80397, 3.... + Name: buffered, dtype: geometry Returns ------- GeoDataFrame + + See also + -------- + GeoDataFrame.rename_geometry : rename an active geometry column """ # Most of the code here is taken from DataFrame.set_index() if inplace: frame = self else: frame = self.copy() + # if there is no previous self.geometry, self.copy() will downcast + if type(frame) == DataFrame: + frame = GeoDataFrame(frame) to_remove = None geo_column_name = self._geometry_column_name @@ -227,11 +293,17 @@ class GeoDataFrame(GeoPandasBase, DataFrame): raise ValueError("Must pass array with one dimension only.") else: try: - level = frame[col].values + level = frame[col] except KeyError: raise ValueError("Unknown column %s" % col) except Exception: raise + if isinstance(level, DataFrame): + raise ValueError( + "GeoDataFrame does not support setting the geometry column where " + "the column name is shared by multiple columns." + ) + if drop: to_remove = col geo_column_name = self._geometry_column_name @@ -260,7 +332,6 @@ class GeoDataFrame(GeoPandasBase, DataFrame): frame.index = index frame._geometry_column_name = geo_column_name frame.crs = crs - frame._invalidate_sindex() if not inplace: return frame @@ -279,6 +350,9 @@ class GeoDataFrame(GeoPandasBase, DataFrame): Examples -------- + >>> from shapely.geometry import Point + >>> d = {'col1': ['name1', 'name2'], 'geometry': [Point(1, 2), Point(2, 1)]} + >>> df = geopandas.GeoDataFrame(d, crs="EPSG:4326") >>> df1 = df.rename_geometry('geom1') >>> df1.geometry.name 'geom1' @@ -289,12 +363,21 @@ class GeoDataFrame(GeoPandasBase, DataFrame): Returns ------- geodataframe : GeoDataFrame + + See also + -------- + GeoDataFrame.set_geometry : set the active geometry """ geometry_col = self.geometry.name - if not inplace: - return self.rename(columns={geometry_col: col}).set_geometry(col, inplace) - self.rename(columns={geometry_col: col}, inplace=inplace) - self.set_geometry(col, inplace=inplace) + if col in self.columns: + raise ValueError(f"Column named {col} already exists") + else: + if not inplace: + return self.rename(columns={geometry_col: col}).set_geometry( + col, inplace + ) + self.rename(columns={geometry_col: col}, inplace=inplace) + self.set_geometry(col, inplace=inplace) @property def crs(self): @@ -307,6 +390,28 @@ class GeoDataFrame(GeoPandasBase, DataFrame): can be anything accepted by :meth:`pyproj.CRS.from_user_input() `, such as an authority string (eg "EPSG:4326") or a WKT string. + + Examples + -------- + + >>> gdf.crs # doctest: +SKIP + + Name: WGS 84 + Axis Info [ellipsoidal]: + - Lat[north]: Geodetic latitude (degree) + - Lon[east]: Geodetic longitude (degree) + Area of Use: + - name: World + - bounds: (-180.0, -90.0, 180.0, 90.0) + Datum: World Geodetic System 1984 + - Ellipsoid: WGS 84 + - Prime Meridian: Greenwich + + See also + -------- + GeoDataFrame.set_crs : assign CRS + GeoDataFrame.to_crs : re-project to another CRS + """ return self._crs @@ -329,10 +434,60 @@ class GeoDataFrame(GeoPandasBase, DataFrame): # column called 'geometry' without geometry self._crs = None if not value else CRS.from_user_input(value) + def __setstate__(self, state): + # overriding DataFrame method for compat with older pickles (CRS handling) + if isinstance(state, dict): + if "_metadata" in state and "crs" in state["_metadata"]: + metadata = state["_metadata"] + metadata[metadata.index("crs")] = "_crs" + if "crs" in state and "_crs" not in state: + crs = state.pop("crs") + state["_crs"] = CRS.from_user_input(crs) if crs is not None else crs + + super().__setstate__(state) + + # for some versions that didn't yet have CRS at array level -> crs is set + # at GeoDataFrame level with '_crs' (and not 'crs'), so without propagating + # to the GeoSeries/GeometryArray + try: + if self.crs is not None: + if self.geometry.values.crs is None: + self.crs = self.crs + except Exception: + pass + + @classmethod + def from_dict(cls, data, geometry=None, crs=None, **kwargs): + """ + Construct GeoDataFrame from dict of array-like or dicts by + overriding DataFrame.from_dict method with geometry and crs + + Parameters + ---------- + data : dict + Of the form {field : array-like} or {field : dict}. + geometry : str or array (optional) + If str, column to use as geometry. If array, will be set as 'geometry' + column on GeoDataFrame. + crs : str or dict (optional) + Coordinate reference system to set on the resulting frame. + kwargs : key-word arguments + These arguments are passed to DataFrame.from_dict + + Returns + ------- + GeoDataFrame + + """ + dataframe = DataFrame.from_dict(data, **kwargs) + return GeoDataFrame(dataframe, geometry=geometry, crs=crs) + @classmethod def from_file(cls, filename, **kwargs): """Alternate constructor to create a ``GeoDataFrame`` from a file. + It is recommended to use :func:`geopandas.read_file` instead. + Can load a ``GeoDataFrame`` from a file in any format recognized by `fiona`. See http://fiona.readthedocs.io/en/latest/manual.html for details. @@ -349,7 +504,32 @@ class GeoDataFrame(GeoPandasBase, DataFrame): Examples -------- - >>> df = geopandas.GeoDataFrame.from_file('nybb.shp') + + >>> path = geopandas.datasets.get_path('nybb') + >>> gdf = geopandas.GeoDataFrame.from_file(path) + >>> gdf # doctest: +SKIP + BoroCode BoroName Shape_Leng Shape_Area \ + geometry + 0 5 Staten Island 330470.010332 1.623820e+09 MULTIPOLYGON ((\ +(970217.022 145643.332, 970227.... + 1 4 Queens 896344.047763 3.045213e+09 MULTIPOLYGON ((\ +(1029606.077 156073.814, 102957... + 2 3 Brooklyn 741080.523166 1.937479e+09 MULTIPOLYGON ((\ +(1021176.479 151374.797, 102100... + 3 1 Manhattan 359299.096471 6.364715e+08 MULTIPOLYGON ((\ +(981219.056 188655.316, 980940.... + 4 2 Bronx 464392.991824 1.186925e+09 MULTIPOLYGON ((\ +(1012821.806 229228.265, 101278... + + The recommended method of reading files is :func:`geopandas.read_file`: + + >>> gdf = geopandas.read_file(path) + + See also + -------- + read_file : read file to GeoDataFame + GeoDataFrame.to_file : write GeoDataFrame to file + """ return geopandas.io.file._read_file(filename, **kwargs) @@ -384,6 +564,34 @@ class GeoDataFrame(GeoPandasBase, DataFrame): For more information about the ``__geo_interface__``, see https://gist.github.com/sgillies/2217756 + Examples + -------- + >>> feature_coll = { + ... "type": "FeatureCollection", + ... "features": [ + ... { + ... "id": "0", + ... "type": "Feature", + ... "properties": {"col1": "name1"}, + ... "geometry": {"type": "Point", "coordinates": (1.0, 2.0)}, + ... "bbox": (1.0, 2.0, 1.0, 2.0), + ... }, + ... { + ... "id": "1", + ... "type": "Feature", + ... "properties": {"col1": "name2"}, + ... "geometry": {"type": "Point", "coordinates": (2.0, 1.0)}, + ... "bbox": (2.0, 1.0, 2.0, 1.0), + ... }, + ... ], + ... "bbox": (1.0, 1.0, 2.0, 2.0), + ... } + >>> df = geopandas.GeoDataFrame.from_features(feature_coll) + >>> df + geometry col1 + 0 POINT (1.00000 2.00000) name1 + 1 POINT (2.00000 1.00000) name2 + """ # Handle feature collections if hasattr(features, "__geo_interface__"): @@ -429,7 +637,7 @@ class GeoDataFrame(GeoPandasBase, DataFrame): Parameters ---------- sql : string - con : DB connection object or SQLAlchemy engine + con : sqlalchemy.engine.Connection or sqlalchemy.engine.Engine geom_col : string, default 'geom' column name to convert to shapely geometries crs : optional @@ -456,10 +664,27 @@ class GeoDataFrame(GeoPandasBase, DataFrame): Examples -------- + PostGIS + + >>> from sqlalchemy import create_engine # doctest: +SKIP + >>> db_connection_url = "postgresql://myusername:mypassword@myhost:5432/mydb" + >>> con = create_engine(db_connection_url) # doctest: +SKIP >>> sql = "SELECT geom, highway FROM roads" + >>> df = geopandas.GeoDataFrame.from_postgis(sql, con) # doctest: +SKIP + SpatiaLite + >>> sql = "SELECT ST_Binary(geom) AS geom, highway FROM roads" - >>> df = geopandas.GeoDataFrame.from_postgis(sql, con) + >>> df = geopandas.GeoDataFrame.from_postgis(sql, con) # doctest: +SKIP + + The recommended method of reading from PostGIS is + :func:`geopandas.read_postgis`: + + >>> df = geopandas.read_postgis(sql, con) # doctest: +SKIP + + See also + -------- + geopandas.read_postgis : read PostGIS database to GeoDataFrame """ df = geopandas.io.sql._read_postgis( @@ -476,7 +701,9 @@ class GeoDataFrame(GeoPandasBase, DataFrame): return df - def to_json(self, na="null", show_bbox=False, to_wgs84=None, **kwargs): + def to_json( + self, na="null", show_bbox=False, drop_id=False, to_wgs84=None, **kwargs + ): """ Returns a GeoJSON representation of the ``GeoDataFrame`` as a string. @@ -487,6 +714,10 @@ class GeoDataFrame(GeoPandasBase, DataFrame): See below. show_bbox : bool, optional, default: False Include bbox (bounds) in the geojson + drop_id : bool, default: False + Whether to retain the index of the GeoDataFrame as the id property + in the generated GeoJSON. Default is False, but may want True + if the index is just arbitrary row numbers. to_wgs84: bool, optional, default: None If the CRS is set on the active geometry column it is exported as WGS84 (EPSG:4326) to meet the `2016 GeoJSON specification @@ -505,6 +736,32 @@ class GeoDataFrame(GeoPandasBase, DataFrame): - ``drop``: remove the property from the feature. This applies to each feature individually so that features may have different properties. - ``keep``: output the missing entries as NaN. + + Examples + -------- + + >>> from shapely.geometry import Point + >>> d = {'col1': ['name1', 'name2'], 'geometry': [Point(1, 2), Point(2, 1)]} + >>> gdf = geopandas.GeoDataFrame(d, crs="EPSG:4326") + >>> gdf + col1 geometry + 0 name1 POINT (1.00000 2.00000) + 1 name2 POINT (2.00000 1.00000) + + >>> gdf.to_json() + '{"type": "FeatureCollection", "features": [{"id": "0", "type": "Feature", \ +"properties": {"col1": "name1"}, "geometry": {"type": "Point", "coordinates": [1.0,\ + 2.0]}}, {"id": "1", "type": "Feature", "properties": {"col1": "name2"}, "geometry"\ +: {"type": "Point", "coordinates": [2.0, 1.0]}}]}' + + Alternatively, you can write GeoJSON to file: + + >>> gdf.to_file(path, driver="GeoJSON") # doctest: +SKIP + + See also + -------- + GeoDataFrame.to_file : write GeoDataFrame to file + """ if to_wgs84 is None: if self.crs and not self.crs.equals == 4326: @@ -527,7 +784,9 @@ class GeoDataFrame(GeoPandasBase, DataFrame): df = self.to_crs(epsg=4326) else: df = self - return json.dumps(df._to_geo(na=na, show_bbox=show_bbox), **kwargs) + return json.dumps( + df._to_geo(na=na, show_bbox=show_bbox, drop_id=drop_id), **kwargs + ) @property def __geo_interface__(self): @@ -539,25 +798,67 @@ class GeoDataFrame(GeoPandasBase, DataFrame): This differs from `_to_geo()` only in that it is a property with default args instead of a method - """ - return self._to_geo(na="null", show_bbox=True) - def iterfeatures(self, na="null", show_bbox=False): + Examples + -------- + + >>> from shapely.geometry import Point + >>> d = {'col1': ['name1', 'name2'], 'geometry': [Point(1, 2), Point(2, 1)]} + >>> gdf = geopandas.GeoDataFrame(d, crs="EPSG:4326") + >>> gdf + col1 geometry + 0 name1 POINT (1.00000 2.00000) + 1 name2 POINT (2.00000 1.00000) + + >>> gdf.__geo_interface__ + {'type': 'FeatureCollection', 'features': [{'id': '0', 'type': 'Feature', \ +'properties': {'col1': 'name1'}, 'geometry': {'type': 'Point', 'coordinates': (1.0\ +, 2.0)}, 'bbox': (1.0, 2.0, 1.0, 2.0)}, {'id': '1', 'type': 'Feature', 'properties\ +': {'col1': 'name2'}, 'geometry': {'type': 'Point', 'coordinates': (2.0, 1.0)}, 'b\ +box': (2.0, 1.0, 2.0, 1.0)}], 'bbox': (1.0, 1.0, 2.0, 2.0)} + + + """ + return self._to_geo(na="null", show_bbox=True, drop_id=False) + + def iterfeatures(self, na="null", show_bbox=False, drop_id=False): """ Returns an iterator that yields feature dictionaries that comply with __geo_interface__ Parameters ---------- - na : {'null', 'drop', 'keep'}, default 'null' + na : str, optional + Options are {'null', 'drop', 'keep'}, default 'null'. Indicates how to output missing (NaN) values in the GeoDataFrame - * null: ouput the missing entries as JSON null - * drop: remove the property from the feature. This applies to - each feature individually so that features may have - different properties - * keep: output the missing entries as NaN - show_bbox : include bbox (bounds) in the geojson. default False + - null: output the missing entries as JSON null + - drop: remove the property from the feature. This applies to each feature \ +individually so that features may have different properties + - keep: output the missing entries as NaN + + show_bbox : bool, optional + Include bbox (bounds) in the geojson. Default False. + drop_id : bool, default: False + Whether to retain the index of the GeoDataFrame as the id property + in the generated GeoJSON. Default is False, but may want True + if the index is just arbitrary row numbers. + + Examples + -------- + + >>> from shapely.geometry import Point + >>> d = {'col1': ['name1', 'name2'], 'geometry': [Point(1, 2), Point(2, 1)]} + >>> gdf = geopandas.GeoDataFrame(d, crs="EPSG:4326") + >>> gdf + col1 geometry + 0 name1 POINT (1.00000 2.00000) + 1 name2 POINT (2.00000 1.00000) + + >>> feature = next(gdf.iterfeatures()) + >>> feature + {'id': '0', 'type': 'Feature', 'properties': {'col1': 'name1'}, 'geometry': {\ +'type': 'Point', 'coordinates': (1.0, 2.0)}} """ if na not in ["null", "drop", "keep"]: raise ValueError("Unknown na method {0}".format(na)) @@ -571,6 +872,9 @@ class GeoDataFrame(GeoPandasBase, DataFrame): ids = np.array(self.index, copy=False) geometries = np.array(self[self._geometry_column_name], copy=False) + if not self.columns.is_unique: + raise ValueError("GeoDataFrame cannot contain duplicated column names.") + properties_cols = self.columns.difference([self._geometry_column_name]) if len(properties_cols) > 0: @@ -589,27 +893,35 @@ class GeoDataFrame(GeoPandasBase, DataFrame): else: properties_items = {k: v for k, v in zip(properties_cols, row)} - feature = { - "id": str(ids[i]), - "type": "Feature", - "properties": properties_items, - "geometry": mapping(geom) if geom else None, - } + if drop_id: + feature = {} + else: + feature = {"id": str(ids[i])} + + feature["type"] = "Feature" + feature["properties"] = properties_items + feature["geometry"] = mapping(geom) if geom else None if show_bbox: feature["bbox"] = geom.bounds if geom else None + yield feature else: for fid, geom in zip(ids, geometries): - feature = { - "id": str(fid), - "type": "Feature", - "properties": {}, - "geometry": mapping(geom) if geom else None, - } + + if drop_id: + feature = {} + else: + feature = {"id": str(fid)} + + feature["type"] = "Feature" + feature["properties"] = {} + feature["geometry"] = mapping(geom) if geom else None + if show_bbox: feature["bbox"] = geom.bounds if geom else None + yield feature def _to_geo(self, **kwargs): @@ -628,6 +940,57 @@ class GeoDataFrame(GeoPandasBase, DataFrame): return geo + def to_wkb(self, hex=False, **kwargs): + """ + Encode all geometry columns in the GeoDataFrame to WKB. + + Parameters + ---------- + hex : bool + If true, export the WKB as a hexadecimal string. + The default is to return a binary bytes object. + kwargs + Additional keyword args will be passed to + :func:`pygeos.to_wkb` if pygeos is installed. + + Returns + ------- + DataFrame + geometry columns are encoded to WKB + """ + + df = DataFrame(self.copy()) + + # Encode all geometry columns to WKB + for col in df.columns[df.dtypes == "geometry"]: + df[col] = to_wkb(df[col].values, hex=hex, **kwargs) + + return df + + def to_wkt(self, **kwargs): + """ + Encode all geometry columns in the GeoDataFrame to WKT. + + Parameters + ---------- + kwargs + Keyword args will be passed to :func:`pygeos.to_wkt` + if pygeos is installed. + + Returns + ------- + DataFrame + geometry columns are encoded to WKT + """ + + df = DataFrame(self.copy()) + + # Encode all geometry columns to WKT + for col in df.columns[df.dtypes == "geometry"]: + df[col] = to_wkt(df[col].values, **kwargs) + + return df + def to_parquet(self, path, index=None, compression="snappy", **kwargs): """Write a GeoDataFrame to the Parquet format. @@ -658,7 +1021,17 @@ class GeoDataFrame(GeoPandasBase, DataFrame): compression : {'snappy', 'gzip', 'brotli', None}, default 'snappy' Name of the compression to use. Use ``None`` for no compression. kwargs - Additional keyword arguments passed to to pyarrow.parquet.write_table(). + Additional keyword arguments passed to :func:`pyarrow.parquet.write_table`. + + Examples + -------- + + >>> gdf.to_parquet('data.parquet') # doctest: +SKIP + + See also + -------- + GeoDataFrame.to_feather : write GeoDataFrame to feather + GeoDataFrame.to_file : write GeoDataFrame to file """ from geopandas.io.arrow import _to_parquet @@ -696,16 +1069,25 @@ class GeoDataFrame(GeoPandasBase, DataFrame): Name of the compression to use. Use ``"uncompressed"`` for no compression. By default uses LZ4 if available, otherwise uncompressed. kwargs - Additional keyword arguments passed to to pyarrow.feather.write_feather(). + Additional keyword arguments passed to to + :func:`pyarrow.feather.write_feather`. + + Examples + -------- + + >>> gdf.to_feather('data.feather') # doctest: +SKIP + + See also + -------- + GeoDataFrame.to_parquet : write GeoDataFrame to parquet + GeoDataFrame.to_file : write GeoDataFrame to file """ from geopandas.io.arrow import _to_feather _to_feather(self, path, index=index, compression=compression, **kwargs) - def to_file( - self, filename, driver="ESRI Shapefile", schema=None, index=None, **kwargs - ): + def to_file(self, filename, driver=None, schema=None, index=None, **kwargs): """Write the ``GeoDataFrame`` to a file. By default, an ESRI shapefile is written, but any OGR data source @@ -713,14 +1095,16 @@ class GeoDataFrame(GeoPandasBase, DataFrame): providers is available via: >>> import fiona - >>> fiona.supported_drivers + >>> fiona.supported_drivers # doctest: +SKIP Parameters ---------- filename : string File path or file handle to write to. - driver : string, default: 'ESRI Shapefile' + driver : string, default None The OGR format driver used to write the vector file. + If not specified, it attempts to infer it from the file extension. + If no extension is specified, it saves ESRI Shapefile to a folder. schema : dict, default: None If specified, the schema dictionary is passed to Fiona to better control how the file is written. @@ -746,6 +1130,22 @@ class GeoDataFrame(GeoPandasBase, DataFrame): See Also -------- GeoSeries.to_file + GeoDataFrame.to_postgis : write GeoDataFrame to PostGIS database + GeoDataFrame.to_parquet : write GeoDataFrame to parquet + GeoDataFrame.to_feather : write GeoDataFrame to feather + + Examples + -------- + + >>> gdf.to_file('dataframe.shp') # doctest: +SKIP + + >>> gdf.to_file('dataframe.gpkg', driver='GPKG', layer='name') # doctest: +SKIP + + >>> gdf.to_file('dataframe.geojson', driver='GeoJSON') # doctest: +SKIP + + With selected drivers you can also append to a file with `mode="a"`: + + >>> gdf.to_file('dataframe.shp', mode="a") # doctest: +SKIP """ from geopandas.io.file import _to_file @@ -776,6 +1176,50 @@ class GeoDataFrame(GeoPandasBase, DataFrame): allow_override : bool, default False If the the GeoDataFrame already has a CRS, allow to replace the existing CRS, even when both are not equal. + + Examples + -------- + >>> from shapely.geometry import Point + >>> d = {'col1': ['name1', 'name2'], 'geometry': [Point(1, 2), Point(2, 1)]} + >>> gdf = geopandas.GeoDataFrame(d) + >>> gdf + col1 geometry + 0 name1 POINT (1.00000 2.00000) + 1 name2 POINT (2.00000 1.00000) + + Setting CRS to a GeoDataFrame without one: + + >>> gdf.crs is None + True + + >>> gdf = gdf.set_crs('epsg:3857') + >>> gdf.crs # doctest: +SKIP + + Name: WGS 84 / Pseudo-Mercator + Axis Info [cartesian]: + - X[east]: Easting (metre) + - Y[north]: Northing (metre) + Area of Use: + - name: World - 85°S to 85°N + - bounds: (-180.0, -85.06, 180.0, 85.06) + Coordinate Operation: + - name: Popular Visualisation Pseudo-Mercator + - method: Popular Visualisation Pseudo Mercator + Datum: World Geodetic System 1984 + - Ellipsoid: WGS 84 + - Prime Meridian: Greenwich + + Overriding existing CRS: + + >>> gdf = gdf.set_crs(4326, allow_override=True) + + Without ``allow_override=True``, ``set_crs`` returns an error if you try to + override CRS. + + See also + -------- + GeoDataFrame.to_crs : re-project to another CRS + """ if not inplace: df = self.copy() @@ -814,6 +1258,53 @@ class GeoDataFrame(GeoPandasBase, DataFrame): Returns ------- GeoDataFrame + + Examples + -------- + >>> from shapely.geometry import Point + >>> d = {'col1': ['name1', 'name2'], 'geometry': [Point(1, 2), Point(2, 1)]} + >>> gdf = geopandas.GeoDataFrame(d, crs=4326) + >>> gdf + col1 geometry + 0 name1 POINT (1.00000 2.00000) + 1 name2 POINT (2.00000 1.00000) + >>> gdf.crs # doctest: +SKIP + + Name: WGS 84 + Axis Info [ellipsoidal]: + - Lat[north]: Geodetic latitude (degree) + - Lon[east]: Geodetic longitude (degree) + Area of Use: + - name: World + - bounds: (-180.0, -90.0, 180.0, 90.0) + Datum: World Geodetic System 1984 + - Ellipsoid: WGS 84 + - Prime Meridian: Greenwich + + >>> gdf = gdf.to_crs(3857) + >>> gdf + col1 geometry + 0 name1 POINT (111319.491 222684.209) + 1 name2 POINT (222638.982 111325.143) + >>> gdf.crs # doctest: +SKIP + + Name: WGS 84 / Pseudo-Mercator + Axis Info [cartesian]: + - X[east]: Easting (metre) + - Y[north]: Northing (metre) + Area of Use: + - name: World - 85°S to 85°N + - bounds: (-180.0, -85.06, 180.0, 85.06) + Coordinate Operation: + - name: Popular Visualisation Pseudo-Mercator + - method: Popular Visualisation Pseudo Mercator + Datum: World Geodetic System 1984 + - Ellipsoid: WGS 84 + - Prime Meridian: Greenwich + + See also + -------- + GeoDataFrame.set_crs : assign CRS without re-projection """ if inplace: df = self @@ -825,21 +1316,59 @@ class GeoDataFrame(GeoPandasBase, DataFrame): if not inplace: return df + def estimate_utm_crs(self, datum_name="WGS 84"): + """Returns the estimated UTM CRS based on the bounds of the dataset. + + .. versionadded:: 0.9 + + .. note:: Requires pyproj 3+ + + Parameters + ---------- + datum_name : str, optional + The name of the datum to use in the query. Default is WGS 84. + + Returns + ------- + pyproj.CRS + + Examples + -------- + >>> world = geopandas.read_file( + ... geopandas.datasets.get_path("naturalearth_lowres") + ... ) + >>> germany = world.loc[world.name == "Germany"] + >>> germany.estimate_utm_crs() # doctest: +SKIP + + Name: WGS 84 / UTM zone 32N + Axis Info [cartesian]: + - E[east]: Easting (metre) + - N[north]: Northing (metre) + Area of Use: + - name: World - N hemisphere - 6°E to 12°E - by country + - bounds: (6.0, 0.0, 12.0, 84.0) + Coordinate Operation: + - name: UTM zone 32N + - method: Transverse Mercator + Datum: World Geodetic System 1984 + - Ellipsoid: WGS 84 + - Prime Meridian: Greenwich + """ + return self.geometry.estimate_utm_crs(datum_name=datum_name) + def __getitem__(self, key): """ If the result is a column containing only 'geometry', return a GeoSeries. If it's a DataFrame with a 'geometry' column, return a GeoDataFrame. """ - result = super(GeoDataFrame, self).__getitem__(key) + result = super().__getitem__(key) geo_col = self._geometry_column_name if isinstance(result, Series) and isinstance(result.dtype, GeometryDtype): result.__class__ = GeoSeries - result._invalidate_sindex() elif isinstance(result, DataFrame) and geo_col in result: result.__class__ = GeoDataFrame result._geometry_column_name = geo_col - result._invalidate_sindex() elif isinstance(result, DataFrame) and geo_col not in result: result.__class__ = DataFrame return result @@ -854,9 +1383,10 @@ class GeoDataFrame(GeoPandasBase, DataFrame): value = [value] * self.shape[0] try: value = _ensure_geometry(value, crs=self.crs) + self._crs = value.crs except TypeError: warnings.warn("Geometry column does not contain geometry.") - super(GeoDataFrame, self).__setitem__(key, value) + super().__setitem__(key, value) # # Implement pandas methods @@ -889,17 +1419,43 @@ class GeoDataFrame(GeoPandasBase, DataFrame): result.__class__ = GeoDataFrame result.crs = self.crs result._geometry_column_name = geo_col - result._invalidate_sindex() elif isinstance(result, DataFrame) and geo_col not in result: result.__class__ = DataFrame return result + @doc(pd.DataFrame) + def apply(self, func, axis=0, raw=False, result_type=None, args=(), **kwargs): + result = super().apply( + func, axis=axis, raw=raw, result_type=result_type, args=args, **kwargs + ) + # Reconstruct gdf if it was lost by apply + if ( + isinstance(result, DataFrame) + and self._geometry_column_name in result.columns + ): + # axis=1 apply will split GeometryDType to object, try and cast back + try: + result = result.set_geometry(self._geometry_column_name) + except TypeError: + pass + else: + if self.crs is not None and result.crs is None: + result.set_crs(self.crs, inplace=True) + + return result + @property def _constructor(self): - return GeoDataFrame + return _geodataframe_constructor_with_fallback + + @property + def _constructor_sliced(self): + return _geoseries_constructor_with_fallback def __finalize__(self, other, method=None, **kwargs): - """propagate metadata from other to self """ + """propagate metadata from other to self""" + self = super().__finalize__(other, method=method, **kwargs) + # merge operation: using metadata of the left object if method == "merge": for name in self._metadata: @@ -908,27 +1464,26 @@ class GeoDataFrame(GeoPandasBase, DataFrame): elif method == "concat": for name in self._metadata: object.__setattr__(self, name, getattr(other.objs[0], name, None)) - else: - for name in self._metadata: - object.__setattr__(self, name, getattr(other, name, None)) + if (self.columns == self._geometry_column_name).sum() > 1: + raise ValueError( + "Concat operation has resulted in multiple columns using " + f"the geometry column name '{self._geometry_column_name}'.\n" + f"Please ensure this column from the first DataFrame is not " + f"repeated." + ) return self - def plot(self, *args, **kwargs): - """Generate a plot of the geometries in the ``GeoDataFrame``. - - If the ``column`` parameter is given, colors plot according to values - in that column, otherwise calls ``GeoSeries.plot()`` on the - ``geometry`` column. - - Wraps the ``plot_dataframe()`` function, and documentation is copied - from there. - """ - return plot_dataframe(self, *args, **kwargs) - - plot.__doc__ = plot_dataframe.__doc__ - - def dissolve(self, by=None, aggfunc="first", as_index=True): + def dissolve( + self, + by=None, + aggfunc="first", + as_index=True, + level=None, + sort=True, + observed=False, + dropna=True, + ): """ Dissolve geometries within `groupby` into single observation. This is accomplished by applying the `unary_union` method @@ -940,28 +1495,101 @@ class GeoDataFrame(GeoPandasBase, DataFrame): Parameters ---------- by : string, default None - Column whose values define groups to be dissolved + Column whose values define groups to be dissolved. If None, + whole GeoDataFrame is considered a single group. aggfunc : function or string, default "first" Aggregation function for manipulation of data associated with each group. Passed to pandas `groupby.agg` method. + Accepted combinations are: + + - function + - string function name + - list of functions and/or function names, e.g. [np.sum, 'mean'] + - dict of axis labels -> functions, function names or list of such. as_index : boolean, default True If true, groupby columns become index of result. + level : int or str or sequence of int or sequence of str, default None + If the axis is a MultiIndex (hierarchical), group by a + particular level or levels. + + .. versionadded:: 0.9.0 + sort : bool, default True + Sort group keys. Get better performance by turning this off. + Note this does not influence the order of observations within + each group. Groupby preserves the order of rows within each group. + + .. versionadded:: 0.9.0 + observed : bool, default False + This only applies if any of the groupers are Categoricals. + If True: only show observed values for categorical groupers. + If False: show all values for categorical groupers. + + .. versionadded:: 0.9.0 + dropna : bool, default True + If True, and if group keys contain NA values, NA values + together with row/column will be dropped. If False, NA + values will also be treated as the key in groups. + + This parameter is not supported for pandas < 1.1.0. + A warning will be emitted for earlier pandas versions + if a non-default value is given for this parameter. + + .. versionadded:: 0.9.0 Returns ------- GeoDataFrame + + Examples + -------- + >>> from shapely.geometry import Point + >>> d = { + ... "col1": ["name1", "name2", "name1"], + ... "geometry": [Point(1, 2), Point(2, 1), Point(0, 1)], + ... } + >>> gdf = geopandas.GeoDataFrame(d, crs=4326) + >>> gdf + col1 geometry + 0 name1 POINT (1.00000 2.00000) + 1 name2 POINT (2.00000 1.00000) + 2 name1 POINT (0.00000 1.00000) + + >>> dissolved = gdf.dissolve('col1') + >>> dissolved # doctest: +SKIP + geometry + col1 + name1 MULTIPOINT (0.00000 1.00000, 1.00000 2.00000) + name2 POINT (2.00000 1.00000) + + See also + -------- + GeoDataFrame.explode : explode multi-part geometries into single geometries + """ + if by is None and level is None: + by = np.zeros(len(self), dtype="int64") + + groupby_kwargs = dict( + by=by, level=level, sort=sort, observed=observed, dropna=dropna + ) + if not compat.PANDAS_GE_11: + groupby_kwargs.pop("dropna") + + if not dropna: # If they passed a non-default dropna value + warnings.warn("dropna kwarg is not supported for pandas < 1.1.0") + # Process non-spatial component data = self.drop(labels=self.geometry.name, axis=1) - aggregated_data = data.groupby(by=by).agg(aggfunc) + aggregated_data = data.groupby(**groupby_kwargs).agg(aggfunc) + aggregated_data.columns = aggregated_data.columns.to_flat_index() # Process spatial component def merge_geometries(block): merged_geom = block.unary_union return merged_geom - g = self.groupby(by=by, group_keys=False)[self.geometry.name].agg( + g = self.groupby(group_keys=False, **groupby_kwargs)[self.geometry.name].agg( merge_geometries ) @@ -976,19 +1604,31 @@ class GeoDataFrame(GeoPandasBase, DataFrame): return aggregated - # overrides GeoPandasBase method - def explode(self): + # overrides the pandas native explode method to break up features geometrically + def explode(self, column=None, ignore_index=False, index_parts=None, **kwargs): """ - Explode muti-part geometries into multiple single geometries. + Explode multi-part geometries into multiple single geometries. Each row containing a multi-part geometry will be split into multiple rows with single geometries, thereby increasing the vertical size of the GeoDataFrame. - The index of the input geodataframe is no longer unique and is - replaced with a multi-index (original index with additional level - indicating the multiple geometries: a new zero-based index for each - single part geometry per multi-part geometry). + .. note:: ignore_index requires pandas 1.1.0 or newer. + + Parameters + ---------- + column : string, default None + Column to explode. In the case of a geometry column, multi-part + geometries are converted to single-part. + If None, the active geometry column is used. + ignore_index : bool, default False + If True, the resulting index will be labelled 0, 1, …, n - 1, + ignoring `index_parts`. + index_parts : boolean, default True + If True, the resulting index will be a multi-index (original + index with an additional level indicating the multiple + geometries: a new zero-based index for each single part geometry + per multi-part geometry). Returns ------- @@ -996,28 +1636,97 @@ class GeoDataFrame(GeoPandasBase, DataFrame): Exploded geodataframe with each single geometry as a separate entry in the geodataframe. + Examples + -------- + + >>> from shapely.geometry import MultiPoint + >>> d = { + ... "col1": ["name1", "name2"], + ... "geometry": [ + ... MultiPoint([(1, 2), (3, 4)]), + ... MultiPoint([(2, 1), (0, 0)]), + ... ], + ... } + >>> gdf = geopandas.GeoDataFrame(d, crs=4326) + >>> gdf + col1 geometry + 0 name1 MULTIPOINT (1.00000 2.00000, 3.00000 4.00000) + 1 name2 MULTIPOINT (2.00000 1.00000, 0.00000 0.00000) + + >>> exploded = gdf.explode(index_parts=True) + >>> exploded + col1 geometry + 0 0 name1 POINT (1.00000 2.00000) + 1 name1 POINT (3.00000 4.00000) + 1 0 name2 POINT (2.00000 1.00000) + 1 name2 POINT (0.00000 0.00000) + + >>> exploded = gdf.explode(index_parts=False) + >>> exploded + col1 geometry + 0 name1 POINT (1.00000 2.00000) + 0 name1 POINT (3.00000 4.00000) + 1 name2 POINT (2.00000 1.00000) + 1 name2 POINT (0.00000 0.00000) + + >>> exploded = gdf.explode(ignore_index=True) + >>> exploded + col1 geometry + 0 name1 POINT (1.00000 2.00000) + 1 name1 POINT (3.00000 4.00000) + 2 name2 POINT (2.00000 1.00000) + 3 name2 POINT (0.00000 0.00000) + + See also + -------- + GeoDataFrame.dissolve : dissolve geometries into a single observation. + """ - df_copy = self.copy() - if "level_1" in df_copy.columns: # GH1393 - df_copy = df_copy.rename(columns={"level_1": "__level_1"}) + # If no column is specified then default to the active geometry column + if column is None: + column = self.geometry.name + # If the specified column is not a geometry dtype use pandas explode + if not isinstance(self[column].dtype, GeometryDtype): + if compat.PANDAS_GE_11: + return super().explode(column, ignore_index=ignore_index, **kwargs) + else: + return super().explode(column, **kwargs) - exploded_geom = df_copy.geometry.explode().reset_index(level=-1) - exploded_index = exploded_geom.columns[0] + if index_parts is None: + if not ignore_index: + warnings.warn( + "Currently, index_parts defaults to True, but in the future, " + "it will default to False to be consistent with Pandas. " + "Use `index_parts=True` to keep the current behavior and " + "True/False to silence the warning.", + FutureWarning, + stacklevel=2, + ) + index_parts = True - df = pd.concat( - [df_copy.drop(df_copy._geometry_column_name, axis=1), exploded_geom], axis=1 - ) - # reset to MultiIndex, otherwise df index is only first level of - # exploded GeoSeries index. - df.set_index(exploded_index, append=True, inplace=True) - df.index.names = list(self.index.names) + [None] + exploded_geom = self.geometry.reset_index(drop=True).explode(index_parts=True) - if "__level_1" in df.columns: - df = df.rename(columns={"__level_1": "level_1"}) + df = GeoDataFrame( + self.drop(self._geometry_column_name, axis=1).take( + exploded_geom.index.droplevel(-1) + ), + geometry=exploded_geom.values, + ).__finalize__(self) - geo_df = df.set_geometry(self._geometry_column_name) - return geo_df + if ignore_index: + df.reset_index(inplace=True, drop=True) + elif index_parts: + # reset to MultiIndex, otherwise df index is only first level of + # exploded GeoSeries index. + df = df.set_index( + exploded_geom.index.droplevel( + list(range(exploded_geom.index.nlevels - 1)) + ), + append=True, + ) + + return df # overrides the pandas astype method to ensure the correct return type def astype(self, dtype, copy=True, errors="raise", **kwargs): @@ -1033,7 +1742,7 @@ class GeoDataFrame(GeoPandasBase, DataFrame): ------- GeoDataFrame or DataFrame """ - df = super(GeoDataFrame, self).astype(dtype, copy=copy, errors=errors, **kwargs) + df = super().astype(dtype, copy=copy, errors=errors, **kwargs) try: geoms = df[self._geometry_column_name] @@ -1045,6 +1754,34 @@ class GeoDataFrame(GeoPandasBase, DataFrame): # do not return a GeoDataFrame return pd.DataFrame(df) + def convert_dtypes(self, *args, **kwargs): + """ + Convert columns to best possible dtypes using dtypes supporting ``pd.NA``. + + Always returns a GeoDataFrame as no conversions are applied to the + geometry column. + + See the pandas.DataFrame.convert_dtypes docstring for more details. + + Returns + ------- + GeoDataFrame + + """ + # Overridden to fix GH1870, that return type is not preserved always + # (and where it was, geometry col was not) + + if not compat.PANDAS_GE_10: + raise NotImplementedError( + "GeoDataFrame.convert_dtypes requires pandas >= 1.0" + ) + + return GeoDataFrame( + super().convert_dtypes(*args, **kwargs), + geometry=self.geometry.name, + crs=self.crs, + ) + def to_postgis( self, name, @@ -1056,7 +1793,6 @@ class GeoDataFrame(GeoPandasBase, DataFrame): chunksize=None, dtype=None, ): - """ Upload GeoDataFrame into PostGIS database. @@ -1067,7 +1803,7 @@ class GeoDataFrame(GeoPandasBase, DataFrame): ---------- name : str Name of the target table. - con : sqlalchemy.engine.Engine + con : sqlalchemy.engine.Connection or sqlalchemy.engine.Engine Active connection to the PostGIS database. if_exists : {'fail', 'replace', 'append'}, default 'fail' How to behave if the table already exists: @@ -1096,9 +1832,15 @@ class GeoDataFrame(GeoPandasBase, DataFrame): -------- >>> from sqlalchemy import create_engine - >>> engine = create_engine("postgres://myusername:mypassword@myhost:5432\ -/mydatabase";) - >>> gdf.to_postgis("my_table", engine) + >>> engine = create_engine("postgresql://myusername:mypassword@myhost:5432\ +/mydatabase") # doctest: +SKIP + >>> gdf.to_postgis("my_table", engine) # doctest: +SKIP + + See also + -------- + GeoDataFrame.to_file : write GeoDataFrame to file + read_postgis : read PostGIS database to GeoDataFrame + """ geopandas.io.sql._write_postgis( self, name, con, schema, if_exists, index, index_label, chunksize, dtype @@ -1145,6 +1887,353 @@ class GeoDataFrame(GeoPandasBase, DataFrame): ) return self.geometry.difference(other) + plot = CachedAccessor("plot", geopandas.plotting.GeoplotAccessor) + + @doc(_explore) + def explore(self, *args, **kwargs): + """Interactive map based on folium/leaflet.js""" + return _explore(self, *args, **kwargs) + + def sjoin(self, df, *args, **kwargs): + """Spatial join of two GeoDataFrames. + + See the User Guide page :doc:`../../user_guide/mergingdata` for details. + + Parameters + ---------- + df : GeoDataFrame + how : string, default 'inner' + The type of join: + + * 'left': use keys from left_df; retain only left_df geometry column + * 'right': use keys from right_df; retain only right_df geometry column + * 'inner': use intersection of keys from both dfs; retain only + left_df geometry column + + predicate : string, default 'intersects' + Binary predicate. Valid values are determined by the spatial index used. + You can check the valid values in left_df or right_df as + ``left_df.sindex.valid_query_predicates`` or + ``right_df.sindex.valid_query_predicates`` + lsuffix : string, default 'left' + Suffix to apply to overlapping column names (left GeoDataFrame). + rsuffix : string, default 'right' + Suffix to apply to overlapping column names (right GeoDataFrame). + + Examples + -------- + >>> countries = geopandas.read_file( \ + geopandas.datasets.get_path("naturalearth_lowres")) + >>> cities = geopandas.read_file( \ + geopandas.datasets.get_path("naturalearth_cities")) + >>> countries.head() # doctest: +SKIP + pop_est continent name \ + iso_a3 gdp_md_est geometry + 0 920938 Oceania Fiji FJI 8374.0 \ + MULTIPOLYGON (((180.00000 -16.06713, 180.00000... + 1 53950935 Africa Tanzania TZA 150600.0 \ + POLYGON ((33.90371 -0.95000, 34.07262 -1.05982... + 2 603253 Africa W. Sahara ESH 906.5 \ + POLYGON ((-8.66559 27.65643, -8.66512 27.58948... + 3 35623680 North America Canada CAN 1674000.0 \ + MULTIPOLYGON (((-122.84000 49.00000, -122.9742... + 4 326625791 North America United States of America USA 18560000.0 \ + MULTIPOLYGON (((-122.84000 49.00000, -120.0000... + >>> cities.head() + name geometry + 0 Vatican City POINT (12.45339 41.90328) + 1 San Marino POINT (12.44177 43.93610) + 2 Vaduz POINT (9.51667 47.13372) + 3 Luxembourg POINT (6.13000 49.61166) + 4 Palikir POINT (158.14997 6.91664) + + >>> cities_w_country_data = cities.sjoin(countries) + >>> cities_w_country_data.head() # doctest: +SKIP + name_left geometry index_right pop_est \ + continent name_right iso_a3 gdp_md_est + 0 Vatican City POINT (12.45339 41.90328) 141 62137802 \ + Europe Italy ITA 2221000.0 + 1 San Marino POINT (12.44177 43.93610) 141 62137802 \ + Europe Italy ITA 2221000.0 + 192 Rome POINT (12.48131 41.89790) 141 62137802 \ + Europe Italy ITA 2221000.0 + 2 Vaduz POINT (9.51667 47.13372) 114 8754413 \ + Europe Au stria AUT 416600.0 + 184 Vienna POINT (16.36469 48.20196) 114 8754413 \ + Europe Austria AUT 416600.0 + + Notes + ------ + Every operation in GeoPandas is planar, i.e. the potential third + dimension is not taken into account. + + See also + -------- + GeoDataFrame.sjoin_nearest : nearest neighbor join + sjoin : equivalent top-level function + """ + return geopandas.sjoin(left_df=self, right_df=df, *args, **kwargs) + + def sjoin_nearest( + self, + right, + how="inner", + max_distance=None, + lsuffix="left", + rsuffix="right", + distance_col=None, + ): + """ + Spatial join of two GeoDataFrames based on the distance between their + geometries. + + Results will include multiple output records for a single input record + where there are multiple equidistant nearest or intersected neighbors. + + See the User Guide page + https://geopandas.readthedocs.io/en/latest/docs/user_guide/mergingdata.html + for more details. + + + Parameters + ---------- + right : GeoDataFrame + how : string, default 'inner' + The type of join: + + * 'left': use keys from left_df; retain only left_df geometry column + * 'right': use keys from right_df; retain only right_df geometry column + * 'inner': use intersection of keys from both dfs; retain only + left_df geometry column + + max_distance : float, default None + Maximum distance within which to query for nearest geometry. + Must be greater than 0. + The max_distance used to search for nearest items in the tree may have a + significant impact on performance by reducing the number of input + geometries that are evaluated for nearest items in the tree. + lsuffix : string, default 'left' + Suffix to apply to overlapping column names (left GeoDataFrame). + rsuffix : string, default 'right' + Suffix to apply to overlapping column names (right GeoDataFrame). + distance_col : string, default None + If set, save the distances computed between matching geometries under a + column of this name in the joined GeoDataFrame. + + Examples + -------- + >>> countries = geopandas.read_file(geopandas.datasets.get_\ +path("naturalearth_lowres")) + >>> cities = geopandas.read_file(geopandas.datasets.get_path("naturalearth_citi\ +es")) + >>> countries.head(2).name # doctest: +SKIP + pop_est continent name \ + iso_a3 gdp_md_est geometry + 0 920938 Oceania Fiji FJI 8374.0 MULTI\ + POLYGON (((180.00000 -16.06713, 180.00000... + 1 53950935 Africa Tanzania TZA 150600.0 POLYG\ + ON ((33.90371 -0.95000, 34.07262 -1.05982... + >>> cities.head(2).name # doctest: +SKIP + name geometry + 0 Vatican City POINT (12.45339 41.90328) + 1 San Marino POINT (12.44177 43.93610) + + >>> cities_w_country_data = cities.sjoin_nearest(countries) + >>> cities_w_country_data[['name_left', 'name_right']].head(2) # doctest: +SKIP + name_left geometry index_right pop_est continent n\ + ame_right iso_a3 gdp_md_est + 0 Vatican City POINT (12.45339 41.90328) 141 62137802 Europe \ + Italy ITA 2221000.0 + 1 San Marino POINT (12.44177 43.93610) 141 62137802 Europe \ + Italy ITA 2221000.0 + + To include the distances: + + >>> cities_w_country_data = cities.sjoin_nearest(countries, \ +distance_col="distances") + >>> cities_w_country_data[["name_left", "name_right", \ +"distances"]].head(2) # doctest: +SKIP + name_left name_right distances + 0 Vatican City Italy 0.0 + 1 San Marino Italy 0.0 + + In the following example, we get multiple cities for Italy because all results + are equidistant (in this case zero because they intersect). + In fact, we get 3 results in total: + + >>> countries_w_city_data = cities.sjoin_nearest(countries, \ +distance_col="distances", how="right") + >>> italy_results = \ +countries_w_city_data[countries_w_city_data["name_left"] == "Italy"] + >>> italy_results # doctest: +SKIP + name_x name_y + 141 Vatican City Italy + 141 San Marino Italy + 141 Rome Italy + + See also + -------- + GeoDataFrame.sjoin : binary predicate joins + sjoin_nearest : equivalent top-level function + + Notes + ----- + Since this join relies on distances, results will be inaccurate + if your geometries are in a geographic CRS. + + Every operation in GeoPandas is planar, i.e. the potential third + dimension is not taken into account. + """ + return geopandas.sjoin_nearest( + self, + right, + how=how, + max_distance=max_distance, + lsuffix=lsuffix, + rsuffix=rsuffix, + distance_col=distance_col, + ) + + def clip(self, mask, keep_geom_type=False): + """Clip points, lines, or polygon geometries to the mask extent. + + Both layers must be in the same Coordinate Reference System (CRS). + The GeoDataFrame will be clipped to the full extent of the `mask` object. + + If there are multiple polygons in mask, data from the GeoDataFrame will be + clipped to the total boundary of all polygons in mask. + + Parameters + ---------- + mask : GeoDataFrame, GeoSeries, (Multi)Polygon + Polygon vector layer used to clip `gdf`. + The mask's geometry is dissolved into one geometric feature + and intersected with `gdf`. + keep_geom_type : boolean, default False + If True, return only geometries of original type in case of intersection + resulting in multiple geometry types or GeometryCollections. + If False, return all resulting geometries (potentially mixed types). + + Returns + ------- + GeoDataFrame + Vector data (points, lines, polygons) from `gdf` clipped to + polygon boundary from mask. + + See also + -------- + clip : equivalent top-level function + + Examples + -------- + Clip points (global cities) with a polygon (the South American continent): + + >>> world = geopandas.read_file( + ... geopandas.datasets.get_path('naturalearth_lowres')) + >>> south_america = world[world['continent'] == "South America"] + >>> capitals = geopandas.read_file( + ... geopandas.datasets.get_path('naturalearth_cities')) + >>> capitals.shape + (202, 2) + + >>> sa_capitals = capitals.clip(south_america) + >>> sa_capitals.shape + (12, 2) + """ + return geopandas.clip(self, mask=mask, keep_geom_type=keep_geom_type) + + def overlay(self, right, how="intersection", keep_geom_type=None, make_valid=True): + """Perform spatial overlay between GeoDataFrames. + + Currently only supports data GeoDataFrames with uniform geometry types, + i.e. containing only (Multi)Polygons, or only (Multi)Points, or a + combination of (Multi)LineString and LinearRing shapes. + Implements several methods that are all effectively subsets of the union. + + See the User Guide page :doc:`../../user_guide/set_operations` for details. + + Parameters + ---------- + right : GeoDataFrame + how : string + Method of spatial overlay: 'intersection', 'union', + 'identity', 'symmetric_difference' or 'difference'. + keep_geom_type : bool + If True, return only geometries of the same geometry type the GeoDataFrame + has, if False, return all resulting geometries. Default is None, + which will set keep_geom_type to True but warn upon dropping + geometries. + make_valid : bool, default True + If True, any invalid input geometries are corrected with a call to + `buffer(0)`, if False, a `ValueError` is raised if any input geometries + are invalid. + + Returns + ------- + df : GeoDataFrame + GeoDataFrame with new set of polygons and attributes + resulting from the overlay + + Examples + -------- + >>> from shapely.geometry import Polygon + >>> polys1 = geopandas.GeoSeries([Polygon([(0,0), (2,0), (2,2), (0,2)]), + ... Polygon([(2,2), (4,2), (4,4), (2,4)])]) + >>> polys2 = geopandas.GeoSeries([Polygon([(1,1), (3,1), (3,3), (1,3)]), + ... Polygon([(3,3), (5,3), (5,5), (3,5)])]) + >>> df1 = geopandas.GeoDataFrame({'geometry': polys1, 'df1_data':[1,2]}) + >>> df2 = geopandas.GeoDataFrame({'geometry': polys2, 'df2_data':[1,2]}) + + >>> df1.overlay(df2, how='union') + df1_data df2_data geometry + 0 1.0 1.0 POLYGON ((2.00000 2.00000, 2.00000 1.00000, 1.... + 1 2.0 1.0 POLYGON ((2.00000 2.00000, 2.00000 3.00000, 3.... + 2 2.0 2.0 POLYGON ((4.00000 4.00000, 4.00000 3.00000, 3.... + 3 1.0 NaN POLYGON ((2.00000 0.00000, 0.00000 0.00000, 0.... + 4 2.0 NaN MULTIPOLYGON (((3.00000 3.00000, 4.00000 3.000... + 5 NaN 1.0 MULTIPOLYGON (((2.00000 2.00000, 3.00000 2.000... + 6 NaN 2.0 POLYGON ((3.00000 5.00000, 5.00000 5.00000, 5.... + + >>> df1.overlay(df2, how='intersection') + df1_data df2_data geometry + 0 1 1 POLYGON ((2.00000 2.00000, 2.00000 1.00000, 1.... + 1 2 1 POLYGON ((2.00000 2.00000, 2.00000 3.00000, 3.... + 2 2 2 POLYGON ((4.00000 4.00000, 4.00000 3.00000, 3.... + + >>> df1.overlay(df2, how='symmetric_difference') + df1_data df2_data geometry + 0 1.0 NaN POLYGON ((2.00000 0.00000, 0.00000 0.00000, 0.... + 1 2.0 NaN MULTIPOLYGON (((3.00000 3.00000, 4.00000 3.000... + 2 NaN 1.0 MULTIPOLYGON (((2.00000 2.00000, 3.00000 2.000... + 3 NaN 2.0 POLYGON ((3.00000 5.00000, 5.00000 5.00000, 5.... + + >>> df1.overlay(df2, how='difference') + geometry df1_data + 0 POLYGON ((2.00000 0.00000, 0.00000 0.00000, 0.... 1 + 1 MULTIPOLYGON (((3.00000 3.00000, 4.00000 3.000... 2 + + >>> df1.overlay(df2, how='identity') + df1_data df2_data geometry + 0 1.0 1.0 POLYGON ((2.00000 2.00000, 2.00000 1.00000, 1.... + 1 2.0 1.0 POLYGON ((2.00000 2.00000, 2.00000 3.00000, 3.... + 2 2.0 2.0 POLYGON ((4.00000 4.00000, 4.00000 3.00000, 3.... + 3 1.0 NaN POLYGON ((2.00000 0.00000, 0.00000 0.00000, 0.... + 4 2.0 NaN MULTIPOLYGON (((3.00000 3.00000, 4.00000 3.000... + + See also + -------- + GeoDataFrame.sjoin : spatial join + overlay : equivalent top-level function + + Notes + ------ + Every operation in GeoPandas is planar, i.e. the potential third + dimension is not taken into account. + """ + return geopandas.overlay( + self, right, how=how, keep_geom_type=keep_geom_type, make_valid=make_valid + ) + def _dataframe_set_geometry(self, col, drop=False, inplace=False, crs=None): if inplace: @@ -1157,3 +2246,6 @@ def _dataframe_set_geometry(self, col, drop=False, inplace=False, crs=None): DataFrame.set_geometry = _dataframe_set_geometry + +if compat.PANDAS_GE_10 and not compat.PANDAS_GE_11: # i.e. on pandas 1.0.x + _geodataframe_constructor_with_fallback._from_axes = GeoDataFrame._from_axes diff --git a/geopandas/geoseries.py b/geopandas/geoseries.py index ba73e69..2452bed 100644 --- a/geopandas/geoseries.py +++ b/geopandas/geoseries.py @@ -3,18 +3,29 @@ import warnings import numpy as np import pandas as pd -from pandas import Series +from pandas import Series, MultiIndex from pandas.core.internals import SingleBlockManager -from pyproj import CRS, Transformer +from pyproj import CRS from shapely.geometry.base import BaseGeometry from geopandas.base import GeoPandasBase, _delegate_property from geopandas.plotting import plot_series +from geopandas.explore import _explore_geoseries +import geopandas -from .array import GeometryArray, GeometryDtype, from_shapely +from . import _compat as compat +from ._decorator import doc +from .array import ( + GeometryDtype, + from_shapely, + from_wkb, + from_wkt, + points_from_xy, + to_wkb, + to_wkt, +) from .base import is_geometry_type -from . import _vectorized as vectorized _SERIES_WARNING_MSG = """\ @@ -42,24 +53,6 @@ def _geoseries_constructor_with_fallback(data=None, index=None, crs=None, **kwar return Series(data=data, index=index, **kwargs) -def inherit_doc(cls): - """ - A decorator adding a docstring from an existing method. - """ - - def decorator(decorated): - original_method = getattr(cls, decorated.__name__, None) - if original_method: - doc = original_method.__doc__ or "" - else: - doc = "" - - decorated.__doc__ = doc - return decorated - - return decorator - - class GeoSeries(GeoPandasBase, Series): """ A Series object designed to store shapely geometry objects. @@ -85,11 +78,52 @@ class GeoSeries(GeoPandasBase, Series): >>> from shapely.geometry import Point >>> s = geopandas.GeoSeries([Point(1, 1), Point(2, 2), Point(3, 3)]) >>> s - 0 POINT (1 1) - 1 POINT (2 2) - 2 POINT (3 3) + 0 POINT (1.00000 1.00000) + 1 POINT (2.00000 2.00000) + 2 POINT (3.00000 3.00000) dtype: geometry + >>> s = geopandas.GeoSeries( + ... [Point(1, 1), Point(2, 2), Point(3, 3)], crs="EPSG:3857" + ... ) + >>> s.crs # doctest: +SKIP + + Name: WGS 84 / Pseudo-Mercator + Axis Info [cartesian]: + - X[east]: Easting (metre) + - Y[north]: Northing (metre) + Area of Use: + - name: World - 85°S to 85°N + - bounds: (-180.0, -85.06, 180.0, 85.06) + Coordinate Operation: + - name: Popular Visualisation Pseudo-Mercator + - method: Popular Visualisation Pseudo Mercator + Datum: World Geodetic System 1984 + - Ellipsoid: WGS 84 + - Prime Meridian: Greenwich + + >>> s = geopandas.GeoSeries( + ... [Point(1, 1), Point(2, 2), Point(3, 3)], index=["a", "b", "c"], crs=4326 + ... ) + >>> s + a POINT (1.00000 1.00000) + b POINT (2.00000 2.00000) + c POINT (3.00000 3.00000) + dtype: geometry + + >>> s.crs + + Name: WGS 84 + Axis Info [ellipsoidal]: + - Lat[north]: Geodetic latitude (degree) + - Lon[east]: Geodetic longitude (degree) + Area of Use: + - name: World. + - bounds: (-180.0, -90.0, 180.0, 90.0) + Datum: World Geodetic System 1984 ensemble + - Ellipsoid: WGS 84 + - Prime Meridian: Greenwich + See Also -------- GeoDataFrame @@ -109,17 +143,12 @@ class GeoSeries(GeoPandasBase, Series): data = data.copy() else: if not data.crs == crs: - warnings.warn( + raise ValueError( "CRS mismatch between CRS of the passed geometries " - "and 'crs'. Use 'GeoDataFrame.set_crs(crs, " + "and 'crs'. Use 'GeoSeries.set_crs(crs, " "allow_override=True)' to overwrite CRS or " "'GeoSeries.to_crs(crs)' to reproject geometries. " - "CRS mismatch will raise an error in the future versions " - "of GeoPandas.", - FutureWarning, - stacklevel=2, ) - # TODO: raise error in 0.9 or 0.10. if isinstance(data, SingleBlockManager): if isinstance(data.blocks[0].dtype, GeometryDtype): @@ -155,10 +184,18 @@ class GeoSeries(GeoPandasBase, Series): # https://github.com/pandas-dev/pandas/issues/26469 kwargs.pop("dtype", None) # Use Series constructor to handle input data - s = pd.Series(data, index=index, name=name, **kwargs) + with compat.ignore_shapely2_warnings(): + # suppress additional warning from pandas for empty data + # (will always give object dtype instead of float dtype in the future, + # making the `if s.empty: s = s.astype(object)` below unnecessary) + empty_msg = "The default dtype for empty Series" + warnings.filterwarnings("ignore", empty_msg, DeprecationWarning) + warnings.filterwarnings("ignore", empty_msg, FutureWarning) + s = pd.Series(data, index=index, name=name, **kwargs) # prevent trying to convert non-geometry objects if s.dtype != object: - if s.empty: + if (s.empty and s.dtype == "float64") or data is None: + # pd.Series with empty data gives float64 for older pandas versions s = s.astype(object) else: warnings.warn(_SERIES_WARNING_MSG, FutureWarning, stacklevel=2) @@ -177,7 +214,6 @@ class GeoSeries(GeoPandasBase, Series): if not self.crs: self.crs = crs - self._invalidate_sindex() return self def __init__(self, *args, **kwargs): @@ -194,20 +230,96 @@ class GeoSeries(GeoPandasBase, Series): @property def x(self): - """Return the x location of point geometries in a GeoSeries""" + """Return the x location of point geometries in a GeoSeries + + Returns + ------- + pandas.Series + + Examples + -------- + + >>> from shapely.geometry import Point + >>> s = geopandas.GeoSeries([Point(1, 1), Point(2, 2), Point(3, 3)]) + >>> s.x + 0 1.0 + 1 2.0 + 2 3.0 + dtype: float64 + + See Also + -------- + + GeoSeries.y + GeoSeries.z + + """ return _delegate_property("x", self) @property def y(self): - """Return the y location of point geometries in a GeoSeries""" + """Return the y location of point geometries in a GeoSeries + + Returns + ------- + pandas.Series + + Examples + -------- + + >>> from shapely.geometry import Point + >>> s = geopandas.GeoSeries([Point(1, 1), Point(2, 2), Point(3, 3)]) + >>> s.y + 0 1.0 + 1 2.0 + 2 3.0 + dtype: float64 + + See Also + -------- + + GeoSeries.x + GeoSeries.z + + """ return _delegate_property("y", self) + @property + def z(self): + """Return the z location of point geometries in a GeoSeries + + Returns + ------- + pandas.Series + + Examples + -------- + + >>> from shapely.geometry import Point + >>> s = geopandas.GeoSeries([Point(1, 1, 1), Point(2, 2, 2), Point(3, 3, 3)]) + >>> s.z + 0 1.0 + 1 2.0 + 2 3.0 + dtype: float64 + + See Also + -------- + + GeoSeries.x + GeoSeries.y + + """ + return _delegate_property("z", self) + @classmethod def from_file(cls, filename, **kwargs): """Alternate constructor to create a ``GeoSeries`` from a file. Can load a ``GeoSeries`` from a file from any format recognized by `fiona`. See http://fiona.readthedocs.io/en/latest/manual.html for details. + From a file with attributes loads only geometry column. Note that to do + that, GeoPandas first loads the whole GeoDataFrame. Parameters ---------- @@ -219,6 +331,23 @@ class GeoSeries(GeoPandasBase, Series): These arguments are passed to fiona.open, and can be used to access multi-layer data, data stored within archives (zip files), etc. + + Examples + -------- + + >>> path = geopandas.datasets.get_path('nybb') + >>> s = geopandas.GeoSeries.from_file(path) + >>> s + 0 MULTIPOLYGON (((970217.022 145643.332, 970227.... + 1 MULTIPOLYGON (((1029606.077 156073.814, 102957... + 2 MULTIPOLYGON (((1021176.479 151374.797, 102100... + 3 MULTIPOLYGON (((981219.056 188655.316, 980940.... + 4 MULTIPOLYGON (((1012821.806 229228.265, 101278... + Name: geometry, dtype: geometry + + See Also + -------- + read_file : read file to GeoDataFame """ from geopandas import GeoDataFrame @@ -226,6 +355,152 @@ class GeoSeries(GeoPandasBase, Series): return GeoSeries(df.geometry, crs=df.crs) + @classmethod + def from_wkb(cls, data, index=None, crs=None, **kwargs): + """ + Alternate constructor to create a ``GeoSeries`` + from a list or array of WKB objects + + Parameters + ---------- + data : array-like or Series + Series, list or array of WKB objects + index : array-like or Index + The index for the GeoSeries. + crs : value, optional + Coordinate Reference System of the geometry objects. Can be anything + accepted by + :meth:`pyproj.CRS.from_user_input() `, + such as an authority string (eg "EPSG:4326") or a WKT string. + kwargs + Additional arguments passed to the Series constructor, + e.g. ``name``. + + Returns + ------- + GeoSeries + + See Also + -------- + GeoSeries.from_wkt + + """ + return cls._from_wkb_or_wkb(from_wkb, data, index=index, crs=crs, **kwargs) + + @classmethod + def from_wkt(cls, data, index=None, crs=None, **kwargs): + """ + Alternate constructor to create a ``GeoSeries`` + from a list or array of WKT objects + + Parameters + ---------- + data : array-like, Series + Series, list, or array of WKT objects + index : array-like or Index + The index for the GeoSeries. + crs : value, optional + Coordinate Reference System of the geometry objects. Can be anything + accepted by + :meth:`pyproj.CRS.from_user_input() `, + such as an authority string (eg "EPSG:4326") or a WKT string. + kwargs + Additional arguments passed to the Series constructor, + e.g. ``name``. + + Returns + ------- + GeoSeries + + See Also + -------- + GeoSeries.from_wkb + + Examples + -------- + + >>> wkts = [ + ... 'POINT (1 1)', + ... 'POINT (2 2)', + ... 'POINT (3 3)', + ... ] + >>> s = geopandas.GeoSeries.from_wkt(wkts) + >>> s + 0 POINT (1.00000 1.00000) + 1 POINT (2.00000 2.00000) + 2 POINT (3.00000 3.00000) + dtype: geometry + """ + return cls._from_wkb_or_wkb(from_wkt, data, index=index, crs=crs, **kwargs) + + @classmethod + def from_xy(cls, x, y, z=None, index=None, crs=None, **kwargs): + """ + Alternate constructor to create a :class:`~geopandas.GeoSeries` of Point + geometries from lists or arrays of x, y(, z) coordinates + + In case of geographic coordinates, it is assumed that longitude is captured + by ``x`` coordinates and latitude by ``y``. + + Parameters + ---------- + x, y, z : iterable + index : array-like or Index, optional + The index for the GeoSeries. If not given and all coordinate inputs + are Series with an equal index, that index is used. + crs : value, optional + Coordinate Reference System of the geometry objects. Can be anything + accepted by + :meth:`pyproj.CRS.from_user_input() `, + such as an authority string (eg "EPSG:4326") or a WKT string. + **kwargs + Additional arguments passed to the Series constructor, + e.g. ``name``. + + Returns + ------- + GeoSeries + + See Also + -------- + GeoSeries.from_wkt + points_from_xy + + Examples + -------- + + >>> x = [2.5, 5, -3.0] + >>> y = [0.5, 1, 1.5] + >>> s = geopandas.GeoSeries.from_xy(x, y, crs="EPSG:4326") + >>> s + 0 POINT (2.50000 0.50000) + 1 POINT (5.00000 1.00000) + 2 POINT (-3.00000 1.50000) + dtype: geometry + """ + if index is None: + if ( + isinstance(x, Series) + and isinstance(y, Series) + and x.index.equals(y.index) + and (z is None or (isinstance(z, Series) and x.index.equals(z.index))) + ): # check if we can reuse index + index = x.index + return cls(points_from_xy(x, y, z, crs=crs), index=index, crs=crs, **kwargs) + + @classmethod + def _from_wkb_or_wkb( + cls, from_wkb_or_wkt_function, data, index=None, crs=None, **kwargs + ): + """Create a GeoSeries from either WKT or WKB values""" + if isinstance(data, Series): + if index is not None: + data = data.reindex(index) + else: + index = data.index + data = data.values + return cls(from_wkb_or_wkt_function(data, crs=crs), index=index, **kwargs) + @property def __geo_interface__(self): """Returns a ``GeoSeries`` as a python feature collection. @@ -234,12 +509,26 @@ class GeoSeries(GeoPandasBase, Series): represents the ``GeoSeries`` as a GeoJSON-like ``FeatureCollection``. Note that the features will have an empty ``properties`` dict as they don't have associated attributes (geometry only). + + Examples + -------- + + >>> from shapely.geometry import Point + >>> s = geopandas.GeoSeries([Point(1, 1), Point(2, 2), Point(3, 3)]) + >>> s.__geo_interface__ + {'type': 'FeatureCollection', 'features': [{'id': '0', 'type': 'Feature', \ +'properties': {}, 'geometry': {'type': 'Point', 'coordinates': (1.0, 1.0)}, \ +'bbox': (1.0, 1.0, 1.0, 1.0)}, {'id': '1', 'type': 'Feature', \ +'properties': {}, 'geometry': {'type': 'Point', 'coordinates': (2.0, 2.0)}, \ +'bbox': (2.0, 2.0, 2.0, 2.0)}, {'id': '2', 'type': 'Feature', 'properties': \ +{}, 'geometry': {'type': 'Point', 'coordinates': (3.0, 3.0)}, 'bbox': (3.0, \ +3.0, 3.0, 3.0)}], 'bbox': (1.0, 1.0, 3.0, 3.0)} """ from geopandas import GeoDataFrame return GeoDataFrame({"geometry": self}).__geo_interface__ - def to_file(self, filename, driver="ESRI Shapefile", index=None, **kwargs): + def to_file(self, filename, driver=None, index=None, **kwargs): """Write the ``GeoSeries`` to a file. By default, an ESRI shapefile is written, but any OGR data source @@ -249,8 +538,10 @@ class GeoSeries(GeoPandasBase, Series): ---------- filename : string File path or file handle to write to. - driver : string, default: 'ESRI Shapefile' + driver : string, default None The OGR format driver used to write the vector file. + If not specified, it attempts to infer it from the file extension. + If no extension is specified, it saves ESRI Shapefile to a folder. index : bool, default None If True, write index into one or more columns (for MultiIndex). Default None writes the index into one or more columns only if @@ -268,7 +559,17 @@ class GeoSeries(GeoPandasBase, Series): See Also -------- - GeoDataFrame.to_file + GeoDataFrame.to_file : write GeoDataFrame to file + read_file : read file to GeoDataFame + + Examples + -------- + + >>> s.to_file('series.shp') # doctest: +SKIP + + >>> s.to_file('series.gpkg', driver='GPKG', layer='name1') # doctest: +SKIP + + >>> s.to_file('series.geojson', driver='GeoJSON') # doctest: +SKIP """ from geopandas import GeoDataFrame @@ -292,43 +593,35 @@ class GeoSeries(GeoPandasBase, Series): def _wrapped_pandas_method(self, mtd, *args, **kwargs): """Wrap a generic pandas method to ensure it returns a GeoSeries""" - val = getattr(super(GeoSeries, self), mtd)(*args, **kwargs) + val = getattr(super(), mtd)(*args, **kwargs) if type(val) == Series: val.__class__ = GeoSeries val.crs = self.crs - val._invalidate_sindex() return val def __getitem__(self, key): return self._wrapped_pandas_method("__getitem__", key) - @inherit_doc(pd.Series) + @doc(pd.Series) def sort_index(self, *args, **kwargs): return self._wrapped_pandas_method("sort_index", *args, **kwargs) - @inherit_doc(pd.Series) + @doc(pd.Series) def take(self, *args, **kwargs): return self._wrapped_pandas_method("take", *args, **kwargs) - @inherit_doc(pd.Series) + @doc(pd.Series) def select(self, *args, **kwargs): return self._wrapped_pandas_method("select", *args, **kwargs) - @inherit_doc(pd.Series) - def apply(self, func, args=(), **kwargs): - result = super().apply(func, args=args, **kwargs) + @doc(pd.Series) + def apply(self, func, convert_dtype=True, args=(), **kwargs): + result = super().apply(func, convert_dtype=convert_dtype, args=args, **kwargs) if isinstance(result, GeoSeries): if self.crs is not None: result.set_crs(self.crs, inplace=True) return result - def __finalize__(self, other, method=None, **kwargs): - """ propagate metadata from other to self """ - # NOTE: backported from pandas master (upcoming v0.13) - for name in self._metadata: - object.__setattr__(self, name, getattr(other, name, None)) - return self - def isna(self): """ Detect missing values. @@ -344,27 +637,30 @@ class GeoSeries(GeoPandasBase, Series): A boolean pandas Series of the same size as the GeoSeries, True where a value is NA. + Examples + -------- + + >>> from shapely.geometry import Polygon + >>> s = geopandas.GeoSeries( + ... [Polygon([(0, 0), (1, 1), (0, 1)]), None, Polygon([])] + ... ) + >>> s + 0 POLYGON ((0.00000 0.00000, 1.00000 1.00000, 0.... + 1 None + 2 GEOMETRYCOLLECTION EMPTY + dtype: geometry + >>> s.isna() + 0 False + 1 True + 2 False + dtype: bool + See Also -------- GeoSeries.notna : inverse of isna GeoSeries.is_empty : detect empty geometries """ - if self.is_empty.any(): - warnings.warn( - "GeoSeries.isna() previously returned True for both missing (None) " - "and empty geometries. Now, it only returns True for missing values. " - "Since the calling GeoSeries contains empty geometries, the result " - "has changed compared to previous versions of GeoPandas.\n" - "Given a GeoSeries 's', you can use 's.is_empty | s.isna()' to get " - "back the old behaviour.\n\n" - "To further ignore this warning, you can do: \n" - "import warnings; warnings.filterwarnings('ignore', 'GeoSeries.isna', " - "UserWarning)", - UserWarning, - stacklevel=2, - ) - - return super(GeoSeries, self).isna() + return super().isna() def isnull(self): """Alias for `isna` method. See `isna` for more detail.""" @@ -385,6 +681,24 @@ class GeoSeries(GeoPandasBase, Series): A boolean pandas Series of the same size as the GeoSeries, False where a value is NA. + Examples + -------- + + >>> from shapely.geometry import Polygon + >>> s = geopandas.GeoSeries( + ... [Polygon([(0, 0), (1, 1), (0, 1)]), None, Polygon([])] + ... ) + >>> s + 0 POLYGON ((0.00000 0.00000, 1.00000 1.00000, 0.... + 1 None + 2 GEOMETRYCOLLECTION EMPTY + dtype: geometry + >>> s.notna() + 0 True + 1 False + 2 True + dtype: bool + See Also -------- GeoSeries.isna : inverse of notna @@ -404,7 +718,7 @@ class GeoSeries(GeoPandasBase, Series): UserWarning, stacklevel=2, ) - return super(GeoSeries, self).notna() + return super().notna() def notnull(self): """Alias for `notna` method. See `notna` for more detail.""" @@ -414,12 +728,43 @@ class GeoSeries(GeoPandasBase, Series): """Fill NA values with a geometry (empty polygon by default). "method" is currently not implemented for pandas <= 0.12. + + Examples + -------- + + >>> from shapely.geometry import Polygon + >>> s = geopandas.GeoSeries( + ... [ + ... Polygon([(0, 0), (1, 1), (0, 1)]), + ... None, + ... Polygon([(0, 0), (-1, 1), (0, -1)]), + ... ] + ... ) + >>> s + 0 POLYGON ((0.00000 0.00000, 1.00000 1.00000, 0.... + 1 None + 2 POLYGON ((0.00000 0.00000, -1.00000 1.00000, 0... + dtype: geometry + + >>> s.fillna() + 0 POLYGON ((0.00000 0.00000, 1.00000 1.00000, 0.... + 1 GEOMETRYCOLLECTION EMPTY + 2 POLYGON ((0.00000 0.00000, -1.00000 1.00000, 0... + dtype: geometry + + >>> s.fillna(Polygon([(0, 1), (2, 1), (1, 2)])) + 0 POLYGON ((0.00000 0.00000, 1.00000 1.00000, 0.... + 1 POLYGON ((0.00000 1.00000, 2.00000 1.00000, 1.... + 2 POLYGON ((0.00000 0.00000, -1.00000 1.00000, 0... + dtype: geometry + + See Also + -------- + GeoSeries.isna : detect missing values """ if value is None: value = BaseGeometry() - return super(GeoSeries, self).fillna( - value=value, method=method, inplace=inplace, **kwargs - ) + return super().fillna(value=value, method=method, inplace=inplace, **kwargs) def __contains__(self, other): """Allow tests of the form "geom in s" @@ -433,15 +778,144 @@ class GeoSeries(GeoPandasBase, Series): else: return False + @doc(plot_series) def plot(self, *args, **kwargs): - """Generate a plot of the geometries in the ``GeoSeries``. - - Wraps the ``plot_series()`` function, and documentation is copied from - there. - """ return plot_series(self, *args, **kwargs) - plot.__doc__ = plot_series.__doc__ + @doc(_explore_geoseries) + def explore(self, *args, **kwargs): + """Interactive map based on folium/leaflet.js""" + return _explore_geoseries(self, *args, **kwargs) + + def explode(self, ignore_index=False, index_parts=None): + """ + Explode multi-part geometries into multiple single geometries. + + Single rows can become multiple rows. + This is analogous to PostGIS's ST_Dump(). The 'path' index is the + second level of the returned MultiIndex + + Parameters + ---------- + ignore_index : bool, default False + If True, the resulting index will be labelled 0, 1, …, n - 1, + ignoring `index_parts`. + index_parts : boolean, default True + If True, the resulting index will be a multi-index (original + index with an additional level indicating the multiple + geometries: a new zero-based index for each single part geometry + per multi-part geometry). + + Returns + ------- + A GeoSeries with a MultiIndex. The levels of the MultiIndex are the + original index and a zero-based integer index that counts the + number of single geometries within a multi-part geometry. + + Examples + -------- + >>> from shapely.geometry import MultiPoint + >>> s = geopandas.GeoSeries( + ... [MultiPoint([(0, 0), (1, 1)]), MultiPoint([(2, 2), (3, 3), (4, 4)])] + ... ) + >>> s + 0 MULTIPOINT (0.00000 0.00000, 1.00000 1.00000) + 1 MULTIPOINT (2.00000 2.00000, 3.00000 3.00000, ... + dtype: geometry + + >>> s.explode(index_parts=True) + 0 0 POINT (0.00000 0.00000) + 1 POINT (1.00000 1.00000) + 1 0 POINT (2.00000 2.00000) + 1 POINT (3.00000 3.00000) + 2 POINT (4.00000 4.00000) + dtype: geometry + + See also + -------- + GeoDataFrame.explode + + """ + if index_parts is None and not ignore_index: + warnings.warn( + "Currently, index_parts defaults to True, but in the future, " + "it will default to False to be consistent with Pandas. " + "Use `index_parts=True` to keep the current behavior and True/False " + "to silence the warning.", + FutureWarning, + stacklevel=2, + ) + index_parts = True + + if compat.USE_PYGEOS and compat.PYGEOS_GE_09: + import pygeos # noqa + + geometries, outer_idx = pygeos.get_parts( + self.values.data, return_index=True + ) + + if len(outer_idx): + # Generate inner index as a range per value of outer_idx + # 1. identify the start of each run of values in outer_idx + # 2. count number of values per run + # 3. use cumulative sums to create an incremental range + # starting at 0 in each run + run_start = np.r_[True, outer_idx[:-1] != outer_idx[1:]] + counts = np.diff(np.r_[np.nonzero(run_start)[0], len(outer_idx)]) + inner_index = (~run_start).cumsum() + inner_index -= np.repeat(inner_index[run_start], counts) + + else: + inner_index = [] + + # extract original index values based on integer index + outer_index = self.index.take(outer_idx) + if ignore_index: + index = range(len(geometries)) + + elif index_parts: + nlevels = outer_index.nlevels + index_arrays = [ + outer_index.get_level_values(lvl) for lvl in range(nlevels) + ] + index_arrays.append(inner_index) + + index = MultiIndex.from_arrays( + index_arrays, names=self.index.names + [None] + ) + + else: + index = outer_index + + return GeoSeries(geometries, index=index, crs=self.crs).__finalize__(self) + + # else PyGEOS is not available or version <= 0.8 + + index = [] + geometries = [] + for idx, s in self.geometry.items(): + if s.type.startswith("Multi") or s.type == "GeometryCollection": + geoms = s.geoms + idxs = [(idx, i) for i in range(len(geoms))] + else: + geoms = [s] + idxs = [(idx, 0)] + index.extend(idxs) + geometries.extend(geoms) + + if ignore_index: + index = range(len(geometries)) + + elif index_parts: + # if self.index is a MultiIndex then index is a list of nested tuples + if isinstance(self.index, MultiIndex): + index = [tuple(outer) + (inner,) for outer, inner in index] + index = MultiIndex.from_tuples(index, names=self.index.names + [None]) + + else: + index = [idx for idx, _ in index] + + return GeoSeries(geometries, index=index, crs=self.crs).__finalize__(self) # # Additional methods @@ -473,6 +947,50 @@ class GeoSeries(GeoPandasBase, Series): Returns ------- GeoSeries + + Examples + -------- + >>> from shapely.geometry import Point + >>> s = geopandas.GeoSeries([Point(1, 1), Point(2, 2), Point(3, 3)]) + >>> s + 0 POINT (1.00000 1.00000) + 1 POINT (2.00000 2.00000) + 2 POINT (3.00000 3.00000) + dtype: geometry + + Setting CRS to a GeoSeries without one: + + >>> s.crs is None + True + + >>> s = s.set_crs('epsg:3857') + >>> s.crs # doctest: +SKIP + + Name: WGS 84 / Pseudo-Mercator + Axis Info [cartesian]: + - X[east]: Easting (metre) + - Y[north]: Northing (metre) + Area of Use: + - name: World - 85°S to 85°N + - bounds: (-180.0, -85.06, 180.0, 85.06) + Coordinate Operation: + - name: Popular Visualisation Pseudo-Mercator + - method: Popular Visualisation Pseudo Mercator + Datum: World Geodetic System 1984 + - Ellipsoid: WGS 84 + - Prime Meridian: Greenwich + + Overriding existing CRS: + + >>> s = s.set_crs(4326, allow_override=True) + + Without ``allow_override=True``, ``set_crs`` returns an error if you try to + override CRS. + + See Also + -------- + GeoSeries.to_crs : re-project to another CRS + """ if crs is not None: crs = CRS.from_user_input(crs) @@ -521,30 +1039,100 @@ class GeoSeries(GeoPandasBase, Series): Returns ------- GeoSeries + + Examples + -------- + >>> from shapely.geometry import Point + >>> s = geopandas.GeoSeries([Point(1, 1), Point(2, 2), Point(3, 3)], crs=4326) + >>> s + 0 POINT (1.00000 1.00000) + 1 POINT (2.00000 2.00000) + 2 POINT (3.00000 3.00000) + dtype: geometry + >>> s.crs # doctest: +SKIP + + Name: WGS 84 + Axis Info [ellipsoidal]: + - Lat[north]: Geodetic latitude (degree) + - Lon[east]: Geodetic longitude (degree) + Area of Use: + - name: World + - bounds: (-180.0, -90.0, 180.0, 90.0) + Datum: World Geodetic System 1984 + - Ellipsoid: WGS 84 + - Prime Meridian: Greenwich + + >>> s = s.to_crs(3857) + >>> s + 0 POINT (111319.491 111325.143) + 1 POINT (222638.982 222684.209) + 2 POINT (333958.472 334111.171) + dtype: geometry + >>> s.crs # doctest: +SKIP + + Name: WGS 84 / Pseudo-Mercator + Axis Info [cartesian]: + - X[east]: Easting (metre) + - Y[north]: Northing (metre) + Area of Use: + - name: World - 85°S to 85°N + - bounds: (-180.0, -85.06, 180.0, 85.06) + Coordinate Operation: + - name: Popular Visualisation Pseudo-Mercator + - method: Popular Visualisation Pseudo Mercator + Datum: World Geodetic System 1984 + - Ellipsoid: WGS 84 + - Prime Meridian: Greenwich + + See Also + -------- + GeoSeries.set_crs : assign CRS + """ - if self.crs is None: - raise ValueError( - "Cannot transform naive geometries. " - "Please set a crs on the object first." - ) - if crs is not None: - crs = CRS.from_user_input(crs) - elif epsg is not None: - crs = CRS.from_epsg(epsg) - else: - raise ValueError("Must pass either crs or epsg.") - - # skip if the input CRS and output CRS are the exact same - if self.crs.is_exact_same(crs): - return self - - transformer = Transformer.from_crs(self.crs, crs, always_xy=True) - - new_data = vectorized.transform(self.values.data, transformer.transform) return GeoSeries( - GeometryArray(new_data), crs=crs, index=self.index, name=self.name + self.values.to_crs(crs=crs, epsg=epsg), index=self.index, name=self.name ) + def estimate_utm_crs(self, datum_name="WGS 84"): + """Returns the estimated UTM CRS based on the bounds of the dataset. + + .. versionadded:: 0.9 + + .. note:: Requires pyproj 3+ + + Parameters + ---------- + datum_name : str, optional + The name of the datum to use in the query. Default is WGS 84. + + Returns + ------- + pyproj.CRS + + Examples + -------- + >>> world = geopandas.read_file( + ... geopandas.datasets.get_path("naturalearth_lowres") + ... ) + >>> germany = world.loc[world.name == "Germany"] + >>> germany.geometry.estimate_utm_crs() # doctest: +SKIP + + Name: WGS 84 / UTM zone 32N + Axis Info [cartesian]: + - E[east]: Easting (metre) + - N[north]: Northing (metre) + Area of Use: + - name: World - N hemisphere - 6°E to 12°E - by country + - bounds: (6.0, 0.0, 12.0, 84.0) + Coordinate Operation: + - name: UTM zone 32N + - method: Transverse Mercator + Datum: World Geodetic System 1984 + - Ellipsoid: WGS 84 + - Prime Meridian: Greenwich + """ + return self.values.estimate_utm_crs(datum_name) + def to_json(self, **kwargs): """ Returns a GeoJSON string representation of the GeoSeries. @@ -552,9 +1140,96 @@ class GeoSeries(GeoPandasBase, Series): Parameters ---------- *kwargs* that will be passed to json.dumps(). + + Returns + ------- + JSON string + + Examples + -------- + >>> from shapely.geometry import Point + >>> s = geopandas.GeoSeries([Point(1, 1), Point(2, 2), Point(3, 3)]) + >>> s + 0 POINT (1.00000 1.00000) + 1 POINT (2.00000 2.00000) + 2 POINT (3.00000 3.00000) + dtype: geometry + + >>> s.to_json() + '{"type": "FeatureCollection", "features": [{"id": "0", "type": "Feature", "pr\ +operties": {}, "geometry": {"type": "Point", "coordinates": [1.0, 1.0]}, "bbox": [1.0,\ + 1.0, 1.0, 1.0]}, {"id": "1", "type": "Feature", "properties": {}, "geometry": {"type"\ +: "Point", "coordinates": [2.0, 2.0]}, "bbox": [2.0, 2.0, 2.0, 2.0]}, {"id": "2", "typ\ +e": "Feature", "properties": {}, "geometry": {"type": "Point", "coordinates": [3.0, 3.\ +0]}, "bbox": [3.0, 3.0, 3.0, 3.0]}], "bbox": [1.0, 1.0, 3.0, 3.0]}' + + See Also + -------- + GeoSeries.to_file : write GeoSeries to file """ return json.dumps(self.__geo_interface__, **kwargs) + def to_wkb(self, hex=False, **kwargs): + """ + Convert GeoSeries geometries to WKB + + Parameters + ---------- + hex : bool + If true, export the WKB as a hexadecimal string. + The default is to return a binary bytes object. + kwargs + Additional keyword args will be passed to + :func:`pygeos.to_wkb` if pygeos is installed. + + Returns + ------- + Series + WKB representations of the geometries + + See also + -------- + GeoSeries.to_wkt + """ + return Series(to_wkb(self.array, hex=hex, **kwargs), index=self.index) + + def to_wkt(self, **kwargs): + """ + Convert GeoSeries geometries to WKT + + Parameters + ---------- + kwargs + Keyword args will be passed to :func:`pygeos.to_wkt` + if pygeos is installed. + + Returns + ------- + Series + WKT representations of the geometries + + Examples + -------- + >>> from shapely.geometry import Point + >>> s = geopandas.GeoSeries([Point(1, 1), Point(2, 2), Point(3, 3)]) + >>> s + 0 POINT (1.00000 1.00000) + 1 POINT (2.00000 2.00000) + 2 POINT (3.00000 3.00000) + dtype: geometry + + >>> s.to_wkt() + 0 POINT (1 1) + 1 POINT (2 2) + 2 POINT (3 3) + dtype: object + + See also + -------- + GeoSeries.to_wkb + """ + return Series(to_wkt(self.array, **kwargs), index=self.index) + # # Implement standard operators for GeoSeries # @@ -595,3 +1270,51 @@ class GeoSeries(GeoPandasBase, Series): stacklevel=2, ) return self.difference(other) + + def clip(self, mask, keep_geom_type=False): + """Clip points, lines, or polygon geometries to the mask extent. + + Both layers must be in the same Coordinate Reference System (CRS). + The GeoSeries will be clipped to the full extent of the `mask` object. + + If there are multiple polygons in mask, data from the GeoSeries will be + clipped to the total boundary of all polygons in mask. + + Parameters + ---------- + mask : GeoDataFrame, GeoSeries, (Multi)Polygon + Polygon vector layer used to clip `gdf`. + The mask's geometry is dissolved into one geometric feature + and intersected with `gdf`. + keep_geom_type : boolean, default False + If True, return only geometries of original type in case of intersection + resulting in multiple geometry types or GeometryCollections. + If False, return all resulting geometries (potentially mixed-types). + + Returns + ------- + GeoSeries + Vector data (points, lines, polygons) from `gdf` clipped to + polygon boundary from mask. + + See also + -------- + clip : top-level function for clip + + Examples + -------- + Clip points (global cities) with a polygon (the South American continent): + + >>> world = geopandas.read_file( + ... geopandas.datasets.get_path('naturalearth_lowres')) + >>> south_america = world[world['continent'] == "South America"] + >>> capitals = geopandas.read_file( + ... geopandas.datasets.get_path('naturalearth_cities')) + >>> capitals.shape + (202, 2) + + >>> sa_capitals = capitals.geometry.clip(south_america) + >>> sa_capitals.shape + (12,) + """ + return geopandas.clip(self, mask=mask, keep_geom_type=keep_geom_type) diff --git a/geopandas/io/arrow.py b/geopandas/io/arrow.py index acd574f..2421211 100644 --- a/geopandas/io/arrow.py +++ b/geopandas/io/arrow.py @@ -1,14 +1,14 @@ -from distutils.version import LooseVersion +from packaging.version import Version import json import warnings from pandas import DataFrame from geopandas._compat import import_optional_dependency -from geopandas.array import from_wkb, to_wkb +from geopandas.array import from_wkb from geopandas import GeoDataFrame import geopandas - +from .file import _expand_user METADATA_VERSION = "0.1.0" # reference: https://github.com/geopandas/geo-arrow-spec @@ -32,6 +32,14 @@ METADATA_VERSION = "0.1.0" # } +def _is_fsspec_url(url): + return ( + isinstance(url, str) + and "://" in url + and not url.startswith(("http://", "https://")) + ) + + def _create_metadata(df): """Create and encode geo metadata dict. @@ -76,28 +84,6 @@ def _encode_metadata(metadata): return json.dumps(metadata).encode("utf-8") -def _encode_wkb(df): - """Encode all geometry columns in the GeoDataFrame to WKB. - - Parameters - ---------- - df : GeoDataFrame - - Returns - ------- - DataFrame - geometry columns are encoded to WKB - """ - - df = DataFrame(df.copy()) - - # Encode all geometry columns to WKB - for col in df.columns[df.dtypes == "geometry"]: - df[col] = to_wkb(df[col].values) - - return df - - def _decode_metadata(metadata_str): """Decode a UTF-8 encoded JSON string to dict @@ -188,27 +174,12 @@ def _geopandas_to_arrow(df, index=None): """ from pyarrow import Table - warnings.warn( - "this is an initial implementation of Parquet/Feather file support and " - "associated metadata. This is tracking version 0.1.0 of the metadata " - "specification at " - "https://github.com/geopandas/geo-arrow-spec\n\n" - "This metadata specification does not yet make stability promises. " - "We do not yet recommend using this in a production setting unless you " - "are able to rewrite your Parquet/Feather files.\n\n" - "To further ignore this warning, you can do: \n" - "import warnings; warnings.filterwarnings('ignore', " - "message='.*initial implementation of Parquet.*')", - UserWarning, - stacklevel=4, - ) - _validate_dataframe(df) # create geo metadata before altering incoming data frame geo_metadata = _create_metadata(df) - df = _encode_wkb(df) + df = df.to_wkb() table = Table.from_pandas(df, preserve_index=index) @@ -227,16 +198,11 @@ def _to_parquet(df, path, index=None, compression="snappy", **kwargs): Requires 'pyarrow'. - WARNING: this is an initial implementation of Parquet file support and + This is an initial implementation of Parquet file support and associated metadata. This is tracking version 0.1.0 of the metadata specification at: https://github.com/geopandas/geo-arrow-spec - This metadata specification does not yet make stability promises. As such, - we do not yet recommend using this in a production setting unless you are - able to rewrite your Parquet files. - - .. versionadded:: 0.8 Parameters @@ -257,6 +223,7 @@ def _to_parquet(df, path, index=None, compression="snappy", **kwargs): "pyarrow.parquet", extra="pyarrow is required for Parquet support." ) + path = _expand_user(path) table = _geopandas_to_arrow(df, index=index) parquet.write_table(table, path, compression=compression, **kwargs) @@ -269,15 +236,11 @@ def _to_feather(df, path, index=None, compression=None, **kwargs): Requires 'pyarrow' >= 0.17. - WARNING: this is an initial implementation of Feather file support and + This is an initial implementation of Feather file support and associated metadata. This is tracking version 0.1.0 of the metadata specification at: https://github.com/geopandas/geo-arrow-spec - This metadata specification does not yet make stability promises. As such, - we do not yet recommend using this in a production setting unless you are - able to rewrite your Feather files. - .. versionadded:: 0.8 Parameters @@ -301,9 +264,10 @@ def _to_feather(df, path, index=None, compression=None, **kwargs): # TODO move this into `import_optional_dependency` import pyarrow - if pyarrow.__version__ < LooseVersion("0.17.0"): + if Version(pyarrow.__version__) < Version("0.17.0"): raise ImportError("pyarrow >= 0.17 required for Feather support") + path = _expand_user(path) table = _geopandas_to_arrow(df, index=index) feather.write_feather(table, path, compression=compression, **kwargs) @@ -315,7 +279,7 @@ def _arrow_to_geopandas(table): df = table.to_pandas() metadata = table.schema.metadata - if b"geo" not in metadata: + if metadata is None or b"geo" not in metadata: raise ValueError( """Missing geo metadata in Parquet/Feather file. Use pandas.read_parquet/read_feather() instead.""" @@ -361,7 +325,45 @@ def _arrow_to_geopandas(table): return GeoDataFrame(df, geometry=geometry) -def _read_parquet(path, columns=None, **kwargs): +def _get_filesystem_path(path, filesystem=None, storage_options=None): + """ + Get the filesystem and path for a given filesystem and path. + + If the filesystem is not None then it's just returned as is. + """ + import pyarrow + + if ( + isinstance(path, str) + and storage_options is None + and filesystem is None + and Version(pyarrow.__version__) >= Version("5.0.0") + ): + # Use the native pyarrow filesystem if possible. + try: + from pyarrow.fs import FileSystem + + filesystem, path = FileSystem.from_uri(path) + except Exception: + # fallback to use get_handle / fsspec for filesystems + # that pyarrow doesn't support + pass + + if _is_fsspec_url(path) and filesystem is None: + fsspec = import_optional_dependency( + "fsspec", extra="fsspec is requred for 'storage_options'." + ) + filesystem, path = fsspec.core.url_to_fs(path, **(storage_options or {})) + + if filesystem is None and storage_options: + raise ValueError( + "Cannot provide 'storage_options' with non-fsspec path '{}'".format(path) + ) + + return filesystem, path + + +def _read_parquet(path, columns=None, storage_options=None, **kwargs): """ Load a Parquet object from the file path, returning a GeoDataFrame. @@ -388,20 +390,49 @@ def _read_parquet(path, columns=None, **kwargs): geometry read from the file will be set as the geometry column of the returned GeoDataFrame. If no geometry columns are present, a ``ValueError`` will be raised. + storage_options : dict, optional + Extra options that make sense for a particular storage connection, e.g. host, + port, username, password, etc. For HTTP(S) URLs the key-value pairs are + forwarded to urllib as header options. For other URLs (e.g. starting with + "s3://", and "gcs://") the key-value pairs are forwarded to fsspec. Please + see fsspec and urllib for more details. + + When no storage options are provided and a filesystem is implemented by + both ``pyarrow.fs`` and ``fsspec`` (e.g. "s3://") then the ``pyarrow.fs`` + filesystem is preferred. Provide the instantiated fsspec filesystem using + the ``filesystem`` keyword if you wish to use its implementation. **kwargs Any additional kwargs passed to pyarrow.parquet.read_table(). Returns ------- GeoDataFrame + + Examples + -------- + >>> df = geopandas.read_parquet("data.parquet") # doctest: +SKIP + + Specifying columns to read: + + >>> df = geopandas.read_parquet( + ... "data.parquet", + ... columns=["geometry", "pop_est"] + ... ) # doctest: +SKIP """ parquet = import_optional_dependency( "pyarrow.parquet", extra="pyarrow is required for Parquet support." ) + # TODO(https://github.com/pandas-dev/pandas/pull/41194): see if pandas + # adds filesystem as a keyword and match that. + filesystem = kwargs.pop("filesystem", None) + filesystem, path = _get_filesystem_path( + path, filesystem=filesystem, storage_options=storage_options + ) + path = _expand_user(path) kwargs["use_pandas_metadata"] = True - table = parquet.read_table(path, columns=columns, **kwargs) + table = parquet.read_table(path, columns=columns, filesystem=filesystem, **kwargs) return _arrow_to_geopandas(table) @@ -439,6 +470,17 @@ def _read_feather(path, columns=None, **kwargs): Returns ------- GeoDataFrame + + Examples + -------- + >>> df = geopandas.read_feather("data.feather") # doctest: +SKIP + + Specifying columns to read: + + >>> df = geopandas.read_feather( + ... "data.feather", + ... columns=["geometry", "pop_est"] + ... ) # doctest: +SKIP """ feather = import_optional_dependency( @@ -447,8 +489,9 @@ def _read_feather(path, columns=None, **kwargs): # TODO move this into `import_optional_dependency` import pyarrow - if pyarrow.__version__ < LooseVersion("0.17.0"): + if Version(pyarrow.__version__) < Version("0.17.0"): raise ImportError("pyarrow >= 0.17 required for Feather support") + path = _expand_user(path) table = feather.read_table(path, columns=columns, **kwargs) return _arrow_to_geopandas(table) diff --git a/geopandas/io/file.py b/geopandas/io/file.py index 04a1b68..d524a80 100644 --- a/geopandas/io/file.py +++ b/geopandas/io/file.py @@ -1,18 +1,36 @@ -from distutils.version import LooseVersion +import os +from packaging.version import Version +from pathlib import Path +import warnings -import io import numpy as np import pandas as pd +from pandas.api.types import is_integer_dtype -import fiona import pyproj from shapely.geometry import mapping from shapely.geometry.base import BaseGeometry try: - from fiona import Env as fiona_env -except ImportError: - from fiona import drivers as fiona_env + import fiona + + fiona_import_error = None + + # only try to import fiona.Env if the main fiona import succeeded (otherwise you + # can get confusing "AttributeError: module 'fiona' has no attribute '_loading'" + # / partially initialized module errors) + try: + from fiona import Env as fiona_env + except ImportError: + try: + from fiona import drivers as fiona_env + except ImportError: + fiona_env = None + +except ImportError as err: + fiona = None + fiona_import_error = str(err) + from geopandas import GeoDataFrame, GeoSeries @@ -23,10 +41,48 @@ from urllib.parse import urlparse as parse_url from urllib.parse import uses_netloc, uses_params, uses_relative -_FIONA18 = LooseVersion(fiona.__version__) >= LooseVersion("1.8") _VALID_URLS = set(uses_relative + uses_netloc + uses_params) _VALID_URLS.discard("") +_EXTENSION_TO_DRIVER = { + ".bna": "BNA", + ".dxf": "DXF", + ".csv": "CSV", + ".shp": "ESRI Shapefile", + ".dbf": "ESRI Shapefile", + ".json": "GeoJSON", + ".geojson": "GeoJSON", + ".geojsonl": "GeoJSONSeq", + ".geojsons": "GeoJSONSeq", + ".gpkg": "GPKG", + ".gml": "GML", + ".xml": "GML", + ".gpx": "GPX", + ".gtm": "GPSTrackMaker", + ".gtz": "GPSTrackMaker", + ".tab": "MapInfo File", + ".mif": "MapInfo File", + ".mid": "MapInfo File", + ".dgn": "DGN", +} + + +def _expand_user(path): + """Expand paths that use ~.""" + if isinstance(path, str): + path = os.path.expanduser(path) + elif isinstance(path, Path): + path = path.expanduser() + return path + + +def _check_fiona(func): + if fiona is None: + raise ImportError( + f"the {func} requires the 'fiona' package, but it is not installed or does " + f"not import correctly.\nImporting fiona resulted in: {fiona_import_error}" + ) + def _is_url(url): """Check to see if *url* has a valid protocol.""" @@ -36,6 +92,16 @@ def _is_url(url): return False +def _is_zip(path): + """Check if a given path is a zipfile""" + parsed = fiona.path.ParsedPath.from_uri(path) + return ( + parsed.archive.endswith(".zip") + if parsed.archive + else parsed.path.endswith(".zip") + ) + + def _read_file(filename, bbox=None, mask=None, rows=None, **kwargs): """ Returns a GeoDataFrame from a file or URL. @@ -51,7 +117,8 @@ def _read_file(filename, bbox=None, mask=None, rows=None, **kwargs): bbox : tuple | GeoDataFrame or GeoSeries | shapely Geometry, default None Filter features by given bounding box, GeoSeries, GeoDataFrame or a shapely geometry. CRS mis-matches are resolved if given a GeoSeries - or GeoDataFrame. Cannot be used with mask. + or GeoDataFrame. Tuple is (minx, miny, maxx, maxy) to match the + bounds property of shapely geometry objects. Cannot be used with mask. mask : dict | GeoDataFrame or GeoSeries | shapely Geometry, default None Filter for features that intersect with the given dict-like geojson geometry, GeoSeries, GeoDataFrame or shapely geometry. @@ -68,7 +135,23 @@ def _read_file(filename, bbox=None, mask=None, rows=None, **kwargs): Examples -------- - >>> df = geopandas.read_file("nybb.shp") + >>> df = geopandas.read_file("nybb.shp") # doctest: +SKIP + + Specifying layer of GPKG: + + >>> df = geopandas.read_file("file.gpkg", layer='cities') # doctest: +SKIP + + Reading only first 10 rows: + + >>> df = geopandas.read_file("nybb.shp", rows=10) # doctest: +SKIP + + Reading only geometries intersecting ``mask``: + + >>> df = geopandas.read_file("nybb.shp", mask=polygon) # doctest: +SKIP + + Reading only geometries intersecting ``bbox``: + + >>> df = geopandas.read_file("nybb.shp", bbox=(0, 0, 10, 20)) # doctest: +SKIP Returns ------- @@ -81,14 +164,37 @@ def _read_file(filename, bbox=None, mask=None, rows=None, **kwargs): may fail. In this case, the proper encoding can be specified explicitly by using the encoding keyword parameter, e.g. ``encoding='utf-8'``. """ + _check_fiona("'read_file' function") + filename = _expand_user(filename) + if _is_url(filename): req = _urlopen(filename) path_or_bytes = req.read() reader = fiona.BytesCollection - elif isinstance(filename, io.TextIOBase): - path_or_bytes = filename.read() - reader = fiona.open + elif pd.api.types.is_file_like(filename): + data = filename.read() + path_or_bytes = data.encode("utf-8") if isinstance(data, str) else data + reader = fiona.BytesCollection else: + # Opening a file via URL or file-like-object above automatically detects a + # zipped file. In order to match that behavior, attempt to add a zip scheme + # if missing. + if _is_zip(str(filename)): + parsed = fiona.parse_path(str(filename)) + if isinstance(parsed, fiona.path.ParsedPath): + # If fiona is able to parse the path, we can safely look at the scheme + # and update it to have a zip scheme if necessary. + schemes = (parsed.scheme or "").split("+") + if "zip" not in schemes: + parsed.scheme = "+".join(["zip"] + schemes) + filename = parsed.name + elif isinstance(parsed, fiona.path.UnparsedPath) and not str( + filename + ).startswith("/vsi"): + # If fiona is unable to parse the path, it might have a Windows drive + # scheme. Try adding zip:// to the front. If the path starts with "/vsi" + # it is a legacy GDAL path type, so let it pass unmodified. + filename = "zip://" + parsed.name path_or_bytes = filename reader = fiona.open @@ -131,19 +237,25 @@ def _read_file(filename, bbox=None, mask=None, rows=None, **kwargs): f_filt = features # get list of columns columns = list(features.schema["properties"]) + datetime_fields = [ + k for (k, v) in features.schema["properties"].items() if v == "datetime" + ] if kwargs.get("ignore_geometry", False): - return pd.DataFrame( + df = pd.DataFrame( [record["properties"] for record in f_filt], columns=columns ) - - return GeoDataFrame.from_features( - f_filt, crs=crs, columns=columns + ["geometry"] - ) + else: + df = GeoDataFrame.from_features( + f_filt, crs=crs, columns=columns + ["geometry"] + ) + for k in datetime_fields: + # fiona only supports up to ms precision, any microseconds are + # floating point rounding error + df[k] = pd.to_datetime(df[k]).dt.round(freq="ms") + return df def read_file(*args, **kwargs): - import warnings - warnings.warn( "geopandas.io.file.read_file() is intended for internal " "use only, and will be deprecated. Use geopandas.read_file() instead.", @@ -155,8 +267,6 @@ def read_file(*args, **kwargs): def to_file(*args, **kwargs): - import warnings - warnings.warn( "geopandas.io.file.to_file() is intended for internal " "use only, and will be deprecated. Use GeoDataFrame.to_file() " @@ -168,30 +278,50 @@ def to_file(*args, **kwargs): return _to_file(*args, **kwargs) +def _detect_driver(path): + """ + Attempt to auto-detect driver based on the extension + """ + try: + # in case the path is a file handle + path = path.name + except AttributeError: + pass + try: + return _EXTENSION_TO_DRIVER[Path(path).suffix.lower()] + except KeyError: + # Assume it is a shapefile folder for now. In the future, + # will likely raise an exception when the expected + # folder writing behavior is more clearly defined. + return "ESRI Shapefile" + + def _to_file( df, filename, - driver="ESRI Shapefile", + driver=None, schema=None, index=None, mode="w", crs=None, - **kwargs + **kwargs, ): """ Write this GeoDataFrame to an OGR data source A dictionary of supported OGR providers is available via: >>> import fiona - >>> fiona.supported_drivers + >>> fiona.supported_drivers # doctest: +SKIP Parameters ---------- df : GeoDataFrame to be written filename : string File path or file handle to write to. - driver : string, default 'ESRI Shapefile' + driver : string, default None The OGR format driver used to write the vector file. + If not specified, it attempts to infer it from the file extension. + If no extension is specified, it saves ESRI Shapefile to a folder. schema : dict, default None If specified, the schema dictionary is passed to Fiona to better control how the file is written. If None, GeoPandas @@ -227,12 +357,13 @@ def _to_file( may fail. In this case, the proper encoding can be specified explicitly by using the encoding keyword parameter, e.g. ``encoding='utf-8'``. """ + _check_fiona("'to_file' method") + filename = _expand_user(filename) + if index is None: # Determine if index attribute(s) should be saved to file - index = list(df.index.names) != [None] or type(df.index) not in ( - pd.RangeIndex, - pd.Int64Index, - ) + # (only if they are named or are non-integer) + index = list(df.index.names) != [None] or not is_integer_dtype(df.index.dtype) if index: df = df.reset_index(drop=False) if schema is None: @@ -241,13 +372,24 @@ def _to_file( crs = pyproj.CRS.from_user_input(crs) else: crs = df.crs + + if driver is None: + driver = _detect_driver(filename) + + if driver == "ESRI Shapefile" and any([len(c) > 10 for c in df.columns.tolist()]): + warnings.warn( + "Column names longer than 10 characters will be truncated when saved to " + "ESRI Shapefile.", + stacklevel=3, + ) + with fiona_env(): crs_wkt = None try: gdal_version = fiona.env.get_gdal_release_name() except AttributeError: gdal_version = "2.0.0" # just assume it is not the latest - if LooseVersion(gdal_version) >= LooseVersion("3.0.0") and crs: + if Version(gdal_version) >= Version("3.0.0") and crs: crs_wkt = crs.to_wkt() elif crs: crs_wkt = crs.to_wkt("WKT1_GDAL") @@ -275,12 +417,6 @@ def infer_schema(df): out_type = type(np.zeros(1, in_type).item()).__name__ if out_type == "long": out_type = "int" - if not _FIONA18 and out_type == "bool": - raise ValueError( - 'column "{}" is boolean type, '.format(column) - + "which is unsupported in file writing with fiona " - "< 1.8. Consider casting the column to int type." - ) return out_type properties = OrderedDict( @@ -292,7 +428,12 @@ def infer_schema(df): ) if df.empty: - raise ValueError("Cannot write empty DataFrame to file.") + warnings.warn( + "You are attempting to write an empty DataFrame to file. " + "For some drivers, this operation may fail.", + UserWarning, + stacklevel=3, + ) # Since https://github.com/Toblerity/Fiona/issues/446 resolution, # Fiona allows a list of geometry types @@ -307,24 +448,11 @@ def _geometry_types(df): """ Determine the geometry types in the GeoDataFrame for the schema. """ - if _FIONA18: - # Starting from Fiona 1.8, schema submitted to fiona to write a gdf - # can have mixed geometries: - # - 3D and 2D shapes can coexist in inferred schema - # - Shape and MultiShape types can (and must) coexist in inferred - # schema - geom_types_2D = df[~df.geometry.has_z].geometry.geom_type.unique() - geom_types_2D = [gtype for gtype in geom_types_2D if gtype is not None] - geom_types_3D = df[df.geometry.has_z].geometry.geom_type.unique() - geom_types_3D = ["3D " + gtype for gtype in geom_types_3D if gtype is not None] - geom_types = geom_types_3D + geom_types_2D - - else: - # Before Fiona 1.8, schema submitted to write a gdf should have - # one single geometry type whenever possible: - # - 3D and 2D shapes cannot coexist in inferred schema - # - Shape and MultiShape can not coexist in inferred schema - geom_types = _geometry_types_back_compat(df) + geom_types_2D = df[~df.geometry.has_z].geometry.geom_type.unique() + geom_types_2D = [gtype for gtype in geom_types_2D if gtype is not None] + geom_types_3D = df[df.geometry.has_z].geometry.geom_type.unique() + geom_types_3D = ["3D " + gtype for gtype in geom_types_3D if gtype is not None] + geom_types = geom_types_3D + geom_types_2D if len(geom_types) == 0: # Default geometry type supported by Fiona @@ -335,25 +463,3 @@ def _geometry_types(df): geom_types = geom_types[0] return geom_types - - -def _geometry_types_back_compat(df): - """ - for backward compatibility with Fiona<1.8 only - """ - unique_geom_types = df.geometry.geom_type.unique() - unique_geom_types = [gtype for gtype in unique_geom_types if gtype is not None] - - # merge single and Multi types (eg Polygon and MultiPolygon) - unique_geom_types = [ - gtype - for gtype in unique_geom_types - if not gtype.startswith("Multi") or gtype[5:] not in unique_geom_types - ] - - if df.geometry.has_z.any(): - # declare all geometries as 3D geometries - unique_geom_types = ["3D " + type for type in unique_geom_types] - # by default, all geometries are 2D geometries - - return unique_geom_types diff --git a/geopandas/io/sql.py b/geopandas/io/sql.py index 16996c7..485cf93 100644 --- a/geopandas/io/sql.py +++ b/geopandas/io/sql.py @@ -1,4 +1,5 @@ import warnings +from contextlib import contextmanager import pandas as pd @@ -9,6 +10,35 @@ from geopandas import GeoDataFrame from .. import _compat as compat +@contextmanager +def _get_conn(conn_or_engine): + """ + Yield a connection within a transaction context. + + Engine.begin() returns a Connection with an implicit Transaction while + Connection.begin() returns the Transaction. This helper will always return a + Connection with an implicit (possibly nested) Transaction. + + Parameters + ---------- + conn_or_engine : Connection or Engine + A sqlalchemy Connection or Engine instance + Returns + ------- + Connection + """ + from sqlalchemy.engine.base import Engine, Connection + + if isinstance(conn_or_engine, Connection): + with conn_or_engine.begin(): + yield conn_or_engine + elif isinstance(conn_or_engine, Engine): + with conn_or_engine.begin() as conn: + yield conn + else: + raise ValueError(f"Unknown Connectable: {conn_or_engine}") + + def _df_to_geodf(df, geom_col="geom", crs=None): """ Transforms a pandas DataFrame into a GeoDataFrame. @@ -83,7 +113,7 @@ def _read_postgis( sql : string SQL query to execute in selecting entries from database, or name of the table to read from the database. - con : DB connection object or SQLAlchemy engine + con : sqlalchemy.engine.Connection or sqlalchemy.engine.Engine Active connection to the database to query. geom_col : string, default 'geom' column name to convert to shapely geometries @@ -106,10 +136,17 @@ def _read_postgis( Examples -------- PostGIS - >>> sql = "SELECT geom, kind FROM polygons" + + >>> from sqlalchemy import create_engine # doctest: +SKIP + >>> db_connection_url = "postgresql://myusername:mypassword@myhost:5432/mydatabase" + >>> con = create_engine(db_connection_url) # doctest: +SKIP + >>> sql = "SELECT geom, highway FROM roads" + >>> df = geopandas.read_postgis(sql, con) # doctest: +SKIP + SpatiaLite - >>> sql = "SELECT ST_AsBinary(geom) AS geom, kind FROM polygons" - >>> df = geopandas.read_postgis(sql, con) + + >>> sql = "SELECT ST_Binary(geom) AS geom, highway FROM roads" + >>> df = geopandas.read_postgis(sql, con) # doctest: +SKIP """ if chunksize is None: @@ -170,7 +207,7 @@ def _get_geometry_type(gdf): such as GeometryCollection([Point, LineStrings]) - if any of the geometries has Z-coordinate, all records will be written with 3D. - """ + """ geom_types = list(gdf.geometry.geom_type.unique()) has_curve = False @@ -248,8 +285,12 @@ def _convert_to_ewkb(gdf, geom_name, srid): geoms = [dumps(geom, srid=srid, hex=True) for geom in gdf[geom_name]] - gdf[geom_name] = geoms - return gdf + # The gdf will warn that the geometry column doesn't hold in-memory geometries + # now that they are EWKB, so convert back to a regular dataframe to avoid warning + # the user that the dtypes are unexpected. + df = pd.DataFrame(gdf, copy=False) + df[geom_name] = geoms + return df def _psql_insert_copy(tbl, conn, keys, data_iter): @@ -265,7 +306,9 @@ def _psql_insert_copy(tbl, conn, keys, data_iter): dbapi_conn = conn.connection with dbapi_conn.cursor() as cur: - sql = "COPY {} ({}) FROM STDIN WITH CSV".format(tbl.table.fullname, columns) + sql = 'COPY "{}"."{}" ({}) FROM STDIN WITH CSV'.format( + tbl.table.schema, tbl.table.name, columns + ) cur.copy_expert(sql=sql, file=s_buf) @@ -290,7 +333,7 @@ def _write_postgis( ---------- name : str Name of the target table. - con : sqlalchemy.engine.Engine + con : sqlalchemy.engine.Connection or sqlalchemy.engine.Engine Active connection to the PostGIS database. if_exists : {'fail', 'replace', 'append'}, default 'fail' How to behave if the table already exists: @@ -318,10 +361,10 @@ def _write_postgis( Examples -------- - >>> from sqlalchemy import create_engine - >>> engine = create_engine("postgres://myusername:mypassword@myhost:5432\ -/mydatabase";) - >>> gdf.to_postgis("my_table", engine) + >>> from sqlalchemy import create_engine # doctest: +SKIP + >>> engine = create_engine("postgresql://myusername:mypassword@myhost:5432\ +/mydatabase";) # doctest: +SKIP + >>> gdf.to_postgis("my_table", engine) # doctest: +SKIP """ try: from geoalchemy2 import Geometry @@ -358,16 +401,16 @@ def _write_postgis( # Convert geometries to EWKB gdf = _convert_to_ewkb(gdf, geom_name, srid) + if schema is not None: + schema_name = schema + else: + schema_name = "public" + if if_exists == "append": # Check that the geometry srid matches with the current GeoDataFrame - with con.begin() as connection: - if schema is not None: - schema_name = schema - else: - schema_name = "public" - + with _get_conn(con) as connection: # Only check SRID if table exists - if connection.run_callable(connection.dialect.has_table, name, schema): + if connection.dialect.has_table(connection, name, schema): target_srid = connection.execute( "SELECT Find_SRID('{schema}', '{table}', '{geom_col}');".format( schema=schema_name, table=name, geom_col=geom_name @@ -383,12 +426,12 @@ def _write_postgis( ) raise ValueError(msg) - with con.begin() as connection: + with _get_conn(con) as connection: gdf.to_sql( name, connection, - schema=schema, + schema=schema_name, if_exists=if_exists, index=index, index_label=index_label, diff --git a/geopandas/io/tests/data/pickle/0.5.1_pd-0.25.3_py-3.7.3_x86_64_linux.pickle b/geopandas/io/tests/data/pickle/0.5.1_pd-0.25.3_py-3.7.3_x86_64_linux.pickle new file mode 100644 index 0000000..1d97ad5 Binary files /dev/null and b/geopandas/io/tests/data/pickle/0.5.1_pd-0.25.3_py-3.7.3_x86_64_linux.pickle differ diff --git a/geopandas/io/tests/data/pickle/0.6.3_pd-0.25.3_py-3.8.0_x86_64_linux.pickle b/geopandas/io/tests/data/pickle/0.6.3_pd-0.25.3_py-3.8.0_x86_64_linux.pickle new file mode 100644 index 0000000..32e5afb Binary files /dev/null and b/geopandas/io/tests/data/pickle/0.6.3_pd-0.25.3_py-3.8.0_x86_64_linux.pickle differ diff --git a/geopandas/io/tests/data/pickle/0.7.0_pd-1.0.4_py-3.7.6_x86_64_linux.pickle b/geopandas/io/tests/data/pickle/0.7.0_pd-1.0.4_py-3.7.6_x86_64_linux.pickle new file mode 100644 index 0000000..7d61b0e Binary files /dev/null and b/geopandas/io/tests/data/pickle/0.7.0_pd-1.0.4_py-3.7.6_x86_64_linux.pickle differ diff --git a/geopandas/io/tests/data/pickle/0.8.0_pd-1.0.5_py-3.8.3_x86_64_linux.pickle b/geopandas/io/tests/data/pickle/0.8.0_pd-1.0.5_py-3.8.3_x86_64_linux.pickle new file mode 100644 index 0000000..087338b Binary files /dev/null and b/geopandas/io/tests/data/pickle/0.8.0_pd-1.0.5_py-3.8.3_x86_64_linux.pickle differ diff --git a/geopandas/io/tests/generate_legacy_storage_files.py b/geopandas/io/tests/generate_legacy_storage_files.py new file mode 100644 index 0000000..cc39273 --- /dev/null +++ b/geopandas/io/tests/generate_legacy_storage_files.py @@ -0,0 +1,98 @@ +""" +Script to create the data and write legacy storage (pickle) files. + +Based on pandas' generate_legacy_storage_files.py script. + +To use this script, create an environment for which you want to +generate pickles, activate the environment, and run this script as: + +$ python geopandas/geopandas/io/tests/generate_legacy_storage_files.py \ + geopandas/geopandas/io/tests/data/pickle/ pickle + +This script generates a storage file for the current arch, system, + +The idea here is you are using the *current* version of the +generate_legacy_storage_files with an *older* version of geopandas to +generate a pickle file. We will then check this file into a current +branch, and test using test_pickle.py. This will load the *older* +pickles and test versus the current data that is generated +(with master). These are then compared. + +""" +import os +import pickle +import platform +import sys + +import pandas as pd + +import geopandas +from shapely.geometry import Point + + +def create_pickle_data(): + """ create the pickle data """ + + # custom geometry column name + gdf_the_geom = geopandas.GeoDataFrame( + {"a": [1, 2, 3], "the_geom": [Point(1, 1), Point(2, 2), Point(3, 3)]}, + geometry="the_geom", + ) + + # with crs + gdf_crs = geopandas.GeoDataFrame( + {"a": [0.1, 0.2, 0.3], "geometry": [Point(1, 1), Point(2, 2), Point(3, 3)]}, + crs="EPSG:4326", + ) + + return dict(gdf_the_geom=gdf_the_geom, gdf_crs=gdf_crs) + + +def platform_name(): + return "_".join( + [ + str(geopandas.__version__), + "pd-" + str(pd.__version__), + "py-" + str(platform.python_version()), + str(platform.machine()), + str(platform.system().lower()), + ] + ) + + +def write_legacy_pickles(output_dir): + print( + "This script generates a storage file for the current arch, system, " + "and python version" + ) + print("geopandas version: {}").format(geopandas.__version__) + print(" output dir : {}".format(output_dir)) + print(" storage format: pickle") + + pth = "{}.pickle".format(platform_name()) + + fh = open(os.path.join(output_dir, pth), "wb") + pickle.dump(create_pickle_data(), fh, pickle.DEFAULT_PROTOCOL) + fh.close() + + print("created pickle file: {}".format(pth)) + + +def main(): + if len(sys.argv) != 3: + exit( + "Specify output directory and storage type: generate_legacy_" + "storage_files.py " + ) + + output_dir = str(sys.argv[1]) + storage_type = str(sys.argv[2]) + + if storage_type == "pickle": + write_legacy_pickles(output_dir=output_dir) + else: + exit("storage_type must be one of {'pickle'}") + + +if __name__ == "__main__": + main() diff --git a/geopandas/io/tests/test_arrow.py b/geopandas/io/tests/test_arrow.py index ecfa37c..1e70158 100644 --- a/geopandas/io/tests/test_arrow.py +++ b/geopandas/io/tests/test_arrow.py @@ -1,12 +1,13 @@ from __future__ import absolute_import -from distutils.version import LooseVersion +from packaging.version import Version import os import pytest from pandas import DataFrame, read_parquet as pd_read_parquet from pandas.testing import assert_frame_equal import numpy as np +from shapely.geometry import box import geopandas from geopandas import GeoDataFrame, read_file, read_parquet, read_feather @@ -16,7 +17,7 @@ from geopandas.io.arrow import ( _create_metadata, _decode_metadata, _encode_metadata, - _encode_wkb, + _get_filesystem_path, _validate_dataframe, _validate_metadata, METADATA_VERSION, @@ -27,9 +28,6 @@ from geopandas.testing import assert_geodataframe_equal, assert_geoseries_equal # Skip all tests in this module if pyarrow is not available pyarrow = pytest.importorskip("pyarrow") -# TEMPORARY: hide warning from to_parquet -pytestmark = pytest.mark.filterwarnings("ignore:.*initial implementation of Parquet.*") - @pytest.fixture( params=[ @@ -37,7 +35,7 @@ pytestmark = pytest.mark.filterwarnings("ignore:.*initial implementation of Parq pytest.param( "feather", marks=pytest.mark.skipif( - pyarrow.__version__ < LooseVersion("0.17.0"), + Version(pyarrow.__version__) < Version("0.17.0"), reason="needs pyarrow >= 0.17", ), ), @@ -174,20 +172,6 @@ def test_validate_metadata_invalid(metadata, error): _validate_metadata(metadata) -def test_encode_wkb(): - test_dataset = "naturalearth_lowres" - df = read_file(get_path(test_dataset)) - - encoded = _encode_wkb(df) - - # make sure original is not modified - assert isinstance(df, GeoDataFrame) - assert ( - encoded.geometry.iloc[0][:16] - == b"\x01\x06\x00\x00\x00\x03\x00\x00\x00\x01\x03\x00\x00\x00\x01\x00" - ) - - # TEMPORARY: used to determine if pyarrow fails for roundtripping pandas data # without geometries def test_pandas_parquet_roundtrip1(tmpdir): @@ -230,9 +214,7 @@ def test_roundtrip(tmpdir, file_format, test_dataset): filename = os.path.join(str(tmpdir), "test.pq") - # TEMP: Initial implementation should raise a UserWarning - with pytest.warns(UserWarning, match="initial implementation"): - writer(df, filename) + writer(df, filename) assert os.path.exists(filename) @@ -284,7 +266,7 @@ def test_parquet_compression(compression, tmpdir): @pytest.mark.skipif( - pyarrow.__version__ < LooseVersion("0.17.0"), + Version(pyarrow.__version__) < Version("0.17.0"), reason="Feather only supported for pyarrow >= 0.17", ) @pytest.mark.parametrize("compression", ["uncompressed", "lz4", "zstd"]) @@ -353,6 +335,26 @@ def test_parquet_missing_metadata(tmpdir): read_parquet(filename) +def test_parquet_missing_metadata2(tmpdir): + """Missing geo metadata, such as from a parquet file created + from a pyarrow Table (which will also not contain pandas metadata), + will raise a ValueError. + """ + import pyarrow.parquet as pq + + table = pyarrow.table({"a": [1, 2, 3]}) + filename = os.path.join(str(tmpdir), "test.pq") + + # use pyarrow.parquet write_table (no geo metadata, but also no pandas metadata) + pq.write_table(table, filename) + + # missing metadata will raise ValueError + with pytest.raises( + ValueError, match="Missing geo metadata in Parquet/Feather file." + ): + read_parquet(filename) + + @pytest.mark.parametrize( "geo_meta,error", [ @@ -416,22 +418,6 @@ def test_subset_columns(tmpdir, file_format): reader(filename, columns=["name"]) -def test_parquet_repeat_columns(tmpdir): - """Reading repeated columns should return first value of each repeated column - """ - - test_dataset = "naturalearth_lowres" - df = read_file(get_path(test_dataset)) - - filename = os.path.join(str(tmpdir), "test.pq") - df.to_parquet(filename) - - columns = ["name", "name", "iso_a3", "name", "geometry"] - pq_df = read_parquet(filename, columns=columns) - - assert pq_df.columns.tolist() == ["name", "iso_a3", "geometry"] - - def test_promote_secondary_geometry(tmpdir, file_format): """Reading a subset of columns that does not include the primary geometry column should promote the first geometry column present. @@ -498,7 +484,7 @@ def test_missing_crs(tmpdir, file_format): @pytest.mark.skipif( - pyarrow.__version__ >= LooseVersion("0.17.0"), + Version(pyarrow.__version__) >= Version("0.17.0"), reason="Feather only supported for pyarrow >= 0.17", ) def test_feather_arrow_version(tmpdir): @@ -509,3 +495,63 @@ def test_feather_arrow_version(tmpdir): ImportError, match="pyarrow >= 0.17 required for Feather support" ): df.to_feather(filename) + + +def test_fsspec_url(): + fsspec = pytest.importorskip("fsspec") + import fsspec.implementations.memory + + class MyMemoryFileSystem(fsspec.implementations.memory.MemoryFileSystem): + # Simple fsspec filesystem that adds a required keyword. + # Attempting to use this filesystem without the keyword will raise an exception. + def __init__(self, is_set, *args, **kwargs): + self.is_set = is_set + super().__init__(*args, **kwargs) + + fsspec.register_implementation("memory", MyMemoryFileSystem, clobber=True) + memfs = MyMemoryFileSystem(is_set=True) + + test_dataset = "naturalearth_lowres" + df = read_file(get_path(test_dataset)) + + with memfs.open("data.parquet", "wb") as f: + df.to_parquet(f) + + result = read_parquet("memory://data.parquet", storage_options=dict(is_set=True)) + assert_geodataframe_equal(result, df) + + result = read_parquet("memory://data.parquet", filesystem=memfs) + assert_geodataframe_equal(result, df) + + +def test_non_fsspec_url_with_storage_options_raises(): + with pytest.raises(ValueError, match="storage_options"): + test_dataset = "naturalearth_lowres" + read_parquet(get_path(test_dataset), storage_options={"foo": "bar"}) + + +@pytest.mark.skipif( + Version(pyarrow.__version__) < Version("5.0.0"), + reason="pyarrow.fs requires pyarrow>=5.0.0", +) +def test_prefers_pyarrow_fs(): + filesystem, _ = _get_filesystem_path("file:///data.parquet") + assert isinstance(filesystem, pyarrow.fs.LocalFileSystem) + + +def test_write_read_parquet_expand_user(): + gdf = geopandas.GeoDataFrame(geometry=[box(0, 0, 10, 10)], crs="epsg:4326") + test_file = "~/test_file.parquet" + gdf.to_parquet(test_file) + pq_df = geopandas.read_parquet(test_file) + assert_geodataframe_equal(gdf, pq_df, check_crs=True) + os.remove(os.path.expanduser(test_file)) + + +def test_write_read_feather_expand_user(): + gdf = geopandas.GeoDataFrame(geometry=[box(0, 0, 10, 10)], crs="epsg:4326") + test_file = "~/test_file.feather" + gdf.to_feather(test_file) + f_df = geopandas.read_feather(test_file) + assert_geodataframe_equal(gdf, f_df, check_crs=True) + os.remove(os.path.expanduser(test_file)) diff --git a/geopandas/io/tests/test_file.py b/geopandas/io/tests/test_file.py index 8207d32..bd145fb 100644 --- a/geopandas/io/tests/test_file.py +++ b/geopandas/io/tests/test_file.py @@ -1,22 +1,22 @@ from collections import OrderedDict import datetime -from distutils.version import LooseVersion +from packaging.version import Version import io import os import pathlib import tempfile -import sys import numpy as np import pandas as pd import fiona +import pytz +from pandas.testing import assert_series_equal from shapely.geometry import Point, Polygon, box import geopandas from geopandas import GeoDataFrame, read_file -from geopandas.io.file import fiona_env, _FIONA18 -from geopandas._compat import PANDAS_GE_024 +from geopandas.io.file import fiona_env, _detect_driver, _EXTENSION_TO_DRIVER from geopandas.testing import assert_geodataframe_equal, assert_geoseries_equal from geopandas.tests.util import PACKAGE_DIR, validate_boro_df @@ -24,6 +24,9 @@ from geopandas.tests.util import PACKAGE_DIR, validate_boro_df import pytest +FIONA_GE_1814 = Version(fiona.__version__) >= Version("1.8.14") # datetime roundtrip + + _CRS = "epsg:4326" @@ -36,12 +39,14 @@ def df_nybb(): @pytest.fixture def df_null(): - return read_file(os.path.join(PACKAGE_DIR, "examples", "null_geom.geojson")) + return read_file( + os.path.join(PACKAGE_DIR, "geopandas", "tests", "data", "null_geom.geojson") + ) @pytest.fixture def file_path(): - return os.path.join(PACKAGE_DIR, "examples", "null_geom.geojson") + return os.path.join(PACKAGE_DIR, "geopandas", "tests", "data", "null_geom.geojson") @pytest.fixture @@ -62,12 +67,27 @@ def df_points(): # to_file tests # ----------------------------------------------------------------------------- -driver_ext_pairs = [("ESRI Shapefile", "shp"), ("GeoJSON", "geojson"), ("GPKG", "gpkg")] +driver_ext_pairs = [ + ("ESRI Shapefile", ".shp"), + ("GeoJSON", ".geojson"), + ("GPKG", ".gpkg"), + (None, ".shp"), + (None, ""), + (None, ".geojson"), + (None, ".gpkg"), +] + + +def assert_correct_driver(file_path, ext): + # check the expected driver + expected_driver = "ESRI Shapefile" if ext == "" else _EXTENSION_TO_DRIVER[ext] + with fiona.open(str(file_path)) as fds: + assert fds.driver == expected_driver @pytest.mark.parametrize("driver,ext", driver_ext_pairs) def test_to_file(tmpdir, df_nybb, df_null, driver, ext): - """ Test to_file and from_file """ + """Test to_file and from_file""" tempfilename = os.path.join(str(tmpdir), "boros." + ext) df_nybb.to_file(tempfilename, driver=driver) # Read layer back in @@ -77,19 +97,20 @@ def test_to_file(tmpdir, df_nybb, df_null, driver, ext): assert np.alltrue(df["BoroName"].values == df_nybb["BoroName"]) # Write layer with null geometry out to file - tempfilename = os.path.join(str(tmpdir), "null_geom." + ext) + tempfilename = os.path.join(str(tmpdir), "null_geom" + ext) df_null.to_file(tempfilename, driver=driver) # Read layer back in df = GeoDataFrame.from_file(tempfilename) assert "geometry" in df assert len(df) == 2 assert np.alltrue(df["Name"].values == df_null["Name"]) + # check the expected driver + assert_correct_driver(tempfilename, ext) @pytest.mark.parametrize("driver,ext", driver_ext_pairs) -@pytest.mark.skipif(not _FIONA18, reason="pathlib support added to fiona in 1.8") def test_to_file_pathlib(tmpdir, df_nybb, df_null, driver, ext): - """ Test to_file and from_file """ + """Test to_file and from_file""" temppath = pathlib.Path(os.path.join(str(tmpdir), "boros." + ext)) df_nybb.to_file(temppath, driver=driver) # Read layer back in @@ -97,6 +118,8 @@ def test_to_file_pathlib(tmpdir, df_nybb, df_null, driver, ext): assert "geometry" in df assert len(df) == 5 assert np.alltrue(df["BoroName"].values == df_nybb["BoroName"]) + # check the expected driver + assert_correct_driver(temppath, ext) @pytest.mark.parametrize("driver,ext", driver_ext_pairs) @@ -108,71 +131,98 @@ def test_to_file_bool(tmpdir, driver, ext): "a": [1, 2, 3], "b": [True, False, True], "geometry": [Point(0, 0), Point(1, 1), Point(2, 2)], - } + }, + crs=4326, ) - if LooseVersion(fiona.__version__) < LooseVersion("1.8"): - with pytest.raises(ValueError): - df.to_file(tempfilename, driver=driver) - else: - df.to_file(tempfilename, driver=driver) - result = read_file(tempfilename) - if driver == "GeoJSON": - # geojson by default assumes epsg:4326 - result.crs = None - if driver == "ESRI Shapefile": - # Shapefile does not support boolean, so is read back as int - df["b"] = df["b"].astype("int64") - # PY2: column names 'mixed' instead of 'unicode' - assert_geodataframe_equal(result, df, check_column_type=False) + df.to_file(tempfilename, driver=driver) + result = read_file(tempfilename) + if ext in (".shp", ""): + # Shapefile does not support boolean, so is read back as int + df["b"] = df["b"].astype("int64") + assert_geodataframe_equal(result, df) + # check the expected driver + assert_correct_driver(tempfilename, ext) -@pytest.mark.skipif( - (sys.version_info < (3, 0)) and sys.platform.startswith("win"), - reason="GPKG tests failing on AppVeyor for Python 2.7", +TEST_DATE = datetime.datetime(2021, 11, 21, 1, 7, 43, 17500) +eastern = pytz.timezone("US/Eastern") + +datetime_type_tests = (TEST_DATE, eastern.localize(TEST_DATE)) + + +@pytest.mark.parametrize( + "time", datetime_type_tests, ids=("naive_datetime", "datetime_with_timezone") ) -def test_to_file_datetime(tmpdir): +@pytest.mark.parametrize("driver,ext", driver_ext_pairs) +def test_to_file_datetime(tmpdir, driver, ext, time): """Test writing a data file with the datetime column type""" - tempfilename = os.path.join(str(tmpdir), "test_datetime.gpkg") + if ext in (".shp", ""): + pytest.skip(f"Driver corresponding to ext {ext} doesn't support dt fields") + if time.tzinfo is not None and FIONA_GE_1814 is False: + # https://github.com/Toblerity/Fiona/pull/915 + pytest.skip("Fiona >= 1.8.14 needed for timezone support") + + tempfilename = os.path.join(str(tmpdir), f"test_datetime{ext}") point = Point(0, 0) - now = datetime.datetime.now() - df = GeoDataFrame({"a": [1, 2], "b": [now, now]}, geometry=[point, point], crs={}) - df.to_file(tempfilename, driver="GPKG") + + df = GeoDataFrame( + {"a": [1, 2], "b": [time, time]}, geometry=[point, point], crs=4326 + ) + if FIONA_GE_1814: + fiona_precision_limit = "ms" + else: + fiona_precision_limit = "s" + df["b"] = df["b"].dt.round(freq=fiona_precision_limit) + + df.to_file(tempfilename, driver=driver) df_read = read_file(tempfilename) - assert_geoseries_equal(df.geometry, df_read.geometry) + + assert_geodataframe_equal(df.drop(columns=["b"]), df_read.drop(columns=["b"])) + if df["b"].dt.tz is not None: + # US/Eastern becomes pytz.FixedOffset(-300) when read from file + # so compare fairly in terms of UTC + assert_series_equal( + df["b"].dt.tz_convert(pytz.utc), df_read["b"].dt.tz_convert(pytz.utc) + ) + else: + assert_series_equal(df["b"], df_read["b"]) @pytest.mark.parametrize("driver,ext", driver_ext_pairs) def test_to_file_with_point_z(tmpdir, ext, driver): """Test that 3D geometries are retained in writes (GH #612).""" - tempfilename = os.path.join(str(tmpdir), "test_3Dpoint." + ext) + tempfilename = os.path.join(str(tmpdir), "test_3Dpoint" + ext) point3d = Point(0, 0, 500) point2d = Point(1, 1) df = GeoDataFrame({"a": [1, 2]}, geometry=[point3d, point2d], crs=_CRS) df.to_file(tempfilename, driver=driver) df_read = GeoDataFrame.from_file(tempfilename) assert_geoseries_equal(df.geometry, df_read.geometry) + # check the expected driver + assert_correct_driver(tempfilename, ext) @pytest.mark.parametrize("driver,ext", driver_ext_pairs) def test_to_file_with_poly_z(tmpdir, ext, driver): """Test that 3D geometries are retained in writes (GH #612).""" - tempfilename = os.path.join(str(tmpdir), "test_3Dpoly." + ext) + tempfilename = os.path.join(str(tmpdir), "test_3Dpoly" + ext) poly3d = Polygon([[0, 0, 5], [0, 1, 5], [1, 1, 5], [1, 0, 5]]) poly2d = Polygon([[0, 0], [0, 1], [1, 1], [1, 0]]) df = GeoDataFrame({"a": [1, 2]}, geometry=[poly3d, poly2d], crs=_CRS) df.to_file(tempfilename, driver=driver) df_read = GeoDataFrame.from_file(tempfilename) assert_geoseries_equal(df.geometry, df_read.geometry) + # check the expected driver + assert_correct_driver(tempfilename, ext) def test_to_file_types(tmpdir, df_points): - """ Test various integer type columns (GH#93) """ + """Test various integer type columns (GH#93)""" tempfilename = os.path.join(str(tmpdir), "int.shp") int_types = [ - np.int, np.int8, np.int16, np.int32, @@ -182,7 +232,6 @@ def test_to_file_types(tmpdir, df_points): np.uint16, np.uint32, np.uint64, - np.long, ] geometry = df_points.geometry data = dict( @@ -193,7 +242,6 @@ def test_to_file_types(tmpdir, df_points): df.to_file(tempfilename) -@pytest.mark.skipif(not PANDAS_GE_024, reason="pandas >= 0.24 needed") def test_to_file_int64(tmpdir, df_points): tempfilename = os.path.join(str(tmpdir), "int64.shp") geometry = df_points.geometry @@ -205,9 +253,9 @@ def test_to_file_int64(tmpdir, df_points): def test_to_file_empty(tmpdir): - input_empty_df = GeoDataFrame() + input_empty_df = GeoDataFrame(columns=["geometry"]) tempfilename = os.path.join(str(tmpdir), "test.shp") - with pytest.raises(ValueError, match="Cannot write empty DataFrame to file."): + with pytest.warns(UserWarning): input_empty_df.to_file(tempfilename) @@ -243,15 +291,32 @@ def test_to_file_schema(tmpdir, df_nybb): assert result_schema == schema +def test_to_file_column_len(tmpdir, df_points): + """ + Ensure that a warning about truncation is given when a geodataframe with + column names longer than 10 characters is saved to shapefile + """ + tempfilename = os.path.join(str(tmpdir), "test.shp") + + df = df_points.iloc[:1].copy() + df["0123456789A"] = ["the column name is 11 characters"] + + with pytest.warns( + UserWarning, match="Column names longer than 10 characters will be truncated" + ): + df.to_file(tempfilename, driver="ESRI Shapefile") + + @pytest.mark.parametrize("driver,ext", driver_ext_pairs) def test_append_file(tmpdir, df_nybb, df_null, driver, ext): - """ Test to_file with append mode and from_file """ + """Test to_file with append mode and from_file""" from fiona import supported_drivers + tempfilename = os.path.join(str(tmpdir), "boros" + ext) + driver = driver if driver else _detect_driver(tempfilename) if "a" not in supported_drivers[driver]: return None - tempfilename = os.path.join(str(tmpdir), "boros." + ext) df_nybb.to_file(tempfilename, driver=driver) df_nybb.to_file(tempfilename, mode="a", driver=driver) # Read layer back in @@ -259,10 +324,10 @@ def test_append_file(tmpdir, df_nybb, df_null, driver, ext): assert "geometry" in df assert len(df) == (5 * 2) expected = pd.concat([df_nybb] * 2, ignore_index=True) - assert_geodataframe_equal(df, expected) + assert_geodataframe_equal(df, expected, check_less_precise=True) # Write layer with null geometry out to file - tempfilename = os.path.join(str(tmpdir), "null_geom." + ext) + tempfilename = os.path.join(str(tmpdir), "null_geom" + ext) df_null.to_file(tempfilename, driver=driver) df_null.to_file(tempfilename, mode="a", driver=driver) # Read layer back in @@ -270,7 +335,31 @@ def test_append_file(tmpdir, df_nybb, df_null, driver, ext): assert "geometry" in df assert len(df) == (2 * 2) expected = pd.concat([df_null] * 2, ignore_index=True) - assert_geodataframe_equal(df, expected) + assert_geodataframe_equal(df, expected, check_less_precise=True) + + +@pytest.mark.parametrize("driver,ext", driver_ext_pairs) +def test_empty_crs(tmpdir, driver, ext): + """Test handling of undefined CRS with GPKG driver (GH #1975).""" + if ext == ".gpkg": + pytest.xfail("GPKG is read with Undefined geographic SRS.") + + tempfilename = os.path.join(str(tmpdir), "boros" + ext) + df = GeoDataFrame( + { + "a": [1, 2, 3], + "geometry": [Point(0, 0), Point(1, 1), Point(2, 2)], + }, + ) + + df.to_file(tempfilename, driver=driver) + result = read_file(tempfilename) + + if ext == ".geojson": + # geojson by default assumes epsg:4326 + df.crs = "EPSG:4326" + + assert_geodataframe_equal(result, df) # ----------------------------------------------------------------------------- @@ -296,15 +385,22 @@ def test_read_file(df_nybb): def test_read_file_remote_geojson_url(): url = ( "https://raw.githubusercontent.com/geopandas/geopandas/" - "master/examples/null_geom.geojson" + "main/geopandas/tests/data/null_geom.geojson" + ) + gdf = read_file(url) + assert isinstance(gdf, geopandas.GeoDataFrame) + + +@pytest.mark.web +def test_read_file_remote_zipfile_url(): + url = ( + "https://raw.githubusercontent.com/geopandas/geopandas/" + "main/geopandas/datasets/nybb_16a.zip" ) gdf = read_file(url) assert isinstance(gdf, geopandas.GeoDataFrame) -@pytest.mark.skipif( - not _FIONA18, reason="support for file-like objects in fiona.open() added in 1.8" -) def test_read_file_textio(file_path): file_text_stream = open(file_path) file_stringio = io.StringIO(open(file_path).read()) @@ -314,9 +410,6 @@ def test_read_file_textio(file_path): assert isinstance(gdf_stringio, geopandas.GeoDataFrame) -@pytest.mark.skipif( - not _FIONA18, reason="support for file-like objects in fiona.open() added in 1.8" -) def test_read_file_bytesio(file_path): file_binary_stream = open(file_path, "rb") file_bytesio = io.BytesIO(open(file_path, "rb").read()) @@ -326,27 +419,18 @@ def test_read_file_bytesio(file_path): assert isinstance(gdf_bytesio, geopandas.GeoDataFrame) -@pytest.mark.skipif( - not _FIONA18, reason="support for file-like objects in fiona.open() added in 1.8" -) def test_read_file_raw_stream(file_path): file_raw_stream = open(file_path, "rb", buffering=0) gdf_raw_stream = read_file(file_raw_stream) assert isinstance(gdf_raw_stream, geopandas.GeoDataFrame) -@pytest.mark.skipif( - not _FIONA18, reason="support for file-like objects in fiona.open() added in 1.8" -) def test_read_file_pathlib(file_path): path_object = pathlib.Path(file_path) gdf_path_object = read_file(path_object) assert isinstance(gdf_path_object, geopandas.GeoDataFrame) -@pytest.mark.skipif( - not _FIONA18, reason="support for file-like objects in fiona.open() added in 1.8" -) def test_read_file_tempfile(): temp = tempfile.TemporaryFile() temp.write( @@ -369,8 +453,49 @@ def test_read_file_tempfile(): temp.close() -def test_read_file_filtered(df_nybb): - full_df_shape = df_nybb.shape +def test_read_binary_file_fsspec(): + fsspec = pytest.importorskip("fsspec") + # Remove the zip scheme so fsspec doesn't open as a zipped file, + # instead we want to read as bytes and let fiona decode it. + path = geopandas.datasets.get_path("nybb")[6:] + with fsspec.open(path, "rb") as f: + gdf = read_file(f) + assert isinstance(gdf, geopandas.GeoDataFrame) + + +def test_read_text_file_fsspec(file_path): + fsspec = pytest.importorskip("fsspec") + with fsspec.open(file_path, "r") as f: + gdf = read_file(f) + assert isinstance(gdf, geopandas.GeoDataFrame) + + +def test_infer_zipped_file(): + # Remove the zip scheme so that the test for a zipped file can + # check it and add it back. + path = geopandas.datasets.get_path("nybb")[6:] + gdf = read_file(path) + assert isinstance(gdf, geopandas.GeoDataFrame) + + # Check that it can successfully add a zip scheme to a path that already has a + # scheme + gdf = read_file("file+file://" + path) + assert isinstance(gdf, geopandas.GeoDataFrame) + + # Check that it can add a zip scheme for a path that includes a subpath + # within the archive. + gdf = read_file(path + "!nybb.shp") + assert isinstance(gdf, geopandas.GeoDataFrame) + + +def test_allow_legacy_gdal_path(): + # Construct a GDAL-style zip path. + path = "/vsizip/" + geopandas.datasets.get_path("nybb")[6:] + gdf = read_file(path) + assert isinstance(gdf, geopandas.GeoDataFrame) + + +def test_read_file_filtered__bbox(df_nybb): nybb_filename = geopandas.datasets.get_path("nybb") bbox = ( 1031051.7879884212, @@ -379,22 +504,36 @@ def test_read_file_filtered(df_nybb): 244317.30894023244, ) filtered_df = read_file(nybb_filename, bbox=bbox) - filtered_df_shape = filtered_df.shape - assert full_df_shape != filtered_df_shape - assert filtered_df_shape == (2, 5) + expected = df_nybb[df_nybb["BoroName"].isin(["Bronx", "Queens"])] + assert_geodataframe_equal(filtered_df, expected.reset_index(drop=True)) + + +def test_read_file_filtered__bbox__polygon(df_nybb): + nybb_filename = geopandas.datasets.get_path("nybb") + bbox = box( + 1031051.7879884212, 224272.49231459625, 1047224.3104931959, 244317.30894023244 + ) + filtered_df = read_file(nybb_filename, bbox=bbox) + expected = df_nybb[df_nybb["BoroName"].isin(["Bronx", "Queens"])] + assert_geodataframe_equal(filtered_df, expected.reset_index(drop=True)) def test_read_file_filtered__rows(df_nybb): - full_df_shape = df_nybb.shape nybb_filename = geopandas.datasets.get_path("nybb") filtered_df = read_file(nybb_filename, rows=1) - filtered_df_shape = filtered_df.shape - assert full_df_shape != filtered_df_shape - assert filtered_df_shape == (1, 5) + assert_geodataframe_equal(filtered_df, df_nybb.iloc[[0], :]) +def test_read_file_filtered__rows_slice(df_nybb): + nybb_filename = geopandas.datasets.get_path("nybb") + filtered_df = read_file(nybb_filename, rows=slice(1, 3)) + assert_geodataframe_equal(filtered_df, df_nybb.iloc[1:3, :].reset_index(drop=True)) + + +@pytest.mark.filterwarnings( + "ignore:Layer does not support OLC_FASTFEATURECOUNT:RuntimeWarning" +) # for the slice with -1 def test_read_file_filtered__rows_bbox(df_nybb): - full_df_shape = df_nybb.shape nybb_filename = geopandas.datasets.get_path("nybb") bbox = ( 1031051.7879884212, @@ -402,22 +541,11 @@ def test_read_file_filtered__rows_bbox(df_nybb): 1047224.3104931959, 244317.30894023244, ) + # combination bbox and rows (rows slice applied after bbox filtering!) + filtered_df = read_file(nybb_filename, bbox=bbox, rows=slice(4, None)) + assert filtered_df.empty filtered_df = read_file(nybb_filename, bbox=bbox, rows=slice(-1, None)) - filtered_df_shape = filtered_df.shape - assert full_df_shape != filtered_df_shape - assert filtered_df_shape == (1, 5) - - -def test_read_file_filtered__rows_bbox__polygon(df_nybb): - full_df_shape = df_nybb.shape - nybb_filename = geopandas.datasets.get_path("nybb") - bbox = box( - 1031051.7879884212, 224272.49231459625, 1047224.3104931959, 244317.30894023244 - ) - filtered_df = read_file(nybb_filename, bbox=bbox, rows=slice(-1, None)) - filtered_df_shape = filtered_df.shape - assert full_df_shape != filtered_df_shape - assert filtered_df_shape == (1, 5) + assert_geodataframe_equal(filtered_df, df_nybb.iloc[4:, :].reset_index(drop=True)) def test_read_file_filtered_rows_invalid(): @@ -425,22 +553,14 @@ def test_read_file_filtered_rows_invalid(): read_file(geopandas.datasets.get_path("nybb"), rows="not_a_slice") -@pytest.mark.skipif( - LooseVersion(fiona.__version__) < LooseVersion("1.8"), - reason="Ignore geometry only available in Fiona 1.8", -) def test_read_file__ignore_geometry(): pdf = geopandas.read_file( - geopandas.datasets.get_path("naturalearth_lowres"), ignore_geometry=True, + geopandas.datasets.get_path("naturalearth_lowres"), ignore_geometry=True ) assert "geometry" not in pdf.columns assert isinstance(pdf, pd.DataFrame) and not isinstance(pdf, geopandas.GeoDataFrame) -@pytest.mark.skipif( - LooseVersion(fiona.__version__) < LooseVersion("1.8"), - reason="Ignore fields only available in Fiona 1.8", -) def test_read_file__ignore_all_fields(): gdf = geopandas.read_file( geopandas.datasets.get_path("naturalearth_lowres"), @@ -749,3 +869,21 @@ def test_write_index_to_file(tmpdir, df_points, driver, ext): # named DatetimeIndex df.index.name = "datetime" do_checks(df, index_is_used=True) + + +def test_to_file__undetermined_driver(tmp_path, df_nybb): + shpdir = tmp_path / "boros.invalid" + df_nybb.to_file(shpdir) + assert shpdir.is_dir() + assert list(shpdir.glob("*.shp")) + + +@pytest.mark.parametrize( + "test_file", [(pathlib.Path("~/test_file.geojson")), "~/test_file.geojson"] +) +def test_write_read_file(test_file): + gdf = geopandas.GeoDataFrame(geometry=[box(0, 0, 10, 10)], crs=_CRS) + gdf.to_file(test_file, driver="GeoJSON") + df_json = geopandas.read_file(test_file) + assert_geodataframe_equal(gdf, df_json, check_crs=True) + os.remove(os.path.expanduser(test_file)) diff --git a/geopandas/io/tests/test_file_geom_types_drivers.py b/geopandas/io/tests/test_file_geom_types_drivers.py index 2a90f6a..aebd79e 100644 --- a/geopandas/io/tests/test_file_geom_types_drivers.py +++ b/geopandas/io/tests/test_file_geom_types_drivers.py @@ -1,6 +1,4 @@ -from enum import Enum import os -import sys from shapely.geometry import ( LineString, @@ -13,7 +11,6 @@ from shapely.geometry import ( import geopandas from geopandas import GeoDataFrame -from geopandas.io.file import _FIONA18 from geopandas.testing import assert_geodataframe_equal import pytest @@ -68,11 +65,6 @@ point_3D = Point(-73.553785, 45.508722, 300) # TEST TOOLING -class _Fiona(Enum): - below_1_8 = "fiona_below_1_8" - above_1_8 = "fiona_above_1_8" - - class _ExpectedError: def __init__(self, error_type, error_message_match): self.type = error_type @@ -89,19 +81,16 @@ class _ExpectedErrorBuilder: ) -def _expect_writing(gdf, ogr_driver, fiona_version): - return _ExpectedErrorBuilder(_composite_key(gdf, ogr_driver, fiona_version)) +def _expect_writing(gdf, ogr_driver): + return _ExpectedErrorBuilder(_composite_key(gdf, ogr_driver)) -def _composite_key(gdf, ogr_driver, fiona_version): - return frozenset([id(gdf), ogr_driver, fiona_version.value]) +def _composite_key(gdf, ogr_driver): + return frozenset([id(gdf), ogr_driver]) -def _expected_error_on(gdf, ogr_driver, is_fiona_above_1_8): - if is_fiona_above_1_8: - composite_key = _composite_key(gdf, ogr_driver, _Fiona.above_1_8) - else: - composite_key = _composite_key(gdf, ogr_driver, _Fiona.below_1_8) +def _expected_error_on(gdf, ogr_driver): + composite_key = _composite_key(gdf, ogr_driver) return _expected_exceptions.get(composite_key, None) @@ -141,15 +130,7 @@ _geodataframes_to_write.append(gdf) # 'ESRI Shapefile' driver supports writing LineString/MultiLinestring and # Polygon/MultiPolygon but does not mention Point/MultiPoint # see https://www.gdal.org/drv_shapefile.html -for driver in ("ESRI Shapefile", "GPKG"): - _expect_writing(gdf, driver, _Fiona.below_1_8).to_raise( - ValueError, - "Record's geometry type does not match collection schema's geometry " - "type: 'MultiPoint' != 'Point'", - ) -_expect_writing(gdf, "ESRI Shapefile", _Fiona.above_1_8).to_raise( - RuntimeError, "Failed to write record" -) +_expect_writing(gdf, "ESRI Shapefile").to_raise(RuntimeError, "Failed to write record") # ------------------ # gdf with LineStrings @@ -173,11 +154,6 @@ gdf = GeoDataFrame( geometry=[MultiLineString(city_hall_walls), city_hall_walls[0]], ) _geodataframes_to_write.append(gdf) -_expect_writing(gdf, "GPKG", _Fiona.below_1_8).to_raise( - ValueError, - "Record's geometry type does not match collection schema's geometry " - "type: 'MultiLineString' != 'LineString'", -) # ------------------ # gdf with Polygons @@ -206,11 +182,6 @@ gdf = GeoDataFrame( ], ) _geodataframes_to_write.append(gdf) -_expect_writing(gdf, "GPKG", _Fiona.below_1_8).to_raise( - ValueError, - "Record's geometry type does not match collection schema's geometry " - "type: 'MultiPolygon' != 'Polygon'", -) # ------------------ # gdf with null geometry and Point @@ -243,13 +214,7 @@ gdf = GeoDataFrame( ) _geodataframes_to_write.append(gdf) # Not supported by 'ESRI Shapefile' driver -for driver in ("ESRI Shapefile", "GPKG"): - _expect_writing(gdf, driver, _Fiona.below_1_8).to_raise( - AttributeError, "'list' object has no attribute 'lstrip'" - ) -_expect_writing(gdf, "ESRI Shapefile", _Fiona.above_1_8).to_raise( - RuntimeError, "Failed to write record" -) +_expect_writing(gdf, "ESRI Shapefile").to_raise(RuntimeError, "Failed to write record") # ------------------ # gdf with all 2D shape types and 3D Point mixed together @@ -268,13 +233,7 @@ gdf = GeoDataFrame( ) _geodataframes_to_write.append(gdf) # Not supported by 'ESRI Shapefile' driver -for driver in ("ESRI Shapefile", "GPKG"): - _expect_writing(gdf, driver, _Fiona.below_1_8).to_raise( - AttributeError, "'list' object has no attribute 'lstrip'" - ) -_expect_writing(gdf, "ESRI Shapefile", _Fiona.above_1_8).to_raise( - RuntimeError, "Failed to write record" -) +_expect_writing(gdf, "ESRI Shapefile").to_raise(RuntimeError, "Failed to write record") @pytest.fixture(params=_geodataframes_to_write) @@ -290,20 +249,13 @@ def ogr_driver(request): def test_to_file_roundtrip(tmpdir, geodataframe, ogr_driver): output_file = os.path.join(str(tmpdir), "output_file") - expected_error = _expected_error_on(geodataframe, ogr_driver, _FIONA18) + expected_error = _expected_error_on(geodataframe, ogr_driver) if expected_error: - with pytest.raises(expected_error.type, match=expected_error.match): + with pytest.raises(RuntimeError, match="Failed to write record"): geodataframe.to_file(output_file, driver=ogr_driver) else: geodataframe.to_file(output_file, driver=ogr_driver) reloaded = geopandas.read_file(output_file) - check_column_type = "equiv" - if sys.version_info[0] < 3: - # do not check column types in python 2 (mixed string/unicode) - check_column_type = False - - assert_geodataframe_equal( - geodataframe, reloaded, check_column_type=check_column_type - ) + assert_geodataframe_equal(geodataframe, reloaded, check_column_type="equiv") diff --git a/geopandas/io/tests/test_infer_schema.py b/geopandas/io/tests/test_infer_schema.py index c077254..8565aa0 100644 --- a/geopandas/io/tests/test_infer_schema.py +++ b/geopandas/io/tests/test_infer_schema.py @@ -11,10 +11,8 @@ from shapely.geometry import ( import pandas as pd import numpy as np -import pytest from geopandas import GeoDataFrame -from geopandas.io.file import _FIONA18, infer_schema -from geopandas._compat import PANDAS_GE_024 +from geopandas.io.file import infer_schema # Credit: Polygons below come from Montreal city Open Data portal # http://donnees.ville.montreal.qc.ca/dataset/unites-evaluation-fonciere @@ -90,13 +88,10 @@ def test_infer_schema_points_and_multipoints(): ] ) - if _FIONA18: - assert infer_schema(df) == { - "geometry": ["MultiPoint", "Point"], - "properties": OrderedDict(), - } - else: - assert infer_schema(df) == {"geometry": "Point", "properties": OrderedDict()} + assert infer_schema(df) == { + "geometry": ["MultiPoint", "Point"], + "properties": OrderedDict(), + } def test_infer_schema_only_multipoints(): @@ -120,16 +115,10 @@ def test_infer_schema_only_linestrings(): def test_infer_schema_linestrings_and_multilinestrings(): df = GeoDataFrame(geometry=[MultiLineString(city_hall_walls), city_hall_walls[0]]) - if _FIONA18: - assert infer_schema(df) == { - "geometry": ["MultiLineString", "LineString"], - "properties": OrderedDict(), - } - else: - assert infer_schema(df) == { - "geometry": "LineString", - "properties": OrderedDict(), - } + assert infer_schema(df) == { + "geometry": ["MultiLineString", "LineString"], + "properties": OrderedDict(), + } def test_infer_schema_only_multilinestrings(): @@ -155,13 +144,10 @@ def test_infer_schema_polygons_and_multipolygons(): ] ) - if _FIONA18: - assert infer_schema(df) == { - "geometry": ["MultiPolygon", "Polygon"], - "properties": OrderedDict(), - } - else: - assert infer_schema(df) == {"geometry": "Polygon", "properties": OrderedDict()} + assert infer_schema(df) == { + "geometry": ["MultiPolygon", "Polygon"], + "properties": OrderedDict(), + } def test_infer_schema_only_multipolygons(): @@ -182,23 +168,17 @@ def test_infer_schema_multiple_shape_types(): ] ) - if _FIONA18: - assert infer_schema(df) == { - "geometry": [ - "MultiPolygon", - "Polygon", - "MultiLineString", - "LineString", - "MultiPoint", - "Point", - ], - "properties": OrderedDict(), - } - else: - assert infer_schema(df) == { - "geometry": ["Polygon", "LineString", "Point"], - "properties": OrderedDict(), - } + assert infer_schema(df) == { + "geometry": [ + "MultiPolygon", + "Polygon", + "MultiLineString", + "LineString", + "MultiPoint", + "Point", + ], + "properties": OrderedDict(), + } def test_infer_schema_mixed_3D_shape_type(): @@ -214,36 +194,27 @@ def test_infer_schema_mixed_3D_shape_type(): ] ) - if _FIONA18: - assert infer_schema(df) == { - "geometry": [ - "3D Point", - "MultiPolygon", - "Polygon", - "MultiLineString", - "LineString", - "MultiPoint", - "Point", - ], - "properties": OrderedDict(), - } - else: - assert infer_schema(df) == { - "geometry": ["3D Polygon", "3D LineString", "3D Point"], - "properties": OrderedDict(), - } + assert infer_schema(df) == { + "geometry": [ + "3D Point", + "MultiPolygon", + "Polygon", + "MultiLineString", + "LineString", + "MultiPoint", + "Point", + ], + "properties": OrderedDict(), + } def test_infer_schema_mixed_3D_Point(): df = GeoDataFrame(geometry=[city_hall_balcony, point_3D]) - if _FIONA18: - assert infer_schema(df) == { - "geometry": ["3D Point", "Point"], - "properties": OrderedDict(), - } - else: - assert infer_schema(df) == {"geometry": "3D Point", "properties": OrderedDict()} + assert infer_schema(df) == { + "geometry": ["3D Point", "Point"], + "properties": OrderedDict(), + } def test_infer_schema_only_3D_Points(): @@ -255,16 +226,10 @@ def test_infer_schema_only_3D_Points(): def test_infer_schema_mixed_3D_linestring(): df = GeoDataFrame(geometry=[city_hall_walls[0], linestring_3D]) - if _FIONA18: - assert infer_schema(df) == { - "geometry": ["3D LineString", "LineString"], - "properties": OrderedDict(), - } - else: - assert infer_schema(df) == { - "geometry": "3D LineString", - "properties": OrderedDict(), - } + assert infer_schema(df) == { + "geometry": ["3D LineString", "LineString"], + "properties": OrderedDict(), + } def test_infer_schema_only_3D_linestrings(): @@ -279,16 +244,10 @@ def test_infer_schema_only_3D_linestrings(): def test_infer_schema_mixed_3D_Polygon(): df = GeoDataFrame(geometry=[city_hall_boundaries, polygon_3D]) - if _FIONA18: - assert infer_schema(df) == { - "geometry": ["3D Polygon", "Polygon"], - "properties": OrderedDict(), - } - else: - assert infer_schema(df) == { - "geometry": "3D Polygon", - "properties": OrderedDict(), - } + assert infer_schema(df) == { + "geometry": ["3D Polygon", "Polygon"], + "properties": OrderedDict(), + } def test_infer_schema_only_3D_Polygons(): @@ -319,7 +278,6 @@ def test_infer_schema_null_geometry_all(): assert infer_schema(df) == {"geometry": "Unknown", "properties": OrderedDict()} -@pytest.mark.skipif(not PANDAS_GE_024, reason="pandas >= 0.24 needed") def test_infer_schema_int64(): int64col = pd.array([1, np.nan], dtype=pd.Int64Dtype()) df = GeoDataFrame(geometry=[city_hall_entrance, city_hall_balcony]) diff --git a/geopandas/io/tests/test_pickle.py b/geopandas/io/tests/test_pickle.py new file mode 100644 index 0000000..85bbcba --- /dev/null +++ b/geopandas/io/tests/test_pickle.py @@ -0,0 +1,113 @@ +""" +See generate_legacy_storage_files.py for the creation of the legacy files. + +""" +from contextlib import contextmanager +from packaging.version import Version +import glob +import os +import pathlib + +import pandas as pd + +import pyproj + +import pytest +from geopandas.testing import assert_geodataframe_equal +from geopandas import _compat as compat +import geopandas +from shapely.geometry import Point + +DATA_PATH = pathlib.Path(os.path.dirname(__file__)) / "data" + + +@pytest.fixture(scope="module") +def current_pickle_data(): + # our current version pickle data + from .generate_legacy_storage_files import create_pickle_data + + return create_pickle_data() + + +files = glob.glob(str(DATA_PATH / "pickle" / "*.pickle")) + + +@pytest.fixture(params=files, ids=[p.split("/")[-1] for p in files]) +def legacy_pickle(request): + return request.param + + +@contextmanager +def with_use_pygeos(option): + orig = geopandas.options.use_pygeos + geopandas.options.use_pygeos = option + try: + yield + finally: + geopandas.options.use_pygeos = orig + + +@pytest.mark.skipif( + compat.USE_PYGEOS or (Version(pyproj.__version__) < Version("2.4")), + reason=( + "pygeos-based unpickling currently only works for pygeos-written files; " + "old pyproj versions can't read pickles from newer pyproj versions" + ), +) +def test_legacy_pickles(current_pickle_data, legacy_pickle): + result = pd.read_pickle(legacy_pickle) + + for name, value in result.items(): + expected = current_pickle_data[name] + assert_geodataframe_equal(value, expected) + + +def test_round_trip_current(tmpdir, current_pickle_data): + data = current_pickle_data + + for name, value in data.items(): + path = str(tmpdir / "{}.pickle".format(name)) + value.to_pickle(path) + result = pd.read_pickle(path) + assert_geodataframe_equal(result, value) + assert isinstance(result.has_sindex, bool) + + +def _create_gdf(): + return geopandas.GeoDataFrame( + {"a": [0.1, 0.2, 0.3], "geometry": [Point(1, 1), Point(2, 2), Point(3, 3)]}, + crs="EPSG:4326", + ) + + +@pytest.mark.skipif(not compat.HAS_PYGEOS, reason="requires pygeos to test #1745") +def test_pygeos_switch(tmpdir): + # writing and reading with pygeos disabled + with with_use_pygeos(False): + gdf = _create_gdf() + path = str(tmpdir / "gdf_crs1.pickle") + gdf.to_pickle(path) + result = pd.read_pickle(path) + assert_geodataframe_equal(result, gdf) + + # writing without pygeos, reading with pygeos + with with_use_pygeos(False): + gdf = _create_gdf() + path = str(tmpdir / "gdf_crs1.pickle") + gdf.to_pickle(path) + + with with_use_pygeos(True): + result = pd.read_pickle(path) + gdf = _create_gdf() + assert_geodataframe_equal(result, gdf) + + # writing with pygeos, reading without pygeos + with with_use_pygeos(True): + gdf = _create_gdf() + path = str(tmpdir / "gdf_crs1.pickle") + gdf.to_pickle(path) + + with with_use_pygeos(False): + result = pd.read_pickle(path) + gdf = _create_gdf() + assert_geodataframe_equal(result, gdf) diff --git a/geopandas/io/tests/test_sql.py b/geopandas/io/tests/test_sql.py index bf3beff..3376447 100644 --- a/geopandas/io/tests/test_sql.py +++ b/geopandas/io/tests/test_sql.py @@ -11,7 +11,7 @@ import pandas as pd import geopandas from geopandas import GeoDataFrame, read_file, read_postgis -from geopandas.io.sql import _write_postgis as write_postgis +from geopandas.io.sql import _get_conn as get_conn, _write_postgis as write_postgis from geopandas.tests.util import create_postgis, create_spatialite, validate_boro_df import pytest @@ -26,7 +26,7 @@ def df_nybb(): @pytest.fixture() def connection_postgis(): """ - Initiaties a connection to a postGIS database that must already exist. + Initiates a connection to a postGIS database that must already exist. See create_postgis for more information. """ psycopg2 = pytest.importorskip("psycopg2") @@ -51,7 +51,7 @@ def connection_postgis(): @pytest.fixture() def engine_postgis(): """ - Initiaties a connection engine to a postGIS database that must already exist. + Initiates a connection engine to a postGIS database that must already exist. """ sqlalchemy = pytest.importorskip("sqlalchemy") from sqlalchemy.engine.url import URL @@ -64,7 +64,7 @@ def engine_postgis(): try: con = sqlalchemy.create_engine( - URL( + URL.create( drivername="postgresql+psycopg2", username=user, database=dbname, @@ -111,11 +111,11 @@ def connection_spatialite(): con.close() -def drop_table_if_exists(engine, table): +def drop_table_if_exists(conn_or_engine, table): sqlalchemy = pytest.importorskip("sqlalchemy") - if engine.has_table(table): - metadata = sqlalchemy.MetaData(engine) + if sqlalchemy.inspect(conn_or_engine).has_table(table): + metadata = sqlalchemy.MetaData(conn_or_engine) metadata.reflect() table = metadata.tables.get(table) if table is not None: @@ -188,6 +188,19 @@ def df_3D_geoms(): class TestIO: + def test_get_conn(self, engine_postgis): + Connection = pytest.importorskip("sqlalchemy.engine.base").Connection + + engine = engine_postgis + with get_conn(engine) as output: + assert isinstance(output, Connection) + with engine.connect() as conn: + with get_conn(conn) as output: + assert isinstance(output, Connection) + with pytest.raises(ValueError): + with get_conn(object()): + pass + def test_read_postgis_default(self, connection_postgis, df_nybb): con = connection_postgis create_postgis(con, df_nybb) @@ -331,6 +344,36 @@ class TestIO: df = read_postgis(sql, engine, geom_col="geometry") validate_boro_df(df) + def test_write_postgis_uppercase_tablename(self, engine_postgis, df_nybb): + """Tests writing GeoDataFrame to PostGIS with uppercase tablename.""" + engine = engine_postgis + table = "aTestTable" + + # If table exists, delete it before trying to write with defaults + drop_table_if_exists(engine, table) + + # Write to db + write_postgis(df_nybb, con=engine, name=table, if_exists="fail") + # Validate + sql = 'SELECT * FROM "{table}";'.format(table=table) + df = read_postgis(sql, engine, geom_col="geometry") + validate_boro_df(df) + + def test_write_postgis_sqlalchemy_connection(self, engine_postgis, df_nybb): + """Tests that GeoDataFrame can be written to PostGIS with defaults.""" + with engine_postgis.begin() as con: + table = "nybb_con" + + # If table exists, delete it before trying to write with defaults + drop_table_if_exists(con, table) + + # Write to db + write_postgis(df_nybb, con=con, name=table, if_exists="fail") + # Validate + sql = "SELECT * FROM {table};".format(table=table) + df = read_postgis(sql, con, geom_col="geometry") + validate_boro_df(df) + def test_write_postgis_fail_when_table_exists(self, engine_postgis, df_nybb): """ Tests that uploading the same table raises error when: if_replace='fail'. diff --git a/geopandas/plotting.py b/geopandas/plotting.py index cc5168a..603b8b8 100644 --- a/geopandas/plotting.py +++ b/geopandas/plotting.py @@ -2,10 +2,13 @@ import warnings import numpy as np import pandas as pd +from pandas.plotting import PlotAccessor import geopandas -from distutils.version import LooseVersion +from packaging.version import Version + +from ._decorator import doc def deprecated(new): @@ -45,8 +48,8 @@ def _flatten_multi_geoms(geoms, prefix="Multi"): return geoms, np.arange(len(geoms)) for ix, geom in enumerate(geoms): - if geom.type.startswith(prefix): - for poly in geom: + if geom is not None and geom.type.startswith(prefix) and not geom.is_empty: + for poly in geom.geoms: components.append(poly) component_index.append(ix) else: @@ -63,9 +66,17 @@ def _expand_kwargs(kwargs, multiindex): it (in place) to the correct length/formats with help of 'multiindex', unless the value appears to already be a valid (single) value for the key. """ + import matplotlib from matplotlib.colors import is_color_like from typing import Iterable + mpl = Version(matplotlib.__version__) + if mpl >= Version("3.4") or (mpl > Version("3.3.2") and "+" in mpl): + # alpha is supported as array argument with matplotlib 3.4+ + scalar_kwargs = ["marker", "path_effects"] + else: + scalar_kwargs = ["marker", "alpha", "path_effects"] + for att, value in kwargs.items(): if "color" in att: # color(s), edgecolor(s), facecolor(s) if is_color_like(value): @@ -78,7 +89,7 @@ def _expand_kwargs(kwargs, multiindex): and isinstance(value[1], Iterable) ): continue - elif att in ["marker", "alpha"]: + elif att in scalar_kwargs: # For these attributes, only a single value is allowed, so never expand. continue @@ -86,6 +97,32 @@ def _expand_kwargs(kwargs, multiindex): kwargs[att] = np.take(value, multiindex, axis=0) +def _PolygonPatch(polygon, **kwargs): + """Constructs a matplotlib patch from a Polygon geometry + + The `kwargs` are those supported by the matplotlib.patches.PathPatch class + constructor. Returns an instance of matplotlib.patches.PathPatch. + + Example (using Shapely Point and a matplotlib axes):: + + b = shapely.geometry.Point(0, 0).buffer(1.0) + patch = _PolygonPatch(b, fc='blue', ec='blue', alpha=0.5) + ax.add_patch(patch) + + GeoPandas originally relied on the descartes package by Sean Gillies + (BSD license, https://pypi.org/project/descartes) for PolygonPatch, but + this dependency was removed in favor of the below matplotlib code. + """ + from matplotlib.patches import PathPatch + from matplotlib.path import Path + + path = Path.make_compound_path( + Path(np.asarray(polygon.exterior.coords)[:, :2]), + *[Path(np.asarray(ring.coords)[:, :2]) for ring in polygon.interiors], + ) + return PathPatch(path, **kwargs) + + def _plot_polygon_collection( ax, geoms, values=None, color=None, cmap=None, vmin=None, vmax=None, **kwargs ): @@ -115,15 +152,6 @@ def _plot_polygon_collection( ------- collection : matplotlib.collections.Collection that was plotted """ - - try: - from descartes.patch import PolygonPatch - except ImportError: - raise ImportError( - "The descartes package is required for plotting polygons in geopandas. " - "You can install it using 'conda install -c conda-forge descartes' or " - "'pip install descartes'." - ) from matplotlib.collections import PatchCollection geoms, multiindex = _flatten_multi_geoms(geoms) @@ -143,7 +171,9 @@ def _plot_polygon_collection( _expand_kwargs(kwargs, multiindex) - collection = PatchCollection([PolygonPatch(poly) for poly in geoms], **kwargs) + collection = PatchCollection( + [_PolygonPatch(poly) for poly in geoms if not poly.is_empty], **kwargs + ) if values is not None: collection.set_array(np.asarray(values)) @@ -200,7 +230,7 @@ def _plot_linestring_collection( _expand_kwargs(kwargs, multiindex) - segments = [np.array(linestring)[:, :2] for linestring in geoms] + segments = [np.array(linestring.coords)[:, :2] for linestring in geoms] collection = LineCollection(segments, **kwargs) if values is not None: @@ -227,7 +257,7 @@ def _plot_point_collection( vmax=None, marker="o", markersize=None, - **kwargs + **kwargs, ): """ Plots a collection of Point and MultiPoint geometries to `ax` @@ -254,11 +284,10 @@ def _plot_point_collection( raise ValueError("Can only specify one of 'values' and 'color' kwargs") geoms, multiindex = _flatten_multi_geoms(geoms) - if values is not None: - values = np.take(values, multiindex, axis=0) + # values are expanded below as kwargs["c"] - x = [p.x for p in geoms] - y = [p.y for p in geoms] + x = [p.x if not p.is_empty else None for p in geoms] + y = [p.y if not p.is_empty else None for p in geoms] # matplotlib 1.4 does not support c=None, and < 2.0 does not support s=None if values is not None: @@ -313,14 +342,14 @@ def plot_series( figsize : pair of floats (default None) Size of the resulting matplotlib.figure.Figure. If the argument ax is given explicitly, figsize is ignored. - aspect : 'auto', 'equal' or float (default 'auto') + aspect : 'auto', 'equal', None or float (default 'auto') Set aspect of axis. If 'auto', the default aspect for map plots is 'equal'; if however data are not projected (coordinates are long/lat), the aspect is by default set to 1/cos(s_y * pi/180) with s_y the y coordinate of the middle of the GeoSeries (the mean of the y range of bounding box) so that a long/lat square appears square in the middle of the plot. This implies an - Equirectangular projection. It can also be set manually (float) as the ratio - of y-unit to x-unit. + Equirectangular projection. If None, the aspect of `ax` won't be changed. It can + also be set manually (float) as the ratio of y-unit to x-unit. **style_kwds : dict Color options to be passed on to the actual plot function, such as ``edgecolor``, ``facecolor``, ``linewidth``, ``markersize``, @@ -366,7 +395,7 @@ def plot_series( # https://github.com/edzer/sp/blob/master/R/mapasp.R else: ax.set_aspect("equal") - else: + elif aspect is not None: ax.set_aspect(aspect) if s.empty: @@ -377,6 +406,14 @@ def plot_series( ) return ax + if s.is_empty.all(): + warnings.warn( + "The GeoSeries you are attempting to plot is " + "composed of empty geometries. Nothing has been displayed.", + UserWarning, + ) + return ax + # if cmap is specified, create range of colors based on cmap values = None if cmap is not None: @@ -454,7 +491,7 @@ def plot_dataframe( classification_kwds=None, missing_kwds=None, aspect="auto", - **style_kwds + **style_kwds, ): """ Plot a GeoDataFrame. @@ -465,15 +502,26 @@ def plot_dataframe( Parameters ---------- - df : GeoDataFrame - The GeoDataFrame to be plotted. Currently Polygon, - MultiPolygon, LineString, MultiLineString and Point - geometries can be plotted. column : str, np.array, pd.Series (default None) The name of the dataframe column, np.array, or pd.Series to be plotted. If np.array or pd.Series are used then it must have same length as dataframe. Values are used to color the plot. Ignored if `color` is also set. + kind: str + The kind of plots to produce: + - 'geo': Map (default) + Pandas Kinds + - 'line' : line plot + - 'bar' : vertical bar plot + - 'barh' : horizontal bar plot + - 'hist' : histogram + - 'box' : BoxPlot + - 'kde' : Kernel Density Estimation plot + - 'density' : same as 'kde' + - 'area' : area plot + - 'pie' : pie plot + - 'scatter' : scatter plot + - 'hexbin' : hexbin plot. cmap : str (default None) The name of a colormap recognized by matplotlib. color : str (default None) @@ -515,8 +563,8 @@ def plot_dataframe( Size of the resulting matplotlib.figure.Figure. If the argument axes is given explicitly, figsize is ignored. legend_kwds : dict (default None) - Keyword arguments to pass to matplotlib.pyplot.legend() or - matplotlib.pyplot.colorbar(). + Keyword arguments to pass to :func:`matplotlib.pyplot.legend` or + :func:`matplotlib.pyplot.colorbar`. Additional accepted keywords when `scheme` is specified: fmt : string @@ -526,6 +574,9 @@ def plot_dataframe( A list of legend labels to override the auto-generated labels. Needs to have the same number of elements as the number of classes (`k`). + interval : boolean (default False) + An option to control brackets from mapclassify legend. + If True, open/closed interval brackets are shown in the legend. categories : list-like Ordered list-like object of categories to be used for categorical plot. classification_kwds : dict (default None) @@ -535,14 +586,14 @@ def plot_dataframe( to be passed on to geometries with missing values in addition to or overwriting other style kwds. If None, geometries with missing values are not plotted. - aspect : 'auto', 'equal' or float (default 'auto') + aspect : 'auto', 'equal', None or float (default 'auto') Set aspect of axis. If 'auto', the default aspect for map plots is 'equal'; if however data are not projected (coordinates are long/lat), the aspect is by default set to 1/cos(df_y * pi/180) with df_y the y coordinate of the middle of the GeoDataFrame (the mean of the y range of bounding box) so that a long/lat square appears square in the middle of the plot. This implies an - Equirectangular projection. It can also be set manually (float) as the ratio - of y-unit to x-unit. + Equirectangular projection. If None, the aspect of `ax` won't be changed. It can + also be set manually (float) as the ratio of y-unit to x-unit. **style_kwds : dict Style options to be passed on to the actual plot function, such @@ -553,6 +604,27 @@ def plot_dataframe( ------- ax : matplotlib axes instance + Examples + -------- + >>> df = geopandas.read_file(geopandas.datasets.get_path("naturalearth_lowres")) + >>> df.head() # doctest: +SKIP + pop_est continent name iso_a3 \ +gdp_md_est geometry + 0 920938 Oceania Fiji FJI 8374.0 MULTIPOLY\ +GON (((180.00000 -16.06713, 180.00000... + 1 53950935 Africa Tanzania TZA 150600.0 POLYGON (\ +(33.90371 -0.95000, 34.07262 -1.05982... + 2 603253 Africa W. Sahara ESH 906.5 POLYGON (\ +(-8.66559 27.65643, -8.66512 27.58948... + 3 35623680 North America Canada CAN 1674000.0 MULTIPOLY\ +GON (((-122.84000 49.00000, -122.9742... + 4 326625791 North America United States of America USA 18560000.0 MULTIPOLY\ +GON (((-122.84000 49.00000, -120.0000... + + >>> df.plot("pop_est", cmap="Blues") # doctest: +SKIP + + See the User Guide page :doc:`../../user_guide/mapping` for details. + """ if "colormap" in style_kwds: warnings.warn( @@ -597,9 +669,14 @@ def plot_dataframe( # https://github.com/edzer/sp/blob/master/R/mapasp.R else: ax.set_aspect("equal") - else: + elif aspect is not None: ax.set_aspect(aspect) + # GH 1555 + # if legend_kwds set, copy so we don't update it in place + if legend_kwds is not None: + legend_kwds = legend_kwds.copy() + if df.empty: warnings.warn( "The GeoDataFrame you are attempting to plot is " @@ -620,7 +697,7 @@ def plot_dataframe( figsize=figsize, markersize=markersize, aspect=aspect, - **style_kwds + **style_kwds, ) # To accept pd.Series and np.arrays as column @@ -631,6 +708,10 @@ def plot_dataframe( ) else: values = column + + # Make sure index of a Series matches index of df + if isinstance(values, pd.Series): + values = values.reindex(df.index) else: values = df[column] @@ -645,6 +726,62 @@ def plot_dataframe( nan_idx = np.asarray(pd.isna(values), dtype="bool") + if scheme is not None: + mc_err = ( + "The 'mapclassify' package (>= 2.4.0) is " + "required to use the 'scheme' keyword." + ) + try: + import mapclassify + + except ImportError: + raise ImportError(mc_err) + + if Version(mapclassify.__version__) < Version("2.4.0"): + raise ImportError(mc_err) + + if classification_kwds is None: + classification_kwds = {} + if "k" not in classification_kwds: + classification_kwds["k"] = k + + binning = mapclassify.classify( + np.asarray(values[~nan_idx]), scheme, **classification_kwds + ) + # set categorical to True for creating the legend + categorical = True + if legend_kwds is not None and "labels" in legend_kwds: + if len(legend_kwds["labels"]) != binning.k: + raise ValueError( + "Number of labels must match number of bins, " + "received {} labels for {} bins".format( + len(legend_kwds["labels"]), binning.k + ) + ) + else: + labels = list(legend_kwds.pop("labels")) + else: + fmt = "{:.2f}" + if legend_kwds is not None and "fmt" in legend_kwds: + fmt = legend_kwds.pop("fmt") + + labels = binning.get_legend_classes(fmt) + if legend_kwds is not None: + show_interval = legend_kwds.pop("interval", False) + else: + show_interval = False + if not show_interval: + labels = [c[1:-1] for c in labels] + + values = pd.Categorical( + [np.nan] * len(values), categories=binning.bins, ordered=True + ) + values[~nan_idx] = pd.Categorical.from_codes( + binning.yb, categories=binning.bins, ordered=True + ) + if cmap is None: + cmap = "viridis" + # Define `values` as a Series if categorical: if cmap is None: @@ -665,32 +802,6 @@ def plot_dataframe( vmin = 0 if vmin is None else vmin vmax = len(categories) - 1 if vmax is None else vmax - if scheme is not None: - if classification_kwds is None: - classification_kwds = {} - if "k" not in classification_kwds: - classification_kwds["k"] = k - - binning = _mapclassify_choro(values[~nan_idx], scheme, **classification_kwds) - # set categorical to True for creating the legend - categorical = True - if legend_kwds is not None and "labels" in legend_kwds: - if len(legend_kwds["labels"]) != binning.k: - raise ValueError( - "Number of labels must match number of bins, " - "received {} labels for {} bins".format( - len(legend_kwds["labels"]), binning.k - ) - ) - else: - categories = list(legend_kwds.pop("labels")) - else: - fmt = "{:.2f}" - if legend_kwds is not None and "fmt" in legend_kwds: - fmt = legend_kwds.pop("fmt") - categories = binning.get_legend_classes(fmt) - values = np.array(binning.yb) - # fill values with placeholder where were NaNs originally to map them properly # (after removing them in categorical or scheme) if categorical: @@ -746,10 +857,11 @@ def plot_dataframe( vmax=mx, markersize=markersize, cmap=cmap, - **style_kwds + **style_kwds, ) - if missing_kwds is not None: + missing_data = not expl_series[nan_idx].empty + if missing_kwds is not None and missing_data: if color: if "color" not in missing_kwds: missing_kwds["color"] = color @@ -775,6 +887,8 @@ def plot_dataframe( norm = Normalize(vmin=mn, vmax=mx) n_cmap = cm.ScalarMappable(norm=norm, cmap=cmap) if categorical: + if scheme is not None: + categories = labels patches = [] for value, cat in enumerate(categories): patches.append( @@ -789,7 +903,7 @@ def plot_dataframe( markeredgewidth=0, ) ) - if missing_kwds is not None: + if missing_kwds is not None and missing_data: if "color" in merged_kwds: merged_kwds["facecolor"] = merged_kwds["color"] patches.append( @@ -818,105 +932,29 @@ def plot_dataframe( else: legend_kwds.setdefault("ax", ax) - n_cmap.set_array([]) + n_cmap.set_array(np.array([])) ax.get_figure().colorbar(n_cmap, **legend_kwds) plt.draw() return ax -def _mapclassify_choro(values, scheme, **classification_kwds): - """ - Wrapper for choropleth schemes from mapclassify for use with plot_dataframe +@doc(plot_dataframe) +class GeoplotAccessor(PlotAccessor): - Parameters - ---------- - values - Series to be plotted - scheme : str - One of mapclassify classification schemes - Options are BoxPlot, EqualInterval, FisherJenks, - FisherJenksSampled, HeadTailBreaks, JenksCaspall, - JenksCaspallForced, JenksCaspallSampled, MaxP, - MaximumBreaks, NaturalBreaks, Quantiles, Percentiles, StdMean, - UserDefined + _pandas_kinds = PlotAccessor._all_kinds - **classification_kwds : dict - Keyword arguments for classification scheme - For details see mapclassify documentation: - https://mapclassify.readthedocs.io/en/latest/api.html + def __call__(self, *args, **kwargs): + data = self._parent.copy() + kind = kwargs.pop("kind", "geo") + if kind == "geo": + return plot_dataframe(data, *args, **kwargs) + if kind in self._pandas_kinds: + # Access pandas plots + return PlotAccessor(data)(kind=kind, **kwargs) + else: + # raise error + raise ValueError(f"{kind} is not a valid plot kind") - Returns - ------- - binning - Binning objects that holds the Series with values replaced with - class identifier and the bins. - """ - try: - import mapclassify.classifiers as classifiers - - except ImportError: - raise ImportError( - "The 'mapclassify' >= 2.2.0 package is required to use the 'scheme' keyword" - ) - from mapclassify import __version__ as mc_version - - if mc_version < LooseVersion("2.2.0"): - raise ImportError( - "The 'mapclassify' >= 2.2.0 package is required to " - "use the 'scheme' keyword" - ) - schemes = {} - for classifier in classifiers.CLASSIFIERS: - schemes[classifier.lower()] = getattr(classifiers, classifier) - - scheme = scheme.lower() - - # mapclassify < 2.1 cleaned up the scheme names (removing underscores) - # trying both to keep compatibility with older versions and provide - # compatibility with newer versions of mapclassify - oldnew = { - "Box_Plot": "BoxPlot", - "Equal_Interval": "EqualInterval", - "Fisher_Jenks": "FisherJenks", - "Fisher_Jenks_Sampled": "FisherJenksSampled", - "HeadTail_Breaks": "HeadTailBreaks", - "Jenks_Caspall": "JenksCaspall", - "Jenks_Caspall_Forced": "JenksCaspallForced", - "Jenks_Caspall_Sampled": "JenksCaspallSampled", - "Max_P_Plassifier": "MaxP", - "Maximum_Breaks": "MaximumBreaks", - "Natural_Breaks": "NaturalBreaks", - "Std_Mean": "StdMean", - "User_Defined": "UserDefined", - } - scheme_names_mapping = {} - scheme_names_mapping.update( - {old.lower(): new.lower() for old, new in oldnew.items()} - ) - scheme_names_mapping.update( - {new.lower(): old.lower() for old, new in oldnew.items()} - ) - - try: - scheme_class = schemes[scheme] - except KeyError: - scheme = scheme_names_mapping.get(scheme, scheme) - try: - scheme_class = schemes[scheme] - except KeyError: - raise ValueError( - "Invalid scheme. Scheme must be in the set: %r" % schemes.keys() - ) - - if classification_kwds["k"] is not None: - from inspect import getfullargspec as getspec - - spec = getspec(scheme_class.__init__) - if "k" not in spec.args: - del classification_kwds["k"] - try: - binning = scheme_class(values, **classification_kwds) - except TypeError: - raise TypeError("Invalid keyword argument for %r " % scheme) - return binning + def geo(self, *args, **kwargs): + return self(kind="geo", *args, **kwargs) diff --git a/geopandas/sindex.py b/geopandas/sindex.py index 7159f68..effa208 100644 --- a/geopandas/sindex.py +++ b/geopandas/sindex.py @@ -1,35 +1,14 @@ -from collections import namedtuple -from warnings import warn +import warnings from shapely.geometry.base import BaseGeometry import pandas as pd import numpy as np from . import _compat as compat +from ._decorator import doc -VALID_QUERY_PREDICATES = { - None, - "intersects", - "within", - "contains", - "overlaps", - "crosses", - "touches", -} - - -def has_sindex(): - """Dynamically checks for ability to generate spatial index. - """ - try: - get_sindex_class() - return True - except ImportError: - return False - - -def get_sindex_class(): +def _get_sindex_class(): """Dynamically chooses a spatial indexing backend. Required to comply with _compat.USE_PYGEOS. @@ -45,24 +24,372 @@ def get_sindex_class(): ) +class BaseSpatialIndex: + @property + def valid_query_predicates(self): + """Returns valid predicates for this spatial index. + + Returns + ------- + set + Set of valid predicates for this spatial index. + + Examples + -------- + >>> from shapely.geometry import Point + >>> s = geopandas.GeoSeries([Point(0, 0), Point(1, 1)]) + >>> s.sindex.valid_query_predicates # doctest: +SKIP + {'contains', 'crosses', 'intersects', 'within', 'touches', \ +'overlaps', None, 'covers', 'contains_properly'} + """ + raise NotImplementedError + + def query(self, geometry, predicate=None, sort=False): + """Return the index of all geometries in the tree with extents that + intersect the envelope of the input geometry. + + When using the ``rtree`` package, this is not a vectorized function. + If speed is important, please use PyGEOS. + + Parameters + ---------- + geometry : shapely geometry + A single shapely geometry to query against the spatial index. + predicate : {None, 'intersects', 'within', 'contains', \ +'overlaps', 'crosses', 'touches'}, optional + If predicate is provided, the input geometry is + tested using the predicate function against each item + in the tree whose extent intersects the envelope of the + input geometry: predicate(input_geometry, tree_geometry). + If possible, prepared geometries are used to help + speed up the predicate operation. + sort : bool, default False + If True, the results will be sorted in ascending order. + If False, results are often sorted but there is no guarantee. + + Returns + ------- + matches : ndarray of shape (n_results, ) + Integer indices for matching geometries from the spatial index. + + Examples + -------- + >>> from shapely.geometry import Point, box + >>> s = geopandas.GeoSeries(geopandas.points_from_xy(range(10), range(10))) + >>> s + 0 POINT (0.00000 0.00000) + 1 POINT (1.00000 1.00000) + 2 POINT (2.00000 2.00000) + 3 POINT (3.00000 3.00000) + 4 POINT (4.00000 4.00000) + 5 POINT (5.00000 5.00000) + 6 POINT (6.00000 6.00000) + 7 POINT (7.00000 7.00000) + 8 POINT (8.00000 8.00000) + 9 POINT (9.00000 9.00000) + dtype: geometry + + >>> s.sindex.query(box(1, 1, 3, 3)) + array([1, 2, 3]) + + >>> s.sindex.query(box(1, 1, 3, 3), predicate="contains") + array([2]) + """ + raise NotImplementedError + + def query_bulk(self, geometry, predicate=None, sort=False): + """ + Returns all combinations of each input geometry and geometries in + the tree where the envelope of each input geometry intersects with + the envelope of a tree geometry. + + In the context of a spatial join, input geometries are the “left” + geometries that determine the order of the results, and tree geometries + are “right” geometries that are joined against the left geometries. + This effectively performs an inner join, where only those combinations + of geometries that can be joined based on envelope overlap or optional + predicate are returned. + + When using the ``rtree`` package, this is not a vectorized function + and may be slow. If speed is important, please use PyGEOS. + + Parameters + ---------- + geometry : {GeoSeries, GeometryArray, numpy.array of PyGEOS geometries} + Accepts GeoPandas geometry iterables (GeoSeries, GeometryArray) + or a numpy array of PyGEOS geometries. + predicate : {None, 'intersects', 'within', 'contains', 'overlaps', \ +'crosses', 'touches'}, optional + If predicate is provided, the input geometries are tested using + the predicate function against each item in the tree whose extent + intersects the envelope of the each input geometry: + predicate(input_geometry, tree_geometry). If possible, prepared + geometries are used to help speed up the predicate operation. + sort : bool, default False + If True, results sorted lexicographically using + geometry's indexes as the primary key and the sindex's indexes as the + secondary key. If False, no additional sorting is applied. + + Returns + ------- + ndarray with shape (2, n) + The first subarray contains input geometry integer indexes. + The second subarray contains tree geometry integer indexes. + + Examples + -------- + >>> from shapely.geometry import Point, box + >>> s = geopandas.GeoSeries(geopandas.points_from_xy(range(10), range(10))) + >>> s + 0 POINT (0.00000 0.00000) + 1 POINT (1.00000 1.00000) + 2 POINT (2.00000 2.00000) + 3 POINT (3.00000 3.00000) + 4 POINT (4.00000 4.00000) + 5 POINT (5.00000 5.00000) + 6 POINT (6.00000 6.00000) + 7 POINT (7.00000 7.00000) + 8 POINT (8.00000 8.00000) + 9 POINT (9.00000 9.00000) + dtype: geometry + >>> s2 = geopandas.GeoSeries([box(2, 2, 4, 4), box(5, 5, 6, 6)]) + >>> s2 + 0 POLYGON ((4.00000 2.00000, 4.00000 4.00000, 2.... + 1 POLYGON ((6.00000 5.00000, 6.00000 6.00000, 5.... + dtype: geometry + + >>> s.sindex.query_bulk(s2) + array([[0, 0, 0, 1, 1], + [2, 3, 4, 5, 6]]) + + >>> s.sindex.query_bulk(s2, predicate="contains") + array([[0], + [3]]) + """ + raise NotImplementedError + + def nearest( + self, geometry, return_all=True, max_distance=None, return_distance=False + ): + """ + Return the nearest geometry in the tree for each input geometry in + ``geometry``. + + .. note:: + ``nearest`` currently only works with PyGEOS >= 0.10. + + Note that if PyGEOS is not available, geopandas will use rtree + for the spatial index, where nearest has a different + function signature to temporarily preserve existing + functionality. See the documentation of + :meth:`rtree.index.Index.nearest` for the details on the + ``rtree``-based implementation. + + If multiple tree geometries have the same distance from an input geometry, + multiple results will be returned for that input geometry by default. + Specify ``return_all=False`` to only get a single nearest geometry + (non-deterministic which nearest is returned). + + In the context of a spatial join, input geometries are the "left" + geometries that determine the order of the results, and tree geometries + are "right" geometries that are joined against the left geometries. + If ``max_distance`` is not set, this will effectively be a left join + because every geometry in ``geometry`` will have a nearest geometry in + the tree. However, if ``max_distance`` is used, this becomes an + inner join, since some geometries in ``geometry`` may not have a match + in the tree. + + For performance reasons, it is highly recommended that you set + the ``max_distance`` parameter. + + Parameters + ---------- + geometry : {shapely.geometry, GeoSeries, GeometryArray, numpy.array of PyGEOS \ +geometries} + A single shapely geometry, one of the GeoPandas geometry iterables + (GeoSeries, GeometryArray), or a numpy array of PyGEOS geometries to query + against the spatial index. + return_all : bool, default True + If there are multiple equidistant or intersecting nearest + geometries, return all those geometries instead of a single + nearest geometry. + max_distance : float, optional + Maximum distance within which to query for nearest items in tree. + Must be greater than 0. By default None, indicating no distance limit. + return_distance : bool, optional + If True, will return distances in addition to indexes. By default False + + Returns + ------- + Indices or tuple of (indices, distances) + Indices is an ndarray of shape (2,n) and distances (if present) an + ndarray of shape (n). + The first subarray of indices contains input geometry indices. + The second subarray of indices contains tree geometry indices. + + Examples + -------- + >>> from shapely.geometry import Point, box + >>> s = geopandas.GeoSeries(geopandas.points_from_xy(range(10), range(10))) + >>> s.head() + 0 POINT (0.00000 0.00000) + 1 POINT (1.00000 1.00000) + 2 POINT (2.00000 2.00000) + 3 POINT (3.00000 3.00000) + 4 POINT (4.00000 4.00000) + dtype: geometry + + >>> s.sindex.nearest(Point(1, 1)) + array([[0], + [1]]) + + >>> s.sindex.nearest([box(4.9, 4.9, 5.1, 5.1)]) + array([[0], + [5]]) + + >>> s2 = geopandas.GeoSeries(geopandas.points_from_xy([7.6, 10], [7.6, 10])) + >>> s2 + 0 POINT (7.60000 7.60000) + 1 POINT (10.00000 10.00000) + dtype: geometry + + >>> s.sindex.nearest(s2) + array([[0, 1], + [8, 9]]) + """ + raise NotImplementedError + + def intersection(self, coordinates): + """Compatibility wrapper for rtree.index.Index.intersection, + use ``query`` instead. + + Parameters + ---------- + coordinates : sequence or array + Sequence of the form (min_x, min_y, max_x, max_y) + to query a rectangle or (x, y) to query a point. + + Examples + -------- + >>> from shapely.geometry import Point, box + >>> s = geopandas.GeoSeries(geopandas.points_from_xy(range(10), range(10))) + >>> s + 0 POINT (0.00000 0.00000) + 1 POINT (1.00000 1.00000) + 2 POINT (2.00000 2.00000) + 3 POINT (3.00000 3.00000) + 4 POINT (4.00000 4.00000) + 5 POINT (5.00000 5.00000) + 6 POINT (6.00000 6.00000) + 7 POINT (7.00000 7.00000) + 8 POINT (8.00000 8.00000) + 9 POINT (9.00000 9.00000) + dtype: geometry + + >>> s.sindex.intersection(box(1, 1, 3, 3).bounds) + array([1, 2, 3]) + + Alternatively, you can use ``query``: + + >>> s.sindex.query(box(1, 1, 3, 3)) + array([1, 2, 3]) + + """ + raise NotImplementedError + + @property + def size(self): + """Size of the spatial index + + Number of leaves (input geometries) in the index. + + Examples + -------- + >>> from shapely.geometry import Point + >>> s = geopandas.GeoSeries(geopandas.points_from_xy(range(10), range(10))) + >>> s + 0 POINT (0.00000 0.00000) + 1 POINT (1.00000 1.00000) + 2 POINT (2.00000 2.00000) + 3 POINT (3.00000 3.00000) + 4 POINT (4.00000 4.00000) + 5 POINT (5.00000 5.00000) + 6 POINT (6.00000 6.00000) + 7 POINT (7.00000 7.00000) + 8 POINT (8.00000 8.00000) + 9 POINT (9.00000 9.00000) + dtype: geometry + + >>> s.sindex.size + 10 + """ + raise NotImplementedError + + @property + def is_empty(self): + """Check if the spatial index is empty + + Examples + -------- + >>> from shapely.geometry import Point + >>> s = geopandas.GeoSeries(geopandas.points_from_xy(range(10), range(10))) + >>> s + 0 POINT (0.00000 0.00000) + 1 POINT (1.00000 1.00000) + 2 POINT (2.00000 2.00000) + 3 POINT (3.00000 3.00000) + 4 POINT (4.00000 4.00000) + 5 POINT (5.00000 5.00000) + 6 POINT (6.00000 6.00000) + 7 POINT (7.00000 7.00000) + 8 POINT (8.00000 8.00000) + 9 POINT (9.00000 9.00000) + dtype: geometry + + >>> s.sindex.is_empty + False + + >>> s2 = geopandas.GeoSeries() + >>> s2.sindex.is_empty + True + """ + raise NotImplementedError + + if compat.HAS_RTREE: import rtree.index # noqa from rtree.core import RTreeError # noqa from shapely.prepared import prep # noqa - class SpatialIndex(rtree.index.Index): - """Original rtree wrapper, kept for backwards compatibility. - """ + class SpatialIndex(rtree.index.Index, BaseSpatialIndex): + """Original rtree wrapper, kept for backwards compatibility.""" def __init__(self, *args): - super().__init__(self, *args) + warnings.warn( + "Directly using SpatialIndex is deprecated, and the class will be " + "removed in a future version. Access the spatial index through the " + "`GeoSeries.sindex` attribute, or use `rtree.index.Index` directly.", + FutureWarning, + stacklevel=2, + ) + super().__init__(*args) + + @doc(BaseSpatialIndex.intersection) + def intersection(self, coordinates, *args, **kwargs): + return super().intersection(coordinates, *args, **kwargs) + + @doc(BaseSpatialIndex.nearest) + def nearest(self, *args, **kwargs): + return super().nearest(*args, **kwargs) @property + @doc(BaseSpatialIndex.size) def size(self): return len(self.leaves()[0][1]) @property + @doc(BaseSpatialIndex.is_empty) def is_empty(self): if len(self.leaves()) > 1: return False @@ -73,18 +400,14 @@ if compat.HAS_RTREE: Parameters ---------- - geometry : GeoSeries - GeoSeries from which to build the spatial index. + geometry : np.array of Shapely geometries + Geometries from which to build the spatial index. """ - # set of valid predicates for this spatial index - # by default, the global set - valid_query_predicates = VALID_QUERY_PREDICATES - def __init__(self, geometry): stream = ( - (i, item.bounds, idx) - for i, (idx, item) in enumerate(geometry.iteritems()) + (i, item.bounds, None) + for i, item in enumerate(geometry) if pd.notnull(item) and not item.is_empty ) try: @@ -97,40 +420,29 @@ if compat.HAS_RTREE: super().__init__() # store reference to geometries for predicate queries - self.geometries = geometry.geometry.values + self.geometries = geometry # create a prepared geometry cache self._prepared_geometries = np.array( [None] * self.geometries.size, dtype=object ) + @property + @doc(BaseSpatialIndex.valid_query_predicates) + def valid_query_predicates(self): + return { + None, + "intersects", + "within", + "contains", + "overlaps", + "crosses", + "touches", + "covers", + "contains_properly", + } + + @doc(BaseSpatialIndex.query) def query(self, geometry, predicate=None, sort=False): - """Compatibility layer for pygeos.query. - - This is not a vectorized function, if speed is important, - please use PyGEOS. - - Parameters - ---------- - geometry : shapely geometry - A single shapely geometry to query against the spatial index. - predicate : {None, 'intersects', 'within', 'contains', \ -'overlaps', 'crosses', 'touches'}, optional - If predicate is provided, the input geometry is - tested using the predicate function against each item - in the tree whose extent intersects the envelope of the - input geometry: predicate(input_geometry, tree_geometry). - If possible, prepared geometries are used to help - speed up the predicate operation. - sort : bool, default False - If True, the results will be sorted in ascending order. - If False, results are often sorted but there is no guarantee. - - Returns - ------- - matches : ndarray of shape (n_results, ) - Integer indices for matching geometries from the spatial index. - """ - # handle invalid predicates if predicate not in self.valid_query_predicates: raise ValueError( @@ -141,7 +453,7 @@ if compat.HAS_RTREE: # handle empty / invalid geometries if geometry is None: - # return an empty integer array, similar to pygeys.STRtree.query. + # return an empty integer array, similar to pygeos.STRtree.query. return np.array([], dtype=np.intp) if not isinstance(geometry, BaseGeometry): @@ -157,7 +469,7 @@ if compat.HAS_RTREE: # query tree bounds = geometry.bounds # rtree operates on bounds - tree_idx = list(self.intersection(bounds, objects=False)) + tree_idx = list(self.intersection(bounds)) if not tree_idx: return np.array([], dtype=np.intp) @@ -187,7 +499,12 @@ if compat.HAS_RTREE: elif predicate is not None: # For the remaining predicates, # we compare input_geom.predicate(tree_geom) - if predicate in ("contains", "intersects"): + if predicate in ( + "contains", + "intersects", + "covers", + "contains_properly", + ): # prepare this input geometry geometry = prep(geometry) tree_idx = [ @@ -204,36 +521,8 @@ if compat.HAS_RTREE: # unsorted return np.array(tree_idx, dtype=np.intp) + @doc(BaseSpatialIndex.query_bulk) def query_bulk(self, geometry, predicate=None, sort=False): - """Compatibility layer for pygeos.query_bulk. - - Iterates over `geometry` and queries index. - This operation is not vectorized and may be slow. - Use PyGEOS with `query_bulk` for speed. - - Parameters - ---------- - geometry : {GeoSeries, GeometryArray, numpy.array of PyGEOS geometries} - Accepts GeoPandas geometry iterables (GeoSeries, GeometryArray) - or a numpy array of PyGEOS geometries. - predicate : {None, 'intersects', 'within', 'contains', 'overlaps', \ -'crosses', 'touches'}, optional - If predicate is provided, the input geometries are tested using - the predicate function against each item in the tree whose extent - intersects the envelope of the each input geometry: - predicate(input_geometry, tree_geometry). If possible, prepared - geometries are used to help speed up the predicate operation. - sort : bool, default False - If True, results sorted lexicographically using - geometry's indexes as the primary key and the sindex's indexes as the - secondary key. If False, no additional sorting is applied. - - Returns - ------- - ndarray with shape (2, n) - The first subarray contains input geometry integer indexes. - The second subarray contains tree geometry integer indexes. - """ # Iterates over geometry, applying func. tree_index = [] input_geometry_index = [] @@ -244,34 +533,93 @@ if compat.HAS_RTREE: input_geometry_index.extend([i] * len(res)) return np.vstack([input_geometry_index, tree_index]) - def intersection(self, coordinates, objects=False): - """Find tree geometries that intersect the input coordinates. + def nearest(self, coordinates, num_results=1, objects=False): + """ + Returns the nearest object or objects to the given coordinates. + + Requires rtree, and passes parameters directly to + :meth:`rtree.index.Index.nearest`. + + This behaviour is deprecated and will be updated to be consistent + with the pygeos PyGEOSSTRTreeIndex in a future release. + + If longer-term compatibility is required, use + :meth:`rtree.index.Index.nearest` directly instead. + + Examples + -------- + >>> s = geopandas.GeoSeries(geopandas.points_from_xy(range(3), range(3))) + >>> s + 0 POINT (0.00000 0.00000) + 1 POINT (1.00000 1.00000) + 2 POINT (2.00000 2.00000) + dtype: geometry + + >>> list(s.sindex.nearest((0, 0))) # doctest: +SKIP + [0] + + >>> list(s.sindex.nearest((0.5, 0.5))) # doctest: +SKIP + [0, 1] + + >>> list(s.sindex.nearest((3, 3), num_results=2)) # doctest: +SKIP + [2, 1] + + >>> list(super(type(s.sindex), s.sindex).nearest((0, 0), + ... num_results=2)) # doctest: +SKIP + [0, 1] Parameters ---------- coordinates : sequence or array - Sequence of the form (min_x, min_y, max_x, max_y) - to query a rectangle or (x, y) to query a point. - objects : boolean, default False - If True, return the label based indexes. If False, integer indexes - are returned. + This may be an object that satisfies the numpy array protocol, + providing the index’s dimension * 2 coordinate pairs + representing the mink and maxk coordinates in each dimension + defining the bounds of the query window. + num_results : integer + The number of results to return nearest to the given + coordinates. If two index entries are equidistant, both are + returned. This property means that num_results may return more + items than specified + objects : True / False / ‘raw’ + If True, the nearest method will return index objects that were + pickled when they were stored with each index entry, as well as + the id and bounds of the index entries. If ‘raw’, it will + return the object as entered into the database without the + rtree.index.Item wrapper. """ - if objects: - warn( - "`objects` is deprecated and will be removed in a future version. " - "Instead, use `iloc` to index your GeoSeries/GeoDataFrame using " - "integer indexes returned by `intersection`.", - FutureWarning, - ) - return super().intersection(coordinates, objects) + warnings.warn( + "sindex.nearest using the rtree backend was not previously documented " + "and this behavior is deprecated in favor of matching the function " + "signature provided by the pygeos backend (see " + "PyGEOSSTRTreeIndex.nearest for details). This behavior will be " + "updated in a future release.", + FutureWarning, + ) + return super().nearest( + coordinates, num_results=num_results, objects=objects + ) + + @doc(BaseSpatialIndex.intersection) + def intersection(self, coordinates): + return super().intersection(coordinates, objects=False) @property + @doc(BaseSpatialIndex.size) def size(self): - return len(self.leaves()[0][1]) + if hasattr(self, "_size"): + size = self._size + else: + # self.leaves are lists of tuples of (int, lists...) + # index [0][1] always has an element, even for empty sindex + # for an empty index, it will be an empty list + size = len(self.leaves()[0][1]) + self._size = size + return size @property + @doc(BaseSpatialIndex.is_empty) def is_empty(self): - return self.size == 0 + return self.geometries.size == 0 or self.size == 0 def __len__(self): return self.size @@ -280,69 +628,54 @@ if compat.HAS_RTREE: if compat.HAS_PYGEOS: from . import geoseries # noqa - from .array import GeometryArray, _shapely_to_geom # noqa + from . import array # noqa import pygeos # noqa - class PyGEOSSTRTreeIndex(pygeos.STRtree): + _PYGEOS_PREDICATES = {p.name for p in pygeos.strtree.BinaryPredicate} | set([None]) + + class PyGEOSSTRTreeIndex(BaseSpatialIndex): """A simple wrapper around pygeos's STRTree. Parameters ---------- - geometry : GeoSeries - GeoSeries from which to build the spatial index. + geometry : np.array of PyGEOS geometries + Geometries from which to build the spatial index. """ - # helper for loc/label based indexing in `intersection` method - with_objects = namedtuple("with_objects", "object id") - - # set of valid predicates for this spatial index - # by default, the global set - valid_query_predicates = VALID_QUERY_PREDICATES - def __init__(self, geometry): - # for compatibility with old RTree implementation, store ids/indexes - original_indexes = geometry.index # set empty geometries to None to avoid segfault on GEOS <= 3.6 # see: # https://github.com/pygeos/pygeos/issues/146 # https://github.com/pygeos/pygeos/issues/147 - non_empty = geometry.values.data.copy() + non_empty = geometry.copy() non_empty[pygeos.is_empty(non_empty)] = None - # set empty geometries to None to mantain indexing - self.objects = self.ids = original_indexes - super().__init__(non_empty) + # set empty geometries to None to maintain indexing + self._tree = pygeos.STRtree(non_empty) # store geometries, including empty geometries for user access - self.geometries = geometry.values.data.copy() + self.geometries = geometry.copy() - def query(self, geometry, predicate=None, sort=False): - """Wrapper for pygeos.query. - - This also ensures a deterministic (sorted) order for the results. - - Parameters - ---------- - geometry : single PyGEOS geometry - predicate : {None, 'intersects', 'within', 'contains', \ -'overlaps', 'crosses', 'touches'}, optional - If predicate is provided, the input geometry is tested - using the predicate function against each item in the - tree whose extent intersects the envelope of the input - geometry: predicate(input_geometry, tree_geometry). - sort : bool, default False - If True, the results will be sorted in ascending order. - If False, results are often sorted but there is no guarantee. + @property + def valid_query_predicates(self): + """Returns valid predicates for the used spatial index. Returns ------- - matches : ndarray of shape (n_results, ) - Integer indices for matching geometries from the spatial index. + set + Set of valid predicates for this spatial index. - See also + Examples -------- - See PyGEOS.strtree documentation for more information. + >>> from shapely.geometry import Point + >>> s = geopandas.GeoSeries([Point(0, 0), Point(1, 1)]) + >>> s.sindex.valid_query_predicates # doctest: +SKIP + {'contains', 'crosses', 'covered_by', None, 'intersects', 'within', \ +'touches', 'overlaps', 'contains_properly', 'covers'} """ + return _PYGEOS_PREDICATES + @doc(BaseSpatialIndex.query) + def query(self, geometry, predicate=None, sort=False): if predicate not in self.valid_query_predicates: raise ValueError( "Got `predicate` = `{}`; ".format(predicate) @@ -352,62 +685,62 @@ if compat.HAS_PYGEOS: ) if isinstance(geometry, BaseGeometry): - geometry = _shapely_to_geom(geometry) + geometry = array._shapely_to_geom(geometry) - matches = super().query(geometry=geometry, predicate=predicate) + matches = self._tree.query(geometry=geometry, predicate=predicate) if sort: return np.sort(matches) return matches - def query_bulk(self, geometry, predicate=None, sort=False): - """Wrapper to expose underlaying pygeos objects to pygeos.query_bulk. - - This also allows a deterministic (sorted) order for the results. - + @staticmethod + def _as_geometry_array(geometry): + """Convert geometry into a numpy array of PyGEOS geometries. Parameters ---------- - geometry : {GeoSeries, GeometryArray, numpy.array of PyGEOS geometries} - Accepts GeoPandas geometry iterables (GeoSeries, GeometryArray) - or a numpy array of PyGEOS geometries. - predicate : {None, 'intersects', 'within', 'contains', \ -'overlaps', 'crosses', 'touches'}, optional - If predicate is provided, the input geometry is tested - using the predicate function against each item in the - index whose extent intersects the envelope of the input geometry: - predicate(input_geometry, tree_geometry). - sort : bool, default False - If True, results sorted lexicographically using - geometry's indexes as the primary key and the sindex's indexes as the - secondary key. If False, no additional sorting is applied. + geometry + An array-like of PyGEOS geometries, a GeoPandas GeoSeries/GeometryArray, + shapely.geometry or list of shapely geometries. Returns ------- - ndarray with shape (2, n) - The first subarray contains input geometry integer indexes. - The second subarray contains tree geometry integer indexes. - - See also - -------- - See PyGEOS.strtree documentation for more information. + np.ndarray + A numpy array of pygeos geometries. """ + if isinstance(geometry, np.ndarray): + return geometry + elif isinstance(geometry, geoseries.GeoSeries): + return geometry.values.data + elif isinstance(geometry, array.GeometryArray): + return geometry.data + elif isinstance(geometry, BaseGeometry): + return array._shapely_to_geom(geometry) + elif isinstance(geometry, list): + return np.asarray( + [ + array._shapely_to_geom(el) + if isinstance(el, BaseGeometry) + else el + for el in geometry + ] + ) + else: + return np.asarray(geometry) + @doc(BaseSpatialIndex.query_bulk) + def query_bulk(self, geometry, predicate=None, sort=False): if predicate not in self.valid_query_predicates: raise ValueError( "Got `predicate` = `{}`, `predicate` must be one of {}".format( predicate, self.valid_query_predicates ) ) - if isinstance(geometry, geoseries.GeoSeries): - geometry = geometry.values.data - elif isinstance(geometry, GeometryArray): - geometry = geometry.data - elif not isinstance(geometry, np.ndarray): - geometry = np.asarray(geometry) - res = super().query_bulk(geometry, predicate) + geometry = self._as_geometry_array(geometry) + + res = self._tree.query_bulk(geometry, predicate) if sort: # sort by first array (geometry) and then second (tree) @@ -417,26 +750,44 @@ if compat.HAS_PYGEOS: return res - def intersection(self, coordinates, objects=False): - """Wrapper for pygeos.query that uses the RTree API. + @doc(BaseSpatialIndex.nearest) + def nearest( + self, geometry, return_all=True, max_distance=None, return_distance=False + ): + if not compat.PYGEOS_GE_010: + raise NotImplementedError("sindex.nearest requires pygeos >= 0.10") - Parameters - ---------- - coordinates : sequence or array - Sequence of the form (min_x, min_y, max_x, max_y) - to query a rectangle or (x, y) to query a point. - objects : boolean, default False - If True, return the label based indexes. If False, integer indexes - are returned. - """ - if objects: - warn( - "`objects` is deprecated and will be removed in a future version. " - "Instead, use `iloc` to index your GeoSeries/GeoDataFrame using " - "integer indexes returned by `intersection`.", - FutureWarning, - ) + geometry = self._as_geometry_array(geometry) + if not return_all and max_distance is None and not return_distance: + return self._tree.nearest(geometry) + + result = self._tree.nearest_all( + geometry, max_distance=max_distance, return_distance=return_distance + ) + if return_distance: + indices, distances = result + else: + indices = result + + if not return_all: + # first subarray of geometry indices is sorted, so we can use this + # trick to get the first of each index value + mask = np.diff(indices[0, :]).astype("bool") + # always select the first element + mask = np.insert(mask, 0, True) + + indices = indices[:, mask] + if return_distance: + distances = distances[mask] + + if return_distance: + return indices, distances + else: + return indices + + @doc(BaseSpatialIndex.intersection) + def intersection(self, coordinates): # convert bounds to geometry # the old API uses tuples of bound, but pygeos uses geometries try: @@ -453,9 +804,9 @@ if compat.HAS_PYGEOS: # need to convert tuple of bounds to a geometry object if len(coordinates) == 4: - indexes = super().query(pygeos.box(*coordinates)) + indexes = self._tree.query(pygeos.box(*coordinates)) elif len(coordinates) == 2: - indexes = super().query(pygeos.points(*coordinates)) + indexes = self._tree.query(pygeos.points(*coordinates)) else: raise TypeError( "Invalid coordinates, must be iterable in format " @@ -463,19 +814,17 @@ if compat.HAS_PYGEOS: "Got `coordinates` = {}.".format(coordinates) ) - if objects: - objs = self.objects[indexes].values - ids = self.ids[indexes] - return [ - self.with_objects(id=id, object=obj) for id, obj in zip(ids, objs) - ] - else: - return indexes + return indexes @property + @doc(BaseSpatialIndex.size) def size(self): - return len(self) + return len(self._tree) @property + @doc(BaseSpatialIndex.is_empty) def is_empty(self): - return len(self) == 0 + return len(self._tree) == 0 + + def __len__(self): + return len(self._tree) diff --git a/geopandas/testing.py b/geopandas/testing.py index 142d475..72ba71d 100644 --- a/geopandas/testing.py +++ b/geopandas/testing.py @@ -7,16 +7,48 @@ import pandas as pd from geopandas import GeoDataFrame, GeoSeries from geopandas.array import GeometryDtype +from geopandas import _vectorized def _isna(this): """isna version that works for both scalars and (Geo)Series""" - if hasattr(this, "isna"): - return this.isna() - elif hasattr(this, "isnull"): - return this.isnull() - else: - return pd.isnull(this) + with warnings.catch_warnings(): + # GeoSeries.isna will raise a warning about no longer returning True + # for empty geometries. This helper is used below always in combination + # with an is_empty check to preserve behaviour, and thus we ignore the + # warning here to avoid it bubbling up to the user + warnings.filterwarnings( + "ignore", r"GeoSeries.isna\(\) previously returned", UserWarning + ) + if hasattr(this, "isna"): + return this.isna() + elif hasattr(this, "isnull"): + return this.isnull() + else: + return pd.isnull(this) + + +def _geom_equals_mask(this, that): + """ + Test for geometric equality. Empty or missing geometries are considered + equal. + + Parameters + ---------- + this, that : arrays of Geo objects (or anything that has an `is_empty` + attribute) + + Returns + ------- + Series + boolean Series, True if geometries in left equal geometries in right + """ + + return ( + this.geom_equals(that) + | (this.is_empty & that.is_empty) + | (_isna(this) & _isna(that)) + ) def geom_equals(this, that): @@ -28,13 +60,40 @@ def geom_equals(this, that): ---------- this, that : arrays of Geo objects (or anything that has an `is_empty` attribute) + + Returns + ------- + bool + True if all geometries in left equal geometries in right + """ + + return _geom_equals_mask(this, that).all() + + +def _geom_almost_equals_mask(this, that): + """ + Test for 'almost' geometric equality. Empty or missing geometries + considered equal. + + This method allows small difference in the coordinates, but this + requires coordinates be in the same order for all components of a geometry. + + Parameters + ---------- + this, that : arrays of Geo objects (or anything that has an `is_empty` + property) + + Returns + ------- + Series + boolean Series, True if geometries in left almost equal geometries in right """ return ( - this.geom_equals(that) + this.geom_almost_equals(that) | (this.is_empty & that.is_empty) | (_isna(this) & _isna(that)) - ).all() + ) def geom_almost_equals(this, that): @@ -49,13 +108,14 @@ def geom_almost_equals(this, that): ---------- this, that : arrays of Geo objects (or anything that has an `is_empty` property) + + Returns + ------- + bool + True if all geometries in left almost equal geometries in right """ - return ( - this.geom_almost_equals(that) - | (this.is_empty & that.is_empty) - | (_isna(this) & _isna(that)) - ).all() + return _geom_almost_equals_mask(this, that).all() def assert_geoseries_equal( @@ -67,6 +127,7 @@ def assert_geoseries_equal( check_less_precise=False, check_geom_type=False, check_crs=True, + normalize=False, ): """ Test util for checking that two GeoSeries are equal. @@ -89,6 +150,10 @@ def assert_geoseries_equal( check_crs: bool, default True If `check_series_type` is True, then also check that the crs matches. + normalize: bool, default False + If True, normalize the geometries before comparing equality. + Typically useful with ``check_less_precise=True``, which uses + ``geom_almost_equals`` and requires exact coordinate order. """ assert len(left) == len(right), "%d != %d" % (len(left), len(right)) @@ -120,18 +185,55 @@ def assert_geoseries_equal( right.type, ) + if normalize: + left = GeoSeries(_vectorized.normalize(left.array.data)) + right = GeoSeries(_vectorized.normalize(right.array.data)) + if not check_crs: with warnings.catch_warnings(): warnings.filterwarnings("ignore", "CRS mismatch", UserWarning) - if check_less_precise: - assert geom_almost_equals(left, right) - else: - assert geom_equals(left, right) + _check_equality(left, right, check_less_precise) else: - if check_less_precise: - assert geom_almost_equals(left, right) - else: - assert geom_equals(left, right) + _check_equality(left, right, check_less_precise) + + +def _truncated_string(geom): + """Truncated WKT repr of geom""" + s = str(geom) + if len(s) > 100: + return s[:100] + "..." + else: + return s + + +def _check_equality(left, right, check_less_precise): + assert_error_message = ( + "{0} out of {1} geometries are not {3}equal.\n" + "Indices where geometries are not {3}equal: {2} \n" + "The first not {3}equal geometry:\n" + "Left: {4}\n" + "Right: {5}\n" + ) + if check_less_precise: + precise = "almost " + equal = _geom_almost_equals_mask(left, right) + else: + precise = "" + equal = _geom_equals_mask(left, right) + + if not equal.all(): + unequal_left_geoms = left[~equal] + unequal_right_geoms = right[~equal] + raise AssertionError( + assert_error_message.format( + len(unequal_left_geoms), + len(left), + unequal_left_geoms.index.to_list(), + precise, + _truncated_string(unequal_left_geoms.iloc[0]), + _truncated_string(unequal_right_geoms.iloc[0]), + ) + ) def assert_geodataframe_equal( @@ -145,6 +247,7 @@ def assert_geodataframe_equal( check_less_precise=False, check_geom_type=False, check_crs=True, + normalize=False, ): """ Check that two GeoDataFrames are equal/ @@ -168,6 +271,10 @@ def assert_geodataframe_equal( check_crs: bool, default True If `check_frame_type` is True, then also check that the crs matches. + normalize: bool, default False + If True, normalize the geometries before comparing equality. + Typically useful with ``check_less_precise=True``, which uses + ``geom_almost_equals`` and requires exact coordinate order. """ try: # added from pandas 0.20 @@ -195,12 +302,9 @@ def assert_geodataframe_equal( # shape comparison assert left.shape == right.shape, ( "GeoDataFrame shape mismatch, left: {lshape!r}, right: {rshape!r}.\n" - "Left columns: {lcols!r}, right columns: {rcols!r}".format( - lshape=left.shape, - rshape=right.shape, - lcols=left.columns, - rcols=right.columns, - ) + "Left columns: {lcols!r}, right columns: {rcols!r}" + ).format( + lshape=left.shape, rshape=right.shape, lcols=left.columns, rcols=right.columns ) if check_like: @@ -212,11 +316,12 @@ def assert_geodataframe_equal( ) # geometry comparison - for col, dtype in left.dtypes.iteritems(): + for col, dtype in left.dtypes.items(): if isinstance(dtype, GeometryDtype): assert_geoseries_equal( left[col], right[col], + normalize=normalize, check_dtype=check_dtype, check_less_precise=check_less_precise, check_geom_type=check_geom_type, diff --git a/examples/null_geom.geojson b/geopandas/tests/data/null_geom.geojson similarity index 100% rename from examples/null_geom.geojson rename to geopandas/tests/data/null_geom.geojson diff --git a/geopandas/tests/data/overlay/geom_type/df1.geojson b/geopandas/tests/data/overlay/geom_type/df1.geojson new file mode 100644 index 0000000..50d1206 --- /dev/null +++ b/geopandas/tests/data/overlay/geom_type/df1.geojson @@ -0,0 +1 @@ +{"type": "FeatureCollection", "features": [{"id": "9", "type": "Feature", "properties": {"acres": 4.96074455173779, "idx": 9, "value": 2}, "geometry": {"type": "Polygon", "coordinates": [[[-95.58937565036604, 60.755964062925905], [-95.58937565036604, 60.75598209180554], [-95.58936454178152, 60.75598209180555], [-95.58936454178152, 60.75599110624536], [-95.58935343319699, 60.75599110624537], [-95.58934232461245, 60.75599110624537], [-95.58934232461245, 60.75600012068519], [-95.58933121602794, 60.75600012068519], [-95.58933121602794, 60.756009135125026], [-95.5893201074434, 60.75600913512501], [-95.5893201074434, 60.75601814956483], [-95.58930899885887, 60.75601814956484], [-95.58929789027435, 60.75601814956484], [-95.58929789027435, 60.756027164004664], [-95.58928678168982, 60.756027164004664], [-95.58927567310528, 60.756027164004664], [-95.58927567310528, 60.75603617844449], [-95.58926456452075, 60.75603617844449], [-95.58926456452075, 60.756045192884315], [-95.5892534559362, 60.75604519288431], [-95.5892423473517, 60.7560451928843], [-95.5892423473517, 60.75605420732413], [-95.58923123876716, 60.75605420732413], [-95.58923123876716, 60.75607223620378], [-95.58922013018262, 60.75607223620377], [-95.58922013018262, 60.7560812506436], [-95.58920902159808, 60.7560812506436], [-95.58920902159808, 60.756099279523234], [-95.58919791301358, 60.756099279523234], [-95.58919791301358, 60.756117308402885], [-95.58918680442903, 60.756117308402885], [-95.58918680442903, 60.75612632284271], [-95.5891756958445, 60.75612632284271], [-95.5891756958445, 60.75614435172235], [-95.58916458725996, 60.756144351722334], [-95.58916458725996, 60.756162380602], [-95.58915347867546, 60.756162380602], [-95.58915347867546, 60.75617139504182], [-95.58914237009091, 60.75617139504182], [-95.58914237009091, 60.75618942392147], [-95.58913126150641, 60.75618942392147], [-95.58913126150641, 60.75621646724094], [-95.58912015292186, 60.75621646724094], [-95.58912015292186, 60.75625252500023], [-95.58910904433733, 60.75625252500023], [-95.58910904433733, 60.756279568319705], [-95.58909793575279, 60.756279568319705], [-95.58909793575279, 60.756288582759524], [-95.58908682716829, 60.75628858275951], [-95.58908682716829, 60.756306611639175], [-95.58907571858374, 60.75630661163917], [-95.58907571858374, 60.75632464051881], [-95.58906460999921, 60.75632464051881], [-95.58906460999921, 60.75633365495864], [-95.58905350141468, 60.75633365495864], [-95.58905350141468, 60.756351683838275], [-95.58904239283017, 60.756351683838275], [-95.58904239283017, 60.75636971271793], [-95.58903128424562, 60.75636971271793], [-95.58903128424562, 60.756387741597564], [-95.58902017566109, 60.75638774159757], [-95.58902017566109, 60.75639675603739], [-95.58900906707656, 60.7563967560374], [-95.58900906707656, 60.756414784917034], [-95.58899795849204, 60.756414784917034], [-95.58899795849204, 60.75643281379669], [-95.58898684990751, 60.7564328137967], [-95.58898684990751, 60.756441828236504], [-95.58897574132297, 60.75644182823651], [-95.58897574132297, 60.75645985711615], [-95.58896463273845, 60.75645985711616], [-95.58896463273845, 60.75648690043562], [-95.58895352415392, 60.75648690043561], [-95.58895352415392, 60.75679339138959], [-95.58894241556939, 60.756793391389586], [-95.58894241556939, 60.75682043470906], [-95.58893130698488, 60.756820434709056], [-95.58893130698488, 60.756829449148874], [-95.58892019840034, 60.756829449148874], [-95.58892019840034, 60.75684747802852], [-95.5889090898158, 60.756847478028526], [-95.5889090898158, 60.75686550690818], [-95.58889798123127, 60.75686550690817], [-95.58889798123127, 60.756874521348], [-95.58888687264673, 60.75687452134798], [-95.58888687264673, 60.75689255022763], [-95.58887576406222, 60.75689255022763], [-95.58887576406222, 60.75691057910728], [-95.58886465547768, 60.756910579107284], [-95.58886465547768, 60.75692860798693], [-95.58885354689315, 60.75692860798692], [-95.58885354689315, 60.756937622426754], [-95.5888424383086, 60.75693762242674], [-95.5888424383086, 60.7569556513064], [-95.5888313297241, 60.756955651306406], [-95.5888313297241, 60.75697368018604], [-95.58882022113956, 60.75697368018604], [-95.58882022113956, 60.756982694625854], [-95.58880911255503, 60.756982694625854], [-95.58880911255503, 60.75700072350551], [-95.58879800397048, 60.75700072350551], [-95.58879800397048, 60.75702776682498], [-95.58878689538598, 60.75702776682499], [-95.58878689538598, 60.757063824584264], [-95.58877578680143, 60.75706382458427], [-95.58877578680143, 60.75707283902409], [-95.58876467821693, 60.7570728390241], [-95.58876467821693, 60.7570818534639], [-95.58875356963239, 60.757081853463916], [-95.58875356963239, 60.75709086790375], [-95.58874246104786, 60.75709086790374], [-95.58873135246331, 60.757090867903734], [-95.58873135246331, 60.75709988234357], [-95.58870913529427, 60.75709988234356], [-95.58869802670974, 60.75709988234356], [-95.58869802670974, 60.75710889678338], [-95.58845363785008, 60.757108896783386], [-95.58844252926555, 60.75710889678338], [-95.58844252926555, 60.757117911223204], [-95.58843142068103, 60.75711791122322], [-95.5884203120965, 60.75711791122322], [-95.5884203120965, 60.75712692566304], [-95.58840920351196, 60.75712692566302], [-95.58840920351196, 60.757135940102856], [-95.58837587775838, 60.757135940102856], [-95.58836476917384, 60.75713594010286], [-95.58836476917384, 60.757144954542674], [-95.58828700908214, 60.75714495454267], [-95.5882759004976, 60.75714495454267], [-95.5882759004976, 60.7571539689825], [-95.58820924899044, 60.7571539689825], [-95.58820924899044, 60.757144954542674], [-95.58819814040592, 60.75714495454267], [-95.58819814040592, 60.757135940102856], [-95.58818703182139, 60.757135940102856], [-95.58818703182139, 60.75712692566304], [-95.58817592323685, 60.75712692566303], [-95.58817592323685, 60.757117911223204], [-95.58816481465232, 60.75711791122322], [-95.58816481465232, 60.75710889678338], [-95.58815370606777, 60.75710889678338], [-95.58815370606777, 60.75709086790374], [-95.58814259748327, 60.75709086790374], [-95.58814259748327, 60.757072839024104], [-95.58813148889872, 60.7570728390241], [-95.58813148889872, 60.75705481014444], [-95.5881203803142, 60.75705481014444], [-95.5881203803142, 60.75660408815332], [-95.58810927172965, 60.75660408815332], [-95.58810927172965, 60.75658605927365], [-95.58809816314515, 60.756586059273666], [-95.58809816314515, 60.75656803039402], [-95.5880870545606, 60.75656803039402], [-95.5880870545606, 60.7565590159542], [-95.58807594597607, 60.75655901595421], [-95.58807594597607, 60.75655000151438], [-95.58806483739156, 60.75655000151438], [-95.58806483739156, 60.756540987074565], [-95.58805372880703, 60.75654098707455], [-95.58805372880703, 60.75653197263474], [-95.58804262022248, 60.75653197263473], [-95.58804262022248, 60.75652295819491], [-95.58802040305343, 60.75652295819491], [-95.58802040305343, 60.75651394375508], [-95.58799818588436, 60.75651394375509], [-95.58799818588436, 60.75650492931526], [-95.58797596871531, 60.75650492931526], [-95.58797596871531, 60.756495914875444], [-95.58792042579266, 60.75649591487544], [-95.58792042579266, 60.75648690043562], [-95.58789820862361, 60.75648690043561], [-95.58789820862361, 60.75647788599579], [-95.58787599145457, 60.75647788599579], [-95.58787599145457, 60.75646887155597], [-95.58786488287002, 60.75646887155597], [-95.58786488287002, 60.756459857116155], [-95.58784266570096, 60.75645985711616], [-95.58784266570096, 60.75645084267633], [-95.58782044853191, 60.75645084267634], [-95.58782044853191, 60.75644182823651], [-95.58780933994737, 60.75644182823651], [-95.58780933994737, 60.75643281379668], [-95.5877871227783, 60.756432813796685], [-95.5877871227783, 60.75642379935685], [-95.58776490560925, 60.75642379935686], [-95.58776490560925, 60.75641478491704], [-95.58775379702472, 60.756414784917034], [-95.58775379702472, 60.756405770477215], [-95.58774268844017, 60.75640577047721], [-95.58774268844017, 60.75639675603739], [-95.58773157985567, 60.75639675603738], [-95.58773157985567, 60.75638774159756], [-95.58772047127113, 60.75638774159757], [-95.58772047127113, 60.756378727157745], [-95.58770936268662, 60.756378727157745], [-95.58770936268662, 60.756360698278094], [-95.58769825410208, 60.756360698278094], [-95.58769825410208, 60.75634266939846], [-95.58768714551755, 60.75634266939845], [-95.58768714551755, 60.7563246405188], [-95.587676036933, 60.756324640518805], [-95.587676036933, 60.75631562607899], [-95.5876649283485, 60.75631562607898], [-95.5876649283485, 60.756297597199335], [-95.58765381976396, 60.75629759719934], [-95.58765381976396, 60.7562795683197], [-95.58764271117943, 60.7562795683197], [-95.58764271117943, 60.756261539440054], [-95.58763160259488, 60.75626153944006], [-95.58763160259488, 60.75624351056042], [-95.58762049401038, 60.75624351056042], [-95.58762049401038, 60.7558108174489], [-95.58763160259488, 60.755810817448925], [-95.58763160259488, 60.75578377412945], [-95.58764271117943, 60.755783774129455], [-95.58764271117943, 60.755765745249796], [-95.58765381976396, 60.75576574524981], [-95.58765381976396, 60.75575673080998], [-95.5876649283485, 60.755756730809985], [-95.5876649283485, 60.75574771637016], [-95.587676036933, 60.75574771637016], [-95.587676036933, 60.755729687490515], [-95.58768714551755, 60.755729687490515], [-95.58769825410208, 60.755729687490515], [-95.58769825410208, 60.755720673050696], [-95.58770936268662, 60.75572067305069], [-95.58770936268662, 60.75571165861086], [-95.58772047127113, 60.755711658610856], [-95.58772047127113, 60.75570264417103], [-95.58773157985567, 60.755702644171045], [-95.58774268844017, 60.75570264417104], [-95.58774268844017, 60.75569362973122], [-95.58775379702472, 60.75569362973121], [-95.58777601419379, 60.75569362973122], [-95.58777601419379, 60.75568461529139], [-95.58780933994737, 60.75568461529141], [-95.58780933994737, 60.75569362973122], [-95.58783155711644, 60.75569362973123], [-95.58783155711644, 60.75570264417104], [-95.58785377428549, 60.755702644171045], [-95.58785377428549, 60.75571165861086], [-95.58787599145457, 60.75571165861086], [-95.58787599145457, 60.75572067305069], [-95.58789820862361, 60.75572067305069], [-95.58789820862361, 60.75572968749052], [-95.58790931720813, 60.75572968749053], [-95.58790931720813, 60.75573870193034], [-95.58793153437719, 60.75573870193034], [-95.58793153437719, 60.75574771637016], [-95.58795375154625, 60.755747716370166], [-95.58795375154625, 60.75575673080996], [-95.58797596871531, 60.75575673080998], [-95.58797596871531, 60.755765745249796], [-95.58798707729986, 60.7557657452498], [-95.58798707729986, 60.75577475968964], [-95.5880092944689, 60.755774759689636], [-95.5880092944689, 60.75578377412945], [-95.58803151163798, 60.75578377412945], [-95.58803151163798, 60.75579278856928], [-95.58804262022248, 60.75579278856928], [-95.58804262022248, 60.75580180300909], [-95.58806483739156, 60.755801803009085], [-95.58806483739156, 60.755810817448925], [-95.5880870545606, 60.75581081744891], [-95.5880870545606, 60.75581983188873], [-95.58832033483573, 60.75581983188873], [-95.58832033483573, 60.75581081744892], [-95.58833144342026, 60.75581081744891], [-95.58833144342026, 60.75580180300909], [-95.58834255200479, 60.75580180300909], [-95.58834255200479, 60.75579278856928], [-95.58835366058933, 60.75579278856927], [-95.58835366058933, 60.75576574524981], [-95.58836476917384, 60.7557657452498], [-95.58836476917384, 60.75573870193034], [-95.58837587775838, 60.75573870193033], [-95.58837587775838, 60.75568461529141], [-95.58836476917384, 60.75568461529141], [-95.58836476917384, 60.755666586411756], [-95.58835366058933, 60.75566658641174], [-95.58835366058933, 60.75565757197193], [-95.58834255200479, 60.75565757197194], [-95.58834255200479, 60.755648557532105], [-95.58833144342026, 60.7556485575321], [-95.58833144342026, 60.755639543092286], [-95.58832033483573, 60.755639543092286], [-95.58832033483573, 60.75563052865246], [-95.58830922625121, 60.75563052865246], [-95.58830922625121, 60.755621514212635], [-95.58828700908214, 60.75562151421264], [-95.58828700908214, 60.75561249977282], [-95.58826479191309, 60.75561249977282], [-95.58826479191309, 60.755603485333], [-95.58825368332856, 60.755603485333], [-95.58825368332856, 60.75559447089318], [-95.58824257474404, 60.75559447089316], [-95.58824257474404, 60.75558545645335], [-95.5882314661595, 60.755585456453346], [-95.5882314661595, 60.75557644201353], [-95.58822035757497, 60.75557644201353], [-95.58822035757497, 60.75556742757371], [-95.58820924899044, 60.75556742757369], [-95.58820924899044, 60.75554939869405], [-95.58819814040592, 60.75554939869406], [-95.58819814040592, 60.75553136981441], [-95.58818703182139, 60.75553136981442], [-95.58818703182139, 60.75551334093476], [-95.58817592323685, 60.755513340934776], [-95.58817592323685, 60.75550432649495], [-95.58816481465232, 60.75550432649495], [-95.58816481465232, 60.7554862976153], [-95.58815370606777, 60.75548629761529], [-95.58815370606777, 60.75546826873566], [-95.58814259748327, 60.75546826873565], [-95.58814259748327, 60.75545023985601], [-95.58813148889872, 60.755450239855996], [-95.58813148889872, 60.755432210976366], [-95.5881203803142, 60.755432210976366], [-95.5881203803142, 60.755260936619734], [-95.58813148889872, 60.75526093661973], [-95.58813148889872, 60.755233893300264], [-95.58814259748327, 60.75523389330026], [-95.58814259748327, 60.75521586442062], [-95.58815370606777, 60.75521586442063], [-95.58815370606777, 60.755206849980794], [-95.58816481465232, 60.755206849980794], [-95.58816481465232, 60.75518882110116], [-95.58817592323685, 60.75518882110116], [-95.58817592323685, 60.75517079222149], [-95.58818703182139, 60.7551707922215], [-95.58818703182139, 60.75516177778168], [-95.58819814040592, 60.75516177778167], [-95.58819814040592, 60.755143748902036], [-95.58820924899044, 60.755143748902036], [-95.58820924899044, 60.75492740234629], [-95.58822035757497, 60.7549274023463], [-95.58822035757497, 60.754909373466646], [-95.5882314661595, 60.75490937346664], [-95.5882314661595, 60.754891344586994], [-95.58824257474404, 60.754891344587], [-95.58824257474404, 60.75488233014718], [-95.58825368332856, 60.75488233014717], [-95.58825368332856, 60.754873315707364], [-95.58826479191309, 60.75487331570736], [-95.5882759004976, 60.75487331570735], [-95.5882759004976, 60.754864301267524], [-95.58830922625121, 60.75486430126753], [-95.58830922625121, 60.75487331570735], [-95.58833144342026, 60.754873315707364], [-95.58833144342026, 60.754882330147176], [-95.58835366058933, 60.75488233014717], [-95.58835366058933, 60.754891344586994], [-95.58837587775838, 60.754891344586994], [-95.58837587775838, 60.754900359026834], [-95.58839809492746, 60.75490035902682], [-95.58839809492746, 60.754909373466646], [-95.58840920351196, 60.75490937346664], [-95.58840920351196, 60.75491838790648], [-95.58843142068103, 60.75491838790648], [-95.58843142068103, 60.7549274023463], [-95.58845363785008, 60.75492740234629], [-95.58845363785008, 60.75493641678613], [-95.58847585501913, 60.754936416786116], [-95.58847585501913, 60.754945431225934], [-95.58848696360367, 60.75494543122592], [-95.58848696360367, 60.75495444566575], [-95.5884980721882, 60.754954445665746], [-95.5884980721882, 60.754963460105586], [-95.58850918077275, 60.754963460105586], [-95.58850918077275, 60.754972474545404], [-95.58852028935725, 60.754972474545404], [-95.58852028935725, 60.75498148898524], [-95.5885313979418, 60.75498148898522], [-95.5885313979418, 60.754999517864874], [-95.58854250652632, 60.75499951786488], [-95.58854250652632, 60.75501754674452], [-95.58855361511087, 60.75501754674452], [-95.58855361511087, 60.755026561184344], [-95.5885647236954, 60.75502656118434], [-95.5885647236954, 60.75503557562417], [-95.58857583227991, 60.75503557562416], [-95.58857583227991, 60.75504459006399], [-95.58858694086445, 60.75504459006399], [-95.58858694086445, 60.755053604503814], [-95.58859804944898, 60.755053604503814], [-95.58859804944898, 60.755062618943626], [-95.58862026661804, 60.755062618943626], [-95.58862026661804, 60.75507163338346], [-95.58864248378708, 60.75507163338346], [-95.58864248378708, 60.75508064782328], [-95.58865359237161, 60.75508064782327], [-95.58865359237161, 60.75508966226311], [-95.58867580954069, 60.75508966226311], [-95.58867580954069, 60.75509867670293], [-95.58869802670974, 60.75509867670293], [-95.58869802670974, 60.75510769114275], [-95.58870913529427, 60.75510769114275], [-95.58870913529427, 60.75511670558255], [-95.58873135246331, 60.755116705582566], [-95.58873135246331, 60.755125720022384], [-95.58875356963239, 60.75512572002238], [-95.58875356963239, 60.75513473446221], [-95.58880911255503, 60.75513473446222], [-95.58880911255503, 60.755143748902036], [-95.5888313297241, 60.755143748902036], [-95.5888313297241, 60.755152763341854], [-95.58885354689315, 60.75515276334186], [-95.58885354689315, 60.755170792221506], [-95.58886465547768, 60.75517079222149], [-95.58886465547768, 60.75524290774008], [-95.58885354689315, 60.75524290774008], [-95.58885354689315, 60.75526093661973], [-95.5888424383086, 60.75526093661973], [-95.5888424383086, 60.75526995105955], [-95.5888313297241, 60.75526995105955], [-95.58882022113956, 60.755269951059546], [-95.58882022113956, 60.75527896549938], [-95.58862026661804, 60.755278965499365], [-95.58860915803352, 60.75527896549937], [-95.58860915803352, 60.7552879799392], [-95.58859804944898, 60.7552879799392], [-95.58858694086445, 60.75528797993919], [-95.58858694086445, 60.75529699437902], [-95.58857583227991, 60.755296994379016], [-95.58857583227991, 60.75530600881885], [-95.5885647236954, 60.75530600881885], [-95.5885647236954, 60.755324037698486], [-95.58855361511087, 60.75532403769849], [-95.58855361511087, 60.755351081017956], [-95.58854250652632, 60.75535108101796], [-95.58854250652632, 60.755432210976366], [-95.58855361511087, 60.755432210976366], [-95.58855361511087, 60.75544122541619], [-95.5885647236954, 60.755441225416185], [-95.5885647236954, 60.755459254295836], [-95.58857583227991, 60.755459254295836], [-95.58857583227991, 60.75547728317547], [-95.58858694086445, 60.75547728317548], [-95.58858694086445, 60.7554862976153], [-95.58859804944898, 60.755486297615285], [-95.58859804944898, 60.75550432649495], [-95.58860915803352, 60.755504326494936], [-95.58860915803352, 60.75552235537458], [-95.58862026661804, 60.75552235537459], [-95.58862026661804, 60.75556742757369], [-95.58863137520257, 60.7555674275737], [-95.58863137520257, 60.755585456453346], [-95.58864248378708, 60.75558545645334], [-95.58864248378708, 60.755603485333], [-95.58865359237161, 60.755603485333], [-95.58865359237161, 60.75562151421265], [-95.58866470095614, 60.75562151421264], [-95.58866470095614, 60.75563052865246], [-95.58867580954069, 60.75563052865245], [-95.58867580954069, 60.75563954309229], [-95.5886869181252, 60.755639543092286], [-95.5886869181252, 60.755648557532105], [-95.58869802670974, 60.755648557532105], [-95.58869802670974, 60.75565757197193], [-95.58870913529427, 60.75565757197193], [-95.58870913529427, 60.75566658641174], [-95.58873135246331, 60.75566658641175], [-95.58873135246331, 60.75567560085157], [-95.58875356963239, 60.75567560085157], [-95.58875356963239, 60.75568461529141], [-95.58895352415392, 60.755684615291415], [-95.58895352415392, 60.75569362973122], [-95.58897574132297, 60.755693629731226], [-95.58897574132297, 60.75570264417104], [-95.58898684990751, 60.755702644171045], [-95.58898684990751, 60.75571165861086], [-95.58900906707656, 60.755711658610856], [-95.58900906707656, 60.75572067305069], [-95.58903128424562, 60.755720673050696], [-95.58903128424562, 60.755729687490515], [-95.58904239283017, 60.755729687490515], [-95.58904239283017, 60.75573870193034], [-95.58906460999921, 60.75573870193034], [-95.58906460999921, 60.75574771637015], [-95.58908682716829, 60.75574771637015], [-95.58908682716829, 60.755756730809985], [-95.58909793575279, 60.75575673080998], [-95.58909793575279, 60.7557657452498], [-95.58912015292186, 60.7557657452498], [-95.58912015292186, 60.755774759689636], [-95.58913126150641, 60.75577475968963], [-95.58913126150641, 60.75578377412944], [-95.58915347867546, 60.75578377412944], [-95.58915347867546, 60.755792788569266], [-95.58916458725996, 60.75579278856928], [-95.58916458725996, 60.755801803009085], [-95.58918680442903, 60.755801803009085], [-95.58918680442903, 60.75581081744891], [-95.58920902159808, 60.75581081744892], [-95.58920902159808, 60.75581983188873], [-95.58922013018262, 60.75581983188873], [-95.58922013018262, 60.75582884632856], [-95.5892423473517, 60.75582884632856], [-95.5892423473517, 60.75583786076839], [-95.5892534559362, 60.755837860768395], [-95.5892534559362, 60.7558468752082], [-95.58927567310528, 60.75584687520821], [-95.58927567310528, 60.755855889648025], [-95.58928678168982, 60.755855889648025], [-95.58928678168982, 60.75586490408786], [-95.58930899885887, 60.75586490408785], [-95.58930899885887, 60.755873918527676], [-95.5893201074434, 60.75587391852767], [-95.5893201074434, 60.75588293296748], [-95.58934232461245, 60.755882932967474], [-95.58934232461245, 60.75589194740732], [-95.58936454178152, 60.755891947407314], [-95.58936454178152, 60.755900961847146], [-95.58937565036604, 60.755900961847146], [-95.58937565036604, 60.755964062925905]]]}}]} \ No newline at end of file diff --git a/geopandas/tests/data/overlay/geom_type/df2.geojson b/geopandas/tests/data/overlay/geom_type/df2.geojson new file mode 100644 index 0000000..f1d471c --- /dev/null +++ b/geopandas/tests/data/overlay/geom_type/df2.geojson @@ -0,0 +1 @@ +{"type": "FeatureCollection", "features": [{"id": "77", "type": "Feature", "properties": {"acres": 3.859654188573176, "idx": 77, "value": 1}, "geometry": {"type": "Polygon", "coordinates": [[[-95.58719836779824, 60.755928005166616], [-95.5871872592137, 60.7559280051666], [-95.5871872592137, 60.75552235537458], [-95.58717615062918, 60.75552235537459], [-95.58717615062918, 60.75468401247108], [-95.58716504204466, 60.75468401247108], [-95.58716504204466, 60.75448569479499], [-95.5871761506293, 60.75448569479499], [-95.5871872592137, 60.75448569479498], [-95.5871872592137, 60.754494709234805], [-95.58719836779824, 60.754494709234805], [-95.58719836779824, 60.754503723674624], [-95.58720947638278, 60.754503723674624], [-95.58720947638278, 60.75451273811445], [-95.5872205849673, 60.75451273811445], [-95.5872205849673, 60.75452175255427], [-95.58723169355183, 60.754521752554275], [-95.58723169355183, 60.75453076699409], [-95.58724280213636, 60.75453076699409], [-95.58724280213636, 60.75453978143392], [-95.5872539107209, 60.75453978143391], [-95.5872539107209, 60.75454879587373], [-95.5872650193054, 60.75454879587374], [-95.5872650193054, 60.754557810313564], [-95.58727612788995, 60.75455781031357], [-95.58727612788995, 60.7545758391932], [-95.58728723647448, 60.7545758391932], [-95.58728723647448, 60.75461189695249], [-95.58729834505903, 60.7546118969525], [-95.58729834505903, 60.75462992583214], [-95.58730945364353, 60.75462992583214], [-95.58730945364353, 60.754647954711785], [-95.58732056222807, 60.754647954711785], [-95.58732056222807, 60.75466598359144], [-95.5873316708126, 60.75466598359144], [-95.5873316708126, 60.75468401247107], [-95.58734277939715, 60.754684012471074], [-95.58734277939715, 60.7546930269109], [-95.58735388798165, 60.75469302691089], [-95.58735388798165, 60.754711055790544], [-95.5873649965662, 60.754711055790544], [-95.5873649965662, 60.75472908467019], [-95.5873761051507, 60.754729084670196], [-95.5873761051507, 60.75474711354984], [-95.58738721373524, 60.75474711354984], [-95.58738721373524, 60.75475612798965], [-95.58739832231977, 60.75475612798965], [-95.58739832231977, 60.754765142429484], [-95.58740943090432, 60.75476514242948], [-95.58740943090432, 60.7547741568693], [-95.58742053948882, 60.7547741568693], [-95.58742053948882, 60.75478317130912], [-95.58743164807336, 60.75478317130912], [-95.58743164807336, 60.75479218574895], [-95.58745386524244, 60.75479218574894], [-95.58745386524244, 60.75480120018877], [-95.58747608241148, 60.75480120018877], [-95.58747608241148, 60.75481021462859], [-95.58748719099601, 60.7548102146286], [-95.58748719099601, 60.75481922906841], [-95.58749829958055, 60.75481922906842], [-95.58749829958055, 60.75482824350824], [-95.58750940816509, 60.754828243508236], [-95.58750940816509, 60.75483725794807], [-95.5875205167496, 60.75483725794807], [-95.5875205167496, 60.75484627238787], [-95.58753162533414, 60.75484627238789], [-95.58753162533414, 60.75486430126754], [-95.58754273391865, 60.75486430126753], [-95.58754273391865, 60.754882330147176], [-95.58755384250318, 60.75488233014718], [-95.58755384250318, 60.754891344586994], [-95.58756495108771, 60.754891344587], [-95.58756495108771, 60.754900359026834], [-95.58757605967226, 60.75490035902682], [-95.58757605967226, 60.75490937346665], [-95.58758716825677, 60.754909373466646], [-95.58758716825677, 60.75491838790648], [-95.5875982768413, 60.75491838790647], [-95.5875982768413, 60.75492740234629], [-95.58762049401038, 60.75492740234629], [-95.58762049401038, 60.754936416786116], [-95.58769825410208, 60.75493641678611], [-95.58769825410208, 60.7549274023463], [-95.5877093626868, 60.75492740234629], [-95.58773157985567, 60.7549274023463], [-95.58773157985567, 60.75491838790648], [-95.5877426884403, 60.75491838790648], [-95.58775379702472, 60.75491838790647], [-95.58775379702472, 60.75490937346665], [-95.58776490560925, 60.75490937346664], [-95.58776490560925, 60.75490035902683], [-95.58777601419379, 60.75490035902683], [-95.58777601419379, 60.754891344586994], [-95.5877871227783, 60.75489134458701], [-95.5877871227783, 60.75483725794807], [-95.58777601419379, 60.75483725794806], [-95.58777601419379, 60.75481922906842], [-95.58776490560925, 60.75481922906842], [-95.58776490560925, 60.7548102146286], [-95.58775379702472, 60.7548102146286], [-95.58775379702472, 60.75479218574894], [-95.58774268844017, 60.75479218574894], [-95.58774268844017, 60.7547741568693], [-95.58773157985567, 60.75477415686929], [-95.58773157985567, 60.754756127989644], [-95.58772047127113, 60.754756127989644], [-95.58772047127113, 60.75474711354983], [-95.58770936268662, 60.75474711354984], [-95.58770936268662, 60.75472908467019], [-95.58769825410208, 60.754729084670196], [-95.58769825410208, 60.754711055790544], [-95.58768714551755, 60.754711055790544], [-95.58768714551755, 60.7546930269109], [-95.587676036933, 60.7546930269109], [-95.587676036933, 60.75468401247108], [-95.5876649283485, 60.75468401247108], [-95.5876649283485, 60.75466598359144], [-95.58765381976396, 60.754665983591444], [-95.58765381976396, 60.75464795471179], [-95.58764271117943, 60.754647954711785], [-95.58764271117943, 60.75462992583215], [-95.58763160259488, 60.75462992583214], [-95.58763160259488, 60.7546118969525], [-95.58762049401038, 60.75461189695249], [-95.58762049401038, 60.75458485363303], [-95.58763160259488, 60.754584853633034], [-95.58763160259488, 60.75455781031358], [-95.58764271117943, 60.754557810313564], [-95.58764271117943, 60.75453978143393], [-95.58765381976396, 60.75453978143392], [-95.58765381976396, 60.75453076699409], [-95.5876649283485, 60.75453076699409], [-95.5876649283485, 60.75451273811445], [-95.587676036933, 60.754512738114435], [-95.587676036933, 60.7544947092348], [-95.58768714551755, 60.7544947092348], [-95.58768714551755, 60.75448569479498], [-95.58769825410208, 60.75448569479499], [-95.58769825410208, 60.75446766591533], [-95.58770936268662, 60.75446766591532], [-95.58770936268662, 60.75444963703569], [-95.58772047127113, 60.75444963703569], [-95.58772047127113, 60.75444062259586], [-95.58773157985567, 60.754440622595865], [-95.58773157985567, 60.754422593716214], [-95.58774268844017, 60.75442259371622], [-95.58774268844017, 60.754413579276395], [-95.58775379702485, 60.75441357927639], [-95.58776490560925, 60.75441357927639], [-95.58776490560925, 60.754404564836584], [-95.58777601419379, 60.75440456483658], [-95.58777601419379, 60.75439555039674], [-95.58778712277842, 60.754395550396744], [-95.58779823136284, 60.75439555039675], [-95.58779823136284, 60.754386535956925], [-95.5878093399475, 60.75438653595693], [-95.58782044853191, 60.754386535956925], [-95.58782044853191, 60.754377521517114], [-95.58783155711644, 60.754377521517114], [-95.58783155711644, 60.75436850707728], [-95.58784266570109, 60.75436850707729], [-95.58785377428549, 60.75436850707728], [-95.58785377428549, 60.75435949263747], [-95.58786488287015, 60.75435949263747], [-95.58787599145457, 60.75435949263746], [-95.58787599145457, 60.75435047819764], [-95.58788710003908, 60.75435047819763], [-95.58788710003908, 60.75434146375782], [-95.58789820862374, 60.75434146375782], [-95.58790931720813, 60.75434146375782], [-95.58790931720813, 60.754332449318], [-95.58792042579284, 60.754332449317985], [-95.58794264296174, 60.754332449317985], [-95.58794264296174, 60.75432343487817], [-95.58814259748327, 60.754323434878174], [-95.58814259748327, 60.75433244931799], [-95.58816481465232, 60.754332449317985], [-95.58816481465232, 60.75434146375782], [-95.58818703182139, 60.75434146375782], [-95.58818703182139, 60.75435047819764], [-95.58820924899044, 60.754350478197644], [-95.58820924899044, 60.75435949263746], [-95.5882314661595, 60.75435949263746], [-95.5882314661595, 60.75436850707728], [-95.58824257474404, 60.75436850707729], [-95.58824257474404, 60.754377521517114], [-95.58826479191309, 60.75437752151711], [-95.58826479191309, 60.75438653595694], [-95.58828700908214, 60.75438653595692], [-95.58828700908214, 60.754395550396744], [-95.58830922625121, 60.75439555039675], [-95.58830922625121, 60.75440456483658], [-95.58832033483573, 60.75440456483657], [-95.58832033483573, 60.754413579276395], [-95.58833144342026, 60.7544135792764], [-95.58833144342026, 60.754422593716214], [-95.58834255200479, 60.754422593716214], [-95.58834255200479, 60.75443160815605], [-95.58835366058933, 60.75443160815605], [-95.58835366058933, 60.754440622595865], [-95.58836476917384, 60.754440622595865], [-95.58836476917384, 60.75445865147551], [-95.58837587775838, 60.75445865147551], [-95.58837587775838, 60.754476680355154], [-95.58838698634291, 60.75447668035514], [-95.58838698634291, 60.75448569479499], [-95.58839809492746, 60.75448569479499], [-95.58839809492746, 60.7544947092348], [-95.58840920351196, 60.7544947092348], [-95.58840920351196, 60.75450372367462], [-95.5884203120965, 60.754503723674624], [-95.5884203120965, 60.75451273811444], [-95.58843142068103, 60.75451273811444], [-95.58843142068103, 60.75452175255426], [-95.58845363785008, 60.75452175255427], [-95.58845363785008, 60.75453076699409], [-95.58847585501913, 60.75453076699409], [-95.58847585501913, 60.754539781433905], [-95.58848696360367, 60.75453978143391], [-95.58848696360367, 60.75454879587374], [-95.5884980721882, 60.75454879587374], [-95.5884980721882, 60.75455781031357], [-95.58850918077275, 60.75455781031356], [-95.58850918077275, 60.75456682475338], [-95.58852028935725, 60.75456682475338], [-95.58852028935725, 60.7545758391932], [-95.5885313979418, 60.7545758391932], [-95.5885313979418, 60.754593868072845], [-95.58854250652632, 60.754593868072845], [-95.58854250652632, 60.75461189695248], [-95.58855361511087, 60.7546118969525], [-95.58855361511087, 60.75462091139233], [-95.5885647236954, 60.75462091139232], [-95.5885647236954, 60.754629925832134], [-95.58857583227991, 60.754629925832134], [-95.58857583227991, 60.754638940271974], [-95.58858694086445, 60.75463894027197], [-95.58858694086445, 60.754647954711785], [-95.58859804944898, 60.754647954711785], [-95.58859804944898, 60.75465696915161], [-95.58862026661804, 60.75465696915162], [-95.58862026661804, 60.754665983591444], [-95.58864248378708, 60.754665983591444], [-95.58864248378708, 60.754674998031255], [-95.58865359237161, 60.75467499803125], [-95.58865359237161, 60.75468401247108], [-95.58867580954069, 60.754684012471074], [-95.58867580954069, 60.75469302691089], [-95.58869802670974, 60.75469302691089], [-95.58869802670974, 60.75470204135073], [-95.58870913529427, 60.754702041350725], [-95.58870913529427, 60.754711055790544], [-95.58873135246331, 60.75471105579055], [-95.58873135246331, 60.75472007023037], [-95.58875356963239, 60.75472007023037], [-95.58875356963239, 60.754729084670196], [-95.58880911255503, 60.754729084670196], [-95.58880911255503, 60.75473809911001], [-95.5888313297241, 60.75473809911002], [-95.5888313297241, 60.75474711354983], [-95.58885354689315, 60.75474711354983], [-95.58885354689315, 60.75475612798965], [-95.58887576406222, 60.754756127989644], [-95.58887576406222, 60.75476514242948], [-95.58889798123127, 60.754765142429484], [-95.58889798123127, 60.7547741568693], [-95.5889090898158, 60.75477415686931], [-95.5889090898158, 60.75478317130913], [-95.58893130698488, 60.75478317130912], [-95.58893130698488, 60.75479218574894], [-95.58895352415392, 60.75479218574895], [-95.58895352415392, 60.754801200188766], [-95.58913126150641, 60.75480120018877], [-95.58913126150641, 60.754792185748954], [-95.58914237009104, 60.75479218574895], [-95.58915347867546, 60.754792185748954], [-95.58915347867546, 60.75478317130914], [-95.58916458725996, 60.75478317130913], [-95.58916458725996, 60.754774156869296], [-95.58917569584463, 60.75477415686931], [-95.58918680442903, 60.7547741568693], [-95.58918680442903, 60.75476514242948], [-95.5891979130137, 60.754765142429484], [-95.58920902159808, 60.754765142429484], [-95.58920902159808, 60.75475612798965], [-95.58922013018262, 60.754756127989666], [-95.58922013018262, 60.75474711354983], [-95.58923123876728, 60.75474711354983], [-95.5892423473517, 60.75474711354984], [-95.5892423473517, 60.754738099110014], [-95.58925345593639, 60.754738099110014], [-95.58927567310528, 60.754738099110014], [-95.58927567310528, 60.754729084670196], [-95.58944230187322, 60.75472908467019], [-95.58944230187322, 60.75473809911002], [-95.58943119328869, 60.754738099110014], [-95.58943119328869, 60.75475612798966], [-95.58942008470416, 60.75475612798965], [-95.58942008470416, 60.754774156869296], [-95.58940897611964, 60.754774156869296], [-95.58940897611964, 60.754792185748954], [-95.5893978675351, 60.754792185748954], [-95.5893978675351, 60.754801200188766], [-95.58938675895057, 60.754801200188766], [-95.58938675895057, 60.75482824350824], [-95.58937565036604, 60.75482824350824], [-95.58937565036604, 60.75483725794807], [-95.58936454178152, 60.75483725794807], [-95.58936454178152, 60.754855286827706], [-95.58935343319699, 60.754855286827706], [-95.58935343319699, 60.754873315707364], [-95.58934232461245, 60.75487331570736], [-95.58934232461245, 60.754891344587], [-95.58933121602794, 60.75489134458701], [-95.58933121602794, 60.754909373466646], [-95.5893201074434, 60.75490937346665], [-95.5893201074434, 60.75491838790648], [-95.58930899885887, 60.75491838790648], [-95.58930899885887, 60.75493641678611], [-95.58929789027435, 60.754936416786116], [-95.58929789027435, 60.75495444566575], [-95.58928678168982, 60.75495444566575], [-95.58928678168982, 60.7549724745454], [-95.58927567310528, 60.754972474545404], [-95.58927567310528, 60.754990503425056], [-95.58926456452075, 60.75499050342504], [-95.58926456452075, 60.755008532304686], [-95.5892534559362, 60.755008532304686], [-95.5892534559362, 60.75501754674452], [-95.5892423473517, 60.75501754674452], [-95.5892423473517, 60.75503557562416], [-95.58923123876716, 60.75503557562416], [-95.58923123876716, 60.75505360450382], [-95.58922013018262, 60.7550536045038], [-95.58922013018262, 60.75506261894363], [-95.58920902159808, 60.75506261894363], [-95.58920902159808, 60.75507163338345], [-95.58919791301358, 60.755071633383466], [-95.58919791301358, 60.75508064782327], [-95.58918680442903, 60.75508064782327], [-95.58918680442903, 60.7550896622631], [-95.5891756958445, 60.75508966226311], [-95.5891756958445, 60.75510769114275], [-95.58916458725996, 60.75510769114275], [-95.58916458725996, 60.755116705582566], [-95.58915347867546, 60.75511670558255], [-95.58915347867546, 60.755125720022384], [-95.58914237009091, 60.75512572002239], [-95.58914237009091, 60.755143748902036], [-95.58913126150641, 60.75514374890204], [-95.58913126150641, 60.755152763341854], [-95.58912015292186, 60.75515276334186], [-95.58912015292186, 60.75516177778168], [-95.58910904433733, 60.75516177778169], [-95.58910904433733, 60.7551707922215], [-95.58909793575279, 60.755170792221506], [-95.58909793575279, 60.75517980666133], [-95.58908682716829, 60.75517980666133], [-95.58908682716829, 60.75519783554097], [-95.58907571858374, 60.755197835540976], [-95.58907571858374, 60.7552068499808], [-95.58906460999921, 60.7552068499808], [-95.58906460999921, 60.75521586442063], [-95.58905350141468, 60.755215864420634], [-95.58905350141468, 60.75522487886044], [-95.58904239283017, 60.75522487886044], [-95.58904239283017, 60.75524290774008], [-95.58903128424562, 60.75524290774008], [-95.58903128424562, 60.75525192217991], [-95.58902017566109, 60.75525192217991], [-95.58902017566109, 60.75526093661975], [-95.58900906707656, 60.75526093661973], [-95.58900906707656, 60.75527896549938], [-95.58899795849204, 60.75527896549938], [-95.58899795849204, 60.755287979939204], [-95.58898684990751, 60.75528797993919], [-95.58898684990751, 60.75529699437903], [-95.58897574132297, 60.75529699437902], [-95.58897574132297, 60.75530600881885], [-95.58896463273845, 60.75530600881885], [-95.58896463273845, 60.7553240376985], [-95.58895352415392, 60.75532403769849], [-95.58895352415392, 60.75533305213831], [-95.58894241556939, 60.75533305213831], [-95.58894241556939, 60.75534206657814], [-95.58893130698488, 60.75534206657813], [-95.58893130698488, 60.75536009545778], [-95.58892019840034, 60.75536009545778], [-95.58892019840034, 60.75536910989761], [-95.5889090898158, 60.755369109897615], [-95.5889090898158, 60.755378124337426], [-95.58889798123127, 60.75537812433742], [-95.58889798123127, 60.755387138777245], [-95.58888687264673, 60.755387138777245], [-95.58888687264673, 60.75539615321708], [-95.58887576406222, 60.75539615321708], [-95.58887576406222, 60.755414182096715], [-95.58886465547768, 60.755414182096715], [-95.58886465547768, 60.75542319653654], [-95.58885354689315, 60.755423196536555], [-95.58885354689315, 60.755441225416185], [-95.5888424383086, 60.755441225416185], [-95.5888424383086, 60.75545925429584], [-95.5888313297241, 60.755459254295836], [-95.5888313297241, 60.755477283175466], [-95.58882022113956, 60.755477283175466], [-95.58882022113956, 60.75549531205512], [-95.58880911255503, 60.755495312055125], [-95.58880911255503, 60.75551334093477], [-95.58879800397048, 60.75551334093477], [-95.58879800397048, 60.75554939869406], [-95.58878689538598, 60.75554939869405], [-95.58878689538598, 60.755594470893165], [-95.58879800397048, 60.755594470893165], [-95.58879800397048, 60.755603485333], [-95.58880911255503, 60.755603485333], [-95.58880911255503, 60.75561249977282], [-95.58882022113956, 60.755612499772816], [-95.58882022113956, 60.75562151421263], [-95.5888313297241, 60.75562151421264], [-95.5888313297241, 60.755630528652446], [-95.58885354689315, 60.75563052865245], [-95.58885354689315, 60.755639543092286], [-95.58886465547768, 60.75563954309228], [-95.58886465547768, 60.755648557532105], [-95.58888687264673, 60.755648557532105], [-95.58888687264673, 60.75565757197192], [-95.5889090898158, 60.75565757197193], [-95.5889090898158, 60.755666586411756], [-95.58892019840034, 60.755666586411756], [-95.58892019840034, 60.75567560085157], [-95.58894241556939, 60.75567560085157], [-95.58894241556939, 60.75568461529141], [-95.58876467821693, 60.75568461529139], [-95.58876467821693, 60.755675600851575], [-95.58875356963239, 60.75567560085157], [-95.58875356963239, 60.755666586411756], [-95.58874246104786, 60.755666586411756], [-95.58874246104786, 60.75565757197192], [-95.58873135246331, 60.75565757197193], [-95.58873135246331, 60.755639543092286], [-95.58872024387881, 60.75563954309229], [-95.58872024387881, 60.75562151421264], [-95.58870913529427, 60.75562151421264], [-95.58870913529427, 60.75554038425424], [-95.58872024387881, 60.75554038425425], [-95.58872024387881, 60.755522355374595], [-95.58873135246331, 60.75552235537459], [-95.58873135246331, 60.755513340934776], [-95.58874246104786, 60.75551334093476], [-95.58874246104786, 60.75549531205512], [-95.58875356963239, 60.75549531205512], [-95.58875356963239, 60.75547728317548], [-95.58876467821693, 60.75547728317547], [-95.58876467821693, 60.755468268735655], [-95.58877578680143, 60.755468268735655], [-95.58877578680143, 60.755441225416185], [-95.58878689538598, 60.75544122541619], [-95.58878689538598, 60.755387138777245], [-95.58877578680143, 60.755387138777245], [-95.58877578680143, 60.75536910989761], [-95.58876467821693, 60.7553691098976], [-95.58876467821693, 60.755351081017956], [-95.58875356963239, 60.75535108101796], [-95.58875356963239, 60.75534206657814], [-95.58874246104786, 60.75534206657813], [-95.58874246104786, 60.75533305213831], [-95.58873135246331, 60.75533305213831], [-95.58873135246331, 60.75532403769849], [-95.58872024387881, 60.75532403769849], [-95.58872024387881, 60.75531502325866], [-95.58870913529427, 60.75531502325867], [-95.58870913529427, 60.75530600881885], [-95.5886869181252, 60.75530600881885], [-95.5886869181252, 60.75529699437902], [-95.58866470095614, 60.755296994379016], [-95.58866470095614, 60.755287979939204], [-95.58864248378708, 60.7552879799392], [-95.58864248378708, 60.75527896549937], [-95.58858694086445, 60.75527896549938], [-95.58858694086445, 60.75526995105955], [-95.5885647236954, 60.75526995105956], [-95.5885647236954, 60.75526093661974], [-95.58854250652632, 60.755260936619734], [-95.58854250652632, 60.75525192217991], [-95.5885313979418, 60.75525192217991], [-95.5885313979418, 60.755242907740076], [-95.58852028935725, 60.755242907740076], [-95.58852028935725, 60.755233893300264], [-95.5884980721882, 60.755233893300264], [-95.5884980721882, 60.75522487886043], [-95.58847585501913, 60.755224878860446], [-95.58847585501913, 60.755215864420634], [-95.58846474643462, 60.75521586442063], [-95.58846474643462, 60.7552068499808], [-95.58844252926555, 60.7552068499808], [-95.58844252926555, 60.755197835540976], [-95.58843142068103, 60.75519783554097], [-95.58843142068103, 60.75518882110114], [-95.58840920351196, 60.75518882110116], [-95.58840920351196, 60.755179806661324], [-95.58838698634291, 60.75517980666134], [-95.58838698634291, 60.75517079222151], [-95.58837587775838, 60.75517079222149], [-95.58837587775838, 60.75516177778168], [-95.58835366058933, 60.75516177778167], [-95.58835366058933, 60.75515276334184], [-95.58833144342026, 60.75515276334186], [-95.58833144342026, 60.75514374890204], [-95.58830922625121, 60.755143748902036], [-95.58830922625121, 60.755134734462224], [-95.58810927172965, 60.75513473446222], [-95.58810927172965, 60.75514374890204], [-95.58808705456079, 60.755143748902036], [-95.58807594597607, 60.755143748902036], [-95.58807594597607, 60.755152763341854], [-95.58806483739168, 60.75515276334186], [-95.58805372880703, 60.755152763341854], [-95.58805372880703, 60.75516177778169], [-95.58804262022248, 60.75516177778168], [-95.58804262022248, 60.755170792221506], [-95.58803151163798, 60.7551707922215], [-95.58803151163798, 60.75517980666134], [-95.58802040305356, 60.755179806661324], [-95.5880092944689, 60.75517980666133], [-95.5880092944689, 60.755197835540976], [-95.58799818588436, 60.75519783554097], [-95.58799818588436, 60.755206849980794], [-95.58798707729986, 60.75520684998081], [-95.58798707729986, 60.755215864420634], [-95.58797596871531, 60.75521586442063], [-95.58797596871531, 60.755233893300264], [-95.58796486013078, 60.755233893300264], [-95.58796486013078, 60.755260936619734], [-95.58795375154625, 60.75526093661973], [-95.58795375154625, 60.755441225416185], [-95.58794264296174, 60.755441225416185], [-95.58794264296174, 60.755468268735655], [-95.58793153437719, 60.755468268735655], [-95.58793153437719, 60.75547728317548], [-95.58792042579266, 60.75547728317547], [-95.58792042579266, 60.755495312055125], [-95.58790931720813, 60.75549531205512], [-95.58790931720813, 60.75550432649495], [-95.58789820862361, 60.75550432649495], [-95.58789820862361, 60.75551334093476], [-95.58788710003908, 60.75551334093477], [-95.58788710003908, 60.75552235537458], [-95.5878759914547, 60.75552235537459], [-95.58786488287002, 60.75552235537459], [-95.58786488287002, 60.75553136981442], [-95.58785377428549, 60.75553136981441], [-95.58785377428549, 60.75554038425424], [-95.58783155711663, 60.75554038425424], [-95.58782044853191, 60.75554038425424], [-95.58782044853191, 60.75554939869406], [-95.58775379702472, 60.75554939869405], [-95.58775379702472, 60.75554038425424], [-95.58773157985567, 60.75554038425424], [-95.58773157985567, 60.75553136981442], [-95.58770936268662, 60.75553136981441], [-95.58770936268662, 60.75552235537459], [-95.58769825410208, 60.75552235537459], [-95.58769825410208, 60.75551334093476], [-95.587676036933, 60.75551334093477], [-95.587676036933, 60.75550432649494], [-95.58765381976396, 60.755504326494936], [-95.58765381976396, 60.75549531205512], [-95.58764271117943, 60.755495312055125], [-95.58764271117943, 60.755486297615285], [-95.58762049401038, 60.7554862976153], [-95.58762049401038, 60.75547728317547], [-95.5875982768413, 60.755477283175466], [-95.5875982768413, 60.75546826873566], [-95.58758716825677, 60.755468268735655], [-95.58758716825677, 60.75545925429583], [-95.58757605967226, 60.755459254295836], [-95.58757605967226, 60.755450239855996], [-95.58756495108771, 60.75545023985601], [-95.58756495108771, 60.755441225416185], [-95.58755384250318, 60.755441225416185], [-95.58755384250318, 60.755432210976366], [-95.58754273391865, 60.755432210976366], [-95.58754273391865, 60.7554141820967], [-95.58753162533414, 60.755414182096715], [-95.58753162533414, 60.75539615321708], [-95.5875205167496, 60.75539615321708], [-95.5875205167496, 60.75537812433743], [-95.58750940816509, 60.75537812433742], [-95.58750940816509, 60.755369109897615], [-95.58749829958055, 60.75536910989761], [-95.58749829958055, 60.75535108101796], [-95.58748719099601, 60.75535108101795], [-95.58748719099601, 60.75533305213831], [-95.58747608241148, 60.75533305213832], [-95.58747608241148, 60.75531502325867], [-95.58746497382697, 60.75531502325866], [-95.58746497382697, 60.75529699437902], [-95.58745386524244, 60.75529699437901], [-95.58745386524244, 60.755116705582566], [-95.5874427566579, 60.75511670558255], [-95.5874427566579, 60.75510769114275], [-95.58743164807336, 60.75510769114275], [-95.58743164807336, 60.755098676702914], [-95.58740943090432, 60.755098676702914], [-95.58740943090432, 60.7550896622631], [-95.5873316708126, 60.755089662263096], [-95.5873316708126, 60.755098676702914], [-95.5873205622282, 60.75509867670292], [-95.58730945364353, 60.755098676702914], [-95.58730945364353, 60.75510769114275], [-95.58729834505903, 60.755107691142754], [-95.58729834505903, 60.7551257200224], [-95.58728723647448, 60.755125720022384], [-95.58728723647448, 60.7555674275737], [-95.58729834505903, 60.7555674275737], [-95.58729834505903, 60.755585456453346], [-95.58730945364353, 60.755585456453346], [-95.58730945364353, 60.75560348533298], [-95.58732056222807, 60.75560348533298], [-95.58732056222807, 60.75562151421264], [-95.5873316708126, 60.75562151421264], [-95.5873316708126, 60.75563052865246], [-95.58734277939715, 60.755630528652446], [-95.58734277939715, 60.75563954309227], [-95.58735388798165, 60.755639543092286], [-95.58735388798165, 60.755648557532105], [-95.5873649965662, 60.75564855753211], [-95.5873649965662, 60.75565757197193], [-95.5873761051507, 60.75565757197192], [-95.5873761051507, 60.755666586411756], [-95.58739832231977, 60.755666586411756], [-95.58739832231977, 60.75567560085157], [-95.58742053948882, 60.75567560085157], [-95.58742053948882, 60.75568461529141], [-95.58747608241148, 60.75568461529141], [-95.58747608241148, 60.75569362973121], [-95.58748719099601, 60.75569362973122], [-95.58748719099601, 60.75570264417104], [-95.58749829958055, 60.755702644171045], [-95.58749829958055, 60.755711658610856], [-95.58750940816509, 60.755711658610856], [-95.58750940816509, 60.75573870193034], [-95.5875205167496, 60.75573870193035], [-95.5875205167496, 60.7557657452498], [-95.58750940816509, 60.7557657452498], [-95.58750940816509, 60.755801803009085], [-95.58749829958055, 60.75580180300909], [-95.58749829958055, 60.75581081744892], [-95.58748719099601, 60.755810817448925], [-95.58748719099601, 60.755819831888736], [-95.58745386524268, 60.755819831888736], [-95.5874427566579, 60.75581983188873], [-95.5874427566579, 60.75582884632856], [-95.587420539489, 60.75582884632856], [-95.58740943090432, 60.75582884632856], [-95.58740943090432, 60.75583786076839], [-95.5873983223199, 60.755837860768395], [-95.58738721373524, 60.75583786076838], [-95.58738721373524, 60.7558468752082], [-95.5873761051507, 60.7558468752082], [-95.5873761051507, 60.755855889648025], [-95.58736499656632, 60.755855889648025], [-95.58735388798165, 60.75585588964804], [-95.58735388798165, 60.75586490408785], [-95.58734277939728, 60.75586490408786], [-95.5873316708126, 60.75586490408785], [-95.5873316708126, 60.75587391852767], [-95.58732056222807, 60.755873918527676], [-95.58732056222807, 60.75588293296749], [-95.58730945364366, 60.755882932967495], [-95.58729834505903, 60.75588293296748], [-95.58729834505903, 60.75589194740732], [-95.58727612789012, 60.755891947407314], [-95.5872650193054, 60.75589194740732], [-95.5872650193054, 60.75590096184715], [-95.58725391072103, 60.75590096184715], [-95.58724280213636, 60.75590096184715], [-95.58724280213636, 60.75590997628696], [-95.58722058496747, 60.755909976286965], [-95.58720947638278, 60.755909976286965], [-95.58720947638278, 60.755918990726784], [-95.58719836779824, 60.755918990726784], [-95.58719836779824, 60.755928005166616]]]}}]} \ No newline at end of file diff --git a/geopandas/tests/test_api.py b/geopandas/tests/test_api.py index 45a3431..5ca9dfc 100644 --- a/geopandas/tests/test_api.py +++ b/geopandas/tests/test_api.py @@ -11,8 +11,9 @@ def test_no_additional_imports(): "pytest", "py", "ipython", - # 'matplotlib', # matplotlib gets imported by pandas, see below - "descartes", + # fiona actually gets imported if installed (but error suppressed until used) + # "fiona", + # "matplotlib", # matplotlib gets imported by pandas, see below "mapclassify", # 'rtree', # rtree actually gets imported if installed "sqlalchemy", diff --git a/geopandas/tests/test_array.py b/geopandas/tests/test_array.py index 8710af7..2724b24 100644 --- a/geopandas/tests/test_array.py +++ b/geopandas/tests/test_array.py @@ -4,11 +4,13 @@ import numpy as np import pandas as pd import six +from pyproj import CRS import shapely import shapely.affinity import shapely.geometry from shapely.geometry.base import CAP_STYLE, JOIN_STYLE import shapely.wkb +import shapely.wkt from shapely._buildcfg import geos_version import geopandas @@ -31,7 +33,7 @@ triangle_no_missing = [ shapely.geometry.Polygon([(random.random(), random.random()) for i in range(3)]) for _ in range(10) ] -triangles = triangle_no_missing + [shapely.geometry.Polygon(), None] +triangles = triangle_no_missing + [shapely.wkt.loads("POLYGON EMPTY"), None] T = from_shapely(triangles) points_no_missing = [ @@ -52,8 +54,8 @@ def equal_geometries(result, expected): def test_points(): - x = np.arange(10).astype(np.float) - y = np.arange(10).astype(np.float) ** 2 + x = np.arange(10).astype(np.float64) + y = np.arange(10).astype(np.float64) ** 2 points = points_from_xy(x, y) assert isinstance(points, GeometryArray) @@ -117,9 +119,11 @@ def test_from_shapely_geo_interface(): return {"type": "Point", "coordinates": (self.x, self.y)} result = from_shapely([Point(1.0, 2.0), Point(3.0, 4.0)]) + expected = from_shapely( [shapely.geometry.Point(1.0, 2.0), shapely.geometry.Point(3.0, 4.0)] ) + assert all(v.equals(t) for v, t in zip(result, expected)) @@ -136,15 +140,16 @@ def test_from_wkb(): assert all(v.equals(t) for v, t in zip(res, points_no_missing)) # missing values - # TODO(pygeos) does not support empty strings - if compat.USE_PYGEOS: - L_wkb.extend([None]) - else: - L_wkb.extend([b"", None]) - res = from_wkb(L_wkb) - assert res[-1] is None + # TODO(pygeos) does not support empty strings, np.nan, or pd.NA + missing_values = [None] if not compat.USE_PYGEOS: - assert res[-2] is None + missing_values.extend([b"", np.nan]) + + if compat.PANDAS_GE_10: + missing_values.append(pd.NA) + + res = from_wkb(missing_values) + np.testing.assert_array_equal(res, np.full(len(missing_values), None)) # single MultiPolygon multi_poly = shapely.geometry.MultiPolygon( @@ -154,6 +159,16 @@ def test_from_wkb(): assert res[0] == multi_poly +def test_from_wkb_hex(): + geometry_hex = ["0101000000CDCCCCCCCCCC1440CDCCCCCCCC0C4A40"] + res = from_wkb(geometry_hex) + assert isinstance(res, GeometryArray) + + # array + res = from_wkb(np.array(geometry_hex, dtype=object)) + assert isinstance(res, GeometryArray) + + def test_to_wkb(): P = from_shapely(points_no_missing) res = to_wkb(P) @@ -191,23 +206,26 @@ def test_from_wkt(string_type): L_wkt = [f(p.wkt) for p in points_no_missing] res = from_wkt(L_wkt) assert isinstance(res, GeometryArray) - assert all(v.almost_equals(t) for v, t in zip(res, points_no_missing)) + tol = 0.5 * 10 ** (-6) + assert all(v.equals_exact(t, tolerance=tol) for v, t in zip(res, points_no_missing)) + assert all(v.equals_exact(t, tolerance=tol) for v, t in zip(res, points_no_missing)) # array res = from_wkt(np.array(L_wkt, dtype=object)) assert isinstance(res, GeometryArray) - assert all(v.almost_equals(t) for v, t in zip(res, points_no_missing)) + assert all(v.equals_exact(t, tolerance=tol) for v, t in zip(res, points_no_missing)) # missing values - # TODO(pygeos) does not support empty strings - if compat.USE_PYGEOS: - L_wkt.extend([None]) - else: - L_wkt.extend([f(""), None]) - res = from_wkt(L_wkt) - assert res[-1] is None + # TODO(pygeos) does not support empty strings, np.nan, or pd.NA + missing_values = [None] if not compat.USE_PYGEOS: - assert res[-2] is None + missing_values.extend([f(""), np.nan]) + + if compat.PANDAS_GE_10: + missing_values.append(pd.NA) + + res = from_wkb(missing_values) + np.testing.assert_array_equal(res, np.full(len(missing_values), None)) # single MultiPolygon multi_poly = shapely.geometry.MultiPolygon( @@ -325,19 +343,6 @@ def test_predicates_vector_vector(attr, args): assert result.tolist() == expected -@pytest.mark.parametrize( - "attr,args", [("equals_exact", (0.1,)), ("almost_equals", (3,))], -) -def test_equals_deprecation(attr, args): - point = points[0] - tri = triangles[0] - - for other in [point, tri, shapely.geometry.Polygon()]: - with pytest.warns(FutureWarning): - result = getattr(T, attr)(other, *args) - assert result.tolist() == getattr(T, "geom_" + attr)(other, *args).tolist() - - @pytest.mark.parametrize( "attr", [ @@ -352,31 +357,8 @@ def test_equals_deprecation(attr, args): def test_unary_geo(attr): na_value = None - if attr == "boundary": - # pygeos returns None for empty geometries - if not compat.USE_PYGEOS: - # boundary raises for empty geometry - with pytest.raises(Exception): - T.boundary - - values = triangle_no_missing + [None] - A = from_shapely(values) - else: - values = triangles - A = T - - result = getattr(A, attr) - if attr == "exterior" and compat.USE_PYGEOS: - # TODO(pygeos) - # empty Polygon() has an exterior with shapely > 1.7, which gives - # empty LinearRing instead of None, - # but conversion to pygeos still results in empty GeometryCollection - expected = [ - getattr(t, attr) if t is not None and not t.is_empty else na_value - for t in values - ] - else: - expected = [getattr(t, attr) if t is not None else na_value for t in values] + result = getattr(T, attr) + expected = [getattr(t, attr) if t is not None else na_value for t in triangles] assert equal_geometries(result, expected) @@ -442,7 +424,25 @@ def test_binary_geo_scalar(attr): @pytest.mark.parametrize( - "attr", ["is_closed", "is_valid", "is_empty", "is_simple", "has_z", "is_ring"] + "attr", + [ + "is_closed", + "is_valid", + "is_empty", + "is_simple", + "has_z", + # for is_ring we raise a warning about the value for Polygon changing + pytest.param( + "is_ring", + marks=[ + pytest.mark.filterwarnings("ignore:is_ring:FutureWarning"), + pytest.mark.skipif( + not compat.SHAPELY_GE_17, + reason="is_ring on empty Polygon doesn't work in Shapely 1.6", + ), + ], + ), + ], ) def test_unary_predicates(attr): na_value = False @@ -458,11 +458,9 @@ def test_unary_predicates(attr): result = getattr(V, attr) - if attr == "is_simple" and (geos_version < (3, 8) or compat.USE_PYGEOS): + if attr == "is_simple" and geos_version < (3, 8): # poly.is_simple raises an error for empty polygon for GEOS < 3.8 # with shapely, pygeos always returns False for all GEOS versions - # But even for Shapely with GEOS >= 3.8, empty GeometryCollection - # returns True instead of False expected = [ getattr(t, attr) if t is not None and not t.is_empty else na_value for t in vals @@ -474,17 +472,45 @@ def test_unary_predicates(attr): else na_value for t in vals ] + # empty Linearring.is_ring gives False with Shapely < 2.0 + if compat.USE_PYGEOS and not compat.SHAPELY_GE_20: + expected[-2] = True else: expected = [getattr(t, attr) if t is not None else na_value for t in vals] assert result.tolist() == expected +# for is_ring we raise a warning about the value for Polygon changing +@pytest.mark.filterwarnings("ignore:is_ring:FutureWarning") +@pytest.mark.skipif( + not compat.SHAPELY_GE_17, + reason="is_ring on empty Polygon doesn't work in Shapely 1.6", +) +def test_is_ring(): + g = [ + shapely.geometry.LinearRing([(0, 0), (1, 1), (1, -1)]), + shapely.geometry.LineString([(0, 0), (1, 1), (1, -1)]), + shapely.geometry.LineString([(0, 0), (1, 1), (1, -1), (0, 0)]), + shapely.geometry.Polygon([(0, 0), (1, 1), (1, -1)]), + shapely.wkt.loads("POLYGON EMPTY"), + None, + ] + expected = [True, False, True, True, True, False] + if not compat.USE_PYGEOS and not compat.SHAPELY_GE_20: + # empty polygon is_ring gives False with Shapely < 2.0 + expected[-2] = False + + result = from_shapely(g).is_ring + + assert result.tolist() == expected + + @pytest.mark.parametrize("attr", ["area", "length"]) def test_unary_float(attr): na_value = np.nan result = getattr(T, attr) assert isinstance(result, np.ndarray) - assert result.dtype == np.float + assert result.dtype == np.dtype("float64") expected = [getattr(t, attr) if t is not None else na_value for t in triangles] np.testing.assert_allclose(result, expected) @@ -492,7 +518,7 @@ def test_unary_float(attr): def test_geom_types(): cat = T.geom_type # empty polygon has GeometryCollection type - assert list(cat) == ["Polygon"] * (len(T) - 2) + ["GeometryCollection", None] + assert list(cat) == ["Polygon"] * (len(T) - 1) + [None] def test_geom_types_null_mixed(): @@ -753,6 +779,15 @@ def test_equality_ops(): res = a1 != a2 assert res.tolist() == [False, True, False] + # check the correct expansion of list-like geometry + multi_poly = shapely.geometry.MultiPolygon( + [shapely.geometry.box(0, 0, 1, 1), shapely.geometry.box(3, 3, 4, 4)] + ) + a3 = from_shapely([points[1], points[2], points[3], multi_poly]) + + res = a3 == multi_poly + assert res.tolist() == [False, False, False, True] + def test_dir(): assert "contains" in dir(P) @@ -856,3 +891,66 @@ def test_isna_pdNA(): t1 = T.copy() t1[0] = pd.NA assert t1[0] is None + + +def test_shift_has_crs(): + t = T.copy() + t.crs = 4326 + assert t.shift(1).crs == t.crs + assert t.shift(0).crs == t.crs + assert t.shift(-1).crs == t.crs + + +@pytest.mark.skipif( + not compat.PANDAS_GE_115, reason="crs only preserved in unique after pandas 1.1.5" +) +def test_unique_has_crs(): + t = T.copy() + t.crs = 4326 + assert t.unique().crs == t.crs + + +class TestEstimateUtmCrs: + def setup_method(self): + self.esb = shapely.geometry.Point(-73.9847, 40.7484) + self.sol = shapely.geometry.Point(-74.0446, 40.6893) + self.landmarks = from_shapely([self.esb, self.sol], crs="epsg:4326") + + def test_estimate_utm_crs__geographic(self): + if compat.PYPROJ_LT_3: + with pytest.raises(RuntimeError, match=r"pyproj 3\+ required"): + self.landmarks.estimate_utm_crs() + else: + assert self.landmarks.estimate_utm_crs() == CRS("EPSG:32618") + assert self.landmarks.estimate_utm_crs("NAD83") == CRS("EPSG:26918") + + @pytest.mark.skipif(compat.PYPROJ_LT_3, reason="requires pyproj 3 or higher") + def test_estimate_utm_crs__projected(self): + assert self.landmarks.to_crs("EPSG:3857").estimate_utm_crs() == CRS( + "EPSG:32618" + ) + + @pytest.mark.skipif(not compat.PYPROJ_GE_31, reason="requires pyproj 3.1 or higher") + def test_estimate_utm_crs__antimeridian(self): + antimeridian = from_shapely( + [ + shapely.geometry.Point(1722483.900174921, 5228058.6143420935), + shapely.geometry.Point(4624385.494808555, 8692574.544944234), + ], + crs="EPSG:3851", + ) + assert antimeridian.estimate_utm_crs() == CRS("EPSG:32760") + + @pytest.mark.skipif(compat.PYPROJ_LT_3, reason="requires pyproj 3 or higher") + def test_estimate_utm_crs__out_of_bounds(self): + with pytest.raises(RuntimeError, match="Unable to determine UTM CRS"): + from_shapely( + [shapely.geometry.Polygon([(0, 90), (1, 90), (2, 90)])], crs="EPSG:4326" + ).estimate_utm_crs() + + @pytest.mark.skipif(compat.PYPROJ_LT_3, reason="requires pyproj 3 or higher") + def test_estimate_utm_crs__missing_crs(self): + with pytest.raises(RuntimeError, match="crs must be set"): + from_shapely( + [shapely.geometry.Polygon([(0, 90), (1, 90), (2, 90)])] + ).estimate_utm_crs() diff --git a/geopandas/tests/test_crs.py b/geopandas/tests/test_crs.py index 222b3ba..2b995e4 100644 --- a/geopandas/tests/test_crs.py +++ b/geopandas/tests/test_crs.py @@ -1,4 +1,4 @@ -from distutils.version import LooseVersion +from packaging.version import Version import os import random @@ -18,7 +18,7 @@ import pytest # pyproj 2.3.1 fixed a segfault for the case working in an environment with # 'init' dicts (https://github.com/pyproj4/pyproj/issues/415) -PYPROJ_LT_231 = LooseVersion(pyproj.__version__) < LooseVersion("2.3.1") +PYPROJ_LT_231 = Version(pyproj.__version__) < Version("2.3.1") def _create_df(x, y=None, crs=None): @@ -49,6 +49,15 @@ def test_to_crs_transform(): assert_geodataframe_equal(df, utm, check_less_precise=True) +def test_to_crs_transform__missing_data(): + # https://github.com/geopandas/geopandas/issues/1573 + df = df_epsg26918() + df.loc[3, "geometry"] = None + lonlat = df.to_crs(epsg=4326) + utm = lonlat.to_crs(epsg=26918) + assert_geodataframe_equal(df, utm, check_less_precise=True) + + def test_to_crs_inplace(): df = df_epsg26918() lonlat = df.to_crs(epsg=4326) @@ -191,7 +200,10 @@ class TestGeometryArrayCRS: assert s.crs == self.osgb assert s.values.crs == self.osgb - with pytest.warns(FutureWarning): + with pytest.raises( + ValueError, + match="CRS mismatch between CRS of the passed geometries and 'crs'", + ): s = GeoSeries(arr, crs=4326) assert s.crs == self.osgb @@ -210,17 +222,15 @@ class TestGeometryArrayCRS: assert df.geometry.crs == self.osgb assert df.geometry.values.crs == self.osgb - # different passed CRS than array CRS is ignored - with pytest.warns(FutureWarning): + # different passed CRS than array CRS is now an error + match_str = "CRS mismatch between CRS of the passed geometries and 'crs'" + with pytest.raises(ValueError, match=match_str): df = GeoDataFrame(geometry=s, crs=4326) - assert df.crs == self.osgb - assert df.geometry.crs == self.osgb - assert df.geometry.values.crs == self.osgb - with pytest.warns(FutureWarning): + with pytest.raises(ValueError, match=match_str): GeoDataFrame(geometry=s, crs=4326) - with pytest.warns(FutureWarning): + with pytest.raises(ValueError, match=match_str): GeoDataFrame({"data": [1, 2], "geometry": s}, crs=4326) - with pytest.warns(FutureWarning): + with pytest.raises(ValueError, match=match_str): GeoDataFrame(df, crs=4326).crs # manually change CRS @@ -259,6 +269,8 @@ class TestGeometryArrayCRS: assert df.geometry.crs == self.wgs assert df.geometry.values.crs == self.wgs + arr = from_shapely(self.geoms) + s = GeoSeries(arr, crs=27700) df = GeoDataFrame() df = df.set_geometry(s) assert df.crs == self.osgb @@ -289,6 +301,42 @@ class TestGeometryArrayCRS: df.crs = 27700 assert df.crs == self.osgb + def test_dataframe_setitem(self): + # new geometry CRS has priority over GDF CRS + arr = from_shapely(self.geoms) + s = GeoSeries(arr, crs=27700) + df = GeoDataFrame() + df["geometry"] = s + assert df.crs == self.osgb + assert df.geometry.crs == self.osgb + assert df.geometry.values.crs == self.osgb + + arr = from_shapely(self.geoms, crs=27700) + df = GeoDataFrame() + df["geometry"] = arr + assert df.crs == self.osgb + assert df.geometry.crs == self.osgb + assert df.geometry.values.crs == self.osgb + + # test to_crs case (GH1960) + arr = from_shapely(self.geoms) + df = GeoDataFrame({"col1": [1, 2], "geometry": arr}, crs=4326) + df["geometry"] = df["geometry"].to_crs(27700) + assert df.crs == self.osgb + assert df.geometry.crs == self.osgb + assert df.geometry.values.crs == self.osgb + + # test changing geometry crs not in the geometry column doesn't change the crs + arr = from_shapely(self.geoms) + df = GeoDataFrame( + {"col1": [1, 2], "geometry": arr, "other_geom": arr}, crs=4326 + ) + df["other_geom"] = from_shapely(self.geoms, crs=27700) + assert df.crs == self.wgs + assert df.geometry.crs == self.wgs + assert df["geometry"].crs == self.wgs + assert df["other_geom"].crs == self.osgb + @pytest.mark.parametrize( "scalar", [None, Point(0, 0), LineString([(0, 0), (1, 1)])] ) @@ -383,7 +431,7 @@ class TestGeometryArrayCRS: assert df.column1.crs == self.wgs assert df.column1.values.crs == self.wgs - def test_to_crs(self): + def test_geoseries_to_crs(self): s = GeoSeries(self.geoms, crs=27700) s = s.to_crs(4326) assert s.crs == self.wgs @@ -403,6 +451,11 @@ class TestGeometryArrayCRS: assert df.col1.crs == self.wgs assert df.col1.values.crs == self.wgs + def test_array_to_crs(self): + arr = from_shapely(self.geoms, crs=27700) + arr = arr.to_crs(4326) + assert arr.crs == self.wgs + def test_from_shapely(self): arr = from_shapely(self.geoms, crs=27700) assert arr.crs == self.osgb @@ -529,12 +582,18 @@ class TestGeometryArrayCRS: # CRS should be assigned to geometry def test_deprecation(self): with pytest.warns(FutureWarning): - GeoDataFrame([], crs=27700) + df = GeoDataFrame([], crs=27700) + + # https://github.com/geopandas/geopandas/issues/1548 + # ensure we still have converted the crs value to a CRS object + assert isinstance(df.crs, pyproj.CRS) with pytest.warns(FutureWarning): df = GeoDataFrame([]) df.crs = 27700 + assert isinstance(df.crs, pyproj.CRS) + # make sure that geometry column from list has CRS (__setitem__) def test_setitem_geometry(self): arr = from_shapely(self.geoms, crs=27700) @@ -561,6 +620,16 @@ class TestGeometryArrayCRS: result = s.apply(lambda x: x.centroid) assert result.crs == 27700 + def test_apply_geodataframe(self): + df = GeoDataFrame({"col1": [0, 1]}, geometry=self.geoms, crs=27700) + assert df.crs == 27700 + + # apply preserves the CRS if the result is a GeoDataFrame + result = df.apply(lambda col: col, axis=0) + assert result.crs == 27700 + result = df.apply(lambda row: row, axis=1) + assert result.crs == 27700 + class TestSetCRS: @pytest.mark.parametrize( diff --git a/geopandas/tests/test_decorator.py b/geopandas/tests/test_decorator.py new file mode 100644 index 0000000..180ba92 --- /dev/null +++ b/geopandas/tests/test_decorator.py @@ -0,0 +1,91 @@ +from textwrap import dedent + +from geopandas._decorator import doc + + +@doc(method="cumsum", operation="sum") +def cumsum(whatever): + """ + This is the {method} method. + + It computes the cumulative {operation}. + """ + ... + + +@doc( + cumsum, + dedent( + """ + Examples + -------- + + >>> cumavg([1, 2, 3]) + 2 + """ + ), + method="cumavg", + operation="average", +) +def cumavg(whatever): + ... + + +@doc(cumsum, method="cummax", operation="maximum") +def cummax(whatever): + ... + + +@doc(cummax, method="cummin", operation="minimum") +def cummin(whatever): + ... + + +def test_docstring_formatting(): + docstr = dedent( + """ + This is the cumsum method. + + It computes the cumulative sum. + """ + ) + assert cumsum.__doc__ == docstr + + +def test_docstring_appending(): + docstr = dedent( + """ + This is the cumavg method. + + It computes the cumulative average. + + Examples + -------- + + >>> cumavg([1, 2, 3]) + 2 + """ + ) + assert cumavg.__doc__ == docstr + + +def test_doc_template_from_func(): + docstr = dedent( + """ + This is the cummax method. + + It computes the cumulative maximum. + """ + ) + assert cummax.__doc__ == docstr + + +def test_inherit_doc_template(): + docstr = dedent( + """ + This is the cummin method. + + It computes the cumulative minimum. + """ + ) + assert cummin.__doc__ == docstr diff --git a/geopandas/tests/test_dissolve.py b/geopandas/tests/test_dissolve.py index d2485ed..2d88761 100644 --- a/geopandas/tests/test_dissolve.py +++ b/geopandas/tests/test_dissolve.py @@ -3,10 +3,13 @@ import pandas as pd import geopandas from geopandas import GeoDataFrame, read_file +from geopandas import _compat as compat from pandas.testing import assert_frame_equal import pytest +from geopandas.testing import assert_geodataframe_equal + @pytest.fixture def nybb_polydf(): @@ -70,7 +73,7 @@ def test_dissolve_retains_nonexisting_crs(nybb_polydf): assert test.crs is None -def first_dissolve(nybb_polydf, first): +def test_first_dissolve(nybb_polydf, first): test = nybb_polydf.dissolve("manhattan_bronx") assert_frame_equal(first, test, check_column_type=False) @@ -99,3 +102,218 @@ def test_reset_index(nybb_polydf, first): test = nybb_polydf.dissolve("manhattan_bronx", as_index=False) comparison = first.reset_index() assert_frame_equal(comparison, test, check_column_type=False) + + +def test_dissolve_none(nybb_polydf): + test = nybb_polydf.dissolve(by=None) + expected = GeoDataFrame( + { + nybb_polydf.geometry.name: [nybb_polydf.geometry.unary_union], + "BoroName": ["Staten Island"], + "BoroCode": [5], + "manhattan_bronx": [5], + }, + geometry=nybb_polydf.geometry.name, + crs=nybb_polydf.crs, + ) + assert_frame_equal(expected, test, check_column_type=False) + + +def test_dissolve_none_mean(nybb_polydf): + test = nybb_polydf.dissolve(aggfunc="mean") + expected = GeoDataFrame( + { + nybb_polydf.geometry.name: [nybb_polydf.geometry.unary_union], + "BoroCode": [3.0], + "manhattan_bronx": [5.4], + }, + geometry=nybb_polydf.geometry.name, + crs=nybb_polydf.crs, + ) + assert_frame_equal(expected, test, check_column_type=False) + + +def test_dissolve_level(): + gdf = geopandas.GeoDataFrame( + { + "a": [1, 1, 2, 2], + "b": [3, 4, 4, 4], + "c": [3, 4, 5, 6], + "geometry": geopandas.array.from_wkt( + ["POINT (0 0)", "POINT (1 1)", "POINT (2 2)", "POINT (3 3)"] + ), + } + ).set_index(["a", "b", "c"]) + + expected_a = geopandas.GeoDataFrame( + { + "a": [1, 2], + "geometry": geopandas.array.from_wkt( + ["MULTIPOINT (0 0, 1 1)", "MULTIPOINT (2 2, 3 3)"] + ), + } + ).set_index("a") + expected_b = geopandas.GeoDataFrame( + { + "b": [3, 4], + "geometry": geopandas.array.from_wkt( + ["POINT (0 0)", "MULTIPOINT (1 1, 2 2, 3 3)"] + ), + } + ).set_index("b") + expected_ab = geopandas.GeoDataFrame( + { + "a": [1, 1, 2], + "b": [3, 4, 4], + "geometry": geopandas.array.from_wkt( + ["POINT (0 0)", "POINT (1 1)", "MULTIPOINT (2 2, 3 3)"] + ), + } + ).set_index(["a", "b"]) + + assert_frame_equal(expected_a, gdf.dissolve(level=0)) + assert_frame_equal(expected_a, gdf.dissolve(level="a")) + assert_frame_equal(expected_b, gdf.dissolve(level=1)) + assert_frame_equal(expected_b, gdf.dissolve(level="b")) + assert_frame_equal(expected_ab, gdf.dissolve(level=[0, 1])) + assert_frame_equal(expected_ab, gdf.dissolve(level=["a", "b"])) + + +def test_dissolve_sort(): + gdf = geopandas.GeoDataFrame( + { + "a": [2, 1, 1], + "geometry": geopandas.array.from_wkt( + ["POINT (0 0)", "POINT (1 1)", "POINT (2 2)"] + ), + } + ) + + expected_unsorted = geopandas.GeoDataFrame( + { + "a": [2, 1], + "geometry": geopandas.array.from_wkt( + ["POINT (0 0)", "MULTIPOINT (1 1, 2 2)"] + ), + } + ).set_index("a") + expected_sorted = expected_unsorted.sort_index() + + assert_frame_equal(expected_sorted, gdf.dissolve("a")) + assert_frame_equal(expected_unsorted, gdf.dissolve("a", sort=False)) + + +def test_dissolve_categorical(): + gdf = geopandas.GeoDataFrame( + { + "cat": pd.Categorical(["a", "a", "b", "b"]), + "noncat": [1, 1, 1, 2], + "to_agg": [1, 2, 3, 4], + "geometry": geopandas.array.from_wkt( + ["POINT (0 0)", "POINT (1 1)", "POINT (2 2)", "POINT (3 3)"] + ), + } + ) + + # when observed=False we get an additional observation + # that wasn't in the original data + expected_gdf_observed_false = geopandas.GeoDataFrame( + { + "cat": pd.Categorical(["a", "a", "b", "b"]), + "noncat": [1, 2, 1, 2], + "geometry": geopandas.array.from_wkt( + [ + "MULTIPOINT (0 0, 1 1)", + None, + "POINT (2 2)", + "POINT (3 3)", + ] + ), + "to_agg": [1, None, 3, 4], + } + ).set_index(["cat", "noncat"]) + + # when observed=True we do not get any additional observations + expected_gdf_observed_true = geopandas.GeoDataFrame( + { + "cat": pd.Categorical(["a", "b", "b"]), + "noncat": [1, 1, 2], + "geometry": geopandas.array.from_wkt( + ["MULTIPOINT (0 0, 1 1)", "POINT (2 2)", "POINT (3 3)"] + ), + "to_agg": [1, 3, 4], + } + ).set_index(["cat", "noncat"]) + + assert_frame_equal(expected_gdf_observed_false, gdf.dissolve(["cat", "noncat"])) + assert_frame_equal( + expected_gdf_observed_true, gdf.dissolve(["cat", "noncat"], observed=True) + ) + + +@pytest.mark.skipif( + not compat.PANDAS_GE_11, reason="dropna groupby kwarg added in pandas 1.1.0" +) +def test_dissolve_dropna(): + gdf = geopandas.GeoDataFrame( + { + "a": [1, 1, None], + "geometry": geopandas.array.from_wkt( + ["POINT (0 0)", "POINT (1 1)", "POINT (2 2)"] + ), + } + ) + + expected_with_na = geopandas.GeoDataFrame( + { + "a": [1.0, np.nan], + "geometry": geopandas.array.from_wkt( + ["MULTIPOINT (0 0, 1 1)", "POINT (2 2)"] + ), + } + ).set_index("a") + expected_no_na = geopandas.GeoDataFrame( + { + "a": [1.0], + "geometry": geopandas.array.from_wkt(["MULTIPOINT (0 0, 1 1)"]), + } + ).set_index("a") + + assert_frame_equal(expected_with_na, gdf.dissolve("a", dropna=False)) + assert_frame_equal(expected_no_na, gdf.dissolve("a")) + + +@pytest.mark.skipif( + compat.PANDAS_GE_11, reason="dropna warning is only emitted if pandas < 1.1.0" +) +def test_dissolve_dropna_warn(nybb_polydf): + # No warning with default params + with pytest.warns(None) as record: + nybb_polydf.dissolve() + + for r in record: + assert "dropna kwarg is not supported" not in str(r.message) + + # Warning is emitted with non-default dropna value + with pytest.warns( + UserWarning, match="dropna kwarg is not supported for pandas < 1.1.0" + ): + nybb_polydf.dissolve(dropna=False) + + +def test_dissolve_multi_agg(nybb_polydf, merged_shapes): + + merged_shapes[("BoroCode", "min")] = [3, 1] + merged_shapes[("BoroCode", "max")] = [5, 2] + merged_shapes[("BoroName", "count")] = [3, 2] + + with pytest.warns(None) as record: + test = nybb_polydf.dissolve( + by="manhattan_bronx", + aggfunc={ + "BoroCode": ["min", "max"], + "BoroName": "count", + }, + ) + assert_geodataframe_equal(test, merged_shapes) + assert len(record) == 0 diff --git a/geopandas/tests/test_explore.py b/geopandas/tests/test_explore.py new file mode 100644 index 0000000..73917a3 --- /dev/null +++ b/geopandas/tests/test_explore.py @@ -0,0 +1,818 @@ +import geopandas as gpd +import numpy as np +import pandas as pd +import pytest +from packaging.version import Version + +folium = pytest.importorskip("folium") +branca = pytest.importorskip("branca") +matplotlib = pytest.importorskip("matplotlib") +mapclassify = pytest.importorskip("mapclassify") + +import matplotlib.cm as cm # noqa +import matplotlib.colors as colors # noqa +from branca.colormap import StepColormap # noqa + +BRANCA_05 = Version(branca.__version__) > Version("0.4.2") + + +class TestExplore: + def setup_method(self): + self.nybb = gpd.read_file(gpd.datasets.get_path("nybb")) + self.world = gpd.read_file(gpd.datasets.get_path("naturalearth_lowres")) + self.cities = gpd.read_file(gpd.datasets.get_path("naturalearth_cities")) + self.world["range"] = range(len(self.world)) + self.missing = self.world.copy() + np.random.seed(42) + self.missing.loc[np.random.choice(self.missing.index, 40), "continent"] = np.nan + self.missing.loc[np.random.choice(self.missing.index, 40), "pop_est"] = np.nan + + def _fetch_map_string(self, m): + out = m._parent.render() + out_str = "".join(out.split()) + return out_str + + def test_simple_pass(self): + """Make sure default pass""" + self.nybb.explore() + self.world.explore() + self.cities.explore() + self.world.geometry.explore() + + def test_choropleth_pass(self): + """Make sure default choropleth pass""" + self.world.explore(column="pop_est") + + def test_map_settings_default(self): + """Check default map settings""" + m = self.world.explore() + assert m.location == [ + pytest.approx(-3.1774349999999956, rel=1e-6), + pytest.approx(2.842170943040401e-14, rel=1e-6), + ] + assert m.options["zoom"] == 10 + assert m.options["zoomControl"] is True + assert m.position == "relative" + assert m.height == (100.0, "%") + assert m.width == (100.0, "%") + assert m.left == (0, "%") + assert m.top == (0, "%") + assert m.global_switches.no_touch is False + assert m.global_switches.disable_3d is False + assert "openstreetmap" in m.to_dict()["children"].keys() + + def test_map_settings_custom(self): + """Check custom map settings""" + m = self.nybb.explore( + zoom_control=False, + width=200, + height=200, + ) + assert m.location == [ + pytest.approx(40.70582377450201, rel=1e-6), + pytest.approx(-73.9778006856748, rel=1e-6), + ] + assert m.options["zoom"] == 10 + assert m.options["zoomControl"] is False + assert m.height == (200.0, "px") + assert m.width == (200.0, "px") + + # custom XYZ tiles + m = self.nybb.explore( + zoom_control=False, + width=200, + height=200, + tiles="https://mt1.google.com/vt/lyrs=m&x={x}&y={y}&z={z}", + attr="Google", + ) + + out_str = self._fetch_map_string(m) + s = '"https://mt1.google.com/vt/lyrs=m\\u0026x={x}\\u0026y={y}\\u0026z={z}"' + assert s in out_str + assert '"attribution":"Google"' in out_str + + m = self.nybb.explore(location=(40, 5)) + assert m.location == [40, 5] + assert m.options["zoom"] == 10 + + m = self.nybb.explore(zoom_start=8) + assert m.location == [ + pytest.approx(40.70582377450201, rel=1e-6), + pytest.approx(-73.9778006856748, rel=1e-6), + ] + assert m.options["zoom"] == 8 + + m = self.nybb.explore(location=(40, 5), zoom_start=8) + assert m.location == [40, 5] + assert m.options["zoom"] == 8 + + def test_simple_color(self): + """Check color settings""" + # single named color + m = self.nybb.explore(color="red") + out_str = self._fetch_map_string(m) + assert '"fillColor":"red"' in out_str + + # list of colors + colors = ["#333333", "#367324", "#95824f", "#fcaa00", "#ffcc33"] + m2 = self.nybb.explore(color=colors) + out_str = self._fetch_map_string(m2) + for c in colors: + assert f'"fillColor":"{c}"' in out_str + + # column of colors + df = self.nybb.copy() + df["colors"] = colors + m3 = df.explore(color="colors") + out_str = self._fetch_map_string(m3) + for c in colors: + assert f'"fillColor":"{c}"' in out_str + + # line GeoSeries + m4 = self.nybb.boundary.explore(color="red") + out_str = self._fetch_map_string(m4) + assert '"fillColor":"red"' in out_str + + def test_choropleth_linear(self): + """Check choropleth colors""" + # default cmap + m = self.nybb.explore(column="Shape_Leng") + out_str = self._fetch_map_string(m) + assert 'color":"#440154"' in out_str + assert 'color":"#fde725"' in out_str + assert 'color":"#50c46a"' in out_str + assert 'color":"#481467"' in out_str + assert 'color":"#3d4e8a"' in out_str + + # named cmap + m = self.nybb.explore(column="Shape_Leng", cmap="PuRd") + out_str = self._fetch_map_string(m) + assert 'color":"#f7f4f9"' in out_str + assert 'color":"#67001f"' in out_str + assert 'color":"#d31760"' in out_str + assert 'color":"#f0ecf5"' in out_str + assert 'color":"#d6bedc"' in out_str + + def test_choropleth_mapclassify(self): + """Mapclassify bins""" + # quantiles + m = self.nybb.explore(column="Shape_Leng", scheme="quantiles") + out_str = self._fetch_map_string(m) + assert 'color":"#21918c"' in out_str + assert 'color":"#3b528b"' in out_str + assert 'color":"#5ec962"' in out_str + assert 'color":"#fde725"' in out_str + assert 'color":"#440154"' in out_str + + # headtail + m = self.world.explore(column="pop_est", scheme="headtailbreaks") + out_str = self._fetch_map_string(m) + assert '"fillColor":"#3b528b"' in out_str + assert '"fillColor":"#21918c"' in out_str + assert '"fillColor":"#5ec962"' in out_str + assert '"fillColor":"#fde725"' in out_str + assert '"fillColor":"#440154"' in out_str + # custom k + m = self.world.explore(column="pop_est", scheme="naturalbreaks", k=3) + out_str = self._fetch_map_string(m) + assert '"fillColor":"#21918c"' in out_str + assert '"fillColor":"#fde725"' in out_str + assert '"fillColor":"#440154"' in out_str + + def test_categorical(self): + """Categorical maps""" + # auto detection + m = self.world.explore(column="continent") + out_str = self._fetch_map_string(m) + assert 'color":"#9467bd","continent":"Europe"' in out_str + assert 'color":"#c49c94","continent":"NorthAmerica"' in out_str + assert 'color":"#1f77b4","continent":"Africa"' in out_str + assert 'color":"#98df8a","continent":"Asia"' in out_str + assert 'color":"#ff7f0e","continent":"Antarctica"' in out_str + assert 'color":"#9edae5","continent":"SouthAmerica"' in out_str + assert 'color":"#7f7f7f","continent":"Oceania"' in out_str + assert 'color":"#dbdb8d","continent":"Sevenseas(openocean)"' in out_str + + # forced categorical + m = self.nybb.explore(column="BoroCode", categorical=True) + out_str = self._fetch_map_string(m) + assert 'color":"#9edae5"' in out_str + assert 'color":"#c7c7c7"' in out_str + assert 'color":"#8c564b"' in out_str + assert 'color":"#1f77b4"' in out_str + assert 'color":"#98df8a"' in out_str + + # pandas.Categorical + df = self.world.copy() + df["categorical"] = pd.Categorical(df["name"]) + m = df.explore(column="categorical") + out_str = self._fetch_map_string(m) + for c in np.apply_along_axis(colors.to_hex, 1, cm.tab20(range(20))): + assert f'"fillColor":"{c}"' in out_str + + # custom cmap + m = self.nybb.explore(column="BoroName", cmap="Set1") + out_str = self._fetch_map_string(m) + assert 'color":"#999999"' in out_str + assert 'color":"#a65628"' in out_str + assert 'color":"#4daf4a"' in out_str + assert 'color":"#e41a1c"' in out_str + assert 'color":"#ff7f00"' in out_str + + # custom list of colors + cmap = ["#333432", "#3b6e8c", "#bc5b4f", "#8fa37e", "#efc758"] + m = self.nybb.explore(column="BoroName", cmap=cmap) + out_str = self._fetch_map_string(m) + for c in cmap: + assert f'"fillColor":"{c}"' in out_str + + # shorter list (to make it repeat) + cmap = ["#333432", "#3b6e8c"] + m = self.nybb.explore(column="BoroName", cmap=cmap) + out_str = self._fetch_map_string(m) + for c in cmap: + assert f'"fillColor":"{c}"' in out_str + + with pytest.raises(ValueError, match="'cmap' is invalid."): + self.nybb.explore(column="BoroName", cmap="nonsense") + + def test_categories(self): + m = self.nybb[["BoroName", "geometry"]].explore( + column="BoroName", + categories=["Brooklyn", "Staten Island", "Queens", "Bronx", "Manhattan"], + ) + out_str = self._fetch_map_string(m) + assert '"Bronx","__folium_color":"#c7c7c7"' in out_str + assert '"Manhattan","__folium_color":"#9edae5"' in out_str + assert '"Brooklyn","__folium_color":"#1f77b4"' in out_str + assert '"StatenIsland","__folium_color":"#98df8a"' in out_str + assert '"Queens","__folium_color":"#8c564b"' in out_str + + df = self.nybb.copy() + df["categorical"] = pd.Categorical(df["BoroName"]) + with pytest.raises(ValueError, match="Cannot specify 'categories'"): + df.explore("categorical", categories=["Brooklyn", "Staten Island"]) + + def test_column_values(self): + """ + Check that the dataframe plot method returns same values with an + input string (column in df), pd.Series, or np.array + """ + column_array = np.array(self.world["pop_est"]) + m1 = self.world.explore(column="pop_est") # column name + m2 = self.world.explore(column=column_array) # np.array + m3 = self.world.explore(column=self.world["pop_est"]) # pd.Series + assert m1.location == m2.location == m3.location + + m1_fields = self.world.explore(column=column_array, tooltip=True, popup=True) + out1_fields_str = self._fetch_map_string(m1_fields) + assert ( + 'fields=["pop_est","continent","name","iso_a3","gdp_md_est","range"]' + in out1_fields_str + ) + assert ( + 'aliases=["pop_est","continent","name","iso_a3","gdp_md_est","range"]' + in out1_fields_str + ) + + m2_fields = self.world.explore( + column=self.world["pop_est"], tooltip=True, popup=True + ) + out2_fields_str = self._fetch_map_string(m2_fields) + assert ( + 'fields=["pop_est","continent","name","iso_a3","gdp_md_est","range"]' + in out2_fields_str + ) + assert ( + 'aliases=["pop_est","continent","name","iso_a3","gdp_md_est","range"]' + in out2_fields_str + ) + + # GeoDataframe and the given list have different number of rows + with pytest.raises(ValueError, match="different number of rows"): + self.world.explore(column=np.array([1, 2, 3])) + + def test_no_crs(self): + """Naive geometry get no tiles""" + df = self.world.copy() + df.crs = None + m = df.explore() + assert "openstreetmap" not in m.to_dict()["children"].keys() + + def test_style_kwds(self): + """Style keywords""" + m = self.world.explore( + style_kwds=dict(fillOpacity=0.1, weight=0.5, fillColor="orange") + ) + out_str = self._fetch_map_string(m) + assert '"fillColor":"orange","fillOpacity":0.1,"weight":0.5' in out_str + m = self.world.explore(column="pop_est", style_kwds=dict(color="black")) + assert '"color":"black"' in self._fetch_map_string(m) + + def test_tooltip(self): + """Test tooltip""" + # default with no tooltip or popup + m = self.world.explore() + assert "GeoJsonTooltip" in str(m.to_dict()) + assert "GeoJsonPopup" not in str(m.to_dict()) + + # True + m = self.world.explore(tooltip=True, popup=True) + assert "GeoJsonTooltip" in str(m.to_dict()) + assert "GeoJsonPopup" in str(m.to_dict()) + out_str = self._fetch_map_string(m) + assert ( + 'fields=["pop_est","continent","name","iso_a3","gdp_md_est","range"]' + in out_str + ) + assert ( + 'aliases=["pop_est","continent","name","iso_a3","gdp_md_est","range"]' + in out_str + ) + + # True choropleth + m = self.world.explore(column="pop_est", tooltip=True, popup=True) + assert "GeoJsonTooltip" in str(m.to_dict()) + assert "GeoJsonPopup" in str(m.to_dict()) + out_str = self._fetch_map_string(m) + assert ( + 'fields=["pop_est","continent","name","iso_a3","gdp_md_est","range"]' + in out_str + ) + assert ( + 'aliases=["pop_est","continent","name","iso_a3","gdp_md_est","range"]' + in out_str + ) + + # single column + m = self.world.explore(tooltip="pop_est", popup="iso_a3") + out_str = self._fetch_map_string(m) + assert 'fields=["pop_est"]' in out_str + assert 'aliases=["pop_est"]' in out_str + assert 'fields=["iso_a3"]' in out_str + assert 'aliases=["iso_a3"]' in out_str + + # list + m = self.world.explore( + tooltip=["pop_est", "continent"], popup=["iso_a3", "gdp_md_est"] + ) + out_str = self._fetch_map_string(m) + assert 'fields=["pop_est","continent"]' in out_str + assert 'aliases=["pop_est","continent"]' in out_str + assert 'fields=["iso_a3","gdp_md_est"' in out_str + assert 'aliases=["iso_a3","gdp_md_est"]' in out_str + + # number + m = self.world.explore(tooltip=2, popup=2) + out_str = self._fetch_map_string(m) + assert 'fields=["pop_est","continent"]' in out_str + assert 'aliases=["pop_est","continent"]' in out_str + + # keywords tooltip + m = self.world.explore( + tooltip=True, + popup=False, + tooltip_kwds=dict(aliases=[0, 1, 2, 3, 4, 5], sticky=False), + ) + out_str = self._fetch_map_string(m) + assert ( + 'fields=["pop_est","continent","name","iso_a3","gdp_md_est","range"]' + in out_str + ) + assert "aliases=[0,1,2,3,4,5]" in out_str + assert '"sticky":false' in out_str + + # keywords popup + m = self.world.explore( + tooltip=False, + popup=True, + popup_kwds=dict(aliases=[0, 1, 2, 3, 4, 5]), + ) + out_str = self._fetch_map_string(m) + assert ( + 'fields=["pop_est","continent","name","iso_a3","gdp_md_est","range"]' + in out_str + ) + assert "aliases=[0,1,2,3,4,5]" in out_str + assert "${aliases[i]" in out_str + + # no labels + m = self.world.explore( + tooltip=True, + popup=True, + tooltip_kwds=dict(labels=False), + popup_kwds=dict(labels=False), + ) + out_str = self._fetch_map_string(m) + assert "${aliases[i]" not in out_str + + # named index + gdf = self.nybb.set_index("BoroName") + m = gdf.explore() + out_str = self._fetch_map_string(m) + assert "BoroName" in out_str + + def test_default_markers(self): + # check overridden default for points + m = self.cities.explore() + strings = ['"radius":2', '"fill":true', "CircleMarker(latlng,opts)"] + out_str = self._fetch_map_string(m) + for s in strings: + assert s in out_str + + m = self.cities.explore(marker_kwds=dict(radius=5, fill=False)) + strings = ['"radius":5', '"fill":false', "CircleMarker(latlng,opts)"] + out_str = self._fetch_map_string(m) + for s in strings: + assert s in out_str + + def test_custom_markers(self): + # Markers + m = self.cities.explore( + marker_type="marker", + marker_kwds={"icon": folium.Icon(icon="star")}, + ) + assert ""","icon":"star",""" in self._fetch_map_string(m) + + # Circle Markers + m = self.cities.explore(marker_type="circle", marker_kwds={"fill_color": "red"}) + assert ""","fillColor":"red",""" in self._fetch_map_string(m) + + # Folium Markers + m = self.cities.explore( + marker_type=folium.Circle( + radius=4, fill_color="orange", fill_opacity=0.4, color="black", weight=1 + ), + ) + assert ""","color":"black",""" in self._fetch_map_string(m) + + # Circle + m = self.cities.explore(marker_type="circle_marker", marker_kwds={"radius": 10}) + assert ""","radius":10,""" in self._fetch_map_string(m) + + # Unsupported Markers + with pytest.raises( + ValueError, + match="Only 'marker', 'circle', and 'circle_marker' are supported", + ): + self.cities.explore(marker_type="dummy") + + def test_vmin_vmax(self): + df = self.world.copy() + df["range"] = range(len(df)) + m = df.explore("range", vmin=-100, vmax=1000) + out_str = self._fetch_map_string(m) + assert 'case"176":return{"color":"#3b528b","fillColor":"#3b528b"' in out_str + assert 'case"119":return{"color":"#414287","fillColor":"#414287"' in out_str + assert 'case"3":return{"color":"#482173","fillColor":"#482173"' in out_str + + # test 0 + df2 = self.nybb.copy() + df2["values"] = df2["BoroCode"] * 10.0 + m = df2[df2["values"] >= 30].explore("values", vmin=0) + out_str = self._fetch_map_string(m) + assert 'case"1":return{"color":"#7ad151","fillColor":"#7ad151"' in out_str + assert 'case"2":return{"color":"#22a884","fillColor":"#22a884"' in out_str + + df2["values_negative"] = df2["BoroCode"] * -10.0 + m = df2[df2["values_negative"] <= 30].explore("values_negative", vmax=0) + out_str = self._fetch_map_string(m) + assert 'case"1":return{"color":"#414487","fillColor":"#414487"' in out_str + assert 'case"2":return{"color":"#2a788e","fillColor":"#2a788e"' in out_str + + def test_missing_vals(self): + m = self.missing.explore("continent") + assert '"fillColor":null' in self._fetch_map_string(m) + + m = self.missing.explore("pop_est") + assert '"fillColor":null' in self._fetch_map_string(m) + + m = self.missing.explore("pop_est", missing_kwds=dict(color="red")) + assert '"fillColor":"red"' in self._fetch_map_string(m) + + m = self.missing.explore("continent", missing_kwds=dict(color="red")) + assert '"fillColor":"red"' in self._fetch_map_string(m) + + def test_categorical_legend(self): + m = self.world.explore("continent", legend=True) + out_str = self._fetch_map_string(m) + assert "#1f77b4'>Africa" in out_str + assert "#ff7f0e'>Antarctica" in out_str + assert "#98df8a'>Asia" in out_str + assert "#9467bd'>Europe" in out_str + assert "#c49c94'>NorthAmerica" in out_str + assert "#7f7f7f'>Oceania" in out_str + assert "#dbdb8d'>Sevenseas(openocean)" in out_str + assert "#9edae5'>SouthAmerica" in out_str + + m = self.missing.explore( + "continent", legend=True, missing_kwds={"color": "red"} + ) + out_str = self._fetch_map_string(m) + assert "red'>NaN" in out_str + + def test_colorbar(self): + m = self.world.explore("range", legend=True) + out_str = self._fetch_map_string(m) + assert "attr(\"id\",'legend')" in out_str + assert "text('range')" in out_str + + m = self.world.explore( + "range", legend=True, legend_kwds=dict(caption="my_caption") + ) + out_str = self._fetch_map_string(m) + assert "attr(\"id\",'legend')" in out_str + assert "text('my_caption')" in out_str + + m = self.missing.explore("pop_est", legend=True, missing_kwds=dict(color="red")) + out_str = self._fetch_map_string(m) + assert "red'>NaN" in out_str + + # do not scale legend + m = self.world.explore( + "pop_est", + legend=True, + legend_kwds=dict(scale=False), + scheme="Headtailbreaks", + ) + out_str = self._fetch_map_string(m) + assert out_str.count("#440154ff") == 100 + assert out_str.count("#3b528bff") == 100 + assert out_str.count("#21918cff") == 100 + assert out_str.count("#5ec962ff") == 100 + assert out_str.count("#fde725ff") == 100 + + # scale legend accordingly + m = self.world.explore( + "pop_est", + legend=True, + scheme="Headtailbreaks", + ) + out_str = self._fetch_map_string(m) + assert out_str.count("#440154ff") == 16 + assert out_str.count("#3b528bff") == 51 + assert out_str.count("#21918cff") == 133 + assert out_str.count("#5ec962ff") == 282 + assert out_str.count("#fde725ff") == 18 + + # discrete cmap + m = self.world.explore("pop_est", legend=True, cmap="Pastel2") + out_str = self._fetch_map_string(m) + + assert out_str.count("b3e2cdff") == 63 + assert out_str.count("fdcdacff") == 62 + assert out_str.count("cbd5e8ff") == 63 + assert out_str.count("f4cae4ff") == 62 + assert out_str.count("e6f5c9ff") == 62 + assert out_str.count("fff2aeff") == 63 + assert out_str.count("f1e2ccff") == 62 + assert out_str.count("ccccccff") == 63 + + @pytest.mark.skipif(not BRANCA_05, reason="requires branca >= 0.5.0") + def test_colorbar_max_labels(self): + # linear + m = self.world.explore("pop_est", legend_kwds=dict(max_labels=3)) + out_str = self._fetch_map_string(m) + + tick_values = [140.0, 465176713.5921569, 930353287.1843138] + for tick in tick_values: + assert str(tick) in out_str + + # scheme + m = self.world.explore( + "pop_est", scheme="headtailbreaks", legend_kwds=dict(max_labels=3) + ) + out_str = self._fetch_map_string(m) + + assert "tickValues([140,'',182567501.0,'',1330619341.0,''])" in out_str + + # short cmap + m = self.world.explore("pop_est", legend_kwds=dict(max_labels=3), cmap="tab10") + out_str = self._fetch_map_string(m) + + tick_values = [140.0, 551721192.4, 1103442244.8] + for tick in tick_values: + assert str(tick) in out_str + + def test_xyzservices_providers(self): + xyzservices = pytest.importorskip("xyzservices") + + m = self.nybb.explore(tiles=xyzservices.providers.CartoDB.PositronNoLabels) + out_str = self._fetch_map_string(m) + + assert ( + '"https://a.basemaps.cartocdn.com/light_nolabels/{z}/{x}/{y}{r}.png"' + in out_str + ) + assert ( + 'attribution":"\\u0026copy;\\u003cahref=\\"https://www.openstreetmap.org' + in out_str + ) + assert '"maxNativeZoom":20,"maxZoom":20,"minZoom":0' in out_str + + def test_xyzservices_query_name(self): + pytest.importorskip("xyzservices") + + m = self.nybb.explore(tiles="CartoDB Positron No Labels") + out_str = self._fetch_map_string(m) + + assert ( + '"https://a.basemaps.cartocdn.com/light_nolabels/{z}/{x}/{y}{r}.png"' + in out_str + ) + assert ( + 'attribution":"\\u0026copy;\\u003cahref=\\"https://www.openstreetmap.org' + in out_str + ) + assert '"maxNativeZoom":20,"maxZoom":20,"minZoom":0' in out_str + + def test_linearrings(self): + rings = self.nybb.explode(index_parts=True).exterior + m = rings.explore() + out_str = self._fetch_map_string(m) + + assert out_str.count("LineString") == len(rings) + + def test_mapclassify_categorical_legend(self): + m = self.missing.explore( + column="pop_est", + legend=True, + scheme="naturalbreaks", + missing_kwds=dict(color="red", label="missing"), + legend_kwds=dict(colorbar=False, interval=True), + ) + out_str = self._fetch_map_string(m) + + strings = [ + "[140.00,33986655.00]", + "(33986655.00,105350020.00]", + "(105350020.00,207353391.00]", + "(207353391.00,326625791.00]", + "(326625791.00,1379302771.00]", + "missing", + ] + for s in strings: + assert s in out_str + + # interval=False + m = self.missing.explore( + column="pop_est", + legend=True, + scheme="naturalbreaks", + missing_kwds=dict(color="red", label="missing"), + legend_kwds=dict(colorbar=False, interval=False), + ) + out_str = self._fetch_map_string(m) + + strings = [ + ">140.00,33986655.00", + ">33986655.00,105350020.00", + ">105350020.00,207353391.00", + ">207353391.00,326625791.00", + ">326625791.00,1379302771.00", + "missing", + ] + for s in strings: + assert s in out_str + + # custom labels + m = self.world.explore( + column="pop_est", + legend=True, + scheme="naturalbreaks", + k=5, + legend_kwds=dict(colorbar=False, labels=["s", "m", "l", "xl", "xxl"]), + ) + out_str = self._fetch_map_string(m) + + strings = [">s<", ">m<", ">l<", ">xl<", ">xxl<"] + for s in strings: + assert s in out_str + + # fmt + m = self.missing.explore( + column="pop_est", + legend=True, + scheme="naturalbreaks", + missing_kwds=dict(color="red", label="missing"), + legend_kwds=dict(colorbar=False, fmt="{:.0f}"), + ) + out_str = self._fetch_map_string(m) + + strings = [ + ">140,33986655", + ">33986655,105350020", + ">105350020,207353391", + ">207353391,326625791", + ">326625791,1379302771", + "missing", + ] + for s in strings: + assert s in out_str + + def test_given_m(self): + "Check that geometry is mapped onto a given folium.Map" + m = folium.Map() + self.nybb.explore(m=m, tooltip=False, highlight=False) + + out_str = self._fetch_map_string(m) + + assert out_str.count("BoroCode") == 5 + # should not change map settings + assert m.options["zoom"] == 1 + + def test_highlight(self): + m = self.nybb.explore(highlight=True) + out_str = self._fetch_map_string(m) + + assert '"fillOpacity":0.75' in out_str + + m = self.nybb.explore( + highlight=True, highlight_kwds=dict(fillOpacity=1, color="red") + ) + out_str = self._fetch_map_string(m) + + assert '{"color":"red","fillOpacity":1}' in out_str + + def test_custom_colormaps(self): + + step = StepColormap(["green", "yellow", "red"], vmin=0, vmax=100000000) + + m = self.world.explore("pop_est", cmap=step, tooltip=["name"], legend=True) + + strings = [ + 'fillColor":"#008000ff"', # Green + '"fillColor":"#ffff00ff"', # Yellow + '"fillColor":"#ff0000ff"', # Red + ] + + out_str = self._fetch_map_string(m) + for s in strings: + assert s in out_str + + assert out_str.count("008000ff") == 306 + assert out_str.count("ffff00ff") == 187 + assert out_str.count("ff0000ff") == 190 + + # Using custom function colormap + def my_color_function(field): + """Maps low values to green and high values to red.""" + if field > 100000000: + return "#ff0000" + else: + return "#008000" + + m = self.world.explore("pop_est", cmap=my_color_function, legend=False) + + strings = [ + '"color":"#ff0000","fillColor":"#ff0000"', + '"color":"#008000","fillColor":"#008000"', + ] + + for s in strings: + assert s in self._fetch_map_string(m) + + # matplotlib.Colormap + cmap = colors.ListedColormap(["red", "green", "blue", "white", "black"]) + + m = self.nybb.explore("BoroName", cmap=cmap) + strings = [ + '"fillColor":"#ff0000"', # Red + '"fillColor":"#008000"', # Green + '"fillColor":"#0000ff"', # Blue + '"fillColor":"#ffffff"', # White + '"fillColor":"#000000"', # Black + ] + + out_str = self._fetch_map_string(m) + for s in strings: + assert s in out_str + + def test_multiple_geoseries(self): + """ + Additional GeoSeries need to be removed as they cannot be converted to GeoJSON + """ + gdf = self.nybb + gdf["boundary"] = gdf.boundary + gdf["centroid"] = gdf.centroid + + gdf.explore() + + def test_map_kwds(self): + def check(): + out_str = self._fetch_map_string(m) + assert "zoomControl:false" in out_str + assert "dragging:false" in out_str + assert "scrollWheelZoom:false" in out_str + + # check that folium and leaflet Map() parameters can be passed + m = self.world.explore( + zoom_control=False, map_kwds=dict(dragging=False, scrollWheelZoom=False) + ) + check() + with pytest.raises( + ValueError, match="'zoom_control' cannot be specified in 'map_kwds'" + ): + self.world.explore( + map_kwds=dict(dragging=False, scrollWheelZoom=False, zoom_control=False) + ) diff --git a/geopandas/tests/test_extension_array.py b/geopandas/tests/test_extension_array.py index 5bb8882..9582404 100644 --- a/geopandas/tests/test_extension_array.py +++ b/geopandas/tests/test_extension_array.py @@ -16,13 +16,14 @@ expected to be available to pytest by the inherited pandas tests). import operator import numpy as np +from numpy.testing import assert_array_equal import pandas as pd from pandas.tests.extension import base as extension_tests import shapely.geometry -from geopandas._compat import PANDAS_GE_024 from geopandas.array import GeometryArray, GeometryDtype, from_shapely +from geopandas._compat import ignore_shapely2_warnings import pytest @@ -31,21 +32,8 @@ import pytest # ----------------------------------------------------------------------------- -if not PANDAS_GE_024: - # pandas 0.23.4 doesn't have those tests yet, so adding dummy classes - # to derive from here - extension_tests.BaseNoReduceTests = object - extension_tests.BaseArithmeticOpsTests = object - extension_tests.BaseComparisonOpsTests = object - extension_tests.BasePrintingTests = object - extension_tests.BaseParsingTests = object - - not_yet_implemented = pytest.mark.skip(reason="Not yet implemented") no_sorting = pytest.mark.skip(reason="Sorting not supported") -skip_pandas_below_024 = pytest.mark.skipif( - not PANDAS_GE_024, reason="Sorting not supported" -) # ----------------------------------------------------------------------------- @@ -60,7 +48,9 @@ def dtype(): def make_data(): - a = np.array([shapely.geometry.Point(i, i) for i in range(100)], dtype=object) + a = np.empty(100, dtype=object) + with ignore_shapely2_warnings(): + a[:] = [shapely.geometry.Point(i, i) for i in range(100)] ga = from_shapely(a) return ga @@ -241,6 +231,18 @@ def as_array(request): return request.param +@pytest.fixture +def invalid_scalar(data): + """ + A scalar that *cannot* be held by this ExtensionArray. + + The default should work for most subclasses, but is not guaranteed. + + If the array can hold any item (i.e. object dtype), then use pytest.skip. + """ + return object.__new__(object) + + # Fixtures defined in pandas/conftest.py that are also needed: defining them # here instead of importing for compatibility @@ -292,7 +294,6 @@ class TestDtype(extension_tests.BaseDtypeTests): def test_array_type_with_arg(self, data, dtype): assert dtype.construct_array_type() is GeometryArray - @skip_pandas_below_024 def test_registry(self, data, dtype): s = pd.Series(np.asarray(data), dtype=object) result = s.astype("geometry") @@ -302,7 +303,35 @@ class TestDtype(extension_tests.BaseDtypeTests): class TestInterface(extension_tests.BaseInterfaceTests): - pass + def test_array_interface(self, data): + # we are overriding this base test because the creation of `expected` + # potentially doesn't work for shapely geometries + # TODO can be removed with Shapely 2.0 + result = np.array(data) + assert result[0] == data[0] + + result = np.array(data, dtype=object) + # expected = np.array(list(data), dtype=object) + expected = np.empty(len(data), dtype=object) + with ignore_shapely2_warnings(): + expected[:] = list(data) + assert_array_equal(result, expected) + + def test_contains(self, data, data_missing): + # overridden due to the inconsistency between + # GeometryDtype.na_value = np.nan + # and None being used as NA in array + + # ensure data without missing values + data = data[~data.isna()] + + # first elements are non-missing + assert data[0] in data + assert data_missing[0] in data_missing + + assert None in data_missing + assert None not in data + assert pd.NaT not in data_missing class TestConstructors(extension_tests.BaseConstructorsTests): @@ -352,6 +381,10 @@ class TestMissing(extension_tests.BaseMissingTests): def test_fillna_series_method(self, data_missing, method): pass + @pytest.mark.skip("fillna method not supported") + def test_fillna_no_op_returns_copy(self, data): + pass + class TestReduce(extension_tests.BaseNoReduceTests): @pytest.mark.skip("boolean reduce (any/all) tested in test_pandas_methods") @@ -381,11 +414,16 @@ def all_arithmetic_operators(request): """ Fixture for dunder names for common arithmetic operations - Adapted to excluse __sub__, as this is implemented as "difference". + Adapted to exclude __sub__, as this is implemented as "difference". """ return request.param +# an inherited test from pandas creates a Series from a list of geometries, which +# triggers the warning from Shapely, out of control of GeoPandas, so ignoring here +@pytest.mark.filterwarnings( + "ignore:The array interface is deprecated and will no longer work in Shapely 2.0" +) class TestArithmeticOps(extension_tests.BaseArithmeticOpsTests): @pytest.mark.skip(reason="not applicable") def test_divmod_series_array(self, data, data_for_twos): @@ -396,6 +434,11 @@ class TestArithmeticOps(extension_tests.BaseArithmeticOpsTests): pass +# an inherited test from pandas creates a Series from a list of geometries, which +# triggers the warning from Shapely, out of control of GeoPandas, so ignoring here +@pytest.mark.filterwarnings( + "ignore:The array interface is deprecated and will no longer work in Shapely 2.0" +) class TestComparisonOps(extension_tests.BaseComparisonOpsTests): def _compare_other(self, s, data, op_name, other): op = getattr(operator, op_name.strip("_")) @@ -403,13 +446,11 @@ class TestComparisonOps(extension_tests.BaseComparisonOpsTests): expected = s.combine(other, op) self.assert_series_equal(result, expected) - @skip_pandas_below_024 def test_compare_scalar(self, data, all_compare_operators): # noqa op_name = all_compare_operators s = pd.Series(data) self._compare_other(s, data, op_name, data[0]) - @skip_pandas_below_024 def test_compare_array(self, data, all_compare_operators): # noqa op_name = all_compare_operators s = pd.Series(data) @@ -418,12 +459,12 @@ class TestComparisonOps(extension_tests.BaseComparisonOpsTests): class TestMethods(extension_tests.BaseMethodsTests): - @not_yet_implemented + @no_sorting @pytest.mark.parametrize("dropna", [True, False]) def test_value_counts(self, all_data, dropna): pass - @not_yet_implemented + @no_sorting def test_value_counts_with_normalize(self, data): pass @@ -497,6 +538,26 @@ class TestMethods(extension_tests.BaseMethodsTests): def test_argsort_missing_array(self): pass + @no_sorting + def test_argmin_argmax(self): + pass + + @no_sorting + def test_argmin_argmax_empty_array(self): + pass + + @no_sorting + def test_argmin_argmax_all_na(self): + pass + + @no_sorting + def test_argreduce_series(self): + pass + + @no_sorting + def test_argmax_argmin_no_skipna_notimplemented(self): + pass + class TestCasting(extension_tests.BaseCastingTests): pass diff --git a/geopandas/tests/test_geocode.py b/geopandas/tests/test_geocode.py index dd5de8a..4b1c8cc 100644 --- a/geopandas/tests/test_geocode.py +++ b/geopandas/tests/test_geocode.py @@ -1,4 +1,3 @@ -import numpy as np import pandas as pd from shapely.geometry import Point @@ -9,6 +8,7 @@ from geopandas.tools.geocoding import _prepare_geocode_result from geopandas.tests.util import assert_geoseries_equal, mock from pandas.testing import assert_series_equal +from geopandas.testing import assert_geodataframe_equal import pytest geopy = pytest.importorskip("geopy") @@ -23,13 +23,13 @@ class ForwardMock(mock.MagicMock): """ def __init__(self, *args, **kwargs): - super(ForwardMock, self).__init__(*args, **kwargs) + super().__init__(*args, **kwargs) self._n = 0.0 def __call__(self, *args, **kwargs): self.return_value = args[0], (self._n, self._n + 0.5) self._n += 1 - return super(ForwardMock, self).__call__(*args, **kwargs) + return super().__call__(*args, **kwargs) class ReverseMock(mock.MagicMock): @@ -41,13 +41,13 @@ class ReverseMock(mock.MagicMock): """ def __init__(self, *args, **kwargs): - super(ReverseMock, self).__init__(*args, **kwargs) + super().__init__(*args, **kwargs) self._n = 0 def __call__(self, *args, **kwargs): self.return_value = "address{0}".format(self._n), args[0] self._n += 1 - return super(ReverseMock, self).__call__(*args, **kwargs) + return super().__call__(*args, **kwargs) @pytest.fixture @@ -106,7 +106,21 @@ def test_prepare_result_none(): # TODO we should probably replace this with a missing value instead of point? # assert len(row["geometry"].coords) == 0 assert row["geometry"].is_empty - assert np.isnan(row["address"]) + assert row["address"] is None + + +@pytest.mark.parametrize("geocode_result", (None, (None, None))) +def test_prepare_geocode_result_when_result_is(geocode_result): + + result = {0: geocode_result} + expected_output = GeoDataFrame( + {"geometry": [Point()], "address": [None]}, + crs="EPSG:4326", + ) + + output = _prepare_geocode_result(result) + + assert_geodataframe_equal(output, expected_output) def test_bad_provider_forward(): @@ -120,14 +134,14 @@ def test_bad_provider_reverse(): from geopy.exc import GeocoderNotFound with pytest.raises(GeocoderNotFound): - reverse_geocode(["cambridge, ma"], "badprovider") + reverse_geocode([Point(0, 0)], "badprovider") def test_forward(locations, points): - from geopy.geocoders import GeocodeFarm + from geopy.geocoders import Photon - for provider in ["geocodefarm", GeocodeFarm]: - with mock.patch("geopy.geocoders.GeocodeFarm.geocode", ForwardMock()) as m: + for provider in ["photon", Photon]: + with mock.patch("geopy.geocoders.Photon.geocode", ForwardMock()) as m: g = geocode(locations, provider=provider, timeout=2) assert len(locations) == m.call_count @@ -141,10 +155,10 @@ def test_forward(locations, points): def test_reverse(locations, points): - from geopy.geocoders import GeocodeFarm + from geopy.geocoders import Photon - for provider in ["geocodefarm", GeocodeFarm]: - with mock.patch("geopy.geocoders.GeocodeFarm.reverse", ReverseMock()) as m: + for provider in ["photon", Photon]: + with mock.patch("geopy.geocoders.Photon.reverse", ReverseMock()) as m: g = reverse_geocode(points, provider=provider, timeout=2) assert len(points) == m.call_count diff --git a/geopandas/tests/test_geodataframe.py b/geopandas/tests/test_geodataframe.py index 8de7f3d..17a5a71 100644 --- a/geopandas/tests/test_geodataframe.py +++ b/geopandas/tests/test_geodataframe.py @@ -2,17 +2,21 @@ import json import os import shutil import tempfile +from packaging.version import Version import numpy as np import pandas as pd -import fiona +import pyproj +from pyproj import CRS from pyproj.exceptions import CRSError -from shapely.geometry import Point +from shapely.geometry import Point, Polygon import geopandas +import geopandas._compat as compat from geopandas import GeoDataFrame, GeoSeries, read_file from geopandas.array import GeometryArray, GeometryDtype, from_shapely +from geopandas._compat import ignore_shapely2_warnings from geopandas.testing import assert_geodataframe_equal, assert_geoseries_equal from geopandas.tests.util import PACKAGE_DIR, validate_boro_df @@ -20,6 +24,39 @@ from pandas.testing import assert_frame_equal, assert_index_equal, assert_series import pytest +PYPROJ_LT_3 = Version(pyproj.__version__) < Version("3") +TEST_NEAREST = compat.PYGEOS_GE_010 and compat.USE_PYGEOS +pandas_133 = Version(pd.__version__) == Version("1.3.3") + + +@pytest.fixture +def dfs(request): + s1 = GeoSeries( + [ + Polygon([(0, 0), (2, 0), (2, 2), (0, 2)]), + Polygon([(2, 2), (4, 2), (4, 4), (2, 4)]), + ] + ) + s2 = GeoSeries( + [ + Polygon([(1, 1), (3, 1), (3, 3), (1, 3)]), + Polygon([(3, 3), (5, 3), (5, 5), (3, 5)]), + ] + ) + df1 = GeoDataFrame({"col1": [1, 2], "geometry": s1}) + df2 = GeoDataFrame({"col2": [1, 2], "geometry": s2}) + return df1, df2 + + +@pytest.fixture( + params=["union", "intersection", "difference", "symmetric_difference", "identity"] +) +def how(request): + if pandas_133 and request.param in ["symmetric_difference", "identity", "union"]: + pytest.xfail("Regression in pandas 1.3.3 (GH #2101)") + return request.param + + class TestDataFrame: def setup_method(self): N = 10 @@ -35,7 +72,9 @@ class TestDataFrame: ], crs=self.crs, ) - self.df3 = read_file(os.path.join(PACKAGE_DIR, "examples", "null_geom.geojson")) + self.df3 = read_file( + os.path.join(PACKAGE_DIR, "geopandas", "tests", "data", "null_geom.geojson") + ) def teardown_method(self): shutil.rmtree(self.tempdir) @@ -209,6 +248,13 @@ class TestDataFrame: assert df2 is None assert self.df.geometry.name == "new_name" + # existing column error + msg = "Column named Shape_Area already exists" + with pytest.raises(ValueError, match=msg): + df2 = self.df.rename_geometry("Shape_Area") + with pytest.raises(ValueError, match=msg): + self.df.rename_geometry("Shape_Area", inplace=True) + def test_set_geometry(self): geom = GeoSeries([Point(x, y) for x, y in zip(range(5), range(5))]) original_geom = self.df.geometry @@ -351,6 +397,8 @@ class TestDataFrame: data = json.loads(text) assert data["type"] == "FeatureCollection" assert len(data["features"]) == 5 + assert "id" in data["features"][0].keys() + # check it converts to WGS84 coord = data["features"][0]["geometry"]["coordinates"][0][0][0] np.testing.assert_allclose(coord, [-74.0505080640324, 40.5664220341941]) @@ -379,6 +427,9 @@ class TestDataFrame: assert coord == [970217.0223999023, 145643.33221435547] @pytest.mark.filterwarnings("ignore::FutureWarning") + @pytest.mark.filterwarnings( + "ignore:Geometry column does not contain geometry:UserWarning" + ) def test_to_json_geom_col(self): df = self.df.copy() df["geom"] = df["geometry"] @@ -390,6 +441,13 @@ class TestDataFrame: assert data["type"] == "FeatureCollection" assert len(data["features"]) == 5 + @pytest.mark.filterwarnings("ignore::FutureWarning") + def test_to_json_only_geom_column(self): + text = self.df[["geometry"]].to_json() + data = json.loads(text) + assert len(data["features"]) == 5 + assert "id" in data["features"][0].keys() + @pytest.mark.filterwarnings("ignore::FutureWarning") def test_to_json_na(self): # Set a value as nan and make sure it's written @@ -453,6 +511,29 @@ class TestDataFrame: assert np.isnan(props["Shape_Leng"]) assert "Shape_Area" in props + def test_to_json_drop_id(self): + text = self.df.to_json(drop_id=True) + data = json.loads(text) + assert len(data["features"]) == 5 + for f in data["features"]: + assert "id" not in f.keys() + + def test_to_json_drop_id_only_geom_column(self): + text = self.df[["geometry"]].to_json(drop_id=True) + data = json.loads(text) + assert len(data["features"]) == 5 + for f in data["features"]: + assert "id" not in f.keys() + + def test_to_json_with_duplicate_columns(self): + df = GeoDataFrame( + data=[[1, 2, 3]], columns=["a", "b", "a"], geometry=[Point(1, 1)] + ) + with pytest.raises( + ValueError, match="GeoDataFrame cannot contain duplicated column names." + ): + df.to_json() + def test_copy(self): df2 = self.df.copy() assert type(df2) is GeoDataFrame @@ -481,6 +562,16 @@ class TestDataFrame: df = GeoDataFrame.from_file(tempfilename) assert df.crs == "epsg:2263" + def test_to_file_with_duplicate_columns(self): + df = GeoDataFrame( + data=[[1, 2, 3]], columns=["a", "b", "a"], geometry=[Point(1, 1)] + ) + with pytest.raises( + ValueError, match="GeoDataFrame cannot contain duplicated column names." + ): + tempfilename = os.path.join(self.tempdir, "crs.shp") + df.to_file(tempfilename) + def test_bool_index(self): # Find boros with 'B' in their name df = self.df[self.df["BoroName"].str.contains("B")] @@ -497,7 +588,18 @@ class TestDataFrame: assert_frame_equal(self.df2.loc[5:], self.df2.cx[:, 5:]) assert_frame_equal(self.df2.loc[5:], self.df2.cx[5:, 5:]) + def test_from_dict(self): + data = {"A": [1], "geometry": [Point(0.0, 0.0)]} + df = GeoDataFrame.from_dict(data, crs=3857) + assert df.crs == "epsg:3857" + assert df._geometry_column_name == "geometry" + + data = {"B": [1], "location": [Point(0.0, 0.0)]} + df = GeoDataFrame.from_dict(data, geometry="location") + assert df._geometry_column_name == "location" + def test_from_features(self): + fiona = pytest.importorskip("fiona") nybb_filename = geopandas.datasets.get_path("nybb") with fiona.open(nybb_filename) as f: features = list(f) @@ -581,7 +683,7 @@ class TestDataFrame: def test_dataframe_to_geodataframe(self): df = pd.DataFrame( - {"A": range(len(self.df)), "location": list(self.df.geometry)}, + {"A": range(len(self.df)), "location": np.array(self.df.geometry)}, index=self.df.index, ) gf = df.set_geometry("location", crs=self.df.crs) @@ -615,7 +717,7 @@ class TestDataFrame: df = self.df.iloc[:1].copy() df.loc[0, "BoroName"] = np.nan # when containing missing values - # null: ouput the missing entries as JSON null + # null: output the missing entries as JSON null result = list(df.iterfeatures(na="null"))[0]["properties"] assert result["BoroName"] is None # drop: remove the property from the feature. @@ -651,6 +753,14 @@ class TestDataFrame: result = list(df_only_numerical_cols.iterfeatures(na="keep"))[0] assert type(result["properties"]["Shape_Leng"]) is float + with pytest.raises( + ValueError, match="GeoDataFrame cannot contain duplicated column names." + ): + df_with_duplicate_columns = df[ + ["Shape_Leng", "Shape_Leng", "Shape_Area", "geometry"] + ] + list(df_with_duplicate_columns.iterfeatures()) + # geometry not set df = GeoDataFrame({"values": [0, 1], "geom": [Point(0, 1), Point(1, 0)]}) with pytest.raises(AttributeError): @@ -683,6 +793,123 @@ class TestDataFrame: assert_frame_equal(self.df, unpickled) assert self.df.crs == unpickled.crs + def test_estimate_utm_crs(self): + if PYPROJ_LT_3: + with pytest.raises(RuntimeError, match=r"pyproj 3\+ required"): + self.df.estimate_utm_crs() + else: + assert self.df.estimate_utm_crs() == CRS("EPSG:32618") + assert self.df.estimate_utm_crs("NAD83") == CRS("EPSG:26918") + + def test_to_wkb(self): + wkbs0 = [ + ( + b"\x01\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00" + b"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + ), # POINT (0 0) + ( + b"\x01\x01\x00\x00\x00\x00\x00\x00\x00\x00" + b"\x00\xf0?\x00\x00\x00\x00\x00\x00\xf0?" + ), # POINT (1 1) + ] + wkbs1 = [ + ( + b"\x01\x01\x00\x00\x00\x00\x00\x00\x00\x00" + b"\x00\x00@\x00\x00\x00\x00\x00\x00\x00@" + ), # POINT (2 2) + ( + b"\x01\x01\x00\x00\x00\x00\x00\x00\x00\x00" + b"\x00\x08@\x00\x00\x00\x00\x00\x00\x08@" + ), # POINT (3 3) + ] + gs0 = GeoSeries.from_wkb(wkbs0) + gs1 = GeoSeries.from_wkb(wkbs1) + gdf = GeoDataFrame({"geom_col0": gs0, "geom_col1": gs1}) + + expected_df = pd.DataFrame({"geom_col0": wkbs0, "geom_col1": wkbs1}) + assert_frame_equal(expected_df, gdf.to_wkb()) + + def test_to_wkt(self): + wkts0 = ["POINT (0 0)", "POINT (1 1)"] + wkts1 = ["POINT (2 2)", "POINT (3 3)"] + gs0 = GeoSeries.from_wkt(wkts0) + gs1 = GeoSeries.from_wkt(wkts1) + gdf = GeoDataFrame({"gs0": gs0, "gs1": gs1}) + + expected_df = pd.DataFrame({"gs0": wkts0, "gs1": wkts1}) + assert_frame_equal(expected_df, gdf.to_wkt()) + + @pytest.mark.parametrize("how", ["left", "inner", "right"]) + @pytest.mark.parametrize("predicate", ["intersects", "within", "contains"]) + @pytest.mark.skipif( + not compat.USE_PYGEOS and not compat.HAS_RTREE, + reason="sjoin needs `rtree` or `pygeos` dependency", + ) + def test_sjoin(self, how, predicate): + """ + Basic test for availability of the GeoDataFrame method. Other + sjoin tests are located in /tools/tests/test_sjoin.py + """ + left = read_file(geopandas.datasets.get_path("naturalearth_cities")) + right = read_file(geopandas.datasets.get_path("naturalearth_lowres")) + + expected = geopandas.sjoin(left, right, how=how, predicate=predicate) + result = left.sjoin(right, how=how, predicate=predicate) + assert_geodataframe_equal(result, expected) + + @pytest.mark.parametrize("how", ["left", "inner", "right"]) + @pytest.mark.parametrize("max_distance", [None, 1]) + @pytest.mark.parametrize("distance_col", [None, "distance"]) + @pytest.mark.skipif( + not TEST_NEAREST, + reason=( + "PyGEOS >= 0.10.0" + " must be installed and activated via the geopandas.compat module to" + " test sjoin_nearest" + ), + ) + def test_sjoin_nearest(self, how, max_distance, distance_col): + """ + Basic test for availability of the GeoDataFrame method. Other + sjoin tests are located in /tools/tests/test_sjoin.py + """ + left = read_file(geopandas.datasets.get_path("naturalearth_cities")) + right = read_file(geopandas.datasets.get_path("naturalearth_lowres")) + + expected = geopandas.sjoin_nearest( + left, right, how=how, max_distance=max_distance, distance_col=distance_col + ) + result = left.sjoin_nearest( + right, how=how, max_distance=max_distance, distance_col=distance_col + ) + assert_geodataframe_equal(result, expected) + + @pytest.mark.skip_no_sindex + def test_clip(self): + """ + Basic test for availability of the GeoDataFrame method. Other + clip tests are located in /tools/tests/test_clip.py + """ + left = read_file(geopandas.datasets.get_path("naturalearth_cities")) + world = read_file(geopandas.datasets.get_path("naturalearth_lowres")) + south_america = world[world["continent"] == "South America"] + + expected = geopandas.clip(left, south_america) + result = left.clip(south_america) + assert_geodataframe_equal(result, expected) + + @pytest.mark.skip_no_sindex + def test_overlay(self, dfs, how): + """ + Basic test for availability of the GeoDataFrame method. Other + overlay tests are located in tests/test_overlay.py + """ + df1, df2 = dfs + + expected = geopandas.overlay(df1, df2, how=how) + result = df1.overlay(df2, how=how) + assert_geodataframe_equal(result, expected) + def check_geodataframe(df, geometry_column="geometry"): assert isinstance(df, GeoDataFrame) @@ -784,7 +1011,8 @@ class TestConstructor: "B": np.arange(3.0), "geometry": [Point(x, x) for x in range(3)], } - a = np.array([data["A"], data["B"], data["geometry"]], dtype=object).T + with ignore_shapely2_warnings(): + a = np.array([data["A"], data["B"], data["geometry"]], dtype=object).T df = GeoDataFrame(a, columns=["A", "B", "geometry"]) check_geodataframe(df) @@ -799,7 +1027,8 @@ class TestConstructor: "geometry": [Point(x, x) for x in range(3)], } gpdf = GeoDataFrame(data) - pddf = pd.DataFrame(data) + with ignore_shapely2_warnings(): + pddf = pd.DataFrame(data) check_geodataframe(gpdf) assert type(pddf) == pd.DataFrame @@ -829,17 +1058,16 @@ class TestConstructor: gpdf = GeoDataFrame(data, geometry="other_geom") check_geodataframe(gpdf, "other_geom") - pddf = pd.DataFrame(data) + with ignore_shapely2_warnings(): + pddf = pd.DataFrame(data) for df in [gpdf, pddf]: res = GeoDataFrame(df, geometry="other_geom") check_geodataframe(res, "other_geom") - # when passing GeoDataFrame with custom geometry name to constructor - # an invalid geodataframe is the result TODO is this desired ? + # gdf from gdf should preserve active geometry column name df = GeoDataFrame(gpdf) - with pytest.raises(AttributeError): - df.geometry + check_geodataframe(df, "other_geom") def test_only_geometry(self): exp = GeoDataFrame( @@ -915,13 +1143,32 @@ class TestConstructor: def test_overwrite_geometry(self): # GH602 data = pd.DataFrame({"geometry": [1, 2, 3], "col1": [4, 5, 6]}) - geoms = pd.Series([Point(i, i) for i in range(3)]) + with ignore_shapely2_warnings(): + geoms = pd.Series([Point(i, i) for i in range(3)]) # passed geometry kwarg should overwrite geometry column in data res = GeoDataFrame(data, geometry=geoms) assert_geoseries_equal(res.geometry, GeoSeries(geoms)) + def test_repeat_geo_col(self): + df = pd.DataFrame( + [ + {"geometry": Point(x, y), "geom": Point(x, y)} + for x, y in zip(range(3), range(3)) + ], + ) + # explicitly prevent construction of gdf with repeat geometry column names + # two columns called "geometry", geom col inferred + df2 = df.rename(columns={"geom": "geometry"}) + with pytest.raises(ValueError): + GeoDataFrame(df2) + # ensure case is caught when custom geom column name is used + # two columns called "geom", geom col explicit + df3 = df.rename(columns={"geometry": "geom"}) + with pytest.raises(ValueError): + GeoDataFrame(df3, geometry="geom") + def test_geodataframe_crs(): - gdf = GeoDataFrame() + gdf = GeoDataFrame(columns=["geometry"]) gdf.crs = "IGNF:ETRS89UTM28" assert gdf.crs.to_authority() == ("IGNF", "ETRS89UTM28") diff --git a/geopandas/tests/test_geom_methods.py b/geopandas/tests/test_geom_methods.py index e5e021d..05475a9 100644 --- a/geopandas/tests/test_geom_methods.py +++ b/geopandas/tests/test_geom_methods.py @@ -2,15 +2,17 @@ import string import numpy as np from numpy.testing import assert_array_equal -from pandas import DataFrame, MultiIndex, Series +from pandas import DataFrame, Index, MultiIndex, Series from shapely.geometry import LinearRing, LineString, MultiPoint, Point, Polygon from shapely.geometry.collection import GeometryCollection from shapely.ops import unary_union +from shapely import wkt from geopandas import GeoDataFrame, GeoSeries from geopandas.base import GeoPandasBase +from geopandas.testing import assert_geodataframe_equal from geopandas.tests.util import assert_geoseries_equal, geom_almost_equals, geom_equals from geopandas import _compat as compat from pandas.testing import assert_frame_equal, assert_series_equal @@ -29,7 +31,10 @@ class TestGeomMethods: self.t1 = Polygon([(0, 0), (1, 0), (1, 1)]) self.t2 = Polygon([(0, 0), (1, 1), (0, 1)]) self.t3 = Polygon([(2, 0), (3, 0), (3, 1)]) + self.tz = Polygon([(1, 1, 1), (2, 2, 2), (3, 3, 3)]) + self.tz1 = Polygon([(2, 2, 2), (1, 1, 1), (3, 3, 3)]) self.sq = Polygon([(0, 0), (1, 0), (1, 1), (0, 1)]) + self.sqz = Polygon([(1, 1, 1), (2, 2, 2), (3, 3, 3), (4, 4, 4)]) self.t4 = Polygon([(0, 0), (3, 0), (3, 3), (0, 2)]) self.t5 = Polygon([(2, 0), (3, 0), (3, 3), (2, 3)]) self.inner_sq = Polygon( @@ -52,6 +57,7 @@ class TestGeomMethods: self.g1 = GeoSeries([self.t1, self.sq]) self.g2 = GeoSeries([self.sq, self.t1]) self.g3 = GeoSeries([self.t1, self.t2]) + self.gz = GeoSeries([self.tz, self.sqz, self.tz1]) self.g3.crs = "epsg:4326" self.g4 = GeoSeries([self.t2, self.t1]) self.g4.crs = "epsg:4326" @@ -62,9 +68,15 @@ class TestGeomMethods: self.a1.index = ["A", "B"] self.a2 = self.g2.copy() self.a2.index = ["B", "C"] - self.esb = Point(-73.9847, 40.7484) - self.sol = Point(-74.0446, 40.6893) + self.esb = Point(-73.9847, 40.7484, 30.3244) + self.sol = Point(-74.0446, 40.6893, 31.2344) self.landmarks = GeoSeries([self.esb, self.sol], crs="epsg:4326") + self.pt2d = Point(-73.9847, 40.7484) + self.landmarks_mixed = GeoSeries([self.esb, self.sol, self.pt2d], crs=4326) + self.pt_empty = wkt.loads("POINT EMPTY") + self.landmarks_mixed_empty = GeoSeries( + [self.esb, self.sol, self.pt2d, self.pt_empty], crs=4326 + ) self.l1 = LineString([(0, 0), (0, 1), (1, 1)]) self.l2 = LineString([(0, 0), (1, 0), (1, 1), (0, 1)]) self.g5 = GeoSeries([self.l1, self.l2]) @@ -74,6 +86,7 @@ class TestGeomMethods: self.empty = GeoSeries([]) self.all_none = GeoSeries([None, None]) self.empty_poly = Polygon() + self.g9 = GeoSeries(self.g0, index=range(1, 8)) # Crossed lines self.l3 = LineString([(0, 0), (1, 1)]) @@ -91,9 +104,12 @@ class TestGeomMethods: self.gdf3 = GeoDataFrame( {"geometry": self.g3, "col3": [4, 5], "col4": ["rand", "string"]} ) + self.gdfz = GeoDataFrame( + {"geometry": self.gz, "col3": [4, 5, 6], "col4": ["rand", "string", "geo"]} + ) def _test_unary_real(self, op, expected, a): - """ Tests for 'area', 'length', 'is_valid', etc. """ + """Tests for 'area', 'length', 'is_valid', etc.""" fcmp = assert_series_equal self._test_unary(op, expected, a, fcmp) @@ -108,7 +124,7 @@ class TestGeomMethods: self._test_unary(op, expected, a, fcmp) def _test_binary_topological(self, op, expected, a, b, *args, **kwargs): - """ Tests for 'intersection', 'union', 'symmetric_difference', etc. """ + """Tests for 'intersection', 'union', 'symmetric_difference', etc.""" if isinstance(expected, GeoPandasBase): fcmp = assert_geoseries_equal else: @@ -218,7 +234,7 @@ class TestGeomMethods: result = getattr(gdf, op) fcmp(result, expected) - # TODO reenable for all operations once we use pyproj > 2 + # TODO re-enable for all operations once we use pyproj > 2 # def test_crs_warning(self): # # operations on geometries should warn for different CRS # no_crs_g3 = self.g3.copy() @@ -234,15 +250,27 @@ class TestGeomMethods: "intersection", self.all_none, self.g1, self.empty ) + with pytest.warns(UserWarning, match="The indices .+ different"): + assert len(self.g0.intersection(self.g9, align=True) == 8) + assert len(self.g0.intersection(self.g9, align=False) == 7) + def test_union_series(self): self._test_binary_topological("union", self.sq, self.g1, self.g2) + with pytest.warns(UserWarning, match="The indices .+ different"): + assert len(self.g0.union(self.g9, align=True) == 8) + assert len(self.g0.union(self.g9, align=False) == 7) + def test_union_polygon(self): self._test_binary_topological("union", self.sq, self.g1, self.t2) def test_symmetric_difference_series(self): self._test_binary_topological("symmetric_difference", self.sq, self.g3, self.g4) + with pytest.warns(UserWarning, match="The indices .+ different"): + assert len(self.g0.symmetric_difference(self.g9, align=True) == 8) + assert len(self.g0.symmetric_difference(self.g9, align=False) == 7) + def test_symmetric_difference_poly(self): expected = GeoSeries([GeometryCollection(), self.sq], crs=self.g3.crs) self._test_binary_topological( @@ -253,6 +281,10 @@ class TestGeomMethods: expected = GeoSeries([GeometryCollection(), self.t2]) self._test_binary_topological("difference", expected, self.g1, self.g2) + with pytest.warns(UserWarning, match="The indices .+ different"): + assert len(self.g0.difference(self.g9, align=True) == 8) + assert len(self.g0.difference(self.g9, align=False) == 7) + def test_difference_poly(self): expected = GeoSeries([self.t1, self.t1]) self._test_binary_topological("difference", expected, self.g1, self.t2) @@ -267,7 +299,7 @@ class TestGeomMethods: # binary geo empty result with right GeoSeries result = GeoSeries([l1]).intersection(GeoSeries([l2])) assert_geoseries_equal(result, expected) - # unary geo resulting in emtpy geometry + # unary geo resulting in empty geometry result = GeoSeries([GeometryCollection()]).convex_hull assert_geoseries_equal(result, expected) @@ -327,10 +359,33 @@ class TestGeomMethods: self._test_unary_topological("unary_union", expected, g) + g2 = GeoSeries([p1, None]) + self._test_unary_topological("unary_union", p1, g2) + + g3 = GeoSeries([None, None]) + assert g3.unary_union is None + + def test_cascaded_union_deprecated(self): + p1 = self.t1 + p2 = Polygon([(2, 0), (3, 0), (3, 1)]) + g = GeoSeries([p1, p2]) + with pytest.warns( + FutureWarning, match="The 'cascaded_union' attribute is deprecated" + ): + result = g.cascaded_union + assert result == g.unary_union + def test_contains(self): expected = [True, False, True, False, False, False, False] assert_array_dtype_equal(expected, self.g0.contains(self.t1)) + expected = [False, True, True, True, True, True, False, False] + with pytest.warns(UserWarning, match="The indices .+ different"): + assert_array_dtype_equal(expected, self.g0.contains(self.g9, align=True)) + + expected = [False, False, True, False, False, False, False] + assert_array_dtype_equal(expected, self.g0.contains(self.g9, align=False)) + def test_length(self): expected = Series(np.array([2 + np.sqrt(2), 4]), index=self.g1.index) self._test_unary_real("length", expected, self.g1) @@ -349,10 +404,24 @@ class TestGeomMethods: expected = [False, True] assert_array_dtype_equal(expected, self.crossed_lines.crosses(self.l3)) + expected = [False] * 8 + with pytest.warns(UserWarning, match="The indices .+ different"): + assert_array_dtype_equal(expected, self.g0.crosses(self.g9, align=True)) + + expected = [False] * 7 + assert_array_dtype_equal(expected, self.g0.crosses(self.g9, align=False)) + def test_disjoint(self): expected = [False, False, False, False, False, True, False] assert_array_dtype_equal(expected, self.g0.disjoint(self.t1)) + expected = [False] * 8 + with pytest.warns(UserWarning, match="The indices .+ different"): + assert_array_dtype_equal(expected, self.g0.disjoint(self.g9, align=True)) + + expected = [False, False, False, False, True, False, False] + assert_array_dtype_equal(expected, self.g0.disjoint(self.g9, align=False)) + def test_relate(self): expected = Series( [ @@ -371,6 +440,37 @@ class TestGeomMethods: expected = Series(["FF0FFF212", None], index=self.g6.index) assert_array_dtype_equal(expected, self.g6.relate(self.na_none)) + expected = Series( + [ + None, + "2FFF1FFF2", + "2FFF1FFF2", + "2FFF1FFF2", + "2FFF1FFF2", + "0FFFFFFF2", + None, + None, + ], + index=range(8), + ) + + with pytest.warns(UserWarning, match="The indices .+ different"): + assert_array_dtype_equal(expected, self.g0.relate(self.g9, align=True)) + + expected = Series( + [ + "FF2F11212", + "2FF11F212", + "212FF1FF2", + "FF2F1F212", + "FF2FF10F2", + None, + None, + ], + index=self.g0.index, + ) + assert_array_dtype_equal(expected, self.g0.relate(self.g9, align=False)) + def test_distance(self): expected = Series( np.array([np.sqrt((5 - 1) ** 2 + (5 - 1) ** 2), np.nan]), self.na_none.index @@ -380,6 +480,14 @@ class TestGeomMethods: expected = Series(np.array([np.sqrt(4 ** 2 + 4 ** 2), np.nan]), self.g6.index) assert_array_dtype_equal(expected, self.g6.distance(self.na_none)) + expected = Series(np.array([np.nan, 0, 0, 0, 0, 0, np.nan, np.nan]), range(8)) + with pytest.warns(UserWarning, match="The indices .+ different"): + assert_array_dtype_equal(expected, self.g0.distance(self.g9, align=True)) + + val = self.g0.iloc[4].distance(self.g9.iloc[4]) + expected = Series(np.array([0, 0, 0, 0, val, np.nan, np.nan]), self.g0.index) + assert_array_dtype_equal(expected, self.g0.distance(self.g9, align=False)) + def test_distance_crs_warning(self): with pytest.warns(UserWarning, match="Geometry is in a geographic CRS"): self.g4.distance(self.p0) @@ -400,6 +508,13 @@ class TestGeomMethods: expected = [False] * 7 assert_array_dtype_equal(expected, self.g0.intersects(self.empty_poly)) + expected = [False, True, True, True, True, True, False, False] + with pytest.warns(UserWarning, match="The indices .+ different"): + assert_array_dtype_equal(expected, self.g0.intersects(self.g9, align=True)) + + expected = [True, True, True, True, False, False, False] + assert_array_dtype_equal(expected, self.g0.intersects(self.g9, align=False)) + def test_overlaps(self): expected = [True, True, False, False, False, False, False] assert_array_dtype_equal(expected, self.g0.overlaps(self.inner_sq)) @@ -407,10 +522,24 @@ class TestGeomMethods: expected = [False, False] assert_array_dtype_equal(expected, self.g4.overlaps(self.t1)) + expected = [False] * 8 + with pytest.warns(UserWarning, match="The indices .+ different"): + assert_array_dtype_equal(expected, self.g0.overlaps(self.g9, align=True)) + + expected = [False] * 7 + assert_array_dtype_equal(expected, self.g0.overlaps(self.g9, align=False)) + def test_touches(self): expected = [False, True, False, False, False, False, False] assert_array_dtype_equal(expected, self.g0.touches(self.t1)) + expected = [False] * 8 + with pytest.warns(UserWarning, match="The indices .+ different"): + assert_array_dtype_equal(expected, self.g0.touches(self.g9, align=True)) + + expected = [True, False, False, True, False, False, False] + assert_array_dtype_equal(expected, self.g0.touches(self.g9, align=False)) + def test_within(self): expected = [True, False, False, False, False, False, False] assert_array_dtype_equal(expected, self.g0.within(self.t1)) @@ -418,6 +547,13 @@ class TestGeomMethods: expected = [True, True, True, True, True, False, False] assert_array_dtype_equal(expected, self.g0.within(self.sq)) + expected = [False, True, True, True, True, True, False, False] + with pytest.warns(UserWarning, match="The indices .+ different"): + assert_array_dtype_equal(expected, self.g0.within(self.g9, align=True)) + + expected = [False, True, False, False, False, False, False] + assert_array_dtype_equal(expected, self.g0.within(self.g9, align=False)) + def test_covers_itself(self): # Each polygon in a Series covers itself res = self.g1.covers(self.g1) @@ -429,6 +565,13 @@ class TestGeomMethods: exp = Series([True, False]) assert_series_equal(res, exp) + expected = [False, True, True, True, True, True, False, False] + with pytest.warns(UserWarning, match="The indices .+ different"): + assert_array_dtype_equal(expected, self.g0.covers(self.g9, align=True)) + + expected = [False, False, True, False, False, False, False] + assert_array_dtype_equal(expected, self.g0.covers(self.g9, align=False)) + def test_covers_inverse(self): res = self.g8.covers(self.g7) exp = Series([False, False]) @@ -443,6 +586,13 @@ class TestGeomMethods: exp = Series([True, True]) assert_series_equal(res, exp) + expected = [False, True, True, True, True, True, False, False] + with pytest.warns(UserWarning, match="The indices .+ different"): + assert_array_dtype_equal(expected, self.g0.covered_by(self.g9, align=True)) + + expected = [False, True, False, False, False, False, False] + assert_array_dtype_equal(expected, self.g0.covered_by(self.g9, align=False)) + def test_is_valid(self): expected = Series(np.array([True] * len(self.g1)), self.g1.index) self._test_unary_real("is_valid", expected, self.g1) @@ -451,6 +601,8 @@ class TestGeomMethods: expected = Series(np.array([False] * len(self.g1)), self.g1.index) self._test_unary_real("is_empty", expected, self.g1) + # for is_ring we raise a warning about the value for Polygon changing + @pytest.mark.filterwarnings("ignore:is_ring:FutureWarning") def test_is_ring(self): expected = Series(np.array([True] * len(self.g1)), self.g1.index) self._test_unary_real("is_ring", expected, self.g1) @@ -463,20 +615,38 @@ class TestGeomMethods: expected = Series([False, True], self.g_3d.index) self._test_unary_real("has_z", expected, self.g_3d) - def test_xy_points(self): + def test_xyz_points(self): expected_x = [-73.9847, -74.0446] expected_y = [40.7484, 40.6893] + expected_z = [30.3244, 31.2344] assert_array_dtype_equal(expected_x, self.landmarks.geometry.x) assert_array_dtype_equal(expected_y, self.landmarks.geometry.y) + assert_array_dtype_equal(expected_z, self.landmarks.geometry.z) - def test_xy_polygons(self): + # mixed dimensions + expected_z = [30.3244, 31.2344, np.nan] + assert_array_dtype_equal(expected_z, self.landmarks_mixed.geometry.z) + + def test_xyz_points_empty(self): + expected_x = [-73.9847, -74.0446, -73.9847, np.nan] + expected_y = [40.7484, 40.6893, 40.7484, np.nan] + expected_z = [30.3244, 31.2344, np.nan, np.nan] + + assert_array_dtype_equal(expected_x, self.landmarks_mixed_empty.geometry.x) + assert_array_dtype_equal(expected_y, self.landmarks_mixed_empty.geometry.y) + assert_array_dtype_equal(expected_z, self.landmarks_mixed_empty.geometry.z) + + def test_xyz_polygons(self): # accessing x attribute in polygon geoseries should raise an error with pytest.raises(ValueError): _ = self.gdf1.geometry.x # and same for accessing y attribute in polygon geoseries with pytest.raises(ValueError): _ = self.gdf1.geometry.y + # and same for accessing z attribute in polygon geoseries + with pytest.raises(ValueError): + _ = self.gdfz.geometry.z def test_centroid(self): polygon = Polygon([(-1, -1), (1, -1), (1, 1), (-1, 1)]) @@ -553,6 +723,14 @@ class TestGeomMethods: expected = Series([1.0, 0.5], index=self.g5.index) self._test_binary_real("project", expected, self.g5, p, normalized=True) + s = GeoSeries([Point(2, 2), Point(0.5, 0.5)], index=[1, 2]) + expected = Series([np.nan, 2.0, np.nan]) + with pytest.warns(UserWarning, match="The indices .+ different"): + assert_series_equal(self.g5.project(s), expected) + + expected = Series([2.0, 0.5], index=self.g5.index) + assert_series_equal(self.g5.project(s, align=False), expected) + def test_affine_transform(self): # 45 degree reflection matrix matrix = [0, 1, 1, 0, 0, 0] @@ -671,7 +849,8 @@ class TestGeomMethods: # do not warn for 0 self.g4.buffer(0) - assert len(record) == 0 + for r in record: + assert "Geometry is in a geographic CRS." not in str(r.message) def test_envelope(self): e = self.g3.envelope @@ -691,7 +870,8 @@ class TestGeomMethods: def test_explode_geoseries(self): s = GeoSeries( - [MultiPoint([(0, 0), (1, 1)]), MultiPoint([(2, 2), (3, 3), (4, 4)])] + [MultiPoint([(0, 0), (1, 1)]), MultiPoint([(2, 2), (3, 3), (4, 4)])], + crs=4326, ) s.index.name = "test_index_name" expected_index_name = ["test_index_name", None] @@ -699,8 +879,10 @@ class TestGeomMethods: expected = GeoSeries( [Point(0, 0), Point(1, 1), Point(2, 2), Point(3, 3), Point(4, 4)], index=MultiIndex.from_tuples(index, names=expected_index_name), + crs=4326, ) - assert_geoseries_equal(expected, s.explode()) + with pytest.warns(FutureWarning, match="Currently, index_parts defaults"): + assert_geoseries_equal(expected, s.explode()) @pytest.mark.parametrize("index_name", [None, "test"]) def test_explode_geodataframe(self, index_name): @@ -708,7 +890,8 @@ class TestGeomMethods: df = GeoDataFrame({"col": [1, 2], "geometry": s}) df.index.name = index_name - test_df = df.explode() + with pytest.warns(FutureWarning, match="Currently, index_parts defaults"): + test_df = df.explode() expected_s = GeoSeries([Point(1, 2), Point(2, 3), Point(5, 5)]) expected_df = GeoDataFrame({"col": [1, 1, 2], "geometry": expected_s}) @@ -727,7 +910,7 @@ class TestGeomMethods: df = GeoDataFrame({"level_1": [1, 2], "geometry": s}) df.index.name = index_name - test_df = df.explode() + test_df = df.explode(index_parts=True) expected_s = GeoSeries([Point(1, 2), Point(2, 3), Point(5, 5)]) expected_df = GeoDataFrame({"level_1": [1, 1, 2], "geometry": expected_s}) @@ -737,10 +920,293 @@ class TestGeomMethods: names=[index_name, None], ) expected_df = expected_df.set_index(expected_index) - if not compat.PANDAS_GE_024: - expected_df = expected_df[["level_1", "geometry"]] assert_frame_equal(test_df, expected_df) + @pytest.mark.parametrize("index_name", [None, "test"]) + def test_explode_geodataframe_no_multiindex(self, index_name): + # GH1393 + s = GeoSeries([MultiPoint([Point(1, 2), Point(2, 3)]), Point(5, 5)]) + df = GeoDataFrame({"level_1": [1, 2], "geometry": s}) + df.index.name = index_name + + test_df = df.explode(index_parts=False) + + expected_s = GeoSeries([Point(1, 2), Point(2, 3), Point(5, 5)]) + expected_df = GeoDataFrame({"level_1": [1, 1, 2], "geometry": expected_s}) + + expected_index = Index([0, 0, 1], name=index_name) + expected_df = expected_df.set_index(expected_index) + assert_frame_equal(test_df, expected_df) + + def test_explode_pandas_fallback(self): + d = { + "col1": [["name1", "name2"], ["name3", "name4"]], + "geometry": [MultiPoint([(1, 2), (3, 4)]), MultiPoint([(2, 1), (0, 0)])], + } + gdf = GeoDataFrame(d, crs=4326) + expected_df = GeoDataFrame( + { + "col1": ["name1", "name2", "name3", "name4"], + "geometry": [ + MultiPoint([(1, 2), (3, 4)]), + MultiPoint([(1, 2), (3, 4)]), + MultiPoint([(2, 1), (0, 0)]), + MultiPoint([(2, 1), (0, 0)]), + ], + }, + index=[0, 0, 1, 1], + crs=4326, + ) + + # Test with column provided as arg + exploded_df = gdf.explode("col1") + assert_geodataframe_equal(exploded_df, expected_df) + + # Test with column provided as kwarg + exploded_df = gdf.explode(column="col1") + assert_geodataframe_equal(exploded_df, expected_df) + + @pytest.mark.skipif( + not compat.PANDAS_GE_11, + reason="ignore_index keyword introduced in pandas 1.1.0", + ) + def test_explode_pandas_fallback_ignore_index(self): + d = { + "col1": [["name1", "name2"], ["name3", "name4"]], + "geometry": [MultiPoint([(1, 2), (3, 4)]), MultiPoint([(2, 1), (0, 0)])], + } + gdf = GeoDataFrame(d, crs=4326) + expected_df = GeoDataFrame( + { + "col1": ["name1", "name2", "name3", "name4"], + "geometry": [ + MultiPoint([(1, 2), (3, 4)]), + MultiPoint([(1, 2), (3, 4)]), + MultiPoint([(2, 1), (0, 0)]), + MultiPoint([(2, 1), (0, 0)]), + ], + }, + crs=4326, + ) + + # Test with column provided as arg + exploded_df = gdf.explode("col1", ignore_index=True) + assert_geodataframe_equal(exploded_df, expected_df) + + # Test with column provided as kwarg + exploded_df = gdf.explode(column="col1", ignore_index=True) + assert_geodataframe_equal(exploded_df, expected_df) + + @pytest.mark.parametrize("outer_index", [1, (1, 2), "1"]) + def test_explode_pandas_multi_index(self, outer_index): + index = MultiIndex.from_arrays( + [[outer_index, outer_index, outer_index], [1, 2, 3]], + names=("first", "second"), + ) + df = GeoDataFrame( + {"vals": [1, 2, 3]}, + geometry=[MultiPoint([(x, x), (x, 0)]) for x in range(3)], + index=index, + ) + + test_df = df.explode(index_parts=True) + + expected_s = GeoSeries( + [ + Point(0, 0), + Point(0, 0), + Point(1, 1), + Point(1, 0), + Point(2, 2), + Point(2, 0), + ] + ) + expected_df = GeoDataFrame({"vals": [1, 1, 2, 2, 3, 3], "geometry": expected_s}) + expected_index = MultiIndex.from_tuples( + [ + (outer_index, *pair) + for pair in [(1, 0), (1, 1), (2, 0), (2, 1), (3, 0), (3, 1)] + ], + names=["first", "second", None], + ) + expected_df = expected_df.set_index(expected_index) + assert_frame_equal(test_df, expected_df) + + @pytest.mark.parametrize("outer_index", [1, (1, 2), "1"]) + def test_explode_pandas_multi_index_false(self, outer_index): + index = MultiIndex.from_arrays( + [[outer_index, outer_index, outer_index], [1, 2, 3]], + names=("first", "second"), + ) + df = GeoDataFrame( + {"vals": [1, 2, 3]}, + geometry=[MultiPoint([(x, x), (x, 0)]) for x in range(3)], + index=index, + ) + + test_df = df.explode(index_parts=False) + + expected_s = GeoSeries( + [ + Point(0, 0), + Point(0, 0), + Point(1, 1), + Point(1, 0), + Point(2, 2), + Point(2, 0), + ] + ) + expected_df = GeoDataFrame({"vals": [1, 1, 2, 2, 3, 3], "geometry": expected_s}) + expected_index = MultiIndex.from_tuples( + [ + (outer_index, 1), + (outer_index, 1), + (outer_index, 2), + (outer_index, 2), + (outer_index, 3), + (outer_index, 3), + ], + names=["first", "second"], + ) + expected_df = expected_df.set_index(expected_index) + assert_frame_equal(test_df, expected_df) + + @pytest.mark.parametrize("outer_index", [1, (1, 2), "1"]) + def test_explode_pandas_multi_index_ignore_index(self, outer_index): + index = MultiIndex.from_arrays( + [[outer_index, outer_index, outer_index], [1, 2, 3]], + names=("first", "second"), + ) + df = GeoDataFrame( + {"vals": [1, 2, 3]}, + geometry=[MultiPoint([(x, x), (x, 0)]) for x in range(3)], + index=index, + ) + + test_df = df.explode(ignore_index=True) + + expected_s = GeoSeries( + [ + Point(0, 0), + Point(0, 0), + Point(1, 1), + Point(1, 0), + Point(2, 2), + Point(2, 0), + ] + ) + expected_df = GeoDataFrame({"vals": [1, 1, 2, 2, 3, 3], "geometry": expected_s}) + expected_index = Index(range(len(expected_df))) + expected_df = expected_df.set_index(expected_index) + assert_frame_equal(test_df, expected_df) + + # index_parts is ignored if ignore_index=True + test_df = df.explode(ignore_index=True, index_parts=True) + assert_frame_equal(test_df, expected_df) + + def test_explode_order(self): + df = GeoDataFrame( + {"vals": [1, 2, 3]}, + geometry=[MultiPoint([(x, x), (x, 0)]) for x in range(3)], + index=[2, 9, 7], + ) + test_df = df.explode(index_parts=True) + + expected_index = MultiIndex.from_arrays( + [[2, 2, 9, 9, 7, 7], [0, 1, 0, 1, 0, 1]], + ) + expected_geometry = GeoSeries( + [ + Point(0, 0), + Point(0, 0), + Point(1, 1), + Point(1, 0), + Point(2, 2), + Point(2, 0), + ], + index=expected_index, + ) + expected_df = GeoDataFrame( + {"vals": [1, 1, 2, 2, 3, 3]}, + geometry=expected_geometry, + index=expected_index, + ) + assert_geodataframe_equal(test_df, expected_df) + + def test_explode_order_no_multi(self): + df = GeoDataFrame( + {"vals": [1, 2, 3]}, + geometry=[Point(0, x) for x in range(3)], + index=[2, 9, 7], + ) + test_df = df.explode(index_parts=True) + + expected_index = MultiIndex.from_arrays( + [[2, 9, 7], [0, 0, 0]], + ) + expected_df = GeoDataFrame( + {"vals": [1, 2, 3]}, + geometry=[Point(0, x) for x in range(3)], + index=expected_index, + ) + assert_geodataframe_equal(test_df, expected_df) + + def test_explode_order_mixed(self): + df = GeoDataFrame( + {"vals": [1, 2, 3]}, + geometry=[MultiPoint([(x, x), (x, 0)]) for x in range(2)] + [Point(0, 10)], + index=[2, 9, 7], + ) + test_df = df.explode(index_parts=True) + + expected_index = MultiIndex.from_arrays( + [[2, 2, 9, 9, 7], [0, 1, 0, 1, 0]], + ) + expected_geometry = GeoSeries( + [ + Point(0, 0), + Point(0, 0), + Point(1, 1), + Point(1, 0), + Point(0, 10), + ], + index=expected_index, + ) + expected_df = GeoDataFrame( + {"vals": [1, 1, 2, 2, 3]}, + geometry=expected_geometry, + index=expected_index, + ) + assert_geodataframe_equal(test_df, expected_df) + + def test_explode_duplicated_index(self): + df = GeoDataFrame( + {"vals": [1, 2, 3]}, + geometry=[MultiPoint([(x, x), (x, 0)]) for x in range(3)], + index=[1, 1, 2], + ) + test_df = df.explode(index_parts=True) + expected_index = MultiIndex.from_arrays( + [[1, 1, 1, 1, 2, 2], [0, 1, 0, 1, 0, 1]], + ) + expected_geometry = GeoSeries( + [ + Point(0, 0), + Point(0, 0), + Point(1, 1), + Point(1, 0), + Point(2, 2), + Point(2, 0), + ], + index=expected_index, + ) + expected_df = GeoDataFrame( + {"vals": [1, 1, 2, 2, 3, 3]}, + geometry=expected_geometry, + index=expected_index, + ) + assert_geodataframe_equal(test_df, expected_df) + # # Test '&', '|', '^', and '-' # diff --git a/geopandas/tests/test_geoseries.py b/geopandas/tests/test_geoseries.py index 72b6f23..6d785d3 100644 --- a/geopandas/tests/test_geoseries.py +++ b/geopandas/tests/test_geoseries.py @@ -7,7 +7,9 @@ import tempfile import numpy as np from numpy.testing import assert_array_equal import pandas as pd +from pandas.util.testing import assert_index_equal +from pyproj import CRS from shapely.geometry import ( LineString, MultiLineString, @@ -18,8 +20,10 @@ from shapely.geometry import ( ) from shapely.geometry.base import BaseGeometry -from geopandas import GeoSeries, GeoDataFrame +from geopandas import GeoSeries, GeoDataFrame, read_file, datasets, clip +from geopandas._compat import PYPROJ_LT_3, ignore_shapely2_warnings from geopandas.array import GeometryArray, GeometryDtype +from geopandas.testing import assert_geoseries_equal from geopandas.tests.util import geom_equals from pandas.testing import assert_series_equal @@ -130,20 +134,38 @@ class TestSeries: def test_geom_equals_align(self): with pytest.warns(UserWarning, match="The indices .+ different"): - a = self.a1.geom_equals(self.a2) + a = self.a1.geom_equals(self.a2, align=True) exp = pd.Series([False, True, False], index=["A", "B", "C"]) assert_series_equal(a, exp) + a = self.a1.geom_equals(self.a2, align=False) + exp = pd.Series([False, False], index=["A", "B"]) + assert_series_equal(a, exp) + def test_geom_almost_equals(self): # TODO: test decimal parameter assert np.all(self.g1.geom_almost_equals(self.g1)) assert_array_equal(self.g1.geom_almost_equals(self.sq), [False, True]) + assert_array_equal( + self.a1.geom_almost_equals(self.a2, align=True), [False, True, False] + ) + assert_array_equal( + self.a1.geom_almost_equals(self.a2, align=False), [False, False] + ) + def test_geom_equals_exact(self): # TODO: test tolerance parameter assert np.all(self.g1.geom_equals_exact(self.g1, 0.001)) assert_array_equal(self.g1.geom_equals_exact(self.sq, 0.001), [False, True]) + assert_array_equal( + self.a1.geom_equals_exact(self.a2, 0.001, align=True), [False, True, False] + ) + assert_array_equal( + self.a1.geom_equals_exact(self.a2, 0.001, align=False), [False, False] + ) + def test_equal_comp_op(self): s = GeoSeries([Point(x, x) for x in range(3)]) res = s == Point(1, 1) @@ -151,7 +173,7 @@ class TestSeries: assert_series_equal(res, exp) def test_to_file(self): - """ Test to_file and from_file """ + """Test to_file and from_file""" tempfilename = os.path.join(self.tempdir, "test.shp") self.g3.to_file(tempfilename) # Read layer back in? @@ -182,6 +204,32 @@ class TestSeries: with pytest.raises(ValueError): self.landmarks.to_crs(crs=None, epsg=None) + def test_estimate_utm_crs__geographic(self): + if PYPROJ_LT_3: + with pytest.raises(RuntimeError, match=r"pyproj 3\+ required"): + self.landmarks.estimate_utm_crs() + else: + assert self.landmarks.estimate_utm_crs() == CRS("EPSG:32618") + assert self.landmarks.estimate_utm_crs("NAD83") == CRS("EPSG:26918") + + @pytest.mark.skipif(PYPROJ_LT_3, reason="requires pyproj 3 or higher") + def test_estimate_utm_crs__projected(self): + assert self.landmarks.to_crs("EPSG:3857").estimate_utm_crs() == CRS( + "EPSG:32618" + ) + + @pytest.mark.skipif(PYPROJ_LT_3, reason="requires pyproj 3 or higher") + def test_estimate_utm_crs__out_of_bounds(self): + with pytest.raises(RuntimeError, match="Unable to determine UTM CRS"): + GeoSeries( + [Polygon([(0, 90), (1, 90), (2, 90)])], crs="EPSG:4326" + ).estimate_utm_crs() + + @pytest.mark.skipif(PYPROJ_LT_3, reason="requires pyproj 3 or higher") + def test_estimate_utm_crs__missing_crs(self): + with pytest.raises(RuntimeError, match="crs must be set"): + GeoSeries([Polygon([(0, 90), (1, 90), (2, 90)])]).estimate_utm_crs() + def test_fillna(self): # default is to fill with empty geometry na = self.na_none.fillna() @@ -192,7 +240,7 @@ class TestSeries: # self.na_none.fillna(method='backfill') def test_coord_slice(self): - """ Test CoordinateSlicer """ + """Test CoordinateSlicer""" # need some better test cases assert geom_equals(self.g3, self.g3.cx[:, :]) assert geom_equals(self.g3[[True, False]], self.g3.cx[0.9:, :0.1]) @@ -215,35 +263,120 @@ class TestSeries: def test_proj4strings(self): # As string - reprojected = self.g3.to_crs("+proj=utm +zone=30N") + reprojected = self.g3.to_crs("+proj=utm +zone=30") reprojected_back = reprojected.to_crs(epsg=4326) assert np.all(self.g3.geom_almost_equals(reprojected_back)) # As dict - reprojected = self.g3.to_crs({"proj": "utm", "zone": "30N"}) + reprojected = self.g3.to_crs({"proj": "utm", "zone": "30"}) reprojected_back = reprojected.to_crs(epsg=4326) assert np.all(self.g3.geom_almost_equals(reprojected_back)) # Set to equivalent string, convert, compare to original copy = self.g3.copy() copy.crs = "epsg:4326" - reprojected = copy.to_crs({"proj": "utm", "zone": "30N"}) + reprojected = copy.to_crs({"proj": "utm", "zone": "30"}) reprojected_back = reprojected.to_crs(epsg=4326) assert np.all(self.g3.geom_almost_equals(reprojected_back)) # Conversions by different format - reprojected_string = self.g3.to_crs("+proj=utm +zone=30N") - reprojected_dict = self.g3.to_crs({"proj": "utm", "zone": "30N"}) + reprojected_string = self.g3.to_crs("+proj=utm +zone=30") + reprojected_dict = self.g3.to_crs({"proj": "utm", "zone": "30"}) assert np.all(reprojected_string.geom_almost_equals(reprojected_dict)) + def test_from_wkb(self): + assert_geoseries_equal(self.g1, GeoSeries.from_wkb([self.t1.wkb, self.sq.wkb])) -def test_missing_values_empty_warning(): - s = GeoSeries([Point(1, 1), None, np.nan, BaseGeometry(), Polygon()]) - with pytest.warns(UserWarning): - s.isna() + def test_from_wkb_series(self): + s = pd.Series([self.t1.wkb, self.sq.wkb], index=[1, 2]) + expected = self.g1.copy() + expected.index = pd.Index([1, 2]) + assert_geoseries_equal(expected, GeoSeries.from_wkb(s)) - with pytest.warns(UserWarning): - s.notna() + def test_from_wkb_series_with_index(self): + index = [0] + s = pd.Series([self.t1.wkb, self.sq.wkb], index=[0, 2]) + expected = self.g1.reindex(index) + assert_geoseries_equal(expected, GeoSeries.from_wkb(s, index=index)) + + def test_from_wkt(self): + assert_geoseries_equal(self.g1, GeoSeries.from_wkt([self.t1.wkt, self.sq.wkt])) + + def test_from_wkt_series(self): + s = pd.Series([self.t1.wkt, self.sq.wkt], index=[1, 2]) + expected = self.g1.copy() + expected.index = pd.Index([1, 2]) + assert_geoseries_equal(expected, GeoSeries.from_wkt(s)) + + def test_from_wkt_series_with_index(self): + index = [0] + s = pd.Series([self.t1.wkt, self.sq.wkt], index=[0, 2]) + expected = self.g1.reindex(index) + assert_geoseries_equal(expected, GeoSeries.from_wkt(s, index=index)) + + def test_to_wkb(self): + assert_series_equal(pd.Series([self.t1.wkb, self.sq.wkb]), self.g1.to_wkb()) + assert_series_equal( + pd.Series([self.t1.wkb_hex, self.sq.wkb_hex]), self.g1.to_wkb(hex=True) + ) + + def test_to_wkt(self): + assert_series_equal(pd.Series([self.t1.wkt, self.sq.wkt]), self.g1.to_wkt()) + + @pytest.mark.skip_no_sindex + def test_clip(self): + left = read_file(datasets.get_path("naturalearth_cities")) + world = read_file(datasets.get_path("naturalearth_lowres")) + south_america = world[world["continent"] == "South America"] + + expected = clip(left.geometry, south_america) + result = left.geometry.clip(south_america) + assert_geoseries_equal(result, expected) + + def test_from_xy_points(self): + x = self.landmarks.x.values + y = self.landmarks.y.values + index = self.landmarks.index.tolist() + crs = self.landmarks.crs + assert_geoseries_equal( + self.landmarks, GeoSeries.from_xy(x, y, index=index, crs=crs) + ) + assert_geoseries_equal( + self.landmarks, + GeoSeries.from_xy(self.landmarks.x, self.landmarks.y, crs=crs), + ) + + def test_from_xy_points_w_z(self): + index_values = [5, 6, 7] + x = pd.Series([0, -1, 2], index=index_values) + y = pd.Series([8, 3, 1], index=index_values) + z = pd.Series([5, -6, 7], index=index_values) + expected = GeoSeries( + [Point(0, 8, 5), Point(-1, 3, -6), Point(2, 1, 7)], index=index_values + ) + assert_geoseries_equal(expected, GeoSeries.from_xy(x, y, z)) + + def test_from_xy_points_unequal_index(self): + x = self.landmarks.x + y = self.landmarks.y + y.index = -np.arange(len(y)) + crs = self.landmarks.crs + assert_geoseries_equal( + self.landmarks, GeoSeries.from_xy(x, y, index=x.index, crs=crs) + ) + unindexed_landmarks = self.landmarks.copy() + unindexed_landmarks.reset_index(inplace=True, drop=True) + assert_geoseries_equal( + unindexed_landmarks, + GeoSeries.from_xy(x, y, crs=crs), + ) + + def test_from_xy_points_indexless(self): + x = np.array([0.0, 3.0]) + y = np.array([2.0, 5.0]) + z = np.array([-1.0, 4.0]) + expected = GeoSeries([Point(0, 2, -1), Point(3, 5, 4)]) + assert_geoseries_equal(expected, GeoSeries.from_xy(x, y, z)) @pytest.mark.filterwarnings("ignore::UserWarning") @@ -269,6 +402,13 @@ def test_missing_values(): assert len(s.dropna()) == 3 +def test_isna_empty_geoseries(): + # ensure that isna() result for empty GeoSeries has the correct bool dtype + s = GeoSeries([]) + result = s.isna() + assert_series_equal(result, pd.Series([], dtype="bool")) + + def test_geoseries_crs(): gs = GeoSeries() gs.crs = "IGNF:ETRS89UTM28" @@ -344,12 +484,49 @@ class TestConstructor: s = GeoSeries() check_geoseries(s) + def test_data_is_none(self): + s = GeoSeries(index=range(3)) + check_geoseries(s) + + def test_empty_array(self): + # with empty data that have an explicit dtype, we use the fallback or + # not depending on the dtype + arr = np.array([], dtype="bool") + + # dtypes that can never hold geometry-like data + for arr in [ + np.array([], dtype="bool"), + np.array([], dtype="int64"), + np.array([], dtype="float32"), + # this gets converted to object dtype by pandas + # np.array([], dtype="str"), + ]: + with pytest.warns(FutureWarning): + s = GeoSeries(arr) + assert not isinstance(s, GeoSeries) + assert type(s) == pd.Series + + # dtypes that can potentially hold geometry-like data (object) or + # can come from empty data (float64) + for arr in [ + np.array([], dtype="object"), + np.array([], dtype="float64"), + np.array([], dtype="str"), + ]: + with pytest.warns(None) as record: + s = GeoSeries(arr) + assert not record + assert isinstance(s, GeoSeries) + def test_from_series(self): shapes = [ Polygon([(random.random(), random.random()) for _ in range(3)]) for _ in range(10) ] - s = pd.Series(shapes, index=list("abcdefghij"), name="foo") + with ignore_shapely2_warnings(): + # the warning here is not suppressed by GeoPandas, as this is a pure + # pandas construction call + s = pd.Series(shapes, index=list("abcdefghij"), name="foo") g = GeoSeries(s) check_geoseries(g) @@ -362,6 +539,27 @@ class TestConstructor: s = GeoSeries( [MultiPoint([(0, 0), (1, 1)]), MultiPoint([(2, 2), (3, 3), (4, 4)])] ) - s = s.explode() + s = s.explode(index_parts=True) df = s.reset_index() assert type(df) == GeoDataFrame + + def test_explode_without_multiindex(self): + s = GeoSeries( + [MultiPoint([(0, 0), (1, 1)]), MultiPoint([(2, 2), (3, 3), (4, 4)])] + ) + s = s.explode(index_parts=False) + expected_index = pd.Index([0, 0, 1, 1, 1]) + assert_index_equal(s.index, expected_index) + + def test_explode_ignore_index(self): + s = GeoSeries( + [MultiPoint([(0, 0), (1, 1)]), MultiPoint([(2, 2), (3, 3), (4, 4)])] + ) + s = s.explode(ignore_index=True) + expected_index = pd.Index(range(len(s))) + print(expected_index) + assert_index_equal(s.index, expected_index) + + # index_parts is ignored if ignore_index=True + s = s.explode(index_parts=True, ignore_index=True) + assert_index_equal(s.index, expected_index) diff --git a/geopandas/tests/test_merge.py b/geopandas/tests/test_merge.py index d003b11..a0495ab 100644 --- a/geopandas/tests/test_merge.py +++ b/geopandas/tests/test_merge.py @@ -1,4 +1,6 @@ import pandas as pd +import pytest +from geopandas.testing import assert_geodataframe_equal from shapely.geometry import Point @@ -48,6 +50,13 @@ class TestMerging: assert isinstance(res, GeoDataFrame) assert isinstance(res.geometry, GeoSeries) self._check_metadata(res) + exp = GeoDataFrame(pd.concat([pd.DataFrame(self.gdf), pd.DataFrame(self.gdf)])) + assert_geodataframe_equal(exp, res) + # check metadata comes from first gdf + res4 = pd.concat([self.gdf.set_crs("epsg:4326"), self.gdf], axis=0) + # Note: this behaviour potentially does not make sense. If geom cols are + # concatenated but have different CRS, then the CRS will be overridden. + self._check_metadata(res4, crs="epsg:4326") # series res = pd.concat([self.gdf.geometry, self.gdf.geometry]) @@ -63,3 +72,28 @@ class TestMerging: assert isinstance(res, GeoDataFrame) assert isinstance(res.geometry, GeoSeries) self._check_metadata(res) + + def test_concat_axis1_multiple_geodataframes(self): + # https://github.com/geopandas/geopandas/issues/1230 + # Expect that concat should fail gracefully if duplicate column names belonging + # to geometry columns are introduced. + expected_err = ( + "GeoDataFrame does not support multiple columns using the geometry" + " column name 'geometry'" + ) + with pytest.raises(ValueError, match=expected_err): + pd.concat([self.gdf, self.gdf], axis=1) + + # Check case is handled if custom geometry column name is used + df2 = self.gdf.rename_geometry("geom") + expected_err2 = ( + "Concat operation has resulted in multiple columns using the geometry " + "column name 'geom'." + ) + with pytest.raises(ValueError, match=expected_err2): + pd.concat([df2, df2], axis=1) + + # Check that two geometry columns is fine, if they have different names + res3 = pd.concat([df2.set_crs("epsg:4326"), self.gdf], axis=1) + # check metadata comes from first df + self._check_metadata(res3, geometry_column_name="geom", crs="epsg:4326") diff --git a/geopandas/tests/test_op_output_types.py b/geopandas/tests/test_op_output_types.py new file mode 100644 index 0000000..3be6b35 --- /dev/null +++ b/geopandas/tests/test_op_output_types.py @@ -0,0 +1,216 @@ +import pandas as pd +import pyproj +import pytest + +from shapely.geometry import Point + +from geopandas import GeoDataFrame, GeoSeries + + +crs_osgb = pyproj.CRS(27700) +crs_wgs = pyproj.CRS(4326) + + +N = 10 + + +@pytest.fixture(params=["geometry", "point"]) +def df(request): + geo_name = request.param + + df = GeoDataFrame( + [ + { + "value1": x + y, + "value2": x * y, + geo_name: Point(x, y), # rename this col in tests + } + for x, y in zip(range(N), range(N)) + ], + crs=crs_wgs, + geometry=geo_name, + ) + # want geometry2 to be a GeoSeries not Series, test behaviour of non geom col + df["geometry2"] = df[geo_name].set_crs(crs_osgb, allow_override=True) + return df + + +def _check_metadata_gdf(gdf, geo_name="geometry", crs=crs_wgs): + assert gdf._geometry_column_name == geo_name + assert gdf.geometry.name == geo_name + assert gdf.crs == crs + + +def _check_metadata_gs(gs, name="geometry", crs=crs_wgs): + assert gs.name == name + assert gs.crs == crs + + +def assert_object(result, expected_type, geo_name="geometry", crs=crs_wgs): + """ + Helper method to make tests easier to read. Checks result is of the expected + type. If result is a GeoDataFrame or GeoSeries, checks geo_name + and crs match. If geo_name is None, then we expect a GeoDataFrame + where the geometry column is invalid/ isn't set. This is never desirable, + but is a reality of this first stage of implementation. + """ + assert type(result) is expected_type + + if expected_type == GeoDataFrame: + if geo_name is not None: + _check_metadata_gdf(result, geo_name=geo_name, crs=crs) + else: + with pytest.raises(AttributeError, match="No geometry data set yet"): + result.geometry.name # be explicit that geometry is invalid here + elif expected_type == GeoSeries: + _check_metadata_gs(result, name=geo_name, crs=crs) + + +def test_getitem(df): + geo_name = df.geometry.name + assert_object(df[["value1", "value2"]], pd.DataFrame) + assert_object(df[[geo_name, "geometry2"]], GeoDataFrame, geo_name) + assert_object(df[[geo_name]], GeoDataFrame, geo_name) + assert_object(df[["geometry2", "value1"]], pd.DataFrame) + assert_object(df[["geometry2"]], pd.DataFrame) + assert_object(df[["value1"]], pd.DataFrame) + # Series + assert_object(df[geo_name], GeoSeries, geo_name) + assert_object(df["geometry2"], GeoSeries, "geometry2", crs=crs_osgb) + assert_object(df["value1"], pd.Series) + + +def test_loc(df): + geo_name = df.geometry.name + assert_object(df.loc[:, ["value1", "value2"]], pd.DataFrame) + assert_object(df.loc[:, [geo_name, "geometry2"]], GeoDataFrame, geo_name) + assert_object(df.loc[:, [geo_name]], GeoDataFrame, geo_name) + # TODO: should this set the geometry column to geometry2 or return a DataFrame? + assert_object(df.loc[:, ["geometry2", "value1"]], GeoDataFrame, None) + assert_object(df.loc[:, ["geometry2"]], GeoDataFrame, None) + # Ideally this would mirror __getitem__ and below would be true + # assert_object(df.loc[:, ["geometry2", "value1"]], pd.DataFrame) + # assert_object(df.loc[:, ["geometry2"]], pd.DataFrame) + assert_object(df.loc[:, ["value1"]], pd.DataFrame) + # Series + assert_object(df.loc[:, geo_name], GeoSeries, geo_name) + assert_object(df.loc[:, "geometry2"], GeoSeries, "geometry2", crs=crs_osgb) + assert_object(df.loc[:, "value1"], pd.Series) + + +def test_iloc(df): + geo_name = df.geometry.name + assert_object(df.iloc[:, 0:2], pd.DataFrame) + assert_object(df.iloc[:, 2:4], GeoDataFrame, geo_name) + assert_object(df.iloc[:, [2]], GeoDataFrame, geo_name) + # TODO: should this set the geometry column to geometry2 or return a DataFrame? + assert_object(df.iloc[:, [3, 0]], GeoDataFrame, None) + assert_object(df.iloc[:, [3]], GeoDataFrame, None) + # Ideally this would mirror __getitem__ and below would be true + # assert_object(df.iloc[:, [3, 0]], pd.DataFrame) + # assert_object(df.iloc[:, [3]], pd.DataFrame) + assert_object(df.iloc[:, [0]], pd.DataFrame) + # Series + assert_object(df.iloc[:, 2], GeoSeries, geo_name) + assert_object(df.iloc[:, 3], GeoSeries, "geometry2", crs=crs_osgb) + assert_object(df.iloc[:, 0], pd.Series) + + +def test_squeeze(df): + geo_name = df.geometry.name + assert_object(df[[geo_name]].squeeze(), GeoSeries, geo_name) + + # Not ideal behaviour, but this is consistent with __getitem__ + assert_object(df[["geometry2"]].squeeze(), pd.Series) + + +def test_to_frame(df): + geo_name = df.geometry.name + # TODO this reflects current behaviour, but we should fix + # GeoSeries._constructor_expanddim so this doesn't happen + res1 = df[geo_name].to_frame() + if geo_name == "geometry": # -> this should be doable for any geo_name + assert_object(res1, GeoDataFrame, geo_name) + assert res1._geometry_column_name == "geometry" # -> should be geo_name + + res2 = df["geometry2"].to_frame() + assert type(res2) is GeoDataFrame + assert res2._geometry_column_name == "geometry" # -> should be geometry2 + assert res2.crs is None # -> should be crs_osgb + # also res2.geometry should not crash because geometry isn't set + + res3 = df["value1"].to_frame() + assert_object(res3, pd.DataFrame) + + +def test_reindex(df): + geo_name = df.geometry.name + assert_object(df.reindex(columns=["value1", "value2"]), pd.DataFrame) + assert_object(df.reindex(columns=[geo_name, "geometry2"]), GeoDataFrame, geo_name) + assert_object(df.reindex(columns=[geo_name]), GeoDataFrame, geo_name) + assert_object(df.reindex(columns=["new_col", geo_name]), GeoDataFrame, geo_name) + # TODO: should this set the geometry column to geometry2 or return a DataFrame? + assert_object(df.reindex(columns=["geometry2", "value1"]), GeoDataFrame, None) + assert_object(df.reindex(columns=["geometry2"]), GeoDataFrame, None) + # Ideally this would mirror __getitem__ and below would be true + # assert_object(df.reindex(columns=["geometry2", "value1"]), pd.DataFrame) + # assert_object(df.reindex(columns=["geometry2"]), pd.DataFrame) + assert_object(df.reindex(columns=["value1"]), pd.DataFrame) + + # reindexing the rows always preserves the GeoDataFrame + assert_object(df.reindex(index=[0, 1, 20]), GeoDataFrame, geo_name) + + # reindexing both rows and columns + assert_object( + df.reindex(index=[0, 1, 20], columns=[geo_name]), GeoDataFrame, geo_name + ) + assert_object(df.reindex(index=[0, 1, 20], columns=["value1"]), pd.DataFrame) + + +def test_drop(df): + geo_name = df.geometry.name + assert_object(df.drop(columns=[geo_name, "geometry2"]), pd.DataFrame) + assert_object(df.drop(columns=["value1", "value2"]), GeoDataFrame, geo_name) + cols = ["value1", "value2", "geometry2"] + assert_object(df.drop(columns=cols), GeoDataFrame, geo_name) + # TODO: should this set the geometry column to geometry2 or return a DataFrame? + assert_object(df.drop(columns=[geo_name, "value2"]), GeoDataFrame, None) + assert_object(df.drop(columns=["value1", "value2", geo_name]), GeoDataFrame, None) + # Ideally this would mirror __getitem__ and below would be true + # assert_object(df.drop(columns=[geo_name, "value2"]), pd.DataFrame) + # assert_object(df.drop(columns=["value1", "value2", geo_name]), pd.DataFrame) + assert_object(df.drop(columns=["geometry2", "value2", geo_name]), pd.DataFrame) + + +def test_apply(df): + geo_name = df.geometry.name + + def identity(x): + return x + + # axis = 0 + assert_object(df[["value1", "value2"]].apply(identity), pd.DataFrame) + assert_object(df[[geo_name, "geometry2"]].apply(identity), GeoDataFrame, geo_name) + assert_object(df[[geo_name]].apply(identity), GeoDataFrame, geo_name) + assert_object(df[["geometry2", "value1"]].apply(identity), pd.DataFrame) + assert_object(df[["geometry2"]].apply(identity), pd.DataFrame) + assert_object(df[["value1"]].apply(identity), pd.DataFrame) + + # axis = 0, Series + assert_object(df[geo_name].apply(identity), GeoSeries, geo_name) + assert_object(df["geometry2"].apply(identity), GeoSeries, "geometry2", crs=crs_osgb) + assert_object(df["value1"].apply(identity), pd.Series) + + # axis = 0, Series, no longer geometry + assert_object(df[geo_name].apply(lambda x: str(x)), pd.Series) + assert_object(df["geometry2"].apply(lambda x: str(x)), pd.Series) + + # axis = 1 + assert_object(df[["value1", "value2"]].apply(identity, axis=1), pd.DataFrame) + assert_object( + df[[geo_name, "geometry2"]].apply(identity, axis=1), GeoDataFrame, geo_name + ) + assert_object(df[[geo_name]].apply(identity, axis=1), GeoDataFrame, geo_name) + assert_object(df[["geometry2", "value1"]].apply(identity, axis=1), pd.DataFrame) + assert_object(df[["geometry2"]].apply(identity, axis=1), pd.DataFrame) + assert_object(df[["value1"]].apply(identity, axis=1), pd.DataFrame) diff --git a/geopandas/tests/test_overlay.py b/geopandas/tests/test_overlay.py index 467fbb9..14ea914 100644 --- a/geopandas/tests/test_overlay.py +++ b/geopandas/tests/test_overlay.py @@ -1,12 +1,15 @@ import os +from packaging.version import Version +import numpy as np import pandas as pd -from shapely.geometry import Point, Polygon, LineString, GeometryCollection +from shapely.geometry import Point, Polygon, LineString, GeometryCollection, box from fiona.errors import DriverError import geopandas from geopandas import GeoDataFrame, GeoSeries, overlay, read_file +from geopandas import _compat from geopandas.testing import assert_geodataframe_equal, assert_geoseries_equal import pytest @@ -14,9 +17,8 @@ import pytest DATA = os.path.join(os.path.abspath(os.path.dirname(__file__)), "data", "overlay") -pytestmark = pytest.mark.skipif( - not geopandas.sindex.has_sindex(), reason="overlay requires spatial index" -) +pytestmark = pytest.mark.skip_no_sindex +pandas_133 = Version(pd.__version__) == Version("1.3.3") @pytest.fixture @@ -53,6 +55,8 @@ def dfs_index(request, dfs): params=["union", "intersection", "difference", "symmetric_difference", "identity"] ) def how(request): + if pandas_133 and request.param in ["symmetric_difference", "identity", "union"]: + pytest.xfail("Regression in pandas 1.3.3 (GH #2101)") return request.param @@ -109,19 +113,23 @@ def test_overlay(dfs_index, how): def test_overlay_nybb(how): polydf = read_file(geopandas.datasets.get_path("nybb")) - # construct circles dataframe - N = 10 - b = [int(x) for x in polydf.total_bounds] - polydf2 = GeoDataFrame( - [ - {"geometry": Point(x, y).buffer(10000), "value1": x + y, "value2": x - y} - for x, y in zip( - range(b[0], b[2], int((b[2] - b[0]) / N)), - range(b[1], b[3], int((b[3] - b[1]) / N)), - ) - ], - crs=polydf.crs, - ) + # The circles have been constructed and saved at the time the expected + # results were created (exact output of buffer algorithm can slightly + # change over time -> use saved ones) + # # construct circles dataframe + # N = 10 + # b = [int(x) for x in polydf.total_bounds] + # polydf2 = GeoDataFrame( + # [ + # {"geometry": Point(x, y).buffer(10000), "value1": x + y, "value2": x - y} + # for x, y in zip( + # range(b[0], b[2], int((b[2] - b[0]) / N)), + # range(b[1], b[3], int((b[3] - b[1]) / N)), + # ) + # ], + # crs=polydf.crs, + # ) + polydf2 = read_file(os.path.join(DATA, "nybb_qgis", "polydf2.shp")) result = overlay(polydf, polydf2, how=how) @@ -181,19 +189,34 @@ def test_overlay_nybb(how): # first, check that all bounds and areas are approx equal # this is a very rough check for multipolygon equality + if not _compat.PANDAS_GE_11: + kwargs = dict(check_less_precise=True) + else: + kwargs = {} pd.testing.assert_series_equal( - result.geometry.area, expected.geometry.area, check_less_precise=True + result.geometry.area, expected.geometry.area, **kwargs ) pd.testing.assert_frame_equal( - result.geometry.bounds, expected.geometry.bounds, check_less_precise=True + result.geometry.bounds, expected.geometry.bounds, **kwargs ) - # now drop multipolygons - result.geometry[result.geometry.geom_type == "MultiPolygon"] = None - expected.geometry[expected.geometry.geom_type == "MultiPolygon"] = None + # There are two cases where the multipolygon have a different number + # of sub-geometries -> not solved by normalize (and thus drop for now) + if how == "symmetric_difference": + expected.loc[9, "geometry"] = None + result.loc[9, "geometry"] = None + + if how == "union": + expected.loc[24, "geometry"] = None + result.loc[24, "geometry"] = None assert_geodataframe_equal( - result, expected, check_crs=False, check_column_type=False + result, + expected, + normalize=True, + check_crs=False, + check_column_type=False, + check_less_precise=True, ) @@ -246,7 +269,11 @@ def test_overlay_overlap(how): result = result.sort_values(["col1", "col2"]).reset_index(drop=True) assert_geodataframe_equal( - result, expected, check_column_type=False, check_less_precise=True + result, + expected, + normalize=True, + check_column_type=False, + check_less_precise=True, ) @@ -302,10 +329,12 @@ def test_bad_how(dfs): overlay(df1, df2, how="spandex") -def test_duplicate_column_name(dfs): +def test_duplicate_column_name(dfs, how): + if how == "difference": + pytest.skip("Difference uses columns from one df only.") df1, df2 = dfs df2r = df2.rename(columns={"col2": "col1"}) - res = overlay(df1, df2r, how="union") + res = overlay(df1, df2r, how=how) assert ("col1_1" in res.columns) and ("col1_2" in res.columns) @@ -346,7 +375,7 @@ def test_empty_intersection(dfs): df3 = GeoDataFrame({"geometry": polys3, "col3": [1, 2]}) expected = GeoDataFrame([], columns=["col1", "col3", "geometry"]) result = overlay(df1, df3) - assert_geodataframe_equal(result, expected, check_like=True) + assert_geodataframe_equal(result, expected, check_dtype=False) def test_correct_index(dfs): @@ -365,10 +394,26 @@ def test_correct_index(dfs): expected = GeoDataFrame( [[1, 1, i1], [3, 2, i2]], columns=["col3", "col2", "geometry"] ) - result = overlay(df3, df2) + result = overlay(df3, df2, keep_geom_type=True) assert_geodataframe_equal(result, expected) +def test_warn_on_keep_geom_type(dfs): + + df1, df2 = dfs + polys3 = GeoSeries( + [ + Polygon([(1, 1), (3, 1), (3, 3), (1, 3)]), + Polygon([(-1, 1), (1, 1), (1, 3), (-1, 3)]), + Polygon([(3, 3), (5, 3), (5, 5), (3, 5)]), + ] + ) + df3 = GeoDataFrame({"geometry": polys3}) + + with pytest.warns(UserWarning, match="`keep_geom_type=True` in overlay"): + overlay(df2, df3, keep_geom_type=None) + + @pytest.mark.parametrize( "geom_types", ["polys", "poly_line", "poly_point", "line_poly", "point_poly"] ) @@ -471,6 +516,7 @@ def test_overlay_strict(how, keep_geom_type, geom_types): assert_geodataframe_equal( result, expected, + normalize=True, check_column_type=False, check_less_precise=True, check_crs=False, @@ -522,3 +568,230 @@ def test_keep_geom_type_error(): df1 = GeoDataFrame({"col1": [1, 2], "geometry": polys1}) with pytest.raises(TypeError): overlay(dfcol, df1, keep_geom_type=True) + + +def test_keep_geom_type_geometry_collection(): + # GH 1581 + + df1 = read_file(os.path.join(DATA, "geom_type", "df1.geojson")) + df2 = read_file(os.path.join(DATA, "geom_type", "df2.geojson")) + + with pytest.warns(UserWarning, match="`keep_geom_type=True` in overlay"): + intersection = overlay(df1, df2, keep_geom_type=None) + assert len(intersection) == 1 + assert (intersection.geom_type == "Polygon").all() + + intersection = overlay(df1, df2, keep_geom_type=True) + assert len(intersection) == 1 + assert (intersection.geom_type == "Polygon").all() + + intersection = overlay(df1, df2, keep_geom_type=False) + assert len(intersection) == 1 + assert (intersection.geom_type == "GeometryCollection").all() + + +def test_keep_geom_type_geometry_collection2(): + polys1 = [ + box(0, 0, 1, 1), + box(1, 1, 3, 3).union(box(1, 3, 5, 5)), + ] + + polys2 = [ + box(0, 0, 1, 1), + box(3, 1, 4, 2).union(box(4, 1, 5, 4)), + ] + df1 = GeoDataFrame({"left": [0, 1], "geometry": polys1}) + df2 = GeoDataFrame({"right": [0, 1], "geometry": polys2}) + + result1 = overlay(df1, df2, keep_geom_type=True) + expected1 = GeoDataFrame( + { + "left": [0, 1], + "right": [0, 1], + "geometry": [box(0, 0, 1, 1), box(4, 3, 5, 4)], + } + ) + assert_geodataframe_equal(result1, expected1) + + result1 = overlay(df1, df2, keep_geom_type=False) + expected1 = GeoDataFrame( + { + "left": [0, 1, 1], + "right": [0, 0, 1], + "geometry": [ + box(0, 0, 1, 1), + Point(1, 1), + GeometryCollection([box(4, 3, 5, 4), LineString([(3, 1), (3, 2)])]), + ], + } + ) + assert_geodataframe_equal(result1, expected1) + + +def test_keep_geom_type_geomcoll_different_types(): + polys1 = [box(0, 1, 1, 3), box(10, 10, 12, 12)] + polys2 = [ + Polygon([(1, 0), (3, 0), (3, 3), (1, 3), (1, 2), (2, 2), (2, 1), (1, 1)]), + box(11, 11, 13, 13), + ] + df1 = GeoDataFrame({"left": [0, 1], "geometry": polys1}) + df2 = GeoDataFrame({"right": [0, 1], "geometry": polys2}) + result1 = overlay(df1, df2, keep_geom_type=True) + expected1 = GeoDataFrame( + { + "left": [1], + "right": [1], + "geometry": [box(11, 11, 12, 12)], + } + ) + assert_geodataframe_equal(result1, expected1) + + result2 = overlay(df1, df2, keep_geom_type=False) + expected2 = GeoDataFrame( + { + "left": [0, 1], + "right": [0, 1], + "geometry": [ + GeometryCollection([LineString([(1, 2), (1, 3)]), Point(1, 1)]), + box(11, 11, 12, 12), + ], + } + ) + assert_geodataframe_equal(result2, expected2) + + +def test_keep_geom_type_geometry_collection_difference(): + # GH 2163 + + polys1 = [ + box(0, 0, 1, 1), + box(1, 1, 2, 2), + ] + + # the tiny sliver in the second geometry may be converted to a + # linestring during the overlay process due to floating point errors + # on some platforms + polys2 = [ + box(0, 0, 1, 1), + box(1, 1, 2, 3).union(box(2, 2, 3, 2.00000000000000001)), + ] + df1 = GeoDataFrame({"left": [0, 1], "geometry": polys1}) + df2 = GeoDataFrame({"right": [0, 1], "geometry": polys2}) + + result1 = overlay(df2, df1, keep_geom_type=True, how="difference") + expected1 = GeoDataFrame( + { + "right": [1], + "geometry": [box(1, 2, 2, 3)], + }, + ) + + assert_geodataframe_equal(result1, expected1) + + +@pytest.mark.parametrize("make_valid", [True, False]) +def test_overlap_make_valid(make_valid): + bowtie = Polygon([(1, 1), (9, 9), (9, 1), (1, 9), (1, 1)]) + assert not bowtie.is_valid + fixed_bowtie = bowtie.buffer(0) + assert fixed_bowtie.is_valid + + df1 = GeoDataFrame({"col1": ["region"], "geometry": GeoSeries([box(0, 0, 10, 10)])}) + df_bowtie = GeoDataFrame( + {"col1": ["invalid", "valid"], "geometry": GeoSeries([bowtie, fixed_bowtie])} + ) + + if make_valid: + df_overlay_bowtie = overlay(df1, df_bowtie, make_valid=make_valid) + assert df_overlay_bowtie.at[0, "geometry"].equals(fixed_bowtie) + assert df_overlay_bowtie.at[1, "geometry"].equals(fixed_bowtie) + else: + with pytest.raises(ValueError, match="1 invalid input geometries"): + overlay(df1, df_bowtie, make_valid=make_valid) + + +def test_empty_overlay_return_non_duplicated_columns(): + + nybb = geopandas.read_file(geopandas.datasets.get_path("nybb")) + nybb2 = nybb.copy() + nybb2.geometry = nybb2.translate(20000000) + + result = geopandas.overlay(nybb, nybb2) + + expected = GeoDataFrame( + columns=[ + "BoroCode_1", + "BoroName_1", + "Shape_Leng_1", + "Shape_Area_1", + "BoroCode_2", + "BoroName_2", + "Shape_Leng_2", + "Shape_Area_2", + "geometry", + ], + crs=nybb.crs, + ) + assert_geodataframe_equal(result, expected, check_dtype=False) + + +def test_non_overlapping(how): + p1 = Polygon([(0, 0), (2, 0), (2, 2), (0, 2)]) + p2 = Polygon([(3, 3), (5, 3), (5, 5), (3, 5)]) + df1 = GeoDataFrame({"col1": [1], "geometry": [p1]}) + df2 = GeoDataFrame({"col2": [2], "geometry": [p2]}) + result = overlay(df1, df2, how=how) + + if how == "intersection": + expected = GeoDataFrame( + { + "col1": np.array([], dtype="int64"), + "col2": np.array([], dtype="int64"), + "geometry": [], + }, + index=pd.Index([], dtype="object"), + ) + elif how == "union": + expected = GeoDataFrame( + { + "col1": [1, np.nan], + "col2": [np.nan, 2], + "geometry": [p1, p2], + } + ) + elif how == "identity": + expected = GeoDataFrame( + { + "col1": [1.0], + "col2": [np.nan], + "geometry": [p1], + } + ) + elif how == "symmetric_difference": + expected = GeoDataFrame( + { + "col1": [1, np.nan], + "col2": [np.nan, 2], + "geometry": [p1, p2], + } + ) + elif how == "difference": + expected = GeoDataFrame( + { + "col1": [1], + "geometry": [p1], + } + ) + + assert_geodataframe_equal(result, expected) + + +def test_no_intersection(): + # overlapping bounds but non-overlapping geometries + gs = GeoSeries([Point(x, x).buffer(0.1) for x in range(3)]) + gdf1 = GeoDataFrame({"foo": ["a", "b", "c"]}, geometry=gs) + gdf2 = GeoDataFrame({"bar": ["1", "3", "5"]}, geometry=gs.translate(1)) + + expected = GeoDataFrame(columns=["foo", "bar", "geometry"]) + result = overlay(gdf1, gdf2, how="intersection") + assert_geodataframe_equal(result, expected, check_index_type=False) diff --git a/geopandas/tests/test_pandas_methods.py b/geopandas/tests/test_pandas_methods.py index ed63b36..801e88a 100644 --- a/geopandas/tests/test_pandas_methods.py +++ b/geopandas/tests/test_pandas_methods.py @@ -5,11 +5,11 @@ from numpy.testing import assert_array_equal import pandas as pd import shapely -from shapely.geometry import Point, GeometryCollection +from shapely.geometry import Point, GeometryCollection, LineString import geopandas from geopandas import GeoDataFrame, GeoSeries -from geopandas._compat import PANDAS_GE_024, PANDAS_GE_025, PANDAS_GE_11 +import geopandas._compat as compat from geopandas.array import from_shapely from geopandas.testing import assert_geodataframe_equal, assert_geoseries_equal @@ -39,9 +39,6 @@ def test_repr(s, df): assert "POINT" in df._repr_html_() -@pytest.mark.skipif( - not PANDAS_GE_024, reason="formatting for EA only implemented in 0.24.0" -) def test_repr_boxed_display_precision(): # geographic coordinates p1 = Point(10.123456789, 50.123456789) @@ -49,12 +46,20 @@ def test_repr_boxed_display_precision(): s1 = GeoSeries([p1, p2, None]) assert "POINT (10.12346 50.12346)" in repr(s1) + # geographic coordinates 4326 + s3 = GeoSeries([p1, p2], crs=4326) + assert "POINT (10.12346 50.12346)" in repr(s3) + # projected coordinates p1 = Point(3000.123456789, 3000.123456789) p2 = Point(4000.123456789, 4000.123456789) s2 = GeoSeries([p1, p2, None]) assert "POINT (3000.123 3000.123)" in repr(s2) + # projected geographic coordinate + s4 = GeoSeries([p1, p2], crs=3857) + assert "POINT (3000.123 3000.123)" in repr(s4) + geopandas.options.display_precision = 1 assert "POINT (10.1 50.1)" in repr(s1) @@ -74,11 +79,7 @@ def test_repr_all_missing(): def test_repr_empty(): # https://github.com/geopandas/geopandas/issues/1195 s = GeoSeries([]) - if PANDAS_GE_025: - # repr with correct name fixed in pandas 0.25 - assert repr(s) == "GeoSeries([], dtype: geometry)" - else: - assert repr(s) == "Series([], dtype: geometry)" + assert repr(s) == "GeoSeries([], dtype: geometry)" df = GeoDataFrame({"a": [], "geometry": s}) assert "Empty GeoDataFrame" in repr(df) # https://github.com/geopandas/geopandas/issues/1184 @@ -87,7 +88,7 @@ def test_repr_empty(): def test_indexing(s, df): - # accessing scalar from the geometry (colunm) + # accessing scalar from the geometry (column) exp = Point(1, 1) assert s[1] == exp assert s.loc[1] == exp @@ -138,8 +139,9 @@ def test_reindex(s, df): assert isinstance(res.geometry, GeoSeries) assert_frame_equal(res, df[["value1", "geometry"]]) - # TODO df.reindex(columns=['value1', 'value2']) still returns GeoDataFrame, - # should it return DataFrame instead ? + res = df.reindex(columns=["value1", "value2"]) + assert type(res) == pd.DataFrame + assert_frame_equal(res, df[["value1", "value2"]]) def test_take(s, df): @@ -240,7 +242,7 @@ def test_astype(s, df): res = df.astype({"value1": float}) assert isinstance(res, GeoDataFrame) - # check whether returned object is a datafrane + # check whether returned object is a dataframe res = df.astype(str) assert isinstance(res, pd.DataFrame) and not isinstance(res, GeoDataFrame) @@ -261,6 +263,42 @@ def test_astype_invalid_geodataframe(): assert res["a"].dtype == object +@pytest.mark.xfail( + not compat.PANDAS_GE_10, + reason="Convert dtypes new in pandas 1.0", + raises=NotImplementedError, +) +def test_convert_dtypes(df): + # https://github.com/geopandas/geopandas/issues/1870 + + # Test geometry col is first col, first, geom_col_name=geometry + # (order is important in concat, used internally) + res1 = df.convert_dtypes() # note res1 done first for pandas < 1 xfail check + + expected1 = GeoDataFrame( + pd.DataFrame(df).convert_dtypes(), crs=df.crs, geometry=df.geometry.name + ) + + # Checking type and metadata are right + assert_geodataframe_equal(expected1, res1) + + # Test geom last, geom_col_name=geometry + res2 = df[["value1", "value2", "geometry"]].convert_dtypes() + assert_geodataframe_equal(expected1[["value1", "value2", "geometry"]], res2) + + # Test again with crs set and custom geom col name + df2 = df.set_crs(epsg=4326).rename_geometry("points") + expected2 = GeoDataFrame( + pd.DataFrame(df2).convert_dtypes(), crs=df2.crs, geometry=df2.geometry.name + ) + res3 = df2.convert_dtypes() + assert_geodataframe_equal(expected2, res3) + + # Test geom last, geom_col=geometry + res4 = df2[["value1", "value2", "points"]].convert_dtypes() + assert_geodataframe_equal(expected2[["value1", "value2", "points"]], res4) + + def test_to_csv(df): exp = ( @@ -275,14 +313,15 @@ def test_numerical_operations(s, df): exp = pd.Series([3, 4], index=["value1", "value2"]) assert_series_equal(df.sum(), exp) - # series methods raise error + # series methods raise error (not supported for geometry) with pytest.raises(TypeError): s.sum() with pytest.raises(TypeError): s.max() - with pytest.raises(TypeError): + with pytest.raises((TypeError, ValueError)): + # TODO: remove ValueError after pandas-dev/pandas#32749 s.idxmax() # numerical ops raise an error @@ -299,9 +338,6 @@ def test_numerical_operations(s, df): assert_frame_equal(res, exp) -@pytest.mark.skipif( - not PANDAS_GE_024, reason="where for EA only implemented in 0.24.0 (GH24114)" -) def test_where(s): res = s.where(np.array([True, False, True])) exp = GeoSeries([Point(0, 0), None, Point(2, 2)]) @@ -348,7 +384,7 @@ def test_fillna(s, df): df2["geometry"] = s2 res = df2.fillna(Point(1, 1)) assert_geodataframe_equal(res, df) - with pytest.raises(NotImplementedError): + with pytest.raises((NotImplementedError, TypeError)): # GH2351 df2.fillna(0) # allow non-geometry fill value if there are no missing values @@ -409,13 +445,46 @@ def test_unique(): assert_array_equal(s.unique(), exp) -@pytest.mark.xfail +def pd14_compat_index(index): + if compat.PANDAS_GE_14: + return from_shapely(index) + else: + return index + + def test_value_counts(): # each object is considered unique s = GeoSeries([Point(0, 0), Point(1, 1), Point(0, 0)]) res = s.value_counts() - exp = pd.Series([2, 1], index=[Point(0, 0), Point(1, 1)]) + with compat.ignore_shapely2_warnings(): + exp = pd.Series([2, 1], index=pd14_compat_index([Point(0, 0), Point(1, 1)])) assert_series_equal(res, exp) + # Check crs doesn't make a difference - note it is not kept in output index anyway + s2 = GeoSeries([Point(0, 0), Point(1, 1), Point(0, 0)], crs="EPSG:4326") + res2 = s2.value_counts() + assert_series_equal(res2, exp) + if compat.PANDAS_GE_14: + # TODO should/ can we fix CRS being lost + assert s2.value_counts().index.array.crs is None + + # check mixed geometry + s3 = GeoSeries([Point(0, 0), LineString([[1, 1], [2, 2]]), Point(0, 0)]) + res3 = s3.value_counts() + index = pd14_compat_index([Point(0, 0), LineString([[1, 1], [2, 2]])]) + with compat.ignore_shapely2_warnings(): + exp3 = pd.Series([2, 1], index=index) + assert_series_equal(res3, exp3) + + # check None is handled + s4 = GeoSeries([Point(0, 0), None, Point(0, 0)]) + res4 = s4.value_counts(dropna=True) + with compat.ignore_shapely2_warnings(): + exp4_dropna = pd.Series([2], index=pd14_compat_index([Point(0, 0)])) + assert_series_equal(res4, exp4_dropna) + with compat.ignore_shapely2_warnings(): + exp4_keepna = pd.Series([2, 1], index=pd14_compat_index([Point(0, 0), None])) + res4_keepna = s4.value_counts(dropna=False) + assert_series_equal(res4_keepna, exp4_keepna) @pytest.mark.xfail(strict=False) @@ -459,8 +528,8 @@ def test_groupby(df): assert_frame_equal(res, exp) # applying on the geometry column - res = df.groupby("value2")["geometry"].apply(lambda x: x.cascaded_union) - if PANDAS_GE_11: + res = df.groupby("value2")["geometry"].apply(lambda x: x.unary_union) + if compat.PANDAS_GE_11: exp = GeoSeries( [shapely.geometry.MultiPoint([(0, 0), (2, 2)]), Point(1, 1)], index=pd.Index([1, 2], name="value2"), @@ -489,6 +558,45 @@ def test_groupby_groups(df): assert_frame_equal(res, exp) +@pytest.mark.skip_no_sindex +@pytest.mark.skipif( + compat.PANDAS_GE_13 and not compat.PANDAS_GE_14, + reason="this was broken in pandas 1.3.5 (GH-2294)", +) +@pytest.mark.parametrize("crs", [None, "EPSG:4326"]) +def test_groupby_metadata(crs): + # https://github.com/geopandas/geopandas/issues/2294 + df = GeoDataFrame( + { + "geometry": [Point(0, 0), Point(1, 1), Point(0, 0)], + "value1": np.arange(3, dtype="int64"), + "value2": np.array([1, 2, 1], dtype="int64"), + }, + crs=crs, + ) + + # dummy test asserting we can access the crs + def func(group): + assert isinstance(group, GeoDataFrame) + assert group.crs == crs + + df.groupby("value2").apply(func) + + # actual test with functionality + res = df.groupby("value2").apply( + lambda x: geopandas.sjoin(x, x[["geometry", "value1"]], how="inner") + ) + + expected = ( + df.take([0, 2, 0, 2, 1]) + .set_index("value2", drop=False, append=True) + .swaplevel() + .rename(columns={"value1": "value1_left"}) + .assign(value1_right=[0, 0, 2, 2, 1]) + ) + assert_geodataframe_equal(res.drop(columns=["index_right"]), expected) + + def test_apply(s): # function that returns geometry preserves GeoSeries class def geom_func(geom): @@ -517,3 +625,83 @@ def test_apply_loc_len1(df): result = subset.apply(lambda geom: geom.is_empty) expected = subset.is_empty np.testing.assert_allclose(result, expected) + + +def test_apply_convert_dtypes_keyword(s): + # ensure the convert_dtypes keyword is accepted + res = s.apply(lambda x: x, convert_dtype=True, args=()) + assert_geoseries_equal(res, s) + + +@pytest.mark.parametrize("crs", [None, "EPSG:4326"]) +def test_apply_no_geometry_result(df, crs): + if crs: + df = df.set_crs(crs) + result = df.apply(lambda col: col.astype(str), axis=0) + assert type(result) is pd.DataFrame + expected = df.astype(str) + assert_frame_equal(result, expected) + + result = df.apply(lambda col: col.astype(str), axis=1) + assert type(result) is pd.DataFrame + assert_frame_equal(result, expected) + + +def test_apply_preserves_geom_col_name(df): + df = df.rename_geometry("geom") + result = df.apply(lambda col: col, axis=0) + assert result.geometry.name == "geom" + + +def test_df_apply_returning_series(df): + # https://github.com/geopandas/geopandas/issues/2283 + result = df.apply(lambda row: row.geometry, axis=1) + assert_geoseries_equal(result, df.geometry, check_crs=False) + + result = df.apply(lambda row: row.value1, axis=1) + assert_series_equal(result, df["value1"].rename(None)) + + +@pytest.mark.skipif(not compat.PANDAS_GE_10, reason="attrs introduced in pandas 1.0") +def test_preserve_attrs(df): + # https://github.com/geopandas/geopandas/issues/1654 + df.attrs["name"] = "my_name" + attrs = {"name": "my_name"} + assert df.attrs == attrs + + # preserve attrs in indexing operations + for subset in [df[:2], df[df["value1"] > 2], df[["value2", "geometry"]]]: + assert df.attrs == attrs + + # preserve attrs in methods + df2 = df.reset_index() + assert df2.attrs == attrs + + # https://github.com/geopandas/geopandas/issues/1875 + df3 = df2.explode(index_parts=True) + assert df3.attrs == attrs + + +@pytest.mark.skipif(not compat.PANDAS_GE_12, reason="attrs introduced in pandas 1.0") +def test_preserve_flags(df): + # https://github.com/geopandas/geopandas/issues/1654 + df = df.set_flags(allows_duplicate_labels=False) + assert df.flags.allows_duplicate_labels is False + + # preserve flags in indexing operations + for subset in [df[:2], df[df["value1"] > 2], df[["value2", "geometry"]]]: + assert df.flags.allows_duplicate_labels is False + + # preserve attrs in methods + df2 = df.reset_index() + assert df2.flags.allows_duplicate_labels is False + + # it is honored for operations that introduce duplicate labels + with pytest.raises(ValueError): + df.reindex([0, 0, 1]) + + with pytest.raises(ValueError): + df[["value1", "value1", "geometry"]] + + with pytest.raises(ValueError): + pd.concat([df, df]) diff --git a/geopandas/tests/test_plotting.py b/geopandas/tests/test_plotting.py index 23d1896..d2cac73 100644 --- a/geopandas/tests/test_plotting.py +++ b/geopandas/tests/test_plotting.py @@ -1,9 +1,11 @@ +from packaging.version import Version import itertools import warnings import numpy as np import pandas as pd +from shapely import wkt from shapely.affinity import rotate from shapely.geometry import ( MultiPolygon, @@ -19,6 +21,8 @@ from shapely.geometry import ( from geopandas import GeoDataFrame, GeoSeries, read_file from geopandas.datasets import get_path +import geopandas._compat as compat +from geopandas.plotting import GeoplotAccessor import pytest @@ -26,6 +30,17 @@ matplotlib = pytest.importorskip("matplotlib") matplotlib.use("Agg") import matplotlib.pyplot as plt # noqa +try: # skipif and importorskip do not work for decorators + from matplotlib.testing.decorators import check_figures_equal + + if Version(matplotlib.__version__) >= Version("3.3.0"): + + MPL_DECORATORS = True + else: + MPL_DECORATORS = False +except ImportError: + MPL_DECORATORS = False + @pytest.fixture(autouse=True) def close_figures(request): @@ -39,6 +54,8 @@ try: except KeyError: MPL_DFT_COLOR = matplotlib.rcParams["axes.color_cycle"][0] +plt.rcParams.update({"figure.max_open_warning": 0}) + class TestPointPlotting: def setup_method(self): @@ -86,6 +103,43 @@ class TestPointPlotting: expected_colors = cmap(np.arange(self.N) / (self.N - 1)) _check_colors(self.N, ax.collections[0].get_facecolors(), expected_colors) + def test_series_color_no_index(self): + + # Color order with ordered index + colors_ord = pd.Series(["a", "b", "c", "a", "b", "c", "a", "b", "c", "a"]) + + # Plot using Series as color + ax1 = self.df.plot(colors_ord) + + # Correct answer: Add as column to df and plot + self.df["colors_ord"] = colors_ord + ax2 = self.df.plot("colors_ord") + + # Confirm out-of-order index re-sorted + point_colors1 = ax1.collections[0].get_facecolors() + point_colors2 = ax2.collections[0].get_facecolors() + np.testing.assert_array_equal(point_colors1[1], point_colors2[1]) + + def test_series_color_index(self): + + # Color order with out-of-order index + colors_ord = pd.Series( + ["a", "a", "a", "a", "b", "b", "b", "c", "c", "c"], + index=[0, 3, 6, 9, 1, 4, 7, 2, 5, 8], + ) + + # Plot using Series as color + ax1 = self.df.plot(colors_ord) + + # Correct answer: Add as column to df and plot + self.df["colors_ord"] = colors_ord + ax2 = self.df.plot("colors_ord") + + # Confirm out-of-order index re-sorted + point_colors1 = ax1.collections[0].get_facecolors() + point_colors2 = ax2.collections[0].get_facecolors() + np.testing.assert_array_equal(point_colors1[1], point_colors2[1]) + def test_colormap(self): # without specifying values but cmap specified -> no uniform color @@ -109,7 +163,7 @@ class TestPointPlotting: # colors ax = self.points.plot(cmap=plt.get_cmap("Set1", lut=5)) cmap = plt.get_cmap("Set1", lut=5) - exp_colors = cmap(list(range(5)) * 3) + exp_colors = cmap(list(range(5)) * 2) _check_colors(self.N, ax.collections[0].get_facecolors(), exp_colors) def test_single_color(self): @@ -171,8 +225,15 @@ class TestPointPlotting: def test_style_kwargs_alpha(self): ax = self.df.plot(alpha=0.7) np.testing.assert_array_equal([0.7], ax.collections[0].get_alpha()) - with pytest.raises(TypeError): # no list allowed for alpha - ax = self.df.plot(alpha=[0.7, 0.2]) + try: + ax = self.df.plot(alpha=np.linspace(0, 0.0, 1.0, self.N)) + except TypeError: + # no list allowed for alpha up to matplotlib 3.3 + pass + else: + np.testing.assert_array_equal( + np.linspace(0, 0.0, 1.0, self.N), ax.collections[0].get_alpha() + ) def test_legend(self): with warnings.catch_warnings(record=True) as _: # don't print warning @@ -188,7 +249,7 @@ class TestPointPlotting: # the colorbar matches the Point colors ax = self.df.plot(column="values", cmap="RdYlGn", legend=True) point_colors = ax.collections[0].get_facecolors() - cbar_colors = ax.get_figure().axes[1].collections[0].get_facecolors() + cbar_colors = _get_colorbar_ax(ax.get_figure()).collections[-1].get_facecolors() # first point == bottom of colorbar np.testing.assert_array_equal(point_colors[0], cbar_colors[0]) # last point == top of colorbar @@ -198,7 +259,7 @@ class TestPointPlotting: # the colorbar matches the Point colors ax = self.df.plot(column="values", categorical=True, legend=True) point_colors = ax.collections[0].get_facecolors() - cbar_colors = ax.get_legend().axes.collections[0].get_facecolors() + cbar_colors = ax.get_legend().axes.collections[-1].get_facecolors() # first point == bottom of colorbar np.testing.assert_array_equal(point_colors[0], cbar_colors[0]) # last point == top of colorbar @@ -211,7 +272,7 @@ class TestPointPlotting: ) ax = self.df[1:].plot(column="exp", cmap="RdYlGn", legend=True, norm=norm) point_colors = ax.collections[0].get_facecolors() - cbar_colors = ax.get_figure().axes[1].collections[0].get_facecolors() + cbar_colors = _get_colorbar_ax(ax.get_figure()).collections[-1].get_facecolors() # first point == bottom of colorbar np.testing.assert_array_equal(point_colors[0], cbar_colors[0]) # last point == top of colorbar @@ -233,15 +294,46 @@ class TestPointPlotting: np.testing.assert_array_equal(actual_colors_orig[1], actual_colors_sub[0]) def test_empty_plot(self): + + s = GeoSeries([Polygon()]) + with pytest.warns(UserWarning): + ax = s.plot() + assert len(ax.collections) == 0 s = GeoSeries([]) with pytest.warns(UserWarning): ax = s.plot() assert len(ax.collections) == 0 - df = GeoDataFrame([]) + df = GeoDataFrame([], columns=["geometry"]) with pytest.warns(UserWarning): ax = df.plot() assert len(ax.collections) == 0 + def test_empty_geometry(self): + + if compat.USE_PYGEOS: + s = GeoSeries([wkt.loads("POLYGON EMPTY")]) + s = GeoSeries( + [Polygon([(0, 0), (1, 0), (1, 1)]), wkt.loads("POLYGON EMPTY")] + ) + ax = s.plot() + assert len(ax.collections) == 1 + if not compat.USE_PYGEOS: + s = GeoSeries([Polygon([(0, 0), (1, 0), (1, 1)]), Polygon()]) + ax = s.plot() + assert len(ax.collections) == 1 + + # more complex case with GEOMETRYCOLLECTION EMPTY, POINT EMPTY and NONE + poly = Polygon([(-1, -1), (-1, 2), (2, 2), (2, -1), (-1, -1)]) + point = Point(0, 1) + point_ = Point(10, 10) + empty_point = Point() + + gdf = GeoDataFrame(geometry=[point, empty_point, point_]) + gdf["geometry"] = gdf.intersection(poly) + gdf.loc[3] = [None] + ax = gdf.plot() + assert len(ax.collections) == 1 + def test_multipoints(self): # MultiPoints @@ -249,19 +341,26 @@ class TestPointPlotting: _check_colors(4, ax.collections[0].get_facecolors(), [MPL_DFT_COLOR] * 4) ax = self.df2.plot(column="values") - cmap = plt.get_cmap() + cmap = plt.get_cmap(lut=2) expected_colors = [cmap(0)] * self.N + [cmap(1)] * self.N - _check_colors(2, ax.collections[0].get_facecolors(), expected_colors) + _check_colors(20, ax.collections[0].get_facecolors(), expected_colors) ax = self.df2.plot(color=["r", "b"]) # colors are repeated for all components within a MultiPolygon - _check_colors(2, ax.collections[0].get_facecolors(), ["r"] * 10 + ["b"] * 10) + _check_colors(20, ax.collections[0].get_facecolors(), ["r"] * 10 + ["b"] * 10) def test_multipoints_alpha(self): ax = self.df2.plot(alpha=0.7) np.testing.assert_array_equal([0.7], ax.collections[0].get_alpha()) - with pytest.raises(TypeError): # no list allowed for alpha + try: ax = self.df2.plot(alpha=[0.7, 0.2]) + except TypeError: + # no list allowed for alpha up to matplotlib 3.3 + pass + else: + np.testing.assert_array_equal( + [0.7] * 10 + [0.2] * 10, ax.collections[0].get_alpha() + ) def test_categories(self): self.df["cats_object"] = ["cat1", "cat2"] * 5 @@ -305,7 +404,7 @@ class TestPointPlotting: ): self.df.plot(column="cats", categories=["cat1"]) - def test_misssing(self): + def test_missing(self): self.df.loc[0, "values"] = np.nan ax = self.df.plot("values") cmap = plt.get_cmap() @@ -329,6 +428,12 @@ class TestPointPlotting: np.testing.assert_array_equal(point_colors[0], leg_colors[0]) np.testing.assert_array_equal(nan_color[0], leg_colors1[0]) + def test_no_missing_and_missing_kwds(self): + # GH2210 + df = self.df.copy() + df["category"] = df["values"].astype("str") + df.plot("category", missing_kwds={"facecolor": "none"}, legend=True) + class TestPointZPlotting: def setup_method(self): @@ -417,7 +522,7 @@ class TestLineStringPlotting: self.df.plot(linestyle=ls, linewidth=1), self.df.plot(column="values", linestyle=ls, linewidth=1), ]: - np.testing.assert_array_equal(exp_ls, ax.collections[0].get_linestyle()) + assert exp_ls == ax.collections[0].get_linestyle() def test_style_kwargs_linewidth(self): # single @@ -441,8 +546,25 @@ class TestLineStringPlotting: def test_style_kwargs_alpha(self): ax = self.df.plot(alpha=0.7) np.testing.assert_array_equal([0.7], ax.collections[0].get_alpha()) - with pytest.raises(TypeError): # no list allowed for alpha - ax = self.df.plot(alpha=[0.7, 0.2]) + try: + ax = self.df.plot(alpha=np.linspace(0, 0.0, 1.0, self.N)) + except TypeError: + # no list allowed for alpha up to matplotlib 3.3 + pass + else: + np.testing.assert_array_equal( + np.linspace(0, 0.0, 1.0, self.N), ax.collections[0].get_alpha() + ) + + def test_style_kwargs_path_effects(self): + from matplotlib.patheffects import withStroke + + effects = [withStroke(linewidth=8, foreground="b")] + ax = self.df.plot(color="orange", path_effects=effects) + assert ax.collections[0].get_path_effects()[0].__dict__["_gc"] == { + "linewidth": 8, + "foreground": "b", + } def test_subplots_norm(self): # colors of subplots are the same as for plot (norm is applied) @@ -462,17 +584,17 @@ class TestLineStringPlotting: # MultiLineStrings ax = self.df2.plot() assert len(ax.collections[0].get_paths()) == 4 - _check_colors(4, ax.collections[0].get_facecolors(), [MPL_DFT_COLOR] * 4) + _check_colors(4, ax.collections[0].get_edgecolors(), [MPL_DFT_COLOR] * 4) ax = self.df2.plot("values") cmap = plt.get_cmap(lut=2) # colors are repeated for all components within a MultiLineString expected_colors = [cmap(0), cmap(0), cmap(1), cmap(1)] - _check_colors(4, ax.collections[0].get_facecolors(), expected_colors) + _check_colors(4, ax.collections[0].get_edgecolors(), expected_colors) ax = self.df2.plot(color=["r", "b"]) # colors are repeated for all components within a MultiLineString - _check_colors(4, ax.collections[0].get_facecolors(), ["r", "r", "b", "b"]) + _check_colors(4, ax.collections[0].get_edgecolors(), ["r", "r", "b", "b"]) class TestPolygonPlotting: @@ -498,11 +620,11 @@ class TestPolygonPlotting: ax = self.polys.plot(color="green") _check_colors(2, ax.collections[0].get_facecolors(), ["green"] * 2) # color only sets facecolor - _check_colors(2, ax.collections[0].get_edgecolors(), ["k"] * 2) + assert len(ax.collections[0].get_edgecolors()) == 0 ax = self.df.plot(color="green") _check_colors(2, ax.collections[0].get_facecolors(), ["green"] * 2) - _check_colors(2, ax.collections[0].get_edgecolors(), ["k"] * 2) + assert len(ax.collections[0].get_edgecolors()) == 0 # check rgba tuple GH1178 ax = self.df.plot(color=(0.5, 0.5, 0.5)) @@ -602,8 +724,13 @@ class TestPolygonPlotting: # alpha ax = self.df.plot(alpha=0.7) np.testing.assert_array_equal([0.7], ax.collections[0].get_alpha()) - with pytest.raises(TypeError): # no list allowed for alpha + try: ax = self.df.plot(alpha=[0.7, 0.2]) + except TypeError: + # no list allowed for alpha up to matplotlib 3.3 + pass + else: + np.testing.assert_array_equal([0.7, 0.2], ax.collections[0].get_alpha()) def test_legend_kwargs(self): @@ -626,8 +753,8 @@ class TestPolygonPlotting: legend=True, legend_kwds={"label": label_txt}, ) - - assert ax.get_figure().axes[1].get_ylabel() == label_txt + cax = _get_colorbar_ax(ax.get_figure()) + assert cax.get_ylabel() == label_txt ax = self.df.plot( column="values", @@ -636,7 +763,8 @@ class TestPolygonPlotting: legend_kwds={"label": label_txt, "orientation": "horizontal"}, ) - assert ax.get_figure().axes[1].get_xlabel() == label_txt + cax = _get_colorbar_ax(ax.get_figure()) + assert cax.get_xlabel() == label_txt def test_fmt_ignore(self): # test if fmt is removed if scheme is not passed (it would raise Error) @@ -700,8 +828,15 @@ class TestPolygonPlotting: def test_multipolygons_alpha(self): ax = self.df2.plot(alpha=0.7) np.testing.assert_array_equal([0.7], ax.collections[0].get_alpha()) - with pytest.raises(TypeError): # no list allowed for alpha + try: ax = self.df2.plot(alpha=[0.7, 0.2]) + except TypeError: + # no list allowed for alpha up to matplotlib 3.3 + pass + else: + np.testing.assert_array_equal( + [0.7, 0.7, 0.2, 0.2], ax.collections[0].get_alpha() + ) def test_subplots_norm(self): # colors of subplots are the same as for plot (norm is applied) @@ -754,17 +889,23 @@ class TestGeometryCollectionPlotting: def test_colors(self): # default uniform color ax = self.series.plot() - _check_colors(1, ax.collections[0].get_facecolors(), [MPL_DFT_COLOR]) # poly - _check_colors(2, ax.collections[1].get_edgecolors(), [MPL_DFT_COLOR]) # line - _check_colors(2, ax.collections[2].get_facecolors(), [MPL_DFT_COLOR]) # point + _check_colors( + 2, ax.collections[0].get_facecolors(), [MPL_DFT_COLOR] * 2 + ) # poly + _check_colors( + 2, ax.collections[1].get_edgecolors(), [MPL_DFT_COLOR] * 2 + ) # line + _check_colors(1, ax.collections[2].get_facecolors(), [MPL_DFT_COLOR]) # point def test_values(self): ax = self.df.plot("values") cmap = plt.get_cmap() - exp_colors = cmap(np.arange(2) / 1) - _check_colors(1, ax.collections[0].get_facecolors(), exp_colors) # poly - _check_colors(2, ax.collections[1].get_edgecolors(), [exp_colors[0]]) # line - _check_colors(2, ax.collections[2].get_facecolors(), [exp_colors[1]]) # point + exp_colors = cmap([0.0, 1.0]) + _check_colors(2, ax.collections[0].get_facecolors(), exp_colors) # poly + _check_colors( + 2, ax.collections[1].get_edgecolors(), [exp_colors[0]] * 2 + ) # line + _check_colors(1, ax.collections[2].get_facecolors(), [exp_colors[1]]) # point class TestNonuniformGeometryPlotting: @@ -822,7 +963,7 @@ class TestNonuniformGeometryPlotting: self.series.plot(linestyles=ls, linewidth=1), self.df.plot(linestyles=ls, linewidth=1), ]: - np.testing.assert_array_equal(exp_ls, ax.collections[0].get_linestyle()) + assert exp_ls == ax.collections[0].get_linestyle() def test_style_kwargs_linewidth(self): # single @@ -846,8 +987,17 @@ class TestNonuniformGeometryPlotting: def test_style_kwargs_alpha(self): ax = self.df.plot(alpha=0.7) np.testing.assert_array_equal([0.7], ax.collections[0].get_alpha()) - with pytest.raises(TypeError): # no list allowed for alpha - ax = self.df.plot(alpha=[0.7, 0.2, 0.9]) + # TODO splitting array-like arguments for the different plot types + # is not yet supported - https://github.com/geopandas/geopandas/issues/1379 + # try: + # ax = self.df.plot(alpha=[0.7, 0.2, 0.9]) + # except TypeError: + # # no list allowed for alpha up to matplotlib 3.3 + # pass + # else: + # np.testing.assert_array_equal( + # [0.7, 0.2, 0.9], ax.collections[0].get_alpha() + # ) class TestGeographicAspect: @@ -877,22 +1027,40 @@ class TestGeographicAspect: def test_manual(self): ax = self.north.geometry.plot(aspect="equal") assert ax.get_aspect() in ["equal", 1.0] + self.north.geometry.plot(ax=ax, aspect=None) + assert ax.get_aspect() in ["equal", 1.0] ax2 = self.north.geometry.plot(aspect=0.5) assert ax2.get_aspect() == 0.5 + self.north.geometry.plot(ax=ax2, aspect=None) + assert ax2.get_aspect() == 0.5 ax3 = self.north_proj.geometry.plot(aspect=0.5) assert ax3.get_aspect() == 0.5 + self.north_proj.geometry.plot(ax=ax3, aspect=None) + assert ax3.get_aspect() == 0.5 ax = self.north.plot(aspect="equal") assert ax.get_aspect() in ["equal", 1.0] + self.north.plot(ax=ax, aspect=None) + assert ax.get_aspect() in ["equal", 1.0] ax2 = self.north.plot(aspect=0.5) assert ax2.get_aspect() == 0.5 + self.north.plot(ax=ax2, aspect=None) + assert ax2.get_aspect() == 0.5 ax3 = self.north_proj.plot(aspect=0.5) assert ax3.get_aspect() == 0.5 + self.north_proj.plot(ax=ax3, aspect=None) + assert ax3.get_aspect() == 0.5 ax = self.north.plot("pop_est", aspect="equal") assert ax.get_aspect() in ["equal", 1.0] + self.north.plot("pop_est", ax=ax, aspect=None) + assert ax.get_aspect() in ["equal", 1.0] ax2 = self.north.plot("pop_est", aspect=0.5) assert ax2.get_aspect() == 0.5 + self.north.plot("pop_est", ax=ax2, aspect=None) + assert ax2.get_aspect() == 0.5 ax3 = self.north_proj.plot("pop_est", aspect=0.5) assert ax3.get_aspect() == 0.5 + self.north_proj.plot("pop_est", ax=ax3, aspect=None) + assert ax3.get_aspect() == 0.5 class TestMapclassifyPlotting: @@ -902,9 +1070,17 @@ class TestMapclassifyPlotting: import mapclassify # noqa except ImportError: pytest.importorskip("mapclassify") + cls.classifiers = list(mapclassify.classifiers.CLASSIFIERS) + cls.classifiers.remove("UserDefined") pth = get_path("naturalearth_lowres") cls.df = read_file(pth) cls.df["NEGATIVES"] = np.linspace(-10, 10, len(cls.df.index)) + cls.df["low_vals"] = np.linspace(0, 0.3, cls.df.shape[0]) + cls.df["mid_vals"] = np.linspace(0.3, 0.7, cls.df.shape[0]) + cls.df["high_vals"] = np.linspace(0.7, 1.0, cls.df.shape[0]) + cls.df.loc[cls.df.index[:20:2], "high_vals"] = np.nan + cls.nybb = read_file(get_path("nybb")) + cls.nybb["vals"] = [0.001, 0.002, 0.003, 0.004, 0.005] def test_legend(self): with warnings.catch_warnings(record=True) as _: # don't print warning @@ -914,9 +1090,9 @@ class TestMapclassifyPlotting: ) labels = [t.get_text() for t in ax.get_legend().get_texts()] expected = [ - u"[ 140.00, 5217064.00]", - u"( 5217064.00, 19532732.33]", - u"( 19532732.33, 1379302771.00]", + u" 140.00, 5217064.00", + u" 5217064.00, 19532732.33", + u" 19532732.33, 1379302771.00", ] assert labels == expected @@ -949,7 +1125,7 @@ class TestMapclassifyPlotting: column="NEGATIVES", scheme="FISHER_JENKS", k=3, cmap="OrRd", legend=True ) labels = [t.get_text() for t in ax.get_legend().get_texts()] - expected = [u"[-10.00, -3.41]", u"( -3.41, 3.30]", u"( 3.30, 10.00]"] + expected = [u"-10.00, -3.41", u" -3.41, 3.30", u" 3.30, 10.00"] assert labels == expected def test_fmt(self): @@ -962,7 +1138,20 @@ class TestMapclassifyPlotting: legend_kwds={"fmt": "{:.0f}"}, ) labels = [t.get_text() for t in ax.get_legend().get_texts()] - expected = [u"[-10, -3]", u"( -3, 3]", u"( 3, 10]"] + expected = [u"-10, -3", u" -3, 3", u" 3, 10"] + assert labels == expected + + def test_interval(self): + ax = self.df.plot( + column="NEGATIVES", + scheme="FISHER_JENKS", + k=3, + cmap="OrRd", + legend=True, + legend_kwds={"interval": True}, + ) + labels = [t.get_text() for t in ax.get_legend().get_texts()] + expected = [u"[-10.00, -3.41]", u"( -3.41, 3.30]", u"( 3.30, 10.00]"] assert labels == expected @pytest.mark.parametrize("scheme", ["FISHER_JENKS", "FISHERJENKS"]) @@ -970,6 +1159,11 @@ class TestMapclassifyPlotting: ax = self.df.plot(column="NEGATIVES", scheme=scheme, k=3, legend=True) assert len(ax.get_legend().get_texts()) == 3 + def test_schemes(self): + # test if all available classifiers pass + for scheme in self.classifiers: + self.df.plot(column="pop_est", scheme=scheme, legend=True) + def test_classification_kwds(self): ax = self.df.plot( column="pop_est", @@ -980,7 +1174,7 @@ class TestMapclassifyPlotting: legend=True, ) labels = [t.get_text() for t in ax.get_legend().get_texts()] - expected = ["[ 140.00, 9961396.00]", "( 9961396.00, 1379302771.00]"] + expected = [" 140.00, 9961396.00", " 9961396.00, 1379302771.00"] assert labels == expected def test_invalid_scheme(self): @@ -1010,23 +1204,172 @@ class TestMapclassifyPlotting: # base case with warnings.catch_warnings(record=True) as _: # don't print warning ax = self.df.plot(column="pop_est", cmap="OrRd", legend=True) - plot_height = ax.get_figure().get_axes()[0].get_position().height - legend_height = ax.get_figure().get_axes()[1].get_position().height + plot_height = _get_ax(ax.get_figure(), "").get_position().height + legend_height = _get_ax(ax.get_figure(), "").get_position().height assert abs(plot_height - legend_height) >= 1e-6 # fix heights with cax argument - ax2 = plt.axes() + fig, ax2 = plt.subplots() from mpl_toolkits.axes_grid1 import make_axes_locatable divider = make_axes_locatable(ax2) - cax = divider.append_axes("right", size="5%", pad=0.1) + cax = divider.append_axes("right", size="5%", pad=0.1, label="fixed_colorbar") with warnings.catch_warnings(record=True) as _: ax2 = self.df.plot( column="pop_est", cmap="OrRd", legend=True, cax=cax, ax=ax2 ) - plot_height = ax2.get_figure().get_axes()[0].get_position().height - legend_height = ax2.get_figure().get_axes()[1].get_position().height + plot_height = _get_ax(fig, "").get_position().height + legend_height = _get_ax(fig, "fixed_colorbar").get_position().height assert abs(plot_height - legend_height) < 1e-6 + def test_empty_bins(self): + bins = np.arange(1, 11) / 10 + ax = self.df.plot( + "low_vals", + scheme="UserDefined", + classification_kwds={"bins": bins}, + legend=True, + ) + expected = np.array( + [ + [0.281412, 0.155834, 0.469201, 1.0], + [0.267004, 0.004874, 0.329415, 1.0], + [0.244972, 0.287675, 0.53726, 1.0], + ] + ) + assert all( + [ + (z == expected).all(axis=1).any() + for z in ax.collections[0].get_facecolors() + ] + ) + labels = [ + "0.00, 0.10", + "0.10, 0.20", + "0.20, 0.30", + "0.30, 0.40", + "0.40, 0.50", + "0.50, 0.60", + "0.60, 0.70", + "0.70, 0.80", + "0.80, 0.90", + "0.90, 1.00", + ] + legend = [t.get_text() for t in ax.get_legend().get_texts()] + assert labels == legend + + legend_colors_exp = [ + (0.267004, 0.004874, 0.329415, 1.0), + (0.281412, 0.155834, 0.469201, 1.0), + (0.244972, 0.287675, 0.53726, 1.0), + (0.190631, 0.407061, 0.556089, 1.0), + (0.147607, 0.511733, 0.557049, 1.0), + (0.119699, 0.61849, 0.536347, 1.0), + (0.20803, 0.718701, 0.472873, 1.0), + (0.430983, 0.808473, 0.346476, 1.0), + (0.709898, 0.868751, 0.169257, 1.0), + (0.993248, 0.906157, 0.143936, 1.0), + ] + + assert [ + line.get_markerfacecolor() for line in ax.get_legend().get_lines() + ] == legend_colors_exp + + ax2 = self.df.plot( + "mid_vals", + scheme="UserDefined", + classification_kwds={"bins": bins}, + legend=True, + ) + expected = np.array( + [ + [0.244972, 0.287675, 0.53726, 1.0], + [0.190631, 0.407061, 0.556089, 1.0], + [0.147607, 0.511733, 0.557049, 1.0], + [0.119699, 0.61849, 0.536347, 1.0], + [0.20803, 0.718701, 0.472873, 1.0], + ] + ) + assert all( + [ + (z == expected).all(axis=1).any() + for z in ax2.collections[0].get_facecolors() + ] + ) + + labels = [ + "-inf, 0.10", + "0.10, 0.20", + "0.20, 0.30", + "0.30, 0.40", + "0.40, 0.50", + "0.50, 0.60", + "0.60, 0.70", + "0.70, 0.80", + "0.80, 0.90", + "0.90, 1.00", + ] + legend = [t.get_text() for t in ax2.get_legend().get_texts()] + assert labels == legend + assert [ + line.get_markerfacecolor() for line in ax2.get_legend().get_lines() + ] == legend_colors_exp + + ax3 = self.df.plot( + "high_vals", + scheme="UserDefined", + classification_kwds={"bins": bins}, + legend=True, + ) + expected = np.array( + [ + [0.709898, 0.868751, 0.169257, 1.0], + [0.993248, 0.906157, 0.143936, 1.0], + [0.430983, 0.808473, 0.346476, 1.0], + ] + ) + assert all( + [ + (z == expected).all(axis=1).any() + for z in ax3.collections[0].get_facecolors() + ] + ) + + legend = [t.get_text() for t in ax3.get_legend().get_texts()] + assert labels == legend + + assert [ + line.get_markerfacecolor() for line in ax3.get_legend().get_lines() + ] == legend_colors_exp + + def test_equally_formatted_bins(self): + ax = self.nybb.plot( + "vals", + scheme="quantiles", + legend=True, + ) + labels = [t.get_text() for t in ax.get_legend().get_texts()] + expected = [ + "0.00, 0.00", + "0.00, 0.00", + "0.00, 0.00", + "0.00, 0.00", + "0.00, 0.01", + ] + assert labels == expected + + ax2 = self.nybb.plot( + "vals", scheme="quantiles", legend=True, legend_kwds=dict(fmt="{:.3f}") + ) + labels = [t.get_text() for t in ax2.get_legend().get_texts()] + expected = [ + "0.001, 0.002", + "0.002, 0.003", + "0.003, 0.003", + "0.003, 0.004", + "0.004, 0.005", + ] + assert labels == expected + class TestPlotCollections: def setup_method(self): @@ -1200,8 +1543,8 @@ class TestPlotCollections: coll = _plot_linestring_collection(ax, self.lines, self.values, vmin=3, vmax=5) fig.canvas.draw_idle() cmap = plt.get_cmap() - expected_colors = cmap([0]) - _check_colors(self.N, coll.get_color(), expected_colors) + expected_colors = [cmap(0)] + _check_colors(self.N, coll.get_color(), expected_colors * 3) ax.cla() def test_polygons(self): @@ -1216,7 +1559,7 @@ class TestPlotCollections: # default: single default matplotlib color coll = _plot_polygon_collection(ax, self.polygons) _check_colors(self.N, coll.get_facecolor(), [MPL_DFT_COLOR] * self.N) - _check_colors(self.N, coll.get_edgecolor(), ["k"] * self.N) + assert len(coll.get_edgecolor()) == 0 ax.cla() # default: color sets both facecolor and edgecolor @@ -1251,7 +1594,7 @@ class TestPlotCollections: # only setting facecolor keeps default for edgecolor coll = _plot_polygon_collection(ax, self.polygons, facecolor="g") _check_colors(self.N, coll.get_facecolor(), ["g"] * self.N) - _check_colors(self.N, coll.get_edgecolor(), ["k"] * self.N) + assert len(coll.get_edgecolor()) == 0 ax.cla() # custom facecolor and edgecolor @@ -1294,8 +1637,8 @@ class TestPlotCollections: coll = _plot_polygon_collection(ax, self.polygons, self.values, vmin=3, vmax=5) fig.canvas.draw_idle() cmap = plt.get_cmap() - exp_colors = cmap([0]) - _check_colors(self.N, coll.get_facecolor(), exp_colors) + exp_colors = [cmap(0)] + _check_colors(self.N, coll.get_facecolor(), exp_colors * 3) ax.cla() # override edgecolor @@ -1308,6 +1651,80 @@ class TestPlotCollections: ax.cla() +class TestGeoplotAccessor: + def setup_method(self): + geometries = [Polygon([(0, 0), (1, 0), (1, 1)]), Point(1, 3)] + x = [1, 2] + y = [10, 20] + self.gdf = GeoDataFrame( + {"geometry": geometries, "x": x, "y": y}, crs="EPSG:4326" + ) + self.df = pd.DataFrame({"x": x, "y": y}) + + def compare_figures(self, kind, fig_test, fig_ref, kwargs): + """Compare Figures.""" + ax_pandas_1 = fig_test.subplots() + self.df.plot(kind=kind, ax=ax_pandas_1, **kwargs) + ax_geopandas_1 = fig_ref.subplots() + self.gdf.plot(kind=kind, ax=ax_geopandas_1, **kwargs) + + ax_pandas_2 = fig_test.subplots() + getattr(self.df.plot, kind)(ax=ax_pandas_2, **kwargs) + ax_geopandas_2 = fig_ref.subplots() + getattr(self.gdf.plot, kind)(ax=ax_geopandas_2, **kwargs) + + _pandas_kinds = [] + + _pandas_kinds = GeoplotAccessor._pandas_kinds + + if MPL_DECORATORS: + + @pytest.mark.parametrize("kind", _pandas_kinds) + @check_figures_equal(extensions=["png", "pdf"]) + def test_pandas_kind(self, kind, fig_test, fig_ref): + """Test Pandas kind.""" + import importlib + + _scipy_dependent_kinds = ["kde", "density"] # Needs scipy + _y_kinds = ["pie"] # Needs y + _xy_kinds = ["scatter", "hexbin"] # Needs x & y + kwargs = {} + if kind in _scipy_dependent_kinds: + if not importlib.util.find_spec("scipy"): + with pytest.raises( + ModuleNotFoundError, match="No module named 'scipy'" + ): + self.gdf.plot(kind=kind) + elif kind in _y_kinds: + kwargs = {"y": "y"} + elif kind in _xy_kinds: + kwargs = {"x": "x", "y": "y"} + if kind == "hexbin": # increase gridsize to reduce duration + kwargs["gridsize"] = 10 + + self.compare_figures(kind, fig_test, fig_ref, kwargs) + plt.close("all") + + @check_figures_equal(extensions=["png", "pdf"]) + def test_geo_kind(self, fig_test, fig_ref): + """Test Geo kind.""" + ax1 = fig_test.subplots() + self.gdf.plot(ax=ax1) + ax2 = fig_ref.subplots() + getattr(self.gdf.plot, "geo")(ax=ax2) + plt.close("all") + + def test_invalid_kind(self): + """Test invalid kinds.""" + with pytest.raises(ValueError, match="error is not a valid plot kind"): + self.gdf.plot(kind="error") + with pytest.raises( + AttributeError, + match="'GeoplotAccessor' object has no attribute 'error'", + ): + self.gdf.plot.error() + + def test_column_values(): """ Check that the dataframe plot method returns same values with an @@ -1319,7 +1736,7 @@ def test_column_values(): polys = GeoSeries([t1, t2], index=list("AB")) df = GeoDataFrame({"geometry": polys, "values": [0, 1]}) - # Test with continous values + # Test with continuous values ax = df.plot(column="values") colors = ax.collections[0].get_facecolors() ax = df.plot(column=df["values"]) @@ -1339,11 +1756,30 @@ def test_column_values(): colors_array = ax.collections[0].get_facecolors() np.testing.assert_array_equal(colors, colors_array) - # Check raised error: is df rows number equal to column legth? + # Check raised error: is df rows number equal to column length? with pytest.raises(ValueError, match="different number of rows"): ax = df.plot(column=np.array([1, 2, 3])) +def test_polygon_patch(): + # test adapted from descartes by Sean Gillies + # (BSD license, https://pypi.org/project/descartes). + from geopandas.plotting import _PolygonPatch + from matplotlib.patches import PathPatch + + polygon = ( + Point(0, 0).buffer(10.0).difference(MultiPoint([(-5, 0), (5, 0)]).buffer(3.0)) + ) + + patch = _PolygonPatch(polygon) + assert isinstance(patch, PathPatch) + path = patch.get_path() + if compat.GEOS_GE_390: + assert len(path.vertices) == len(path.codes) == 195 + else: + assert len(path.vertices) == len(path.codes) == 198 + + def _check_colors(N, actual_colors, expected_colors, alpha=None): """ Asserts that the members of `collection` match the `expected_colors` @@ -1374,6 +1810,10 @@ def _check_colors(N, actual_colors, expected_colors, alpha=None): actual_colors = map(tuple, actual_colors) all_actual_colors = list(itertools.islice(itertools.cycle(actual_colors), N)) + assert len(all_actual_colors) == len(expected_colors), ( + "Different " "lengths of actual and expected colors!" + ) + for actual, expected in zip(all_actual_colors, expected_colors): assert actual == conv.to_rgba(expected, alpha=alpha), "{} != {}".format( actual, conv.to_rgba(expected, alpha=alpha) @@ -1381,17 +1821,39 @@ def _check_colors(N, actual_colors, expected_colors, alpha=None): def _style_to_linestring_onoffseq(linestyle, linewidth): - """ Converts a linestyle string representation, namely one of: - ['dashed', 'dotted', 'dashdot', 'solid'], - documented in `Collections.set_linestyle`, - to the form `onoffseq`. + """Converts a linestyle string representation, namely one of: + ['dashed', 'dotted', 'dashdot', 'solid'], + documented in `Collections.set_linestyle`, + to the form `onoffseq`. """ offset, dashes = matplotlib.lines._get_dash_pattern(linestyle) return matplotlib.lines._scale_dashes(offset, dashes, linewidth) def _style_to_vertices(markerstyle): - """ Converts a markerstyle string to a path. """ + """Converts a markerstyle string to a path.""" # TODO: Vertices values are twice the actual path; unclear, why. path = matplotlib.markers.MarkerStyle(markerstyle).get_path() return path.vertices / 2 + + +def _get_ax(fig, label): + """ + Helper function to not rely on the order of `fig.axes`. + Previously, we did `fig.axes[1]`, but in matplotlib 3.4 the order switched + and the colorbar ax was first and subplot ax second. + """ + if Version(matplotlib.__version__) < Version("3.0.0"): + if label == "": + return fig.axes[1] + elif label == "": + return fig.axes[0] + for ax in fig.axes: + if ax.get_label() == label: + return ax + else: + raise ValueError("no ax found with label {0}".format(label)) + + +def _get_colorbar_ax(fig): + return _get_ax(fig, "") diff --git a/geopandas/tests/test_sindex.py b/geopandas/tests/test_sindex.py index 241c672..0b53a8d 100644 --- a/geopandas/tests/test_sindex.py +++ b/geopandas/tests/test_sindex.py @@ -1,4 +1,4 @@ -import sys +from math import sqrt from shapely.geometry import ( Point, @@ -12,42 +12,45 @@ from numpy.testing import assert_array_equal import geopandas from geopandas import _compat as compat -from geopandas import GeoDataFrame, GeoSeries, read_file, sindex, datasets +from geopandas import GeoDataFrame, GeoSeries, read_file, datasets import pytest import numpy as np - -class TestNoSindex: - @pytest.mark.skipif(sindex.has_sindex(), reason="Spatial index present, skipping") - def test_no_sindex_installed(self): - """Checks that an error is raised when no spatial index is present.""" - with pytest.raises(ImportError): - sindex.get_sindex_class() - - @pytest.mark.skipif( - compat.HAS_RTREE or not compat.HAS_PYGEOS, - reason="rtree cannot be disabled via flags", - ) - def test_no_sindex_active(self): - """Checks that an error is given when rtree is not installed - and compat.USE_PYGEOS is False. - """ - state = compat.USE_PYGEOS # try to save state - compat.set_use_pygeos(False) - with pytest.raises(ImportError): - sindex.get_sindex_class() - compat.set_use_pygeos(state) # try to restore state +if compat.USE_PYGEOS: + import pygeos -@pytest.mark.skipif(sys.platform.startswith("win"), reason="fails on AppVeyor") -@pytest.mark.skipif(not sindex.has_sindex(), reason="Spatial index absent, skipping") +@pytest.mark.skip_no_sindex class TestSeriesSindex: + def test_has_sindex(self): + """Test the has_sindex method.""" + t1 = Polygon([(0, 0), (1, 0), (1, 1)]) + t2 = Polygon([(0, 0), (1, 1), (0, 1)]) + + d = GeoDataFrame({"geom": [t1, t2]}, geometry="geom") + assert not d.has_sindex + d.sindex + assert d.has_sindex + d.geometry.values._sindex = None + assert not d.has_sindex + d.sindex + assert d.has_sindex + + s = GeoSeries([t1, t2]) + assert not s.has_sindex + s.sindex + assert s.has_sindex + s.values._sindex = None + assert not s.has_sindex + s.sindex + assert s.has_sindex + def test_empty_geoseries(self): """Tests creating a spatial index from an empty GeoSeries.""" - with pytest.warns(FutureWarning, match="Generated spatial index is empty"): - # TODO: add checking len(GeoSeries().sindex) == 0 once deprecated - assert not GeoSeries(dtype=object).sindex + s = GeoSeries(dtype=object) + assert not s.sindex + assert len(s.sindex) == 0 def test_point(self): s = GeoSeries([Point(0, 0)]) @@ -60,12 +63,8 @@ class TestSeriesSindex: def test_empty_point(self): """Tests that a single empty Point results in an empty tree.""" s = GeoSeries([Point()]) - - with pytest.warns(FutureWarning, match="Generated spatial index is empty"): - # TODO: add checking len(s) == 0 once deprecated - assert not s.sindex - - assert s._sindex_generated is True + assert not s.sindex + assert len(s.sindex) == 0 def test_polygons(self): t1 = Polygon([(0, 0), (1, 0), (1, 1)]) @@ -86,43 +85,94 @@ class TestSeriesSindex: def test_lazy_build(self): s = GeoSeries([Point(0, 0)]) - assert s._sindex is None + assert s.values._sindex is None assert s.sindex.size == 1 - assert s._sindex is not None + assert s.values._sindex is not None + + def test_rebuild_on_item_change(self): + s = GeoSeries([Point(0, 0)]) + original_index = s.sindex + s.iloc[0] = Point(0, 0) + assert s.sindex is not original_index + + def test_rebuild_on_slice(self): + s = GeoSeries([Point(0, 0), Point(0, 0)]) + original_index = s.sindex + # Select a couple of rows + sliced = s.iloc[:1] + assert sliced.sindex is not original_index + # Select all rows + sliced = s.iloc[:] + assert sliced.sindex is original_index + # Select all rows and flip + sliced = s.iloc[::-1] + assert sliced.sindex is not original_index -@pytest.mark.skipif(sys.platform.startswith("win"), reason="fails on AppVeyor") -@pytest.mark.skipif(not sindex.has_sindex(), reason="Spatial index absent, skipping") +@pytest.mark.skip_no_sindex class TestFrameSindex: def setup_method(self): data = { "A": range(5), "B": range(-5, 0), - "location": [Point(x, y) for x, y in zip(range(5), range(5))], + "geom": [Point(x, y) for x, y in zip(range(5), range(5))], } - self.df = GeoDataFrame(data, geometry="location") + self.df = GeoDataFrame(data, geometry="geom") def test_sindex(self): self.df.crs = "epsg:4326" assert self.df.sindex.size == 5 - with pytest.warns(FutureWarning, match="`objects` is deprecated"): - # TODO: remove warning check once deprecated - hits = list(self.df.sindex.intersection((2.5, 2.5, 4, 4), objects=True)) + hits = list(self.df.sindex.intersection((2.5, 2.5, 4, 4))) assert len(hits) == 2 - assert hits[0].object == 3 + assert hits[0] == 3 def test_lazy_build(self): - assert self.df._sindex is None + assert self.df.geometry.values._sindex is None assert self.df.sindex.size == 5 - assert self.df._sindex is not None + assert self.df.geometry.values._sindex is not None def test_sindex_rebuild_on_set_geometry(self): # First build the sindex assert self.df.sindex is not None + original_index = self.df.sindex self.df.set_geometry( [Point(x, y) for x, y in zip(range(5, 10), range(5, 10))], inplace=True ) - assert self.df._sindex_generated is False + assert self.df.sindex is not original_index + + def test_rebuild_on_row_slice(self): + # Select a subset of rows rebuilds + original_index = self.df.sindex + sliced = self.df.iloc[:1] + assert sliced.sindex is not original_index + # Slicing all does not rebuild + original_index = self.df.sindex + sliced = self.df.iloc[:] + assert sliced.sindex is original_index + # Re-ordering rebuilds + sliced = self.df.iloc[::-1] + assert sliced.sindex is not original_index + + def test_rebuild_on_single_col_selection(self): + """Selecting a single column should not rebuild the spatial index.""" + # Selecting geometry column preserves the index + original_index = self.df.sindex + geometry_col = self.df["geom"] + assert geometry_col.sindex is original_index + geometry_col = self.df.geometry + assert geometry_col.sindex is original_index + + @pytest.mark.skipif( + not compat.PANDAS_GE_11, reason="Column selection returns a copy on pd<=1.1.0" + ) + def test_rebuild_on_multiple_col_selection(self): + """Selecting a subset of columns preserves the index.""" + original_index = self.df.sindex + # Selecting a subset of columns preserves the index + subset1 = self.df[["geom", "A"]] + assert subset1.sindex is original_index + subset2 = self.df[["A", "geom"]] + assert subset2.sindex is original_index # Skip to accommodate Shapely geometries being unhashable @@ -135,28 +185,22 @@ class TestJoinSindex: def test_merge_geo(self): # First check that we gets hits from the boros frame. tree = self.boros.sindex - with pytest.warns(FutureWarning, match="`objects` is deprecated"): - # TODO: remove warning check once deprecated - hits = tree.intersection((1012821.80, 229228.26), objects=True) - res = [self.boros.loc[hit.object]["BoroName"] for hit in hits] + hits = tree.intersection((1012821.80, 229228.26)) + res = [self.boros.iloc[hit]["BoroName"] for hit in hits] assert res == ["Bronx", "Queens"] # Check that we only get the Bronx from this view. first = self.boros[self.boros["BoroCode"] < 3] tree = first.sindex - with pytest.warns(FutureWarning, match="`objects` is deprecated"): - # TODO: remove warning check once deprecated - hits = tree.intersection((1012821.80, 229228.26), objects=True) - res = [first.loc[hit.object]["BoroName"] for hit in hits] + hits = tree.intersection((1012821.80, 229228.26)) + res = [first.iloc[hit]["BoroName"] for hit in hits] assert res == ["Bronx"] # Check that we only get Queens from this view. second = self.boros[self.boros["BoroCode"] >= 3] tree = second.sindex - with pytest.warns(FutureWarning, match="`objects` is deprecated"): - # TODO: remove warning check once deprecated - hits = tree.intersection((1012821.80, 229228.26), objects=True) - res = ([second.loc[hit.object]["BoroName"] for hit in hits],) + hits = tree.intersection((1012821.80, 229228.26)) + res = ([second.iloc[hit]["BoroName"] for hit in hits],) assert res == ["Queens"] # Get both the Bronx and Queens again. @@ -164,22 +208,20 @@ class TestJoinSindex: assert len(merged) == 5 assert merged.sindex.size == 5 tree = merged.sindex - with pytest.warns(FutureWarning, match="`objects` is deprecated"): - # TODO: remove warning check once deprecated - hits = tree.intersection((1012821.80, 229228.26), objects=True) - res = [merged.loc[hit.object]["BoroName"] for hit in hits] + hits = tree.intersection((1012821.80, 229228.26)) + res = [merged.iloc[hit]["BoroName"] for hit in hits] assert res == ["Bronx", "Queens"] -@pytest.mark.skipif(not sindex.has_sindex(), reason="Spatial index absent, skipping") +@pytest.mark.skip_no_sindex class TestPygeosInterface: def setup_method(self): data = { - "location": [Point(x, y) for x, y in zip(range(5), range(5))] + "geom": [Point(x, y) for x, y in zip(range(5), range(5))] + [box(10, 10, 20, 20)] # include a box geometry } - self.df = GeoDataFrame(data, geometry="location") - self.expected_size = len(data["location"]) + self.df = GeoDataFrame(data, geometry="geom") + self.expected_size = len(data["geom"]) # --------------------------- `intersection` tests -------------------------- # @pytest.mark.parametrize( @@ -256,6 +298,56 @@ class TestPygeosInterface: box(-0.5, -0.5, 1.5, 1.5), [], ), # bbox intersects but geom does not touch + ( + "contains", + box(10, 10, 20, 20), + [5], + ), # contains but does not contains_properly + ( + "covers", + box(-0.5, -0.5, 1, 1), + [0, 1], + ), # covers (0, 0) and (1, 1) + ( + "covers", + box(0.001, 0.001, 0.99, 0.99), + [], + ), # does not cover any + ( + "covers", + box(0, 0, 1, 1), + [0, 1], + ), # covers but does not contain + ( + "contains_properly", + box(0, 0, 1, 1), + [], + ), # intersects but does not contain + ( + "contains_properly", + box(0, 0, 1.001, 1.001), + [1], + ), # intersects 2 and contains 1 + ( + "contains_properly", + box(0.5, 0.5, 1.001, 1.001), + [1], + ), # intersects 1 and contains 1 + ( + "contains_properly", + box(0.5, 0.5, 1.5, 1.5), + [1], + ), # intersects and contains + ( + "contains_properly", + box(-1, -1, 2, 2), + [0, 1], + ), # intersects and contains multiple + ( + "contains_properly", + box(10, 10, 20, 20), + [], + ), # contains but does not contains_properly ), ) def test_query(self, predicate, test_geom, expected): @@ -264,8 +356,7 @@ class TestPygeosInterface: assert_array_equal(res, expected) def test_query_invalid_geometry(self): - """Tests the `query` method with invalid geometry. - """ + """Tests the `query` method with invalid geometry.""" with pytest.raises(TypeError): self.df.sindex.query("notavalidgeom") @@ -280,14 +371,12 @@ class TestPygeosInterface: ], ) def test_query_empty_geometry(self, test_geom, expected_value): - """Tests the `query` method with empty geometry. - """ + """Tests the `query` method with empty geometry.""" res = self.df.sindex.query(test_geom) assert_array_equal(res, expected_value) def test_query_invalid_predicate(self): - """Tests the `query` method with invalid predicates. - """ + """Tests the `query` method with invalid predicates.""" test_geom = box(-1, -1, -0.5, -0.5) with pytest.raises(ValueError): self.df.sindex.query(test_geom, predicate="test") @@ -324,10 +413,14 @@ class TestPygeosInterface: test_geo = test_df.geometry.values.data[0] res = tree_df.sindex.query(test_geo, sort=sort) + + # asserting the same elements + assert sorted(res) == sorted(expected) + # asserting the exact array can fail if sort=False try: assert_array_equal(res, expected) except AssertionError as e: - if not compat.USE_PYGEOS and sort is False: + if sort is False: pytest.xfail( "rtree results are known to be unordered, see " "https://github.com/geopandas/geopandas/issues/1337\n" @@ -357,7 +450,11 @@ class TestPygeosInterface: ("within", [(0.25, 0.28, 0.75, 0.75)], [[], []]), # does not intersect ("within", [(0, 0, 10, 10)], [[], []]), # intersects but is not within ("within", [(11, 11, 12, 12)], [[0], [5]]), # intersects and is within - ("contains", [(0, 0, 1, 1)], [[], []]), # intersects but does not contain + ( + "contains", + [(0, 0, 1, 1)], + [[], []], + ), # intersects and covers, but does not contain ( "contains", [(0, 0, 1.001, 1.001)], @@ -374,6 +471,62 @@ class TestPygeosInterface: [(-1, -1, 2, 2)], [[0, 0], [0, 1]], ), # intersects and contains multiple + ( + "contains", + [(10, 10, 20, 20)], + [[0], [5]], + ), # contains but does not contains_properly + ("touches", [(-1, -1, 0, 0)], [[0], [0]]), # bbox intersects and touches + ( + "touches", + [(-0.5, -0.5, 1.5, 1.5)], + [[], []], + ), # bbox intersects but geom does not touch + ( + "covers", + [(-0.5, -0.5, 1, 1)], + [[0, 0], [0, 1]], + ), # covers (0, 0) and (1, 1) + ( + "covers", + [(0.001, 0.001, 0.99, 0.99)], + [[], []], + ), # does not cover any + ( + "covers", + [(0, 0, 1, 1)], + [[0, 0], [0, 1]], + ), # covers but does not contain + ( + "contains_properly", + [(0, 0, 1, 1)], + [[], []], + ), # intersects but does not contain + ( + "contains_properly", + [(0, 0, 1.001, 1.001)], + [[0], [1]], + ), # intersects 2 and contains 1 + ( + "contains_properly", + [(0.5, 0.5, 1.001, 1.001)], + [[0], [1]], + ), # intersects 1 and contains 1 + ( + "contains_properly", + [(0.5, 0.5, 1.5, 1.5)], + [[0], [1]], + ), # intersects and contains + ( + "contains_properly", + [(-1, -1, 2, 2)], + [[0, 0], [0, 1]], + ), # intersects and contains multiple + ( + "contains_properly", + [(10, 10, 20, 20)], + [[], []], + ), # contains but does not contains_properly ), ) def test_query_bulk(self, predicate, test_geom, expected): @@ -400,8 +553,7 @@ class TestPygeosInterface: ], ) def test_query_bulk_empty_geometry(self, test_geoms, expected_value): - """Tests the `query_bulk` method with an empty geometry. - """ + """Tests the `query_bulk` method with an empty geometry.""" # pass through GeoSeries to have GeoPandas # determine if it should use shapely or pygeos geometry objects # note: for this test, test_geoms (note plural) is a list already @@ -410,23 +562,22 @@ class TestPygeosInterface: assert_array_equal(res, expected_value) def test_query_bulk_empty_input_array(self): - """Tests the `query_bulk` method with an empty input array. - """ + """Tests the `query_bulk` method with an empty input array.""" test_array = np.array([], dtype=object) expected_value = [[], []] res = self.df.sindex.query_bulk(test_array) assert_array_equal(res, expected_value) def test_query_bulk_invalid_input_geometry(self): - """Tests the `query_bulk` method with invalid input for the `geometry` parameter. + """ + Tests the `query_bulk` method with invalid input for the `geometry` parameter. """ test_array = "notanarray" with pytest.raises(TypeError): self.df.sindex.query_bulk(test_array) def test_query_bulk_invalid_predicate(self): - """Tests the `query_bulk` method with invalid predicates. - """ + """Tests the `query_bulk` method with invalid predicates.""" test_geom_bounds = (-1, -1, -0.5, -0.5) test_predicate = "test" @@ -503,10 +654,15 @@ class TestPygeosInterface: test_df = geopandas.GeoDataFrame(geometry=test_polys) res = tree_df.sindex.query_bulk(test_df.geometry, sort=sort) + + # asserting the same elements + assert sorted(res[0]) == sorted(expected[0]) + assert sorted(res[1]) == sorted(expected[1]) + # asserting the exact array can fail if sort=False try: assert_array_equal(res, expected) except AssertionError as e: - if not compat.USE_PYGEOS and sort is False: + if sort is False: pytest.xfail( "rtree results are known to be unordered, see " "https://github.com/geopandas/geopandas/issues/1337\n" @@ -515,11 +671,140 @@ class TestPygeosInterface: ) raise e + # ------------------------- `nearest` tests ------------------------- # + @pytest.mark.skipif( + compat.USE_PYGEOS, + reason=("RTree supports sindex.nearest with different behaviour"), + ) + def test_rtree_nearest_warns(self): + df = geopandas.GeoDataFrame({"geometry": []}) + with pytest.warns( + FutureWarning, match="sindex.nearest using the rtree backend" + ): + df.sindex.nearest((0, 0, 1, 1), num_results=2) + + @pytest.mark.skipif( + not (compat.USE_PYGEOS and not compat.PYGEOS_GE_010), + reason=("PyGEOS < 0.10 does not support sindex.nearest"), + ) + def test_pygeos_error(self): + df = geopandas.GeoDataFrame({"geometry": []}) + with pytest.raises(NotImplementedError, match="requires pygeos >= 0.10"): + df.sindex.nearest(None) + + @pytest.mark.skipif( + not (compat.USE_PYGEOS and compat.PYGEOS_GE_010), + reason=("PyGEOS >= 0.10 is required to test sindex.nearest"), + ) + @pytest.mark.parametrize("return_all", [True, False]) + @pytest.mark.parametrize( + "geometry,expected", + [ + ([0.25, 0.25], [[0], [0]]), + ([0.75, 0.75], [[0], [1]]), + ], + ) + def test_nearest_single(self, geometry, expected, return_all): + geoms = pygeos.points(np.arange(10), np.arange(10)) + df = geopandas.GeoDataFrame({"geometry": geoms}) + + p = Point(geometry) + res = df.sindex.nearest(p, return_all=return_all) + assert_array_equal(res, expected) + + p = pygeos.points(geometry) + res = df.sindex.nearest(p, return_all=return_all) + assert_array_equal(res, expected) + + @pytest.mark.skipif( + not compat.USE_PYGEOS or not compat.PYGEOS_GE_010, + reason=("PyGEOS >= 0.10 is required to test sindex.nearest"), + ) + @pytest.mark.parametrize("return_all", [True, False]) + @pytest.mark.parametrize( + "geometry,expected", + [ + ([(1, 1), (0, 0)], [[0, 1], [1, 0]]), + ([(1, 1), (0.25, 1)], [[0, 1], [1, 1]]), + ], + ) + def test_nearest_multi(self, geometry, expected, return_all): + geoms = pygeos.points(np.arange(10), np.arange(10)) + df = geopandas.GeoDataFrame({"geometry": geoms}) + + ps = [Point(p) for p in geometry] + res = df.sindex.nearest(ps, return_all=return_all) + assert_array_equal(res, expected) + + ps = pygeos.points(geometry) + res = df.sindex.nearest(ps, return_all=return_all) + assert_array_equal(res, expected) + + s = geopandas.GeoSeries(ps) + res = df.sindex.nearest(s, return_all=return_all) + assert_array_equal(res, expected) + + x, y = zip(*geometry) + ga = geopandas.points_from_xy(x, y) + res = df.sindex.nearest(ga, return_all=return_all) + assert_array_equal(res, expected) + + @pytest.mark.skipif( + not compat.USE_PYGEOS or not compat.PYGEOS_GE_010, + reason=("PyGEOS >= 0.10 is required to test sindex.nearest"), + ) + @pytest.mark.parametrize("return_all", [True, False]) + @pytest.mark.parametrize( + "geometry,expected", + [ + (None, [[], []]), + ([None], [[], []]), + ], + ) + def test_nearest_none(self, geometry, expected, return_all): + geoms = pygeos.points(np.arange(10), np.arange(10)) + df = geopandas.GeoDataFrame({"geometry": geoms}) + + res = df.sindex.nearest(geometry, return_all=return_all) + assert_array_equal(res, expected) + + @pytest.mark.skipif( + not compat.USE_PYGEOS or not compat.PYGEOS_GE_010, + reason=("PyGEOS >= 0.10 is required to test sindex.nearest"), + ) + @pytest.mark.parametrize("return_distance", [True, False]) + @pytest.mark.parametrize( + "return_all,max_distance,expected", + [ + (True, None, ([[0, 0, 1], [0, 1, 5]], [sqrt(0.5), sqrt(0.5), sqrt(50)])), + (False, None, ([[0, 1], [0, 5]], [sqrt(0.5), sqrt(50)])), + (True, 1, ([[0, 0], [0, 1]], [sqrt(0.5), sqrt(0.5)])), + (False, 1, ([[0], [0]], [sqrt(0.5)])), + ], + ) + def test_nearest_max_distance( + self, expected, max_distance, return_all, return_distance + ): + geoms = pygeos.points(np.arange(10), np.arange(10)) + df = geopandas.GeoDataFrame({"geometry": geoms}) + + ps = [Point(0.5, 0.5), Point(0, 10)] + res = df.sindex.nearest( + ps, + return_all=return_all, + max_distance=max_distance, + return_distance=return_distance, + ) + if return_distance: + assert_array_equal(res[0], expected[0]) + assert_array_equal(res[1], expected[1]) + else: + assert_array_equal(res, expected[0]) + # --------------------------- misc tests ---------------------------- # def test_empty_tree_geometries(self): - """Tests building sindex with interleaved empty geometries. - """ + """Tests building sindex with interleaved empty geometries.""" geoms = [Point(0, 0), None, Point(), Point(1, 1), Point()] df = geopandas.GeoDataFrame(geometry=geoms) assert df.sindex.query(Point(1, 1))[0] == 3 @@ -535,14 +820,15 @@ class TestPygeosInterface: def test_is_empty(self): """Tests the `is_empty` property.""" # create empty tree - cls_ = sindex.get_sindex_class() - empty = geopandas.GeoSeries(dtype=object) - tree = cls_(empty) - assert tree.is_empty + empty = geopandas.GeoSeries([], dtype=object) + assert empty.sindex.is_empty + empty = geopandas.GeoSeries([None]) + assert empty.sindex.is_empty + empty = geopandas.GeoSeries([Point()]) + assert empty.sindex.is_empty # create a non-empty tree non_empty = geopandas.GeoSeries([Point(0, 0)]) - tree = cls_(non_empty) - assert not tree.is_empty + assert not non_empty.sindex.is_empty @pytest.mark.parametrize( "predicate, expected_shape", @@ -563,3 +849,16 @@ class TestPygeosInterface: res = world.sindex.query_bulk(capitals.geometry, predicate) assert res.shape == expected_shape + + +@pytest.mark.skipif(not compat.HAS_RTREE, reason="no rtree installed") +def test_old_spatial_index_deprecated(): + t1 = Polygon([(0, 0), (1, 0), (1, 1)]) + t2 = Polygon([(0, 0), (1, 1), (0, 1)]) + + stream = ((i, item.bounds, None) for i, item in enumerate([t1, t2])) + + with pytest.warns(FutureWarning): + idx = geopandas.sindex.SpatialIndex(stream) + + assert list(idx.intersection((0, 0, 1, 1))) == [0, 1] diff --git a/geopandas/tests/test_testing.py b/geopandas/tests/test_testing.py index 582c01b..f85286d 100644 --- a/geopandas/tests/test_testing.py +++ b/geopandas/tests/test_testing.py @@ -46,6 +46,14 @@ s4 = s1.copy() s4.crs = 4326 s5 = s2.copy() s5.crs = 27700 + +s6 = GeoSeries( + [ + Polygon([(0, 3), (0, 0), (2, 0), (2, 2)]), + Polygon([(2, 2), (4, 2), (4, 4), (2, 4)]), + ] +) + df4 = GeoDataFrame( {"col1": [1, 2], "geometry": s1.copy(), "geom2": s4.copy(), "geom3": s5.copy()}, crs=3857, @@ -63,8 +71,15 @@ def test_geoseries(): assert_geoseries_equal(s3, s2, check_series_type=False, check_dtype=False) assert_geoseries_equal(s1, s4, check_series_type=False) - with pytest.raises(AssertionError): + with pytest.raises(AssertionError) as error: assert_geoseries_equal(s1, s2, check_less_precise=True) + assert "1 out of 2 geometries are not almost equal" in str(error.value) + assert "not almost equal: [0]" in str(error.value) + + with pytest.raises(AssertionError) as error: + assert_geoseries_equal(s2, s6, check_less_precise=False) + assert "1 out of 2 geometries are not equal" in str(error.value) + assert "not equal: [0]" in str(error.value) def test_geodataframe(): @@ -114,3 +129,11 @@ def test_ignore_crs_mismatch(): assert_geodataframe_equal(df1, df2, check_crs=False) assert len(record) == 0 + + +def test_almost_equal_but_not_equal(): + s_origin = GeoSeries([Point(0, 0)]) + s_almost_origin = GeoSeries([Point(0.0000001, 0)]) + assert_geoseries_equal(s_origin, s_almost_origin, check_less_precise=True) + with pytest.raises(AssertionError): + assert_geoseries_equal(s_origin, s_almost_origin) diff --git a/geopandas/tools/__init__.py b/geopandas/tools/__init__.py index 6c5fa61..495d504 100644 --- a/geopandas/tools/__init__.py +++ b/geopandas/tools/__init__.py @@ -1,16 +1,15 @@ -from .crs import explicit_crs_from_epsg from .geocoding import geocode, reverse_geocode from .overlay import overlay -from .sjoin import sjoin +from .sjoin import sjoin, sjoin_nearest from .util import collect from .clip import clip __all__ = [ "collect", - "explicit_crs_from_epsg", "geocode", "overlay", "reverse_geocode", "sjoin", + "sjoin_nearest", "clip", ] diff --git a/geopandas/tools/_show_versions.py b/geopandas/tools/_show_versions.py index 500b517..4798515 100644 --- a/geopandas/tools/_show_versions.py +++ b/geopandas/tools/_show_versions.py @@ -98,6 +98,7 @@ def _get_deps_info(): "psycopg2", "geoalchemy2", "pyarrow", + "pygeos", ] def get_version(module): diff --git a/geopandas/tools/clip.py b/geopandas/tools/clip.py index 8a1d6d1..27ff372 100644 --- a/geopandas/tools/clip.py +++ b/geopandas/tools/clip.py @@ -7,50 +7,22 @@ A module to clip vector data using GeoPandas. """ import warnings -import numpy as np -import pandas as pd - from shapely.geometry import Polygon, MultiPolygon from geopandas import GeoDataFrame, GeoSeries from geopandas.array import _check_crs, _crs_mismatch_warn -def _clip_points(gdf, poly): - """Clip point geometry to the polygon extent. +def _clip_gdf_with_polygon(gdf, poly): + """Clip geometry to the polygon extent. - Clip an input point GeoDataFrame to the polygon extent of the poly - parameter. Points that intersect the poly geometry are extracted with - associated attributes and returned. + Clip an input GeoDataFrame to the polygon extent of the poly + parameter. Parameters ---------- gdf : GeoDataFrame, GeoSeries - Composed of point geometry that will be clipped to the poly. - - poly : (Multi)Polygon - Reference geometry used to spatially clip the data. - - Returns - ------- - GeoDataFrame - The returned GeoDataFrame is a subset of gdf that intersects - with poly. - """ - return gdf.iloc[gdf.sindex.query(poly, predicate="intersects")] - - -def _clip_line_poly(gdf, poly): - """Clip line and polygon geometry to the polygon extent. - - Clip an input line or polygon to the polygon extent of the poly - parameter. Parts of Lines or Polygons that intersect the poly geometry are - extracted with associated attributes and returned. - - Parameters - ---------- - gdf : GeoDataFrame, GeoSeries - Line or polygon geometry that is clipped to poly. + Dataframe to clip. poly : (Multi)Polygon Reference polygon for clipping. @@ -63,13 +35,23 @@ def _clip_line_poly(gdf, poly): """ gdf_sub = gdf.iloc[gdf.sindex.query(poly, predicate="intersects")] + # For performance reasons points don't need to be intersected with poly + non_point_mask = gdf_sub.geom_type != "Point" + + if not non_point_mask.any(): + # only points, directly return + return gdf_sub + # Clip the data with the polygon if isinstance(gdf_sub, GeoDataFrame): clipped = gdf_sub.copy() - clipped["geometry"] = gdf_sub.intersection(poly) + clipped.loc[ + non_point_mask, clipped._geometry_column_name + ] = gdf_sub.geometry.values[non_point_mask].intersection(poly) else: # GeoSeries - clipped = gdf_sub.intersection(poly) + clipped = gdf_sub.copy() + clipped[non_point_mask] = gdf_sub.values[non_point_mask].intersection(poly) return clipped @@ -102,12 +84,15 @@ def clip(gdf, mask, keep_geom_type=False): Vector data (points, lines, polygons) from `gdf` clipped to polygon boundary from mask. + See also + -------- + GeoDataFrame.clip : equivalent GeoDataFrame method + GeoSeries.clip : equivalent GeoSeries method + Examples -------- Clip points (global cities) with a polygon (the South American continent): - >>> import geopandas - >>> path = >>> world = geopandas.read_file( ... geopandas.datasets.get_path('naturalearth_lowres')) >>> south_america = world[world['continent'] == "South America"] @@ -115,6 +100,7 @@ def clip(gdf, mask, keep_geom_type=False): ... geopandas.datasets.get_path('naturalearth_cities')) >>> capitals.shape (202, 2) + >>> sa_capitals = geopandas.clip(capitals, south_america) >>> sa_capitals.shape (12, 2) @@ -127,7 +113,7 @@ def clip(gdf, mask, keep_geom_type=False): if not isinstance(mask, (GeoDataFrame, GeoSeries, Polygon, MultiPolygon)): raise TypeError( "'mask' should be GeoDataFrame, GeoSeries or" - "(Multi)Polygon, got {}".format(type(gdf)) + "(Multi)Polygon, got {}".format(type(mask)) ) if isinstance(mask, (GeoDataFrame, GeoSeries)): @@ -150,42 +136,11 @@ def clip(gdf, mask, keep_geom_type=False): else: poly = mask - geom_types = gdf.geometry.type - poly_idx = np.asarray((geom_types == "Polygon") | (geom_types == "MultiPolygon")) - line_idx = np.asarray( - (geom_types == "LineString") - | (geom_types == "LinearRing") - | (geom_types == "MultiLineString") - ) - point_idx = np.asarray((geom_types == "Point") | (geom_types == "MultiPoint")) - geomcoll_idx = np.asarray((geom_types == "GeometryCollection")) - - if point_idx.any(): - point_gdf = _clip_points(gdf[point_idx], poly) - else: - point_gdf = None - - if poly_idx.any(): - poly_gdf = _clip_line_poly(gdf[poly_idx], poly) - else: - poly_gdf = None - - if line_idx.any(): - line_gdf = _clip_line_poly(gdf[line_idx], poly) - else: - line_gdf = None - - if geomcoll_idx.any(): - geomcoll_gdf = _clip_line_poly(gdf[geomcoll_idx], poly) - else: - geomcoll_gdf = None - - order = pd.Series(range(len(gdf)), index=gdf.index) - concat = pd.concat([point_gdf, line_gdf, poly_gdf, geomcoll_gdf]) + clipped = _clip_gdf_with_polygon(gdf, poly) if keep_geom_type: - geomcoll_concat = (concat.geom_type == "GeometryCollection").any() - geomcoll_orig = geomcoll_idx.any() + geomcoll_concat = (clipped.geom_type == "GeometryCollection").any() + geomcoll_orig = (gdf.geom_type == "GeometryCollection").any() new_collection = geomcoll_concat and not geomcoll_orig @@ -211,9 +166,9 @@ def clip(gdf, mask, keep_geom_type=False): # Check how many geometry types are in the clipped GeoDataFrame clip_types_total = sum( [ - concat.geom_type.isin(polys).any(), - concat.geom_type.isin(lines).any(), - concat.geom_type.isin(points).any(), + clipped.geom_type.isin(polys).any(), + clipped.geom_type.isin(lines).any(), + clipped.geom_type.isin(points).any(), ] ) @@ -227,21 +182,10 @@ def clip(gdf, mask, keep_geom_type=False): elif new_collection or more_types: orig_type = gdf.geom_type.iloc[0] if new_collection: - concat = concat.explode() + clipped = clipped.explode(index_parts=False) if orig_type in polys: - concat = concat.loc[concat.geom_type.isin(polys)] + clipped = clipped.loc[clipped.geom_type.isin(polys)] elif orig_type in lines: - concat = concat.loc[concat.geom_type.isin(lines)] + clipped = clipped.loc[clipped.geom_type.isin(lines)] - # Return empty GeoDataFrame or GeoSeries if no shapes remain - if len(concat) == 0: - return gdf.iloc[:0] - - # Preserve the original order of the input - if isinstance(concat, GeoDataFrame): - concat["_order"] = order - return concat.sort_values(by="_order").drop(columns="_order") - else: - concat = GeoDataFrame(geometry=concat) - concat["_order"] = order - return concat.sort_values(by="_order").geometry + return clipped diff --git a/geopandas/tools/crs.py b/geopandas/tools/crs.py deleted file mode 100644 index fadc68a..0000000 --- a/geopandas/tools/crs.py +++ /dev/null @@ -1,57 +0,0 @@ -import warnings - -from pyproj import CRS - - -def explicit_crs_from_epsg(crs=None, epsg=None): - """ - Gets full/explicit CRS from EPSG code provided. - - Parameters - ---------- - crs : dict or string, default None - An existing crs dict or Proj string with the 'init' key specifying an EPSG code - epsg : string or int, default None - The EPSG code to lookup - """ - warnings.warn( - "explicit_crs_from_epsg is deprecated. " - "You can set the epsg on the GeoDataFrame (gdf) using gdf.crs=epsg", - FutureWarning, - stacklevel=2, - ) - if crs is not None: - return CRS.from_user_input(crs) - elif epsg is not None: - return CRS.from_epsg(epsg) - raise ValueError("Must pass either crs or epsg.") - - -def epsg_from_crs(crs): - """ - Returns an epsg code from a crs dict or Proj string. - - Parameters - ---------- - crs : dict or string, default None - A crs dict or Proj string - - """ - warnings.warn( - "epsg_from_crs is deprecated. " - "You can get the epsg code from GeoDataFrame (gdf) " - "using gdf.crs.to_epsg()", - FutureWarning, - stacklevel=2, - ) - crs = CRS.from_user_input(crs) - if "init=epsg" in crs.to_string().lower(): - epsg_code = crs.to_epsg(0) - else: - epsg_code = crs.to_epsg() - return epsg_code - - -def get_epsg_file_contents(): - warnings.warn("get_epsg_file_contents is deprecated.", FutureWarning, stacklevel=2) - return "" diff --git a/geopandas/tools/geocoding.py b/geopandas/tools/geocoding.py index 4e3a78f..bba8bb6 100644 --- a/geopandas/tools/geocoding.py +++ b/geopandas/tools/geocoding.py @@ -1,7 +1,6 @@ from collections import defaultdict import time -import numpy as np import pandas as pd from shapely.geometry import Point @@ -32,13 +31,12 @@ def geocode(strings, provider=None, **kwargs): strings : list or Series of addresses to geocode provider : str or geopy.geocoder Specifies geocoding service to use. If none is provided, - will use 'geocodefarm' with a rate limit applied (see the geocodefarm - terms of service at: - https://geocode.farm/geocoding/free-api-documentation/ ). + will use 'photon' (see the Photon's terms of service at: + https://photon.komoot.io). Either the string name used by geopy (as specified in geopy.geocoders.SERVICE_TO_GEOCODER) or a geopy Geocoder instance - (e.g., geopy.geocoders.GeocodeFarm) may be used. + (e.g., geopy.geocoders.Photon) may be used. Some providers require additional arguments such as access keys See each geocoder's specific parameters in geopy.geocoders @@ -53,22 +51,18 @@ def geocode(strings, provider=None, **kwargs): Examples -------- - >>> df = geocode(['boston, ma', '1600 pennsylvania ave. washington, dc']) - >>> df - address \\ - 0 Boston, MA, USA - 1 1600 Pennsylvania Avenue Northwest, President'... - geometry - 0 POINT (-71.0597732 42.3584308) - 1 POINT (-77.0365305 38.8977332) + >>> df = geopandas.tools.geocode( # doctest: +SKIP + ... ["boston, ma", "1600 pennsylvania ave. washington, dc"] + ... ) + >>> df # doctest: +SKIP + geometry address + 0 POINT (-71.05863 42.35899) Boston, MA, United States + 1 POINT (-77.03651 38.89766) 1600 Pennsylvania Ave NW, Washington, DC 20006... """ if provider is None: - # https://geocode.farm/geocoding/free-api-documentation/ - provider = "geocodefarm" - throttle_time = 0.25 - else: - throttle_time = _get_throttle_time(provider) + provider = "photon" + throttle_time = _get_throttle_time(provider) return _query(strings, True, provider, throttle_time, **kwargs) @@ -87,13 +81,12 @@ def reverse_geocode(points, provider=None, **kwargs): y coordinate is latitude provider : str or geopy.geocoder (opt) Specifies geocoding service to use. If none is provided, - will use 'geocodefarm' with a rate limit applied (see the geocodefarm - terms of service at: - https://geocode.farm/geocoding/free-api-documentation/ ). + will use 'photon' (see the Photon's terms of service at: + https://photon.komoot.io). Either the string name used by geopy (as specified in geopy.geocoders.SERVICE_TO_GEOCODER) or a geopy Geocoder instance - (e.g., geopy.geocoders.GeocodeFarm) may be used. + (e.g., geopy.geocoders.Photon) may be used. Some providers require additional arguments such as access keys See each geocoder's specific parameters in geopy.geocoders @@ -108,23 +101,19 @@ def reverse_geocode(points, provider=None, **kwargs): Examples -------- - >>> df = reverse_geocode([Point(-71.0594869, 42.3584697), - Point(-77.0365305, 38.8977332)]) - >>> df - address \\ - 0 29 Court Square, Boston, MA 02108, USA - 1 1600 Pennsylvania Avenue Northwest, President'... - geometry - 0 POINT (-71.0594869 42.3584697) - 1 POINT (-77.0365305 38.8977332) + >>> from shapely.geometry import Point + >>> df = geopandas.tools.reverse_geocode( # doctest: +SKIP + ... [Point(-71.0594869, 42.3584697), Point(-77.0365305, 38.8977332)] + ... ) + >>> df # doctest: +SKIP + geometry address + 0 POINT (-71.05941 42.35837) 29 Court Sq, Boston, MA 02108, United States + 1 POINT (-77.03641 38.89766) 1600 Pennsylvania Ave NW, Washington, DC 20006... """ if provider is None: - # https://geocode.farm/geocoding/free-api-documentation/ - provider = "geocodefarm" - throttle_time = 0.25 - else: - throttle_time = _get_throttle_time(provider) + provider = "photon" + throttle_time = _get_throttle_time(provider) return _query(points, False, provider, throttle_time, **kwargs) @@ -134,8 +123,12 @@ def _query(data, forward, provider, throttle_time, **kwargs): from geopy.geocoders.base import GeocoderQueryError from geopy.geocoders import get_geocoder_for_service - if not isinstance(data, pd.Series): - data = pd.Series(data) + if forward: + if not isinstance(data, pd.Series): + data = pd.Series(data) + else: + if not isinstance(data, geopandas.GeoSeries): + data = geopandas.GeoSeries(data) if isinstance(provider, str): provider = get_geocoder_for_service(provider) @@ -169,16 +162,19 @@ def _prepare_geocode_result(results): index = [] for i, s in results.items(): - address, loc = s - # loc is lat, lon and we want lon, lat - if loc is None: + if s is None: p = Point() - else: - p = Point(loc[1], loc[0]) + address = None - if address is None: - address = np.nan + else: + address, loc = s + + # loc is lat, lon and we want lon, lat + if loc is None: + p = Point() + else: + p = Point(loc[1], loc[0]) d["geometry"].append(p) d["address"].append(address) diff --git a/geopandas/tools/overlay.py b/geopandas/tools/overlay.py index 514173c..babb67a 100644 --- a/geopandas/tools/overlay.py +++ b/geopandas/tools/overlay.py @@ -59,11 +59,17 @@ def _overlay_intersection(df1, df2): return GeoDataFrame(dfinter, geometry=geom_intersect, crs=df1.crs) else: - return GeoDataFrame( - [], - columns=list(set(df1.columns).union(df2.columns)) + ["__idx1", "__idx2"], - crs=df1.crs, + result = df1.iloc[:0].merge( + df2.iloc[:0].drop(df2.geometry.name, axis=1), + left_index=True, + right_index=True, + suffixes=("_1", "_2"), ) + result["__idx1"] = None + result["__idx2"] = None + return result[ + result.columns.drop(df1.geometry.name).tolist() + [df1.geometry.name] + ] def _overlay_difference(df1, df2): @@ -137,7 +143,7 @@ def _overlay_union(df1, df2): return dfunion.reindex(columns=columns) -def overlay(df1, df2, how="intersection", make_valid=True, keep_geom_type=True): +def overlay(df1, df2, how="intersection", keep_geom_type=None, make_valid=True): """Perform spatial overlay between two GeoDataFrames. Currently only supports data GeoDataFrames with uniform geometry types, @@ -145,6 +151,8 @@ def overlay(df1, df2, how="intersection", make_valid=True, keep_geom_type=True): combination of (Multi)LineString and LinearRing shapes. Implements several methods that are all effectively subsets of the union. + See the User Guide page :doc:`../../user_guide/set_operations` for details. + Parameters ---------- df1 : GeoDataFrame @@ -154,7 +162,12 @@ def overlay(df1, df2, how="intersection", make_valid=True, keep_geom_type=True): 'identity', 'symmetric_difference' or 'difference'. keep_geom_type : bool If True, return only geometries of the same geometry type as df1 has, - if False, return all resulting gemetries. + if False, return all resulting geometries. Default is None, + which will set keep_geom_type to True but warn upon dropping + geometries. + make_valid : bool, default True + If True, any invalid input geometries are corrected with a call to `buffer(0)`, + if False, a `ValueError` is raised if any input geometries are invalid. Returns ------- @@ -162,6 +175,61 @@ def overlay(df1, df2, how="intersection", make_valid=True, keep_geom_type=True): GeoDataFrame with new set of polygons and attributes resulting from the overlay + Examples + -------- + >>> from shapely.geometry import Polygon + >>> polys1 = geopandas.GeoSeries([Polygon([(0,0), (2,0), (2,2), (0,2)]), + ... Polygon([(2,2), (4,2), (4,4), (2,4)])]) + >>> polys2 = geopandas.GeoSeries([Polygon([(1,1), (3,1), (3,3), (1,3)]), + ... Polygon([(3,3), (5,3), (5,5), (3,5)])]) + >>> df1 = geopandas.GeoDataFrame({'geometry': polys1, 'df1_data':[1,2]}) + >>> df2 = geopandas.GeoDataFrame({'geometry': polys2, 'df2_data':[1,2]}) + + >>> geopandas.overlay(df1, df2, how='union') + df1_data df2_data geometry + 0 1.0 1.0 POLYGON ((2.00000 2.00000, 2.00000 1.00000, 1.... + 1 2.0 1.0 POLYGON ((2.00000 2.00000, 2.00000 3.00000, 3.... + 2 2.0 2.0 POLYGON ((4.00000 4.00000, 4.00000 3.00000, 3.... + 3 1.0 NaN POLYGON ((2.00000 0.00000, 0.00000 0.00000, 0.... + 4 2.0 NaN MULTIPOLYGON (((3.00000 3.00000, 4.00000 3.000... + 5 NaN 1.0 MULTIPOLYGON (((2.00000 2.00000, 3.00000 2.000... + 6 NaN 2.0 POLYGON ((3.00000 5.00000, 5.00000 5.00000, 5.... + + >>> geopandas.overlay(df1, df2, how='intersection') + df1_data df2_data geometry + 0 1 1 POLYGON ((2.00000 2.00000, 2.00000 1.00000, 1.... + 1 2 1 POLYGON ((2.00000 2.00000, 2.00000 3.00000, 3.... + 2 2 2 POLYGON ((4.00000 4.00000, 4.00000 3.00000, 3.... + + >>> geopandas.overlay(df1, df2, how='symmetric_difference') + df1_data df2_data geometry + 0 1.0 NaN POLYGON ((2.00000 0.00000, 0.00000 0.00000, 0.... + 1 2.0 NaN MULTIPOLYGON (((3.00000 3.00000, 4.00000 3.000... + 2 NaN 1.0 MULTIPOLYGON (((2.00000 2.00000, 3.00000 2.000... + 3 NaN 2.0 POLYGON ((3.00000 5.00000, 5.00000 5.00000, 5.... + + >>> geopandas.overlay(df1, df2, how='difference') + geometry df1_data + 0 POLYGON ((2.00000 0.00000, 0.00000 0.00000, 0.... 1 + 1 MULTIPOLYGON (((3.00000 3.00000, 4.00000 3.000... 2 + + >>> geopandas.overlay(df1, df2, how='identity') + df1_data df2_data geometry + 0 1.0 1.0 POLYGON ((2.00000 2.00000, 2.00000 1.00000, 1.... + 1 2.0 1.0 POLYGON ((2.00000 2.00000, 2.00000 3.00000, 3.... + 2 2.0 2.0 POLYGON ((4.00000 4.00000, 4.00000 3.00000, 3.... + 3 1.0 NaN POLYGON ((2.00000 0.00000, 0.00000 0.00000, 0.... + 4 2.0 NaN MULTIPOLYGON (((3.00000 3.00000, 4.00000 3.000... + + See also + -------- + sjoin : spatial join + GeoDataFrame.overlay : equivalent method + + Notes + ------ + Every operation in GeoPandas is planar, i.e. the potential third + dimension is not taken into account. """ # Allowed operations allowed_hows = [ @@ -185,6 +253,12 @@ def overlay(df1, df2, how="intersection", make_valid=True, keep_geom_type=True): if not _check_crs(df1, df2): _crs_mismatch_warn(df1, df2, stacklevel=3) + if keep_geom_type is None: + keep_geom_type = True + keep_geom_type_warning = True + else: + keep_geom_type_warning = False + polys = ["Polygon", "MultiPolygon"] lines = ["LineString", "MultiLineString", "LinearRing"] points = ["Point", "MultiPoint"] @@ -197,18 +271,48 @@ def overlay(df1, df2, how="intersection", make_valid=True, keep_geom_type=True): "df{} contains mixed geometry types.".format(i + 1) ) - # Computations - df1 = df1.copy() - df2 = df2.copy() - if df1.geom_type.isin(polys).all(): - df1[df1._geometry_column_name] = df1.geometry.buffer(0) - if df2.geom_type.isin(polys).all(): - df2[df2._geometry_column_name] = df2.geometry.buffer(0) + if how == "intersection": + box_gdf1 = df1.total_bounds + box_gdf2 = df2.total_bounds - with warnings.catch_warnings(): # CRS checked above, supress array-level warning + if not ( + ((box_gdf1[0] <= box_gdf2[2]) and (box_gdf2[0] <= box_gdf1[2])) + and ((box_gdf1[1] <= box_gdf2[3]) and (box_gdf2[1] <= box_gdf1[3])) + ): + result = df1.iloc[:0].merge( + df2.iloc[:0].drop(df2.geometry.name, axis=1), + left_index=True, + right_index=True, + suffixes=("_1", "_2"), + ) + return result[ + result.columns.drop(df1.geometry.name).tolist() + [df1.geometry.name] + ] + + # Computations + def _make_valid(df): + df = df.copy() + if df.geom_type.isin(polys).all(): + mask = ~df.geometry.is_valid + col = df._geometry_column_name + if make_valid: + df.loc[mask, col] = df.loc[mask, col].buffer(0) + elif mask.any(): + raise ValueError( + "You have passed make_valid=False along with " + f"{mask.sum()} invalid input geometries. " + "Use make_valid=True or make sure that all geometries " + "are valid before using overlay." + ) + return df + + df1 = _make_valid(df1) + df2 = _make_valid(df2) + + with warnings.catch_warnings(): # CRS checked above, suppress array-level warning warnings.filterwarnings("ignore", message="CRS mismatch between the CRS") if how == "difference": - return _overlay_difference(df1, df2) + result = _overlay_difference(df1, df2) elif how == "intersection": result = _overlay_intersection(df1, df2) elif how == "symmetric_difference": @@ -219,17 +323,73 @@ def overlay(df1, df2, how="intersection", make_valid=True, keep_geom_type=True): dfunion = _overlay_union(df1, df2) result = dfunion[dfunion["__idx1"].notnull()].copy() + if how in ["intersection", "symmetric_difference", "union", "identity"]: + result.drop(["__idx1", "__idx2"], axis=1, inplace=True) + if keep_geom_type: - type = df1.geom_type.iloc[0] - if type in polys: + geom_type = df1.geom_type.iloc[0] + + # First we filter the geometry types inside GeometryCollections objects + # (e.g. GeometryCollection([polygon, point]) -> polygon) + # we do this separately on only the relevant rows, as this is an expensive + # operation (an expensive no-op for geometry types other than collections) + is_collection = result.geom_type == "GeometryCollection" + if is_collection.any(): + geom_col = result._geometry_column_name + collections = result[[geom_col]][is_collection] + + exploded = collections.reset_index(drop=True).explode(index_parts=True) + exploded = exploded.reset_index(level=0) + + orig_num_geoms_exploded = exploded.shape[0] + if geom_type in polys: + exploded.loc[~exploded.geom_type.isin(polys), geom_col] = None + elif geom_type in lines: + exploded.loc[~exploded.geom_type.isin(lines), geom_col] = None + elif geom_type in points: + exploded.loc[~exploded.geom_type.isin(points), geom_col] = None + else: + raise TypeError( + "`keep_geom_type` does not support {}.".format(geom_type) + ) + num_dropped_collection = ( + orig_num_geoms_exploded - exploded.geometry.isna().sum() + ) + + # level_0 created with above reset_index operation + # and represents the original geometry collections + # TODO avoiding dissolve to call unary_union in this case could further + # improve performance (we only need to collect geometries in their + # respective Multi version) + dissolved = exploded.dissolve(by="level_0") + result.loc[is_collection, geom_col] = dissolved[geom_col].values + else: + num_dropped_collection = 0 + + # Now we filter all geometries (in theory we don't need to do this + # again for the rows handled above for GeometryCollections, but filtering + # them out is probably more expensive as simply including them when this + # is typically about only a few rows) + orig_num_geoms = result.shape[0] + if geom_type in polys: result = result.loc[result.geom_type.isin(polys)] - elif type in lines: + elif geom_type in lines: result = result.loc[result.geom_type.isin(lines)] - elif type in points: + elif geom_type in points: result = result.loc[result.geom_type.isin(points)] else: - raise TypeError("`keep_geom_type` does not support {}.".format(type)) + raise TypeError("`keep_geom_type` does not support {}.".format(geom_type)) + num_dropped = orig_num_geoms - result.shape[0] + + if (num_dropped > 0 or num_dropped_collection > 0) and keep_geom_type_warning: + warnings.warn( + "`keep_geom_type=True` in overlay resulted in {} dropped " + "geometries of different geometry types than df1 has. " + "Set `keep_geom_type=False` to retain all " + "geometries".format(num_dropped + num_dropped_collection), + UserWarning, + stacklevel=2, + ) result.reset_index(drop=True, inplace=True) - result.drop(["__idx1", "__idx2"], axis=1, inplace=True) return result diff --git a/geopandas/tools/sjoin.py b/geopandas/tools/sjoin.py index 8e01410..c693ca1 100644 --- a/geopandas/tools/sjoin.py +++ b/geopandas/tools/sjoin.py @@ -1,16 +1,28 @@ +from typing import Optional import warnings +import numpy as np import pandas as pd from geopandas import GeoDataFrame +from geopandas import _compat as compat from geopandas.array import _check_crs, _crs_mismatch_warn def sjoin( - left_df, right_df, how="inner", op="intersects", lsuffix="left", rsuffix="right" + left_df, + right_df, + how="inner", + predicate="intersects", + lsuffix="left", + rsuffix="right", + **kwargs, ): """Spatial join of two GeoDataFrames. + See the User Guide page :doc:`../../user_guide/mergingdata` for details. + + Parameters ---------- left_df, right_df : GeoDataFrames @@ -21,14 +33,118 @@ def sjoin( * 'right': use keys from right_df; retain only right_df geometry column * 'inner': use intersection of keys from both dfs; retain only left_df geometry column - op : string, default 'intersects' - Binary predicate, one of {'intersects', 'contains', 'within'}. - See http://shapely.readthedocs.io/en/latest/manual.html#binary-predicates. + predicate : string, default 'intersects' + Binary predicate. Valid values are determined by the spatial index used. + You can check the valid values in left_df or right_df as + ``left_df.sindex.valid_query_predicates`` or + ``right_df.sindex.valid_query_predicates`` + Replaces deprecated ``op`` parameter. lsuffix : string, default 'left' Suffix to apply to overlapping column names (left GeoDataFrame). rsuffix : string, default 'right' Suffix to apply to overlapping column names (right GeoDataFrame). + Examples + -------- + >>> countries = geopandas.read_file(geopandas.datasets.get_\ +path("naturalearth_lowres")) + >>> cities = geopandas.read_file(geopandas.datasets.get_path("naturalearth_cities")) + >>> countries.head() # doctest: +SKIP + pop_est continent name \ +iso_a3 gdp_md_est geometry + 0 920938 Oceania Fiji FJI 8374.0 MULTIPOLY\ +GON (((180.00000 -16.06713, 180.00000... + 1 53950935 Africa Tanzania TZA 150600.0 POLYGON (\ +(33.90371 -0.95000, 34.07262 -1.05982... + 2 603253 Africa W. Sahara ESH 906.5 POLYGON (\ +(-8.66559 27.65643, -8.66512 27.58948... + 3 35623680 North America Canada CAN 1674000.0 MULTIPOLY\ +GON (((-122.84000 49.00000, -122.9742... + 4 326625791 North America United States of America USA 18560000.0 MULTIPOLY\ +GON (((-122.84000 49.00000, -120.0000... + >>> cities.head() + name geometry + 0 Vatican City POINT (12.45339 41.90328) + 1 San Marino POINT (12.44177 43.93610) + 2 Vaduz POINT (9.51667 47.13372) + 3 Luxembourg POINT (6.13000 49.61166) + 4 Palikir POINT (158.14997 6.91664) + + >>> cities_w_country_data = geopandas.sjoin(cities, countries) + >>> cities_w_country_data.head() # doctest: +SKIP + name_left geometry index_right pop_est continent name_\ +right iso_a3 gdp_md_est + 0 Vatican City POINT (12.45339 41.90328) 141 62137802 Europe \ +Italy ITA 2221000.0 + 1 San Marino POINT (12.44177 43.93610) 141 62137802 Europe \ +Italy ITA 2221000.0 + 192 Rome POINT (12.48131 41.89790) 141 62137802 Europe \ +Italy ITA 2221000.0 + 2 Vaduz POINT (9.51667 47.13372) 114 8754413 Europe Au\ +stria AUT 416600.0 + 184 Vienna POINT (16.36469 48.20196) 114 8754413 Europe Au\ +stria AUT 416600.0 + + See also + -------- + overlay : overlay operation resulting in a new geometry + GeoDataFrame.sjoin : equivalent method + + Notes + ------ + Every operation in GeoPandas is planar, i.e. the potential third + dimension is not taken into account. + """ + if "op" in kwargs: + op = kwargs.pop("op") + deprecation_message = ( + "The `op` parameter is deprecated and will be removed" + " in a future release. Please use the `predicate` parameter" + " instead." + ) + if predicate != "intersects" and op != predicate: + override_message = ( + "A non-default value for `predicate` was passed" + f' (got `predicate="{predicate}"`' + f' in combination with `op="{op}"`).' + " The value of `predicate` will be overridden by the value of `op`," + " , which may result in unexpected behavior." + f"\n{deprecation_message}" + ) + warnings.warn(override_message, UserWarning, stacklevel=4) + else: + warnings.warn(deprecation_message, FutureWarning, stacklevel=4) + predicate = op + if kwargs: + first = next(iter(kwargs.keys())) + raise TypeError(f"sjoin() got an unexpected keyword argument '{first}'") + + _basic_checks(left_df, right_df, how, lsuffix, rsuffix) + + indices = _geom_predicate_query(left_df, right_df, predicate) + + joined = _frame_join(indices, left_df, right_df, how, lsuffix, rsuffix) + + return joined + + +def _basic_checks(left_df, right_df, how, lsuffix, rsuffix): + """Checks the validity of join input parameters. + + `how` must be one of the valid options. + `'index_'` concatenated with `lsuffix` or `rsuffix` must not already + exist as columns in the left or right data frames. + + Parameters + ------------ + left_df : GeoDataFrame + right_df : GeoData Frame + how : str, one of 'left', 'right', 'inner' + join type + lsuffix : str + left index suffix + rsuffix : str + right index suffix """ if not isinstance(left_df, GeoDataFrame): raise ValueError( @@ -43,20 +159,14 @@ def sjoin( allowed_hows = ["left", "right", "inner"] if how not in allowed_hows: raise ValueError( - '`how` was "%s" but is expected to be in %s' % (how, allowed_hows) - ) - - allowed_ops = ["contains", "within", "intersects"] - if op not in allowed_ops: - raise ValueError( - '`op` was "%s" but is expected to be in %s' % (op, allowed_ops) + '`how` was "{}" but is expected to be in {}'.format(how, allowed_hows) ) if not _check_crs(left_df, right_df): - _crs_mismatch_warn(left_df, right_df, stacklevel=3) + _crs_mismatch_warn(left_df, right_df, stacklevel=4) - index_left = "index_%s" % lsuffix - index_right = "index_%s" % rsuffix + index_left = "index_{}".format(lsuffix) + index_right = "index_{}".format(rsuffix) # due to GH 352 if any(left_df.columns.isin([index_left, index_right])) or any( @@ -67,14 +177,33 @@ def sjoin( " joined".format(index_left, index_right) ) - # query index + +def _geom_predicate_query(left_df, right_df, predicate): + """Compute geometric comparisons and get matching indices. + + Parameters + ---------- + left_df : GeoDataFrame + right_df : GeoDataFrame + predicate : string + Binary predicate to query. + + Returns + ------- + DataFrame + DataFrame with matching indices in + columns named `_key_left` and `_key_right`. + """ with warnings.catch_warnings(): # We don't need to show our own warning here # TODO remove this once the deprecation has been enforced warnings.filterwarnings( "ignore", "Generated spatial index is empty", FutureWarning ) - if op == "within": + + original_predicate = predicate + + if predicate == "within": # within is implemented as the inverse of contains # contains is a faster predicate # see discussion at https://github.com/geopandas/geopandas/pull/1421 @@ -84,47 +213,78 @@ def sjoin( else: # all other predicates are symmetric # keep them the same - predicate = op sindex = right_df.sindex input_geoms = left_df.geometry if sindex: l_idx, r_idx = sindex.query_bulk(input_geoms, predicate=predicate, sort=False) - result = pd.DataFrame({"_key_left": l_idx, "_key_right": r_idx}) + indices = pd.DataFrame({"_key_left": l_idx, "_key_right": r_idx}) else: # when sindex is empty / has no valid geometries - result = pd.DataFrame(columns=["_key_left", "_key_right"], dtype=float) - if op == "within": + indices = pd.DataFrame(columns=["_key_left", "_key_right"], dtype=float) + + if original_predicate == "within": # within is implemented as the inverse of contains # flip back the results - result = result.rename( + indices = indices.rename( columns={"_key_left": "_key_right", "_key_right": "_key_left"} ) + return indices + + +def _frame_join(join_df, left_df, right_df, how, lsuffix, rsuffix): + """Join the GeoDataFrames at the DataFrame level. + + Parameters + ---------- + join_df : DataFrame + Indices and join data returned by the geometric join. + Must have columns `_key_left` and `_key_right` + with integer indices representing the matches + from `left_df` and `right_df` respectively. + Additional columns may be included and will be copied to + the resultant GeoDataFrame. + left_df : GeoDataFrame + right_df : GeoDataFrame + lsuffix : string + Suffix to apply to overlapping column names (left GeoDataFrame). + rsuffix : string + Suffix to apply to overlapping column names (right GeoDataFrame). + how : string + The type of join to use on the DataFrame level. + + Returns + ------- + GeoDataFrame + Joined GeoDataFrame. + """ # the spatial index only allows limited (numeric) index types, but an # index in geopandas may be any arbitrary dtype. so reset both indices now # and store references to the original indices, to be reaffixed later. # GH 352 + index_left = "index_{}".format(lsuffix) left_df = left_df.copy(deep=True) try: left_index_name = left_df.index.name left_df.index = left_df.index.rename(index_left) except TypeError: index_left = [ - "index_%s" % lsuffix + str(pos) + "index_{}".format(lsuffix + str(pos)) for pos, ix in enumerate(left_df.index.names) ] left_index_name = left_df.index.names left_df.index = left_df.index.rename(index_left) left_df = left_df.reset_index() + index_right = "index_{}".format(rsuffix) right_df = right_df.copy(deep=True) try: right_index_name = right_df.index.name right_df.index = right_df.index.rename(index_right) except TypeError: index_right = [ - "index_%s" % rsuffix + str(pos) + "index_{}".format(rsuffix + str(pos)) for pos, ix in enumerate(right_df.index.names) ] right_index_name = right_df.index.names @@ -133,14 +293,14 @@ def sjoin( # perform join on the dataframes if how == "inner": - result = result.set_index("_key_left") + join_df = join_df.set_index("_key_left") joined = ( - left_df.merge(result, left_index=True, right_index=True) + left_df.merge(join_df, left_index=True, right_index=True) .merge( right_df.drop(right_df.geometry.name, axis=1), left_on="_key_right", right_index=True, - suffixes=("_%s" % lsuffix, "_%s" % rsuffix), + suffixes=("_{}".format(lsuffix), "_{}".format(rsuffix)), ) .set_index(index_left) .drop(["_key_right"], axis=1) @@ -151,15 +311,15 @@ def sjoin( joined.index.name = left_index_name elif how == "left": - result = result.set_index("_key_left") + join_df = join_df.set_index("_key_left") joined = ( - left_df.merge(result, left_index=True, right_index=True, how="left") + left_df.merge(join_df, left_index=True, right_index=True, how="left") .merge( right_df.drop(right_df.geometry.name, axis=1), how="left", left_on="_key_right", right_index=True, - suffixes=("_%s" % lsuffix, "_%s" % rsuffix), + suffixes=("_{}".format(lsuffix), "_{}".format(rsuffix)), ) .set_index(index_left) .drop(["_key_right"], axis=1) @@ -173,15 +333,17 @@ def sjoin( joined = ( left_df.drop(left_df.geometry.name, axis=1) .merge( - result.merge( + join_df.merge( right_df, left_on="_key_right", right_index=True, how="right" ), left_index=True, right_on="_key_left", how="right", + suffixes=("_{}".format(lsuffix), "_{}".format(rsuffix)), ) .set_index(index_right) .drop(["_key_left", "_key_right"], axis=1) + .set_geometry(right_df.geometry.name) ) if isinstance(index_right, list): joined.index.names = right_index_name @@ -189,3 +351,186 @@ def sjoin( joined.index.name = right_index_name return joined + + +def _nearest_query( + left_df: GeoDataFrame, + right_df: GeoDataFrame, + max_distance: float, + how: str, + return_distance: bool, +): + if not (compat.PYGEOS_GE_010 and compat.USE_PYGEOS): + raise NotImplementedError( + "Currently, only PyGEOS >= 0.10.0 supports `nearest_all`. " + + compat.INSTALL_PYGEOS_ERROR + ) + # use the opposite of the join direction for the index + use_left_as_sindex = how == "right" + if use_left_as_sindex: + sindex = left_df.sindex + query = right_df.geometry + else: + sindex = right_df.sindex + query = left_df.geometry + if sindex: + res = sindex.nearest( + query, + return_all=True, + max_distance=max_distance, + return_distance=return_distance, + ) + if return_distance: + (input_idx, tree_idx), distances = res + else: + (input_idx, tree_idx) = res + distances = None + if use_left_as_sindex: + l_idx, r_idx = tree_idx, input_idx + sort_order = np.argsort(l_idx, kind="stable") + l_idx, r_idx = l_idx[sort_order], r_idx[sort_order] + if distances is not None: + distances = distances[sort_order] + else: + l_idx, r_idx = input_idx, tree_idx + join_df = pd.DataFrame( + {"_key_left": l_idx, "_key_right": r_idx, "distances": distances} + ) + else: + # when sindex is empty / has no valid geometries + join_df = pd.DataFrame( + columns=["_key_left", "_key_right", "distances"], dtype=float + ) + return join_df + + +def sjoin_nearest( + left_df: GeoDataFrame, + right_df: GeoDataFrame, + how: str = "inner", + max_distance: Optional[float] = None, + lsuffix: str = "left", + rsuffix: str = "right", + distance_col: Optional[str] = None, +) -> GeoDataFrame: + """Spatial join of two GeoDataFrames based on the distance between their geometries. + + Results will include multiple output records for a single input record + where there are multiple equidistant nearest or intersected neighbors. + + Distance is calculated in CRS units and can be returned using the + `distance_col` parameter. + + See the User Guide page + https://geopandas.readthedocs.io/en/latest/docs/user_guide/mergingdata.html + for more details. + + + Parameters + ---------- + left_df, right_df : GeoDataFrames + how : string, default 'inner' + The type of join: + + * 'left': use keys from left_df; retain only left_df geometry column + * 'right': use keys from right_df; retain only right_df geometry column + * 'inner': use intersection of keys from both dfs; retain only + left_df geometry column + max_distance : float, default None + Maximum distance within which to query for nearest geometry. + Must be greater than 0. + The max_distance used to search for nearest items in the tree may have a + significant impact on performance by reducing the number of input + geometries that are evaluated for nearest items in the tree. + lsuffix : string, default 'left' + Suffix to apply to overlapping column names (left GeoDataFrame). + rsuffix : string, default 'right' + Suffix to apply to overlapping column names (right GeoDataFrame). + distance_col : string, default None + If set, save the distances computed between matching geometries under a + column of this name in the joined GeoDataFrame. + + Examples + -------- + >>> countries = geopandas.read_file(geopandas.datasets.get_\ +path("naturalearth_lowres")) + >>> cities = geopandas.read_file(geopandas.datasets.get_path("naturalearth_cities")) + >>> countries.head(2).name # doctest: +SKIP + pop_est continent name \ +iso_a3 gdp_md_est geometry + 0 920938 Oceania Fiji FJI 8374.0 MULTIPOLY\ +GON (((180.00000 -16.06713, 180.00000... + 1 53950935 Africa Tanzania TZA 150600.0 POLYGON (\ +(33.90371 -0.95000, 34.07262 -1.05982... + >>> cities.head(2).name # doctest: +SKIP + name geometry + 0 Vatican City POINT (12.45339 41.90328) + 1 San Marino POINT (12.44177 43.93610) + + >>> cities_w_country_data = geopandas.sjoin_nearest(cities, countries) + >>> cities_w_country_data[['name_left', 'name_right']].head(2) # doctest: +SKIP + name_left geometry index_right pop_est continent name_\ +right iso_a3 gdp_md_est + 0 Vatican City POINT (12.45339 41.90328) 141 62137802 Europe \ +Italy ITA 2221000.0 + 1 San Marino POINT (12.44177 43.93610) 141 62137802 Europe \ +Italy ITA 2221000.0 + + To include the distances: + + >>> cities_w_country_data = geopandas.sjoin_nearest\ +(cities, countries, distance_col="distances") + >>> cities_w_country_data[["name_left", "name_right", \ +"distances"]].head(2) # doctest: +SKIP + name_left name_right distances + 0 Vatican City Italy 0.0 + 1 San Marino Italy 0.0 + + In the following example, we get multiple cities for Italy because all results are + equidistant (in this case zero because they intersect). + In fact, we get 3 results in total: + + >>> countries_w_city_data = geopandas.sjoin_nearest\ +(cities, countries, distance_col="distances", how="right") + >>> italy_results = \ +countries_w_city_data[countries_w_city_data["name_left"] == "Italy"] + >>> italy_results # doctest: +SKIP + name_x name_y + 141 Vatican City Italy + 141 San Marino Italy + 141 Rome Italy + + See also + -------- + sjoin : binary predicate joins + GeoDataFrame.sjoin_nearest : equivalent method + + Notes + ----- + Since this join relies on distances, results will be inaccurate + if your geometries are in a geographic CRS. + + Every operation in GeoPandas is planar, i.e. the potential third + dimension is not taken into account. + """ + _basic_checks(left_df, right_df, how, lsuffix, rsuffix) + + left_df.geometry.values.check_geographic_crs(stacklevel=1) + right_df.geometry.values.check_geographic_crs(stacklevel=1) + + return_distance = distance_col is not None + + join_df = _nearest_query(left_df, right_df, max_distance, how, return_distance) + + if return_distance: + join_df = join_df.rename(columns={"distances": distance_col}) + else: + join_df.pop("distances") + + joined = _frame_join(join_df, left_df, right_df, how, lsuffix, rsuffix) + + if return_distance: + columns = [c for c in joined.columns if c != distance_col] + [distance_col] + joined = joined[columns] + + return joined diff --git a/geopandas/tools/tests/test_clip.py b/geopandas/tools/tests/test_clip.py index 40abaa0..8076747 100644 --- a/geopandas/tools/tests/test_clip.py +++ b/geopandas/tools/tests/test_clip.py @@ -1,11 +1,20 @@ """Tests for the clip module.""" import warnings +from packaging.version import Version import numpy as np +import pandas as pd import shapely -from shapely.geometry import Polygon, Point, LineString, LinearRing, GeometryCollection +from shapely.geometry import ( + Polygon, + Point, + LineString, + LinearRing, + GeometryCollection, + MultiPoint, +) import geopandas from geopandas import GeoDataFrame, GeoSeries, clip @@ -14,16 +23,15 @@ from geopandas.testing import assert_geodataframe_equal, assert_geoseries_equal import pytest -pytestmark = pytest.mark.skipif( - not geopandas.sindex.has_sindex(), reason="clip requires spatial index" -) +pytestmark = pytest.mark.skip_no_sindex +pandas_133 = Version(pd.__version__) == Version("1.3.3") @pytest.fixture def point_gdf(): """Create a point GeoDataFrame.""" pts = np.array([[2, 2], [3, 4], [9, 8], [-12, -15]]) - gdf = GeoDataFrame([Point(xy) for xy in pts], columns=["geometry"], crs="EPSG:4326") + gdf = GeoDataFrame([Point(xy) for xy in pts], columns=["geometry"], crs="EPSG:3857") return gdf @@ -32,7 +40,7 @@ def pointsoutside_nooverlap_gdf(): """Create a point GeoDataFrame. Its points are all outside the single rectangle, and its bounds are outside the single rectangle's.""" pts = np.array([[5, 15], [15, 15], [15, 20]]) - gdf = GeoDataFrame([Point(xy) for xy in pts], columns=["geometry"], crs="EPSG:4326") + gdf = GeoDataFrame([Point(xy) for xy in pts], columns=["geometry"], crs="EPSG:3857") return gdf @@ -41,7 +49,7 @@ def pointsoutside_overlap_gdf(): """Create a point GeoDataFrame. Its points are all outside the single rectangle, and its bounds are overlapping the single rectangle's.""" pts = np.array([[5, 15], [15, 15], [15, 5]]) - gdf = GeoDataFrame([Point(xy) for xy in pts], columns=["geometry"], crs="EPSG:4326") + gdf = GeoDataFrame([Point(xy) for xy in pts], columns=["geometry"], crs="EPSG:3857") return gdf @@ -49,7 +57,7 @@ def pointsoutside_overlap_gdf(): def single_rectangle_gdf(): """Create a single rectangle for clipping.""" poly_inters = Polygon([(0, 0), (0, 10), (10, 10), (10, 0), (0, 0)]) - gdf = GeoDataFrame([1], geometry=[poly_inters], crs="EPSG:4326") + gdf = GeoDataFrame([1], geometry=[poly_inters], crs="EPSG:3857") gdf["attr2"] = "site-boundary" return gdf @@ -62,7 +70,7 @@ def larger_single_rectangle_gdf(): eliminates the slivers in the clip return. """ poly_inters = Polygon([(-5, -5), (-5, 15), (15, 15), (15, -5), (-5, -5)]) - gdf = GeoDataFrame([1], geometry=[poly_inters], crs="EPSG:4326") + gdf = GeoDataFrame([1], geometry=[poly_inters], crs="EPSG:3857") gdf["attr2"] = ["study area"] return gdf @@ -90,7 +98,7 @@ def two_line_gdf(): """Create Line Objects For Testing""" linea = LineString([(1, 1), (2, 2), (3, 2), (5, 3)]) lineb = LineString([(3, 4), (5, 7), (12, 2), (10, 5), (9, 7.5)]) - gdf = GeoDataFrame([1, 2], geometry=[linea, lineb], crs="EPSG:4326") + gdf = GeoDataFrame([1, 2], geometry=[linea, lineb], crs="EPSG:3857") return gdf @@ -98,7 +106,7 @@ def two_line_gdf(): def multi_poly_gdf(donut_geometry): """Create a multi-polygon GeoDataFrame.""" multi_poly = donut_geometry.unary_union - out_df = GeoDataFrame(geometry=GeoSeries(multi_poly), crs="EPSG:4326") + out_df = GeoDataFrame(geometry=GeoSeries(multi_poly), crs="EPSG:3857") out_df["attr"] = ["pool"] return out_df @@ -110,7 +118,7 @@ def multi_line(two_line_gdf): # Create a single and multi line object multiline_feat = two_line_gdf.unary_union linec = LineString([(2, 1), (3, 1), (4, 1), (5, 2)]) - out_df = GeoDataFrame(geometry=GeoSeries([multiline_feat, linec]), crs="EPSG:4326") + out_df = GeoDataFrame(geometry=GeoSeries([multiline_feat, linec]), crs="EPSG:3857") out_df["attr"] = ["road", "stream"] return out_df @@ -123,7 +131,7 @@ def multi_point(point_gdf): geometry=GeoSeries( [multi_point, Point(2, 5), Point(-11, -14), Point(-10, -12)] ), - crs="EPSG:4326", + crs="EPSG:3857", ) out_df["attr"] = ["tree", "another tree", "shrub", "berries"] return out_df @@ -137,7 +145,7 @@ def mixed_gdf(): poly = Polygon([(3, 4), (5, 2), (12, 2), (10, 5), (9, 7.5)]) ring = LinearRing([(1, 1), (2, 2), (3, 2), (5, 3), (12, 1)]) gdf = GeoDataFrame( - [1, 2, 3, 4], geometry=[point, poly, line, ring], crs="EPSG:4326" + [1, 2, 3, 4], geometry=[point, poly, line, ring], crs="EPSG:3857" ) return gdf @@ -148,7 +156,7 @@ def geomcol_gdf(): point = Point([(2, 3), (11, 4), (7, 2), (8, 9), (1, 13)]) poly = Polygon([(3, 4), (5, 2), (12, 2), (10, 5), (9, 7.5)]) coll = GeometryCollection([point, poly]) - gdf = GeoDataFrame([1], geometry=[coll], crs="EPSG:4326") + gdf = GeoDataFrame([1], geometry=[coll], crs="EPSG:3857") return gdf @@ -157,7 +165,7 @@ def sliver_line(): """Create a line that will create a point when clipped.""" linea = LineString([(10, 5), (13, 5), (15, 5)]) lineb = LineString([(1, 1), (2, 2), (3, 2), (5, 3), (12, 1)]) - gdf = GeoDataFrame([1, 2], geometry=[linea, lineb], crs="EPSG:4326") + gdf = GeoDataFrame([1, 2], geometry=[linea, lineb], crs="EPSG:3857") return gdf @@ -184,7 +192,7 @@ def test_returns_series(point_gdf, single_rectangle_gdf): def test_non_overlapping_geoms(): """Test that a bounding box returns empty if the extents don't overlap""" unit_box = Polygon([(0, 0), (0, 1), (1, 1), (1, 0), (0, 0)]) - unit_gdf = GeoDataFrame([1], geometry=[unit_box], crs="EPSG:4326") + unit_gdf = GeoDataFrame([1], geometry=[unit_box], crs="EPSG:3857") non_overlapping_gdf = unit_gdf.copy() non_overlapping_gdf = non_overlapping_gdf.geometry.apply( lambda x: shapely.affinity.translate(x, xoff=20) @@ -199,7 +207,21 @@ def test_clip_points(point_gdf, single_rectangle_gdf): """Test clipping a points GDF with a generic polygon geometry.""" clip_pts = clip(point_gdf, single_rectangle_gdf) pts = np.array([[2, 2], [3, 4], [9, 8]]) - exp = GeoDataFrame([Point(xy) for xy in pts], columns=["geometry"], crs="EPSG:4326") + exp = GeoDataFrame([Point(xy) for xy in pts], columns=["geometry"], crs="EPSG:3857") + assert_geodataframe_equal(clip_pts, exp) + + +def test_clip_points_geom_col_rename(point_gdf, single_rectangle_gdf): + """Test clipping a points GDF with a generic polygon geometry.""" + point_gdf_geom_col_rename = point_gdf.rename_geometry("geometry2") + clip_pts = clip(point_gdf_geom_col_rename, single_rectangle_gdf) + pts = np.array([[2, 2], [3, 4], [9, 8]]) + exp = GeoDataFrame( + [Point(xy) for xy in pts], + columns=["geometry2"], + crs="EPSG:3857", + geometry="geometry2", + ) assert_geodataframe_equal(clip_pts, exp) @@ -210,6 +232,16 @@ def test_clip_poly(buffered_locations, single_rectangle_gdf): assert all(clipped_poly.geom_type == "Polygon") +def test_clip_poly_geom_col_rename(buffered_locations, single_rectangle_gdf): + """Test clipping a polygon GDF with a generic polygon geometry.""" + + poly_gdf_geom_col_rename = buffered_locations.rename_geometry("geometry2") + clipped_poly = clip(poly_gdf_geom_col_rename, single_rectangle_gdf) + assert len(clipped_poly.geometry) == 3 + assert "geometry" not in clipped_poly.keys() + assert "geometry2" in clipped_poly.keys() + + def test_clip_poly_series(buffered_locations, single_rectangle_gdf): """Test clipping a polygon GDF with a generic polygon geometry.""" clipped_poly = clip(buffered_locations.geometry, single_rectangle_gdf) @@ -217,6 +249,7 @@ def test_clip_poly_series(buffered_locations, single_rectangle_gdf): assert all(clipped_poly.geom_type == "Polygon") +@pytest.mark.xfail(pandas_133, reason="Regression in pandas 1.3.3 (GH #2101)") def test_clip_multipoly_keep_slivers(multi_poly_gdf, single_rectangle_gdf): """Test a multi poly object where the return includes a sliver. Also the bounds of the object should == the bounds of the clip object @@ -227,6 +260,7 @@ def test_clip_multipoly_keep_slivers(multi_poly_gdf, single_rectangle_gdf): assert "GeometryCollection" in clipped.geom_type[0] +@pytest.mark.xfail(pandas_133, reason="Regression in pandas 1.3.3 (GH #2101)") def test_clip_multipoly_keep_geom_type(multi_poly_gdf, single_rectangle_gdf): """Test a multi poly object where the return includes a sliver. Also the bounds of the object should == the bounds of the clip object @@ -260,6 +294,15 @@ def test_clip_multipoint(single_rectangle_gdf, multi_point): assert clipped.geom_type[0] == "MultiPoint" assert hasattr(clipped, "attr") # All points should intersect the clip geom + assert len(clipped) == 2 + clipped_mutltipoint = MultiPoint( + [ + Point(2, 2), + Point(3, 4), + Point(9, 8), + ] + ) + assert clipped.iloc[0].geometry.wkt == clipped_mutltipoint.wkt assert all(clipped.intersects(single_rectangle_gdf.unary_union)) @@ -313,7 +356,7 @@ def test_clip_with_polygon(single_rectangle_gdf): exp_poly = polygon.intersection( Polygon([(0, 0), (0, 10), (10, 10), (10, 0), (0, 0)]) ) - exp = GeoDataFrame([1], geometry=[exp_poly], crs="EPSG:4326") + exp = GeoDataFrame([1], geometry=[exp_poly], crs="EPSG:3857") exp["attr2"] = "site-boundary" assert_geodataframe_equal(clipped, exp) @@ -343,7 +386,7 @@ def test_clip_no_box_overlap(pointsoutside_nooverlap_gdf, single_rectangle_gdf): def test_clip_box_overlap(pointsoutside_overlap_gdf, single_rectangle_gdf): - """Test clip when intersection is emtpy and boxes do overlap.""" + """Test clip when intersection is empty and boxes do overlap.""" clipped = clip(pointsoutside_overlap_gdf, single_rectangle_gdf) assert len(clipped) == 0 @@ -364,4 +407,4 @@ def test_warning_geomcoll(single_rectangle_gdf, geomcol_gdf): def test_warning_crs_mismatch(point_gdf, single_rectangle_gdf): with pytest.warns(UserWarning, match="CRS mismatch between the CRS"): - clip(point_gdf, single_rectangle_gdf.to_crs(3857)) + clip(point_gdf, single_rectangle_gdf.to_crs(4326)) diff --git a/geopandas/tools/tests/test_sjoin.py b/geopandas/tools/tests/test_sjoin.py index a5a2d01..c14367c 100644 --- a/geopandas/tools/tests/test_sjoin.py +++ b/geopandas/tools/tests/test_sjoin.py @@ -1,4 +1,7 @@ -from distutils.version import LooseVersion +from packaging.version import Version +import math +from typing import Sequence +from geopandas.testing import assert_geodataframe_equal import numpy as np import pandas as pd @@ -6,15 +9,18 @@ import pandas as pd from shapely.geometry import Point, Polygon, GeometryCollection import geopandas -from geopandas import GeoDataFrame, GeoSeries, read_file, sindex, sjoin +import geopandas._compat as compat +from geopandas import GeoDataFrame, GeoSeries, read_file, sjoin, sjoin_nearest +from geopandas.testing import assert_geoseries_equal from pandas.testing import assert_frame_equal import pytest -pytestmark = pytest.mark.skipif( - not sindex.has_sindex(), reason="sjoin requires spatial index" -) +TEST_NEAREST = compat.PYGEOS_GE_010 and compat.USE_PYGEOS + + +pytestmark = pytest.mark.skip_no_sindex @pytest.fixture() @@ -91,6 +97,23 @@ def dfs(request): class TestSpatialJoin: + @pytest.mark.parametrize( + "how, lsuffix, rsuffix, expected_cols", + [ + ("left", "left", "right", {"col_left", "col_right", "index_right"}), + ("inner", "left", "right", {"col_left", "col_right", "index_right"}), + ("right", "left", "right", {"col_left", "col_right", "index_left"}), + ("left", "lft", "rgt", {"col_lft", "col_rgt", "index_rgt"}), + ("inner", "lft", "rgt", {"col_lft", "col_rgt", "index_rgt"}), + ("right", "lft", "rgt", {"col_lft", "col_rgt", "index_lft"}), + ], + ) + def test_suffixes(self, how: str, lsuffix: str, rsuffix: str, expected_cols): + left = GeoDataFrame({"col": [1], "geometry": [Point(0, 0)]}) + right = GeoDataFrame({"col": [1], "geometry": [Point(0, 0)]}) + joined = sjoin(left, right, how=how, lsuffix=lsuffix, rsuffix=rsuffix) + assert set(joined.columns) == expected_cols | set(("geometry",)) + @pytest.mark.parametrize("dfs", ["default-index", "string-index"], indirect=True) def test_crs_mismatch(self, dfs): index, df1, df2, expected = dfs @@ -98,6 +121,41 @@ class TestSpatialJoin: with pytest.warns(UserWarning, match="CRS mismatch between the CRS"): sjoin(df1, df2) + @pytest.mark.parametrize("dfs", ["default-index"], indirect=True) + @pytest.mark.parametrize("op", ["intersects", "contains", "within"]) + def test_deprecated_op_param(self, dfs, op): + _, df1, df2, _ = dfs + with pytest.warns(FutureWarning, match="`op` parameter is deprecated"): + sjoin(df1, df2, op=op) + + @pytest.mark.parametrize("dfs", ["default-index"], indirect=True) + @pytest.mark.parametrize("op", ["intersects", "contains", "within"]) + @pytest.mark.parametrize("predicate", ["contains", "within"]) + def test_deprecated_op_param_nondefault_predicate(self, dfs, op, predicate): + _, df1, df2, _ = dfs + match = "use the `predicate` parameter instead" + if op != predicate: + warntype = UserWarning + match = ( + "`predicate` will be overridden by the value of `op`" + + r"(.|\s)*" + + match + ) + else: + warntype = FutureWarning + with pytest.warns(warntype, match=match): + sjoin(df1, df2, predicate=predicate, op=op) + + @pytest.mark.parametrize("dfs", ["default-index"], indirect=True) + def test_unknown_kwargs(self, dfs): + _, df1, df2, _ = dfs + with pytest.raises( + TypeError, + match=r"sjoin\(\) got an unexpected keyword argument 'extra_param'", + ): + sjoin(df1, df2, extra_param="test") + + @pytest.mark.filterwarnings("ignore:The `op` parameter:FutureWarning") @pytest.mark.parametrize( "dfs", [ @@ -109,13 +167,14 @@ class TestSpatialJoin: ], indirect=True, ) - @pytest.mark.parametrize("op", ["intersects", "contains", "within"]) - def test_inner(self, op, dfs): + @pytest.mark.parametrize("predicate", ["intersects", "contains", "within"]) + @pytest.mark.parametrize("predicate_kw", ["predicate", "op"]) + def test_inner(self, predicate, predicate_kw, dfs): index, df1, df2, expected = dfs - res = sjoin(df1, df2, how="inner", op=op) + res = sjoin(df1, df2, how="inner", **{predicate_kw: predicate}) - exp = expected[op].dropna().copy() + exp = expected[predicate].dropna().copy() exp = exp.drop("geometry_y", axis=1).rename(columns={"geometry_x": "geometry"}) exp[["df1", "df2"]] = exp[["df1", "df2"]].astype("int64") if index == "default-index": @@ -152,20 +211,20 @@ class TestSpatialJoin: ], indirect=True, ) - @pytest.mark.parametrize("op", ["intersects", "contains", "within"]) - def test_left(self, op, dfs): + @pytest.mark.parametrize("predicate", ["intersects", "contains", "within"]) + def test_left(self, predicate, dfs): index, df1, df2, expected = dfs - res = sjoin(df1, df2, how="left", op=op) + res = sjoin(df1, df2, how="left", predicate=predicate) if index in ["default-index", "string-index"]: - exp = expected[op].dropna(subset=["index_left"]).copy() + exp = expected[predicate].dropna(subset=["index_left"]).copy() elif index == "named-index": - exp = expected[op].dropna(subset=["df1_ix"]).copy() + exp = expected[predicate].dropna(subset=["df1_ix"]).copy() elif index == "multi-index": - exp = expected[op].dropna(subset=["level_0_x"]).copy() + exp = expected[predicate].dropna(subset=["level_0_x"]).copy() elif index == "named-multi-index": - exp = expected[op].dropna(subset=["df1_ix1"]).copy() + exp = expected[predicate].dropna(subset=["df1_ix1"]).copy() exp = exp.drop("geometry_y", axis=1).rename(columns={"geometry_x": "geometry"}) exp["df1"] = exp["df1"].astype("int64") if index == "default-index": @@ -203,14 +262,14 @@ class TestSpatialJoin: } ) not_in = geopandas.GeoDataFrame({"col1": [1], "geometry": [Point(-0.5, 0.5)]}) - empty = sjoin(not_in, polygons, how="left", op="intersects") + empty = sjoin(not_in, polygons, how="left", predicate="intersects") assert empty.index_right.isnull().all() - empty = sjoin(not_in, polygons, how="right", op="intersects") + empty = sjoin(not_in, polygons, how="right", predicate="intersects") assert empty.index_left.isnull().all() - empty = sjoin(not_in, polygons, how="inner", op="intersects") + empty = sjoin(not_in, polygons, how="inner", predicate="intersects") assert empty.empty - @pytest.mark.parametrize("op", ["intersects", "contains", "within"]) + @pytest.mark.parametrize("predicate", ["intersects", "contains", "within"]) @pytest.mark.parametrize( "empty", [ @@ -218,7 +277,7 @@ class TestSpatialJoin: GeoDataFrame(geometry=GeoSeries()), ], ) - def test_join_with_empty(self, op, empty): + def test_join_with_empty(self, predicate, empty): # Check joins with empty geometry columns/dataframes. polygons = geopandas.GeoDataFrame( { @@ -229,11 +288,11 @@ class TestSpatialJoin: ], } ) - result = sjoin(empty, polygons, how="left", op=op) + result = sjoin(empty, polygons, how="left", predicate=predicate) assert result.index_right.isnull().all() - result = sjoin(empty, polygons, how="right", op=op) + result = sjoin(empty, polygons, how="right", predicate=predicate) assert result.index_left.isnull().all() - result = sjoin(empty, polygons, how="inner", op=op) + result = sjoin(empty, polygons, how="inner", predicate=predicate) assert result.empty @pytest.mark.parametrize("dfs", ["default-index", "string-index"], indirect=True) @@ -257,20 +316,20 @@ class TestSpatialJoin: ], indirect=True, ) - @pytest.mark.parametrize("op", ["intersects", "contains", "within"]) - def test_right(self, op, dfs): + @pytest.mark.parametrize("predicate", ["intersects", "contains", "within"]) + def test_right(self, predicate, dfs): index, df1, df2, expected = dfs - res = sjoin(df1, df2, how="right", op=op) + res = sjoin(df1, df2, how="right", predicate=predicate) if index in ["default-index", "string-index"]: - exp = expected[op].dropna(subset=["index_right"]).copy() + exp = expected[predicate].dropna(subset=["index_right"]).copy() elif index == "named-index": - exp = expected[op].dropna(subset=["df2_ix"]).copy() + exp = expected[predicate].dropna(subset=["df2_ix"]).copy() elif index == "multi-index": - exp = expected[op].dropna(subset=["level_0_y"]).copy() + exp = expected[predicate].dropna(subset=["level_0_y"]).copy() elif index == "named-multi-index": - exp = expected[op].dropna(subset=["df2_ix1"]).copy() + exp = expected[predicate].dropna(subset=["df2_ix1"]).copy() exp = exp.drop("geometry_x", axis=1).rename(columns={"geometry_y": "geometry"}) exp["df2"] = exp["df2"].astype("int64") if index == "default-index": @@ -295,7 +354,7 @@ class TestSpatialJoin: exp.index.names = df2.index.names # GH 1364 fix of behaviour was done in pandas 1.1.0 - if op == "within" and str(pd.__version__) >= LooseVersion("1.1.0"): + if predicate == "within" and Version(pd.__version__) >= Version("1.1.0"): exp = exp.sort_index() assert_frame_equal(res, exp, check_index_type=False) @@ -352,21 +411,21 @@ class TestSpatialJoinNYBB: df = sjoin(self.pointdf, self.polydf, how="inner") assert df.shape == (11, 8) - def test_sjoin_op(self): + def test_sjoin_predicate(self): # points within polygons - df = sjoin(self.pointdf, self.polydf, how="left", op="within") + df = sjoin(self.pointdf, self.polydf, how="left", predicate="within") assert df.shape == (21, 8) assert df.loc[1]["BoroName"] == "Staten Island" # points contain polygons? never happens so we should have nulls - df = sjoin(self.pointdf, self.polydf, how="left", op="contains") + df = sjoin(self.pointdf, self.polydf, how="left", predicate="contains") assert df.shape == (21, 8) assert np.isnan(df.loc[1]["Shape_Area"]) - def test_sjoin_bad_op(self): + def test_sjoin_bad_predicate(self): # AttributeError: 'Point' object has no attribute 'spandex' with pytest.raises(ValueError): - sjoin(self.pointdf, self.polydf, how="left", op="spandex") + sjoin(self.pointdf, self.polydf, how="left", predicate="spandex") def test_sjoin_duplicate_column_name(self): pointdf2 = self.pointdf.rename(columns={"pointattr1": "Shape_Area"}) @@ -465,14 +524,25 @@ class TestSpatialJoinNYBB: df2 = sjoin(self.pointdf, self.polydf.append(empty), how="left") assert df2.shape == (21, 8) - @pytest.mark.parametrize("op", ["intersects", "within", "contains"]) - def test_sjoin_no_valid_geoms(self, op): + @pytest.mark.parametrize("predicate", ["intersects", "within", "contains"]) + def test_sjoin_no_valid_geoms(self, predicate): """Tests a completely empty GeoDataFrame.""" empty = GeoDataFrame(geometry=[], crs=self.pointdf.crs) - assert sjoin(self.pointdf, empty, how="inner", op=op).empty - assert sjoin(self.pointdf, empty, how="right", op=op).empty - assert sjoin(empty, self.pointdf, how="inner", op=op).empty - assert sjoin(empty, self.pointdf, how="left", op=op).empty + assert sjoin(self.pointdf, empty, how="inner", predicate=predicate).empty + assert sjoin(self.pointdf, empty, how="right", predicate=predicate).empty + assert sjoin(empty, self.pointdf, how="inner", predicate=predicate).empty + assert sjoin(empty, self.pointdf, how="left", predicate=predicate).empty + + def test_empty_sjoin_return_duplicated_columns(self): + + nybb = geopandas.read_file(geopandas.datasets.get_path("nybb")) + nybb2 = nybb.copy() + nybb2.geometry = nybb2.translate(200000) # to get non-overlapping + + result = geopandas.sjoin(nybb, nybb2) + + assert "BoroCode_right" in result.columns + assert "BoroCode_left" in result.columns class TestSpatialJoinNaturalEarth: @@ -487,6 +557,364 @@ class TestSpatialJoinNaturalEarth: countries = self.world[["geometry", "name"]] countries = countries.rename(columns={"name": "country"}) cities_with_country = sjoin( - self.cities, countries, how="inner", op="intersects" + self.cities, countries, how="inner", predicate="intersects" ) assert cities_with_country.shape == (172, 4) + + +@pytest.mark.skipif( + TEST_NEAREST, + reason=("This test can only be run _without_ PyGEOS >= 0.10 installed"), +) +def test_no_nearest_all(): + df1 = geopandas.GeoDataFrame({"geometry": []}) + df2 = geopandas.GeoDataFrame({"geometry": []}) + with pytest.raises( + NotImplementedError, + match="Currently, only PyGEOS >= 0.10.0 supports `nearest_all`", + ): + sjoin_nearest(df1, df2) + + +@pytest.mark.skipif( + not TEST_NEAREST, + reason=( + "PyGEOS >= 0.10.0" + " must be installed and activated via the geopandas.compat module to" + " test sjoin_nearest" + ), +) +class TestNearest: + @pytest.mark.parametrize( + "how_kwargs", ({}, {"how": "inner"}, {"how": "left"}, {"how": "right"}) + ) + def test_allowed_hows(self, how_kwargs): + left = geopandas.GeoDataFrame({"geometry": []}) + right = geopandas.GeoDataFrame({"geometry": []}) + sjoin_nearest(left, right, **how_kwargs) # no error + + @pytest.mark.parametrize("how", ("outer", "abcde")) + def test_invalid_hows(self, how: str): + left = geopandas.GeoDataFrame({"geometry": []}) + right = geopandas.GeoDataFrame({"geometry": []}) + with pytest.raises(ValueError, match="`how` was"): + sjoin_nearest(left, right, how=how) + + @pytest.mark.parametrize("distance_col", (None, "distance")) + def test_empty_right_df_how_left(self, distance_col: str): + # all records from left and no results from right + left = geopandas.GeoDataFrame({"geometry": [Point(0, 0), Point(1, 1)]}) + right = geopandas.GeoDataFrame({"geometry": []}) + joined = sjoin_nearest( + left, + right, + how="left", + distance_col=distance_col, + ) + assert_geoseries_equal(joined["geometry"], left["geometry"]) + assert joined["index_right"].isna().all() + if distance_col is not None: + assert joined[distance_col].isna().all() + + @pytest.mark.parametrize("distance_col", (None, "distance")) + def test_empty_right_df_how_right(self, distance_col: str): + # no records in joined + left = geopandas.GeoDataFrame({"geometry": [Point(0, 0), Point(1, 1)]}) + right = geopandas.GeoDataFrame({"geometry": []}) + joined = sjoin_nearest( + left, + right, + how="right", + distance_col=distance_col, + ) + assert joined.empty + if distance_col is not None: + assert distance_col in joined + + @pytest.mark.parametrize("how", ["inner", "left"]) + @pytest.mark.parametrize("distance_col", (None, "distance")) + def test_empty_left_df(self, how, distance_col: str): + right = geopandas.GeoDataFrame({"geometry": [Point(0, 0), Point(1, 1)]}) + left = geopandas.GeoDataFrame({"geometry": []}) + joined = sjoin_nearest(left, right, how=how, distance_col=distance_col) + assert joined.empty + if distance_col is not None: + assert distance_col in joined + + @pytest.mark.parametrize("distance_col", (None, "distance")) + def test_empty_left_df_how_right(self, distance_col: str): + right = geopandas.GeoDataFrame({"geometry": [Point(0, 0), Point(1, 1)]}) + left = geopandas.GeoDataFrame({"geometry": []}) + joined = sjoin_nearest( + left, + right, + how="right", + distance_col=distance_col, + ) + assert_geoseries_equal(joined["geometry"], right["geometry"]) + assert joined["index_left"].isna().all() + if distance_col is not None: + assert joined[distance_col].isna().all() + + @pytest.mark.parametrize("how", ["inner", "left"]) + def test_empty_join_due_to_max_distance(self, how): + # after applying max_distance the join comes back empty + # (as in NaN in the joined columns) + left = geopandas.GeoDataFrame({"geometry": [Point(0, 0)]}) + right = geopandas.GeoDataFrame({"geometry": [Point(1, 1), Point(2, 2)]}) + joined = sjoin_nearest( + left, + right, + how=how, + max_distance=1, + distance_col="distances", + ) + expected = left.copy() + expected["index_right"] = [np.nan] + expected["distances"] = [np.nan] + if how == "inner": + expected = expected.dropna() + expected["index_right"] = expected["index_right"].astype("int64") + assert_geodataframe_equal(joined, expected) + + def test_empty_join_due_to_max_distance_how_right(self): + # after applying max_distance the join comes back empty + # (as in NaN in the joined columns) + left = geopandas.GeoDataFrame({"geometry": [Point(0, 0), Point(1, 1)]}) + right = geopandas.GeoDataFrame({"geometry": [Point(2, 2)]}) + joined = sjoin_nearest( + left, + right, + how="right", + max_distance=1, + distance_col="distances", + ) + expected = right.copy() + expected["index_left"] = [np.nan] + expected["distances"] = [np.nan] + expected = expected[["index_left", "geometry", "distances"]] + assert_geodataframe_equal(joined, expected) + + @pytest.mark.parametrize("how", ["inner", "left"]) + def test_max_distance(self, how): + left = geopandas.GeoDataFrame({"geometry": [Point(0, 0), Point(1, 1)]}) + right = geopandas.GeoDataFrame({"geometry": [Point(1, 1), Point(2, 2)]}) + joined = sjoin_nearest( + left, + right, + how=how, + max_distance=1, + distance_col="distances", + ) + expected = left.copy() + expected["index_right"] = [np.nan, 0] + expected["distances"] = [np.nan, 0] + if how == "inner": + expected = expected.dropna() + expected["index_right"] = expected["index_right"].astype("int64") + assert_geodataframe_equal(joined, expected) + + def test_max_distance_how_right(self): + left = geopandas.GeoDataFrame({"geometry": [Point(1, 1), Point(2, 2)]}) + right = geopandas.GeoDataFrame({"geometry": [Point(0, 0), Point(1, 1)]}) + joined = sjoin_nearest( + left, + right, + how="right", + max_distance=1, + distance_col="distances", + ) + expected = right.copy() + expected["index_left"] = [np.nan, 0] + expected["distances"] = [np.nan, 0] + expected = expected[["index_left", "geometry", "distances"]] + assert_geodataframe_equal(joined, expected) + + @pytest.mark.parametrize("how", ["inner", "left"]) + @pytest.mark.parametrize( + "geo_left, geo_right, expected_left, expected_right, distances", + [ + ( + [Point(0, 0), Point(1, 1)], + [Point(1, 1)], + [0, 1], + [0, 0], + [math.sqrt(2), 0], + ), + ( + [Point(0, 0), Point(1, 1)], + [Point(1, 1), Point(0, 0)], + [0, 1], + [1, 0], + [0, 0], + ), + ( + [Point(0, 0), Point(1, 1)], + [Point(1, 1), Point(0, 0), Point(0, 0)], + [0, 0, 1], + [1, 2, 0], + [0, 0, 0], + ), + ( + [Point(0, 0), Point(1, 1)], + [Point(1, 1), Point(0, 0), Point(2, 2)], + [0, 1], + [1, 0], + [0, 0], + ), + ( + [Point(0, 0), Point(1, 1)], + [Point(1, 1), Point(0.25, 1)], + [0, 1], + [1, 0], + [math.sqrt(0.25 ** 2 + 1), 0], + ), + ( + [Point(0, 0), Point(1, 1)], + [Point(-10, -10), Point(100, 100)], + [0, 1], + [0, 0], + [math.sqrt(10 ** 2 + 10 ** 2), math.sqrt(11 ** 2 + 11 ** 2)], + ), + ( + [Point(0, 0), Point(1, 1)], + [Point(x, y) for x, y in zip(np.arange(10), np.arange(10))], + [0, 1], + [0, 1], + [0, 0], + ), + ( + [Point(0, 0), Point(1, 1), Point(0, 0)], + [Point(1.1, 1.1), Point(0, 0)], + [0, 1, 2], + [1, 0, 1], + [0, np.sqrt(0.1 ** 2 + 0.1 ** 2), 0], + ), + ], + ) + def test_sjoin_nearest_left( + self, + geo_left, + geo_right, + expected_left: Sequence[int], + expected_right: Sequence[int], + distances: Sequence[float], + how, + ): + left = geopandas.GeoDataFrame({"geometry": geo_left}) + right = geopandas.GeoDataFrame({"geometry": geo_right}) + expected_gdf = left.iloc[expected_left].copy() + expected_gdf["index_right"] = expected_right + # without distance col + joined = sjoin_nearest(left, right, how=how) + # inner / left join give a different row order + check_like = how == "inner" + assert_geodataframe_equal(expected_gdf, joined, check_like=check_like) + # with distance col + expected_gdf["distance_col"] = np.array(distances, dtype=float) + joined = sjoin_nearest(left, right, how=how, distance_col="distance_col") + assert_geodataframe_equal(expected_gdf, joined, check_like=check_like) + + @pytest.mark.parametrize( + "geo_left, geo_right, expected_left, expected_right, distances", + [ + ([Point(0, 0), Point(1, 1)], [Point(1, 1)], [1], [0], [0]), + ( + [Point(0, 0), Point(1, 1)], + [Point(1, 1), Point(0, 0)], + [1, 0], + [0, 1], + [0, 0], + ), + ( + [Point(0, 0), Point(1, 1)], + [Point(1, 1), Point(0, 0), Point(0, 0)], + [1, 0, 0], + [0, 1, 2], + [0, 0, 0], + ), + ( + [Point(0, 0), Point(1, 1)], + [Point(1, 1), Point(0, 0), Point(2, 2)], + [1, 0, 1], + [0, 1, 2], + [0, 0, math.sqrt(2)], + ), + ( + [Point(0, 0), Point(1, 1)], + [Point(1, 1), Point(0.25, 1)], + [1, 1], + [0, 1], + [0, 0.75], + ), + ( + [Point(0, 0), Point(1, 1)], + [Point(-10, -10), Point(100, 100)], + [0, 1], + [0, 1], + [math.sqrt(10 ** 2 + 10 ** 2), math.sqrt(99 ** 2 + 99 ** 2)], + ), + ( + [Point(0, 0), Point(1, 1)], + [Point(x, y) for x, y in zip(np.arange(10), np.arange(10))], + [0, 1] + [1] * 8, + list(range(10)), + [0, 0] + [np.sqrt(x ** 2 + x ** 2) for x in np.arange(1, 9)], + ), + ( + [Point(0, 0), Point(1, 1), Point(0, 0)], + [Point(1.1, 1.1), Point(0, 0)], + [1, 0, 2], + [0, 1, 1], + [np.sqrt(0.1 ** 2 + 0.1 ** 2), 0, 0], + ), + ], + ) + def test_sjoin_nearest_right( + self, + geo_left, + geo_right, + expected_left: Sequence[int], + expected_right: Sequence[int], + distances: Sequence[float], + ): + left = geopandas.GeoDataFrame({"geometry": geo_left}) + right = geopandas.GeoDataFrame({"geometry": geo_right}) + expected_gdf = right.iloc[expected_right].copy() + expected_gdf["index_left"] = expected_left + expected_gdf = expected_gdf[["index_left", "geometry"]] + # without distance col + joined = sjoin_nearest(left, right, how="right") + assert_geodataframe_equal(expected_gdf, joined) + # with distance col + expected_gdf["distance_col"] = np.array(distances, dtype=float) + joined = sjoin_nearest(left, right, how="right", distance_col="distance_col") + assert_geodataframe_equal(expected_gdf, joined) + + @pytest.mark.filterwarnings("ignore:Geometry is in a geographic CRS") + def test_sjoin_nearest_inner(self): + # check equivalency of left and inner join + countries = read_file(geopandas.datasets.get_path("naturalearth_lowres")) + cities = read_file(geopandas.datasets.get_path("naturalearth_cities")) + countries = countries[["geometry", "name"]].rename(columns={"name": "country"}) + + # default: inner and left give the same result + result1 = sjoin_nearest(cities, countries, distance_col="dist") + assert result1.shape[0] == cities.shape[0] + result2 = sjoin_nearest(cities, countries, distance_col="dist", how="inner") + assert_geodataframe_equal(result2, result1) + result3 = sjoin_nearest(cities, countries, distance_col="dist", how="left") + assert_geodataframe_equal(result3, result1, check_like=True) + + # with max_distance: rows that go above are dropped in case of inner + result4 = sjoin_nearest(cities, countries, distance_col="dist", max_distance=1) + assert_geodataframe_equal( + result4, result1[result1["dist"] < 1], check_like=True + ) + result5 = sjoin_nearest( + cities, countries, distance_col="dist", max_distance=1, how="left" + ) + assert result5.shape[0] == cities.shape[0] + result5 = result5.dropna() + result5["index_right"] = result5["index_right"].astype("int64") + assert_geodataframe_equal(result5, result4, check_like=True) diff --git a/geopandas/tools/tests/test_tools.py b/geopandas/tools/tests/test_tools.py index b7b9faf..603aad0 100644 --- a/geopandas/tools/tests/test_tools.py +++ b/geopandas/tools/tests/test_tools.py @@ -1,21 +1,11 @@ -from distutils.version import LooseVersion - from shapely.geometry import LineString, MultiPoint, Point -import pyproj -from pyproj import CRS from geopandas import GeoSeries from geopandas.tools import collect -from geopandas.tools.crs import epsg_from_crs, explicit_crs_from_epsg import pytest -# pyproj 2.3.1 fixed a segfault for the case working in an environment with -# 'init' dicts (https://github.com/pyproj4/pyproj/issues/415) -PYPROJ_LT_231 = LooseVersion(pyproj.__version__) < LooseVersion("2.3.1") - - class TestTools: def setup_method(self): self.p1 = Point(0, 0) @@ -59,27 +49,3 @@ class TestTools: def test_collect_mixed_multi(self): with pytest.raises(ValueError): collect([self.mpc, self.mp1]) - - @pytest.mark.skipif(PYPROJ_LT_231, reason="segfault") - def test_epsg_from_crs(self): - with pytest.warns(FutureWarning): - assert epsg_from_crs({"init": "epsg:4326"}) == 4326 - assert epsg_from_crs({"init": "EPSG:4326"}) == 4326 - assert epsg_from_crs("+init=epsg:4326") == 4326 - - @pytest.mark.skipif(PYPROJ_LT_231, reason="segfault") - def test_explicit_crs_from_epsg(self): - with pytest.warns(FutureWarning): - assert explicit_crs_from_epsg(epsg=4326) == CRS.from_epsg(4326) - assert explicit_crs_from_epsg(epsg="4326") == CRS.from_epsg(4326) - assert explicit_crs_from_epsg(crs={"init": "epsg:4326"}) == CRS.from_dict( - {"init": "epsg:4326"} - ) - assert explicit_crs_from_epsg(crs="+init=epsg:4326") == CRS.from_proj4( - "+init=epsg:4326" - ) - - @pytest.mark.filterwarnings("ignore:explicit_crs_from_epsg:FutureWarning") - def test_explicit_crs_from_epsg__missing_input(self): - with pytest.raises(ValueError): - explicit_crs_from_epsg() diff --git a/geopandas/tools/util.py b/geopandas/tools/util.py index 2ced515..c42c921 100644 --- a/geopandas/tools/util.py +++ b/geopandas/tools/util.py @@ -34,7 +34,7 @@ def collect(x, multi=False): # Point and MultiPoint... or even just MultiPoint t = x[0].type if not all(g.type == t for g in x): - raise ValueError("Geometry type must be homogenous") + raise ValueError("Geometry type must be homogeneous") if len(x) > 1 and t.startswith("Multi"): raise ValueError("Cannot collect {0}. Must have single geometries".format(t)) diff --git a/readthedocs.yml b/readthedocs.yml index 6e71009..af979a2 100644 --- a/readthedocs.yml +++ b/readthedocs.yml @@ -1,9 +1,12 @@ version: 2 -formats: [] -conda: - environment: doc/environment.yml +build: + os: ubuntu-20.04 + tools: + python: mambaforge-4.10 python: - version: 3 - install: - - method: pip - path: . + install: + - method: pip + path: . +conda: + environment: doc/environment.yml +formats: [] diff --git a/requirements-dev.txt b/requirements-dev.txt index 95a7ea4..8adc89e 100644 --- a/requirements-dev.txt +++ b/requirements-dev.txt @@ -1,8 +1,9 @@ # required -fiona>=1.7 -pandas>=0.23.4 +fiona>=1.8 +pandas>=0.25 pyproj>=2.2.0 -shapely>=1.5 +shapely>=1.6 +packaging # geodatabase access psycopg2>=2.5.1 @@ -12,17 +13,15 @@ SQLAlchemy>=0.8.3 geopy # plotting -descartes>=1.0 -matplotlib>=2.0 +matplotlib>=2.2 mapclassify -# testing -mock>=1.0.1 # technically not need for python >= 3.3 +# testing pytest>=3.1.0 pytest-cov codecov -# spatial access methods +# spatial access methods rtree>=0.8 # styling diff --git a/setup.py b/setup.py index acb6411..2a58918 100644 --- a/setup.py +++ b/setup.py @@ -29,7 +29,13 @@ such as PostGIS. if os.environ.get("READTHEDOCS", False) == "True": INSTALL_REQUIRES = [] else: - INSTALL_REQUIRES = ["pandas >= 0.23.0", "shapely", "fiona", "pyproj >= 2.2.0"] + INSTALL_REQUIRES = [ + "pandas >= 0.25.0", + "shapely >= 1.6", + "fiona >= 1.8", + "pyproj >= 2.2.0", + "packaging", + ] # get all data dirs in the datasets module data_files = [] @@ -62,7 +68,7 @@ setup( "geopandas.tools.tests", ], package_data={"geopandas": data_files}, - python_requires=">=3.5", + python_requires=">=3.7", install_requires=INSTALL_REQUIRES, cmdclass=versioneer.get_cmdclass(), ) diff --git a/versioneer.py b/versioneer.py index 7ed2a21..d70f31b 100644 --- a/versioneer.py +++ b/versioneer.py @@ -1,5 +1,4 @@ - -# Version: 0.16 +# Version: 0.21 """The Versioneer - like a rocketeer, but for versions. @@ -7,16 +6,12 @@ The Versioneer ============== * like a rocketeer, but for versions! -* https://github.com/warner/python-versioneer +* https://github.com/python-versioneer/python-versioneer * Brian Warner * License: Public Domain -* Compatible With: python2.6, 2.7, 3.3, 3.4, 3.5, and pypy -* [![Latest Version] -(https://pypip.in/version/versioneer/badge.svg?style=flat) -](https://pypi.python.org/pypi/versioneer/) -* [![Build Status] -(https://travis-ci.org/warner/python-versioneer.png?branch=master) -](https://travis-ci.org/warner/python-versioneer) +* Compatible with: Python 3.6, 3.7, 3.8, 3.9 and pypy3 +* [![Latest Version][pypi-image]][pypi-url] +* [![Build Status][travis-image]][travis-url] This is a tool for managing a recorded version number in distutils-based python projects. The goal is to remove the tedious and error-prone "update @@ -27,9 +22,10 @@ system, and maybe making new tarballs. ## Quick Install -* `pip install versioneer` to somewhere to your $PATH -* add a `[versioneer]` section to your setup.cfg (see below) +* `pip install versioneer` to somewhere in your $PATH +* add a `[versioneer]` section to your setup.cfg (see [Install](INSTALL.md)) * run `versioneer install` in your source tree, commit the results +* Verify version information with `python setup.py version` ## Version Identifiers @@ -61,7 +57,7 @@ version 1.3). Many VCS systems can report a description that captures this, for example `git describe --tags --dirty --always` reports things like "0.7-1-g574ab98-dirty" to indicate that the checkout is one revision past the 0.7 tag, has a unique revision id of "574ab98", and is "dirty" (it has -uncommitted changes. +uncommitted changes). The version identifier is used for multiple purposes: @@ -88,127 +84,7 @@ the generated version data. ## Installation -First, decide on values for the following configuration variables: - -* `VCS`: the version control system you use. Currently accepts "git". - -* `style`: the style of version string to be produced. See "Styles" below for - details. Defaults to "pep440", which looks like - `TAG[+DISTANCE.gSHORTHASH[.dirty]]`. - -* `versionfile_source`: - - A project-relative pathname into which the generated version strings should - be written. This is usually a `_version.py` next to your project's main - `__init__.py` file, so it can be imported at runtime. If your project uses - `src/myproject/__init__.py`, this should be `src/myproject/_version.py`. - This file should be checked in to your VCS as usual: the copy created below - by `setup.py setup_versioneer` will include code that parses expanded VCS - keywords in generated tarballs. The 'build' and 'sdist' commands will - replace it with a copy that has just the calculated version string. - - This must be set even if your project does not have any modules (and will - therefore never import `_version.py`), since "setup.py sdist" -based trees - still need somewhere to record the pre-calculated version strings. Anywhere - in the source tree should do. If there is a `__init__.py` next to your - `_version.py`, the `setup.py setup_versioneer` command (described below) - will append some `__version__`-setting assignments, if they aren't already - present. - -* `versionfile_build`: - - Like `versionfile_source`, but relative to the build directory instead of - the source directory. These will differ when your setup.py uses - 'package_dir='. If you have `package_dir={'myproject': 'src/myproject'}`, - then you will probably have `versionfile_build='myproject/_version.py'` and - `versionfile_source='src/myproject/_version.py'`. - - If this is set to None, then `setup.py build` will not attempt to rewrite - any `_version.py` in the built tree. If your project does not have any - libraries (e.g. if it only builds a script), then you should use - `versionfile_build = None`. To actually use the computed version string, - your `setup.py` will need to override `distutils.command.build_scripts` - with a subclass that explicitly inserts a copy of - `versioneer.get_version()` into your script file. See - `test/demoapp-script-only/setup.py` for an example. - -* `tag_prefix`: - - a string, like 'PROJECTNAME-', which appears at the start of all VCS tags. - If your tags look like 'myproject-1.2.0', then you should use - tag_prefix='myproject-'. If you use unprefixed tags like '1.2.0', this - should be an empty string, using either `tag_prefix=` or `tag_prefix=''`. - -* `parentdir_prefix`: - - a optional string, frequently the same as tag_prefix, which appears at the - start of all unpacked tarball filenames. If your tarball unpacks into - 'myproject-1.2.0', this should be 'myproject-'. To disable this feature, - just omit the field from your `setup.cfg`. - -This tool provides one script, named `versioneer`. That script has one mode, -"install", which writes a copy of `versioneer.py` into the current directory -and runs `versioneer.py setup` to finish the installation. - -To versioneer-enable your project: - -* 1: Modify your `setup.cfg`, adding a section named `[versioneer]` and - populating it with the configuration values you decided earlier (note that - the option names are not case-sensitive): - - ```` - [versioneer] - VCS = git - style = pep440 - versionfile_source = src/myproject/_version.py - versionfile_build = myproject/_version.py - tag_prefix = - parentdir_prefix = myproject- - ```` - -* 2: Run `versioneer install`. This will do the following: - - * copy `versioneer.py` into the top of your source tree - * create `_version.py` in the right place (`versionfile_source`) - * modify your `__init__.py` (if one exists next to `_version.py`) to define - `__version__` (by calling a function from `_version.py`) - * modify your `MANIFEST.in` to include both `versioneer.py` and the - generated `_version.py` in sdist tarballs - - `versioneer install` will complain about any problems it finds with your - `setup.py` or `setup.cfg`. Run it multiple times until you have fixed all - the problems. - -* 3: add a `import versioneer` to your setup.py, and add the following - arguments to the setup() call: - - version=versioneer.get_version(), - cmdclass=versioneer.get_cmdclass(), - -* 4: commit these changes to your VCS. To make sure you won't forget, - `versioneer install` will mark everything it touched for addition using - `git add`. Don't forget to add `setup.py` and `setup.cfg` too. - -## Post-Installation Usage - -Once established, all uses of your tree from a VCS checkout should get the -current version string. All generated tarballs should include an embedded -version string (so users who unpack them will not need a VCS tool installed). - -If you distribute your project through PyPI, then the release process should -boil down to two steps: - -* 1: git tag 1.0 -* 2: python setup.py register sdist upload - -If you distribute it through github (i.e. users use github to generate -tarballs with `git archive`), the process is: - -* 1: git tag 1.0 -* 2: git push; git push --tags - -Versioneer will report "0+untagged.NUMCOMMITS.gHASH" until your tree has at -least one tag in its history. +See [INSTALL.md](./INSTALL.md) for detailed installation instructions. ## Version-String Flavors @@ -229,6 +105,10 @@ information: * `['full-revisionid']`: detailed revision identifier. For Git, this is the full SHA1 commit id, e.g. "1076c978a8d3cfc70f408fe5974aa6c092c949ac". +* `['date']`: Date and time of the latest `HEAD` commit. For Git, it is the + commit date in ISO 8601 format. This will be None if the date is not + available. + * `['dirty']`: a boolean, True if the tree has uncommitted changes. Note that this is only accurate if run in a VCS checkout, otherwise it is likely to be False or None @@ -267,8 +147,8 @@ that this commit is two revisions ("+2") beyond the "0.11" tag. For released software (exactly equal to a known tag), the identifier will only contain the stripped tag, e.g. "0.11". -Other styles are available. See details.md in the Versioneer source tree for -descriptions. +Other styles are available. See [details.md](details.md) in the Versioneer +source tree for descriptions. ## Debugging @@ -278,52 +158,84 @@ version`, which will run the version-lookup code in a verbose mode, and will display the full contents of `get_versions()` (including the `error` string, which may help identify what went wrong). +## Known Limitations + +Some situations are known to cause problems for Versioneer. This details the +most significant ones. More can be found on Github +[issues page](https://github.com/python-versioneer/python-versioneer/issues). + +### Subprojects + +Versioneer has limited support for source trees in which `setup.py` is not in +the root directory (e.g. `setup.py` and `.git/` are *not* siblings). The are +two common reasons why `setup.py` might not be in the root: + +* Source trees which contain multiple subprojects, such as + [Buildbot](https://github.com/buildbot/buildbot), which contains both + "master" and "slave" subprojects, each with their own `setup.py`, + `setup.cfg`, and `tox.ini`. Projects like these produce multiple PyPI + distributions (and upload multiple independently-installable tarballs). +* Source trees whose main purpose is to contain a C library, but which also + provide bindings to Python (and perhaps other languages) in subdirectories. + +Versioneer will look for `.git` in parent directories, and most operations +should get the right version string. However `pip` and `setuptools` have bugs +and implementation details which frequently cause `pip install .` from a +subproject directory to fail to find a correct version string (so it usually +defaults to `0+unknown`). + +`pip install --editable .` should work correctly. `setup.py install` might +work too. + +Pip-8.1.1 is known to have this problem, but hopefully it will get fixed in +some later version. + +[Bug #38](https://github.com/python-versioneer/python-versioneer/issues/38) is tracking +this issue. The discussion in +[PR #61](https://github.com/python-versioneer/python-versioneer/pull/61) describes the +issue from the Versioneer side in more detail. +[pip PR#3176](https://github.com/pypa/pip/pull/3176) and +[pip PR#3615](https://github.com/pypa/pip/pull/3615) contain work to improve +pip to let Versioneer work correctly. + +Versioneer-0.16 and earlier only looked for a `.git` directory next to the +`setup.cfg`, so subprojects were completely unsupported with those releases. + +### Editable installs with setuptools <= 18.5 + +`setup.py develop` and `pip install --editable .` allow you to install a +project into a virtualenv once, then continue editing the source code (and +test) without re-installing after every change. + +"Entry-point scripts" (`setup(entry_points={"console_scripts": ..})`) are a +convenient way to specify executable scripts that should be installed along +with the python package. + +These both work as expected when using modern setuptools. When using +setuptools-18.5 or earlier, however, certain operations will cause +`pkg_resources.DistributionNotFound` errors when running the entrypoint +script, which must be resolved by re-installing the package. This happens +when the install happens with one version, then the egg_info data is +regenerated while a different version is checked out. Many setup.py commands +cause egg_info to be rebuilt (including `sdist`, `wheel`, and installing into +a different virtualenv), so this can be surprising. + +[Bug #83](https://github.com/python-versioneer/python-versioneer/issues/83) describes +this one, but upgrading to a newer version of setuptools should probably +resolve it. + + ## Updating Versioneer To upgrade your project to a new release of Versioneer, do the following: * install the new Versioneer (`pip install -U versioneer` or equivalent) * edit `setup.cfg`, if necessary, to include any new configuration settings - indicated by the release notes + indicated by the release notes. See [UPGRADING](./UPGRADING.md) for details. * re-run `versioneer install` in your source tree, to replace `SRC/_version.py` * commit any changed files -### Upgrading to 0.16 - -Nothing special. - -### Upgrading to 0.15 - -Starting with this version, Versioneer is configured with a `[versioneer]` -section in your `setup.cfg` file. Earlier versions required the `setup.py` to -set attributes on the `versioneer` module immediately after import. The new -version will refuse to run (raising an exception during import) until you -have provided the necessary `setup.cfg` section. - -In addition, the Versioneer package provides an executable named -`versioneer`, and the installation process is driven by running `versioneer -install`. In 0.14 and earlier, the executable was named -`versioneer-installer` and was run without an argument. - -### Upgrading to 0.14 - -0.14 changes the format of the version string. 0.13 and earlier used -hyphen-separated strings like "0.11-2-g1076c97-dirty". 0.14 and beyond use a -plus-separated "local version" section strings, with dot-separated -components, like "0.11+2.g1076c97". PEP440-strict tools did not like the old -format, but should be ok with the new one. - -### Upgrading from 0.11 to 0.12 - -Nothing special. - -### Upgrading from 0.10 to 0.11 - -You must add a `versioneer.VCS = "git"` to your `setup.py` before re-running -`setup.py setup_versioneer`. This will enable the use of additional -version-control systems (SVN, etc) in the future. - ## Future Directions This tool is designed to make it easily extended to other version-control @@ -337,6 +249,14 @@ installation by editing setup.py . Alternatively, it might go the other direction and include code from all supported VCS systems, reducing the number of intermediate scripts. +## Similar projects + +* [setuptools_scm](https://github.com/pypa/setuptools_scm/) - a non-vendored build-time + dependency +* [minver](https://github.com/jbweston/miniver) - a lightweight reimplementation of + versioneer +* [versioningit](https://github.com/jwodder/versioningit) - a PEP 518-based setuptools + plugin ## License @@ -346,19 +266,27 @@ Specifically, both are released under the Creative Commons "Public Domain Dedication" license (CC0-1.0), as described in https://creativecommons.org/publicdomain/zero/1.0/ . -""" +[pypi-image]: https://img.shields.io/pypi/v/versioneer.svg +[pypi-url]: https://pypi.python.org/pypi/versioneer/ +[travis-image]: +https://img.shields.io/travis/com/python-versioneer/python-versioneer.svg +[travis-url]: https://travis-ci.com/github/python-versioneer/python-versioneer -from __future__ import print_function -try: - import configparser -except ImportError: - import ConfigParser as configparser +""" +# pylint:disable=invalid-name,import-outside-toplevel,missing-function-docstring +# pylint:disable=missing-class-docstring,too-many-branches,too-many-statements +# pylint:disable=raise-missing-from,too-many-lines,too-many-locals,import-error +# pylint:disable=too-few-public-methods,redefined-outer-name,consider-using-with +# pylint:disable=attribute-defined-outside-init,too-many-arguments + +import configparser import errno import json import os import re import subprocess import sys +from typing import Callable, Dict class VersioneerConfig: @@ -380,11 +308,13 @@ def get_root(): setup_py = os.path.join(root, "setup.py") versioneer_py = os.path.join(root, "versioneer.py") if not (os.path.exists(setup_py) or os.path.exists(versioneer_py)): - err = ("Versioneer was unable to run the project root directory. " - "Versioneer requires setup.py to be executed from " - "its immediate directory (like 'python setup.py COMMAND'), " - "or in a way that lets it use sys.argv[0] to find the root " - "(like 'python path/to/setup.py COMMAND').") + err = ( + "Versioneer was unable to run the project root directory. " + "Versioneer requires setup.py to be executed from " + "its immediate directory (like 'python setup.py COMMAND'), " + "or in a way that lets it use sys.argv[0] to find the root " + "(like 'python path/to/setup.py COMMAND')." + ) raise VersioneerBadRootError(err) try: # Certain runtime workflows (setup.py install/develop in a setuptools @@ -393,10 +323,14 @@ def get_root(): # module-import table will cache the first one. So we can't use # os.path.dirname(__file__), as that will find whichever # versioneer.py was first imported, even in later projects. - me = os.path.realpath(os.path.abspath(__file__)) - if os.path.splitext(me)[0] != os.path.splitext(versioneer_py)[0]: - print("Warning: build in %s is using versioneer.py from %s" - % (os.path.dirname(me), versioneer_py)) + my_path = os.path.realpath(os.path.abspath(__file__)) + me_dir = os.path.normcase(os.path.splitext(my_path)[0]) + vsr_dir = os.path.normcase(os.path.splitext(versioneer_py)[0]) + if me_dir != vsr_dir: + print( + "Warning: build in %s is using versioneer.py from %s" + % (os.path.dirname(my_path), versioneer_py) + ) except NameError: pass return root @@ -404,85 +338,92 @@ def get_root(): def get_config_from_root(root): """Read the project setup.cfg file to determine Versioneer config.""" - # This might raise EnvironmentError (if setup.cfg is missing), or + # This might raise OSError (if setup.cfg is missing), or # configparser.NoSectionError (if it lacks a [versioneer] section), or # configparser.NoOptionError (if it lacks "VCS="). See the docstring at # the top of versioneer.py for instructions on writing your setup.cfg . setup_cfg = os.path.join(root, "setup.cfg") - parser = configparser.SafeConfigParser() - with open(setup_cfg, "r") as f: - parser.readfp(f) + parser = configparser.ConfigParser() + with open(setup_cfg, "r") as cfg_file: + parser.read_file(cfg_file) VCS = parser.get("versioneer", "VCS") # mandatory - def get(parser, name): - if parser.has_option("versioneer", name): - return parser.get("versioneer", name) - return None + # Dict-like interface for non-mandatory entries + section = parser["versioneer"] + cfg = VersioneerConfig() cfg.VCS = VCS - cfg.style = get(parser, "style") or "" - cfg.versionfile_source = get(parser, "versionfile_source") - cfg.versionfile_build = get(parser, "versionfile_build") - cfg.tag_prefix = get(parser, "tag_prefix") + cfg.style = section.get("style", "") + cfg.versionfile_source = section.get("versionfile_source") + cfg.versionfile_build = section.get("versionfile_build") + cfg.tag_prefix = section.get("tag_prefix") if cfg.tag_prefix in ("''", '""'): cfg.tag_prefix = "" - cfg.parentdir_prefix = get(parser, "parentdir_prefix") - cfg.verbose = get(parser, "verbose") + cfg.parentdir_prefix = section.get("parentdir_prefix") + cfg.verbose = section.get("verbose") return cfg class NotThisMethod(Exception): """Exception raised if a method is not valid for the current scenario.""" + # these dictionaries contain VCS-specific tools -LONG_VERSION_PY = {} -HANDLERS = {} +LONG_VERSION_PY: Dict[str, str] = {} +HANDLERS: Dict[str, Dict[str, Callable]] = {} def register_vcs_handler(vcs, method): # decorator - """Decorator to mark a method as the handler for a particular VCS.""" + """Create decorator to mark a method as the handler of a VCS.""" + def decorate(f): """Store f in HANDLERS[vcs][method].""" - if vcs not in HANDLERS: - HANDLERS[vcs] = {} - HANDLERS[vcs][method] = f + HANDLERS.setdefault(vcs, {})[method] = f return f + return decorate -def run_command(commands, args, cwd=None, verbose=False, hide_stderr=False): +def run_command(commands, args, cwd=None, verbose=False, hide_stderr=False, env=None): """Call the given command(s).""" assert isinstance(commands, list) - p = None - for c in commands: + process = None + for command in commands: try: - dispcmd = str([c] + args) + dispcmd = str([command] + args) # remember shell=False, so use git.cmd on windows, not just git - p = subprocess.Popen([c] + args, cwd=cwd, stdout=subprocess.PIPE, - stderr=(subprocess.PIPE if hide_stderr - else None)) + process = subprocess.Popen( + [command] + args, + cwd=cwd, + env=env, + stdout=subprocess.PIPE, + stderr=(subprocess.PIPE if hide_stderr else None), + ) break - except EnvironmentError: + except OSError: e = sys.exc_info()[1] if e.errno == errno.ENOENT: continue if verbose: print("unable to run %s" % dispcmd) print(e) - return None + return None, None else: if verbose: print("unable to find command, tried %s" % (commands,)) - return None - stdout = p.communicate()[0].strip() - if sys.version_info[0] >= 3: - stdout = stdout.decode() - if p.returncode != 0: + return None, None + stdout = process.communicate()[0].strip().decode() + if process.returncode != 0: if verbose: print("unable to run %s (error)" % dispcmd) - return None - return stdout -LONG_VERSION_PY['git'] = ''' + print("stdout was %s" % stdout) + return None, process.returncode + return stdout, process.returncode + + +LONG_VERSION_PY[ + "git" +] = r''' # This file helps to compute a version number in source trees obtained from # git-archive tarball (such as those provided by githubs download-from-tag # feature). Distribution tarballs (built by setup.py sdist) and build @@ -490,7 +431,7 @@ LONG_VERSION_PY['git'] = ''' # that just contains the computed version number. # This file is released into the public domain. Generated by -# versioneer-0.16 (https://github.com/warner/python-versioneer) +# versioneer-0.21 (https://github.com/python-versioneer/python-versioneer) """Git implementation of _version.py.""" @@ -499,6 +440,7 @@ import os import re import subprocess import sys +from typing import Callable, Dict def get_keywords(): @@ -509,7 +451,8 @@ def get_keywords(): # get_keywords(). git_refnames = "%(DOLLAR)sFormat:%%d%(DOLLAR)s" git_full = "%(DOLLAR)sFormat:%%H%(DOLLAR)s" - keywords = {"refnames": git_refnames, "full": git_full} + git_date = "%(DOLLAR)sFormat:%%ci%(DOLLAR)s" + keywords = {"refnames": git_refnames, "full": git_full, "date": git_date} return keywords @@ -535,12 +478,12 @@ class NotThisMethod(Exception): """Exception raised if a method is not valid for the current scenario.""" -LONG_VERSION_PY = {} -HANDLERS = {} +LONG_VERSION_PY: Dict[str, str] = {} +HANDLERS: Dict[str, Dict[str, Callable]] = {} def register_vcs_handler(vcs, method): # decorator - """Decorator to mark a method as the handler for a particular VCS.""" + """Create decorator to mark a method as the handler of a VCS.""" def decorate(f): """Store f in HANDLERS[vcs][method].""" if vcs not in HANDLERS: @@ -550,55 +493,63 @@ def register_vcs_handler(vcs, method): # decorator return decorate -def run_command(commands, args, cwd=None, verbose=False, hide_stderr=False): +def run_command(commands, args, cwd=None, verbose=False, hide_stderr=False, + env=None): """Call the given command(s).""" assert isinstance(commands, list) - p = None - for c in commands: + process = None + for command in commands: try: - dispcmd = str([c] + args) + dispcmd = str([command] + args) # remember shell=False, so use git.cmd on windows, not just git - p = subprocess.Popen([c] + args, cwd=cwd, stdout=subprocess.PIPE, - stderr=(subprocess.PIPE if hide_stderr - else None)) + process = subprocess.Popen([command] + args, cwd=cwd, env=env, + stdout=subprocess.PIPE, + stderr=(subprocess.PIPE if hide_stderr + else None)) break - except EnvironmentError: + except OSError: e = sys.exc_info()[1] if e.errno == errno.ENOENT: continue if verbose: print("unable to run %%s" %% dispcmd) print(e) - return None + return None, None else: if verbose: print("unable to find command, tried %%s" %% (commands,)) - return None - stdout = p.communicate()[0].strip() - if sys.version_info[0] >= 3: - stdout = stdout.decode() - if p.returncode != 0: + return None, None + stdout = process.communicate()[0].strip().decode() + if process.returncode != 0: if verbose: print("unable to run %%s (error)" %% dispcmd) - return None - return stdout + print("stdout was %%s" %% stdout) + return None, process.returncode + return stdout, process.returncode def versions_from_parentdir(parentdir_prefix, root, verbose): """Try to determine the version from the parent directory name. - Source tarballs conventionally unpack into a directory that includes - both the project name and a version string. + Source tarballs conventionally unpack into a directory that includes both + the project name and a version string. We will also support searching up + two directory levels for an appropriately named parent directory """ - dirname = os.path.basename(root) - if not dirname.startswith(parentdir_prefix): - if verbose: - print("guessing rootdir is '%%s', but '%%s' doesn't start with " - "prefix '%%s'" %% (root, dirname, parentdir_prefix)) - raise NotThisMethod("rootdir doesn't start with parentdir_prefix") - return {"version": dirname[len(parentdir_prefix):], - "full-revisionid": None, - "dirty": False, "error": None} + rootdirs = [] + + for _ in range(3): + dirname = os.path.basename(root) + if dirname.startswith(parentdir_prefix): + return {"version": dirname[len(parentdir_prefix):], + "full-revisionid": None, + "dirty": False, "error": None, "date": None} + rootdirs.append(root) + root = os.path.dirname(root) # up a level + + if verbose: + print("Tried directories %%s but none started with prefix %%s" %% + (str(rootdirs), parentdir_prefix)) + raise NotThisMethod("rootdir doesn't start with parentdir_prefix") @register_vcs_handler("git", "get_keywords") @@ -610,18 +561,21 @@ def git_get_keywords(versionfile_abs): # _version.py. keywords = {} try: - f = open(versionfile_abs, "r") - for line in f.readlines(): - if line.strip().startswith("git_refnames ="): - mo = re.search(r'=\s*"(.*)"', line) - if mo: - keywords["refnames"] = mo.group(1) - if line.strip().startswith("git_full ="): - mo = re.search(r'=\s*"(.*)"', line) - if mo: - keywords["full"] = mo.group(1) - f.close() - except EnvironmentError: + with open(versionfile_abs, "r") as fobj: + for line in fobj: + if line.strip().startswith("git_refnames ="): + mo = re.search(r'=\s*"(.*)"', line) + if mo: + keywords["refnames"] = mo.group(1) + if line.strip().startswith("git_full ="): + mo = re.search(r'=\s*"(.*)"', line) + if mo: + keywords["full"] = mo.group(1) + if line.strip().startswith("git_date ="): + mo = re.search(r'=\s*"(.*)"', line) + if mo: + keywords["date"] = mo.group(1) + except OSError: pass return keywords @@ -629,18 +583,31 @@ def git_get_keywords(versionfile_abs): @register_vcs_handler("git", "keywords") def git_versions_from_keywords(keywords, tag_prefix, verbose): """Get version information from git keywords.""" - if not keywords: - raise NotThisMethod("no keywords at all, weird") + if "refnames" not in keywords: + raise NotThisMethod("Short version file found") + date = keywords.get("date") + if date is not None: + # Use only the last line. Previous lines may contain GPG signature + # information. + date = date.splitlines()[-1] + + # git-2.2.0 added "%%cI", which expands to an ISO-8601 -compliant + # datestamp. However we prefer "%%ci" (which expands to an "ISO-8601 + # -like" string, which we must then edit to make compliant), because + # it's been around since git-1.5.3, and it's too difficult to + # discover which version we're using, or to work around using an + # older one. + date = date.strip().replace(" ", "T", 1).replace(" ", "", 1) refnames = keywords["refnames"].strip() if refnames.startswith("$Format"): if verbose: print("keywords are unexpanded, not using") raise NotThisMethod("unexpanded keywords, not a git-archive tarball") - refs = set([r.strip() for r in refnames.strip("()").split(",")]) + refs = {r.strip() for r in refnames.strip("()").split(",")} # starting in git-1.8.3, tags are listed as "tag: foo-1.0" instead of # just "foo-1.0". If we see a "tag: " prefix, prefer those. TAG = "tag: " - tags = set([r[len(TAG):] for r in refs if r.startswith(TAG)]) + tags = {r[len(TAG):] for r in refs if r.startswith(TAG)} if not tags: # Either we're using git < 1.8.3, or there really are no tags. We use # a heuristic: assume all version tags have a digit. The old git %%d @@ -649,56 +616,67 @@ def git_versions_from_keywords(keywords, tag_prefix, verbose): # between branches and tags. By ignoring refnames without digits, we # filter out many common branch names like "release" and # "stabilization", as well as "HEAD" and "master". - tags = set([r for r in refs if re.search(r'\d', r)]) + tags = {r for r in refs if re.search(r'\d', r)} if verbose: - print("discarding '%%s', no digits" %% ",".join(refs-tags)) + print("discarding '%%s', no digits" %% ",".join(refs - tags)) if verbose: print("likely tags: %%s" %% ",".join(sorted(tags))) for ref in sorted(tags): # sorting will prefer e.g. "2.0" over "2.0rc1" if ref.startswith(tag_prefix): r = ref[len(tag_prefix):] + # Filter out refs that exactly match prefix or that don't start + # with a number once the prefix is stripped (mostly a concern + # when prefix is '') + if not re.match(r'\d', r): + continue if verbose: print("picking %%s" %% r) return {"version": r, "full-revisionid": keywords["full"].strip(), - "dirty": False, "error": None - } + "dirty": False, "error": None, + "date": date} # no suitable tags, so version is "0+unknown", but full hex is still there if verbose: print("no suitable tags, using unknown + full revision id") return {"version": "0+unknown", "full-revisionid": keywords["full"].strip(), - "dirty": False, "error": "no suitable tags"} + "dirty": False, "error": "no suitable tags", "date": None} @register_vcs_handler("git", "pieces_from_vcs") -def git_pieces_from_vcs(tag_prefix, root, verbose, run_command=run_command): +def git_pieces_from_vcs(tag_prefix, root, verbose, runner=run_command): """Get version from 'git describe' in the root of the source tree. This only gets called if the git-archive 'subst' keywords were *not* expanded, and _version.py hasn't already been rewritten with a short version string, meaning we're inside a checked out source tree. """ - if not os.path.exists(os.path.join(root, ".git")): - if verbose: - print("no .git in %%s" %% root) - raise NotThisMethod("no .git directory") - GITS = ["git"] + TAG_PREFIX_REGEX = "*" if sys.platform == "win32": GITS = ["git.cmd", "git.exe"] + TAG_PREFIX_REGEX = r"\*" + + _, rc = runner(GITS, ["rev-parse", "--git-dir"], cwd=root, + hide_stderr=True) + if rc != 0: + if verbose: + print("Directory %%s not under git control" %% root) + raise NotThisMethod("'git rev-parse --git-dir' returned error") + # if there is a tag matching tag_prefix, this yields TAG-NUM-gHEX[-dirty] # if there isn't one, this yields HEX[-dirty] (no NUM) - describe_out = run_command(GITS, ["describe", "--tags", "--dirty", - "--always", "--long", - "--match", "%%s*" %% tag_prefix], - cwd=root) + describe_out, rc = runner(GITS, ["describe", "--tags", "--dirty", + "--always", "--long", + "--match", + "%%s%%s" %% (tag_prefix, TAG_PREFIX_REGEX)], + cwd=root) # --long was added in git-1.5.5 if describe_out is None: raise NotThisMethod("'git describe' failed") describe_out = describe_out.strip() - full_out = run_command(GITS, ["rev-parse", "HEAD"], cwd=root) + full_out, rc = runner(GITS, ["rev-parse", "HEAD"], cwd=root) if full_out is None: raise NotThisMethod("'git rev-parse' failed") full_out = full_out.strip() @@ -708,6 +686,39 @@ def git_pieces_from_vcs(tag_prefix, root, verbose, run_command=run_command): pieces["short"] = full_out[:7] # maybe improved later pieces["error"] = None + branch_name, rc = runner(GITS, ["rev-parse", "--abbrev-ref", "HEAD"], + cwd=root) + # --abbrev-ref was added in git-1.6.3 + if rc != 0 or branch_name is None: + raise NotThisMethod("'git rev-parse --abbrev-ref' returned error") + branch_name = branch_name.strip() + + if branch_name == "HEAD": + # If we aren't exactly on a branch, pick a branch which represents + # the current commit. If all else fails, we are on a branchless + # commit. + branches, rc = runner(GITS, ["branch", "--contains"], cwd=root) + # --contains was added in git-1.5.4 + if rc != 0 or branches is None: + raise NotThisMethod("'git branch --contains' returned error") + branches = branches.split("\n") + + # Remove the first line if we're running detached + if "(" in branches[0]: + branches.pop(0) + + # Strip off the leading "* " from the list of branches. + branches = [branch[2:] for branch in branches] + if "master" in branches: + branch_name = "master" + elif not branches: + branch_name = None + else: + # Pick the first branch that is returned. Good or bad. + branch_name = branches[0] + + pieces["branch"] = branch_name + # parse describe_out. It will be like TAG-NUM-gHEX[-dirty] or HEX[-dirty] # TAG might have hyphens. git_describe = describe_out @@ -724,7 +735,7 @@ def git_pieces_from_vcs(tag_prefix, root, verbose, run_command=run_command): # TAG-NUM-gHEX mo = re.search(r'^(.+)-(\d+)-g([0-9a-f]+)$', git_describe) if not mo: - # unparseable. Maybe git-describe is misbehaving? + # unparsable. Maybe git-describe is misbehaving? pieces["error"] = ("unable to parse git-describe output: '%%s'" %% describe_out) return pieces @@ -749,10 +760,16 @@ def git_pieces_from_vcs(tag_prefix, root, verbose, run_command=run_command): else: # HEX: no tags pieces["closest-tag"] = None - count_out = run_command(GITS, ["rev-list", "HEAD", "--count"], - cwd=root) + count_out, rc = runner(GITS, ["rev-list", "HEAD", "--count"], cwd=root) pieces["distance"] = int(count_out) # total number of commits + # commit date: see ISO-8601 comment in git_versions_from_keywords() + date = runner(GITS, ["show", "-s", "--format=%%ci", "HEAD"], cwd=root)[0].strip() + # Use only the last line. Previous lines may contain GPG signature + # information. + date = date.splitlines()[-1] + pieces["date"] = date.strip().replace(" ", "T", 1).replace(" ", "", 1) + return pieces @@ -788,19 +805,67 @@ def render_pep440(pieces): return rendered -def render_pep440_pre(pieces): - """TAG[.post.devDISTANCE] -- No -dirty. +def render_pep440_branch(pieces): + """TAG[[.dev0]+DISTANCE.gHEX[.dirty]] . + + The ".dev0" means not master branch. Note that .dev0 sorts backwards + (a feature branch will appear "older" than the master branch). Exceptions: - 1: no tags. 0.post.devDISTANCE + 1: no tags. 0[.dev0]+untagged.DISTANCE.gHEX[.dirty] """ if pieces["closest-tag"]: rendered = pieces["closest-tag"] - if pieces["distance"]: - rendered += ".post.dev%%d" %% pieces["distance"] + if pieces["distance"] or pieces["dirty"]: + if pieces["branch"] != "master": + rendered += ".dev0" + rendered += plus_or_dot(pieces) + rendered += "%%d.g%%s" %% (pieces["distance"], pieces["short"]) + if pieces["dirty"]: + rendered += ".dirty" else: # exception #1 - rendered = "0.post.dev%%d" %% pieces["distance"] + rendered = "0" + if pieces["branch"] != "master": + rendered += ".dev0" + rendered += "+untagged.%%d.g%%s" %% (pieces["distance"], + pieces["short"]) + if pieces["dirty"]: + rendered += ".dirty" + return rendered + + +def pep440_split_post(ver): + """Split pep440 version string at the post-release segment. + + Returns the release segments before the post-release and the + post-release version number (or -1 if no post-release segment is present). + """ + vc = str.split(ver, ".post") + return vc[0], int(vc[1] or 0) if len(vc) == 2 else None + + +def render_pep440_pre(pieces): + """TAG[.postN.devDISTANCE] -- No -dirty. + + Exceptions: + 1: no tags. 0.post0.devDISTANCE + """ + if pieces["closest-tag"]: + if pieces["distance"]: + # update the post release segment + tag_version, post_version = pep440_split_post(pieces["closest-tag"]) + rendered = tag_version + if post_version is not None: + rendered += ".post%%d.dev%%d" %% (post_version+1, pieces["distance"]) + else: + rendered += ".post0.dev%%d" %% (pieces["distance"]) + else: + # no commits, use the tag as the version + rendered = pieces["closest-tag"] + else: + # exception #1 + rendered = "0.post0.dev%%d" %% pieces["distance"] return rendered @@ -831,12 +896,41 @@ def render_pep440_post(pieces): return rendered +def render_pep440_post_branch(pieces): + """TAG[.postDISTANCE[.dev0]+gHEX[.dirty]] . + + The ".dev0" means not master branch. + + Exceptions: + 1: no tags. 0.postDISTANCE[.dev0]+gHEX[.dirty] + """ + if pieces["closest-tag"]: + rendered = pieces["closest-tag"] + if pieces["distance"] or pieces["dirty"]: + rendered += ".post%%d" %% pieces["distance"] + if pieces["branch"] != "master": + rendered += ".dev0" + rendered += plus_or_dot(pieces) + rendered += "g%%s" %% pieces["short"] + if pieces["dirty"]: + rendered += ".dirty" + else: + # exception #1 + rendered = "0.post%%d" %% pieces["distance"] + if pieces["branch"] != "master": + rendered += ".dev0" + rendered += "+g%%s" %% pieces["short"] + if pieces["dirty"]: + rendered += ".dirty" + return rendered + + def render_pep440_old(pieces): """TAG[.postDISTANCE[.dev0]] . The ".dev0" means dirty. - Eexceptions: + Exceptions: 1: no tags. 0.postDISTANCE[.dev0] """ if pieces["closest-tag"]: @@ -899,17 +993,22 @@ def render(pieces, style): return {"version": "unknown", "full-revisionid": pieces.get("long"), "dirty": None, - "error": pieces["error"]} + "error": pieces["error"], + "date": None} if not style or style == "default": style = "pep440" # the default if style == "pep440": rendered = render_pep440(pieces) + elif style == "pep440-branch": + rendered = render_pep440_branch(pieces) elif style == "pep440-pre": rendered = render_pep440_pre(pieces) elif style == "pep440-post": rendered = render_pep440_post(pieces) + elif style == "pep440-post-branch": + rendered = render_pep440_post_branch(pieces) elif style == "pep440-old": rendered = render_pep440_old(pieces) elif style == "git-describe": @@ -920,7 +1019,8 @@ def render(pieces, style): raise ValueError("unknown style '%%s'" %% style) return {"version": rendered, "full-revisionid": pieces["long"], - "dirty": pieces["dirty"], "error": None} + "dirty": pieces["dirty"], "error": None, + "date": pieces.get("date")} def get_versions(): @@ -944,12 +1044,13 @@ def get_versions(): # versionfile_source is the relative path from the top of the source # tree (where the .git directory might live) to this file. Invert # this to find the root from __file__. - for i in cfg.versionfile_source.split('/'): + for _ in cfg.versionfile_source.split('/'): root = os.path.dirname(root) except NameError: return {"version": "0+unknown", "full-revisionid": None, "dirty": None, - "error": "unable to find root of source tree"} + "error": "unable to find root of source tree", + "date": None} try: pieces = git_pieces_from_vcs(cfg.tag_prefix, root, verbose) @@ -965,7 +1066,7 @@ def get_versions(): return {"version": "0+unknown", "full-revisionid": None, "dirty": None, - "error": "unable to compute version"} + "error": "unable to compute version", "date": None} ''' @@ -978,18 +1079,21 @@ def git_get_keywords(versionfile_abs): # _version.py. keywords = {} try: - f = open(versionfile_abs, "r") - for line in f.readlines(): - if line.strip().startswith("git_refnames ="): - mo = re.search(r'=\s*"(.*)"', line) - if mo: - keywords["refnames"] = mo.group(1) - if line.strip().startswith("git_full ="): - mo = re.search(r'=\s*"(.*)"', line) - if mo: - keywords["full"] = mo.group(1) - f.close() - except EnvironmentError: + with open(versionfile_abs, "r") as fobj: + for line in fobj: + if line.strip().startswith("git_refnames ="): + mo = re.search(r'=\s*"(.*)"', line) + if mo: + keywords["refnames"] = mo.group(1) + if line.strip().startswith("git_full ="): + mo = re.search(r'=\s*"(.*)"', line) + if mo: + keywords["full"] = mo.group(1) + if line.strip().startswith("git_date ="): + mo = re.search(r'=\s*"(.*)"', line) + if mo: + keywords["date"] = mo.group(1) + except OSError: pass return keywords @@ -997,18 +1101,31 @@ def git_get_keywords(versionfile_abs): @register_vcs_handler("git", "keywords") def git_versions_from_keywords(keywords, tag_prefix, verbose): """Get version information from git keywords.""" - if not keywords: - raise NotThisMethod("no keywords at all, weird") + if "refnames" not in keywords: + raise NotThisMethod("Short version file found") + date = keywords.get("date") + if date is not None: + # Use only the last line. Previous lines may contain GPG signature + # information. + date = date.splitlines()[-1] + + # git-2.2.0 added "%cI", which expands to an ISO-8601 -compliant + # datestamp. However we prefer "%ci" (which expands to an "ISO-8601 + # -like" string, which we must then edit to make compliant), because + # it's been around since git-1.5.3, and it's too difficult to + # discover which version we're using, or to work around using an + # older one. + date = date.strip().replace(" ", "T", 1).replace(" ", "", 1) refnames = keywords["refnames"].strip() if refnames.startswith("$Format"): if verbose: print("keywords are unexpanded, not using") raise NotThisMethod("unexpanded keywords, not a git-archive tarball") - refs = set([r.strip() for r in refnames.strip("()").split(",")]) + refs = {r.strip() for r in refnames.strip("()").split(",")} # starting in git-1.8.3, tags are listed as "tag: foo-1.0" instead of # just "foo-1.0". If we see a "tag: " prefix, prefer those. TAG = "tag: " - tags = set([r[len(TAG):] for r in refs if r.startswith(TAG)]) + tags = {r[len(TAG) :] for r in refs if r.startswith(TAG)} if not tags: # Either we're using git < 1.8.3, or there really are no tags. We use # a heuristic: assume all version tags have a digit. The old git %d @@ -1017,56 +1134,81 @@ def git_versions_from_keywords(keywords, tag_prefix, verbose): # between branches and tags. By ignoring refnames without digits, we # filter out many common branch names like "release" and # "stabilization", as well as "HEAD" and "master". - tags = set([r for r in refs if re.search(r'\d', r)]) + tags = {r for r in refs if re.search(r"\d", r)} if verbose: - print("discarding '%s', no digits" % ",".join(refs-tags)) + print("discarding '%s', no digits" % ",".join(refs - tags)) if verbose: print("likely tags: %s" % ",".join(sorted(tags))) for ref in sorted(tags): # sorting will prefer e.g. "2.0" over "2.0rc1" if ref.startswith(tag_prefix): - r = ref[len(tag_prefix):] + r = ref[len(tag_prefix) :] + # Filter out refs that exactly match prefix or that don't start + # with a number once the prefix is stripped (mostly a concern + # when prefix is '') + if not re.match(r"\d", r): + continue if verbose: print("picking %s" % r) - return {"version": r, - "full-revisionid": keywords["full"].strip(), - "dirty": False, "error": None - } + return { + "version": r, + "full-revisionid": keywords["full"].strip(), + "dirty": False, + "error": None, + "date": date, + } # no suitable tags, so version is "0+unknown", but full hex is still there if verbose: print("no suitable tags, using unknown + full revision id") - return {"version": "0+unknown", - "full-revisionid": keywords["full"].strip(), - "dirty": False, "error": "no suitable tags"} + return { + "version": "0+unknown", + "full-revisionid": keywords["full"].strip(), + "dirty": False, + "error": "no suitable tags", + "date": None, + } @register_vcs_handler("git", "pieces_from_vcs") -def git_pieces_from_vcs(tag_prefix, root, verbose, run_command=run_command): +def git_pieces_from_vcs(tag_prefix, root, verbose, runner=run_command): """Get version from 'git describe' in the root of the source tree. This only gets called if the git-archive 'subst' keywords were *not* expanded, and _version.py hasn't already been rewritten with a short version string, meaning we're inside a checked out source tree. """ - if not os.path.exists(os.path.join(root, ".git")): - if verbose: - print("no .git in %s" % root) - raise NotThisMethod("no .git directory") - GITS = ["git"] + TAG_PREFIX_REGEX = "*" if sys.platform == "win32": GITS = ["git.cmd", "git.exe"] + TAG_PREFIX_REGEX = r"\*" + + _, rc = runner(GITS, ["rev-parse", "--git-dir"], cwd=root, hide_stderr=True) + if rc != 0: + if verbose: + print("Directory %s not under git control" % root) + raise NotThisMethod("'git rev-parse --git-dir' returned error") + # if there is a tag matching tag_prefix, this yields TAG-NUM-gHEX[-dirty] # if there isn't one, this yields HEX[-dirty] (no NUM) - describe_out = run_command(GITS, ["describe", "--tags", "--dirty", - "--always", "--long", - "--match", "%s*" % tag_prefix], - cwd=root) + describe_out, rc = runner( + GITS, + [ + "describe", + "--tags", + "--dirty", + "--always", + "--long", + "--match", + "%s%s" % (tag_prefix, TAG_PREFIX_REGEX), + ], + cwd=root, + ) # --long was added in git-1.5.5 if describe_out is None: raise NotThisMethod("'git describe' failed") describe_out = describe_out.strip() - full_out = run_command(GITS, ["rev-parse", "HEAD"], cwd=root) + full_out, rc = runner(GITS, ["rev-parse", "HEAD"], cwd=root) if full_out is None: raise NotThisMethod("'git rev-parse' failed") full_out = full_out.strip() @@ -1076,6 +1218,38 @@ def git_pieces_from_vcs(tag_prefix, root, verbose, run_command=run_command): pieces["short"] = full_out[:7] # maybe improved later pieces["error"] = None + branch_name, rc = runner(GITS, ["rev-parse", "--abbrev-ref", "HEAD"], cwd=root) + # --abbrev-ref was added in git-1.6.3 + if rc != 0 or branch_name is None: + raise NotThisMethod("'git rev-parse --abbrev-ref' returned error") + branch_name = branch_name.strip() + + if branch_name == "HEAD": + # If we aren't exactly on a branch, pick a branch which represents + # the current commit. If all else fails, we are on a branchless + # commit. + branches, rc = runner(GITS, ["branch", "--contains"], cwd=root) + # --contains was added in git-1.5.4 + if rc != 0 or branches is None: + raise NotThisMethod("'git branch --contains' returned error") + branches = branches.split("\n") + + # Remove the first line if we're running detached + if "(" in branches[0]: + branches.pop(0) + + # Strip off the leading "* " from the list of branches. + branches = [branch[2:] for branch in branches] + if "master" in branches: + branch_name = "master" + elif not branches: + branch_name = None + else: + # Pick the first branch that is returned. Good or bad. + branch_name = branches[0] + + pieces["branch"] = branch_name + # parse describe_out. It will be like TAG-NUM-gHEX[-dirty] or HEX[-dirty] # TAG might have hyphens. git_describe = describe_out @@ -1084,17 +1258,16 @@ def git_pieces_from_vcs(tag_prefix, root, verbose, run_command=run_command): dirty = git_describe.endswith("-dirty") pieces["dirty"] = dirty if dirty: - git_describe = git_describe[:git_describe.rindex("-dirty")] + git_describe = git_describe[: git_describe.rindex("-dirty")] # now we have TAG-NUM-gHEX or HEX if "-" in git_describe: # TAG-NUM-gHEX - mo = re.search(r'^(.+)-(\d+)-g([0-9a-f]+)$', git_describe) + mo = re.search(r"^(.+)-(\d+)-g([0-9a-f]+)$", git_describe) if not mo: - # unparseable. Maybe git-describe is misbehaving? - pieces["error"] = ("unable to parse git-describe output: '%s'" - % describe_out) + # unparsable. Maybe git-describe is misbehaving? + pieces["error"] = "unable to parse git-describe output: '%s'" % describe_out return pieces # tag @@ -1103,10 +1276,12 @@ def git_pieces_from_vcs(tag_prefix, root, verbose, run_command=run_command): if verbose: fmt = "tag '%s' doesn't start with prefix '%s'" print(fmt % (full_tag, tag_prefix)) - pieces["error"] = ("tag '%s' doesn't start with prefix '%s'" - % (full_tag, tag_prefix)) + pieces["error"] = "tag '%s' doesn't start with prefix '%s'" % ( + full_tag, + tag_prefix, + ) return pieces - pieces["closest-tag"] = full_tag[len(tag_prefix):] + pieces["closest-tag"] = full_tag[len(tag_prefix) :] # distance: number of commits since tag pieces["distance"] = int(mo.group(2)) @@ -1117,10 +1292,16 @@ def git_pieces_from_vcs(tag_prefix, root, verbose, run_command=run_command): else: # HEX: no tags pieces["closest-tag"] = None - count_out = run_command(GITS, ["rev-list", "HEAD", "--count"], - cwd=root) + count_out, rc = runner(GITS, ["rev-list", "HEAD", "--count"], cwd=root) pieces["distance"] = int(count_out) # total number of commits + # commit date: see ISO-8601 comment in git_versions_from_keywords() + date = runner(GITS, ["show", "-s", "--format=%ci", "HEAD"], cwd=root)[0].strip() + # Use only the last line. Previous lines may contain GPG signature + # information. + date = date.splitlines()[-1] + pieces["date"] = date.strip().replace(" ", "T", 1).replace(" ", "", 1) + return pieces @@ -1128,7 +1309,7 @@ def do_vcs_install(manifest_in, versionfile_source, ipy): """Git-specific installation logic for Versioneer. For Git, this means creating/changing .gitattributes to mark _version.py - for export-time keyword substitution. + for export-subst keyword substitution. """ GITS = ["git"] if sys.platform == "win32": @@ -1137,27 +1318,26 @@ def do_vcs_install(manifest_in, versionfile_source, ipy): if ipy: files.append(ipy) try: - me = __file__ - if me.endswith(".pyc") or me.endswith(".pyo"): - me = os.path.splitext(me)[0] + ".py" - versioneer_file = os.path.relpath(me) + my_path = __file__ + if my_path.endswith(".pyc") or my_path.endswith(".pyo"): + my_path = os.path.splitext(my_path)[0] + ".py" + versioneer_file = os.path.relpath(my_path) except NameError: versioneer_file = "versioneer.py" files.append(versioneer_file) present = False try: - f = open(".gitattributes", "r") - for line in f.readlines(): - if line.strip().startswith(versionfile_source): - if "export-subst" in line.strip().split()[1:]: - present = True - f.close() - except EnvironmentError: + with open(".gitattributes", "r") as fobj: + for line in fobj: + if line.strip().startswith(versionfile_source): + if "export-subst" in line.strip().split()[1:]: + present = True + break + except OSError: pass if not present: - f = open(".gitattributes", "a+") - f.write("%s export-subst\n" % versionfile_source) - f.close() + with open(".gitattributes", "a+") as fobj: + fobj.write(f"{versionfile_source} export-subst\n") files.append(".gitattributes") run_command(GITS, ["add", "--"] + files) @@ -1165,27 +1345,40 @@ def do_vcs_install(manifest_in, versionfile_source, ipy): def versions_from_parentdir(parentdir_prefix, root, verbose): """Try to determine the version from the parent directory name. - Source tarballs conventionally unpack into a directory that includes - both the project name and a version string. + Source tarballs conventionally unpack into a directory that includes both + the project name and a version string. We will also support searching up + two directory levels for an appropriately named parent directory """ - dirname = os.path.basename(root) - if not dirname.startswith(parentdir_prefix): - if verbose: - print("guessing rootdir is '%s', but '%s' doesn't start with " - "prefix '%s'" % (root, dirname, parentdir_prefix)) - raise NotThisMethod("rootdir doesn't start with parentdir_prefix") - return {"version": dirname[len(parentdir_prefix):], - "full-revisionid": None, - "dirty": False, "error": None} + rootdirs = [] + + for _ in range(3): + dirname = os.path.basename(root) + if dirname.startswith(parentdir_prefix): + return { + "version": dirname[len(parentdir_prefix) :], + "full-revisionid": None, + "dirty": False, + "error": None, + "date": None, + } + rootdirs.append(root) + root = os.path.dirname(root) # up a level + + if verbose: + print( + "Tried directories %s but none started with prefix %s" + % (str(rootdirs), parentdir_prefix) + ) + raise NotThisMethod("rootdir doesn't start with parentdir_prefix") + SHORT_VERSION_PY = """ -# This file was generated by 'versioneer.py' (0.16) from +# This file was generated by 'versioneer.py' (0.21) from # revision-control system data, or from the parent directory name of an # unpacked source archive. Distribution tarballs contain a pre-generated copy # of this file. import json -import sys version_json = ''' %s @@ -1202,10 +1395,15 @@ def versions_from_file(filename): try: with open(filename) as f: contents = f.read() - except EnvironmentError: + except OSError: raise NotThisMethod("unable to read _version.py") - mo = re.search(r"version_json = '''\n(.*)''' # END VERSION_JSON", - contents, re.M | re.S) + mo = re.search( + r"version_json = '''\n(.*)''' # END VERSION_JSON", contents, re.M | re.S + ) + if not mo: + mo = re.search( + r"version_json = '''\r\n(.*)''' # END VERSION_JSON", contents, re.M | re.S + ) if not mo: raise NotThisMethod("no version_json in _version.py") return json.loads(mo.group(1)) @@ -1214,8 +1412,7 @@ def versions_from_file(filename): def write_to_version_file(filename, versions): """Write the given version number to the given _version.py file.""" os.unlink(filename) - contents = json.dumps(versions, sort_keys=True, - indent=1, separators=(",", ": ")) + contents = json.dumps(versions, sort_keys=True, indent=1, separators=(",", ": ")) with open(filename, "w") as f: f.write(SHORT_VERSION_PY % contents) @@ -1247,26 +1444,72 @@ def render_pep440(pieces): rendered += ".dirty" else: # exception #1 - rendered = "0+untagged.%d.g%s" % (pieces["distance"], - pieces["short"]) + rendered = "0+untagged.%d.g%s" % (pieces["distance"], pieces["short"]) if pieces["dirty"]: rendered += ".dirty" return rendered -def render_pep440_pre(pieces): - """TAG[.post.devDISTANCE] -- No -dirty. +def render_pep440_branch(pieces): + """TAG[[.dev0]+DISTANCE.gHEX[.dirty]] . + + The ".dev0" means not master branch. Note that .dev0 sorts backwards + (a feature branch will appear "older" than the master branch). Exceptions: - 1: no tags. 0.post.devDISTANCE + 1: no tags. 0[.dev0]+untagged.DISTANCE.gHEX[.dirty] """ if pieces["closest-tag"]: rendered = pieces["closest-tag"] - if pieces["distance"]: - rendered += ".post.dev%d" % pieces["distance"] + if pieces["distance"] or pieces["dirty"]: + if pieces["branch"] != "master": + rendered += ".dev0" + rendered += plus_or_dot(pieces) + rendered += "%d.g%s" % (pieces["distance"], pieces["short"]) + if pieces["dirty"]: + rendered += ".dirty" else: # exception #1 - rendered = "0.post.dev%d" % pieces["distance"] + rendered = "0" + if pieces["branch"] != "master": + rendered += ".dev0" + rendered += "+untagged.%d.g%s" % (pieces["distance"], pieces["short"]) + if pieces["dirty"]: + rendered += ".dirty" + return rendered + + +def pep440_split_post(ver): + """Split pep440 version string at the post-release segment. + + Returns the release segments before the post-release and the + post-release version number (or -1 if no post-release segment is present). + """ + vc = str.split(ver, ".post") + return vc[0], int(vc[1] or 0) if len(vc) == 2 else None + + +def render_pep440_pre(pieces): + """TAG[.postN.devDISTANCE] -- No -dirty. + + Exceptions: + 1: no tags. 0.post0.devDISTANCE + """ + if pieces["closest-tag"]: + if pieces["distance"]: + # update the post release segment + tag_version, post_version = pep440_split_post(pieces["closest-tag"]) + rendered = tag_version + if post_version is not None: + rendered += ".post%d.dev%d" % (post_version + 1, pieces["distance"]) + else: + rendered += ".post0.dev%d" % (pieces["distance"]) + else: + # no commits, use the tag as the version + rendered = pieces["closest-tag"] + else: + # exception #1 + rendered = "0.post0.dev%d" % pieces["distance"] return rendered @@ -1297,12 +1540,41 @@ def render_pep440_post(pieces): return rendered +def render_pep440_post_branch(pieces): + """TAG[.postDISTANCE[.dev0]+gHEX[.dirty]] . + + The ".dev0" means not master branch. + + Exceptions: + 1: no tags. 0.postDISTANCE[.dev0]+gHEX[.dirty] + """ + if pieces["closest-tag"]: + rendered = pieces["closest-tag"] + if pieces["distance"] or pieces["dirty"]: + rendered += ".post%d" % pieces["distance"] + if pieces["branch"] != "master": + rendered += ".dev0" + rendered += plus_or_dot(pieces) + rendered += "g%s" % pieces["short"] + if pieces["dirty"]: + rendered += ".dirty" + else: + # exception #1 + rendered = "0.post%d" % pieces["distance"] + if pieces["branch"] != "master": + rendered += ".dev0" + rendered += "+g%s" % pieces["short"] + if pieces["dirty"]: + rendered += ".dirty" + return rendered + + def render_pep440_old(pieces): """TAG[.postDISTANCE[.dev0]] . The ".dev0" means dirty. - Eexceptions: + Exceptions: 1: no tags. 0.postDISTANCE[.dev0] """ if pieces["closest-tag"]: @@ -1362,20 +1634,27 @@ def render_git_describe_long(pieces): def render(pieces, style): """Render the given version pieces into the requested style.""" if pieces["error"]: - return {"version": "unknown", - "full-revisionid": pieces.get("long"), - "dirty": None, - "error": pieces["error"]} + return { + "version": "unknown", + "full-revisionid": pieces.get("long"), + "dirty": None, + "error": pieces["error"], + "date": None, + } if not style or style == "default": style = "pep440" # the default if style == "pep440": rendered = render_pep440(pieces) + elif style == "pep440-branch": + rendered = render_pep440_branch(pieces) elif style == "pep440-pre": rendered = render_pep440_pre(pieces) elif style == "pep440-post": rendered = render_pep440_post(pieces) + elif style == "pep440-post-branch": + rendered = render_pep440_post_branch(pieces) elif style == "pep440-old": rendered = render_pep440_old(pieces) elif style == "git-describe": @@ -1385,8 +1664,13 @@ def render(pieces, style): else: raise ValueError("unknown style '%s'" % style) - return {"version": rendered, "full-revisionid": pieces["long"], - "dirty": pieces["dirty"], "error": None} + return { + "version": rendered, + "full-revisionid": pieces["long"], + "dirty": pieces["dirty"], + "error": None, + "date": pieces.get("date"), + } class VersioneerBadRootError(Exception): @@ -1409,8 +1693,9 @@ def get_versions(verbose=False): handlers = HANDLERS.get(cfg.VCS) assert handlers, "unrecognized VCS '%s'" % cfg.VCS verbose = verbose or cfg.verbose - assert cfg.versionfile_source is not None, \ - "please set versioneer.versionfile_source" + assert ( + cfg.versionfile_source is not None + ), "please set versioneer.versionfile_source" assert cfg.tag_prefix is not None, "please set versioneer.tag_prefix" versionfile_abs = os.path.join(root, cfg.versionfile_source) @@ -1464,8 +1749,13 @@ def get_versions(verbose=False): if verbose: print("unable to compute version") - return {"version": "0+unknown", "full-revisionid": None, - "dirty": None, "error": "unable to compute version"} + return { + "version": "0+unknown", + "full-revisionid": None, + "dirty": None, + "error": "unable to compute version", + "date": None, + } def get_version(): @@ -1473,8 +1763,12 @@ def get_version(): return get_versions()["version"] -def get_cmdclass(): - """Get the custom setuptools/distutils subclasses used by Versioneer.""" +def get_cmdclass(cmdclass=None): + """Get the custom setuptools/distutils subclasses used by Versioneer. + + If the package uses a different cmdclass (e.g. one from numpy), it + should be provide as an argument. + """ if "versioneer" in sys.modules: del sys.modules["versioneer"] # this fixes the "python setup.py develop" case (also 'install' and @@ -1488,9 +1782,9 @@ def get_cmdclass(): # parent is protected against the child's "import versioneer". By # removing ourselves from sys.modules here, before the child build # happens, we protect the child from the parent's versioneer too. - # Also see https://github.com/warner/python-versioneer/issues/52 + # Also see https://github.com/python-versioneer/python-versioneer/issues/52 - cmds = {} + cmds = {} if cmdclass is None else cmdclass.copy() # we add "version" to both distutils and setuptools from distutils.core import Command @@ -1511,8 +1805,10 @@ def get_cmdclass(): print("Version: %s" % vers["version"]) print(" full-revisionid: %s" % vers.get("full-revisionid")) print(" dirty: %s" % vers.get("dirty")) + print(" date: %s" % vers.get("date")) if vers["error"]: print(" error: %s" % vers["error"]) + cmds["version"] = cmd_version # we override "build_py" in both distutils and setuptools @@ -1524,9 +1820,16 @@ def get_cmdclass(): # setuptools/bdist_egg -> distutils/install_lib -> build_py # setuptools/install -> bdist_egg ->.. # setuptools/develop -> ? + # pip install: + # copies source tree to a tempdir before running egg_info/etc + # if .git isn't copied too, 'git describe' will fail + # then does setup.py bdist_wheel, or sometimes setup.py install + # setup.py egg_info -> ? # we override different "build_py" commands for both environments - if "setuptools" in sys.modules: + if "build_py" in cmds: + _build_py = cmds["build_py"] + elif "setuptools" in sys.modules: from setuptools.command.build_py import build_py as _build_py else: from distutils.command.build_py import build_py as _build_py @@ -1540,15 +1843,49 @@ def get_cmdclass(): # now locate _version.py in the new build/ directory and replace # it with an updated value if cfg.versionfile_build: - target_versionfile = os.path.join(self.build_lib, - cfg.versionfile_build) + target_versionfile = os.path.join(self.build_lib, cfg.versionfile_build) print("UPDATING %s" % target_versionfile) write_to_version_file(target_versionfile, versions) + cmds["build_py"] = cmd_build_py + if "build_ext" in cmds: + _build_ext = cmds["build_ext"] + elif "setuptools" in sys.modules: + from setuptools.command.build_ext import build_ext as _build_ext + else: + from distutils.command.build_ext import build_ext as _build_ext + + class cmd_build_ext(_build_ext): + def run(self): + root = get_root() + cfg = get_config_from_root(root) + versions = get_versions() + _build_ext.run(self) + if self.inplace: + # build_ext --inplace will only build extensions in + # build/lib<..> dir with no _version.py to write to. + # As in place builds will already have a _version.py + # in the module dir, we do not need to write one. + return + # now locate _version.py in the new build/ directory and replace + # it with an updated value + target_versionfile = os.path.join(self.build_lib, cfg.versionfile_build) + print("UPDATING %s" % target_versionfile) + write_to_version_file(target_versionfile, versions) + + cmds["build_ext"] = cmd_build_ext + if "cx_Freeze" in sys.modules: # cx_freeze enabled? from cx_Freeze.dist import build_exe as _build_exe + # nczeczulin reports that py2exe won't like the pep440-style string + # as FILEVERSION, but it can be used for PRODUCTVERSION, e.g. + # setup(console=[{ + # "version": versioneer.get_version().split("+", 1)[0], # FILEVERSION + # "product_version": versioneer.get_version(), + # ... + class cmd_build_exe(_build_exe): def run(self): root = get_root() @@ -1562,18 +1899,53 @@ def get_cmdclass(): os.unlink(target_versionfile) with open(cfg.versionfile_source, "w") as f: LONG = LONG_VERSION_PY[cfg.VCS] - f.write(LONG % - {"DOLLAR": "$", - "STYLE": cfg.style, - "TAG_PREFIX": cfg.tag_prefix, - "PARENTDIR_PREFIX": cfg.parentdir_prefix, - "VERSIONFILE_SOURCE": cfg.versionfile_source, - }) + f.write( + LONG + % { + "DOLLAR": "$", + "STYLE": cfg.style, + "TAG_PREFIX": cfg.tag_prefix, + "PARENTDIR_PREFIX": cfg.parentdir_prefix, + "VERSIONFILE_SOURCE": cfg.versionfile_source, + } + ) + cmds["build_exe"] = cmd_build_exe del cmds["build_py"] + if "py2exe" in sys.modules: # py2exe enabled? + from py2exe.distutils_buildexe import py2exe as _py2exe + + class cmd_py2exe(_py2exe): + def run(self): + root = get_root() + cfg = get_config_from_root(root) + versions = get_versions() + target_versionfile = cfg.versionfile_source + print("UPDATING %s" % target_versionfile) + write_to_version_file(target_versionfile, versions) + + _py2exe.run(self) + os.unlink(target_versionfile) + with open(cfg.versionfile_source, "w") as f: + LONG = LONG_VERSION_PY[cfg.VCS] + f.write( + LONG + % { + "DOLLAR": "$", + "STYLE": cfg.style, + "TAG_PREFIX": cfg.tag_prefix, + "PARENTDIR_PREFIX": cfg.parentdir_prefix, + "VERSIONFILE_SOURCE": cfg.versionfile_source, + } + ) + + cmds["py2exe"] = cmd_py2exe + # we override different "sdist" commands for both environments - if "setuptools" in sys.modules: + if "sdist" in cmds: + _sdist = cmds["sdist"] + elif "setuptools" in sys.modules: from setuptools.command.sdist import sdist as _sdist else: from distutils.command.sdist import sdist as _sdist @@ -1596,8 +1968,10 @@ def get_cmdclass(): # updated value target_versionfile = os.path.join(base_dir, cfg.versionfile_source) print("UPDATING %s" % target_versionfile) - write_to_version_file(target_versionfile, - self._versioneer_generated_versions) + write_to_version_file( + target_versionfile, self._versioneer_generated_versions + ) + cmds["sdist"] = cmd_sdist return cmds @@ -1640,23 +2014,26 @@ SAMPLE_CONFIG = """ """ -INIT_PY_SNIPPET = """ +OLD_SNIPPET = """ from ._version import get_versions __version__ = get_versions()['version'] del get_versions """ +INIT_PY_SNIPPET = """ +from . import {0} +__version__ = {0}.get_versions()['version'] +""" + def do_setup(): - """Main VCS-independent setup function for installing Versioneer.""" + """Do main VCS-independent setup function for installing Versioneer.""" root = get_root() try: cfg = get_config_from_root(root) - except (EnvironmentError, configparser.NoSectionError, - configparser.NoOptionError) as e: - if isinstance(e, (EnvironmentError, configparser.NoSectionError)): - print("Adding sample versioneer config to setup.cfg", - file=sys.stderr) + except (OSError, configparser.NoSectionError, configparser.NoOptionError) as e: + if isinstance(e, (OSError, configparser.NoSectionError)): + print("Adding sample versioneer config to setup.cfg", file=sys.stderr) with open(os.path.join(root, "setup.cfg"), "a") as f: f.write(SAMPLE_CONFIG) print(CONFIG_ERROR, file=sys.stderr) @@ -1665,25 +2042,34 @@ def do_setup(): print(" creating %s" % cfg.versionfile_source) with open(cfg.versionfile_source, "w") as f: LONG = LONG_VERSION_PY[cfg.VCS] - f.write(LONG % {"DOLLAR": "$", - "STYLE": cfg.style, - "TAG_PREFIX": cfg.tag_prefix, - "PARENTDIR_PREFIX": cfg.parentdir_prefix, - "VERSIONFILE_SOURCE": cfg.versionfile_source, - }) + f.write( + LONG + % { + "DOLLAR": "$", + "STYLE": cfg.style, + "TAG_PREFIX": cfg.tag_prefix, + "PARENTDIR_PREFIX": cfg.parentdir_prefix, + "VERSIONFILE_SOURCE": cfg.versionfile_source, + } + ) - ipy = os.path.join(os.path.dirname(cfg.versionfile_source), - "__init__.py") + ipy = os.path.join(os.path.dirname(cfg.versionfile_source), "__init__.py") if os.path.exists(ipy): try: with open(ipy, "r") as f: old = f.read() - except EnvironmentError: + except OSError: old = "" - if INIT_PY_SNIPPET not in old: + module = os.path.splitext(os.path.basename(cfg.versionfile_source))[0] + snippet = INIT_PY_SNIPPET.format(module) + if OLD_SNIPPET in old: + print(" replacing boilerplate in %s" % ipy) + with open(ipy, "w") as f: + f.write(old.replace(OLD_SNIPPET, snippet)) + elif snippet not in old: print(" appending to %s" % ipy) with open(ipy, "a") as f: - f.write(INIT_PY_SNIPPET) + f.write(snippet) else: print(" %s unmodified" % ipy) else: @@ -1702,7 +2088,7 @@ def do_setup(): if line.startswith("include "): for include in line.split()[1:]: simple_includes.add(include) - except EnvironmentError: + except OSError: pass # That doesn't cover everything MANIFEST.in can do # (http://docs.python.org/2/distutils/sourcedist.html#commands), so @@ -1715,15 +2101,17 @@ def do_setup(): else: print(" 'versioneer.py' already in MANIFEST.in") if cfg.versionfile_source not in simple_includes: - print(" appending versionfile_source ('%s') to MANIFEST.in" % - cfg.versionfile_source) + print( + " appending versionfile_source ('%s') to MANIFEST.in" + % cfg.versionfile_source + ) with open(manifest_in, "a") as f: f.write("include %s\n" % cfg.versionfile_source) else: print(" versionfile_source already in MANIFEST.in") # Make VCS-specific changes. For git, this means creating/changing - # .gitattributes to mark _version.py for export-time keyword + # .gitattributes to mark _version.py for export-subst keyword # substitution. do_vcs_install(manifest_in, cfg.versionfile_source, ipy) return 0 @@ -1765,6 +2153,7 @@ def scan_setup_py(): errors += 1 return errors + if __name__ == "__main__": cmd = sys.argv[1] if cmd == "setup":