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) |
| Downloads | [](https://pepy.tech/project/contourpy) |
| Python version | [](https://pypi.org/project/contourpy/) |
| Coverage | [](https://app.codecov.io/gh/contourpy/contourpy) |
contourpy-1.3.1/benchmarks/ 0000775 0000000 0000000 00000000000 14714612665 0015707 5 ustar 00root root 0000000 0000000 contourpy-1.3.1/benchmarks/README.md 0000664 0000000 0000000 00000002465 14714612665 0017175 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.6.2"
```
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.3.1/benchmarks/asv.conf.json 0000664 0000000 0000000 00000001226 14714612665 0020320 0 ustar 00root root 0000000 0000000 {
"version": 1,
"project": "contourpy",
"project_url": "http://github.com/contourpy/contourpy",
"repo": "..",
"build_command": [
"python -m pip install --upgrade build pip",
"python -m build --wheel -o {build_cache_dir} {build_dir}"
],
"branches": ["main"],
"dvcs": "git",
"environment_type": "virtualenv",
"show_commit_url": "http://github.com/contourpy/contourpy/commit/",
"matrix": {
"req": {
"matplotlib": [],
"numpy": []
}
},
"benchmark_dir": "benchmarks",
"env_dir": ".asv/env",
"results_dir": ".asv/results",
"html_dir": ".asv/html"
}
contourpy-1.3.1/benchmarks/benchmarks/ 0000775 0000000 0000000 00000000000 14714612665 0020024 5 ustar 00root root 0000000 0000000 contourpy-1.3.1/benchmarks/benchmarks/__init__.py 0000664 0000000 0000000 00000000000 14714612665 0022123 0 ustar 00root root 0000000 0000000 contourpy-1.3.1/benchmarks/benchmarks/bench_base.py 0000664 0000000 0000000 00000001717 14714612665 0022455 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.3.1/benchmarks/benchmarks/bench_filled_mpl20xx.py 0000664 0000000 0000000 00000002376 14714612665 0024376 0 ustar 00root root 0000000 0000000 from __future__ import annotations
from asv_runner.benchmarks.mark import SkipNotImplemented
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:
if name == "mpl2005" and corner_mask is True:
raise SkipNotImplemented(f"{name} does not support corner_mask={corner_mask}")
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:
cont_gen = contour_generator(
self.x, self.y, self.z, name=name, fill_type=fill_type,
corner_mask=corner_mask_to_bool(corner_mask),
)
cont_gen.multi_filled(self.levels)
contourpy-1.3.1/benchmarks/benchmarks/bench_filled_mpl20xx_render.py 0000664 0000000 0000000 00000002724 14714612665 0025732 0 ustar 00root root 0000000 0000000 from __future__ import annotations
from asv_runner.benchmarks.mark import SkipNotImplemented
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:
if name == "mpl2005" and corner_mask is True:
raise SkipNotImplemented(f"{name} does not support corner_mask={corner_mask}")
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:
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()
renderer.multi_filled(cont_gen.multi_filled(self.levels), fill_type)
renderer.save(f"filled_{name}_{corner_mask}_{fill_type}_{n}.png")
contourpy-1.3.1/benchmarks/benchmarks/bench_filled_serial.py 0000664 0000000 0000000 00000002050 14714612665 0024330 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),
)
cont_gen.multi_filled(self.levels)
contourpy-1.3.1/benchmarks/benchmarks/bench_filled_serial_chunk.py 0000664 0000000 0000000 00000002331 14714612665 0025522 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,
)
cont_gen.multi_filled(self.levels)
contourpy-1.3.1/benchmarks/benchmarks/bench_filled_serial_quad_as_tri.py 0000664 0000000 0000000 00000002113 14714612665 0026703 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,
)
cont_gen.multi_filled(self.levels)
contourpy-1.3.1/benchmarks/benchmarks/bench_filled_serial_quad_as_tri_render.py 0000664 0000000 0000000 00000002441 14714612665 0030246 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()
renderer.multi_filled(cont_gen.multi_filled(self.levels), fill_type)
renderer.save(f"filled_{name}_{corner_mask}_{fill_type}_{n}.png")
contourpy-1.3.1/benchmarks/benchmarks/bench_filled_serial_render.py 0000664 0000000 0000000 00000002376 14714612665 0025702 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()
renderer.multi_filled(cont_gen.multi_filled(self.levels), fill_type)
renderer.save(f"filled_{name}_{corner_mask}_{fill_type}_{n}.png")
contourpy-1.3.1/benchmarks/benchmarks/bench_filled_threaded.py 0000664 0000000 0000000 00000002607 14714612665 0024641 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,
)
cont_gen.multi_filled(self.levels)
contourpy-1.3.1/benchmarks/benchmarks/bench_lines_mpl20xx.py 0000664 0000000 0000000 00000002406 14714612665 0024243 0 ustar 00root root 0000000 0000000 from __future__ import annotations
from asv_runner.benchmarks.mark import SkipNotImplemented
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:
if name == "mpl2005" and corner_mask is True:
raise SkipNotImplemented(f"{name} does not support corner_mask={corner_mask}")
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:
cont_gen = contour_generator(
self.x, self.y, self.z, name=name, line_type=line_type,
corner_mask=corner_mask_to_bool(corner_mask),
)
cont_gen.multi_lines(self.levels)
contourpy-1.3.1/benchmarks/benchmarks/bench_lines_mpl20xx_render.py 0000664 0000000 0000000 00000002732 14714612665 0025604 0 ustar 00root root 0000000 0000000 from __future__ import annotations
from asv_runner.benchmarks.mark import SkipNotImplemented
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:
if name == "mpl2005" and corner_mask is True:
raise SkipNotImplemented(f"{name} does not support corner_mask={corner_mask}")
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:
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()
renderer.multi_lines(cont_gen.multi_lines(self.levels), line_type)
renderer.save(f"lines_{name}_{corner_mask}_{line_type}_{n}.png")
contourpy-1.3.1/benchmarks/benchmarks/bench_lines_serial.py 0000664 0000000 0000000 00000002045 14714612665 0024207 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),
)
cont_gen.multi_lines(self.levels)
contourpy-1.3.1/benchmarks/benchmarks/bench_lines_serial_chunk.py 0000664 0000000 0000000 00000002326 14714612665 0025401 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,
)
cont_gen.multi_lines(self.levels)
contourpy-1.3.1/benchmarks/benchmarks/bench_lines_serial_quad_as_tri.py 0000664 0000000 0000000 00000002113 14714612665 0026556 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,
)
cont_gen.multi_lines(self.levels)
contourpy-1.3.1/benchmarks/benchmarks/bench_lines_serial_quad_as_tri_render.py 0000664 0000000 0000000 00000002444 14714612665 0030124 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()
renderer.multi_lines(cont_gen.multi_lines(self.levels), line_type)
renderer.save(f"lines_{name}_{corner_mask}_{line_type}_{n}_True.png")
contourpy-1.3.1/benchmarks/benchmarks/bench_lines_serial_render.py 0000664 0000000 0000000 00000002371 14714612665 0025550 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()
renderer.multi_lines(cont_gen.multi_lines(self.levels), line_type)
renderer.save(f"lines_{name}_{corner_mask}_{line_type}_{n}.png")
contourpy-1.3.1/benchmarks/benchmarks/bench_lines_threaded.py 0000664 0000000 0000000 00000002604 14714612665 0024511 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,
)
cont_gen.multi_lines(self.levels)
contourpy-1.3.1/benchmarks/benchmarks/util_bench.py 0000664 0000000 0000000 00000001517 14714612665 0022516 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.3.1/benchmarks/loader.py 0000664 0000000 0000000 00000006714 14714612665 0017537 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_runner.statistics import get_err
import numpy as np
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&=