ContourPy is a Python library for calculating contours of 2D quadrilateral grids. It is written in C++11 and wrapped using pybind11.
It contains the 2005 and 2014 algorithms used in Matplotlib as well as a newer algorithm that includes more features and is available in both serial and multithreaded versions. It provides an easy way for Python libraries to use contouring algorithms without having to include Matplotlib as a dependency.
* **Documentation**: https://contourpy.readthedocs.io
* **Source code**: https://github.com/contourpy/contourpy
| | |
| --- | --- |
| Latest release | [](https://pypi.python.org/pypi/contourpy) [](https://anaconda.org/conda-forge/contourpy) [](https://anaconda.org/anaconda/contourpy) |
| Downloads | [](https://pepy.tech/project/contourpy) [](https://anaconda.org/conda-forge/contourpy) [](https://anaconda.org/anaconda/contourpy) |
| Python version | [](https://pypi.org/project/contourpy/) |
| Coverage | [](https://app.codecov.io/gh/contourpy/contourpy) |
contourpy-1.2.1/benchmarks/ 0000775 0000000 0000000 00000000000 14603035227 0015674 5 ustar 00root root 0000000 0000000 contourpy-1.2.1/benchmarks/README.md 0000664 0000000 0000000 00000002476 14603035227 0017164 0 ustar 00root root 0000000 0000000 Benchmarking
============
`contourpy` uses ASV (https://asv.readthedocs.io) for benchmarking.
Installing ASV
--------------
ASV creates virtualenvs to run benchmarks in. Before using it you need to
```
pip install asv==0.4.2 virtualenv
```
or the `conda` equivalent.
Running benchmarks
------------------
To run all benchmarks against the default `main` branch:
```
cd benchmarks
asv run
```
The first time this is run it creates a machine file to store information about your machine. Then a virtual environment is created and each benchmark is run multiple times to obtain a statistically valid benchmark time.
To list the benchmark timings stored for the `main` branch use:
```
asv show main
```
ASV ships with its own simple webserver to interactively display the results in a webbrowser. To use this:
```
asv publish
asv preview
```
and then open a web browser at the URL specified.
If you want to quickly run all benchmarks once only to check for errors, etc, use:
```
asv dev
```
instead of `asv run`.
Configuration
-------------
ASV configuration information is stored in `benchmarks/asv.conf.json`. This includes a list of branches to benchmark. If you are using a feature branch and wish to benchmark the code in that branch rather than `main`, edit `asv.conf.json` to change the line
```
"branches": ["main"],
```
contourpy-1.2.1/benchmarks/asv.conf.json 0000664 0000000 0000000 00000015207 14603035227 0020311 0 ustar 00root root 0000000 0000000 {
// The version of the config file format. Do not change, unless
// you know what you are doing.
"version": 1,
// The name of the project being benchmarked
"project": "contourpy",
// The project's homepage
"project_url": "http://github.com/contourpy/contourpy",
// The URL or local path of the source code repository for the
// project being benchmarked
"repo": "..",
// The Python project's subdirectory in your repo. If missing or
// the empty string, the project is assumed to be located at the root
// of the repository.
// "repo_subdir": "",
// Customizable commands for building, installing, and
// uninstalling the project. See asv.conf.json documentation.
//
// "install_command": ["in-dir={env_dir} python -mpip install {wheel_file}"],
// "uninstall_command": ["return-code=any python -mpip uninstall -y {project}"],
// "build_command": [
// "python setup.py build",
// "PIP_NO_BUILD_ISOLATION=false python -mpip wheel --no-deps --no-index -w {build_cache_dir} {build_dir}"
// ],
"build_command": [
"python -m pip install --upgrade build pip",
"python -m build --wheel -o {build_cache_dir} {build_dir}"
],
// List of branches to benchmark. If not provided, defaults to "master"
// (for git) or "default" (for mercurial).
"branches": ["main"],
// The DVCS being used. If not set, it will be automatically
// determined from "repo" by looking at the protocol in the URL
// (if remote), or by looking for special directories, such as
// ".git" (if local).
"dvcs": "git",
// The tool to use to create environments. May be "conda",
// "virtualenv" or other value depending on the plugins in use.
// If missing or the empty string, the tool will be automatically
// determined by looking for tools on the PATH environment
// variable.
"environment_type": "virtualenv",
// timeout in seconds for installing any dependencies in environment
// defaults to 10 min
//"install_timeout": 600,
// the base URL to show a commit for the project.
"show_commit_url": "http://github.com/contourpy/contourpy/commit/",
// The Pythons you'd like to test against. If not provided, defaults
// to the current version of Python used to run `asv`.
//"pythons": ["3.9"],
// The list of conda channel names to be searched for benchmark
// dependency packages in the specified order
// "conda_channels": ["conda-forge", "defaults"],
// The matrix of dependencies to test. Each key is the name of a
// package (in PyPI) and the values are version numbers. An empty
// list or empty string indicates to just test against the default
// (latest) version. null indicates that the package is to not be
// installed. If the package to be tested is only available from
// PyPi, and the 'environment_type' is conda, then you can preface
// the package name by 'pip+', and the package will be installed via
// pip (with all the conda available packages installed first,
// followed by the pip installed packages).
"matrix": {
"matplotlib": [],
"numpy": []
},
// Combinations of libraries/python versions can be excluded/included
// from the set to test. Each entry is a dictionary containing additional
// key-value pairs to include/exclude.
//
// An exclude entry excludes entries where all values match. The
// values are regexps that should match the whole string.
//
// An include entry adds an environment. Only the packages listed
// are installed. The 'python' key is required. The exclude rules
// do not apply to includes.
//
// In addition to package names, the following keys are available:
//
// - python
// Python version, as in the *pythons* variable above.
// - environment_type
// Environment type, as above.
// - sys_platform
// Platform, as in sys.platform. Possible values for the common
// cases: 'linux2', 'win32', 'cygwin', 'darwin'.
//
// "exclude": [
// {"python": "3.2", "sys_platform": "win32"}, // skip py3.2 on windows
// {"environment_type": "conda", "six": null}, // don't run without six on conda
// ],
//
// "include": [
// // additional env for python2.7
// {"python": "2.7", "numpy": "1.8"},
// // additional env if run on windows+conda
// {"platform": "win32", "environment_type": "conda", "python": "2.7", "libpython": ""},
// ],
// The directory (relative to the current directory) that benchmarks are
// stored in. If not provided, defaults to "benchmarks"
"benchmark_dir": "benchmarks",
// The directory (relative to the current directory) to cache the Python
// environments in. If not provided, defaults to "env"
"env_dir": ".asv/env",
// The directory (relative to the current directory) that raw benchmark
// results are stored in. If not provided, defaults to "results".
"results_dir": ".asv/results",
// The directory (relative to the current directory) that the html tree
// should be written to. If not provided, defaults to "html".
"html_dir": ".asv/html",
// The number of characters to retain in the commit hashes.
// "hash_length": 8,
// `asv` will cache results of the recent builds in each
// environment, making them faster to install next time. This is
// the number of builds to keep, per environment.
// "build_cache_size": 2,
// The commits after which the regression search in `asv publish`
// should start looking for regressions. Dictionary whose keys are
// regexps matching to benchmark names, and values corresponding to
// the commit (exclusive) after which to start looking for
// regressions. The default is to start from the first commit
// with results. If the commit is `null`, regression detection is
// skipped for the matching benchmark.
//
// "regressions_first_commits": {
// "some_benchmark": "352cdf", // Consider regressions only after this commit
// "another_benchmark": null, // Skip regression detection altogether
// },
// The thresholds for relative change in results, after which `asv
// publish` starts reporting regressions. Dictionary of the same
// form as in ``regressions_first_commits``, with values
// indicating the thresholds. If multiple entries match, the
// maximum is taken. If no entry matches, the default is 5%.
//
// "regressions_thresholds": {
// "some_benchmark": 0.01, // Threshold of 1%
// "another_benchmark": 0.5, // Threshold of 50%
// },
}
contourpy-1.2.1/benchmarks/benchmarks/ 0000775 0000000 0000000 00000000000 14603035227 0020011 5 ustar 00root root 0000000 0000000 contourpy-1.2.1/benchmarks/benchmarks/__init__.py 0000664 0000000 0000000 00000000000 14603035227 0022110 0 ustar 00root root 0000000 0000000 contourpy-1.2.1/benchmarks/benchmarks/bench_base.py 0000664 0000000 0000000 00000001717 14603035227 0022442 0 ustar 00root root 0000000 0000000 from __future__ import annotations
from typing import TYPE_CHECKING, Any
import numpy as np
from contourpy.util.data import random, simple
if TYPE_CHECKING:
import numpy.typing as npt
class BenchBase:
levels: npt.NDArray[np.float64]
timeout: int = 120 # Some rendering benchmarks can take more than the default minute.
x: npt.NDArray[np.float64]
y: npt.NDArray[np.float64]
z: npt.NDArray[np.float64] | np.ma.MaskedArray[Any, Any]
def set_xyz_and_levels(self, dataset: str, n: int, want_mask: bool) -> None:
if dataset == "random":
mask_fraction = 0.05 if want_mask else 0.0
self.x, self.y, self.z = random((n, n), mask_fraction=mask_fraction)
self.levels = np.arange(0.0, 1.01, 0.1)
elif dataset == "simple":
self.x, self.y, self.z = simple((n, n), want_mask=want_mask)
self.levels = np.arange(-1.0, 1.01, 0.1)
else:
raise NotImplementedError
contourpy-1.2.1/benchmarks/benchmarks/bench_filled_mpl20xx.py 0000664 0000000 0000000 00000002362 14603035227 0024356 0 ustar 00root root 0000000 0000000 from __future__ import annotations
from contourpy import FillType, contour_generator
from .bench_base import BenchBase
from .util_bench import corner_mask_to_bool, corner_masks, datasets, problem_sizes
class BenchFilledMpl20xx(BenchBase):
params: tuple[list[str], list[str], list[FillType], list[str | bool], list[int]] = (
["mpl2005", "mpl2014"], datasets(), [FillType.OuterCode], corner_masks(), problem_sizes(),
)
param_names: tuple[str, ...] = ("name", "dataset", "fill_type", "corner_mask", "n")
def setup(
self, name: str, dataset: str, fill_type: FillType, corner_mask: str | bool, n: int,
) -> None:
self.set_xyz_and_levels(dataset, n, corner_mask != "no mask")
def time_filled_mpl20xx(
self, name: str, dataset: str, fill_type: FillType, corner_mask: str | bool, n: int,
) -> None:
if name == "mpl2005" and corner_mask is True:
raise NotImplementedError # Does not support corner_mask=True
cont_gen = contour_generator(
self.x, self.y, self.z, name=name, fill_type=fill_type,
corner_mask=corner_mask_to_bool(corner_mask),
)
for i in range(len(self.levels)-1):
cont_gen.filled(self.levels[i], self.levels[i+1])
contourpy-1.2.1/benchmarks/benchmarks/bench_filled_mpl20xx_render.py 0000664 0000000 0000000 00000002755 14603035227 0025723 0 ustar 00root root 0000000 0000000 from __future__ import annotations
from contourpy import FillType, contour_generator
from contourpy.util.mpl_renderer import MplTestRenderer
from .bench_base import BenchBase
from .util_bench import corner_mask_to_bool, corner_masks, datasets, problem_sizes
class BenchFilledMpl20xxRender(BenchBase):
params: tuple[list[str], list[str], list[FillType], list[str | bool], list[int]] = (
["mpl2005", "mpl2014"], datasets(), [FillType.OuterCode], corner_masks(), problem_sizes(),
)
param_names: tuple[str, ...] = ("name", "dataset", "fill_type", "corner_mask", "n")
def setup(
self, name: str, dataset: str, fill_type: FillType, corner_mask: str | bool, n: int,
) -> None:
self.set_xyz_and_levels(dataset, n, corner_mask != "no mask")
def time_filled_mpl20xx_render(
self, name: str, dataset: str, fill_type: FillType, corner_mask: str | bool, n: int,
) -> None:
if name == "mpl2005" and corner_mask is True:
raise NotImplementedError # Does not support corner_mask=True
cont_gen = contour_generator(
self.x, self.y, self.z, name=name, fill_type=fill_type,
corner_mask=corner_mask_to_bool(corner_mask),
)
renderer = MplTestRenderer()
for i in range(len(self.levels)-1):
filled = cont_gen.filled(self.levels[i], self.levels[i+1])
renderer.filled(filled, fill_type, color=f"C{i}")
renderer.save(f"filled_{name}_{corner_mask}_{fill_type}_{n}.png")
contourpy-1.2.1/benchmarks/benchmarks/bench_filled_serial.py 0000664 0000000 0000000 00000002147 14603035227 0024324 0 ustar 00root root 0000000 0000000 from __future__ import annotations
from contourpy import FillType, contour_generator
from .bench_base import BenchBase
from .util_bench import corner_mask_to_bool, corner_masks, datasets, fill_types, problem_sizes
class BenchFilledSerial(BenchBase):
params: tuple[list[str], list[str], list[FillType], list[str | bool], list[int]] = (
["serial"], datasets(), fill_types(), corner_masks(), problem_sizes(),
)
param_names: tuple[str, ...] = ("name", "dataset", "fill_type", "corner_mask", "n")
def setup(
self, name: str, dataset: str, fill_type: FillType, corner_mask: str | bool, n: int,
) -> None:
self.set_xyz_and_levels(dataset, n, corner_mask != "no mask")
def time_filled_serial(
self, name: str, dataset: str, fill_type: FillType, corner_mask: str | bool, n: int,
) -> None:
cont_gen = contour_generator(
self.x, self.y, self.z, name=name, fill_type=fill_type,
corner_mask=corner_mask_to_bool(corner_mask),
)
for i in range(len(self.levels)-1):
cont_gen.filled(self.levels[i], self.levels[i+1])
contourpy-1.2.1/benchmarks/benchmarks/bench_filled_serial_chunk.py 0000664 0000000 0000000 00000002430 14603035227 0025507 0 ustar 00root root 0000000 0000000 from __future__ import annotations
from contourpy import FillType, contour_generator
from .bench_base import BenchBase
from .util_bench import corner_mask_to_bool, corner_masks, datasets, fill_types, total_chunk_counts
class BenchFilledSerialChunk(BenchBase):
params: tuple[list[str], list[str], list[FillType], list[str | bool], list[int], list[int]] = (
["serial"], datasets(), fill_types(), corner_masks(), [1000], total_chunk_counts(),
)
param_names: tuple[str, ...] = (
"name", "dataset", "fill_type", "corner_mask", "n", "total_chunk_count",
)
def setup(
self, name: str, dataset: str, fill_type: FillType, corner_mask: str | bool, n: int,
total_chunk_count: int,
) -> None:
self.set_xyz_and_levels(dataset, n, corner_mask != "no mask")
def time_filled_serial_chunk(
self, name: str, dataset: str, fill_type: FillType, corner_mask: str | bool, n: int,
total_chunk_count: int,
) -> None:
cont_gen = contour_generator(
self.x, self.y, self.z, name=name, fill_type=fill_type,
corner_mask=corner_mask_to_bool(corner_mask), total_chunk_count=total_chunk_count,
)
for i in range(len(self.levels)-1):
cont_gen.filled(self.levels[i], self.levels[i+1])
contourpy-1.2.1/benchmarks/benchmarks/bench_filled_serial_quad_as_tri.py 0000664 0000000 0000000 00000002212 14603035227 0026670 0 ustar 00root root 0000000 0000000 from __future__ import annotations
from contourpy import FillType, contour_generator
from .bench_base import BenchBase
from .util_bench import corner_mask_to_bool, corner_masks, datasets, problem_sizes
class BenchFilledSerialQuadAsTri(BenchBase):
params: tuple[list[str], list[str], list[FillType], list[str | bool], list[int]] = (
["serial"], datasets(), [FillType.OuterCode], corner_masks(), problem_sizes(),
)
param_names: tuple[str, ...] = ("name", "dataset", "fill_type", "corner_mask", "n")
def setup(
self, name: str, dataset: str, fill_type: FillType, corner_mask: str | bool, n: int,
) -> None:
self.set_xyz_and_levels(dataset, n, corner_mask != "no mask")
def time_filled_serial_quad_as_tri(
self, name: str, dataset: str, fill_type: FillType, corner_mask: str | bool, n: int,
) -> None:
cont_gen = contour_generator(
self.x, self.y, self.z, name=name, fill_type=fill_type,
corner_mask=corner_mask_to_bool(corner_mask), quad_as_tri=True,
)
for i in range(len(self.levels)-1):
cont_gen.filled(self.levels[i], self.levels[i+1])
contourpy-1.2.1/benchmarks/benchmarks/bench_filled_serial_quad_as_tri_render.py 0000664 0000000 0000000 00000002605 14603035227 0030235 0 ustar 00root root 0000000 0000000 from __future__ import annotations
from contourpy import FillType, contour_generator
from contourpy.util.mpl_renderer import MplTestRenderer
from .bench_base import BenchBase
from .util_bench import corner_mask_to_bool, corner_masks, datasets, problem_sizes
class BenchFilledSerialQuadAsTriRender(BenchBase):
params: tuple[list[str], list[str], list[FillType], list[str | bool], list[int]] = (
["serial"], datasets(), [FillType.OuterCode], corner_masks(), problem_sizes(),
)
param_names: tuple[str, ...] = ("name", "dataset", "fill_type", "corner_mask", "n")
def setup(
self, name: str, dataset: str, fill_type: FillType, corner_mask: str | bool, n: int,
) -> None:
self.set_xyz_and_levels(dataset, n, corner_mask != "no mask")
def time_filled_serial_quad_as_tri_render(
self, name: str, dataset: str, fill_type: FillType, corner_mask: str | bool, n: int,
) -> None:
cont_gen = contour_generator(
self.x, self.y, self.z, name=name, fill_type=fill_type,
corner_mask=corner_mask_to_bool(corner_mask), quad_as_tri=True,
)
renderer = MplTestRenderer()
for i in range(len(self.levels)-1):
filled = cont_gen.filled(self.levels[i], self.levels[i+1])
renderer.filled(filled, fill_type, color=f"C{i}")
renderer.save(f"filled_{name}_{corner_mask}_{fill_type}_{n}.png")
contourpy-1.2.1/benchmarks/benchmarks/bench_filled_serial_render.py 0000664 0000000 0000000 00000002542 14603035227 0025662 0 ustar 00root root 0000000 0000000 from __future__ import annotations
from contourpy import FillType, contour_generator
from contourpy.util.mpl_renderer import MplTestRenderer
from .bench_base import BenchBase
from .util_bench import corner_mask_to_bool, corner_masks, datasets, fill_types, problem_sizes
class BenchFilledSerialRender(BenchBase):
params: tuple[list[str], list[str], list[FillType], list[str | bool], list[int]] = (
["serial"], datasets(), fill_types(), corner_masks(), problem_sizes(),
)
param_names: tuple[str, ...] = ("name", "dataset", "fill_type", "corner_mask", "n")
def setup(
self, name: str, dataset: str, fill_type: FillType, corner_mask: str | bool, n: int,
) -> None:
self.set_xyz_and_levels(dataset, n, corner_mask != "no mask")
def time_filled_serial_render(
self, name: str, dataset: str, fill_type: FillType, corner_mask: str | bool, n: int,
) -> None:
cont_gen = contour_generator(
self.x, self.y, self.z, name=name, fill_type=fill_type,
corner_mask=corner_mask_to_bool(corner_mask),
)
renderer = MplTestRenderer()
for i in range(len(self.levels)-1):
filled = cont_gen.filled(self.levels[i], self.levels[i+1])
renderer.filled(filled, fill_type, color=f"C{i}")
renderer.save(f"filled_{name}_{corner_mask}_{fill_type}_{n}.png")
contourpy-1.2.1/benchmarks/benchmarks/bench_filled_threaded.py 0000664 0000000 0000000 00000002706 14603035227 0024626 0 ustar 00root root 0000000 0000000 from __future__ import annotations
from contourpy import FillType, contour_generator
from .bench_base import BenchBase
from .util_bench import (
corner_mask_to_bool,
corner_masks,
datasets,
fill_types,
problem_sizes,
thread_counts,
)
class BenchFilledThreaded(BenchBase):
params: tuple[list[str], list[str], list[FillType], list[str | bool], list[int], list[int],
list[int]] = (
["threaded"], datasets(), fill_types(), corner_masks(), problem_sizes(), [40],
thread_counts(),
)
param_names: tuple[str, ...] = (
"name", "dataset", "fill_type", "corner_mask", "n", "total_chunk_count", "thread_count",
)
def setup(
self, name: str, dataset: str, fill_type: FillType, corner_mask: str | bool, n: int,
total_chunk_count: int, thread_count: int,
) -> None:
self.set_xyz_and_levels(dataset, n, corner_mask != "no mask")
def time_filled_threaded(
self, name: str, dataset: str, fill_type: FillType, corner_mask: str | bool, n: int,
total_chunk_count: int, thread_count: int,
) -> None:
cont_gen = contour_generator(
self.x, self.y, self.z, name=name, fill_type=fill_type,
corner_mask=corner_mask_to_bool(corner_mask), total_chunk_count=total_chunk_count,
thread_count=thread_count,
)
for i in range(len(self.levels)-1):
cont_gen.filled(self.levels[i], self.levels[i+1])
contourpy-1.2.1/benchmarks/benchmarks/bench_lines_mpl20xx.py 0000664 0000000 0000000 00000002325 14603035227 0024230 0 ustar 00root root 0000000 0000000 from __future__ import annotations
from contourpy import LineType, contour_generator
from .bench_base import BenchBase
from .util_bench import corner_mask_to_bool, corner_masks, datasets, problem_sizes
class BenchLinesMpl20xx(BenchBase):
params: tuple[list[str], list[str], list[LineType], list[str | bool], list[int]] = (
["mpl2005", "mpl2014"], datasets(), [LineType.SeparateCode], corner_masks(),
problem_sizes(),
)
param_names: tuple[str, ...] = ("name", "dataset", "line_type", "corner_mask", "n")
def setup(
self, name: str, dataset: str, line_type: LineType, corner_mask: str | bool, n: int,
) -> None:
self.set_xyz_and_levels(dataset, n, corner_mask != "no mask")
def time_lines_mpl20xx(
self, name: str, dataset: str, line_type: LineType, corner_mask: str | bool, n: int,
) -> None:
if name == "mpl2005" and corner_mask is True:
raise NotImplementedError # Does not support corner_mask=True
cont_gen = contour_generator(
self.x, self.y, self.z, name=name, line_type=line_type,
corner_mask=corner_mask_to_bool(corner_mask),
)
for level in self.levels:
cont_gen.lines(level)
contourpy-1.2.1/benchmarks/benchmarks/bench_lines_mpl20xx_render.py 0000664 0000000 0000000 00000002732 14603035227 0025571 0 ustar 00root root 0000000 0000000 from __future__ import annotations
from contourpy import LineType, contour_generator
from contourpy.util.mpl_renderer import MplTestRenderer
from .bench_base import BenchBase
from .util_bench import corner_mask_to_bool, corner_masks, datasets, problem_sizes
class BenchLinesMpl20xxRender(BenchBase):
params: tuple[list[str], list[str], list[LineType], list[str | bool], list[int]] = (
["mpl2005", "mpl2014"], datasets(), [LineType.SeparateCode], corner_masks(),
problem_sizes(),
)
param_names: tuple[str, ...] = ("name", "dataset", "line_type", "corner_mask", "n")
def setup(
self, name: str, dataset: str, line_type: LineType, corner_mask: str | bool, n: int,
) -> None:
self.set_xyz_and_levels(dataset, n, corner_mask != "no mask")
def time_lines_mpl20xx_render(
self, name: str, dataset: str, line_type: LineType, corner_mask: str | bool, n: int,
) -> None:
if name == "mpl2005" and corner_mask is True:
raise NotImplementedError # Does not support corner_mask=True
cont_gen = contour_generator(
self.x, self.y, self.z, name=name, line_type=line_type,
corner_mask=corner_mask_to_bool(corner_mask),
)
renderer = MplTestRenderer()
for i, level in enumerate(self.levels):
lines = cont_gen.lines(level)
renderer.lines(lines, line_type, color=f"C{i}")
renderer.save(f"lines_{name}_{corner_mask}_{line_type}_{n}.png")
contourpy-1.2.1/benchmarks/benchmarks/bench_lines_serial.py 0000664 0000000 0000000 00000002077 14603035227 0024201 0 ustar 00root root 0000000 0000000 from __future__ import annotations
from contourpy import LineType, contour_generator
from .bench_base import BenchBase
from .util_bench import corner_mask_to_bool, corner_masks, datasets, line_types, problem_sizes
class BenchLinesSerial(BenchBase):
params: tuple[list[str], list[str], list[LineType], list[str | bool], list[int]] = (
["serial"], datasets(), line_types(), corner_masks(), problem_sizes(),
)
param_names: tuple[str, ...] = ("name", "dataset", "line_type", "corner_mask", "n")
def setup(
self, name: str, dataset: str, line_type: LineType, corner_mask: str | bool, n: int,
) -> None:
self.set_xyz_and_levels(dataset, n, corner_mask != "no mask")
def time_lines_serial(
self, name: str, dataset: str, line_type: LineType, corner_mask: str | bool, n: int,
) -> None:
cont_gen = contour_generator(
self.x, self.y, self.z, name=name, line_type=line_type,
corner_mask=corner_mask_to_bool(corner_mask),
)
for level in self.levels:
cont_gen.lines(level)
contourpy-1.2.1/benchmarks/benchmarks/bench_lines_serial_chunk.py 0000664 0000000 0000000 00000002360 14603035227 0025364 0 ustar 00root root 0000000 0000000 from __future__ import annotations
from contourpy import LineType, contour_generator
from .bench_base import BenchBase
from .util_bench import corner_mask_to_bool, corner_masks, datasets, line_types, total_chunk_counts
class BenchLinesSerialChunk(BenchBase):
params: tuple[list[str], list[str], list[LineType], list[str | bool], list[int], list[int]] = (
["serial"], datasets(), line_types(), corner_masks(), [1000], total_chunk_counts(),
)
param_names: tuple[str, ...] = (
"name", "dataset", "line_type", "corner_mask", "n", "total_chunk_count",
)
def setup(
self, name: str, dataset: str, line_type: LineType, corner_mask: str | bool, n: int,
total_chunk_count: int,
) -> None:
self.set_xyz_and_levels(dataset, n, corner_mask != "no mask")
def time_lines_serial_chunk(
self, name: str, dataset: str, line_type: LineType, corner_mask: str | bool, n: int,
total_chunk_count: int,
) -> None:
cont_gen = contour_generator(
self.x, self.y, self.z, name=name, line_type=line_type,
corner_mask=corner_mask_to_bool(corner_mask), total_chunk_count=total_chunk_count,
)
for level in self.levels:
cont_gen.lines(level)
contourpy-1.2.1/benchmarks/benchmarks/bench_lines_serial_quad_as_tri.py 0000664 0000000 0000000 00000002145 14603035227 0026550 0 ustar 00root root 0000000 0000000 from __future__ import annotations
from contourpy import LineType, contour_generator
from .bench_base import BenchBase
from .util_bench import corner_mask_to_bool, corner_masks, datasets, problem_sizes
class BenchLinesSerialQuadAsTri(BenchBase):
params: tuple[list[str], list[str], list[LineType], list[str | bool], list[int]] = (
["serial"], datasets(), [LineType.SeparateCode], corner_masks(), problem_sizes(),
)
param_names: tuple[str, ...] = ("name", "dataset", "line_type", "corner_mask", "n")
def setup(
self, name: str, dataset: str, line_type: LineType, corner_mask: str | bool, n: int,
) -> None:
self.set_xyz_and_levels(dataset, n, corner_mask != "no mask")
def time_lines_serial_quad_as_tri(
self, name: str, dataset: str, line_type: LineType, corner_mask: str | bool, n: int,
) -> None:
cont_gen = contour_generator(
self.x, self.y, self.z, name=name, line_type=line_type,
corner_mask=corner_mask_to_bool(corner_mask), quad_as_tri=True,
)
for level in self.levels:
cont_gen.lines(level)
contourpy-1.2.1/benchmarks/benchmarks/bench_lines_serial_quad_as_tri_render.py 0000664 0000000 0000000 00000002557 14603035227 0030116 0 ustar 00root root 0000000 0000000 from __future__ import annotations
from contourpy import LineType, contour_generator
from contourpy.util.mpl_renderer import MplTestRenderer
from .bench_base import BenchBase
from .util_bench import corner_mask_to_bool, corner_masks, datasets, problem_sizes
class BenchLinesSerialQuadAsTriRender(BenchBase):
params: tuple[list[str], list[str], list[LineType], list[str | bool], list[int]] = (
["serial"], datasets(), [LineType.SeparateCode], corner_masks(), problem_sizes(),
)
param_names: tuple[str, ...] = ("name", "dataset", "line_type", "corner_mask", "n")
def setup(
self, name: str, dataset: str, line_type: LineType, corner_mask: str | bool, n: int,
) -> None:
self.set_xyz_and_levels(dataset, n, corner_mask != "no mask")
def time_lines_serial_quad_as_tri_render(
self, name: str, dataset: str, line_type: LineType, corner_mask: str | bool, n: int,
) -> None:
cont_gen = contour_generator(
self.x, self.y, self.z, name=name, line_type=line_type,
corner_mask=corner_mask_to_bool(corner_mask), quad_as_tri=True,
)
renderer = MplTestRenderer()
for i, level in enumerate(self.levels):
lines = cont_gen.lines(level)
renderer.lines(lines, line_type, color=f"C{i}")
renderer.save(f"lines_{name}_{corner_mask}_{line_type}_{n}_True.png")
contourpy-1.2.1/benchmarks/benchmarks/bench_lines_serial_render.py 0000664 0000000 0000000 00000002504 14603035227 0025533 0 ustar 00root root 0000000 0000000 from __future__ import annotations
from contourpy import LineType, contour_generator
from contourpy.util.mpl_renderer import MplTestRenderer
from .bench_base import BenchBase
from .util_bench import corner_mask_to_bool, corner_masks, datasets, line_types, problem_sizes
class BenchLinesSerialRender(BenchBase):
params: tuple[list[str], list[str], list[LineType], list[str | bool], list[int]] = (
["serial"], datasets(), line_types(), corner_masks(), problem_sizes(),
)
param_names: tuple[str, ...] = ("name", "dataset", "line_type", "corner_mask", "n")
def setup(
self, name: str, dataset: str, line_type: LineType, corner_mask: str | bool, n: int,
) -> None:
self.set_xyz_and_levels(dataset, n, corner_mask != "no mask")
def time_lines_serial_render(
self, name: str, dataset: str, line_type: LineType, corner_mask: str | bool, n: int,
) -> None:
cont_gen = contour_generator(
self.x, self.y, self.z, name=name, line_type=line_type,
corner_mask=corner_mask_to_bool(corner_mask),
)
renderer = MplTestRenderer()
for i, level in enumerate(self.levels):
lines = cont_gen.lines(level)
renderer.lines(lines, line_type, color=f"C{i}")
renderer.save(f"lines_{name}_{corner_mask}_{line_type}_{n}.png")
contourpy-1.2.1/benchmarks/benchmarks/bench_lines_threaded.py 0000664 0000000 0000000 00000002636 14603035227 0024503 0 ustar 00root root 0000000 0000000 from __future__ import annotations
from contourpy import LineType, contour_generator
from .bench_base import BenchBase
from .util_bench import (
corner_mask_to_bool,
corner_masks,
datasets,
line_types,
problem_sizes,
thread_counts,
)
class BenchLinesThreaded(BenchBase):
params: tuple[list[str], list[str], list[LineType], list[str | bool], list[int], list[int],
list[int]] = (
["threaded"], datasets(), line_types(), corner_masks(), problem_sizes(), [40],
thread_counts(),
)
param_names: tuple[str, ...] = (
"name", "dataset", "line_type", "corner_mask", "n", "total_chunk_count", "thread_count",
)
def setup(
self, name: str, dataset: str, line_type: LineType, corner_mask: str | bool, n: int,
total_chunk_count: int, thread_count: int,
) -> None:
self.set_xyz_and_levels(dataset, n, corner_mask != "no mask")
def time_lines_threaded(
self, name: str, dataset: str, line_type: LineType, corner_mask: str | bool, n: int,
total_chunk_count: int, thread_count: int,
) -> None:
cont_gen = contour_generator(
self.x, self.y, self.z, name=name, line_type=line_type,
corner_mask=corner_mask_to_bool(corner_mask), total_chunk_count=total_chunk_count,
thread_count=thread_count,
)
for level in self.levels:
cont_gen.lines(level)
contourpy-1.2.1/benchmarks/benchmarks/util_bench.py 0000664 0000000 0000000 00000001517 14603035227 0022503 0 ustar 00root root 0000000 0000000 from __future__ import annotations
from contourpy import FillType, LineType, max_threads
def corner_mask_to_bool(corner_mask: str | bool) -> bool:
if isinstance(corner_mask, bool):
return corner_mask
else:
return False
def corner_masks() -> list[str | bool]:
return ["no mask", False, True]
def datasets() -> list[str]:
return ["simple", "random"]
def fill_types() -> list[FillType]:
return list(FillType.__members__.values())
def line_types() -> list[LineType]:
return list(LineType.__members__.values())
def problem_sizes() -> list[int]:
return [10, 30, 100, 300, 1000]
def thread_counts() -> list[int]:
thread_counts = [1, 2, 4, 6, 8]
return list(filter(lambda n: n <= max(max_threads(), 1), thread_counts))
def total_chunk_counts() -> list[int]:
return [4, 12, 40, 120]
contourpy-1.2.1/benchmarks/loader.py 0000664 0000000 0000000 00000006633 14603035227 0017524 0 ustar 00root root 0000000 0000000 from __future__ import annotations
from copy import deepcopy
from datetime import datetime
from typing import TYPE_CHECKING, Any
from asv.benchmarks import Benchmarks
from asv.config import Config
from asv.results import Results, iter_results_for_machine
from asv.statistics import get_err
from contourpy import FillType, LineType
if TYPE_CHECKING:
from asv.benchmark import Benchmark
class Loader:
_config: Config
_benchmarks: Benchmarks
_machine: str
_results: Results
def __init__(self, machine: str | None = None) -> None:
self._config = Config.load()
self._benchmarks = Benchmarks.load(self._config)
if machine is None:
import platform
machine = platform.uname()[1]
latest_results = None
for results in iter_results_for_machine(self._config.results_dir, machine):
if latest_results is None or results.date > latest_results.date:
latest_results = results
if latest_results is None:
raise RuntimeError(f"No results found for machine {machine}")
print(latest_results.commit_hash, datetime.fromtimestamp(latest_results.date/1000.0))
self._results = latest_results
self._machine = machine
def _find_benchmark_by_name(self, name: str) -> Benchmark:
for k, v in self._benchmarks.items():
if k.endswith(name):
return v
raise RuntimeError(f"Cannot find benchmark with name {name}")
@property
def commit(self) -> str:
return self._results.commit_hash # type: ignore[no-any-return]
def get(self, benchmark_name: str, **kwargs: Any) -> dict[str, Any]:
benchmark = self._find_benchmark_by_name(benchmark_name)
param_names = benchmark["param_names"]
params = deepcopy(benchmark["params"])
for name, value in kwargs.items():
index = param_names.index(name)
if isinstance(value, list):
params[index] = [repr(item) for item in value]
else:
params[index] = [repr(value)]
stats = self._results.get_result_stats(benchmark["name"], params)
values = self._results.get_result_value(benchmark["name"], params)
ret = {}
for name, param in zip(param_names, params):
for i, item in enumerate(param):
if isinstance(item, str):
if item[0] == "'" and item[-1] == "'":
item = item[1:-1]
if item.startswith("<{#;J \Q+r4LUAYmrܧ:?01\i7/ &M1j&/:eW7NOrH\$ rF5_ޟ?#Bt;oW &%Q붺Z772d0j;ٶ 9w
l=XǺ[%ҫЄԕLH.^/ Bh]p$ibALލN O\ zO_]"'!ɥ:p yCٳ@R\ |sH(DrY
Lt:駨ɵrJ4F9 bXik jw-0 D-[bNc Ih];Ѱo;o{z_=g466*[ξxv{8a6_[?w89s0 ճ5_aVh3{ 6yPre y'ax >ug IV|&]T[xe0Gncc# ~aLӱn^~jxů.6(YV nܨf'9t TAnjj&fF\.6lP2Lcf6͛7'=} \./_{ڵt9t~w*Ju8G~ acq S|mw1:tugϸˀ3AD4 IèyM4pI]%0zxߓj{+Pw6,;3b >*+G}DwmI6|cϖcZ^( ~g7'ӐvG< Q3_]D0$ǐI9'jw Y `=
$]( ]gZXu7+])MkRI[n{yzc/C*=1{瞝tl@msrpSj*/ffƥ;[Z&WUaUe^q :o>T.wc5 ĉċ\iqS`0;)cׅx:rRT7yd IiMxJ=Gņ( |KwWNzi$&&VԹH:ri.Tt28]wyrTzʲ̰xgd' 9kw@eUܯ.wmg 1z%R"o?[iUwmet] nZ̪.q| |]f;<{MonZR.#s&=