commit 9194ef5abd9bac928c0c3ee8573568fde61f09cf Author: wehub-resource-sync Date: Mon Jul 13 12:06:10 2026 +0800 chore: import upstream snapshot with attribution diff --git a/.codecov.yml b/.codecov.yml new file mode 100644 index 0000000..ba63985 --- /dev/null +++ b/.codecov.yml @@ -0,0 +1,41 @@ +# see https://docs.codecov.io/docs/codecov-yaml +# Validation check: +# $ curl --data-binary @.codecov.yml https://codecov.io/validate + +# https://docs.codecov.io/docs/codecovyml-reference +codecov: + bot: "codecov-io" + strict_yaml_branch: "yaml-config" + require_ci_to_pass: yes + notify: + # after_n_builds: 2 + wait_for_ci: yes + +coverage: + precision: 0 # 2 = xx.xx%, 0 = xx% + round: nearest # how coverage is rounded: down/up/nearest + range: 40...100 # custom range of coverage colors from red -> yellow -> green + status: + project: + default: + informational: true + target: 95% # specify the target coverage for each commit status + threshold: 10% # allow this little decrease on project + # branches: master + if_ci_failed: error + patch: + default: + informational: true + target: 95% # enforce same coverage target for new/changed code as the project + threshold: 10% # allow only a small decrease on patch coverage + changes: false + +# https://docs.codecov.com/docs/github-checks#disabling-github-checks-patch-annotations +github_checks: + annotations: false + +comment: + layout: header, diff + require_changes: false + behavior: default # update if exists else create new + # branches: * diff --git a/.gitattributes b/.gitattributes new file mode 100644 index 0000000..5be91f9 --- /dev/null +++ b/.gitattributes @@ -0,0 +1 @@ +*.ipynb linguist-vendored diff --git a/.github/CODEOWNERS b/.github/CODEOWNERS new file mode 100644 index 0000000..0201028 --- /dev/null +++ b/.github/CODEOWNERS @@ -0,0 +1,4 @@ +# These owners will be the default owners for everything in +# the repo. They will be requested for review when someone +# opens a pull request. +* @SkalskiP @soumik12345 diff --git a/.github/CODE_OF_CONDUCT.md b/.github/CODE_OF_CONDUCT.md new file mode 100644 index 0000000..9782ed9 --- /dev/null +++ b/.github/CODE_OF_CONDUCT.md @@ -0,0 +1,85 @@ +# Contributor Covenant Code of Conduct + +## Our Pledge + +We as members, contributors, and leaders pledge to make participation in our community a harassment-free experience for everyone, regardless of age, body size, visible or invisible disability, ethnicity, sex characteristics, gender identity and expression, level of experience, education, socioeconomic status, nationality, personal appearance, race, caste, color, religion, or sexual identity and orientation. + +We pledge to act and interact in ways that contribute to an open, welcoming, diverse, inclusive, and healthy community. + +## Our Standards + +Examples of behavior that contributes to a positive environment for our community include: + +- Demonstrating empathy and kindness toward other people +- Being respectful of differing opinions, viewpoints, and experiences +- Giving and gracefully accepting constructive feedback +- Accepting responsibility and apologizing to those affected by our mistakes, and learning from the experience +- Focusing on what is best not just for us as individuals, but for the overall community + +Examples of unacceptable behavior include: + +- The use of sexualized language or imagery, and sexual attention or advances of any kind +- Trolling, insulting or derogatory comments, and personal or political attacks +- Public or private harassment +- Publishing others' private information, such as a physical or email address, without their explicit permission +- Other conduct which could reasonably be considered inappropriate in a professional setting + +## Enforcement Responsibilities + +Community leaders are responsible for clarifying and enforcing our standards of acceptable behavior and will take appropriate and fair corrective action in response to any behavior that they deem inappropriate, threatening, offensive, or harmful. + +Community leaders have the right and responsibility to remove, edit, or reject comments, commits, code, wiki edits, issues, and other contributions that are not aligned to this Code of Conduct, and will communicate reasons for moderation decisions when appropriate. + +## Scope + +This Code of Conduct applies within all community spaces, and also applies when an individual is officially representing the community in public spaces. Examples of representing our community include using an official e-mail address, posting via an official social media account, or acting as an appointed representative at an online or offline event. + +## Enforcement + +Instances of abusive, harassing, or otherwise unacceptable behavior may be reported to the community leaders responsible for enforcement at community-reports@roboflow.com. + +All complaints will be reviewed and investigated promptly and fairly. + +All community leaders are obligated to respect the privacy and security of the reporter of any incident. + +## Enforcement Guidelines + +Community leaders will follow these Community Impact Guidelines in determining the consequences for any action they deem in violation of this Code of Conduct: + +### 1. Correction + +**Community Impact**: Use of inappropriate language or other behavior deemed unprofessional or unwelcome in the community. + +**Consequence**: A private, written warning from community leaders, providing clarity around the nature of the violation and an explanation of why the behavior was inappropriate. A public apology may be requested. + +### 2. Warning + +**Community Impact**: A violation through a single incident or series of actions. + +**Consequence**: A warning with consequences for continued behavior. No interaction with the people involved, including unsolicited interaction with those enforcing the Code of Conduct, for a specified period of time. This includes avoiding interactions in community spaces as well as external channels like social media. Violating these terms may lead to a temporary or permanent ban. + +### 3. Temporary Ban + +**Community Impact**: A serious violation of community standards, including sustained inappropriate behavior. + +**Consequence**: A temporary ban from any sort of interaction or public communication with the community for a specified period of time. No public or private interaction with the people involved, including unsolicited interaction with those enforcing the Code of Conduct, is allowed during this period. Violating these terms may lead to a permanent ban. + +### 4. Permanent Ban + +**Community Impact**: Demonstrating a pattern of violation of community standards, including sustained inappropriate behavior, harassment of an individual, or aggression toward or disparagement of classes of individuals. + +**Consequence**: A permanent ban from any sort of public interaction within the community. + +## Attribution + +This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 2.1, available at [https://www.contributor-covenant.org/version/2/1/code_of_conduct.html][v2.1]. + +Community Impact Guidelines were inspired by [Mozilla's code of conduct enforcement ladder][mozilla coc]. + +For answers to common questions about this code of conduct, see the FAQ at [https://www.contributor-covenant.org/faq][faq]. Translations are available at [https://www.contributor-covenant.org/translations][translations]. + +[faq]: https://www.contributor-covenant.org/faq +[homepage]: https://www.contributor-covenant.org +[mozilla coc]: https://github.com/mozilla/diversity +[translations]: https://www.contributor-covenant.org/translations +[v2.1]: https://www.contributor-covenant.org/version/2/1/code_of_conduct.html diff --git a/.github/CONTRIBUTING.md b/.github/CONTRIBUTING.md new file mode 100644 index 0000000..02412d5 --- /dev/null +++ b/.github/CONTRIBUTING.md @@ -0,0 +1,506 @@ +# Contributing to Supervision ๐Ÿ› ๏ธ + +Thank you for your interest in contributing to Supervision! + +We are actively improving this library to reduce the amount of work you need to do to solve common computer vision problems. + +## Code of Conduct + +Please read and adhere to our [Code of Conduct](https://supervision.roboflow.com/latest/code_of_conduct/). This document outlines the expected behavior for all participants in our project. + +## Table of Contents + +- [Contribution Guidelines](#contribution-guidelines) + - [Contributing Features](#contributing-features) + - [API Design Principles](#api-design-principles) +- [How to Contribute Changes](#how-to-contribute-changes) +- [Installation for Contributors](#installation-for-contributors) +- [Code Style and Quality](#code-style-and-quality) + - [Pre-commit tool](#pre-commit-tool) + - [Docstrings](#docstrings) + - [Type checking](#type-checking) +- [Documentation](#documentation) +- [Cookbooks](#cookbooks) +- [Tests](#tests) +- [License](#license) + +## Contribution Guidelines + +We welcome contributions to: + +1. Add a new feature to the library (guidance below). +2. Improve our documentation and add examples to make it clear how to leverage the supervision library. +3. Report bugs and issues in the project. +4. Submit a request for a new feature. +5. Improve our test coverage. + +### Contributing Features โœจ + +Supervision is designed to provide generic utilities to solve problems. Thus, we focus on contributions that can have an impact on a wide range of projects. + +For example, counting objects that cross a line anywhere on an image is a common problem in computer vision, but counting objects that cross a line 75% of the way through is less useful. + +Before you contribute a new feature, consider submitting an Issue to discuss the feature so the community can weigh in and assist. + +### API Design Principles + +Supervision APIs should remain generic, composable, and predictable across model families. Before adding a new integration, annotator option, or data conversion method, check the existing `sv.Detections`, `sv.KeyPoints`, and annotator patterns and follow these principles: + +1. **Model integrations normalize raw external outputs into existing Supervision containers.** Use `sv.Detections` for detection, segmentation, and other instance-level predictions that include boxes, masks, class ids, confidence scores, or extra per-instance fields. Use `sv.KeyPoints` for standalone keypoint or pose predictions when keypoints exist independently of detection boxes (e.g. pure pose estimation, landmark detection on pre-cropped images). Use `Detections.keypoints` when keypoints are always co-incident with boxes from the same model โ€” the field stores an `(n, K, 2)` or `(n, K, 3)` array where the optional third channel is per-point confidence in `[0, 1]`. +2. **Do not add a `from_` method when the model already returns a Supervision object.** `from_*` methods are for converting raw outputs from external packages such as Ultralytics, Transformers, Inference, or MediaPipe. If a model's `predict()` method already returns `sv.Detections`, keep that result type and store additional structured payloads in `detections.data` or `detections.metadata` using documented keys. +3. **Annotators render data; filtering and visibility are container state.** Filtering by confidence, class id, tracker id, geometry, or custom data should happen before annotation through the container slicing APIs, for example `detections[detections.confidence > 0.7]` or `key_points[key_points.confidence > 0.5]`. Per-point presentation state, such as a `KeyPoints.visible` mask, may live on the container and be honored consistently by annotators. +4. **Annotator constructor arguments should describe visual presentation, not model-quality gates.** Use constructor arguments for color, thickness, opacity, text, position, style, and generic visualization parameters such as sigma levels. Annotators may skip invalid geometry defensively, including missing points, zero-area boxes, non-finite coordinates, or points marked invisible on the container. They should not introduce confidence thresholds or model-specific quality gates as rendering options. + +## How to Contribute Changes + +First, fork this repository to your own GitHub account. Click "fork" in the top corner of the `supervision` repository to get started: + +![Forking the repository](https://media.roboflow.com/fork.png) + +![Creating a repository fork](https://media.roboflow.com/create_fork.png) + +Then, run `git clone` to download the project code to your computer. + +You should also set up `roboflow/supervision` as an "upstream" remote (that is, tell git that the reference Supervision repository was the source of your fork of it): + +```bash +git remote add upstream https://github.com/roboflow/supervision.git +git fetch upstream +``` + +Move to a new branch using the `git checkout` command: + +```bash +git checkout -b / upstream/develop +``` + +The name you choose for your branch should describe the change you want to make and start with an appropriate prefix: + +- `feat/`: for new features (e.g., `feat/line-counter`) +- `fix/`: for bug fixes (e.g., `fix/memory-leak`) +- `docs/`: for documentation changes (e.g., `docs/update-readme`) +- `chore/`: for routine tasks, maintenance, or tooling changes (e.g., `chore/update-dependencies`) +- `test/`: for adding or modifying tests (e.g., `test/add-unit-tests`) +- `refactor/`: for code refactoring (e.g., `refactor/simplify-algorithm`) + +Make any changes you want to the project code, then run the following commands to commit your changes: + +```bash +git add -A +git commit -m "feat: add line counter functionality" +git push -u origin +``` + +Use conventional commit messages to clearly describe your changes. The format is: + +``` +[optional scope]: +``` + +Common types include: + +- `feat`: A new feature +- `fix`: A bug fix +- `docs`: Documentation only changes +- `style`: Changes that do not affect the meaning of the code (white-space, formatting, etc) +- `refactor`: A code change that neither fixes a bug nor adds a feature +- `perf`: A code change that improves performance +- `test`: Adding missing tests or correcting existing tests +- `chore`: Changes to the build process or auxiliary tools and libraries + +Then, go back to your fork of the `supervision` repository, click "Pull Requests", and click "New Pull Request". + +![Opening a pull request](https://media.roboflow.com/open_pr.png) + +Make sure the `base` branch is `develop` before submitting your PR. + +On the next page, review your changes then click "Create pull request": + +![Configuring a pull request](https://media.roboflow.com/create_pr_submit.png) + +Next, write a description for your pull request, and click "Create pull request" again to submit it for review: + +![Submitting a pull request](https://media.roboflow.com/write_pr.png) + +When creating new functions, please ensure you have the following: + +1. Docstrings for the function and all parameters. +2. Unit tests for the function. +3. Examples in the documentation for the function. +4. Created an entry in our docs to autogenerate the documentation for the function. +5. Please share a Google Colab with minimal code to test a new feature or reproduce the issue whenever possible. Please ensure that Google Colab can be accessed without any restrictions. + +When you submit your Pull Request, you will be asked to sign a Contributor License Agreement (CLA) by the `cla-assistant` GitHub bot. We can only respond to PRs from contributors who have signed the project CLA. + +All pull requests will be reviewed by the maintainers of the project. We will provide feedback and ask for changes if necessary. + +PRs must pass all tests and linting requirements before they can be merged. + +## Installation for Contributors + +Before starting your work on the project, set up your development environment: + +1. **Clone your fork of the project:** + + **Option A: Recommended for most contributors (shallow clone of develop branch):** + + ```bash + git clone --depth 1 -b develop https://github.com/YOUR_USERNAME/supervision.git + cd supervision + ``` + + Replace `YOUR_USERNAME` with your GitHub username. + + > **Note**: Using `--depth 1` creates a shallow clone with minimal history and `-b develop` ensures you start with the development branch. This significantly reduces download size while providing everything needed to contribute. + + **Option B: Full repository clone (if you need complete history):** + + ```bash + git clone https://github.com/YOUR_USERNAME/supervision.git + cd supervision + git checkout develop + ``` + +2. **Set up the upstream remote:** + + ```bash + git remote add upstream https://github.com/roboflow/supervision.git + git fetch upstream + ``` + +3. **Create and activate a virtual environment:** + + **On Linux/macOS:** + + ```bash + python3 -m venv .venv + source .venv/bin/activate + ``` + + **On Windows:** + + ```cmd + python -m venv .venv + .venv\Scripts\activate + ``` + +4. **Install `uv`:** + + Follow the instructions on the [uv installation page](https://docs.astral.sh/uv/getting-started/installation/). + +5. **Install project dependencies:** + + ```bash + uv pip install -r pyproject.toml --group dev --group docs --extra metrics + ``` + +6. **Verify the setup:** + + ```bash + uv run pytest + ``` + +## ๐ŸŽจ Code Style and Quality + +### Pre-commit tool + +This project uses the [pre-commit](https://pre-commit.com/) tool to maintain code quality and consistency. Before submitting a pull request or making any commits, it is important to run the pre-commit tool to ensure that your changes meet the project's guidelines. + +Furthermore, we have integrated a pre-commit GitHub Action into our workflow. This means that with every pull request opened, the pre-commit checks will be automatically enforced, streamlining the code review process and ensuring that all contributions adhere to our quality standards. + +To run the pre-commit tool, follow these steps: + +1. **Install pre-commit** (already included if you followed the installation steps above): + + ```bash + uv sync --group dev + ``` + +2. **Navigate to the project's root directory** (if not already there). + +3. **Run pre-commit checks**: + + ```bash + uv run pre-commit run --all-files + ``` + + This will execute the pre-commit hooks configured for this project. If any issues are found, the pre-commit tool will provide feedback on how to resolve them. Make the necessary changes and re-run the command until all issues are resolved. + +4. **Install pre-commit as a git hook** (optional but recommended): + + ```bash + uv run pre-commit install + ``` + + This will automatically run pre-commit checks every time you make a `git commit`. + +### Docstrings + +All new functions and classes in `supervision` should include docstrings. This is a prerequisite for any new functions and classes to be added to the library. + +`supervision` adheres to the [Google Python docstring style](https://google.github.io/styleguide/pyguide.html#383-functions-and-methods). Please refer to the style guide while writing docstrings for your contribution. + +Every docstring should include a usage example. When the example only uses `supervision`, NumPy, and the standard library โ€” no optional extras, no external files or network access โ€” strongly prefer `>>>` doctest format so it is automatically verified by the test suite. See [Doctests](#doctests) below for syntax guidance and for when fenced ```` ```python ```` blocks are appropriate instead. + +### Type checking + +Type hints are required on all new code. mypy is enforced by the pre-commit hook configured in `.pre-commit-config.yaml` โ€” your PR will fail CI if mypy reports errors. + +### Readability + +Avoid multi-branch conditional expressions inside function or constructor arguments. If an argument needs more than a simple `a if condition else b`, assign it to a named local variable before the call. + +### Performance + +- Avoid unnecessary copies of NumPy arrays. +- Prefer vectorized operations over Python loops in hot paths. +- Lazy-import heavy framework dependencies (`torch`, `transformers`, `ultralytics`) inside the function that needs them โ€” never at module top level. + +### Deprecation policy + +**Minimum window**: deprecated APIs must remain for at least **3 minor releases** before removal. Example: deprecated in `0.29.0` โ†’ removed in `0.32.0`. + +Use the appropriate mechanism depending on what is being deprecated: + +- **Module-level alias**: `supervision.utils.internal.warn_deprecated` in the deprecated module's `__init__.py` +- **Renamed parameter**: `supervision.utils.internal.deprecated_parameter` decorator +- **Public function, method, or class**: `@deprecated` from `pydeprecate` + +Always specify both the deprecation version and the planned removal version in the message or decorator arguments. + +### Deprecated module aliases + +`supervision.keypoint` is deprecated since `0.27.0` and will be removed in `0.30.0`. Always import from `supervision.key_points`: + +```python +from supervision.key_points import KeyPoints # correct +``` + +## ๐Ÿ“ Documentation + +The `supervision` documentation is stored in a folder called `docs`. The project documentation is built using `mkdocs`. + +To run the documentation locally: + +1. **Install documentation dependencies** (if not already installed): + + ```bash + uv sync --group docs + ``` + +2. **Start the documentation server**: + + ```bash + uv run mkdocs serve + ``` + +3. **Access the documentation** at `http://127.0.0.1:8000` in your browser. + +You can learn more about mkdocs on the [mkdocs website](https://www.mkdocs.org/). + +## ๐Ÿง‘โ€๐Ÿณ Cookbooks + +We are always looking for new examples and cookbooks to add to the `supervision` documentation. If you have a use case that you think would be helpful to others, please submit a PR with your example. Here are some guidelines for submitting a new example: + +- Create a new notebook in the [`docs/notebooks`](https://github.com/roboflow/supervision/tree/develop/docs/notebooks) folder. +- Add a link to the new notebook in [`docs/theme/cookbooks.html`](https://github.com/roboflow/supervision/blob/develop/docs/theme/cookbooks.html). Make sure to add the path to the new notebook, as well as a title, labels, author and supervision version. +- Use the [Count Objects Crossing the Line](https://supervision.roboflow.com/develop/notebooks/count-objects-crossing-the-line/) example as a template for your new example. +- Pin the version of `supervision` you are using in the notebook. +- Place an appropriate "Open in Colab" button at the top of the notebook. You can find an example of such a button in the aforementioned `Count Objects Crossing the Line` cookbook. +- **Notebook should be self-contained**. If you rely on external data (videos, images, etc.) or libraries, include download and installation commands in the notebook. +- Annotate the code with appropriate comments, including links to the documentation describing each of the tools you have used. + +## ๐Ÿงช Tests + +[`pytest`](https://docs.pytest.org/en/7.1.x/) is used to run our tests. + +To run tests: + +```bash +uv run pytest +``` + +To run tests with coverage: + +```bash +uv run pytest --cov=supervision +``` + +### Test Structure + +Follow **Arrange-Act-Assert (AAA)**: one setup block, one action, one assertion group per test. Never put two independent actions in the same test. + +**Class grouping:** Group related tests into a class. The class name carries the unit under test; method names describe the expected outcome only โ€” not the mechanism. + +```python +class TestDetectionsWithNms: + def test_keeps_highest_confidence_detection(self): ... + def test_suppresses_lower_score_when_overlap_exceeds_threshold(self): ... + def test_raises_when_confidence_missing(self): ... +``` + +**Parametrize aggressively:** Three or more structurally identical tests should become a single `@pytest.mark.parametrize` case. Use `pytest.param(..., id="slug")` per case โ€” not `ids=[...]` on the decorator โ€” so the ID stays co-located with its arguments and survives reordering. + +```python +@pytest.mark.parametrize( + ("overlap_metric", "expected_keep"), + [ + pytest.param(OverlapMetric.IOU, [True, True], id="iou-keeps-both"), + pytest.param(OverlapMetric.IOS, [True, False], id="ios-suppresses-small"), + ], +) +def test_overlap_metric_determines_suppression( + overlap_metric: OverlapMetric, expected_keep: list[bool] +) -> None: + """Small box inside large: IOU keeps both; IOS suppresses small.""" + ... +``` + +**Docstrings:** Every test function/method requires at minimum a one-line docstring (within the project line length configured in `pyproject.toml`). Describe the scenario, not the implementation. + +### Doctests + +**Guidance:** when an example uses only `supervision`, NumPy, and the standard library โ€” no optional extras (e.g. no `--extra metrics` packages), no external files, no network, no devices โ€” prefer `>>>` doctest format so it is automatically verified by the test suite. Fenced ```` ```python ```` blocks are appropriate when the example cannot reasonably be executed (e.g. loading a third-party model, reading a video file) or when the primary purpose is demonstrating error/exception behaviour rather than return values. + +Doctests run automatically as part of the test suite via `--doctest-modules` in `pyproject.toml`. The `ELLIPSIS` and `NORMALIZE_WHITESPACE` flags are enabled globally, so `...` matches any output fragment and minor whitespace differences are ignored. + +```bash +uv run pytest --doctest-modules src/ +``` + +**Writing a doctest** + +Use the `Example:` section of a Google-style docstring. Prefix each input line with `>>>` and each continuation line with `...`. Place expected output immediately after the last input line with no blank line between them. + +```python +def clip_boxes(xyxy: np.ndarray, resolution_wh: tuple) -> np.ndarray: + """Clip bounding boxes to frame boundaries. + + Args: + xyxy: Box coordinates as (N, 4) float array. + resolution_wh: Frame size as (width, height). + + Returns: + Clipped boxes as (N, 4) float array. + + Example: + >>> import numpy as np + >>> import supervision as sv + >>> boxes = np.array([[-10, -5, 120, 80]], dtype=np.float32) + >>> sv.clip_boxes(boxes, resolution_wh=(100, 60)) + array([[ 0., 0., 100., 60.]], dtype=float32) + """ +``` + +### Key rules + +- **Single-line expression** โ€” write the repr as expected output: `>>> len(result)` โ†’ `1` +- **Multi-line statement** โ€” use `...` continuation: `>>> arr = np.array([` / `... [1, 2],` / `... ])` +- **Print output** โ€” write the printed string as expected output (no quotes). +- **`None` return** โ€” no output line needed (suppress with assignment or `_ =`). +- **Large/variable arrays** โ€” use `ELLIPSIS`: `array([...])` matches any content. +- **`# doctest: +SKIP`** โ€” use only as a last resort for genuinely non-runnable lines (e.g. a GPU-only call inside an otherwise runnable example). Prefer splitting the example into two blocks instead. + +Fenced ```` ```python ```` blocks remain appropriate for: + +- Examples that import optional extras (`supervision[metrics]`, `torch`, `ultralytics`). +- Examples that read files, capture video, or require a running service. +- Illustrative pseudocode that is intentionally incomplete. + +## ๐Ÿ” PR Review Guidelines + +These guidelines help reviewers provide consistent, actionable feedback efficiently. Your goals: validate completeness, identify risks, provide actionable feedback, and highlight quality gaps. + +### Overall Recommendation + +Start with a clear recommendation using these levels: + +- ๐ŸŸข **Approve** โ€” Ready to merge +- ๐ŸŸก **Minor Suggestions** โ€” Improvements recommended but not blocking +- ๐ŸŸ  **Request Changes** โ€” Must address issues before merge +- ๐Ÿ”ด **Block** โ€” Critical issues require major rework + +Example: `๐ŸŸ  Request Changes โ€” Missing unit tests for PolygonMerger and no mkdocs entry.` + +### PR Completeness + +Verify requirements are met (โœ… Complete / โš ๏ธ Incomplete / โŒ Missing / ๐Ÿ”ต N/A): + +- [ ] Clear description of what changed and why +- [ ] Tests added/updated for new functionality or bug fixes +- [ ] Docstrings follow [Google-style](https://google.github.io/styleguide/pyguide.html#383-functions-and-methods) +- [ ] Docs entry added to mkdocs (new functions/classes only) +- [ ] Google Colab provided (if demonstrating feature/fix) +- [ ] Screenshots/videos included (visual changes only) + +Call out missing items explicitly in your review. + +### Quality Scores + +Use **n/5 scoring** with inline code comments for specifics: + +**Code Quality (n/5):** + +- 5/5 ๐ŸŸข Excellent โ€” 4/5 ๐ŸŸข Good โ€” 3/5 ๐ŸŸก Acceptable โ€” 2/5 ๐ŸŸ  Needs Work โ€” 1/5 ๐Ÿ”ด Poor +- Check: correctness (edge cases, None checks, bounds), Python best practices (idiomatic patterns, error handling, type hints), project conventions (docstrings, linting, import order, PEP 8 naming) + +**Testing (n/5):** + +- 5/5 ๐ŸŸข Comprehensive โ€” 4/5 ๐ŸŸข Good โ€” 3/5 ๐ŸŸก Adequate โ€” 2/5 ๐ŸŸ  Insufficient โ€” 1/5 ๐Ÿ”ด Missing +- Verify: unit tests for new code, edge cases covered, specific assertions, realistic scenarios, clear test names + +**Documentation (n/5):** + +- 5/5 ๐ŸŸข Excellent โ€” 4/5 ๐ŸŸข Good โ€” 3/5 ๐ŸŸก Adequate โ€” 2/5 ๐ŸŸ  Insufficient โ€” 1/5 ๐Ÿ”ด Missing +- Confirm: docstrings for public functions/classes, parameters/returns/exceptions documented, usage examples, mkdocs integration, changelog entry for user-facing changes + +### Risk Assessment + +Flag risks with severity (5/5 ๐Ÿ”ด Critical โ€” 4/5 ๐ŸŸ  High โ€” 3/5 ๐ŸŸก Medium โ€” 2/5 ๐ŸŸข Low โ€” 1/5 ๐ŸŸข Negligible): + +**Common risk categories:** + +1. **Breaking changes** โ€” API changes, removed features, behavior modifications (must include migration guide) +2. **Performance** โ€” Inefficient algorithms, memory-intensive operations, bottlenecks +3. **Compatibility** โ€” New Python/dependency requirements, platform-specific code +4. **Security** โ€” Unvalidated input, code execution risks, data exposure + +### Review Summary Template + +```markdown +## Review Summary + +**Recommendation:** [emoji] [Status] โ€” [justification] + +**PR Completeness:** +- โœ… Complete: [items] +- โŒ Missing: [gaps] + +**Quality Scores:** +- Code: n/5 [emoji] โ€” [reason] +- Testing: n/5 [emoji] โ€” [reason] +- Documentation: n/5 [emoji] โ€” [reason] + +**Risk Level:** n/5 [emoji] โ€” [description] + +**Critical Issues (Must Fix):** +1. [Issue] โ€” See comment on `file.py` + +**Suggestions (Optional):** +1. [Improvement] โ€” See suggestion on `file.py` + +**Next Steps:** +1. [Action item] +``` + +### Review Best Practices + +**DO:** Use inline GitHub comments with suggestions, explain *why* (not just *what*), distinguish blocking vs. nice-to-have, acknowledge good work, run linter if needed (`uv run pre-commit run --all-files`) + +**DON'T:** Mention line numbers in summary (use inline comments), give vague feedback, nitpick style (defer to tools), assume knowledge of conventions, block on minor issues + +**Tone:** Be respectful, specific, pragmatic, and consistent. Focus on actionable feedback that moves PRs toward merge. + +## ๐Ÿ“„ License + +By contributing, you agree that your contributions will be licensed under an [MIT license](../LICENSE.md). diff --git a/.github/ISSUE_TEMPLATE/bug-report.yml b/.github/ISSUE_TEMPLATE/bug-report.yml new file mode 100644 index 0000000..bb47504 --- /dev/null +++ b/.github/ISSUE_TEMPLATE/bug-report.yml @@ -0,0 +1,68 @@ +name: ๐Ÿž Bug Report +title: "[Bug]: " +description: Report a bug or unexpected behavior in Supervision +labels: [bug] +body: + - type: checkboxes + attributes: + label: Search before asking + description: Please search [issues](https://github.com/roboflow/supervision/issues) and [discussions](https://github.com/roboflow/supervision/discussions) first. + options: + - label: I have searched the issues and discussions and found no similar bug report. + required: true + + - type: textarea + attributes: + label: Bug + description: Describe the bug, what you expected, and what actually happened. + placeholder: | + **What's the bug?** + Brief description... + + **Expected behavior:** + What should happen... + + **Actual behavior:** + What actually happens... + + **Error/Traceback (if any):** + ```python + # Paste error messages here + ``` + validations: + required: true + + - type: textarea + attributes: + label: Environment + description: Your setup details + placeholder: | + - Supervision: 0.23.0 + - Python: 3.10.12 + - OS: Ubuntu 22.04 + value: | + - Supervision: + - Python: + - OS: + validations: + required: true + + - type: textarea + attributes: + label: Minimal Reproducible Example + description: Code to reproduce the bug ([guide](https://stackoverflow.com/help/minimal-reproducible-example)) + placeholder: | + ```python + import supervision as sv + + # Your code here + ``` + validations: + required: false + + - type: checkboxes + attributes: + label: Are you willing to submit a PR? + description: (Optional) We encourage community contributions! + options: + - label: Yes I'd like to help by submitting a PR! diff --git a/.github/ISSUE_TEMPLATE/config.yml b/.github/ISSUE_TEMPLATE/config.yml new file mode 100644 index 0000000..b5c38ca --- /dev/null +++ b/.github/ISSUE_TEMPLATE/config.yml @@ -0,0 +1,17 @@ +blank_issues_enabled: false +contact_links: + - name: โ“ Ask a Question + url: https://github.com/roboflow/supervision/discussions/new?category=q-a + about: Ask questions about using Supervision in GitHub Discussions + - name: ๐Ÿ“š Documentation + url: https://supervision.roboflow.com/ + about: Check the official Supervision documentation for guides and API references + - name: ๐Ÿ’ฌ GitHub Discussions + url: https://github.com/roboflow/supervision/discussions + about: Join community discussions, share ideas, and get help + - name: ๐ŸŒŸ Show and Tell + url: https://github.com/roboflow/supervision/discussions/categories/show-and-tell + about: Share your projects and creations built with Supervision + - name: ๐Ÿ—ฃ๏ธ Roboflow Discord + url: https://discord.com/invite/GbfgXGJ8Bk + about: Join our Discord to collaborate with other community members diff --git a/.github/ISSUE_TEMPLATE/feature-request.yml b/.github/ISSUE_TEMPLATE/feature-request.yml new file mode 100644 index 0000000..7161b46 --- /dev/null +++ b/.github/ISSUE_TEMPLATE/feature-request.yml @@ -0,0 +1,50 @@ +name: ๐Ÿคฉ Feature Request +title: "[Feature]: " +description: Suggest a new feature or improvement +labels: [enhancement] +body: + - type: markdown + attributes: + value: | + Thank you for submitting a Supervision ๐Ÿคฉ Feature Request! + + - type: checkboxes + attributes: + label: Search before asking + description: Please search [issues](https://github.com/roboflow/supervision/issues) and [discussions](https://github.com/roboflow/supervision/discussions) first. + options: + - label: I have searched the issues and discussions and found no similar feature request. + required: true + + - type: textarea + attributes: + label: Feature Description + description: What feature would you like and why? + placeholder: | + **What:** Describe the feature... + + **Why:** What problem does it solve? Who would benefit? + + **How (optional):** Any ideas on implementation? + validations: + required: true + + - type: textarea + attributes: + label: Example Usage + description: (Optional) Show how you'd like to use this feature + placeholder: | + ```python + import supervision as sv + + # Your example usage here + ``` + validations: + required: false + + - type: checkboxes + attributes: + label: Are you willing to submit a PR? + description: (Optional) We encourage community contributions! + options: + - label: Yes I'd like to help by submitting a PR! diff --git a/.github/PULL_REQUEST_TEMPLATE.md b/.github/PULL_REQUEST_TEMPLATE.md new file mode 100644 index 0000000..3448d85 --- /dev/null +++ b/.github/PULL_REQUEST_TEMPLATE.md @@ -0,0 +1,67 @@ +
+Before submitting + +- [ ] Self-reviewed the code +- [ ] Updated documentation, follow [Google-style](https://google.github.io/styleguide/pyguide.html#383-functions-and-methods) +- [ ] Added docs entry for autogeneration (if new functions/classes) +- [ ] Added/updated tests +- [ ] All tests pass locally + +
+ +## Description + + + +## Type of Change + + + +- ๐Ÿ› Bug fix (non-breaking change which fixes an issue) +- โœจ New feature (non-breaking change which adds functionality) +- ๐Ÿ’ฅ Breaking change (fix or feature that would cause existing functionality to not work as expected) +- ๐Ÿ“ Documentation update +- ๐Ÿงช Test update +- ๐Ÿ”จ Refactoring (no functional changes) +- โšก Performance improvement +- ๐Ÿ”ง Chore (dependencies, configs, etc.) + +## Motivation and Context + + + + + +Closes #(issue) + +## Changes Made + + + +- +- +- + +## Testing + + + +- [ ] I have tested this code locally +- [ ] I have added unit tests that prove my fix is effective or that my feature works +- [ ] All new and existing tests pass + +## Google Colab (optional) + + + + + +Colab link: + +## Screenshots/Videos (optional) + + + +## Additional Notes + + diff --git a/.github/copilot-instructions.md b/.github/copilot-instructions.md new file mode 100644 index 0000000..70e0fd6 --- /dev/null +++ b/.github/copilot-instructions.md @@ -0,0 +1,146 @@ +# GitHub Copilot Instructions for Supervision + +This file provides context-aware guidance for GitHub Copilot when working in the Supervision repository. + +--- + +## ๐Ÿ“š Repository Overview + +**Supervision** is a Python library providing reusable computer vision utilities for working with object detection models (YOLO, SAM, etc.). It offers tools for detections processing, tracking, annotation, and dataset management. + +- **Languages**: Python 3.10+ +- **Key Dependencies**: NumPy, OpenCV, SciPy +- **License**: MIT + +--- + +## ๐Ÿ—๏ธ Project Structure + +``` +supervision/ +โ”œโ”€โ”€ src/ +โ”‚ โ””โ”€โ”€ supervision/ # Main library code +โ”‚ โ”œโ”€โ”€ detection/ # Detection utilities +โ”‚ โ”œโ”€โ”€ draw/ # Annotation and visualization +โ”‚ โ”œโ”€โ”€ tracker/ # Object tracking +โ”‚ โ”œโ”€โ”€ dataset/ # Dataset management +โ”‚ โ””โ”€โ”€ utils/ # Shared utilities +โ”œโ”€โ”€ tests/ # Test suite (mirrors src/supervision/) +โ”œโ”€โ”€ docs/ # MkDocs documentation +โ””โ”€โ”€ examples/ # Usage examples +``` + +--- + +## ๐Ÿ”ง Development Commands + +**Setup:** + +```bash +# Install dependencies +uv sync --group dev --group docs --extra metrics + +# Install pre-commit hooks +uv run pre-commit install +``` + +**Quality Checks:** + +```bash +# Run all pre-commit hooks (formatting, linting, type checking) +uv run pre-commit run --all-files + +# Run tests with coverage +uv run pytest --cov=supervision +``` + +**Documentation:** + +```bash +# Serve docs locally at http://127.0.0.1:8000 +uv run mkdocs serve +``` + +--- + +## ๐Ÿ’ป Code Conventions + +### General Guidelines + +- Follow **[AGENTS.md](../AGENTS.md)** for task-based development workflows +- Reference **[CONTRIBUTING.md](CONTRIBUTING.md)** for detailed contribution guidelines +- All code must pass `pre-commit` hooks before committing + +### Code Style + +- **Formatting**: Enforced by `ruff-format`, `prettier` (pre-commit) +- **Linting**: Enforced by `ruff-check` (pre-commit) +- **Type Hints**: Required on all new code +- **Docstrings**: Required using [Google Python style](https://google.github.io/styleguide/pyguide.html#383-functions-and-methods) + - Must include usage examples with primitive values + - Serve as runnable documentation + +### Performance + +- Avoid unnecessary NumPy array copies +- Prefer vectorized operations over Python loops +- Use OpenCV operations efficiently + +### API Design + +- Follow existing naming patterns for consistency +- Maintain backward compatibility unless explicitly breaking +- Prefer functional utilities over complex classes + +--- + +## ๐Ÿงช Testing Requirements + +All new features must include: + +- Unit tests covering happy path and edge cases +- Tests for `None`, empty inputs, large arrays, boundary conditions +- Clear test names describing what they validate +- Proper assertions (not just "no exception raised") + +--- + +## ๐Ÿ“ Documentation Requirements + +For new public functions/classes: + +- Google-style docstrings with parameters, returns, exceptions +- Usage examples in docstrings +- Entry in appropriate `docs/*.md` file +- Reference in `mkdocs.yml` navigation + +--- + +## ๐Ÿ” Pull Request Reviews + +**When reviewing PRs, follow the comprehensive [PR Review Guidelines](CONTRIBUTING.md#pr-review-guidelines).** + +Quick checklist: + +- Tests included and passing +- Docstrings follow Google style with examples +- Pre-commit hooks pass +- Breaking changes documented +- Score code quality, testing, docs (n/5 scale) +- Use inline comments + GitHub suggestion format + +--- + +## ๐ŸŒฟ Branching & Commits + +- Branch from `develop` using prefixes: `feat/`, `fix/`, `docs/`, `refactor/`, `perf/`, `test/`, `chore/` +- Use **conventional commits**: `feat:`, `fix:`, `docs:`, `refactor:`, `perf:`, `test:`, `chore:` +- All PRs target `develop` branch + +--- + +## ๐ŸŽฏ Context-Aware Behavior + +- **For general development tasks**: Follow [AGENTS.md](../AGENTS.md) +- **For pull request reviews**: Follow [PR Review Guidelines](CONTRIBUTING.md#pr-review-guidelines) +- **For detailed processes**: Consult [CONTRIBUTING.md](CONTRIBUTING.md) diff --git a/.github/dependabot.yml b/.github/dependabot.yml new file mode 100644 index 0000000..b6a2091 --- /dev/null +++ b/.github/dependabot.yml @@ -0,0 +1,26 @@ +version: 2 +updates: + # GitHub Actions + - package-ecosystem: "github-actions" + directory: "/" + schedule: + interval: "weekly" + cooldown: + default-days: 7 + commit-message: + prefix: โฌ†๏ธ + target-branch: "develop" + groups: + github-actions: + patterns: + - "*" + # Python + - package-ecosystem: "pip" + directory: "/" + schedule: + interval: "weekly" + cooldown: + default-days: 7 + commit-message: + prefix: โฌ†๏ธ + target-branch: "develop" diff --git a/.github/lychee.toml b/.github/lychee.toml new file mode 100644 index 0000000..4080e13 --- /dev/null +++ b/.github/lychee.toml @@ -0,0 +1,35 @@ +verbose = "info" +no_progress = true +include_verbatim = true +retry_wait_time = 10 +max_retries = 3 +max_concurrency = 8 +cache = false +accept = [ + 200, # OK + 408, # Request Timeout + # 429 means the server received the request and is actively rate-limiting โ€” the URL is + # reachable. Real dead links return 404, 410, or fail to connect/resolve; none of + # those produce a 429, so accepting it here does not hide broken links. + 429, # Too Many Requests (rate-limited but reachable; does not mask dead links) + # CI regularly sees momentary 502/503/504 from large, healthy hosts (github.com, + # supervision.roboflow.com), and in-run retries tend to land inside the same + # incident window. Genuinely dead links surface as 404, 410, or connection/DNS + # failures, which remain rejected. + 502, # Bad Gateway (transient upstream hiccup) + 503, # Service Unavailable (transient overload or maintenance) + 504, # Gateway Timeout (transient upstream hiccup) +] + +exclude = [ + "https://github.com/YOUR_USERNAME/supervision.git", # hint for forking contributors + "http://127.0.0.1:8000", # hint for local docs server + "https://sam2.metademolab.com/", # returns 403 Forbidden + "https://snyk.io/advisor/python/supervision/badge.svg", # badge URL + "https://trendshift.io", # badge API times out in CI + "https://universe.roboflow.com/", + "https://universe.roboflow.com/model-examples/segmented-animals-basic", + # fixme: this page returns 401 Unauthorized when accessed and 404 Not Found when accessed with browser, + # which is weird and should be investigated + "https://huggingface.co/spaces/Roboflow/Annotators", +] diff --git a/.github/scripts/augment_links.py b/.github/scripts/augment_links.py new file mode 100755 index 0000000..71b2ac4 --- /dev/null +++ b/.github/scripts/augment_links.py @@ -0,0 +1,70 @@ +#!/usr/bin/env python3 +""" +Script to augment relative links in markdown files to GitHub URLs. +""" + +import argparse +import os +import re +from re import Match + + +def get_repo_root() -> str: + """Get the repository root path.""" + script_dir = os.path.dirname(os.path.abspath(__file__)) + return os.path.dirname(os.path.dirname(script_dir)) + + +def augment_links_in_file(file_path: str, branch: str = "main") -> None: + """ + Augment relative links in a markdown file to GitHub URLs. + + Args: + file_path: Path to the markdown file. + branch: Branch name, default "main". + """ + repo_root = get_repo_root() + + if not file_path.endswith(".md"): + return + + with open(file_path) as f: + content = f.read() + + def replace_link(match: Match[str]) -> str: + full_match = match.group(0) + text = match.group(2) + url = match.group(3) + if not url.startswith("http"): + # Resolve relative to an absolute path + abs_path = os.path.normpath(os.path.join(os.path.dirname(file_path), url)) + if os.path.exists(abs_path): + # Use 'tree' for directories and 'blob' for files + ref = "tree" if os.path.isdir(abs_path) else "blob" + rel_to_root = os.path.relpath(abs_path, repo_root) + new_url = f"https://github.com/roboflow/supervision/{ref}/{branch}/{rel_to_root}" + if full_match.startswith("!"): + return f"![{text}]({new_url})" + else: + return f"[{text}]({new_url})" + return full_match + + new_content = re.sub(r"(!?)\[([^\]]+)\]\(([^)]+)\)", replace_link, content) + with open(file_path, "w") as f: + f.write(new_content) + + +def main() -> None: + parser = argparse.ArgumentParser( + description="Augment relative links to GitHub URLs." + ) + parser.add_argument("--branch", default="main", help="Branch name") + parser.add_argument("files", nargs="+", help="Files to process") + args = parser.parse_args() + + for file in args.files: + augment_links_in_file(file, args.branch) + + +if __name__ == "__main__": + main() diff --git a/.github/workflows/build-package.yml b/.github/workflows/build-package.yml new file mode 100644 index 0000000..0d6ef5a --- /dev/null +++ b/.github/workflows/build-package.yml @@ -0,0 +1,56 @@ +name: Build Package + +permissions: + contents: read + +on: + workflow_call: + inputs: + python-version: + required: false + type: string + default: "3.10" + link-check: + required: false + type: boolean + default: true + +jobs: + build: + runs-on: ubuntu-latest + steps: + - name: ๐Ÿ“ฅ Checkout the repository + uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0 + + - name: ๐Ÿ Install uv and set Python version ${{ inputs.python-version }} + uses: astral-sh/setup-uv@d31148d669074a8d0a63714ba94f3201e7020bc3 # v8.3.0 + with: + python-version: ${{ inputs.python-version }} + activate-environment: true + + - name: ๐ŸŽจ Augment paths in README + run: | + python .github/scripts/augment_links.py README.md --branch ${{ github.head_ref || github.ref_name }} + cat README.md + + - name: ๐Ÿ”— Link Checker + if: inputs.link-check + uses: lycheeverse/lychee-action@v2 + with: + lycheeVersion: v0.22.0 + args: | + --config .github/lychee.toml + README.md + fail: true + + - name: ๐Ÿ—๏ธ Build source and wheel distributions + run: | + uv sync --frozen --group build + uv build + twine check --strict dist/* + + - name: ๐Ÿ“ค Upload distribution artifacts + uses: actions/upload-artifact@v7 + with: + name: dist + path: dist/ diff --git a/.github/workflows/ci-build-docs.yml b/.github/workflows/ci-build-docs.yml new file mode 100644 index 0000000..414adaa --- /dev/null +++ b/.github/workflows/ci-build-docs.yml @@ -0,0 +1,37 @@ +name: Docs/Test Workflow + +on: + push: + branches: [main, develop] + pull_request: + branches: [main, develop] + +concurrency: + group: docs-test-${{ github.ref }} + cancel-in-progress: ${{ github.event_name == 'pull_request' }} + +# Restrict permissions by default +permissions: + contents: read # Required for checkout + checks: write # Required for test reporting + +jobs: + docs-build: + name: Test docs build + runs-on: ubuntu-latest + timeout-minutes: 10 + steps: + - name: ๐Ÿ“ฅ Checkout the repository + uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0 + + - name: ๐Ÿ Install uv and set Python + uses: astral-sh/setup-uv@d31148d669074a8d0a63714ba94f3201e7020bc3 # v8.3.0 + with: + python-version: "3.10" + activate-environment: true + + - name: ๐Ÿ—๏ธ Install dependencies + run: uv sync --frozen --group docs + + - name: ๐Ÿงช Test Docs Build + run: mkdocs build --verbose diff --git a/.github/workflows/ci-check-links.yml b/.github/workflows/ci-check-links.yml new file mode 100644 index 0000000..280b197 --- /dev/null +++ b/.github/workflows/ci-check-links.yml @@ -0,0 +1,37 @@ +name: Check links & references + +permissions: + contents: read + +on: + push: + branches: [main, develop] + pull_request: + schedule: + # Run once a week on Sundays + - cron: "0 9 * * 0" + +concurrency: + group: ci-check-links-${{ github.ref }} + cancel-in-progress: true +jobs: + links-check: + runs-on: ubuntu-latest + steps: + - name: Checkout repository + uses: actions/checkout@v7 + + - name: ๐Ÿ”— Link Checker + uses: lycheeverse/lychee-action@v2 + with: + lycheeVersion: v0.22.0 + args: | + --config .github/lychee.toml + './**/*.md' + # TODO: enable also following file types + # './**/*.toml' + # './**/*.yml' + # './**/*.yaml' + # './**/*.py' + fail: true + token: ${{ secrets.GITHUB_TOKEN }} diff --git a/.github/workflows/ci-tests.yml b/.github/workflows/ci-tests.yml new file mode 100644 index 0000000..3112de0 --- /dev/null +++ b/.github/workflows/ci-tests.yml @@ -0,0 +1,90 @@ +name: Pytest/Test Workflow + +on: + push: + branches: [main, develop] + pull_request: + branches: [main, develop] + +permissions: + contents: read + +concurrency: + group: pytest-test-${{ github.ref }} + cancel-in-progress: ${{ github.event_name == 'pull_request' }} + +jobs: + build-pkg: + name: Build this Package + uses: ./.github/workflows/build-package.yml + with: + # only run link check on PRs from the same repo + link-check: ${{ github.event_name != 'pull_request' || github.event.pull_request.head.repo.full_name == github.repository }} + + run-tests: + name: Import Test and Pytest Run + # needs: build # todo: consider using this build package for testing + timeout-minutes: 10 + strategy: + fail-fast: false + matrix: + os: ["ubuntu-latest", "windows-latest", "macos-latest"] + python-version: ["3.10", "3.11", "3.12", "3.13"] + runs-on: ${{ matrix.os }} + steps: + - name: ๐Ÿ“ฅ Checkout the repository + uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0 + + - name: ๐Ÿ Install uv and set Python version ${{ matrix.python-version }} + uses: astral-sh/setup-uv@d31148d669074a8d0a63714ba94f3201e7020bc3 # v8.3.0 + with: + python-version: ${{ matrix.python-version }} + activate-environment: true + + - name: ๐Ÿš€ Install Packages + run: uv sync --frozen --group dev --extra metrics + + - name: ๐Ÿ“ฆ Run the Import test + run: python -c "import supervision; from supervision import assets; from supervision import metrics; print(supervision.__version__)" + + - name: ๐Ÿงช Run the Test + run: pytest src/ tests/ --cov=supervision --cov-report=xml + + - name: Generate Coverage Report + run: | + coverage xml + coverage report + + - name: Upload coverage to Codecov + uses: codecov/codecov-action@v7 + with: + token: ${{ secrets.CODECOV_TOKEN }} + files: "coverage.xml" + flags: cpu,${{ runner.os }},python${{ matrix.python-version }} + env_vars: OS,PYTHON + name: codecov-umbrella + fail_ci_if_error: false + + - name: Minimize uv cache + run: uv cache prune --ci + + testing-guardian: + runs-on: ubuntu-latest + needs: run-tests + if: always() + steps: + - name: ๐Ÿ“‹ Display test result + run: echo "${{ needs.run-tests.result }}" + - name: โŒ Fail guardian on test failure + if: needs.run-tests.result == 'failure' + run: exit 1 + # Ensure that cancelled or skipped test runs still cause this guardian job to fail, + # using an explicit exit code instead of relying on timeout behavior. + - name: โš ๏ธ cancelled or skipped... + if: contains(fromJSON('["cancelled", "skipped"]'), needs.run-tests.result) + run: | + echo "run-tests job result is '${{ needs.run-tests.result }}'; failing explicitly." + exit 1 + - name: โœ… tests succeeded + if: needs.run-tests.result == 'success' + run: echo "All tests completed successfully in job 'run-tests'." diff --git a/.github/workflows/clear-cache.yml b/.github/workflows/clear-cache.yml new file mode 100644 index 0000000..54e0916 --- /dev/null +++ b/.github/workflows/clear-cache.yml @@ -0,0 +1,42 @@ +name: Clear cache + +on: + schedule: + - cron: "0 0 1 * *" # Run at midnight on the first day of every month + workflow_dispatch: + +# Restrict permissions by default +permissions: + actions: write # Required for cache management + +jobs: + clear-cache: + name: Clear cache + runs-on: ubuntu-latest + timeout-minutes: 10 + steps: + - name: Clear cache + uses: actions/github-script@3a2844b7e9c422d3c10d287c895573f7108da1b3 # v9.0.0 + with: + script: | + console.log("Starting cache cleanup...") + const caches = await github.rest.actions.getActionsCacheList({ + owner: context.repo.owner, + repo: context.repo.repo, + }) + + let deletedCount = 0 + for (const cache of caches.data.actions_caches) { + console.log(`Deleting cache: ${cache.key} (${cache.size_in_bytes} bytes)`) + try { + await github.rest.actions.deleteActionsCacheById({ + owner: context.repo.owner, + repo: context.repo.repo, + cache_id: cache.id, + }) + deletedCount++ + } catch (error) { + console.error(`Failed to delete cache ${cache.key}: ${error.message}`) + } + } + console.log(`Cache cleanup completed. Deleted ${deletedCount} caches.`) diff --git a/.github/workflows/pr-conflict-labeler.yml b/.github/workflows/pr-conflict-labeler.yml new file mode 100644 index 0000000..fefaf99 --- /dev/null +++ b/.github/workflows/pr-conflict-labeler.yml @@ -0,0 +1,26 @@ +name: PR Conflict Labeler + +on: + # So that PRs touching the same files as the push are updated + push: + branches: + - main + - develop + # So that the `dirtyLabel` is removed if conflicts are resolved + # We recommend `pull_request_target` so that github secrets are available. + # In `pull_request` we wouldn't be able to change labels of fork PRs + pull_request_target: + types: [synchronize] + +permissions: + pull-requests: write + issues: write +jobs: + main: + runs-on: ubuntu-latest + steps: + - name: check if prs are dirty + uses: eps1lon/actions-label-merge-conflict@v3 + with: + dirtyLabel: "has conflicts" + repoToken: "${{ secrets.GITHUB_TOKEN }}" diff --git a/.github/workflows/publish-docs.yml b/.github/workflows/publish-docs.yml new file mode 100644 index 0000000..fd6b5f4 --- /dev/null +++ b/.github/workflows/publish-docs.yml @@ -0,0 +1,171 @@ +name: Docs/Build and Publish + +# Deploy matrix: +# push develop -> mike deploy develop +# push release/latest -> mike deploy latest +# release published -> mike deploy only; does not move /latest/ + +on: + push: + branches: + - develop + - release/latest + workflow_dispatch: + release: + types: [published] + +# Ensure only one concurrent deployment +concurrency: + group: ${{ github.workflow }}-${{ github.event_name == 'push' && github.ref}} + cancel-in-progress: true + +# Restrict permissions by default +permissions: + contents: write # Required for committing to gh-pages + pages: write # Required for deploying to Pages + pull-requests: write # Required for PR comments + +jobs: + docs-build-deploy: + name: Publish Docs + runs-on: ubuntu-latest + timeout-minutes: 10 + steps: + - name: ๐Ÿ“ฅ Checkout the repository + uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0 + with: + fetch-depth: 0 + + - name: ๐Ÿ Install uv and set Python + uses: astral-sh/setup-uv@d31148d669074a8d0a63714ba94f3201e7020bc3 # v8.3.0 + with: + python-version: "3.10" + activate-environment: true + + - name: ๐Ÿ—๏ธ Install dependencies + run: uv sync --frozen --group docs + + - name: โš™๏ธ Configure git for github-actions + run: | + git config --global user.name "${{ github.actor }}" + git config --global user.email "${{ github.actor }}@users.noreply.github.com" + + - name: ๐Ÿš€ Deploy Development Docs + if: (github.event_name == 'push' && github.ref == 'refs/heads/develop') || github.event_name == 'workflow_dispatch' + env: + MKDOCS_GIT_COMMITTERS_APIKEY: ${{ secrets.GITHUB_TOKEN }} + run: | + mike deploy --push develop + + - name: ๐Ÿš€ Deploy Latest Docs + if: github.event_name == 'push' && github.ref == 'refs/heads/release/latest' + env: + MKDOCS_GIT_COMMITTERS_APIKEY: ${{ secrets.GITHUB_TOKEN }} + run: | + if mike list | grep -Eq '^latest(\s|$)'; then mike delete latest; fi + mike deploy --push latest + + - name: ๐Ÿท๏ธ Determine release deployment metadata + id: release_metadata + run: | + is_rc=false + release_tag="" + if [[ "$GITHUB_EVENT_NAME" == "release" ]]; then + release_tag="${GITHUB_REF_NAME#v}" + release_tag="${release_tag%.post*}" + release_tag_lower="${release_tag,,}" + # Match RC suffixes with separators (1.0-rc1, 1.0.rc1) or compact form (1.0rc1). + if [[ "$release_tag_lower" =~ (^|[._-])rc[0-9]+$ ]] || [[ "$release_tag_lower" =~ [0-9]rc[0-9]+$ ]]; then + is_rc=true + fi + fi + echo "is_rc=$is_rc" >> "$GITHUB_OUTPUT" + echo "release_tag=$release_tag" >> "$GITHUB_OUTPUT" + + - name: ๐Ÿš€ Deploy Release Docs + if: github.event_name == 'release' && github.event.action == 'published' && steps.release_metadata.outputs.is_rc != 'true' + env: + MKDOCS_GIT_COMMITTERS_APIKEY: ${{ secrets.GITHUB_TOKEN }} + run: | + mike deploy --push "${{ steps.release_metadata.outputs.release_tag }}" + + # IndexNow key: 0d5d9799b1cc4a39825146388c6781eb + # This key must stay in sync across three files: + # docs/0d5d9799b1cc4a39825146388c6781eb.txt (key file served at site root) + # docs/theme/main.html (indexnow-key meta tag) + # this workflow (inject step + notify step below) + # Bing/Yandex fetch https://supervision.roboflow.com/.txt to verify ownership. + # Do NOT rename or delete the .txt file or change the key string without updating all three. + - name: ๐ŸŒ Inject GEO root files into gh-pages + if: > + (github.event_name == 'push' && github.ref == 'refs/heads/develop') || + github.event_name == 'workflow_dispatch' || + (github.event_name == 'push' && github.ref == 'refs/heads/release/latest') || + (github.event_name == 'release' && github.event.action == 'published' && steps.release_metadata.outputs.is_rc != 'true') + run: | + cp docs/robots.txt /tmp/robots.txt + cp docs/llms.txt /tmp/llms.txt + cp docs/llms.full.txt /tmp/llms.full.txt + cp docs/llms-100k.txt /tmp/llms-100k.txt + cp docs/_headers /tmp/headers.txt + cp docs/0d5d9799b1cc4a39825146388c6781eb.txt /tmp/indexnow.txt + if [[ "$GITHUB_REF" == "refs/heads/release/latest" ]]; then + version_dir="latest" + else + version_dir="" + fi + git fetch origin gh-pages + git checkout gh-pages + cp /tmp/robots.txt robots.txt + cp /tmp/llms.txt llms.txt + cp /tmp/llms.full.txt llms.full.txt + cp /tmp/llms-100k.txt llms-100k.txt + cp /tmp/headers.txt _headers + cp /tmp/indexnow.txt 0d5d9799b1cc4a39825146388c6781eb.txt + if [[ -n "$version_dir" && -f "$version_dir/sitemap.xml" ]]; then + cp "$version_dir/sitemap.xml" sitemap.xml + gzip -9 -c sitemap.xml > sitemap.xml.gz + fi + files_to_add=( + robots.txt + llms.txt + llms.full.txt + llms-100k.txt + _headers + 0d5d9799b1cc4a39825146388c6781eb.txt + ) + if [[ -f "sitemap.xml" ]]; then + files_to_add+=(sitemap.xml) + fi + if [[ -f "sitemap.xml.gz" ]]; then + files_to_add+=(sitemap.xml.gz) + fi + git add "${files_to_add[@]}" + git diff --cached --quiet || git commit -m "chore: update GEO root files" + git push origin gh-pages + + - name: ๐Ÿ“ก Notify IndexNow + if: > + (github.event_name == 'push' && github.ref == 'refs/heads/develop') || + github.event_name == 'workflow_dispatch' || + (github.event_name == 'push' && github.ref == 'refs/heads/release/latest') + run: | + curl -s -o /dev/null -w "%{http_code}" -X POST "https://api.indexnow.org/IndexNow" \ + -H "Content-Type: application/json; charset=utf-8" \ + -d '{ + "host": "supervision.roboflow.com", + "key": "0d5d9799b1cc4a39825146388c6781eb", + "keyLocation": "https://supervision.roboflow.com/0d5d9799b1cc4a39825146388c6781eb.txt", + "urlList": [ + "https://supervision.roboflow.com/", + "https://supervision.roboflow.com/latest/", + "https://supervision.roboflow.com/latest/how_to/detect_and_annotate/", + "https://supervision.roboflow.com/latest/how_to/track_objects/", + "https://supervision.roboflow.com/latest/how_to/detect_small_objects/", + "https://supervision.roboflow.com/latest/how_to/filter_detections/", + "https://supervision.roboflow.com/latest/how_to/save_detections/", + "https://supervision.roboflow.com/latest/how_to/count_in_zone/", + "https://supervision.roboflow.com/latest/how_to/benchmark_a_model/", + "https://supervision.roboflow.com/latest/how_to/process_datasets/" + ] + }' || true diff --git a/.github/workflows/publish-pre-release.yml b/.github/workflows/publish-pre-release.yml new file mode 100644 index 0000000..4bac780 --- /dev/null +++ b/.github/workflows/publish-pre-release.yml @@ -0,0 +1,51 @@ +name: Publish Supervision Pre-Releases to PyPI + +on: + push: + tags: + - "[0-9]+.[0-9]+.[0-9]+a[0-9]+" + - "[0-9]+.[0-9]+.[0-9]+b[0-9]+" + - "[0-9]+.[0-9]+.[0-9]+rc[0-9]+" + - "[0-9]+.[0-9]+.[0-9]+.a[0-9]+" + - "[0-9]+.[0-9]+.[0-9]+.b[0-9]+" + - "[0-9]+.[0-9]+.[0-9]+.rc[0-9]+" + workflow_dispatch: + pull_request: + branches: [main, develop] + paths: + - ".github/workflows/build-package.yml" + - ".github/workflows/publish-pre-release.yml" + +permissions: {} # Explicitly remove all permissions by default + +jobs: + build: + permissions: + contents: read + uses: ./.github/workflows/build-package.yml + + publish-pre-release: + name: Publish Pre-release Package + needs: build + runs-on: ubuntu-latest + environment: + name: test + url: https://pypi.org/project/supervision/ + timeout-minutes: 10 + permissions: + id-token: write # Required for PyPI publishing + contents: read # Required for checkout + steps: + - name: ๐Ÿ“ฅ Download distribution artifacts + uses: actions/download-artifact@v8 + with: + name: dist + path: dist/ + - name: List distribution artifacts + run: ls -lh dist/ + + - name: ๐Ÿš€ Publish to PyPi + if: github.event_name != 'pull_request' + uses: pypa/gh-action-pypi-publish@cef221092ed1bacb1cc03d23a2d87d1d172e277b # v1.14.0 + with: + attestations: true diff --git a/.github/workflows/publish-release.yml b/.github/workflows/publish-release.yml new file mode 100644 index 0000000..4b38c80 --- /dev/null +++ b/.github/workflows/publish-release.yml @@ -0,0 +1,53 @@ +name: Publish Supervision Releases to PyPI + +on: + release: + types: [published] + workflow_dispatch: + pull_request: + branches: [main, develop] + paths: + - ".github/workflows/build-package.yml" + - ".github/workflows/publish-release.yml" + +permissions: {} # Explicitly remove all permissions by default + +jobs: + build: + permissions: + contents: read + uses: ./.github/workflows/build-package.yml + + publish-release: + name: Publish Release Package + needs: build + runs-on: ubuntu-latest + environment: + name: release + url: https://pypi.org/project/supervision/ + timeout-minutes: 10 + permissions: + id-token: write # Required for PyPI publishing + contents: write # Required for checkout and upload assets + steps: + - name: ๐Ÿ“ฅ Download distribution artifacts + uses: actions/download-artifact@v8 + with: + name: dist + path: dist/ + - name: List distribution artifacts + run: ls -lh dist/ + + - name: ๐Ÿ“ฆ Upload assets to Release + if: github.event_name == 'release' + uses: AButler/upload-release-assets@v4.0 + with: + files: "dist/*" + repo-token: ${{ secrets.GITHUB_TOKEN }} + + - name: ๐Ÿš€ Publish to PyPi + # We only want to publish to PyPi if the event is a release and it's not a pre-release. + if: (github.event_name == 'release' && github.event.release.prerelease != true) || github.event_name == 'workflow_dispatch' + uses: pypa/gh-action-pypi-publish@cef221092ed1bacb1cc03d23a2d87d1d172e277b # v1.14.0 + with: + attestations: true diff --git a/.github/workflows/publish-testpypi.yml b/.github/workflows/publish-testpypi.yml new file mode 100644 index 0000000..d32d86f --- /dev/null +++ b/.github/workflows/publish-testpypi.yml @@ -0,0 +1,44 @@ +name: Publish Supervision Releases to TestPyPI + +on: + workflow_dispatch: + pull_request: + branches: [main, develop] + paths: + - ".github/workflows/build-package.yml" + - ".github/workflows/publish-testpypi.yml" + +permissions: {} # Explicitly remove all permissions by default + +jobs: + build: + permissions: + contents: read + uses: ./.github/workflows/build-package.yml + + publish-testpypi: + name: Publish Release Package + needs: build + runs-on: ubuntu-latest + environment: + name: release + url: https://pypi.org/project/supervision/ + timeout-minutes: 10 + permissions: + id-token: write # Required for PyPI publishing + contents: read # Required for checkout + steps: + - name: ๐Ÿ“ฅ Download distribution artifacts + uses: actions/download-artifact@v8 + with: + name: dist + path: dist/ + - name: List distribution artifacts + run: ls -lh dist/ + + - name: ๐Ÿš€ Publish to Test-PyPi + if: github.event_name != 'pull_request' + uses: pypa/gh-action-pypi-publish@cef221092ed1bacb1cc03d23a2d87d1d172e277b # v1.14.0 + with: + repository-url: https://test.pypi.org/legacy/ + attestations: true diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..5880d0a --- /dev/null +++ b/.gitignore @@ -0,0 +1,178 @@ +# IDE +.idea/ +.vscode/ + +# Byte-compiled / optimized / DLL files +__pycache__/ +*.py[cod] +*$py.class + +# C extensions +*.so + +# Distribution / packaging +.Python +build/ +develop-eggs/ +dist/ +downloads/ +eggs/ +.eggs/ +lib/ +lib64/ +parts/ +sdist/ +var/ +wheels/ +pip-wheel-metadata/ +share/python-wheels/ +*.egg-info/ +.installed.cfg +*.egg +MANIFEST + +# PyInstaller +# Usually these files are written by a python script from a template +# before PyInstaller builds the exe, so as to inject date/other infos into it. +*.manifest +*.spec + +# Installer logs +pip-log.txt +pip-delete-this-directory.txt + +# Unit test / coverage reports +htmlcov/ +.tox/ +.nox/ +.coverage +.coverage.* +.cache +nosetests.xml +coverage.xml +*.cover +*.py,cover +.hypothesis/ +.pytest_cache/ +.ruff_cache/ + +# Translations +*.mo +*.pot + +# Django stuff: +*.log +local_settings.py +db.sqlite3 +db.sqlite3-journal + +# Flask stuff: +instance/ +.webassets-cache + +# Scrapy stuff: +.scrapy + +# Sphinx documentation +docs/_build/ + +# PyBuilder +target/ + +# Jupyter Notebook +.ipynb_checkpoints + +# IPython +profile_default/ +ipython_config.py + +# pyenv +.python-version + +# pipenv +# According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control. +# However, in case of collaboration, if having platform-specific dependencies or dependencies +# having no cross-platform support, pipenv may install dependencies that don't work, or not +# install all needed dependencies. +#Pipfile.lock + +# PEP 582; used by e.g. github.com/David-OConnor/pyflow +__pypackages__/ + +# Celery stuff +celerybeat-schedule +celerybeat.pid + +# SageMath parsed files +*.sage.py + +# Environments +.env +.venv +env/ +venv/ +ENV/ +env.bak/ +venv.bak/ + +# Spyder project settings +.spyderproject +.spyproject + +# Rope project settings +.ropeproject + +# mkdocs documentation +/site + +# mypy +.mypy_cache/ +.dmypy.json +dmypy.json + +# Pyre type checker +.pyre/ + +# OSX folder attributes +.DS_Store +.AppleDouble +.LSOverride + +# Thumbnails +._* + +# Files that might appear on external disk +.Spotlight-V100 +.Trashes + +# Windows +Thumbs.db +Desktop.ini + +# Linux +*~ +.directory +.Trash-* + +# local data +data/ + +# Claude working scratchpad (plans, lessons, ephemeral artefacts) +.claude/logs/ +.claude/state/ +.claude/worktrees/ +.developments/ +.plans/ +.notes/ +.reports/ +.temp/ +.tmp/ +_outputs/ +_resolutions/ +_reviews/ +tasks/ +*.local.md + +output/ +notebooks/ +releases/ diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml new file mode 100644 index 0000000..21e49f8 --- /dev/null +++ b/.pre-commit-config.yaml @@ -0,0 +1,85 @@ +default_language_version: + python: python3 + +ci: + autofix_prs: true + autoupdate_schedule: weekly + autofix_commit_msg: "fix(pre_commit): ๐ŸŽจ auto format pre-commit hooks" + autoupdate_commit_msg: "chore(pre_commit): โฌ† pre_commit autoupdate" + +repos: + - repo: https://github.com/pre-commit/pre-commit-hooks + rev: v6.0.0 + hooks: + - id: trailing-whitespace + - id: check-yaml + args: ["--unsafe"] + - id: check-executables-have-shebangs + - id: check-json + - id: check-toml + - id: check-case-conflict + - id: check-added-large-files + args: ["--maxkb=500", "--enforce-all"] + exclude: uv.lock|.*\.ipynb$ + - id: detect-private-key + - id: pretty-format-json + exclude: demo.ipynb + args: ["--autofix", "--no-sort-keys", "--indent=4"] + - id: end-of-file-fixer + - id: mixed-line-ending + + - repo: https://github.com/JoC0de/pre-commit-prettier + rev: fc2da0552b28c24c836d045bfb6c3057b3d11e62 # v3.9.4 + hooks: + - id: prettier + files: \.(ya?ml|toml)$ + # https://prettier.io/docs/en/options.html#print-width + args: ["--print-width=120"] + + - repo: https://github.com/tox-dev/pyproject-fmt + rev: v2.25.1 + hooks: + - id: pyproject-fmt + additional_dependencies: + - "tomli>=2.0.1" + + - repo: https://github.com/abravalheri/validate-pyproject + rev: v0.25 + hooks: + - id: validate-pyproject + + - repo: https://github.com/astral-sh/ruff-pre-commit + rev: v0.15.20 + hooks: + - id: ruff-check + args: ["--fix"] + - id: ruff-format + types_or: [python, pyi, jupyter] + + - repo: https://github.com/executablebooks/mdformat + rev: 1.0.0 + hooks: + - id: mdformat + additional_dependencies: + - "mdformat-mkdocs[recommended]>=2.1.0" + - "mdformat-ruff" + args: ["--number", "--wrap=no"] + exclude: ^(docs/changelog\.md|docs/deprecated\.md)$ + + - repo: https://github.com/pre-commit/mirrors-mypy + rev: v2.1.0 + hooks: + - id: mypy + language_version: python3.11 + additional_dependencies: + - "numpy>=2.0" + - "types-PyYAML" + - "types-requests" + - "types-tqdm" + + - repo: https://github.com/codespell-project/codespell + rev: v2.4.2 + hooks: + - id: codespell + additional_dependencies: + - "tomli>=2.0.1" diff --git a/AGENTS.md b/AGENTS.md new file mode 100644 index 0000000..8b06331 --- /dev/null +++ b/AGENTS.md @@ -0,0 +1,153 @@ +# Agent Guidelines for `supervision` + +Behave like a senior contributor: precise, efficient, maintainable. When this file and [CONTRIBUTING.md](.github/CONTRIBUTING.md) conflict, **CONTRIBUTING.md wins**. + +--- + +## 1. Before You Code + +- Read the task thoroughly; group clarifications into one ask. +- Outline a plan before making changes. +- Check whether the feature already exists under a different name. +- Confirm alignment with `src/supervision/` architecture. + +--- + +## 2. Repository Architecture + +**Package root**: `src/supervision/` โ€” all library code. **Tests**: `tests/` โ€” mirrors `src/supervision/`. **Public API**: `src/supervision/__init__.py`. + +``` +src/supervision/ +โ”œโ”€โ”€ detection/ +โ”‚ โ”œโ”€โ”€ core.py โ€” Detections dataclass; all model connectors as classmethods +โ”‚ โ”œโ”€โ”€ compact_mask.py โ€” compact mask representation +โ”‚ โ”œโ”€โ”€ vlm.py โ€” VLM connectors (Florence-2, Gemini, Qwen, PaliGemma) +โ”‚ โ”œโ”€โ”€ utils/ โ€” pure NumPy helpers: boxes, converters, iou_and_nms, masks, polygons +โ”‚ โ”œโ”€โ”€ line_zone.py โ€” LineZone +โ”‚ โ””โ”€โ”€ tools/ โ€” InferenceSlicer, PolygonZone, CSVSink, JSONSink, DetectionsSmoother +โ”œโ”€โ”€ annotators/core.py โ€” BoxAnnotator, MaskAnnotator, LabelAnnotator, โ€ฆ each: .annotate(scene, detections) +โ”œโ”€โ”€ key_points/ โ€” KeyPoints, EdgeAnnotator, VertexAnnotator (use this, NOT keypoint/ โ€” see ยง4) +โ”œโ”€โ”€ tracker/ โ€” DEPRECATED +โ”œโ”€โ”€ dataset/core.py โ€” DetectionDataset / ClassificationDataset (YOLO / COCO / Pascal VOC) +โ”œโ”€โ”€ geometry/core.py โ€” Point, Rect, Vector, Position +โ”œโ”€โ”€ metrics/ โ€” mAP, confusion matrix (requires --extra metrics) +โ”œโ”€โ”€ utils/internal.py โ€” warn_deprecated, deprecated_parameter, internal helpers +โ””โ”€โ”€ config.py โ€” string constants; always import from here, never use literals +``` + +### Key design patterns + +- **`Detections` is the lingua franca** โ€” every connector, tracker, and annotator speaks `Detections`. New connector = `@classmethod from_(cls, result) -> Detections`. +- **Annotators are composable** โ€” receive `scene` (BGR `np.ndarray`) + `detections`, return annotated copy. +- **`data` dict extensibility** โ€” per-detection metadata in `detections.data` as `np.ndarray` aligned with `xyxy`. Keys are constants from `config.py`. +- **Vectorized throughout** โ€” NumPy arrays, no Python loops in hot paths. Never write `for det in detections`. +- **Lazy-import heavy deps** โ€” `torch`, `transformers`, `ultralytics` must be imported inside the function that needs them, never at module top level. + +--- + +## 3. Agent-Critical Rules + +These supplement [CONTRIBUTING.md](.github/CONTRIBUTING.md) โ€” covering gaps or agent-specific failure modes. + +**Doc headings**: `###` max in docstrings and docs. `####` renders identically to bold in mkdocs โ€” use `**bold**` instead. + +**Type hints**: required on all new code. mypy is enforced by pre-commit (`.pre-commit-config.yaml`). + +**Function docstrings**: every new or modified function, including private helpers and tests, must have a succinct docstring explaining its purpose. Put function-level why/what/how context inside the function docstring, not in a comment before the function. Public APIs still require the full Google-style structure described below. + +**Readable argument lists**: do not put multi-branch conditional expressions inside function or constructor arguments. If an argument needs more than a simple `a if condition else b`, assign it to a named local variable before the call. + +**Inline comments**: write code so the intent is clear from names, small helpers, and straightforward control flow. For non-trivial logic inside a function that still needs context, add concise inline comments explaining why the code exists, what invariant it protects, and how the tricky part works. Do not put comments before functions; use the function docstring instead. Do not comment obvious assignments, mechanical plumbing, lint-only changes, typing-only changes, or pure docs edits. + +**Doctest determinism** โ€” output must be reproducible across platforms: + +- Use `# doctest: +ELLIPSIS` for floats that vary by platform. +- Seed any RNG before calling it. +- Never assert `dict` or `set` iteration order. +- No network or filesystem access outside `supervision/assets/`. + +**โš  Test structure** โ€” agents frequently fail here; read [CONTRIBUTING.md ยงTests](.github/CONTRIBUTING.md#-tests) carefully: AAA structure, class grouping, parametrize with `pytest.param(..., id="slug")`, one-line docstring per test. + +For branching, commit, code style, and API design conventions see [CONTRIBUTING.md](.github/CONTRIBUTING.md). + +--- + +## 4. Deprecated Module Aliases + +`supervision.keypoint` deprecated since `0.27.0`, removed in `0.31.0`. Always import from `supervision.key_points`, not `supervision.keypoint`. + +--- + +## 5. Deprecating APIs + +**Minimum window**: deprecated APIs must remain for at least **3 minor releases** before removal. Example: deprecated in `0.29.0` โ†’ removed in `0.32.0`. + +- Module-level: `supervision.utils.internal.warn_deprecated` in the deprecated module's own `__init__.py` +- Parameter renamed (oldโ†’new): `supervision.utils.internal.deprecated_parameter` decorator +- Public function, method, or class: `@deprecated` from `pydeprecate` + +Always name the version introduced and the removal version: + +```python +warn_deprecated("'foo' deprecated in `0.29.0`, removed in `0.32.0`. Use 'bar'.") +``` + +--- + +## 6. Implementing Features + +- Minimal implementation; type hints and Google docstrings with usage examples. +- Tests covering new functionality and edge cases (see [CONTRIBUTING.md ยงTests](.github/CONTRIBUTING.md#-tests)). +- Update docstrings and mkdocs entries as needed. +- Update [docs/changelog.md](docs/changelog.md) for every functional change or bug fix, including user-visible behavior changes. Skip changelog entries for lint-only, type-only, formatting-only, and pure documentation-only changes. + +**Extending `Detections`**: store metadata in `detections.data` as `np.ndarray` aligned with `xyxy`; define the key as a constant in `config.py` (e.g. `CLASS_NAME_DATA_FIELD`, `ORIENTED_BOX_COORDINATES`). + +**New model connector** (`detection/core.py`): + +```python +@classmethod +def from_myframework(cls, result) -> "Detections": + import myframework # noqa: F401 โ€” lazy import + + xyxy = ... # (N, 4) + return cls( + xyxy=xyxy, + confidence=..., + class_id=..., + data={CLASS_NAME_DATA_FIELD: np.array([...])}, + ) +``` + +VLM connectors go in `detection/vlm.py`, not `core.py`. + +--- + +## 7. Bugs & Refactoring + +**Bugs**: reproduce โ†’ write failing test โ†’ minimal fix โ†’ verify no regressions. + +**Refactoring**: preserve behavior and API; reduce duplication; avoid sweeping changes unless requested; apply ยง5 deprecation when removing public API. + +--- + +## 8. Before You Commit + +```bash +uv run pytest --cov=supervision +uv run pre-commit run --all-files +``` + +Capture a baseline before changes to avoid introducing new failures: + +```bash +STASH_BEFORE=$(git rev-parse refs/stash 2>/dev/null) +git stash push --include-untracked +uv run pytest -q 2>&1 | tee /tmp/baseline.txt +[ "$(git rev-parse refs/stash 2>/dev/null)" != "$STASH_BEFORE" ] && git stash pop +uv run pytest -q 2>&1 | tee /tmp/after.txt +diff /tmp/baseline.txt /tmp/after.txt +``` + +Any test passing in baseline but failing after = blocker. diff --git a/CITATION.cff b/CITATION.cff new file mode 100644 index 0000000..f7b138f --- /dev/null +++ b/CITATION.cff @@ -0,0 +1,23 @@ +# This CITATION.cff file was generated with cffinit. +# Visit https://bit.ly/cffinit to generate yours today! + +cff-version: 1.2.0 +title: Supervision +message: >- + If you use this software, please cite it using the + metadata from this file. +type: software +authors: + - given-names: Roboflow + email: support@roboflow.com +repository-code: 'https://github.com/roboflow/supervision' +url: 'https://roboflow.github.io/supervision/' +abstract: >- + supervision features a range of utilities for use in + computer vision projects, from detections processing and + filtering to confusion matrix calculation. +keywords: + - computer vision + - image processing + - video processing +license: MIT diff --git a/CLAUDE.md b/CLAUDE.md new file mode 100644 index 0000000..2eefdd7 --- /dev/null +++ b/CLAUDE.md @@ -0,0 +1,5 @@ +# Claude Code Project Instructions + + + +@AGENTS.md diff --git a/LICENSE.md b/LICENSE.md new file mode 100644 index 0000000..ab7110e --- /dev/null +++ b/LICENSE.md @@ -0,0 +1,9 @@ +MIT License + +Copyright (c) 2022 Roboflow + +Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. diff --git a/README.md b/README.md new file mode 100644 index 0000000..c8d587e --- /dev/null +++ b/README.md @@ -0,0 +1,321 @@ +
+

+ + + +

+ +
+ +[notebooks](https://github.com/roboflow/notebooks) | [inference](https://github.com/roboflow/inference) | [autodistill](https://github.com/autodistill/autodistill) | [maestro](https://github.com/roboflow/multimodal-maestro) + +
+ +[![version](https://badge.fury.io/py/supervision.svg)](https://badge.fury.io/py/supervision) [![downloads](https://img.shields.io/pypi/dm/supervision)](https://pypistats.org/packages/supervision) [![license](https://img.shields.io/pypi/l/supervision)](LICENSE.md) [![python-version](https://img.shields.io/pypi/pyversions/supervision)](https://badge.fury.io/py/supervision) [![codecov](https://codecov.io/gh/roboflow/supervision/graph/badge.svg?token=HMNJ5FVZ36)](https://codecov.io/gh/roboflow/supervision) + +[![snyk](https://snyk.io/advisor/python/supervision/badge.svg)](https://snyk.io/advisor/python/supervision) [![colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/roboflow/supervision/blob/main/demo.ipynb) [![gradio](https://img.shields.io/badge/%F0%9F%A4%97%20Hugging%20Face-Spaces-blue)](https://huggingface.co/spaces/Roboflow/Annotators) [![discord](https://img.shields.io/discord/1159501506232451173?logo=discord&label=discord&labelColor=fff&color=5865f2&link=https%3A%2F%2Fdiscord.gg%2FGbfgXGJ8Bk)](https://discord.gg/GbfgXGJ8Bk) + +
+ roboflow%2Fsupervision | Trendshift +
+ +
+ +
+๐Ÿ“‘ Table of Contents + +- [๐Ÿ‘‹ Hello](#-hello) +- [๐Ÿ’ป Install](#-install) +- [๐Ÿ”ฅ Quickstart](#-quickstart) + - [Models](#models) + - [Annotators](#annotators) + - [Datasets](#datasets) +- [๐ŸŽฌ Tutorials](#-tutorials) +- [๐Ÿ’œ Built with Supervision](#-built-with-supervision) +- [๐Ÿ“š Documentation](#-documentation) +- [๐Ÿ† Contribution](#-contribution) + +
+ +## ๐Ÿ‘‹ Hello + +**We are your essential toolkit for computer vision.** From data loading to real-time zone counting, we provide the building blocks so you can focus on building applications around your models. ๐Ÿค + +## ๐Ÿ’ป Install + +Pip install the supervision package in a [**Python>=3.10**](https://www.python.org/) environment. + +```bash +pip install supervision +``` + +Read more about conda, mamba, and installing from source in our [guide](https://roboflow.github.io/supervision/). + +## ๐Ÿ”ฅ Quickstart + +### Models + +Supervision was designed to be model agnostic. Just plug in any classification, detection, or segmentation model. For your convenience, we have created [connectors](https://supervision.roboflow.com/latest/detection/core/#detections) for the most popular libraries like Ultralytics, Transformers, MMDetection, or Inference. Other integrations, like `rfdetr`, already return `sv.Detections` directly. + +Install the optional dependencies for this example with `pip install pillow rfdetr`. + +```python +import supervision as sv +from PIL import Image +from rfdetr import RFDETRSmall + +image = Image.open("path/to/image.jpg") +model = RFDETRSmall() +detections = model.predict(image, threshold=0.5) + +len(detections) +# 5 +``` + +
+๐Ÿ‘‰ more model connectors + +- inference + + Running with [Inference](https://github.com/roboflow/inference) requires a [Roboflow API KEY](https://docs.roboflow.com/api-reference/authentication#retrieve-an-api-key). + + ```python + import supervision as sv + from PIL import Image + from inference import get_model + + image = Image.open("path/to/image.jpg") + model = get_model(model_id="rfdetr-small", api_key="ROBOFLOW_API_KEY") + result = model.infer(image)[0] + detections = sv.Detections.from_inference(result) + + len(detections) + # 5 + ``` + +
+ +### Annotators + +Supervision offers a wide range of highly customizable [annotators](https://supervision.roboflow.com/latest/detection/annotators/), allowing you to compose the perfect visualization for your use case. + +```python +import cv2 +import supervision as sv + +image = cv2.imread("path/to/image.jpg") +# Assuming detections are obtained from a model +detections = sv.Detections(...) + +box_annotator = sv.BoxAnnotator() +annotated_frame = box_annotator.annotate(scene=image.copy(), detections=detections) +``` + +https://github.com/roboflow/supervision/assets/26109316/691e219c-0565-4403-9218-ab5644f39bce + +### Datasets + +Supervision provides a set of [utils](https://supervision.roboflow.com/latest/datasets/core/) that allow you to load, split, merge, and save datasets in one of the supported formats. + +```python +import supervision as sv +from roboflow import Roboflow + +project = Roboflow().workspace("WORKSPACE_ID").project("PROJECT_ID") +dataset = project.version("PROJECT_VERSION").download("coco") + +ds = sv.DetectionDataset.from_coco( + images_directory_path=f"{dataset.location}/train", + annotations_path=f"{dataset.location}/train/_annotations.coco.json", +) + +path, image, annotation = ds[0] +# loads image on demand + +for path, image, annotation in ds: + # loads image on demand + pass +``` + +
+๐Ÿ‘‰ more dataset utils + +- load + + ```python + dataset = sv.DetectionDataset.from_yolo( + images_directory_path=..., + annotations_directory_path=..., + data_yaml_path=..., + ) + + dataset = sv.DetectionDataset.from_pascal_voc( + images_directory_path=..., + annotations_directory_path=..., + ) + + dataset = sv.DetectionDataset.from_coco( + images_directory_path=..., + annotations_path=..., + ) + ``` + +- split + + ```python + train_dataset, test_dataset = dataset.split(split_ratio=0.7) + test_dataset, valid_dataset = test_dataset.split(split_ratio=0.5) + + len(train_dataset), len(test_dataset), len(valid_dataset) + # (700, 150, 150) + ``` + +- merge + + ```python + ds_1 = sv.DetectionDataset(...) + len(ds_1) + # 100 + ds_1.classes + # ['dog', 'person'] + + ds_2 = sv.DetectionDataset(...) + len(ds_2) + # 200 + ds_2.classes + # ['cat'] + + ds_merged = sv.DetectionDataset.merge([ds_1, ds_2]) + len(ds_merged) + # 300 + ds_merged.classes + # ['cat', 'dog', 'person'] + ``` + +- save + + ```python + dataset.as_yolo( + images_directory_path=..., + annotations_directory_path=..., + data_yaml_path=..., + ) + + dataset.as_pascal_voc( + images_directory_path=..., + annotations_directory_path=..., + ) + + dataset.as_coco( + images_directory_path=..., + annotations_path=..., + ) + ``` + +- convert + + ```python + sv.DetectionDataset.from_yolo( + images_directory_path=..., + annotations_directory_path=..., + data_yaml_path=..., + ).as_pascal_voc( + images_directory_path=..., + annotations_directory_path=..., + ) + ``` + +
+ +## ๐ŸŽฌ Tutorials + +Want to learn how to use Supervision? Explore our [how-to guides](https://supervision.roboflow.com/develop/how_to/detect_and_annotate/), [end-to-end examples](./examples), [cheatsheet](https://roboflow.github.io/cheatsheet-supervision/), and [cookbooks](https://supervision.roboflow.com/develop/cookbooks/)! + +
+ +

+Dwell Time Analysis with Computer Vision | Real-Time Stream Processing +Dwell Time Analysis with Computer Vision | Real-Time Stream Processing +

Created: 5 Apr 2024
+
Learn how to use computer vision to analyze wait times and optimize processes. This tutorial covers object detection, tracking, and calculating time spent in designated zones. Use these techniques to improve customer experience in retail, traffic management, or other scenarios.

+ +
+ +

+Speed Estimation & Vehicle Tracking | Computer Vision | Open Source +Speed Estimation & Vehicle Tracking | Computer Vision | Open Source +

Created: 11 Jan 2024
+
Learn how to track and estimate the speed of vehicles using YOLO, ByteTrack, and Roboflow Inference. This comprehensive tutorial covers object detection, multi-object tracking, filtering detections, perspective transformation, speed estimation, visualization improvements, and more.

+ +## ๐Ÿ’œ Built with Supervision + +Did you build something cool using supervision? [Let us know!](https://github.com/roboflow/supervision/discussions/categories/built-with-supervision) + +https://user-images.githubusercontent.com/26109316/207858600-ee862b22-0353-440b-ad85-caa0c4777904.mp4 + +https://github.com/roboflow/supervision/assets/26109316/c9436828-9fbf-4c25-ae8c-60e9c81b3900 + +https://github.com/roboflow/supervision/assets/26109316/3ac6982f-4943-4108-9b7f-51787ef1a69f + +## ๐Ÿ“š Documentation + +Visit our [documentation](https://roboflow.github.io/supervision) page to learn how supervision can help you build computer vision applications faster and more reliably. + +## ๐Ÿ† Contribution + +We love your input! Please see our [contributing guide](.github/CONTRIBUTING.md) to get started. Thank you ๐Ÿ™ to all our contributors! + +

+ + + +

+ +
+ + diff --git a/README.wehub.md b/README.wehub.md new file mode 100644 index 0000000..6d6fc6a --- /dev/null +++ b/README.wehub.md @@ -0,0 +1,7 @@ +# WeHub ๆฅๆบ่ฏดๆ˜Ž + +- ๅŽŸๅง‹้กน็›ฎ๏ผš`roboflow/supervision` +- ๅŽŸๅง‹ไป“ๅบ“๏ผšhttps://github.com/roboflow/supervision +- ๅฏผๅ…ฅๆ–นๅผ๏ผšไธŠๆธธ้ป˜่ฎคๅˆ†ๆ”ฏ็š„ๆœ€ๆ–ฐๅฟซ็…ง +- ๅŽŸไฝœ่€…ใ€็‰ˆๆƒๅ’Œ่ฎธๅฏ่ฏไฟกๆฏไปฅๅŽŸๅง‹ไป“ๅบ“ๅŠๆœฌไป“ๅบ“ LICENSE ไธบๅ‡† +- ๆœฌๆ–‡ไปถไป…็”จไบŽ่ฎฐๅฝ•ๆฅๆบ๏ผŒไธไปฃ่กจ WeHub ๆ˜ฏๅŽŸ้กน็›ฎไฝœ่€… diff --git a/demo.ipynb b/demo.ipynb new file mode 100644 index 0000000..453c801 --- /dev/null +++ b/demo.ipynb @@ -0,0 +1,1481 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "EM54mpHhLjIk" + }, + "source": [ + "[![Supervision](https://media.roboflow.com/open-source/supervision/rf-supervision-banner.png?updatedAt=1678995927529)](https://github.com/roboflow/supervision)\n", + "\n", + "# Supervision Quickstart\n", + "\n", + "---\n", + "\n", + "[![version](https://badge.fury.io/py/supervision.svg)](https://badge.fury.io/py/supervision)\n", + "[![downloads](https://img.shields.io/pypi/dm/supervision)](https://pypistats.org/packages/supervision)\n", + "[![license](https://img.shields.io/pypi/l/supervision)](https://github.com/roboflow/supervision/blob/main/LICENSE.md)\n", + "[![python-version](https://img.shields.io/pypi/pyversions/supervision)](https://badge.fury.io/py/supervision)\n", + "[![GitHub](https://badges.aleen42.com/src/github.svg)](https://github.com/roboflow/supervision)\n", + "\n", + "We write your reusable computer vision tools. Whether you need to load your dataset from your hard drive, draw detections on an image or video, or count how many detections are in a zone. You can count on us! ๐Ÿค\n", + "\n", + "We hope that the resources in this notebook will help you get the most out of Supervision. Please browse the Supervision [Docs](https://roboflow.github.io/supervision/) for details, raise an [issue](https://github.com/roboflow/supervision/issues) on GitHub for support, and join our [discussions](https://github.com/roboflow/supervision/discussions) section for questions!\n", + "\n", + "## Table of contents\n", + "\n", + "- Before you start\n", + "- Install\n", + "- Detection API\n", + " - Plug in your model\n", + " - YOLO-NAS\n", + " - YOLOv8\n", + " - Annotate\n", + " - `BoxAnnotator`, `LabelAnnotator`\n", + " - `MaskAnnotator`\n", + " - Filter\n", + " - By index, index list and index slice\n", + " - By `class_id`\n", + " - By `confidence`\n", + " - By advanced logical condition\n", + "- Video API\n", + " - `VideoInfo`\n", + " - `get_video_frames_generator`\n", + " - `VideoSink`\n", + "- Dataset API\n", + " - `DetectionDataset.from_yolo`\n", + " - Visualize annotations\n", + " - `split`\n", + " - `DetectionDataset.as_pascal_voc`\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "qko8PawxQVoS" + }, + "source": [ + "## โšก Before you start\n", + "\n", + "**NOTE:** In this notebook, we aim to show - among other things - how simple it is to integrate `supervision` with popular object detection and instance segmentation libraries and frameworks. GPU access is optional but will certainly make the ride smoother.\n", + "\n", + "
\n", + "\n", + "Let's make sure that we have access to GPU. We can use `nvidia-smi` command to do that. In case of any problems navigate to `Edit` -> `Notebook settings` -> `Hardware accelerator`, set it to `GPU`, and then click `Save`." + ] + }, + { + "cell_type": "code", + "execution_count": 51, + "metadata": { + "id": "1Pwtk-9CQWsH" + }, + "outputs": [], + "source": [ + "!nvidia-smi" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "d9ZN87GAnqxm" + }, + "source": [ + "**NOTE:** To make it easier for us to manage datasets, images and models we create a `HOME` constant." + ] + }, + { + "cell_type": "code", + "execution_count": 52, + "metadata": { + "id": "dwGOFWdJnr3T" + }, + "outputs": [], + "source": [ + "import os\n", + "\n", + "HOME = os.getcwd()\n", + "print(HOME)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "A6a80OsDrJ1y" + }, + "source": [ + "**NOTE:** During our demo, we will need some example images." + ] + }, + { + "cell_type": "code", + "execution_count": 53, + "metadata": { + "id": "1oeBxRj5wOv7" + }, + "outputs": [], + "source": [ + "!mkdir {HOME}/images" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "rGSeabT2wfQi" + }, + "source": [ + "**NOTE:** Feel free to use your images. Just make sure to put them into `images` directory that we just created. โ˜๏ธ" + ] + }, + { + "cell_type": "code", + "execution_count": 54, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "fDC5HwaXwUyl", + "outputId": "e669fe2b-6c1e-4ad1-aead-63dd5304049b" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Thu Jul 11 20:48:14 2024 \n", + "+---------------------------------------------------------------------------------------+\n", + "| NVIDIA-SMI 535.104.05 Driver Version: 535.104.05 CUDA Version: 12.2 |\n", + "|-----------------------------------------+----------------------+----------------------+\n", + "| GPU Name Persistence-M | Bus-Id Disp.A | Volatile Uncorr. ECC |\n", + "| Fan Temp Perf Pwr:Usage/Cap | Memory-Usage | GPU-Util Compute M. |\n", + "| | | MIG M. |\n", + "|=========================================+======================+======================|\n", + "| 0 Tesla T4 Off | 00000000:00:04.0 Off | 0 |\n", + "| N/A 72C P0 32W / 70W | 473MiB / 15360MiB | 0% Default |\n", + "| | | N/A |\n", + "+-----------------------------------------+----------------------+----------------------+\n", + " \n", + "+---------------------------------------------------------------------------------------+\n", + "| Processes: |\n", + "| GPU GI CI PID Type Process name GPU Memory |\n", + "| ID ID Usage |\n", + "|=======================================================================================|\n", + "+---------------------------------------------------------------------------------------+\n", + "/content/datasets/images\n", + "/content/datasets/images/images\n" + ] + } + ], + "source": [ + "%cd {HOME}/images\n", + "\n", + "!wget -q https://media.roboflow.com/notebooks/examples/dog.jpeg\n", + "!wget -q https://media.roboflow.com/notebooks/examples/dog-2.jpeg\n", + "!wget -q https://media.roboflow.com/notebooks/examples/dog-3.jpeg\n", + "!wget -q https://media.roboflow.com/notebooks/examples/dog-4.jpeg\n", + "!wget -q https://media.roboflow.com/notebooks/examples/dog-5.jpeg\n", + "!wget -q https://media.roboflow.com/notebooks/examples/dog-6.jpeg\n", + "!wget -q https://media.roboflow.com/notebooks/examples/dog-7.jpeg\n", + "!wget -q https://media.roboflow.com/notebooks/examples/dog-8.jpeg" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "-hKaZ9NuMofm" + }, + "source": [ + "## โ€๐Ÿ’ป Install" + ] + }, + { + "cell_type": "code", + "execution_count": 55, + "metadata": { + "id": "Lo8hLtZ2LPWp" + }, + "outputs": [], + "source": [ + "!pip install -q supervision\n", + "\n", + "import supervision as sv\n", + "\n", + "print(sv.__version__)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "2MSBh8-tYuHP" + }, + "source": [ + "## ๐Ÿ‘๏ธ Detection API\n", + "\n", + "- xyxy `(np.ndarray)`: An array of shape `(n, 4)` containing the bounding boxes coordinates in format `[x1, y1, x2, y2]`\n", + "- mask: `(Optional[np.ndarray])`: An array of shape `(n, W, H)` containing the segmentation masks.\n", + "- confidence `(Optional[np.ndarray])`: An array of shape `(n,)` containing the confidence scores of the detections.\n", + "- class_id `(Optional[np.ndarray])`: An array of shape `(n,)` containing the class ids of the detections.\n", + "- tracker_id `(Optional[np.ndarray])`: An array of shape `(n,)` containing the tracker ids of the detections." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "yNKUkCHQchnb" + }, + "source": [ + "### ๐Ÿ”Œ Plug in your model\n", + "\n", + "**NOTE:** In our example, we will focus only on integration with YOLO-NAS and YOLOv8. However, keep in mind that supervision allows seamless integration with many other models like SAM, Transformers, and YOLOv5. You can learn more from our [documentation](https://roboflow.github.io/supervision/detection/core/#detections)." + ] + }, + { + "cell_type": "code", + "execution_count": 96, + "metadata": { + "id": "0ZlmuEpwydTu" + }, + "outputs": [], + "source": [ + "import cv2\n", + "\n", + "IMAGE_PATH = f\"{HOME}/images/dog.jpeg\"\n", + "\n", + "image = cv2.imread(IMAGE_PATH)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "D6FgJfB1oIll" + }, + "source": [ + "### YOLO-NAS [๐Ÿ“š](https://roboflow.github.io/supervision/detection/core/#supervision.detection.core.Detections.from_yolo_nas)" + ] + }, + { + "cell_type": "code", + "execution_count": 57, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "U-q_XWoIOJgL", + "outputId": "bbff96b6-f1dd-41af-e32f-42b37a208bb5" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.21.0\n" + ] + } + ], + "source": [ + "!pip install -q super-gradients" + ] + }, + { + "cell_type": "code", + "execution_count": 58, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "BNcKtoW63g96", + "outputId": "bf7dbb2c-44b2-45d7-bed3-715d0dfac0a2" + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[2024-07-11 20:48:37] WARNING - checkpoint_utils.py - :warning: The pre-trained models provided by SuperGradients may have their own licenses or terms and conditions derived from the dataset used for pre-training.\n", + " It is your responsibility to determine whether you have permission to use the models for your use case.\n", + " The model you have requested was pre-trained on the coco dataset, published under the following terms: https://cocodataset.org/#termsofuse\n", + "[2024-07-11 20:48:37] INFO - checkpoint_utils.py - License Notification: YOLO-NAS pre-trained weights are subjected to the specific license terms and conditions detailed in \n", + "https://github.com/Deci-AI/super-gradients/blob/master/LICENSE.YOLONAS.md\n", + "By downloading the pre-trained weight files you agree to comply with these terms.\n", + "[2024-07-11 20:48:38] INFO - checkpoint_utils.py - Successfully loaded pretrained weights for architecture yolo_nas_l\n", + "[2024-07-11 20:48:38] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n" + ] + } + ], + "source": [ + "from super_gradients.training import models\n", + "\n", + "model = models.get(\"yolo_nas_l\", pretrained_weights=\"coco\")\n", + "result = model.predict(image)\n", + "detections = sv.Detections.from_yolo_nas(result)" + ] + }, + { + "cell_type": "code", + "execution_count": 59, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "jdOW9a0P30ar", + "outputId": "a42af3af-b616-4015-90f9-5f6d11e29ecb" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "('detections', 7)" + ] + }, + "execution_count": 59, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "\"detections\", len(detections)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "eOQdWaHDoNyw" + }, + "source": [ + "### Ultralytics [๐Ÿ“š](https://roboflow.github.io/supervision/detection/core/#supervision.detection.core.Detections.from_ultralytics)" + ] + }, + { + "cell_type": "code", + "execution_count": 60, + "metadata": { + "id": "gNU2p-FYoPbg" + }, + "outputs": [], + "source": [ + "!pip install -q \"ultralytics<=8.3.40\"" + ] + }, + { + "cell_type": "code", + "execution_count": 97, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "PMx3oMPh1fui", + "outputId": "530b0cf8-d792-4723-b2f3-a6cb3d677344" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Downloading https://github.com/ultralytics/assets/releases/download/v8.2.0/yolov8m.pt to 'yolov8m.pt'...\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r 0%| | 0.00/49.7M [00:00" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "box_annotator = sv.BoxAnnotator()\n", + "label_annotator = sv.LabelAnnotator()\n", + "\n", + "annotated_image = box_annotator.annotate(image.copy(), detections=detections)\n", + "annotated_image = label_annotator.annotate(annotated_image, detections=detections)\n", + "\n", + "sv.plot_image(image=annotated_image, size=(8, 8))" + ] + }, + { + "cell_type": "code", + "execution_count": 64, + "metadata": { + "id": "h5ZszOmJiLKp" + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "a94r3v6M6l7o" + }, + "source": [ + "**NOTE:** By default `sv.LabelAnnotator` use corresponding `class_id` as label, however, the labels can have arbitrary format." + ] + }, + { + "cell_type": "code", + "execution_count": 65, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 653 + }, + "id": "ZrqRqzEV54hj", + "outputId": "ba661741-407f-4fb1-b5c9-d9245d98df1b" + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAW4AAAJ8CAYAAADeVEuCAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOz9Wa8lSZImiH2ianaWu/gS4R6RkZFLZVVWFbsbzQFZgybYTRAECPKBy2+Yv8E3/gQC8z58JAG+DAhwBiAbHICYwWDY6J7uqu5aujKrKisjI2P17W5nMVOVeRAV3Uzt3HOvu8eS7Zrpce89x0x3/UTkU1FRYmbGu/QuvUvv0rv0vUnm267Au/QuvUvv0rt0t/QOuN+ld+ldepe+Z+kdcL9L79K79C59z9I74H6X3qV36V36nqV3wP0uvUvv0rv0PUvvgPtdepfepXfpe5beAfe79C69S+/S9yy9A+536V16l96l71l6B9zv0rv0Lr1L37PUHfvg/+k/+xfF3957EBEAwBChM0kG6GHMrutgrYWxgH6t3zFz/OdHBwAgovjPWgtjDIwBrDEIRYGIYIyJZXP4570HM8M5B+99/JtBACjWjYjAzBjHEePoMDjA+/SePtNK9SFT9ijyLr4DwAR4pPZOHqjqdqisVop9cMfDr3d5/k0crJ32Z7vN8pVH6JyYZB4YWCJ0YUTrvPO5kydmjnMhf6b1fP2uvic/HUA+9ofOQa1bnV89j1tlxvmPAWz2wHgO60/Q4RI3F3+Bv/vFv8CvfvFL/PCjP8SD93+KVxdXuN7u8eC9p/joxz/Bkw8+gu0X8Fz2WL628vHTv8dxLOqZ17duv3cEZgLAkKzkp+ZlLWBMuy+tMXEs674xxoRx9MUY5/UEE4yx8T3nXFi342Q887Ywc1xauradY3inbSCAHJhdxDFrLbquQ9d1oW4MY8pxas2RvMwcl+pxyPvAuzS3ChwMn/2f/5P/OW5LRwP3fRawVgYEMANE08bocwqoeVnSCQbMHsB0Yt0nFZ1oDDAmsH4T+b9Lx6QDc6maZ2QIBF2g01fruVO8Gz6v55t+Ny26/YzMFQuAwlxEE7DzfzWwt+oQy4EFsACDQWYHN1zi5cXX+Orr53j48EP85Kd/jPc/+hludntcb3c4OXuA1dkDmG4B58PCOpBqZakF1i1AknYDxDosunb0bwIRF/kXwAVVukphVfZ1Wbfimep5Bba6XXVbjDFgMDwn5RJZ3VRA+AwLFLitDYIijHNets6nFla0FIiW0FSh0pqzd8Gftw7cogUzKKusarZA+EweLj7z3sM5ByJpaC3N7pNq6eadh68k4rvQLW87He7fmrszAAwBBhS+m1+4rbFrAYL+fsx80kUtlgDgfdIYrbWTZ+c08FnQJgJg4UcDYg9jLrEdvsSzZ59hGIGf/PiP8fjpT9GdnuPheYcHZOBhwWThADhmGA5WyIHm5HP/GG07tocAEAUtWyVnek8E2bSPKaA7kSnyy+sjn02VudhXDDCy9ZpZ0nU++nvOAoAA54LVxF5M4CBsyBDgkzYfNW3tCyJQ1m8K3DrPWmNfC+5a246WHyiC933T0cB9n5RMHgYTonT23ofxl05EPthIjRSTzoKsOQpQm8+Ewc+f0bxH5wE2Rdlzi7/992sIkob2eNf0vRUyxJNxSdoQyaIDZN7ILyB4mS+6pmvtLJiqeToE1Ic04LxOcU4aU3yWm/Z5/vWibZU7aTM6GNOD+ApueIbnz36Fly+f4dF7H+HR059icfY+uOsDJSLav9IjHMue5l+3dU5DndO6Q+XiPE2adqJHANs095k5gm7dp0mjTmu/ZYWrqZ4D99yYiYLo0rhkLCSzD/8AggEziSJgCMzTbT5mhqn6s55nLcvlEE1S/t3u77us5zcG3C1wSxUjpDES05fBYM/wYHSGokZea07ee7CZdkpuArlqUEtNJ72j3+uzhgh8i0b0plLbNH+rRX63EylXLRKMCDDGojOiLRUaSqBJ5sRkbsHVmhAw1Sh1rMWim+fG9V1jTNAeS4qklXdL85/7O5YNhgXBYI+r66/w5eefAGzw5MmP8fjpx+BuCQ9hgxkMOCeiTOkLCgLuIAOVtEYAE8Gj9Zn8Hdat1Fn2jKLGiLRec0tafzdE8OSLPsrH6rZEmNIr+n6xz1UBpLQTQbNmGAtYpmAtQeifQMHl789SG0jjWpeZa+k1R1/nF4Va1k+tco5Jbw248wa2FkUulUFJrOcSrX42LydtPiJK47zcVBHJup448i5N5npe9m1tPCbNDcRtWb2ONL4tvc2858oIJYV/OYCo+UqwRja0bEBpQyQ8ZbW5fKjex2jRh57PATkHJAPAdHfb3MzLaGm8JmrxHuAB+/0rPPvqU7x69gIfPP0D/OCjn2FxeoY9i2WYa6gEhokbhlPMbmuw8xTRHF3CQahq0WFVB/BmeJ/KMMbAOVetUR/bOukvlHxvLlhi6XycdVTjA7wINOgmozUBzE3YMLaRpqmFSXPmNjCoLrdlTRWOEvoMm8m7dX63pTcC3AqgdaVr06B8J9OGvRfOCSgGWBp8C3gjmYutVE9G1cgkPwBkMo0ilVULAp3wb1sz/91PqlnoIjKBMiN0xqI3EOAGwIbhfT3BSzP1kHZ7SHupNak86RwstCCaeqWYij5pLcRWvaafeXi/wcsXX+DLz3+L9fIMH37wU5yevQ9vAWIGOx8WTdAmdaOUGY4JvuE5Naf8tIRNaaXWfah/axsVwaceMpqiZkxlGUU/E0Vvs7zOiW6aB8ZWmgpl9RgR0DZe5pwxNm1QZpuOh9Ih4J77XEHbOVd8nyyZKQ3zjQI3MG+lRRNLbTkGUHWw7ox3oUNjXoFTi+AcSkpClWVzUR/P6JOURbCxWcowWdnsGeQpAr/nzJSjROhJHoFvu7XF9008/et3QEaUYEGRe6TAMRpjZHGDYE1uAhMoCH3PwbwkKrTvQ2BYm7apDii+P6SBFlQCtU3Z22iS8A2ILDgQHkzSLoKFYQt4h83Vb/DlZ7/GzY3Djz7+Oc7f+xjUr7AfHJgcDILCEddQvioCEMSNw7RoxDQPUzlbewkkyg3Eui/lcW17Wsv6nbS5DToc1pxUL9PUVBtlBrHRVkXLmCh4fPhU1nz9SssoavdA4KnVmoPsTcKIp4uhsNfGiF5r0LbebpFGpZPF6rA2TGwW+pc9Ywwuxuw57ucQCGQ40MWl0suhvseko4H7oPaCEmOk00hfhFIi3oeFkpHzcUHDAmSFNmGAjIFhBsgHf2htEqWd5oYWwdnkICgAKBDKdwZCdHnyIBPqBQAkm6ixIwHAZ9oCAcSZn/HBPi6tkDoRSXPj0/UE5WkBc1rmt5GO5eIm78XdLgMLAxvGh+DFcYNspj0SYCzYOTCZNH4ZnTVn4ms6pq9q2qNNhfgAXMdrSCWtEzhq48Hk0ZsOxgPGAW53g+sXv8SLZ5/j5PyHWL/3M/j1Q+yIYMgGHKZAK1IC4SAImcVlVnEygQrEf9mLLzaRCEkFdO9FE7R2vg+5mIe6F1Vq8S1TXwEYJlsJlD7X+T46Hz8Tvh9B0HgR1jy1ClqWRE21WGMBNqHdmTspRAApsDPpRiQDEJDNhVu+z5LGlBRl4R3A3sOQDUAsLI3z0ja17JVSIgKM0k9AxDCpnzkWt9+uV0meWoMcUzFp8g5OiwZI2nDOG+X82Vy5UfOoyk88q7h5GRA8sQAJZQj+LaSo5f/OpXKs1YqRtZO7baUUNeM6pztSV+qDHRehUcpDQY0C+B3n038saItWq4t1AWIGeVECmK9xff0FvvzyKwAdnn74Qzx+70mmySKBNfRnLRSmAkV/CqDTBHwyvereiYiiLzQXAKTjokoZ4u+pHXIgBpmvdS4sOTReN0B1jeebzzVwl4rPVHOu657/zPPLU+szUYzLvMdxTM9TELScBFRNI9UceN7+Y9I3Dtz6e55cxSfnu7MIGyEcbCmVXuOo2oKF92q2ATnwq/mVl137kBcSHAraARRIM/kWEiXjDfhuaNlvI6klxEqBeS7Wm2o9gFhhqBfRhNecCuaiNMpd2VCAAgXXtvn3q9yOBW4CiDwMGzA6EFsQj4C/xH77Nb766pd48eoaj578AI/ff4pusQBM0KKzqqvlSjUgcXt9ad85R5HmUOog1z7vkmqQVO2/Bu7YB0HwKJ2jQkg3LqMy3tCkKazllm98vuFXe5oYY4L75nHWlrV2UnauGE7Au1qb+p5zDjpCtdauv6efOXA7JNx6i8Bdazo1XaGf6XN5J7dSmmBu8jkIsGRAlPvG6jFcPRCRBKCsbUFcVtulIZVzDjSaatA5ltma3xJ4Thbn9zjNAaD3iRRRKg2QSQxMQVi1sPq7uTImGgwJgNXufOGrWe+VPB2aw80yY2tUmyAYJhgw/HCDy5ef4tmXf4/l6jF+8NHPcPbgEdgYMAV+F4hUX9TgAjmZKx41WOfgVlIdeRtTvfJ21V5deRsna5nT+y2hx7kcDkDOLLz7Ic2IiGBI+OgU/qLcNK411eK0KhnooanWWNbjlfdX7ZiQ97NSJbMKQ6Xo53VNY5X3GeB9aZ0dk+4E3HVD8oq1wDtPB0Gvyq/QiqO5VTY2/Z00c/k7bHaEiWTA2Xvpdx3gWEocZ2723d1Bm6Kicez70wV/u9A4NBZH1/ROWuvd0hTIciDw8SSiB4v3RDa2kzoEJJua5JJafskFv0k+UBZTb4hUbumqlTLj6H97fFvjN1Jvz2C/BxPBmhHbzQWeff4p/Ojw9KMf4cGjD2C6JTxZeB/qHPZfdOO8bi/RVAvO6y99lX82vz6Z0yGm1pzKzXr5UP6T1mBrnZnsd6DmjNGYq9qPnbUFaJeWuCTv/UQQa79QYz40rYKszLx9dZ/m86tFVaXvUvfM0XnKeTPL+YW7rt17UyV5J7yuJkpomyhx8vgUV0CCxvgQMIYn81BO2KW/OdsIANoTjAgAp01PzoD/m9J8Jwuev5lyv+3EymeFfz4DmmM4vxY/Wr8XzWzjoD7k9SKF0nENEJSvGXoEpi6/Vc/J+2zA3sHzFuABu/01nn/9W1y8eIn3H32IDz78PazWD+CCmW2sFEcQqzI/ZJZAVeufFJdWYs7AJIIzV30vqXUeQvsj99GObZ4pVl15E0VT5mXCoTvT6DtjjAR8shaGkhbdSjXVEetO2rb0Wa6V1yk/DdmiY27DuEJxpbQXoZ8V50NYqaPwDjQgDJK1f0t6LeDWCr8J8BatwoOyXeDka5ntwoYoX855qGtUy2yOGhl5EKZaFnSDJOTtOW20IBuo1yZHQgYinA48R9VieSOFf9dStoij8sfBnA4EAHvwgYVapxq4rbUgI2Z2+Vz8z+RdABG0vZ96EsjDDGPmtcND5jhAILZgdmDegXGNy4sv8Pyr32JhVvjg/R/h/Px94b8NgYNVIEcj9V+5QZlbmUSHNrd087WMo6LKCRqKTb2mc227VqrmUgK7vL55MjBG3PRqbdkGTbsLkQHntNsarOcsu1hiFvBrLuW4Q0RRWNVzZXTjpL36jmyjT+uWHxoM3wQD/7DbYyvdCbhVWpc8mfxem1j6fAtU684flV8OzmJqsKrGy2HDSoF29GVwqJJaSVKPiGADdxkHNuP1nJeO85mmr77hqlwVoQyYo7AE3y4c6+/rqc7R8a1hNjIm4TpLKXA7jfKtpVbDM+vGUnQITeBAWceiXCTKKwrMcIa/aYGQofCPYYxoem0GlYqfkrf2a3JLm8xdBoRPoyxfBrPsv6Q5lrcrzUvHAJFFzx12Nxd4/uwXuNp/iacf/AOcPP1DoF/AG4aBukcCMATnAU8sNI8R/2AEGs7H3y2SBl1uysl6ZRgb/OYJZR0Z8C6dXRCAEVdBCv1dxwnJgdbHDVTOfnKIKqiLR7VWH6gBqaOANMU1GykRq9RIbnX7OP6evZTLXoEj6/s0zipwDmnacXgrqqKmVXLNm3VtpmmjlUj/JLOZtRmcm8OjXOHZMeleHLc2sAXg+l1NScw+i9ABBFjIAhZNOS1WH3w9PTNG75JjO1pgGMcyAr8JVokKh1Q/BmDgXF5fRFCOR+Izziq0QP5fsjKlBjDtvaqiucaECSXjkY8/F69TbPjboVNu06YOp0y45J+Fv62heDISAMQHmSNoJOFFdSbx4/hE3gdRKHsIeOmBnerlSuPO6TLW9+ZaxiTzp86PRcsi9TUn7YdktTEx2I3AfoPLl1/i5bMvsTw5wYOnH4NOHsEFSiGGItVuNAHISQSSnmdINAeitkah3ASs4Z9BOD1IqdqZ4cPx2HpjzWZ5qivedH5wAdv6vAmnXqSPHdLZNmmLnERP4CwHsiTsgf6uY5Ti2vv4Lz8UVbddG1pTJMfQHtoHMZfa+mCG8zShlVrWQesEtoJ/0Xt8eP+kTkcD97Gma56O7aRbMgm8Z+h0De9Yc1oHU/q+3hVnnu5O52/lJy0zWio83xActYUx16wMrFump802Yg5FRfu+pJJ/Lj8HSk1H04Su+JbThEdtfp8EQZ6EZdlgs/sMX379KcbxBB9+9A/x6NFHgBkB2Cqf7F0jWjUHAAfnm1u5EiJHyPUCgFDTcJHJYW0z/1e415nshGsjrngNSPpZ1KDJFl4u+r3SIdYm+ib31c415NpL5lhcybX4up1vIrXyy9tea/HpnTKfvH7Hzvc7A3eLA6sLqyfC6y2+zHyVwqRzmOPfdyljwmsGTkS1k7g4AlM1NbfzQaprWmrGh4QoATCzGgyiWa4R7PJJELW+7xGYp4VMaGFIPVfexAJraU1zfOltedTzvTXnCu2d9WfwR3Yjxv0LfPXsl7i4eolH5z/Ho0d/hH7xAGydjDemQkv+mbjgCepC5rLnVItVkC3boEe8gXZ0vhywa/BVYNVLBvSmqBoH6vGLQAwI9WFNVMKAwDfbxGnnftr533PlzK35/FnNa6rtvu66oRD5sHRN1HLnaOP8p8RMSUKlua9yIB0N3HLQxTc7TStb80L63W0dJazI1CsgGrqctBkF8dZhDC0PKC2EPAh6/p1wd5xNdJn8ckw2gHb4JdfDWYVGNZHSdUzhSWPjMf+8btJmaR+Z6io2XUSc+j3XPEIVDln0336K7EWDMKq+OzQ/Ws/UmmM5D33UROdct/TvusxcWy4/S7/ftiiTVZiflJR6kbvB1asv8eLrL2HtGo/f/ynWJx+AicC4CWNbgl5W49RvhuDc/OCrdlx8ZlMkPNUE08UE043HvI2d7WA7W3hutPqzBtmIBYYzzxHxYa/fzTdNFchrarXOd9Ln1brPcaQGx2MUhBb9ES0GAKbrAs07dRms1/NcvtrWWhE+Jr3WAZy7atJzjYmJc7ZMjb98ACXWgmGOGrcslOlEjmBdSfKWUJmTxJHfzt7J659rKfWOOxEBrNeuzXVIOcHmBlkHt6xjJLq/cymfnPlnunhrgJxYFDP9kX9f/y5/q9voNL5EPX4tUFYhO1eujnMrRGmqT+LoNTodEWPcPsOrZ59j3HV478mP8ei9D2BXVjYe0QFc+1u3+5Vjv+ZtE4XDdmFjL68XTS1DIBubal4VoJvP5QOpBshpn5QKU6paS7CXGFFr2FrOXB8dqncLhGswn2tvXrZSt62Y5nOboOWakLs063l0F2vgzleXzQ1i3dFHJ9VePUdHCc8ipSUSM0WJTUiSKpd2+e/5go8dm1kEekWR1tX7UXapQySyfFEgmKUTKYq00J2ncOIzLzcsMn9YyEXroRo87WeSBwpNiZlr3PtOpnoBHFoQ8/3TMoV99XfeGclzASgXUS0g83gREZSLTerDVsC0XjVNAOgJuWG/w+XLT3D54gXOlh/jgyd/iH69wEhXYCxg0INomG3XHPBGQLSErjPF9VtzaW5McmAqQOZI3aANpqUnSX28nkI7lQ7M53itHNXHxu+qNObv5Fp6LpDnhE/exlhvlMqg1v3Q+2kOTkFb2/bWgHvu79s+n026cIOmrfqYLk+CxGQ2QXuOlxLqAIY88rK1IxeLBfrMdNKd9XSaywu3GAqTI9ihBgHArQ0bKcYGbcZE4B6dwzg6OCPg7Xw1mSjx81qHFurmoEIUNmEy9yKGUDZegQffZfBObW5qPEBBcdXa8yGztQbVHPQj1REXI7KFJFopkYCHgoVkEzaLmMFsJ3XO61BvopUpN8EplAUwj7i+fokXLz4De+DJ+z/F6emHgHFgswXZHuw7ACPioFLgyGPOGXhHzTB9ZgzCPDWB6qv7kGJ+asXm803Bpj5SLvkfFgKHgDQXsi1tlrgE0DzPnIuvrVofwqSSdlYsY7aqxVyJ9WD9vLw5KdYly1jXrgB0CKlDCbxbVlz+e73Gi3LuIYSOBu7brhyqpdexAE4IoIzUUfXCcOFSX3iJHJdLTC0bqLSQwB91nZHYi8Qh3rMMgGjqYRqTHpFV6kUmgbVyQKALGo3y6hwWu2XAdgaOPEayYLZyws1x3LhgDQdKJSVPCBfhQty9bNSwARgbfVXlnxzdF2e18EyV33cqcQiCDx0TACBILB2GCd8ZWwq2ZL7efshDgTkHMOnTFM+dPaLVhiD49T0BswDegRPLQbllQebf1/UzgdNmMmBawPsOxFuMw9e4fvU3uLjY4uHDj3D+9BFo3cPTCoYB4wjgPYJXoZQT2RZd4GpF5AJPfKUtGfSdDTcHhZg+E8Gu/s6JHiGmNAnDe+FLWWMIm4rZpma9znIvkZrC0j4mJsAbsDe6wFC68ZV8cHEmg304MerCT47+0wyKfjgK4NGfXmLJSlFGO9aEZUNRcIE4hHiOkyB1m3cRkCiTnPrf3KttSnEKnjiney5ptSOs9yiAw3ho3i36qJXuxXHPad9Hg3VlHkx0l1z6AjKp9bsqlkCeX20GAkEo2Hyx6Xuy0AwQD9kQy+EDvePSGpJFYS26zk4FBghEDgQLIg7xJRzGkH+8n0cnQN5Q1kmUXA5T/YNHS7BEVKjlx4O5zq/Rf99Wms6PHDOyY+3x1m35jijIZi45xzKVf5eUQjn1ZWHkvGZWLwYIssDyvYbc1G0pBnP8NkhOPHL83IF4h5vLr/Diq09gzBrvffBjnJydA10HUDCxaQQwpkOS0LH1idLL/qv1YTCsTacMrUkxPSZAUvWZgnCHYGEED6Zc8QJuP7RSNr+h6bPQRcwiRJkQ73qU0NOmqNvkfc8ZjRlCXQSZxHFdULRsW3VSa6MUeiQCPtywZEzmb60PmWTFSQijrP9BYE/x0EwLD1VBqAUaAMGFTGO/T3qjd07eFcBvy++YsoCGIMhMG2aOFEmrk9OClQH23kEDmhtC5A1r9yRmOY0WhUrQuDwYREdYHFQO3K0DmD33bQPzbSmfrLWPPINhOPfOKAWv/n3MpbL1HOBcQmSfz82PZjhQrWc1l/W9OY8BT3JoTATFCPgdtjdf4vkXn2B3vcH7T36Eh49+gK5fYwTBhNOQjBHMrooQV9YfxZZ9WRdxsZxaATndUR//lzURNurFyVvaUHHJtfVxn0QKcuSj5WVM0MSryKuTdc3q+ZJcEKMDA8tay9te91v+2W3zaSqIEyU6oUFQnrbO53tqx9TFL+bDKQbSWwfuVuXmnnvdVPOdc2Db4pHK79XMnHdwD8oGVNYatonvqrS+dttyISHvxNs7Gu2K9cvq2cy/mtAUuWPVMpI5/Dpc2dtKrbFjDhfcpk8AmNh/whfWC+D2+TTX/pZgzDXrHMTrv1tUCTDlgbUVngieAn3GI+AucHXxG7x89jnWizM8+fCnWKwfgqmDIYJjD8DBs4P3I9j3k3YR5e6PueVWChClEVvKCQegy1PRVmahd7K2t6igY1Ib5HVuU+a1I9SBQRp37es8STTFKTgaULgezE/a1ko5+Na0TE2FxXfCrltLq5buptgmJTny8lQItjAzv9nnW9G434SGPVfxGrwPvdtaWCkfxF3r/Puo3dWHFbJNCjLhfrqJNM01vfATqhkVmDur6WNmgRR9Ojtpks/v9yWl8USmyQBAmvjy/d03b+o+zP2A889rrToH7bzMGrhrbW2qvTH0MmE/eljjsN29wIvnv8E4Dvjg/d/D6cOncKaHgQE8wxDDeY+BneypMENJblUk5NoxD6FNyra2uPhxHCceULfNEgrcsOMyFn7db03NEXNgnfWMcp1erdGkkVqLeBirsAI0T07eHlJ22KgPgG2qfpgVANk6mqt7rUBxpHlUAczyAcN7M+OJdozCkdiA+ypdd7pzsm6oVrI1eMdo53PP53/Xn7cGpa7joXKL+hOhdQNIyqLNUcXfs8GUzQpOipHM0ENNTu/OmHFc/B4ALgoKzOoat/XZN5nmJqSELaCwL5D8n1sL6a7l1WBcf6ff5/Vr/dS6tI56T8pliZHSowPcDW4un+HVy6+xXD3C4ye/D3SnGAFY9kE71jkU/IK9wpLy/OE2d6II3MaWpwy1v1Qr1bp2XZf6jygqFXWSeQuwc4FLLoNJ1VZsC/ymikWpZOSXJfhR6CEiAW0CopcYEUUf+TxfVsNS/872QGoFqd6faNWztclaU2TaL8VmKKflnFsPqcDGnJjBtKBuT1+4QzoauPteTLl04qr0g/2m0iGAV4mdm301xJUmYeIQUyoHQ7VDfVd/6iTSCc9eNjqSp0qVVyPVk6nUBOtnU/nGGLmv73ue5NYjBrOJGmW+QG7T5uqUL8T69F3rmbrPW8/WgnWuPnKPpIPxHfY3G7x8/gyjG/DkyYdYrn+AkSyAECLUS/hiCbYQLpl12W1AnG/OijbP8BLytRL2zjl4J9RcDl71sfF6LubANvoSkG+zpI8B7mhRsQojDS3BcoFwbMdU40wadwqDylDsQYzgKcHjDh9iydvUuuGm67r4exxvFmvIZ0IxtCquQ6FKlPasL/m93UKs+/Ou6c5UST6pjjWXDuUFYHJUPHwZf6X8e6r2yHUhVsCd8p1qD7HeINAkOD7HP6Omwhw3RKLkh3B1zofbSRRY47tlqs05hMmQYvSKqWwoRFUreLOkzRtGPLmFKFRUgtdj8B2kUyjVkpkxOgZ5Ttw2J7ctkLjsHcyuAbq1Vq2fFfMiE/hz1l3+rtY3TwVAwAjd4W6wu3mGly+ewXQnOH30A3C3EoAiDrciiEeERx7vIqeO8n6K21iiHIQLHShYdDF2SDzqr/7qYQM2AGCevAthUb14afhsjaiyItMxszijttnasAv9g/wZZOsl/E7ivii36ZpwvWgZh8SznoqWOngky8CHuR+fDXNE14rLg1D5EFudw55TBtwcYvB3nYVnhm2MfSwvIEhg4xPNl3soVca1jlvCyXp+ZvzsPZXeO8fjPiRt75q0s+qOywUCgGIjr5WHLtLoLhd/ArEbGwtUJ0ewxYIErQowXiuVIhN6cfT26EJ4RwPPHs4LmOvmZE2BFFpBrFmu3TAcA10IbckIF8ayAhmDWKaSNQS5JFuPSiehgdhr373EwcqJB4oQhsDLuBmP8qQs1IpRCqo9niq8a9fKFkBrOjTngPI49Nxc17Ec0aMzI9z4OTaXv8Kw3+P0ye+hWz/B2I1gx2AXwIYpDVUAVYZYb5O6EsTzQzfZWU7k6vvek2ih4do9zx5kPEDCRSQmUOFHbtMZx8xTI2t37mkj87jckGWPcJFJsB5sVy0aAsNHRYaYY2yVaN3AAJ7g4WEso7MGTATHDGT3zmq7NKbKRHM2Fh4GLgg1qaMCPcE5Eh/wmKWN64zgQQG0mSge+JPYRCYMCEBxIzHMEe/DkE1DL5TYGMJdkAb4yvoovhfypLuv1jsdwGmBdj2Z58A1T5NFckBjmsQ3mNGKNN+StwrvYLooZRAA9cKKzcgFKQGkgewBOJXi8WIHD++puFbqTtcdVWCr9W+dGsvbb4DgelZpg7mCfmSfNev1GsL4qPwxU1XVzlBqyNHGipxv2abkFhcu4jiyva3nDlEF9bjm1hOIMY47uN0NXr58AUKPhw+foOsWGJ1LC79Zj7YSxBxO6nmO2q8ERUvWVaQktIOgQajGzMLz2bPpYu7cAjnUvrw/9N3cPS+HHQ79ofUiX1kmUUkiNWYFnDF1odUQBPW/dC0aJjfUxHXoGOM45bU1WcuhbF/k4b2XiyWK+pVukoXlXM2Nsh9TW0vsKd9R6/Iu6Wjg1sa1tO1WQ45JuaaUv10Hg9Iy8vdaSQcp8ZemOLRSUzpibnGaaFXexJxoGg7cl3Px1BSDgsaTbqjP9wAOCbW5RVxrFa08iChobmmBvW2wfVtpAlYA1MyczCtKcWCAUsBHjRt3F1R1fVpa9hwAxGd4hB+22Fxc4Opqg+X6AfrFGRgd3OhQK115alExxdgHnjtPt22Yan3DX+HZpLkmzpnCflWenwoIPcUquTjnAmg7eM/NeVfcS4ngbshTn3DpMw4gGWtZSHLP5d+lFRUs1Ky8Yu14ddkrxzJx2QrK4RrEoPf42De26Mc5Yd4ar9sUt9vyOibdyY/7TRSoKV90tgLX1um1/PdDC3Oiodop1ZLagcRZxclWJsPCR3IAbg/l2QA9OFEP7DGDdii1/D9rQUYNt7nvW6rHVrlUrkyGgjagNJb5XHldsNY88sU/Jzzro94MBsEBbourq0s4Tzg7ew+2PwWoA8FAjtdPY3dI+dPAWVqm9z5Y7jngThWZ1trUPlUvCPFW0X/55n2SKpxp0M4BGps+10w1DyIOboTJfvLxCCgJf80ZPVhjSGxjqQDmFGnuu162iQGIsFGlqQDpANz5u3m/y8Eg0eoJXFEtwe2wsZZb+yGttrXW5Jtcp6/lx60deB9TvNCWkAD7GC37tg6IUlL1t8bJybyz5dkwqPo94lRGMksBneRxc8e3T9mplgGigxNgrk15vzY1suzZHEi+qXTfshSA8jwS5TBvMSpFEnXyShC3F/Z8Xet5qwDQAu4633osBby32G8ucHN9DdutsD59jG5xCscGRp+faRtzapfml9db8i+D9bcEV20dpDjUCFplprCEuUx1nBKosBKBonUo6JGi3hlfHxuYVg5RorryeilwS1uK3oj1ySmx6RpQWsjFuhXjA2T5UNFvmre0S9a3XASdWpKfjLwttXAlVy7m6OM5gXtMemNH3l8nUbaxWGvbzh32KqhTvsCIIVKV2hoNQweo7GwgTBQiOF92aB49ZBplBfFdYwxgUsCjmrt+nZRrA7GubzDdJlS+C2kCnDMKxCEAr3lL/b12Gys0uWphxnd5wPbmJYbdFovlCZbrB2D0GEegP3Bt2FyqaQHRyhN45bz0XJsTBRLAOl5YmQOsxvJA8JEOP6H8qwqNwNlWxWUK+q0p7zvpMxU4+dhQBrhTP/J8DL2fCycbgBFtyjUKi0yQ5ZQQ0lez6+zQmqipvNvW533W13cCuPMTUDkX1vIVP0bbTr/LBKzjQOSD4byPbkSlCU6T+SiWPGXgPdMe5R+DNTFnOt2WijcqbVv/fFt0yV0snLeRksVTp5L/LjbWqndq7XuuHTnQFVZYpUVJAUlzLsDcDdjeXAFgrNdnWPRrjOIvJfPmDl1YKxASjElBS/PjJphpOyQPA2M82NsIygqWEXE5ASezUgwtq6KkUeLnk16fXxdTysIETbcE5hK4p9ppqpP83bTUmUBU+mhr30Rtv7CkyzGqKdRWuYfSsaB9bH51uvct7/ctECivDiMicBUPuJZYt3lqzIEXcwiDmu1s63/10ToWQU1RkNJ/um6TAxtum6SitSdXLRMPUGDy/qRvgYlwiC3gieLTmCCJt6zTUeZfsSt06+PFm4XZ3/y+rEfe5w6Agey0M1Ha1Es0d/F+/q6WXAQECK6b4HlRq6AP5vLQRQ74TLAwYAxg8nAgEPWA8wA83P4S4/YCMCuszj4A9ScAORjxdW11RGkNZF0TlYcQ7EzqPu0A5tQ5CVgRwRgm8Ly3jHeuKNUWrvRprFjcQMw/uzUZpWRkPRBJiGRr08nllpaaA3feXwnEwyqh5FmUcEL6DWENU+g70mByDuKimQnAvJdqgZ//fQwV1wLuWtAWgiJiwnHpTkfe8zTXiLnn61RrOfk7c53SAu6CB6w6ulW3sl4MkEtHhmNHi18oiCRmNNKEFQ3IRxNSNKBGKICsFGP0aLfWtdykmvRN+E8BNaTO//rM4YlzCLi1j2a/m2RFB76cKTr79dAY1JojgxFcumWXX38nEZrllbrT9niiEA43K/cIjVvpB50HufgRRduA2ILNHp4GeO7kUg1mGIzg8QpuuIHtn8AuHwGmA9EIEMNHk/1Ql4lCkFudKaxrJQzjPAQi7cEK0NlzXhGrnJv6e01DNAMj6UyLH5XzkHAYu2NtjAwis3hyETiMJce+qS2oXNvO65nGMQG3gLfMeRFAHsjmTuoD/VtKd85F6nEu5Rgz14dz/doGeX1H+zFZZccqw/emSo4xAW57Pw7UjFAod7KPd7GpgXtWOhJDd/vryZHybQ+QPIs4GadCQutRbpC0yjjcUUWW6bP7GTvfSLrL3Kj7RX4en8chU3bOtK4/a2n+QOnfrIdmGAQJ4B6EO3swD9jtdxhGj/XZKfrlMsaNpjsMlK6HtqdMDhh1G9B8rpWmlGDJlR/T7/dZ++WaCto9CAi39xBRDPA2tzZqJa1WmGpLudRoa+XBBIWq7Tk019YWMB96J8etQ8+3KK9D6d6XBecVuy+Fkk+cOuUawKE8W4s0n5gH/akZk3dadIt+P8lHRXqzYqo5pwHLb3SeBKn5nUmHNctDCyQH7vqz2/Kbs7xuS63nS3M90Vsc4sNI3CSSYFFwAA/Y7bfwxmKxWoNsFxThQA2Iyn5rXab9UP48VPe7JJ2DNb1Qly9/o5jjU8+S48rPo/yl8vSka3nQLvX9dN3mQKjYMI3Los9O251+98Udo4facshSqb/P86pBu/XsbVg6l+5952Re8GE64vbFami6QHP3o0ONaTU811pamnj5buLf6tvUW2CeJoZqVJLfxGOESgCo+4qICxet6tW4WG7rd2o9d4RGfusEmfuaIEEcZvKkaLJKah37b03ktME0TyMxEtc7pz23rKy5VD+Tg0s9H0AEslo7Aw7AbdjB+x2GYQ/qFrDLNch08DAAuxAPxNV3BkzaR8jWQ0OZmVvwOYjl7a73i+o5rWBX51nPWRAlNiZbS/W4NudxY10XAiL7PHdfTO+UE7nlW9/aF5NypnUu/3nhuW9RCA/2zYH35hiC/LDTofJuS2/Eq+QYKTFLV1TP1AuvJRgO5X/I3JwGTgeAckCMMVm8hulVVaW0z/mqMpG6NdF0AreBPBNA4T8t/G29Uwuk27rrKKk+Z0jcIoSJynrV5dUmY97vt9Xr0LetuXNI6B+zYAu+N15LlqgSqT+D/V7ibvQr2H4J2ZEMgoYDnYL5Ba8gVvfBwecr7bWlNc+5DObRE+vIlPn74Y+i43V9tOZwC4zmxl7nin6ua2oqoErqtM6j5VHSEha1cOMQ4+UQtrSE5Zx2fVs/lPind4jeblXNpW/MHXBuQtYDVgN1C7hbGnCubdfahHacMSZq8kDQDAkAuAhAn35S1B7zQdOLGZxLrlQT7TxM+Nsk9O9Cai3GY54HsjgjcQGKbtrSVmLWBwTT3OI5NtWaqdZXx1M9OSScglyIwDyAmdEv1ugWKzBZHOuxH+ca0rqo5/8cgLSer5851A8twJ/8JIrhZG+r07GWTqse+SGy2mKugT1/pn5Ok/DXJWi3rIRDisibSlO6tlS+8stbjk1v5LJgrUDr+7lBzp/1gMQoboB2fO5A+S1tWzY95UV1ccq1EADh2jITtcT65hRjSg2yNi3ZA96o6Z80eE0xpkmlDc7FvCjTm5g4hxbRLfnfYf0VQELTl3MtSLVL/d3oLUN6CMug6KOiX24BhdpMve/iq8FbA1gJZhPgw0W/JtwD4EcAQL9YousXmksz31SlfJ6ZaLvpPKm13znTPcsd6jrIfPiORd30r8G2Bdzx5vmsXnmd6t9vTY0xPFQHoATdXDmbCC9SS1eF6zRv/efjd9pPtX17BIvQeJKrn4fefB0l494ad2sizaVD3zEzHNJiNVSZf0B019HfJxdHEeRcRFj4xkAuY4WE0axNyhJoPNRflNmByMJ2Jl4wbMKloep2zRwuCdbbE10IlEPyT4Y/PIzycEMdQfDNgPNMui3r+ymkBf8+m3UFPIUmRATDiFy1BcMGzVVCNStSSCWLkogAVy7E25SIYxOHMhkUPOsYKIDWgzxDbgHQ2+G3sLQHD3tYdOj7E1hrhTYxEFDwBuR7wDiZIxGwES06aySWd96e4mh41afT5CGryIUQogJIzotiwtUBtHo9HAIOI50CDr97LwHoKZw0jJHydbwb/Hwe3CosZvG2IXGztzZRlLlyI+cefBQ0ap1Ya9F1HZgdGD6Gt4ht0bnUuGwkCWMGOkSt3CTNS+rs58NkgEpfIaE2Of6u46SR/jk/4h8f0nwII/tj965jemtUST3R5jRy/TuCWvUcZx3SmmRhCQMkVztR5KS1nFJDmFwKW9XbWoOu011qwBjbnuRqPZNo7iYCNUMPKBCbot7T+rc3F0Xk3B/Yb8UtLh+apSTauU8eKMa5UYGCdgiQLT/bAQQ4t14qdUZduOpy879zC+cuiUPZHPrHQ8ImIMSltvBgdKGmDCIvAgeMRb/AarlG3/UY2IDJQ++AqOdZSS0Fqw40mQutOVOvowhUlDaF8wsD5Ib3btJXd9b2AvAI6CIDoOn4T9e6HKTKlbDY4TTVtuv2tfAiKnLFV9qHEntE42br+9PgdRyE5/S2JEM9gBT5M7dgYpGNhZa3nybByLKHqkV0Vz3qWznyfmiA5gD+Nu1A79ozGXAnmJiZ8PF4gfhbGyO3z4gpZhJ4zLUDmambCYe4+13V+3VMo+9yKs16RMukNlGBDLjjGFV5cTgaQYHrLsqZgnOrHnPf3zVp/fWQBsjDkwGHuuXg23UdjO1AZEPkxlAfoiTMJoBNxTNTmmAaKbJunwr4fLOx0NzZB+tzXlAf0we3aeaH3tU25esDiLgf04SKzOZPfc+m9z6bZwnAYz152md1XBPNV+/ozJN3hLm1HwXXEe2+T78dk17bHfAu388tpLpD68lSmyytRCbx28nqCXpdVnYd5cxYZM+jGBEOasW80EjgE7mz2oWRDwmdqbadCqbW3Gu3/R7aZZ0O9u0RAJhrj1xN6wLYOQPyOttghqpGHtU0ID5LXC7+28D7LvMyX5BTwGIQsQQs00hymWA3ZAW0jYEhAw8fhFhGueRgXfQZNbqiXA9za0QRS0FInwVynrsN/HP91nr2UD/WGvNtec+VNf0898VWi1b/IdETMVytDz+VbikVh7x+2kf1ZS25hY+q31t9EAVkppFHquSWwz1zeR6T3ipw58B72002c7xbq+G38elE2WSayTuZW6JtM2u++h1AmabSfldKyEG7mCRcLqhyIA97YBSm1Xc4tcax5acavwMiOgYsK/sEed/InkVJI5RaqM6v1t/HBMCPdQOEX2+BY0hySa0HswOBwST7HdZYdP0CfbcE2MCQhTWBox5Dg4Ogas3dgg3iqY903a5DAJkf8pJ5DxBM8Uz+rq6NfJ7G9h7Y4CyPprctnbrOtSIma23K56e6WhBlt9rEKJ7601XPlx5JeXm1sKzbkfcPM6OzFhLD3E/eUVTIy2gdMMrX/DHC6y4g/p2IDnjXVDQ6ABz7cDtN2FTUA8o1XVEmXdSHy5vrUApEd513mqzp2EU+mdOiMdVEzib7se0/VL+ZBX5Mnnf9vpXqxR01bp8v6Px3BfeMVkACPILwzi3/5HqB3paaykBtblfPhygdYbM6CXjbWfQwwa1L4ltbYyG3eJCcpATiBtqk7khA0Irdc1tqPZX6IqoXRdtyMCndMW/XsA/Nq1xJax2+ypOCN9AOeWyya4NUk87DYOilySVg6j2VPNGCc/BuAXpe5zxCYi3kIubMKJm3MQS1Mntsv+fpewncdWKWwDXjOIp1HUEAoCJi2F05OiCX4JNFJYU1B9gYI8E4s++Lk3jyZEMLSQu51sQOpfsA65t4t04MlHQIGsAd+WEGGd3lD/0GEzVsIsr6Qge07LPWZQdH17XR74z2XBFglcbJ4pU9jL7vwMsVYDzIBK6UTIyIZwzBcg+GXL4x2ehi2UT0d5ybh1INRnOmm2roh7T4N51qjZSo1FTzJN4wZXgICgPhjQ/vigKU8lUPltLltqbW5kBT9qdUMM/3R63VH7JU6jlZ+6DfRse00vHAfSA/Btpiv3omSjpUu+x3KFo1k/w7lX7Oe+yHEY7EO8QYEk8ARrOD1SRPHasQkf5OJh1npYVvg2VdTzqdiIZVR0tmePyJ8l3mRI2kLSdK7X/LCyqve53utJgDuOXeI3qzu1oSZBKlRUQBvIOrIEwBPHltlPZqmfVz2l/LmqnbFscgNCB4ksa/038VvPU9YLlcAsMSIzs46uR9YhQHdQwBxoJ8rYkFLY894HzyiFJlo3iq6ua8LdkDeXtbYBz7nMrzDhQECynNSJz1ATL+X2d0KpgDE6Rl5fGFBJzaK1wULvHIyq84i3VlB3AKvaz+/uw9DEvkTimb43iwz68WzOeE3qOp7Z5eklx4kPAUGgsBP6MIFp+nThHLKzyjZxdUCQFzVAyOVTvuoHHPdH74eeikmHBsIaJatoDj91zeOFK8S1msBISOieZf+IxkoEbvQOxhjYE1BMsG/TAmho8ZrKcmwwIx1kbfV+HUNPKblBj9RAsJztmP9qEhZsASRU1LzThS5ALSIYDQGGY9tBOc43K0MCX/mkuz26iTiTaT0QKtdBfwrvlNsIc1UkHVvK1uGJtwQjB6XZg4oXOTd64cFWDtPYM2MB+jScbv1DKQF8PYZIKWOgAWBoA1gGHx1zadAXqL0QMdRhhPMGxA1IMI8EaVB0CVA1UE9OosZoAC11uPFyPcfdpUEAxyl7pm3xl1FzRJkGT7CAJqXlCPPHRDNf4MdBXC2pOiwjxlXV3VPAAiaGu99Zox/d6BwGTAJIGSdeOZg8Qg9iL+w/OeKMZ8YQA8Bm4cU8WMOd1lqfUjAmARXCSn4QXUG8w5ERgxhniWPxpl1e2uBS7r75klrv7vsmR8Avkj02sD9zGPKC9Y9mM20MgArJZWSH9r45F1YHwioDhzMDudB5hguTTbW78TMiDJgLjULPIwQbrY5uMTaP75z9jerI0KFLKwfTSZmwCWS/ADaU6rTB+g7P+szLrOtfZ2TGLmGDis1p7ltqMpQLfKPtS2GuTvYhUc5GjlgdRnzHHh5ceBKGCZHgYBJS3TBw6cpMEgdQ1FCpQ0jmNRbn2TTzE+3sc7ENXaUDA0xqgeMOmL3OKo3WVjWZwu+FUg16h8k6UY85y7JUcPsiE8U9ahFLTyEENilsm+R6YpM4cDT8XAJcUvw4GaU06/t+YRFYBcg7fWk6qwYDUt4qu/8zz0MA8hbKSjnq9TJfVusP0Ncty5SVqnuhNyjVwnPGFq2uTmZF5OPkFsNFcTn9TS8kJfpzpF7rSU2gk0qSnp44SQP4rPtH6xDdq+2BaunrvrcN4vzYHhfVLiiMvIbTHvaqG06nAo5XPlrnd4Kui1ym89W6dKfwMRoet6+L4H0R5yQJFBcmljOL4vxKD2Sbm5lrWritdT1yF/Xo+rx8NkzMhDoOoaysO25jF86hO8k7lbjUveZ7mXBAdqRZ7LLTuZuzrcRAnUTbiBRsHd6POqTCTTBFGxP9BH+nstQA5ZiGkztvSAqa2cXEEqAlRV41HnTZRiHKlFUtQ3nvK6m0KUpzcE3KWEBmYmPtfAFH73cjjUs0p+Qg3J+eLPNxrmeCYA8M5jzDox7lKrupRrUJWpVwuS9F3WzkrbLtpMQC1Vcs3Aq9QG0mGdRl530STnUq2RlK1Nz+TptcrNhM5Ek66E7ZymPTeuLgPtu1oDczTKXJl5vUQLDJ/rf0iPrNsokKSf5Wg7+USPKfXVilOTl+1n6JLWfIguaPFwdXq2BKjS+skj/LXanPdLnkdex7wMtVQVoD3LHoeJHl6A+LhTuhYOADHDsR7G4ayP5SfBBBqzXJNxHjVcCPN2zIFrqayVayMKRF+OS0tBy7Gh7m8Ju5HiJRV44GsBePe19tpXl8W/j3h3jlbw2kthRVQ67qTMvNMocm7tenpmjOzRkwWMScIhTDTlDnXDqTS5EoXBasIhmXP57TaNVsc612acfnto0A4OppZ3xwE/ZpJMxvU+AF5p2cWCh3D/9aGHOfCtzVOPch4cen8qsKbfH/obyC5+ZpZQoMjLVKEr/3PsYeDBLCDNzJCNWg9DNptD0zrXQqv4vtAWyr4BAA40Qw24eZTMuqwazFv90IrAl1s5kn99XJxiwDiN95PqK1f4xbyYYXxbQAEon40RPU3sE1O1I29P68KHXCOe9GH4GfdPYOIY5vNNlMqAw9k7ORUFZhCchEMgEros6x/fEBiH5mkr3Qu4pwXoRkc73erPmf23TgwEt7opoKj5OVtX7RSIx0nqPQF8AwNjbNxlBlSbTyfOEngr+OQLr3Qxmmjm4fd88au2E83C10i3aeU1sCVt5f4m2rEpgm2l2SmFVC/WlvZcgLaa99V39Tt1HfIy5tIcgEXlgEi0yGjV6+CKBaeL2DknR+I5KuSAwrpzANrtnEvx2RrIs7qhYN4RANMWANWaJ4f6Lwf7XNuutVIF52RdSZ+U4ZHz9mjeae3aQtOu2g8D51KAKa2bgqOtrLU8umcrjGv5TLsvYvsUoKk8qZs3JteyrbXJtTIEjSphKJrpAKpNiZl6HErHn5w89BmF6RsreketLhIFh8uuNcZjGskInhregZE73QtH15GJk0jyrIF7/tRlucnWWIhcmlL5wPgZLWouTRb6a7z7euLi+JTfapKXfRctWBdN5BgbIHJMe1RLapV3SPOMn3svHLaOv6K4zl5mOMghHRn3AKiqdUcwz+aDllPXtaGkaPRAqsBKmL+kQCiY5P7ZOXDXIHRI49Y8WjRBAq3pJnH6rLYqdNqmo+x2xjIFAM8EF97TYG8KkIDy42V9aqsjT3VMoagyttpnTIYJ1XzNxiIH7SjwIhU5bVPoiUmft8bmUDqe4y7FulyUqoW263JU4tb05ekzDIB92gxRIT3dnizr6bPBifxhyICJMPgRHSRwEOnMyigbH2gSZIMbS2TS4yJBi6zrnblcEYCgaBNMkMokN6RMe2DSCRNACyASmpk+j5+1QwykSXSo39IjREcIyFqDIYSbvEUQ5r7ZpWmWFhCF/uNqsjvviqBdnuOSAKBhR2WG6DjkaU4lmKMOindrS4VioE6pk/PYDzuM+13adwltjFqdjn/0Z1YuuKxj+p0nH1KmVTepATIyW0l5WytzjGzKNfRpHpt+mjjWT0E5adPTn60Tl3kdb0u1RVgrZt55KDllCCArbr4qGIhzAQSIwpW0f+Zpf8WWZnqT+tyLi6B0A1OypLSuRfvC7yZo5+LmmjkZcIrHXwcd8mGUfXhWaCMNqXBrtwG4i8ZdD4TVGLNqOt5Pj6NMPjXLTbAdy0sggHKCNyeLTHsFX88+aCkSalIG38JMNnek7BEaD4HBaR6HNUkAG4WMKXBTWAqhPNbYJwaAz66WAiL3XqJMrrHnHzPqLkuLIDejy+8L0J55vyx9KhjaqYKeTPBRyMcQwRoFmbwjU78RMZxnMNIOvmMXwZsBeNii7l6tI5b3c4EVcoqKhc1AaA6k6z4ptbGgPccCGcOwx267gctiXquwLo0x8R2OgqQoimNfl3no6+0B0HZYW0a3I2T8MCS2igobpR3KKJpJudG5Wn+u5eVl1xufdSTDGtAnXHGVb21NEzysCbHayQcLgGGM3NtInGvOlcALwahqugdo30gDtqCwP8EQr6A5614tIGaGsVYom9DvuXLnfXvcHLt4SAgIgO0Ryj4u3U/jBlIHVeD5TaRjeaD4fFbBwiMFsvMNuMJnNAI3IUR5S4uw0JQ8w8nRAZlEVUeoxG/XmbJFQsHEPr5NBMSg9W2NZxois9Ae33ZqCAYyJuwu6GehyVwu7gTcyDQR+XvkscizNI8rVbaqC6dfg0AtIbEeo7xf5YAKsrclefbwzkngfU7GRzRCcsX7QEoas4JNBoAMWAQlJ9N457VJAbJxHKV+foC47h2uResY+KSelMAwB259Px/HOhjYsSnf09Aya+0+Q+jJu/IegairPiu577rP8nKL+dikO9C0NvLnD4XkTULx6G4p0vcuVsncZDr22Ry44qYlBLzz75Q/ZErHZOs8HbNsM2Sg2KpbPrHnvrt9adcZI+ZZeD7EOlBz0czV822mYoIjaZxJVwqT2DM8/GQReAacT+3SVNBfRwLEJJca8CrNqtAKC6mdAYRJdqNy2SV4Syvp0PliQqAoyjsXAaGDTFH0dO9k0s5Aizg/wvsRzL7gh7NmRAWinp/6fVHNA8BdA19LYz1GaWjx8HWf3PY+M0MPRdW8cW0B5O/UsW+OAe5WPvm/lmAViiTv37ut/9cC7rsA5nclFR0IAQQOV5WEdagGtUxomx+y1bYlU9LrO5l2hTAoxpRgUh4gSKfP9Jlju42Manc0Ae6Uysh8tZYxAaUj06GxlXySCVZrg2pCsuYTwDABdEaMZZ87n3F/NDXZp3U4lChQWMHXGFmVZ8Ame1V8c1nib1tLWK8W6PgEW+ew2wt8MytRlOetGxwEpfu46ic9Vao/pQ4aLKLd5pZWp2CiPHy+KT/V0ss65O1OPxP41WB96L1WP9Zj11Iq6nxqD5lDczCBL8BIYV/rcmsgrQ8ltdrRyqsuew7o23+nMb4rbXFv4L5tgbwt8H4TZn7Mg0UPKq6my34nMIwPvFfRnOAKlL8T1kABiGyLDGvpW4Koj/neBo66yOcWkPxtgkRPUr9oe1anQ2XddRxVe2uVxxw450p71J/McnVdEpMUfbfVfzpGxsjyb2k+raQe1zokBiyb0uH+UIP5/mAotSLCyZC4kC6XS5BbwNq9HMRBuOMxw22l5WK/kPZtDkrJcjCF3y9j7kaNOY1uAkJUHqSpuWnd7MtjwNQxsPM5VPd/3vctkG6t2bl1nIN3XWad/21pTuvVKJ11fx3Srmfnc+Y5NWdlzLW3XAfzz7XSN0KVvE7nv9VEk1+yxGAmeCeuXd5x0MaDtk3iSC8AaqCUZAQdBnw4mlxrC6pd13/fyVrKALI92NnmGKYTr7Uojir2wDtSF6ClPUSrg7nwSArfpj7Iggbp854TcMrnUy2xLqf+WzT3uFUpn8XwB14OsfDti63Ol4yJt950Rm7Bgemg1rnRy6utAqeCo4MaHXIhdbDwgvkmekAOAvN1aFEBebv1IExNOeRad0sBkKBQPs7VmmZppbuu9TmLqbYG20KKJ1MtCSCAfVug5J8dK1SYuRB4eUCq3Jq9uwV4v/SNcdy1pPruJ11AWb192v2PIGUNDInhXSwYcLislcLCnvqDqzZzn1jMWq+WqYq6LlxuTLZ+vk6aaiPlIjmk0UwWZvZ2bbpq3vmf+eGMsg4pj/RzCuqRamDRbHPAuE24MfvgsqYnFQ2s6QDuwKzaHcHY6dFx7221AZdc9yTvaEhH66Ouew7cecvyJ3Mtfv4IfAL1mF+heaf88kMu+mxq05SOuytw5f1fz+36u1SvclwpHDUnnl4QzMxFrBf9vo4fMwfouW+7tl/zLg7hVMraNL0eoN/BqyRbjFLT9Dfpf7I65WZVndeBEKUzhd+VAgpvzXTOHfIqIIMTrIgJKqa/ECLSpjwIkgHgGDDeh5gL5TNx0IOWeqhaE7pjVtMWQFFSoQ7aX+/Wvw3NOz8ZxqzlCh2kWmb+ffG7Txs34T/V/gFl+aagRXnbW+DNnPh1zYWZQ5ycwE0fsBT0HQMDkIElAwMWP3Iy6IwJ4V5JtO1AicAavQgHxuT9JvMhWhrqUKbmGpKiIHcqTg/NRCAKFBDFDZow80laZQ1NwDSnaMjIbfBaNSINwyx0kN4mkwvBPFIhV/M5B91a083phRpU8/rNab1AxuuzxrTWPtP2+2DVlXnl4FwLhVr5OKSJe++hx/Q4dVoITxt6LhOEqqGnNqS+iQLpjkvwfu6AdUETM/+QZ7a+n3ELlF6vpdMtOb3lVJedNzTsCofNTb3JA0ht0FNfDAQzPA0eMxeRYguN6RbzLVESKMor8gaXE6P4rsz3kMZ9F1AvBUL5eQIooDVLFbxiXTSvfHI0353uP+T1rkGbgybGkMWl+SmQ122pyxK3PWTvUXYzvYoAACZsTxKnePKcoviZcEOO+O9yuFVckxwS8+yKDexpn2mwMh8uq9Dmp75L1NVhi5fhkGJrI/YhswFRyePWdWhp21MrMAFYYelkedRzvK5vCbC6ZZsLQkneo9lveTm5AKm1+Vb5E0EjD8W/p+6KU8ujaGM+TtV6PiZ979wBvztJAWWqacQnZjSOpknWWJutSVBwkZiCblpIrlhQbysdQ7O8zTpMy7+baZbA9nYVISnLFI1K0aR136O0hvT7KEQxBSCJXaNiZVqDPIpc3eakBfuoDFGsSNDhj7FmkSwjsIIeICcJJcZKC4iBpMXmoDjntlfPfedUkQFyikhPMkbLq3qXgiVBUEuh7Lc5X+z883xtvgkeulirt33PpX09Z2EcSt8+cCf24fuXwlqrtZF8A6MG73oB1sBeAPOMBiLfmaiVts3RcrLW+R0DuPdNLWFSt+FNllVqNtPPY8qVM07CT3/aW/yESWkIEkdC2xlYS2BrUgjTAN4UNln1FplgIU/ApAYYTXXYz4Oarpm6zBX/juxH2cxDsAK0o9ra4Bwo5vO+FYlvav1VMXxyQUUUN6pbWr14BXGznFxZyGmK/PPcyyZ/t2WFqoBqKWPa5vwk9G3WQ56+N8BdV5Kq7962lvimktIg6e/cxaqMqjYHZnN/a376c2LKhQrMAYH3U2ExNynfZmoCaCO9KaEyp/UR0I7vQuLaF48tU+Ify3oLR6+g3BmLrhOPDe4M+r5DP3awtgMcSdxwQI5GE6KrYb7QgRyUpu0Apoc8cpCMh4+MUDC6Aal1pDhBpycCNW8AoHDBbqRtvIaIkJ7Tbih52gatWWnl9SGaWjMHKMS9FiVEvDSUrwfYcARvqR9HlkqG0oPs/ME33VytN7gngi0bb+YUz6WVnyZXCYFaaUNjHtX9Vtch78Pb0hsBbtVE6kbMP58TtEisA6YL/ZsEmdtS3amMNihNBNMbAMta85rTePLvWnX5ptM3WX6uEddWUDRNiab0QVbFeUsnxPEwJHdnksReMZbALlt4WbYyNqK+EjDxE8/zzqmSOWGXa3b5ZQZ9Z2CtRNAzVi6ilTjZIqfGEBrVOVdcmZaAOLtQ22tNtTVU8C21wGlZiDUg5s+XmrMFeOq2qpuyErcmlVsDXu7T3wLJ+l9dx9bJz1ZqKV5NM0Sfn3k//jtQ1rHp26dK3qWj0sQU5HSctw3cYdF9x9ObFcxUap2UNqGi7/hclyjXPWu2UriNPgQniwSyaLuc+aJHEGQfbnzxUQsDUIBMExS0xEZdas0vuiFaxNCiGmo0PmMt9ntEn+NxHJsnLuMdqizBuqTKjY3MA4CY11MFTA3aMUIhdI8gRGIh3a0P48aIgdp8pG5knAyTXFAwo7HOabP55RBzwuZNKFpTSijFSZGmvN7afHPAfbCdB74MfCPPrajvIQc+pzFN6JH2y6IVhgeIMNHi9F2lRPQGegUOnfz3nRvHTNr7atJv2oIqtePq1hZCCKVbWXgH8qrpqaTlJW8dzwAhO1XoEzGcNKpMwAa6hINrHZG6tIXnPEM8OtomvzHpCLz3BqMb5YZzpNgm1rZBiZmja5p+1rbOhLfPee36IoS6v6U+KZSqLlYRbiaCP7KgYZz3mdar0tyll1UgIAKdehipt4xe+jsH3K143FGo5esqDITKVvkzt4wqxQlhgAvnUmTfTzdVa437UJ8ek94QcM9z1poOLtccnFUMxz9Jxe13ijY5lJQnq03uvP6MFD1YLHySGL+MYFaTRIQj9ccuzUZXXjMILo5Ff/c17bl07BjPTXYGiyseJeBkcHQDrMvy0It9O9jK3J5oxKyrXfKX68gM5EJgD+IRzgGOCZ48GGO4GLYL2hZASEfJhXIRgGvt6yQNETBGOe/AZYPgWe42tDZwqsbAhOPcntPhL4KBtR5930dtN4/LrQApAKt96wEyalo0NWjpiXTMX3l1ggHIRldJ9iSx58HhBnQLT14lbYzf7tlLCN9gTRIzLIV7J8mUnhgg9OGqsFp7bgWKyi88AABjKQhj1YK9TBBikPFyqC6sOTkrkJcNGPZyGXQAL/HhDmOk80Q1beZwXgDxIhBklso3BtyTgiZrrcUFt/PiidCqdsGDBvp9Ae08HVPnAlCCph2DsxuT2s4AUw4iOSequd1fy/42020c4zHvAkHTyfJpblpVfydNyMOz+nZPQTtMQ6Q+T3PSBA8fZg8PD+8NvA0amWABnMsvAQkUAxOYphvGrcWc7jQgGGNhrck2J5NmqQpDyUFPvT7yssoN0PAvmHx5F04sRmYg3M0o81Q/l0sQYEzxWb7ZaaLXTfIcqXlsC4R9BDsxvAmlJ01evwkX3rBEKN5gVI4rkVqrFOLnt5UEBXOncYxCOzRQmnetvsrqX43xXcH7Hcf9ltJRdAMQZ2OKACen8RS4dVInDjVRJd9DjL413TaBb+vXCFh3KFNBwwPJGyPLS+o1fc+HICqUB2eioOWrb7byJpgCS11Gnop+CHyZaXC6AArgU+osexmALzwl9F3VQluaaquP6n9zKXeDpepdLZ8oBLnNhEydr7HqctkO6cq+pEdSH5TeLy1BmIRU+j4fn1z41QIibyd8dnNNoCnZ57Hbp+l1NG1Nx9+Ac3DBHOcr+rrpTWwafFPpmLpGZpD1ncA0ZlpQqfKEH/xmYLvW8u777pt4rq7DvXh2BihwyAgUd3CjBlhOsuaLOS9LN43UlJ1QW1Hj5mgmMaeQqUnAerA3YL3mjBGvucoBorYybp0rNNUg9T05x6Kaokc6NSj/dA8EKLXU1rHz1oZpTTuUVMl0HIo2ERKvzRxCP4Q2gSK+TUDbCEWiwkVPmubJjdN65cJHQVytjGIj0kxZgJwOyk9Uzp2IpECPsO5vYKo0tOjSVl53xbU3pHG/LpAceDeYeoSss74rft5UG3B3fF0BG4EeCV4R1qRbusUKEy5UzfnXpRSAcpHOPfu2heR9NY6WtkKBZrJEIVaEiT6/zAwHktOkM+Plw21GmhQE0iINzzED7MBwGOHgRgcbpIP3HM1rz3KyL5+3Ole6rmuORw3i9QUR9aJP76ZDM0rh5Ee+81e6rsvqk2m/FZVSC7gJqCoYVp44OWhKv4d6BMlnONBKmjdPBYWUEdwtg4+60CsoyhC6KIG2HpI55uKEaR9O21cL2JpWks1RH8beJ/dFFn4816xbAN4SjsemN0aV3FVbSu/F39oPqHaZ8YOHFvw3qpFr1ShfnEfWI2os6QCINQadteiMlQ0b5rjjPg2FmtIxAPid6bPXTK125JqoJQ21G8YESYu2RMDsRmDgZTOArLUt0ah1InqMPEqoWMPx3kBYRLfBtOGeLNK8rvWCrl3nIjdLiXuvQcg7DzcKUCtFE+8vzdpWA0cLTFT7zuNV1wCe0yqJ70/PFFo5svjrmUasniHyTqKZ6nlIwZvGWq0rZ/9up9Ry2qQOZSt9Mn0n/5n3Tf2cWhPaBmMktoy+mvdXbSHVVst9FNF3HPdrpdIELif1ca+TIVgidNZiuVigM7LrLZpdWMivaWG0BAtwuxD8JlJbgzxOkNTUgWjbM8f7jZGIbuya/REgqNC0a600v0VcPkc0kePfUOVSkEFu2aTI9dZ51v9y8z5tqom2qbSMbkCqT/Q4ysW0dXgDqcNxfdnicVvR9HIrrfCPD6kQPpA7WyONpHWL7nyJCrydKlIhcVRzJu9Nx3MK3FqPmkJsKWRKVwrtQjAwoBgrIDkJ1OObWwQtS+PYdDxwc/wPcg04fVRX4K4VOvR89t3rsRN3SnPFJO0pHFKA8G9SNdUG+PAGBWRRiQlo0HUd+r6HJQPvXLithULoSBS+oTIBEAGjXb/cxE/eBTrZUj73nzxvKrXM8ZrGKb8DtB2ycWWTZsqcQCHTCEWDJVhvoD7ZlC0w8fvKtGRw0KQUQEN9QtxsYo/O9qJJsXK9qa75nAhDEDRxeU5D71J8MbijIXDjBAhFwOI1YijeLO6Zwc6L+9zoMDoJJRuBG4gx4KP2L7VOnc6QfQAqQWY6FyiCLSIAMeQG9XIG1tpk1EqDBaB9YbRvMjDLOeVYX5an1eUytYHD/Nc7jZIrn/RrCNUbbhIiAjpr0PUWnbUSGx8eGoo5157TfOQogGvgln+hLizOBBzalTaGVXBWFFK+3oLguo/ydDRwx/4P5ampk4auXlgp3Q4LBxGutIqYQdlFHFz5M9+lE44CrFZ2lCZz/DpsJMscIGDmQEXiyhCDA9nOCu8JXdBi9g7eYfDjZJdc6jAHamGyVJsxMc5GBL1yocxx3a8L6i0t//7v5Dyk+C8LcCdBWWs68r5wvz0bWARozDRT3UBznE6kKkDIWEm/WWtBesqPGYtOgSWALARkjVdAdmH6cnD7E6HC0JOUDITTgrFcYoCcNgKIh1hkXL130LClejvN6DxGV95ebiD1tSDxvohdKvlw8F4iQ6k+KPldY0yY4Tngq1ogJ0hhyn2B3GoANEBttrFIeY6hLs05qH1rATbwPpkz4rThweyQDp8BcuG3RicXiqwzhK6zsIZgLaOzLHsSRm4d0lt+EAS7rgvpz2RZ1Boze4N805c8Qz1AHbN0kz6v7c1Am4zMxTzdRYk6Hrhzs/IeEuJ3MnFb5z00AKIlWhgrcS6ssVh0FoaM6ACe4Z3D4EYMzskpuQxkWnm3+Muce5+v/nFm6redSjP5FiE/k/L4HjU4AWLSa6rpBhV4xpBov0QgLxtTungF2I0EPULwKiEEKyCdBkwcrXpIlAI45ZdMgXzMFTg07oj8TsgvO6AMDCm0PQ0xZ3zrMWxx2bF5PVrzpkWt5Px5mW15732L1gAHt0ukdjknh3S0/1v10cNN6kporUHfdbBGLC6EO1l9VU9Ncgx/Gh42Ba7i4BWTOlHnCLMoB2ChOeWwlsksAJp2OgfL+sileCfgrjch/kNPcdDqz3PJmplKOjmsteg6iy4cUyYA3juZpM7DjSMG7+Cyo+w5aKs5nI9+4u2iyjkx8Yqa8+txbN9EqvtOUg10iZNmaVTxfn3Uu/Wd/q2/t7hiWeyqh6OoA5EcErEWIEty4TEp+0KwMCEAnmjXZb+X/a/A0LrfsQZNATEPxvSSA2YWYA8EeX0MPuUztZBvSzUd0qIStE/z+Cn1HFZwy1MNorWHS9R42YNngFt4ZwMKB5XUKsuFAYOR0/PztNx0EzfOB6RNY0DA3nsCeQmQlb+jlJv+3e5THD0Yd9qcbBX4rWvf9Up63exqM30mc2YuaP05AGxpxwoaXdR8PNLFrB6jc3CsmtlMPqBghiaAACBHrAnhRpTp2Kg3wISLvKUf7pom9M0tz5bUxnTh1PVMwJVdyFw9o+CnoF1rTzl41wCRn7aTBecTbRDktQgMobnkerDsODoQrR6hJBBNZwBZSAStb1mHVtvrfozCGimWSQvcVQTU90WGB5vjUdJzbWE5Z7HVwrC2cqKwPfDeXF0K+k9/zsxjk41jxGwOnDibOIbt8LN5H+fgnK58a33PbGCch8l916k8RNTECqIgRN8ycB8q4JvU4ggojvzW9ThUlzlBlAPIm/QYz/M2CDQ1y+3jznkM4yBlhnJbml3Mx6eTdKKBZ/UGSlqyobEfO0Rz49wC2TodIxBq075+Zs66yzVtfS7fVcgPUejfc94+rTbqhnEX4mFwiAsCosh2MHN8ToBE438gbIAJmFPAeyKE2CHpyLTees9cHhg51Ke19UZso/ZYAyoRRbfSnAOPtENwH1RrrdZ0OQu7moPunK93PXa5tp1vQLaso/z3KBxmBWrg59kXQjm2Ifyr51S0VimV1bIYvJ9q/3ndqtWZ5Q+EbUoZy0CvGUr7S2F0sveDAKf2CdFWeucOeCgFbSb+mQ2+SO55fnBOKEQNjgW4vRdqZBxHOPbB75XDom9PHCJh14jklCVPyrodmN+UpTTXzkPafJ5qM/hwPqVpX5vHCP2R561Hve/jK5tr3FJuYKkD6DBKMGR28DwC3AGGITvnBIRbWkAlGHjvASfHftiVbdLvc8DTmNr6jACigSELyWraVmbhWV0GurklItpDHXAq0/L1KuxcmWmAdp1ac7ceX+3LyeecQVvWH2oxKGcNSnHEgcqiIAFLGasAqKr9q1DF9Paqgm5ptCHNjan1k/qMJSZ6da2a8NsK2bUwSBbUMemO7oAH0rfMmLydVHbkoUk4m0M1Esn0lk1I7x188AjQU3egJC4Kc5NUehsYqzy3ehekyS7ZZOZt+eeEXZrTau+T6sV/KP5FrN8MCEzN/vkygdQu1aii9pRpdwJW+cuH65ULDV1gCoajHzGOFt5L5Lqo/cUARlphzlwB05zKLwz2lEAxj7Gu/SgbkVJGDSpMXbAIRPsfxzHG3s6bWNM0YiV4eD/GuiGz3CIGAncazzhfM4unKLPSpnNNvejzbFzz9urmvryTNPrC/z60Ra0GIFGK4uBC4sDT0Mq91xPK07mg44bKJyTvE+b4n9in8juyfp72Wcr79nQ0cB9S4GM9Z8ok0K0L5N6JhCOe++7OHDipMxEKU0tSuZALBjyIU5XwpOI1EKKGCJ0x6Ilgg7a+D8cTBjAcIW2WkPQnIXCoxsAaC6txG0gOmngvfDgzYQzgXYA0Z8ARNAwGwKS/p0EjSo/zocFE/kzWbTOayTGUylyec3mFv5AGN/hZA/CUFkvOYTLkYlkN5mWM8NDEkBOHPDX1c+qCKDznJYSp9xbs5Kh5UukEhMmGZ2BBTPBsYaxo7GIthUVKBJAFiDAywFZOyDr1ZvCQTU4KR9i9mNPadspjXpO0D6GdI0mEOgaDHQoTPAdLhsY6kfkgWmjoXwKIfbTu6jGqwTb/PAI0IFx2NsFyATVdY6mODoi+6NCbh8Ix+M5YsWqQlKH8wBAQDJ7pJArReQP3z6wejtkGopHQvCxK0fQIvQeF8LoiHBDva45lMAA28KwCx8S2ptjubXrpmHQvd8BJ4gzA5p6deb2u+N0Wb3j+QNVyPuvuqVWXTJuq8tWqMTjy7kQESwYWAtwWgPESw2E0DMceDhWnzUnLsAr4XRePw8s5EdnM9CGsJAU3BmZZ7CYEqi8ECRBcmETDyz9Pa+tuQrS1YOvxPATex07UZBVEWyT+jFoNIfrPugBCHtLHgIyLal3MEhuaNQgRexEDlZafNEWhFJg7MBuATXXNF0AwIUochfCeAg9MuTsexf/lrZDYHB7emHRsnT28A8R1LYyzUmgS2QYIscD1MBcz0FnJ36mFEAGeijZJOzV/RMEvIUkDKBLBUhtgWsA9sbjSRIjP1hvFs+MNUTJUVRVXSRlkZgfK+54IXdelvFO4vriWjJFLnWWheOjNRWkdBIvGWFhjgbjBWFdOhbDmzpHi1Ac4+runvicVQvDQuOz3AW3gjgdwWunNGNjf3XQXIEumVDDfGNF7RLQ9ARfvBEw8+8mk10QUdsVtCgDfdR2sEiSVyZw2fhDim5SLbTop3t7IHZqMb4qSyfNO5nEA5wZIRCCp+jqCjEZ4y+pX8skAGTntqIGcSlsslMceJDqzWG+kAj4XOIR6ReXg0nVAisLKkEMlgSOPmmcolbT09LzmE3PmdujWHGg0j+b4NAA7B+eabkg0TEl9lNRTOxX5VPkpsDqnFktZp0JJmPRLpryQcNyi01CwsnVdkRxeM9P6prrptW4UBaquPf0dwbJqXfRA0WrirI6JSjsmfec2J+fMpjeVXievYzo1AikROtvFSxF0IgKAQ7jpA4l/lfjtKX9DciowRgpEFtiHGSAfeUJZjIjatWqVB+v+Bvp0ri9r4L6rVXWXVAgmQraIpiChv6vHySR8ZwVokSP3XuKFWECiwR3wYvIikD35cJNK9qw6d+djEdctgwwid2tsl+gETm2cxqZWeqxsZw428nwah7zNx6RaAWiFOZ0IUX2W5q5KO1xWMV/D350Nyg/EE8uPVVwWlMK6zleujSs140QQIfRz0LC9g2eOh5yKSxhM8hAJLyZrN1hc0TJq9lcsKo5tFO5HKt3fOeDWlA/EIa0tmdBvtx512YfKlYVn0RubD23iXINtRs4HY09MQUOU1jGlWMRqyrNLlBRz2NjMzDktg7I88oWgf+ca6Bx9cZcunQPmGgBfd5wOCU4Oq0Y9PXJvj/R9er4I9q/5VuCXf6/mN+vRdkigfzHJ0+ILLQ5/lh4kzAzjCdYwOttBQVeiwsoNOdYaIN5uQ/CewmEO4UklUl6qrvRpaWHE9jb6LJ8H+Wf5PDk0r1tjIAIl81TBdA7kz7XmQoty85zim4QvogIklE+yOhUc1UqiuA+Qg7aMTaF5R6GoVpOuC1fGFcnqBgY8p3YqZSZrUtaioXZfiDae8Dp+zzgWswF8B4D7Ni22BZw1SBxrXtzl2Vb5x75PlFhM2fziaMJ7hBjF8TkgH7KonVsKp7908GVxy7gzPI/w3sE5Nf8pTGwUAHWf9oqlV0666TNT/2tNE3e01uTPvr9rmnufI4t9XCrAQjKO5nku4ATkOehmToQsM6xRaqbIRSsTk2cGXMiDTKBlXMZ0B4olXgqsQKjH28O1atllAgrYFDYutewcvBO9EHqnEqA6/3w1BrlGn18CUfddYe20+rUC4zzlAuKQIlYAc+yxtAnP4ElesX1an1CX1C/6WTaPtB6sc6g9/2M54ZlwFzSc8+FfyINSX9bRAJlKzfo+Ss23Dtyvmw5p4287zTnLxwkdfIrY6wZk2oQkqt4P9Y53CBLiDGOEzRZmcT1hD88jxP0sLDyTuydRYXW9aXpoThi8Ca36LmmyqDLgvk1g5YJHk9AtSauchN8Mi5p0ccf2UgFSWhfPLDG+yYG9AxHDkIclAze6KKQlWBNE6wrCV0FaTHPlRBOwKT2WI0CLIhLtk4tYJoUVBkS6TfMvzHquuPwMyA9pzbEejTzz9+u65u/nJx9lXSBQErKmas+D3JWSQCVNhfxyCbVQp3Ok6LdMaORt0vx02DXgl3M+3jVJ1DqNGTZ/Ucj1MK/ulo6/uuwOmX5zS/du6a7a523vH9Iiklagt1f7cJs1YvjQfGJRxYP5ANKeMg5EZkm4fZq10ESxcKJKahNzol3OJAWifCpRFAQ5T1dtBilofguDX/b57Sb/9D1A7ec6fkmxWMkXW4wFUEJ6TWqR8vfwgPfBTVG0LSYZQ9n/MBJsjDh4IGiUOkTqhDgDlJC3nLyU+gl9YgqwKT03ElefA68JAbM4A9bJnA4Cq9lnjeentMA03xYvXb+nf+shIxVo0u/a01TMSQVm77mI0KtGqFQnbHByxm1rv7ICerj31Qg1Beh8EqsXeb4qSDjURoULIA4IgYfXh5kBV60TLfsu6XjgrlZ7UU6BEnltvpvpLtTKoXcO8XnOe+wNwcPDyd3fgG4QebntRidBAsEE5IYouy8xm8xR2wu71oGW0bCgVi+URTpFyMyRr+Og9RtR65paci3/ZYrrpgxFbxjNe6ovtCZE+6M3mSa1OED36PcRsKABoShEctPDI2LtCF0CsHFg7EFMILnuBmwBMhKtzrsBsALUgIAJhU0x0dKcXEMXNryslcioFKS6Hu5Qz4UYGc8kUz5K8oxHVShLoUnDVXeehU6rQFuDPyG0W9wQfUEr5MBba+otypI5nVSNglPfMXqVHMXZEWmpbPziSAXJZfS4OOSyAs7brdaOV8Ul3DjvHRyLT7+xycPLeY8YFhfIhLwCcJrPtrMwMPAkLp4UriKzcVzU4lEBG7rKyc3vcvu7lCJum6mPQkTnbOLeHSyPp0pqXrGg80rOBtX3bzLdRo28rlY9V+ZtINCqk2MN9J404fRQ2iAD2jeQ1NpHeC1M/tJdyiDFg6g1Ru9F62PIpgqZtHBalEFz7MILOUjrIioQszJfJ5lU3fc643UMjVOY6ZzAAkD01pmpaXbKNZnnDh4ODuQtSOFSaS2lTyiRNpFW8WokC74QUYqOx4g8tXMEIh89QVRbVvM+1i6nwnw+LjkYCXjrJulMJ0KZGh8QLB+iFpddz5l6jpYadZj5QQio8hlFuyoj+n5VXu2Rpe0nMlCdOWcvEAEYWb/LwOdCrATuKo4PAIYD2aD0GBNvVmJKMYLy9mY9BoCSXzcRlAhnxKpUrbl7+t5z3G8ztczHQ0BTg3rNKc6VUUahS3nVnF9evgnUhf6t3ieanz5fx7sAFDs5aTy18KsF8cxz831SCflvMlVChIBIQxFz9OIRLak8tmx8GZ8k10zZM5wbAdiAFEZcxqLHR1UNBQ610aOmLH2SC1hxO3MwplS+KF6yoHZSNjbFxhojubJN54xqqLN7Eyb5NHMQIj7IWA2EJvWh6U+9zT60zXZ6a5DNNFmPPKZ2OryimDa1WAtraKbupa5Y8vuhNOgF2/CA8w7Ou3ACteqD6l3nhBYj9TLRuhtAwwvMJ0a4Qzhu7oYZA1C4AejA28ekd8B9S5rj/jTVk+4uQBXvSrTZre4NeibnLPVvA2oupFrbnuRlTNxwapm79fOtttbpEHAfeu9NJ9HgUvFqlxilPygJK9Wo87pbQgHaE8CgsC9BHcgTeCiuAUg/MpNbtU05fEVFvrkGK7fvQA7sOIZnB2O038KGmwn0V92dnNzalPcGAgD7YKojacmT8coU4zpvFT51n0StHqWSodEUZU6LINDgWOUGaEZNVGtnWg6152mtKbMKOURhR6B4mqnYvCQTtXktM++O4pA76yZrZk2nE1JlVxKll+N7meVAErbrWwHuucX+NpN5tcDizz484kmeTuz7Jip/aWG3Tr6i/JDGH1xh/wfPyyyzyWJsiiBWA249ofPvu66DpaSe6TstjZ2rZ6KZekADK2iwxvi26Kmy/qU73YRmegtzhiKgcRJqAWgTeKu2FywQAHkcjlwDr/uTDMHCwpMDwCBjYXpC17lAmATNO6cxiEJ8dNH8ohfJhBYjeD1a4hjOK2i79C0x5G5Nnpjq3udzJgfE9HtOCcg7icP24RmfbXzr/2STjprALfFhlMKR+vS9zfhz6RMTLjvWC41TSpum+RzJg0XVc6cAaaqAHywOAJSup+Nik3Y6Z/L1FudRVjdmyUtiA8n8qa1jTfqZDWPPjWdE6Url3CdqJfCWNO5DdEKdjgV+uumx+PMnb8DI+ObSjgnDz18AmAFAz+DsaO2hflOzPZrvQGEuNwGy+jxd35XAO38+/n1Lu24b3zltXT7PVGIcP/7HlEfZ37qphQiU4RoxohgfOdZE+8ijmF+TujUMCwqRGk3QMOVIuo0XyBIIEtekpErqJDIngCBxodEZkk1n9eNnThcDAMmbQjYDETeqOQiyutp53mwoHuhUkPPMsZ/EOiktulz4yBVfOn8QQVpviEn1pDD/cs03deoh6y//LKcfvc9ukI/9l23iZ5ZPkRtRMVdq8D40J5uWGGr6SK+Ly8qtfq/bddf0jir51pIenEgpB9I5DSFy2Y3vWkDcWgzMHOKZtGmg1wPT26gl4M2ZRNOiDShFUaw0W0OiuYoGazLgVpZg2g+5tjppEuuFC4S+62CsDUBuITH1RKOFD7vB8JMxilmRRofkAPIpGTDYA8YwrM1PAUrlvUeIhJfACtAxCC5qjXYBkIsUbDZHwu4ZZ8e6dS+lBOwgDDVo00zScvI9Fv1ctfbYEkoaOTOnU5CUKB6fCZdRN/8bgCv2inpgAeoZVbQTU+COGnCpX8Rnc+tjLomwljySgDDlUfzX1D9fG7jFRJ06hL1LhxMz4s0kacIIfNymfauJK94hGbcaaSIGKE3UyCJ4yCIOZxcMKOalmgsB6dLSA5Nrvn5SbqRMY/UobPAkheNN0WxFf5FqvSZojEDqV+lzA7lcNy7m2FcmYRBpf4R6QyI8Cl2s/SUPGtNLEDBDUTuG6ULHE8h3YB9iQOZUBZA6I/yuWnPqTTHVtXkMiPDJTHqvG3ycgApqkpvSskh6v84jxCv4KFgoBSWCQCeZ0E/EoX+TYMgrrHM5XT6RhLX8LR4hxiTQND5twsrlIhzbJbfICC2oLpoC3NnNNzU9qmWG/NT7pCSnSoER+wPlvGROfRdXDSUrIx+oSBtxPmCSgY/15mxOpj67ZblN0hvRuInKAxvv0u1JF2hYb/pp+EnZpE/9qtqA8LNho0d9qzNTXDTIYKhTcsFy7MF+BBjhAlsCw0QQiRs7yAA340WPapeqfxEEQq3CUW4Bg5J/fxMpTn4rHKccUU/9JbJM+HfPWV9FjpuDV0fQEDUMqj7HDIIFQw6s+JHhRo/djgFahUtpCYb0KLwHyMOQhOGFTbe6MwA3lpcmkLcyF+rlq4KVDBwDcBy6tt13yj4YQ8pZwAUfZM9hExSI4zMJRgYB1jBaMKEdArwqxCI6IfmM53M33yxF8VPe4bhxSQTASowROAlPy3BgD8RIPhpXJlA8EbxdyQ9HzTlYLHnA3eyhyR5PTZPoOtDOjMLTS0BWsbRy7R2ZziSWXB5KGNEK4oKWimVn9T+WZn4j8bhfZwHeVtGj8yagXwLD9n71MBZ4+ANgvwWun5XfPfgQWJ3L724EXvxGsOnhR8D2EtheHFG9BicWdaaGxTKxyjOT0TknkeTizeFAfphH1mTLXUnNw/S9p+yG9Fh2gxa4JaWNR0QPCtXeoPcrZnV4O0nARaPAkXKN1f6PbsKp0NOm+nEEgOB5k8xpQLRSRw4gveFGgHAYXbjMImi8rF4LQagiaJTkY58TCZ2TvC0Y7E2sWx6KNrasohnylMY88dH1c63AW3Ue2YtJrJFaSzIn9UQvB+FsGVEQ6gax/EgCsQDToIkn0anCMbkiRmuPS1CtgXaOZ26lmEf1WetfaUOE/mBZKw5Kq0zLinlUGnzOy+f1rtt2Fxz9neG4F2vgH//vgH/z/wTccLd3jQX+8f8eOHkk+fzyvwU+/bfhSwI+/CPg6R8A3QJ4/yfA/+f/Avz8nwInjwHbAX/xz4Hnn9yj0hlFAZ4uRlP9nXNw+dGRnAOc47WLVIHStF7BlJzMYHm5zrLkKQHDlWGq2oj3bxe3oRaMRo4TIIjaHVLMbWaG4QBzUSjKu3K0o7y0Vw7SUIjJDTBnfZ0BtuYRw3ZCKRlJuXeGXjXmPcOJzIBzLoYS1WeYqOi22lqp9zTq8WdOscX1ucN9mJQEOdBJCbwri2VA4qFT2xAOrEh+eZwUdXHUeuk88Z4x+uASqbx6dm69tXl4qwBqtKv12a3WX96nUajdUbOZKTMH8ruA9/cIuNsdZSzw0z8R7ffp7wNkgNP3gJ/9EwHT3/65vPrxPwIe/xj48hfA138HuVkkpAcfirb93/xf5ff/6P8A/PYvIBe4MvCL/xr4xX8D/N5/DNy8EO379DHw3/3fgA9+Dvyj/y3wX/9nd21OCW6TAWto4ekZlhOQTJFPLLMuN1wmG2HMmefBNH6xeEREcjLydXGhFWa6+kjL7wTEQwcgcTXzEdj0csXXs9Lmk2ptiUog8vB63U+45QZpDUbNULHIM8ONYwnaEEqhNxbkPMimhaYuhJpX6nMEeiWZyTmm5AArMcXEt1g34AoQJoruba3EeikxpnwtUHqdtICtpcEnkKTYX5QpGiKgwrzhoGgYPSoeqLt47N/DO9lI9DFfVauDQhKuCPMhP4ZcT5bThfV8fhPWei0Q4jtV1onvn7dGqRzgmGddz/oGoPushTcD3JXZLx/dovUdnXWYkO1i8Q/+17IPtHkFnDwEzt4H/tH/BvjNvwM+/sdAvxJwf/+nwLO/B/7pfwL8f/9T4PKrlM/qHLj8EvAjcPNcaJBuAQyb9EzXA7//T4D//j8Hxr18//hj4MnvAY9+hLZ2WvFoeZt0EaQ+KqWt4bSZk55JVIeCX+5Tmi92df2rpbv3EvAqD+VZa2zpYFnpH66ixJgy9rJ8lg4QaVAkDiS+Zw7ct1oXmLz/JpLmHcsmXWRpMWq7xJxXQSNfeE4R5JKCJYDaEWDgQM6FjUoTQTn2ZQFm6cRdpE6y+VB6MjCUkdWxK9pVt7FK+k7rxnLO5tEcaLeoCE2OJbaOCYd/NL9a2EcBFVxckSkEcwClG8LynA+brAkka9CrrYzb2tPqp0P9GL/TuuXCkzlbW+11PTc2t2r0R9SpTt8jjXuaTCda9n/3fwfggd/7E+D8A+DmFfD3/wq4egb80f9StPC//K+AV58CP/9nE1YC4x5YnAIgwC4kXz+Wz3z0D4Dr58Crz+X9v/yvgJ//L4DlCfD817gXBVAsSES01JkT+cp60amyrifUNDh9/oyeVMv/CYUgnGrlcVZpmEiTFqWmBaA4BaZCW3f+hR0oFzQF5ett6NhVK4BcxGemuPzJSAqkHkgSKUjBytCtN/0+mvIAvJNAUkSJdhGaY0R9YbUPqr9aAF03vTWm0M4zCqoIT6DgXgFgLgDES6MEkmPBIrfO8vdTQyCxm7yPnji5RcFA6I/Q3xR8zSFCzDmN0zGl2LTvc0slzT31ICmVj7reebqrgjgHtOGXwMNLY1JICQ2FUMbZroG8NQ7Hjskx6XsN3N6J5vzxPwJ2l8DyXKiMsz8RTfjjfyygaqw803XA2ZMqdDUkj9UZ8IM/Fi365W+B5an8/em/A4adUC//7v8t2rjthVL5u/8/8OP/KAD3HdPtA5iBYgO4c41wbrLUR42PnTS5dngofkqoZQR4BRczWaDlz9laHKpey6IBEm2jIJ0/k7E9yV7IHmCOIU3nFlf6PVEGgLaZEIJ0NkBJwUu0z3Eckce4KLXqMmSo3liebqhHRTFkdciFaEjty3hLoVHUleowsFkXgW49PKQbkvpM2GedWHytVNidmRXqA7WFxvxutXm2bjPpkFauCkncIEXm4hjmUd1fRVuzdtQW73cKuPM19abN30OJPfBn/wXwx/8r4L0fAf/6Pxde+8//OfCH/wx4/hvgb/5bqeDP/5n8G7bAWG1e7q6Af/tfAj/7nwH7a9ls7FeifZORf//+/yfeJIBsft68BH76HwOvfgv8/X9/x3pXi6/5WVCriTQgPEetJmzdCPfJBHa5xJeHxAQXDyvdSAOJZmzibmGqz3Qxl4uxrn+iE9KtLQpSUePKgS54DxSWRbNzrGjoGm4+XOTKAZi7cAUjg+BJwVjcyKxndGwkpKbtsGdAfG6DgPEORA6EEKIVssh8vkhnAFKOUks/WoLcnA6ADEND7AYpJnU1RiYoKNImjhmefLCWMvDmsp+V0sqBG0QHF32kGEi1+fgN6g5vAWA6VVvNR7Wiqj6JfaO5s3ahAG6YEXqqKFpck3kWXtTNTwVqCodrULRD5mR+yURrLU37ZiqIKXVaakcB2qEfSBQRAsSCIoYjCdsa80FSWtS68CF7RGsp25iv6nOXTUlNrwXccZAjW/jm020NGraiCRMhun09/zXwL36Dwg1s2ACbC+CrvxWgrtPzT4AXn2pnA/sb2ZTU9MVfl89/9pfA5/8eE1ezN5coXHFkIohraEkFEoTTfxzAPIEOoonOgtZpzgQwNJQD8FR7OczhpXIAxjTeTly2mUDP/zjQ6rjoPWIYVFDMQNZLaDf0RKJeHyPXijGJ1hcv+fXBywEAeQJIgEHB20XQmNZHTwgSZWFPg1OvhQlShBA5akA0VBPqzQZ6y7oeWQchhjvQz7XPFbTzG+YVuGuqRcdkOlZpA00BXVM95vk/Zp5GkVQpTA1g5CquNBDDBxf1zcBSqZBizLOPJthG6anSEsyUBWDWMtT+LPsnWYm19j6nzRdcNbPMhSrlWrUL49bSsk3RwLbidFt6I37c33riqalaA+rzX4sP9md/Cbj9TDZ3BOG3B9oA1CSDbPaZAOKk2kl1AKM29ctFXC7suInYAII717KamGoJ6ILTxRG+weGjWgyCA1GIQRFMTq83x4AwGhUHBoY7EDoQGxAbOPLYL+QyZucHGOtANKBjD8sMRws49Jk1o/AfrASK0BL7JCkniNoUe6mnA2eucZw09oOacXiu0rDz3/M9CQ5aITV7LY3rhOJoAFrerlbZk3nBh8aqrgWikMk1yFZZczOt5tujGRRSvgmff6YWQ0151bfLa9uMMbAZcKP6eQi4o+cLpv1eCNo4J6axYqiaZ3Wbjkn3Au43xdN8k+nV5/Lv+5JUWhMkCppYlMm2mSg/DeDONasJN/0GBfFteSkfLOZpuRgnzwb1jmHgoD7MsggEuGXKW+9hsEeHEZZFs/WGsCeCNR5+3MJ2YqXIASADz0b6MujfErfEhTjdDJ9ZJjW/ryDmg6bu2EmsDCV0kXsPiLCtV6x+X29q1VpzDgiJNmul3PIpy2mBT8yvziV7vo4pEimFI1INfvlnd9EqUyyQ28ql+PxctL50/D61MQVpm7c2m7SQCohQci5g87YC2bkANPo8ZH0fTVvT8VeXfctgbTb9t1r+fVL3m3Oc/POf3evdQhtGyacpJyiPyARPWo8+pG5g+heydZCjSntc80+LJ+c4heL5TEtNtQkTeV6LI82bAdbbzGP7OGrhoiV7GJZD0SQvhPscRduX06XhFplAZagmxEV/Jl8SPc4evxMuBam/xAbSNhITXAd8vbLwPMDtRixHAqiXuBrhPeLUgxy0dlQUho6lAv+UKpj2stLqdV+Dkc2N+yWt46HxAoD65H0BRMdg7yRDndutumcUTvZRAt+p50pN76HIm4GVg/snnwHLdOWa/jwoTKtn8rJE8KQ1VtDIBLAvN4PvA95vyKukdEq/i3Z3m0DQd/u/fB9YeLjH2zvNhZmQDqn8O+R198QwV4s3mBtFquQWJQxAWrYtDb14ZTLbyyWvy+XY6aXrdWIiVhTB/NtKqsh/iWVD0YBhDaPvLBbWorcacAnpeDmMHKIxDA+LvWPc7Bw8p0BGnikIBl1YGSCUE7mol+C4msBystUbYL+RknnsQD4EIQr0BnNyeoutC9lSGJi4sVkJ3awi2Qupbi3h2u7PHETyKXLI8pHm53Wfe05/0+rV650nwr4EWZUxkVKbWCrpfeY0XnW5MS+em7NV3qMBPVvBf3wJ/v1Xs9ZBTbsQpQNR+WEpfU+iU04tjpifkSvq8vs53xpV8l1I7oMb3Pwff3k3tNUd/9ZXwNFmYPt9ruZjWZJH+5aMo/KmENgm/8eANQadsehsbRqSLOZiNWi1Goc6mOOC8MFHVzncun/vam1R9PxImrZjH0DTHxw+wwQmG2mLDgMW7gon2OK03+OjBwM+fn+FpyeMM7OD8TcYxh3IWiz6NXrqMYwjBhisH32Ey3GNv/z1K3z5asTlSLjYMS53hNGewpslAKVdPJxVwBUgLYPckwgeGsDsYdhiAYPTpcPjJx2INnj2/Bo310vY5WOwsWCMYE+A68A8Qg+Pa/s7a9H1Eg6WWbhzz/WhqdChRkKoEpH4VOfP+BD/g5OVRbVAyIARSGU1Jaxq2hwE3cHxCnPTGNhwMa81YTNWLYysXQpSGi8mdG08k9DZLoSKBcAaBVApJpcuepBNCcnPpDWu803XQnwW2Y1TRq6fo5cL9P+PP07NbvHV1Z4DIP3oGu/od6JcBUAPn2m8Hqm2UHetvYlj0/FUyb2yf0vp/hZgmVSluPf7qADydSuUsp1+JoXJQkomVqJDeALWrd8BFBOmMCXDIi/Lb/fRvDBUz4+67snsLrutJFTI7gXaiGCYsTIDHi53+ME54aPzDh+dvMCD7jm67RXM7hoYRoybASNbuJMTvPJbbG4uwezx8NET9Osn+OPTU/zho4f4bPcAn153+O3LPb7ejNixBcPGykQBGa44K2QjM8K2JxgMQ2GDS7XwuKglD88cw+NSOO5P4ucIoxtkNt0W472AM/laQ2MouRMB2VrJU2OAGInGpycQiwblPzW/CtCSQl/5szfHqMowatkJfJWjjoIvtCvXLI0x8JlIiJuLzVKVPqrqHfs+m2MVraH0XK2gmUrJyttbf14DN4LGnT8Tu4OC+262JkV4AXr3poeBBqmKY9/o5UPpe6Vxt5Mut2+h5FuRutaK66FpD5UqSaZ+lESzgREuVkv3Pjft1Ayt9aTywAeQFnpcv9P5PdOqiQEarRdPwGgYxAaWw4LV+MrMYJarxGRTcIQh+dcZj854nJlnOLEOC9NjRcAKW3z0qMMHjwiPViPM9VdYMrDdXsHtB4AJlhy8GzHuPPZuxG6zxzgM2F5/BvZfgNFhffIQ6+4Mf/zwI/zs4w/wt89HfHbj8GrfYzca2G4B9h4dO6ytxwJ7rDqPRQcM+60AEQFMFpc3I2x3AsdAZw08r9DDoveEnr2cDDMdnBy3BGiEjQDnYUnc2SxxjMdeg2bsa2Mi3WLYFuFmJbJj0AqVigkaOYB0uIiykQpcsLrUpTjwiO/HpMKomhMqQAxRjEtjiaRdYabpqtRZmN84FAEyA3HVTg1zOHGq5xZYjtF7H+ZRqq3mXbv76U/H2SUP2mdwIBZXzi58l8QxYv5aVh6pUQWCCUpFnZjDTUiBtAvcm3znfTxT4fPx0ro1xv5QOh6474CNLQ3v2GfrdBxfPpPHkfz5sekuZo1MUopVk3epeuJA3SYfJC0qmnBIv0/b4mMZoumUvGC6F7Kc8LlW0aoJVb/Fv4M2RN7D0ADAiusdLBw8HDuQIfQYsfADOuzR0xadv8bDlcfDlcEH753h4clanmGLlSEsAZwtBli8Au+usLu5wI1zsNbCebmHsV8sYDoP7hbYbRhkejAD4yDH0cdxh83VFQAGffkrnH/4+/iHT36GHz48x6evtnixs9j7EQ/PepyvCO+dLtCPA5YY8eCsh6UVjCXsvcduz3j+ymPnNrja7jHAo6MezB32ZsBgR3jaYTQ9vDcBEBysXtIsvp0iCNhLbAUPgGzTdI6hWFl8xpNCLeBA4VYMCoASY0mjVGlysEyuc6aYA3P+zraaW4VmnYWLZR/isOfv52VXn+V/F+oXc0EHTSMbtk8mlnWvHSiDzRoEglhFKWa2z/hwVULK9TP1ec/L15QsjtS3sZXVfkfd13fBl98Bjfs/rOS9D9p24DTCQp0Adw7UYRIWoJtRIvUkVO2nldJ01r9zIgQgOFgeMIIwEuAtAPLoeIeetzjhCzxe7vHoxOL9E+DD8x4P+z3Ouz16fI49jxhHD8sGZ/0KlgZYvoF3l9htr+BGh+1uL3yl7SMPO44OhBFwDsu+x7gfQMZKrAxijG7EuN+io2u8+NUF1s8+wXsf/QGevPcj9O//FH5xipPVAMvXOO89+GYD2l3C8A7EDn3fwRsDnPUYHnfYDgO2g8PADrvxGs+vDFauw7qzuBwtrr2DpxW8tWEjVIDZEwJwA86PgBtAei0RSje0PIY2UAJInWZd8ajcNIzucFlAKgVt5xA322qgzMtRiseG+DQuhKGdB9G7pTq+jtav5Z45V17wEYLOWMrmvzBWmXnJYvkUDJABALnRCNAgXgrakIseKgqldV1e3ifRwqCpcAxL+TiTF++A+2C678R724lZTmZpFD4AUQsLT9zOt4fbx+MbXDp+TT0JalZ6qimIFWDgqIcjCw/Rvld8iYd0gR+eAz842eGDM4fzFWNl9jjtRizMDnZ/DR63wOhgB8CPjO3GAHAwNKJfMPTOxsifEsO5PYZxxOg8TO/gRof1+gTbzRYnp2ew/Ra77R7YEzwc/LiD2b+Ef3WJi+3XWL7/Gc5WDh//3p+AsMf21RVo+wq7l5/Bb17A765BfsDOELrFEovVCU5OztENDisGusUK9qTHhyuLHz9a4GLf48sbj88vrnCxH3AzWOy9xd4v4WAhpz0tBpbTkYZ9uEdSxkRBM7/0oAau2sKqvSFK4EZBq9XgX4P0FICn2nbio4UWyf2kXxe4y43ZcmOxzrMuqywvHbDKqSG9YIOQ7rvUDUVka8lYE2kpEVYmCFiJ9Z4HaWNm2VjtusIPvj4ApGVZqvxisvF741RJvLX4Owpm37+UG5F3TDyN7he+KHK/nd/KMsns11bWOWzXZcdJCcCbDjvqQTxgaTY4p0v8+HyLnz8c8fHJgAfmCsZfYbVcwVgD23dyzyAtgGWPc+/Bw4hhP2K73WM/DBjdHrurDTpjYFn8+TebLTxvARiMzgltMo4YHeNktUJnDU5P11iul9gPI66ub3B5s8D1xUv02MH5AW77Cv7VF/js7/4dnnz8A6zffx/rk3PsNpfYb0fsLzYYNlcwbkDf91iuAbf32N3sMIwOq5MzjLsBWKxwaoDzfof3+hM8OT3Fh6c9rgaPZxc7vLzc4flwghvfw5sV9ujhWe+nDOvKTwFPY33X5vlc0jWq7wECHi7b0GvFb5cbzoK7pFfA0T2PPO5JGu8oPKh9cOcQVrRu+cnrXL9fAxtRTYOU7c/foXDa2FqSWOFy8gZgRO8VvThDlRUKuzZ6xVqyM1O988sh8vq1wLoWqEajWEzS8ft1d9a4j5lArXeOTcdx2t+/NG3HVJs5NjEwJQqLwoBGFInqmcYYzvV1q+rxd46cIEN4zoVl9P4VnvZX+MMnHn/4eMQH/TXOcA3jNyALgLZg6rG9vpGgUKYHmQ6LYQcMHtvdHiDxzrjZ7OA8Y+ARHTw22y2urq7hPLBaraPGbfsefbcAs4cxjK6zWHRLnNoOi/UK9tUN3H6P3bjHDhbwjGG3g3n+BZ5/+rf4+PFTDK7HgCU8rbEfOuw3hN706OwSw96C2YCcw34cYWnAdr+BtSOWC2B9usRqbbA+W+Nsxdizw08edXj5asAnF1t8dnGFa7fGxbiEcyuAFoAD3OiDi5iA2mKxiBECZVhK03tuTUy07ZDUFU/fLygx0mcT4MmmZb7/MS0vtwqONe9bqdasc4ugPuJeWCNcxVVpgKQxFFwMjSgJXdCyQ9RB9BYeQN9bmM7AhXyJAL0BydrMfZEBju6JpXWh8WVa+3u1lSN53rvLALyjSr7f6cDgN3nv4tt7lsUoTq3H3wP/t+A9Toav8XR1jX/wAePH5xs8stdYd6K9EK8FoJwDGQt2W4y7Pazt4D1ws9li2O4k6h4c3DCgJ4/LVy/hnYc1HTjwrPthHzewxnHEbr/D6foEw24J7+V+yK7vgK7Dw9UjrG0Hd3WBr296sFmAYMAE9Bjw4td/jUc/+UMsl2sQCQ/p2UVze9jvYACMPIKMxzjscbm7wW7ncLJ+CGMeoaNzWLNCTxarFbCyhN3lBovTHRYdYWUHfHoxYBxPxFfdrLDZDjCmw+g9RuewXC4nlEXNm84O0Qxwq4dErXXHZ8PFB8wS8tjrvjYp7z4tK9/EpvzvA6nmdet61wA31Z4p1p+Z4TDV7CNoE8EaQtdZAWajVAnCBirAXYc9CF3XoVsuixDIPlgueT+lchig6Zi4sGneupEqz0cU/dcLdPQ7Atwzk+Y12IjfjfQ6ja9ol4JVEQ3RB5cngxE9Bqytwzlt8JOzS/zkMeOH5zs8Wlyjox08LAb0INPDjyO8d9h8/RwdGJ0bsYS49O09Y/QjdtsN+t5i3Vtc70c8PFnh+bOXuNxfw3Y9Tk5PsVwusN/vsFgscb3ZwBiD/X6Pzc1GNkadw3K5AHUdFusl2DBuXqyxvVkDXY9hdOiMB3YbbF59ha9/+7f48R/8EWzfYbFeY7Va4uZ6BLsBprMwZOHGPaxl8LDDdjeA0aM/ewjqlxjsqWjRI8MNWwy7V+DRYd0v0C/kNN047sDeYOFWeHZ1ieXiHJu9h/MO65MVCMAYLqC0tis9GDAvq1vAV3+ea7clZaKHdUQqG5LAXukUVTmP8vpEN7/KKmg9n/+e6qW8ufDxgZaHsZSCuAVOWhtv9dSrd4nSQbIWKPxuDWW0hEZmJNGqYaBXpVojlJ0PlyOIRVuCrfMIh3+8WF0UCJVQtlqcZKTu4dwsmClePBKFnNwVX1AzyP4+Jt0LuN+mG90bT//BgvdrNJoQ4hCHyISRmwk3kfMIsj1GTzBwOKVrfNB9jZ+d3+Cjky2erkcsO8bSykRm6jBsNjBmB3Q93DBi2A0gN8JYC2t7jN5juxmw2+1F4wRwdbOFsQabzR7jOMIuFjDbHfY319htN1idnmE/eFDXg6Kng8V2vwWMwTDscHX5AuvTU6zXHfjkDA9+8EPsTY/9bo/d9gbkGXsv12Ztvvo1+Ce/B+4ew60Ii/MBu1cvQftXsJ0BW8APgNt57LeAcwusz9/H4uwpFmenQLdHRwzee7jdDvvtFt458GqFEQze7PDUDHj88CF+/fIatHqMV3aJVwNwsl6A4ODhQR1AxooLoA8hrUNURGY5/KPgRCQnOmfplAB6BT/MHGmYzloAJgKw7J8QyLGglfelsMjyjmwdlflrHdRaKKmZ7J9Jm+hEPuaoM5eMWAG6717DiNEokqFfOFwMbciEeOdZEC+TgF+YZA/iDgDDEMMSw1oANoQMjjcKiXZvycMbRscAdRxcUXUPIFgr4ag7ZXWVn2GDVAtHeTFGHDo+HrrvBNz35ZvvAtwtjujedYgzoDZ13kxdvq30Jnj/QzQKg8MBAw2rKqDN4WjFSHLwovcbnNEGP1zf4GcPgafdBu+t9niw7mBJzG5d4tYYDPsdaHDYbfcwZLDoLIbdDqP38N5hv9/Ce8Y4DLi8vJSFb+V48jjsAc8C0AxshwGvLi5huh7jNWO7H7BYLnCyXGHYD+iXS/hxhBtGkPe4evkKZ4+f4vTBOTwYFy9eYbVeYHNzg365ABFhf3OFm1cvsX70IwyLFWixhOkXMFhCL3PwoxP3N3jYxQrL0xXWD07QnSwx+BG77TUAec6PA3b7HQCPm+0Om5sbnK7OYFfAy6stsAauX3yFR6uH2I8EWINu0cN0FuPgASdgpDRGrU1Hj4uMSpjuQbX5aSBsEhKJBhu0QRCBuPTnbnmwpL9roZFuu5fNTgW1oA2bcACLAAoa8bxnSLkxmf/M5yuCF1VOSaQ6qatdbjIGzZc0B5YwyREvchFSbOgAJPE5k6WBMDYmo0mCaJi5VSj3l2/x+8ek3xGq5F16k0kCOyFE2zNCiYRQqHLzTI/O3eABLvHD7iV+drrD750OOKENVr1M7H65BLHHsN9gd3MN5lE0vWGP3i6x6DowO+ycgx/3GIcdRrfHanGCZb/GfrfFbrfDuN9hsVigM4Sb7RYg4biNJWw2W1y/usLq5AS7YcCpP8Gy64WfNAbeebhxxH67AwOwi0ss16d49PgBjAFurm9inIvNZgNij83lBZbng2xkrdawixMYwxjHHcgzRid+42QNFicLLE56DLyD38sly7vNRoDJENg74es9w2232Lx4gfOnPS6+/A2enDzF1ctP8bQ/x4thwGb5EdAtMZLF6CWsrXAF0uuj88WGHZBAzTkfeeYWXdJKCh4jhCFR0Kld8GrQmYRPDac3AYiAidecKZ0i2q6xJrjU5fVLz5VxYdrpNq+2nJMuBBhzOF0MlPsF+U9TxriXm0oQuRg9CclAfrgt7yu9l5KDhTrnyJF/rvsZeRuPSd8IcN/HE+VNp2+l/NdXjL+VFEJqCEhDDpCIyepBYFgYnNANfri6wR+dXuOnJ1d4SDfoaAtDC3TLFcDCWcM5WGvkujjnsVqdwHKHi1cvwTxC/GoJ/XIB6y3GMQQ+MhbG9oCx+PrZC+x2wmU7Nri8vIEHY7ffY7vdYfSA7To4pzesM/quw7DbobMWN5dXWK6WcPsdaL2EdyNW66Ucce86XF/fYHV6Cjc6DLutCJfFAjg7x+rBe8B4Cn9zCbe/hLe9uMAbguk7dIsOnkfsby7R2QXcbgdrxVvBDwOG3RbkHfbXN3h4sgbvNsBuByKDp8tTmN0eZ6eEZ9jjcmSMYwfPPZxc4SNRyY1Bb/omIFMghQvqJH+GS/98+SgDSwYcp89vA+6JFao2VeABrDVFPsyAtQZdZzOXv5RHftgmz78leFp1qV0Kc+GWNF7ETXWKWnZuJejVY3ne6bv8Z3zez1sHWtf6AJU+07KM6r6/LX1jGvddzPt6l5jFFrk1ROtMwd8Kx307tf4dJd+VU2ShRjQuNvGAjkdYjFjTBh/01/jp6SU+WLzAcv81LDv06yVMbwHy2O/2GPd7AIzeWlgsMGKAdx7MDot+Ac8dyAL7/Q6ePfp+hf0w4PrqGjc3I5iB7XYPTwts9lu8urrCYnmKi+stvPfYbDcYxj1WjrFYLTEMHba7Hbz32IWfm5sbrFZrdMbg+tVL7Pcb9P0C/WKF1XKBcRxxsj4RLRoEYzsMzDBdB3QL9A+fYtztQLSCA2PRLzDsboQXNT3c6MBmxLiXIFHDdgdnTIryN44YvA9XpRm8fPUCzjMsgEcPF7DGYG9vgPECw0AY+AzenIO6BWDDhQwgGNjIJ+e+wt57iY3RAAL9XqPwtS4bEDpj5mqvqqzWu8oj66lCKVP9mYW3TqcOGepXnftB1/7QtWWR16flRaJtKw4HBS3Ze4ekKqvW3QFIm5/j6OAHh1ygTOEqXMbhPUpXyTQm4ziG+og7pR7Vn/rNl4eJ7nNG5hvTuI9Nc6bFsXmVXFbasb1v2XP1OOZd5QzvU9bbSMePQ5hoepmBG7HAHgveYG32+PHqJX58PuCJfYUzukKPEaNnYCTQ1oH8TfBH7uBHh+1mkza12ON6s8H19Q2GcRRKxVgwdbjcODz78iVePH+Bm+sbOOew3W4kKI8TD4L1usPgCLvtgN1+xDiOAHYwxsL1I54/f47TkxN89dVXYO/R2w5np2cYt1uYhcXqdIWz84fA2mMYPCwCL0mExfIEvl/Do8NAHfr1ORaPAGxHLJdXGHsG72/gYGH8HmR6jNsRNDCs7bDbXsO7EVeXN7DBD/vq8hIEwugd+sUCr16+hDUWa0/w9BLrkwew/gr99Sd46B+C7AKv4LADw1GgPxC45ANzOZ9P+bH13Idb50CtkYOTdjoFv/m5RIGykoMqmbubBfKwpeo9InywAGQeBC2v0xzVU2965r+3NFfvGd4hEyB6f7MAKoHATj533sO7SjOu2qvg6pwPJyfLDVctO6dKomthZk3UQkkF1134beA/AI47B89vm675fiTdEjdgNgBxCBc1YIUdPlw7/I8eXuMMz7H0lyDawluC6dboVo/hAHi/kQ28ccTN5RXAwGq1wvXVNch02I2yKYZuga9fXuPZ81e4utnCO8blqyt8+flX2O226Louai16wvD8fI/OGoxuj/1uh8Wih/fAMAy4vHIASeyM3W6H3lislysM2x2uXr3CyekC3aLD5ekrrE/OsD45x8nZIxABy+UKi/U5xvUZeLHEYDoYY9GdL+A7h+70IWgNbF59JWCwvYYbRlhm+GGEoxF7N2IYBmw3mxANzmNzfQ0QYQDgdxtcbzboTIe9M1jsPR6wRbdkPF0AvDPY+1Nc0ym2fgSTjbf4sOyLNVPuLTL3fRzdCiDUKyV/tr7tvUUJJC3bx43BmuaoQbbmcjXbZp0yGmQu/kdORTBz1HgTcIuAkI3QnOII7zgHQgB3NxaCkao217Fd5vq+PHVan5hsH4oTCokT1XdE+t4Ad+5Kc5fEFCZ8kPoxeHurjLfCxc+bmd9eOly2HAEewNbBk4Vlg9U44kfrK/z8/BoP/W+x4BusFhKUnhlg08EB2A8DiAewcwB7jLsN9rsBVxcXcM6jW6wBWmA/MH71yWf45Ldf4PJ6h1evrnBxcQWiHtudhGX144C+k5NvpydrGAP4yw2Wix6WGG7v4cnDw2AYBuwGh6634urGDMcOV5c3OFmf4MH5Oba7K3S9wenWgR3klKUbwIbR9T2wPkF/cg5anmMPC7YALSysBYz3MJ2F5yXGEXDEwO4aYDmiv3UeN8Meo3PY7nbY7/aicV9fC5AYxug9dtsBnelwfbXDyckANxKWyw2cszhZfYBdd4UNL0TjNkuM1sKyhR09yMsmsQXkomIQGB1AIUKggltcLInYVQ58QkFgCrS6T6A/kT2jv896uEw2TynSC/qZaqQ6D2vOt6V915qtPEuBcgngqZcsxMiCPvOUkbqwlw0BeU4oK88SLVMsTW132HQNS8UGuhYMEBk5IE/qiWODckix3zxL32uwK3k1uC+Gy12ExnKwhuC9HDZz43hwbWp6a8B9V1ohf2/+3bmbXKacV/FMvtFgsu9V4md5vU69i2cnrkT183nJ36XEADxgRrABgA49GE/sFn948gof41fosMNitUTfy/RZLpbB3LwBj3vst3v4cQ/yDjQM8OMOm/0INh365QN89dUr/Pu/+QS/+u1X+PSL53h1ucGzZ69wfb3F1U7uielILvA9XfV4dL7C0/cNTlZLuMB7nywtjDdwQ9CorIHtLABC1/XY3Gyw3w8gWJjRox/ktOO5PcF2s0PfXePs7AzDfoPF+lz8d9crdKtTgHt01AME+M7CGAuMBqZbYWlXQGcwXlrcfP0p3H6LYb/HftjjerOBc8Kvb3d7uNFjux2w3+9BVjbAtts9gA7Xmx3WJwOWF1ucn57hdNHjdLHEmSOMtAe6PS7oEa7pVP0uwH4ZYNuLDzMJxUTkQabUkn34xyi549ZoK+gL8CHmwUghUPX9kktGVIiaM4nlAIpywmXKPUtS/vqe/j1ZV1GgAGAD70hCnof1pGXKLNIj6OKlkzTq7AQlVISQnP6FEY2cJNArQS0dE0A77ARD46obGNiwLxSsC+jNPWGD3jCYXSjDYthvAO/hxgHeDXKQyI0Yhz38tw3c79L3MzERdjAgs4YdR6zdBk/sS/z44TXeP9uhHw3YS+D83nZgZuy2W/Gk8F6OsoPAjjEMe2w2G+z2I252Ax4/fYwvv77An//l3+G3X73E3/z6K/zF33yKi+sRm60EOBoYIJIbXogZndnh65cDnl0w3nv8EB9/dI5VZ7B3BPLA6AcsYLHqF7LZ5B2AEdebLVaLJTj4hW831zhZL9B3BO/2IPISWXC/w8nDR4CVk4q27+GYYLsObFgsCgmuAoZB152D6AfgroffAbsXn2PrrrG9uQHtNthvthg9ww0O+5HhHWM/MkZnsdkPGEaD/TBiv2d8/vI5bL/Aw7NL/PQHK/DVgOXZBk8XDnYcsYTB0hOuucfIPZgW0OiCTNLPhjncuzk9Kq6pRTPkqWXCRy2Xk1ae0xZRS0aKp6KAnm84jqOruO6pln5wPlYbgCX1AoA40CDJOkDYBAXlnjiBZKfgS248OKAfGQ8yI4yxcj0cAGbZwAzZyRVtFG63AcAUXDWZRUDAAyxUHXsnvxsGG9G4TUdYLRfw3uHV1QtsN1fY7rYYdhuM+53EMg9Xsx2T3gH372I6ZuxntCQCMHYWlnqc7Bye0g3+4Oxr/OTsOZb+GsQdrJXbYsZxFFe1XhbIMAxwo5PDJ95js9nh6mqLbrGCsR2evbjGJ5++xMWW8Itff40//avf4KuLEVsv5qrzjMEheNWKHmSJcO0Yl+MWrwaDkQY8eXCCJw8fwO8dTlZW1svIwCj0zHbrsFqeYLVYgJixXi0BMJYLi74DFusV1qsOgIftDVYnS/TLXvzWnYPtLWAtvJGLGsAWMARPBuAVOn4KMqdY3TDcnrG/uMKOr3C9GbDbAzsHeLPGxX4LRz0Gu4Tv1ujXHawH/HaH7fUNdu4G292ALQ/46IcPcHa2wuMzxuieYcE7rIYRHa5AdI4L8wAeEmOFyQYNUm67B6Z0QzGmVB53bz3T8uIA0hVftVCQn4l4b21qtrj1u1CRNZc8ibxHGm5Vvw91CQeKdHM9ygpi2TPIABxAiC8uni82nphM3D+R9oM4yApYewFrcjDkYQ2DyMMQowOwNCEGSi/hXvu+w2K5wOXFBTavLvDi1We4urqEd3K+YdH3WK9WWCyOu1z8OwHct3mS3JYO0xuHXiw3fN4kx62xCr6dxEFTqk1PqZlynu035Shx5/c45xv8eHmJn6ye4xH/FsYTjHkfq+UKZEJAnXCycbvdYrvZwI1OTjhCot5tNnvQaLE4eYivvnqJTz57iX/xp7/EX/1tAG3ucDN6DB4ATFhroqUwA5aArWfc7PfYXHiAtnAOOD17jN6ucDPsYb2DNwTnBhgi9Nag74Dtbo/eAONAWC46dEaOlp+erAFD2O93AsiQg0Zd34EhwYXYmhDoiiNn7AAwdbD9EkQnOPnAoOt7jNaA+1Ns6AXMyODBwSzWoOs9iDr0ZDEGtzz2jNWJR/+I8Z612Gx3sPAYjMfNfoH11mPd73FuX2GxBPrhGm44x2CAgRbY8wKwPUBWYnnnFzMfOXdrLrnekNREJFxsTpXkG4PiVdLOOxcQOVWTR9A7Zo1rHnpEP/9M8pBTmapw60YpINf7IVKWPv4kMjBkAYi/vYWFpYUcM2NAeO4xWG8hKJRnWCOWZmcJC0uwHdB3HToL+dcB1jJ6CHD3XYeu79B1PRaLHot+gc2DDuP2CXh3jRNrZTdpGNF1HVbLJfq+v7VPgDsA912A9C553bYjfpe86lRnOXlW9jcKjvsuZR0SOHOgPVffN7spKotNj0JrXARCCuxziF5f8x4n/ho/XF/jx6cXeM9coBtuAFrBdGHMGHCjwzgMYAb2ux3cMGK/34NHh+1mi8uLKwwjsF6v8eXXF/js8xf4q7/9FH/z6TN8fTXicgD2YDh0sJ3Fol9gfWbx4KEEkNputvjyy6+w2+7FW2UY8flzh8Vih7OXN3j6cCWgHeKDeC9H9UfjYc2ADg4PTnqAHU5XZ3jy/iOcrpeykbkbsFhbeE/wbEBGbofvewMYI7FCjFwQjECpWuqEzzQEGMD3awyLc/iTD7BdM67XZ7i4vsHnly/w8uISF5sdrrcDdsMIDFuM4Xj/6ByMFV15tV7jfH2KL7zB1UcWP/7A4oPHFt5vYekSC77GerzGGZbYmAXYrrA3NgA1oJO4RY+04lPXv+cpfzYCcOP75O1RHoDJPUEUPPVey9rD5DY8yZ+ZXxvqpaLALH7jelkCs4I1AyT+3Fa1Z2aQXwhws0PnxxDUQbRmY0YY69F1Bn1nsVzIJrkloO8NFtag7wz63qCzBp0Flgt5trcQYLed3HhvDKzpxOeeDc7Xa5wuT8BjOBHrB3S2R29X6O0bBu63nd6kYHid9F2pRyvdpW4W2c0keVxjSj61mhIAyB8nbosn9jk+Pr/Ae4tnsMMNLK/guxVGtwXYY9Hp7eSM/X6P7WaLYRgwDoNcjOA9iDps9xv4mwEXlzt8/fwSf/vJF/j0xRWuRwhFQozTkxUeP3qID568j9XJAqsToTa22x2WiwW++OIrXF5dYz8yrkfGFy+u8fB8g2VncL628M5jcHuJvrfd43S9wOZmi/cfneLkZI2z9QJ9Txi2e2whB3524wiHBRgdBgesuyWcYyxtMKWDV0KI4ATLFvCEcb/FOO6w21zjyy++wC9/+Qt8/dXX+PKrF/jsi+e4vL7B9c0We+fhyYjHAggLGBAv4IlxM2xATk57Xr64wuX1iKVf4dPnr7D4xQYfPFnivbMOj0/XeP/BA3S9wyl/CbYrDDjD3nRgI74/zCKYfTaetVdGGucy0NQh98H4zMz36tXBSIdsai1bQLvNq8+VW6dDnLh8lZwA9Ei9MRI0ywDBLXMEwildE0gmA3H/GwD0Zo/TfodFDyy7Dn3XSUjY3mC16LHojGjSvYE1hGXfYbmQk6C9tbBGhEFn1W1RQgrrtqdo+R7GAIveBsrOoLNCCg4kFzrrpcXHpG8duJs73W9U+zw+3Qe0v6m6TszYww+XG0gNrrEAbqSgQATGqdvgg+Ulzs1n8PuvYGmBvnsPvrdw3YAeck0tWPyrO2Mw7geMwz56Jrx6dYGbmx1OTh7hq5eX+OzzF/jTf/vX+PXnL3CxZeycbISenZ/how8+wMOzUyw6AnmGRYfrqxv84pd/C+ccHj14H/utx87tAMMYPGE7OLDtcXVzg9WCcXK6gncStdB2Czx6dIYH5wsYExYRO7FAHLDb7rEdRpy/t8b65AzLxSmIxXuEyADOARaQC1+deAeMBL/ZYXA3ePHqS/z9b/4Ov/r7X+Nv/uY3+PzzF3jx6gq7/SB3XxqhULabDdKmWC/7AYsO/UKO+F9cXeB6s8N+8FhYh/X5CV6ODp9/ukHvdvhgtcRPHg/4yccPsXoM9KuHWPRbbHkNhz6dB+TprUT5+Lc07/q+xDzln3nwxH88fk8Eynyz84MkSqc4V4E2Z5OXuTmR9Wk5FJPe1YNSBBUGvmij8PRBOIHRsQeTgzUOxgBdHzTkzqA3DDjCpwQ8edzjvR8ssLDAatFh0fXolZfuBJj7jtB1citOZ4RjpaDdGwivrmvCE+CKdolZL2ePDLqO0HUeRCO8H+AxgN0Ivx9h3HGQ/K0Dt6apj+b0u/vle+jL6u+67EpjmSSfpL28/vZBXOtj1VWpAuH4XNjeqxNziPHHkHshjYAT8R6d32Jtdvh48Sl+svgSZ3YP4yz2MHBuDwOCG/bYg9F3PZYLifdxdb3BMDr0/RL7YcCryyu8vLxB3y3x9bNLfPlih2dXDr/68hpfXTNuZPMdpydrfPT0A5ydnsLB4+XNBhebEbtPfgu/3+P68hIdATcMrGwHphFkGGfnD3Bxs8XGAY/PHsGYEaNzILPA8nwBkMTPBhz6BbBcWazOloC1uNntsdncYHmywtnpGuvlGqvVOYATEJ/BOQNYB+cGeE9yHHoE4G4wbF/ixauX+MUvf4m/+Ku/xt/87Sd4/mKD7c5jHHYgjDCGcHpygseP38PLl6/gPePy4gJXuw3GcYBnhhuFKhmdXLJrV4SRgctXA/rlAvsd4GmJ39zs8cXzL/DJi1f4yY8e4cGHFt37HR6sCNfje9gai63dg7wJPt7TsW7NHf29RUVMNxYpuMFl+YR9CNHMBX/1RKEeaQdkeciBRHnIEMKN8Xo5b6nRJ0EkP10IbCZ6aVArvI+HYxjiA91b0YQNj7CG0VuDhfVYW7HCrCEseotFZ9GHuCmLjrGnDr8F8MGDHj/68ASdtVgteyz6DtY60cy5A1jyZxrgsRfQpiXAIrgICFecyV6JYYibnzHwZEBGApCxMaCuA1uLwTvcbDfYbXbY7XfwLgiCmUM6dfpWOO77ldXe0DjsW323chu6x2EO/bb8b+PYq+9uE1i5CSxHMcLfqtXVeVa/Rf6RdUfchDY4LPkGp/4Znqz2+Kh7hQ9OPbabEdauMIwjYAf0XQ84A28Ixlo49thtt9iPo2zSjSOc87i6ucbJ2RkePXiC4fMLXNxc45MvXuDzV1tsWZjI09UCTx8/AsYBr148w27YYWSPq72DGz2MH7BaWPREsH6UsLBGQsquzx/g5ddf4jdffI0HP/89nKxO4IYtbG9hFhYGFrv9AL/u4JlxfXODxaqDHy2uLq7B7PGjDz/Co/eeol+dAfYUpn8Ib8+wHy0cBozk0fUL6VsecbO5wGeffYI///O/wl//4u/wt7/6BLuth+Me+/2Is7MT/MHPfozz83Ocnp7iyftP8a/+1b/BF198gZubG2y3W+z3+3iBwWaziTemdMbADQNWqxV4P2BprJzA3I1g73Hz2Q5Xmw3eu7zBD73Fwx88hqUTEE4wWjkwZSPEIY61ptbGYz7nbju7IJqleF0YK8Drvd7sLvMrlZdtIgLwyOmLsJkIvThBgM45F2LYqAVAwWNGjhnJgRofNGwPQxJHvO88lr3BatFh1VusFz16w+g7g0XHWPSdHOAKwN0bKz+7Dr1hXLJcVPH4wSl+8H6XrTEGyAcfbhEb0swu3Vnpwo5wcEIYxhGOKYRnEP/sfrmILqVJLBGcG3F9fY2XL55jv91he7ORwzeDjPcx6TujcX8fUwtY73JI5675y2cBoyupcctWT/W7hgv1MMxY8Abn/jl+vH6FHy6u8X4/wAR/VCbCbrcDFj2WiwVs16PvLU7Wa/Ek2Qq37Z1sVF5dXmLYbvHeex/i8mqDL5+9xMVmwBfPL3G998JCEPDo/BQ9MXY3l1gsOvTwIB6xgMfe7XCy6HC+XGLZL7BcLPHs+QW8G8DLNezyBFe7ES8ub/DF81d4+Ps/gekX2O9ugNFhubSA8dhtHWgQl0EMXQiOb/H+04/x9Ie/j9PHP4RfPMYNr2B4ga47BWyPrrPoOjmIsd/e4PrqEr/99HP86Z/9Jf71v/kzfP7FV3CO4Tzg/ID33nsff/I//R/jg6fv47e//RR///d/j//i//Vf4uXLC2w2AtjWChirRWmtnPDc7XbY7/c4OTmJ4z2OssmrnhQ8Ahc3wJe/+ARfXjv8w/4DnDx5BPYdyC/C1WTzG3lzsTDu4hig9zcKcDuoDtyKklfMOvJhc84kbdto2FuL0VGIOQ7RXtWfmR06DLDGh+iCjEWgOZYLi2VvsbajAPaqw6rv0Advj0Xfo1t0oH4pG4pGNhINQpApEMgwhqW4xEyvGyMwToRvJmGevWfRsF0v8cpHCXTmPMMxwznG6FkurnYjjCWcGBOuTpPeUNbb7/d49ewrfPr3f4fddodhK37c3vkQFOv29J0E7rsC3G0nJ99mannI1L83n6/nOufkXwDnjFykzOKgQreaS3kB+m7YzAp3LTIBhgYscYOnqy1+0L3CD/tXOFkwrjYbAB67zQD2HtvtDs5JiFHTySkyiQ1h0fdLbIcN5Jomi/cfvQfvGNc3A17djPjq5Q0++fIF9iH+QGcIy95iv72GJeBkITTGfmCwH7HsCQvj8fB0iY8/+gj7wePq6goA4+TsDJc3N+LONzr85rdf4GS1wkcfPsFqfYrd5iWuhz2WpxbbcUC3NOBFj3GwsKsOH/3op/joJz/DyeOPYE6fgk6fYnH6BPbkIeziHGQJjvfYjzfYba5w8fIFPv3NJ/izP/33+Jf/+m/w1dfP4bzHdrvBarXCw4cPcHrS4/LiJf7yL/4t/uW//Jd49uw5dts99vsxejZ1XYfdbgci8e8FBDD6vscwDACAvu+x2+3i3NntpM8X3RqXW8LN4PDlL36JK9fjf/JPH+LkvROwWyLiNrWVh7kDMLMzJ99gJDl0QkThoIuL3hpEU//vPB6JIQFoQ5BDQkZPYrrgqePkIDM5EI0wZkRnGIsO6K3B6n9g7z+bbMvS+z7wt9x2x+VJc13dqmqPBgiAFEmARiRIUTTSxIRmYvRC825iPgC/1owmSIlBShyKxNCIQxICQQFoNEx3A93V5a5Lc+y2y82Ltc/JzFumbzuQnODuuF1pTh679rOf9X/+xuTkRpLlqVBnBrRO1M4i1xQ6kCmBMYnxoYUYXRslQmmCyMbghjCGBKeu9zBSvfOCX4NqIYbkp+7o8bFPcXJOEZ0axWV7eh/orWfwkX5w7Oua/W5H0zYsT0/42Z/5MoupToU+ysRkSbgSfb1nv17hrDtCnmku8B+pcvKzoJD/EMkenz/x/mzo4zhQiYdCPN4Hd+0i7+PnjFthAbeDkc+Aj9K3qbs53Fd6Pql4B5GoaCJaCtEy1zXLrCWza2ZFOEpwh65LnUBIwQHBJsGNRrNZ73HOMvQDMUbyvEwZiUESImxqx6ubPS9vaj58ecOm7kCpRNIYB1eZUqgYiN6SaUU5KZOMGIjW8u6Th4QYuXz1grZryAvDYlay2dzwlS9/gUenS+r1ilcvXnBxsmB+UnG+eMju+gXBWWx0eJ0zmS2ZniyZncw5e/CI+cN3kNUZev4IPTuHfIrKKhAa73vaZk/bbql3a559/DH/5td+nW/+3vdYrQT94BiGDkTAOct2u2K1vuTZRx/yvfe+x+XlJc75ZEfr73fCB7P9Y2yYvj39vPe0bUtVVXSjErUoipSjaR39Zk8UkT44/vA7f4CTFX/+Vxbk1btY1LgB+3w48W4Bf+NDQBpR3mLaUo7lLwqI8nhxijHee00ASIEkomUg+B4pI1om3nOaNYZEsVOCXAsKJShzTW4MhdbkKjE4jDlQ8lLxVlIQDpayIl0cEn+HcRYo0TGpGuNhwCqS9Hz0Cjy+L8774w7nkNYuncR5ixUDnW0SY6rz2Maz2zfcNDvW+55V3bGue9brDYO1yBgoCsNXvvQFvvSVLyeNQPRjdtTtMBMfCCOddhgG/AgT3eWrf97xE8G4f5pDuc/Ced/kb37c5/WjQBs/qPu/Ld53MOrDzw6iHXHgot7+fbjTBSWMW31iwHT/9R7CUbmt/6NpjsQjo6OMO5asWIZXqO4F5w8NMoO+7hAkx7R+sFjvkWpEUYWgyA2K0YN43P7nIx5cTmZ4Mr737H2+9b2P+c6HN1xvWyazGevLNUorYgy0/ZD8RZIoESFASUGVZWm7rCRNvWdXt2z3NS5ANa0w0vHzP/MuX//KVzipSkLf8fLjj5C2oxQl88wwOT1hv37FfDbn5GRKtTjh9NETLp48ppgtkJMzzOwxZv4QVc0JMmHhztbYvqFvd7i+4erykn/9v/07fvMb32a3d1hnGKzDeYeUMfmIe6j3O65urllvtsmnpBsShHAYzHG7AzvsWrTWRzc7OVrAHrrsw+fcNA3GGJQydL0DJEgPxvEH3/h1BAV/6Vf+W2R5jot3MdrPPwfepHh/kn10t5G401iI+7u/e83MuNClhOh7jHDMcsm0kFS5QuuA0pCPlLvcKPKRyZEGiQYtVYJZ5Ih7ixFxFgIrk1+8uD1zjs9BIlDh1jPEj+vfR5dEYlHSdalItm3LZrPBWou1qRnp6o6669m0Lav9nv1uz+bmmma1om5abgYI2QRRLiCb0LuCslgwrwomk4xstiQoM15EEj88jni/UooYBU3Tsd1tGZxDZYnzHf5joQP+h3b8uFDLG1/gDoyq8d/xBDieMBEh71CtUit+W7iFGif49wt32qqO9L6Du5kYT7LxaxUGKr9h4S858x8zsR+wzHsWxVOs9wzOMXQNbdvQDzadHCFiXUoj7ztJrg1a6zS8iUn95Z0DIXn/xUu++8ErVrVDl3N+8U/9LH2UvPfRh3z3w+ds9g3bfUvMDUEl/q1U0IWA7S3BWgSRoR/Y7Bv2Q0QVE956+pR33zplMa2olCMXA4uTisIuubl8xfXHH5A9WjCf5qhZxXw+4fzhBe9+9SucP3iIyHPEZIGsThDVCbKa46UmRI+zbXIy7PZE33J99YJ//s//Ob/1ze9ys7FYLwmuo+sbtILZbM58VrHdrFjd3LDdbGmaJnk1h0DwHCmWh3Vxt+M1xjAMQzKgGn93sA84YOFSJtdDhMeHSLAFQiikHrD9Fb//m/+KRbXkF//y/xlQx873R2l2Xr/93cItCMevk8tsWqshjNQ8XhfeHO6ItHZkBOdZznMeneSczzRVDlqEJGbJMrRWY9DvCM3IBM0I4pFmknapclzWESMS6HF43f5wDsQ0f4g+4oPHB4f1FutTVqh1A653bF5lxPiUjz/+iCvzPXa7Hev1mvVmy6vVjjYYBkow0+TF01vsvmWwHT5fMjl5gpieEcyE2A14o+iMIpeBISpCUlNATBzuKMbzXWp8ENTdwM22RmrF+ckJs/mCvMjf6DN688L902e6/UjHD8vU+FHv6yfxt594LvGWZ3X469SBHb873lSmM+gW4xb3/91Xph1SPw4PIzkoywSRPDacuJcshufM+u8z9S94uFigXUPjIvu6pq0bnHNkeY4fsxaHwWLtgMgy5MhrScIDQ98P7Pd7drXl/RcN9RBZnF4w0xMsBhPhK198h+XFQ/ZDYHV5Sb/d0O7WiaI3tGnw5QCf+o4ih+X5OV95+Jjp4ozl8oRS1OB6jAdhAyqTnM0n5PGUyxcfMS8y+nrP8mTCxYNT3vniO5xenKHLAvIK8gnkE2Q1xQlJ17VE3xN8R7QNtq+5evWSf/KP/ym/8zvf4mZl2XeSKBXCt/jQ431gtbLsNtc4OyTvcX9bQA50tk/7/A8YsLX2Hh586MSstTjnjoU7xoj1KURZBoEkR3oPviPGV3zrm/8b7/zsL1FdfAGkvgXUDhzp19bXm6qD7+4MDxisECk7MikmE24c/AHjPmztXj8PBMSAUoKL5Yy3znMuZopCRUQMSJEof1LJe97jqVv3RBESJBOS2CvExEoRCELfJehjtHFNXjce63xyaRw8Xd/StC1d39F0LXVbs9luaDZ76mcVOvxJfuM3fpPt7//6eMEMOB/Yy4J8+ZRs/hZ68gApBL5OPvGddcSoyUSOkCVRTxlUR4RkvGYiNsJgPQR1x+8l8b21ziiqCfOTU6LSFGXF2+++y/LsjHJSfe7nczjeuHDrVn3u73+SdT3yyZWvRkOG0OpPoV9/9qOnpue2vf2ssV7IAkHdp+L8KFDLvS3qa2ewHDmxh2d2+9xS332wyjxuZaO6d7+314Z0+7sdzl2RRaJQDfgoCdEkSlaMEAa06FmIV7wl30f5G9rVJdVUk5dLmjZgvWVwnt5H3Kh/sNbTNC3D4NJWP6aQBauSj7V0lt12l3IFixnL8yW1fZUEK9GhJQjryXJBrgqCMHCxGE8U8N7RDT273R4fk7JNS8F8UpIbSWk0k7KgMDZtk5VCCZjmiuAHtFFMT2asVgYhBcZIHjw85cnjB5ycLMjzApNVuGxB0AtUdYKXmq5rcV1DJhzKddihodnX/It/+e/4jd/6Q3yscG6PCgEZLbbrEHbAWovKMzpr066kdcQgkcJgXU+8oxt5nTt9d229/rsDxnp33SXs9TBU7pDKoqJABYNvA6sXH/O93/1X/Jm/dkavlzgyVAiYmFr+ID5rxX/22n39aynVmBk5RpDJtJpD8AihiOFwriRf6bT0AwQwimQCJpN/zDyHiQYpDfFghzou6TBebIRMxR4Pziff68R/T/4hIjiCdTiXVLsxDAxDz+Ac26Zl13as9zuevXrOdlez2uzo2gHbW6JzyBiJTmK6x3wpQt049iIgxnIYYkBGhUDjshybJxhQdgYdNYWTeOVQYRTOeIeKHhUcGR4fA7XTybAsRJLWJ4JQKCEpy4zl+QmPnz5mXi85PXvAu1/4MtPpHKl/wpL3t//nd9/0pj+dw41X9h/heXySX/HJ49UvvWL37vbez36sDvzw/591FzEeO5nPvI9PDJmOX7328/vDpxjBR0VKiDSJfuYdFS1z3XIuO6Z07PsVztWU1QVCmWQY5RKn1jpHiJG+rtnvGoRQxyxHxm7bCofxgbpu8D7htdt6ResLNuuXTOcndNZj8oLTxYz1doeRkXJS0fUDWTah6weikDjvaaaTMZjYowTkElR0ZDKSK0tloMgypISu7TDC42xPlk2om4bcCJxtOD+dshihkrLMUVLhnMcqyOYlWVEyRJJ3iBvQwoEdCD7w4Qcf8U//2b+gGSSPnzzEWsnNzQo79Dhr6Uf6ox1hDmvtmFxy+HwOF9X7n83hOAwoE855+7u7VMG7kVe3IQQCxOFxksdKjIGubfj2H/wOP/fn/ipxOiOqw9AwEkcW0T304jOH/581j7k7szl+defn8ThU+2SjEyGkLE6RLGDSP5W8YGKUiOjHFia9Hj+Kkpx34Aecc9gA3eDprcPbZDfQNi2rOrLf1+y3V9TbFbv9ln3Tsm879m1HH4BsRjRTyukFUgZivSUMNdENKRzheN4cXlGCWYJKoijG6DOjxtBs0vA9kLJTiY4Y0sUDmbjfwTu8TQN+vGeU4R7fU2MyZvMZ5+fnzBeBt568Q1FNEnxmf8KsEuk+v+P+Yzt+Ss9DhDejSn3ecX/his+t2+MtPrE1fbP7vg8D3RbsOwGsGDw65SNiMaFjzo6Hccs5K3RscHZHpCcKdwDa2ay3tG2Pc0kcYgeHcx5j1Jg2AtZ5nG/RWrNab+m6FoFAG4MQEqMGHj+Y4oJnUhYgFC5YJlqSCU+hLEL2aBHRWUyYowgI48iygr4fyLUgUxLbdSyqkiJTFLki05KiKNgLT/CWPJfoaBG+YzHNmOaSJw/POD+dMZuW6TX4lBCj85KinAKSoe8IYRhT1CNRBJzz/Nqv/Trf+c4fUk7POTt/zMWDC64uryDGxKIZMWl7YAN4PwqPjqD2DxyOH5gXd2Xn9/xBxr+7332LT3zGB2jlxbNnXL16wcX0yejLMa6J8X9HqsVP4QjeH1WTd480IExWp8dRZkw4tI8+8Z6tJ4Y0LHTeY72nHwZcSCwP29bsd3tWu4Z13bPa7Njtdmy3G9pu4MaWyf/d1pg4IHwP+HHYK8jLM4oHXyY7/xLl4gGu3tF8/If0r75HCDf3Ys8O8vk44uc2Jn65CAGcQwuRvESkwiuFF5EQHTH0EA1aBaRIcx4fB0SeIUN6LilTVYzzK1BaURQlWZYRY+J8GyPZ7TesN7s3et//03Dyp3WMsMwPKtxwix++fnwaH/fu1wcV3n18O+GAKZRJIKMliw1LXfNIbHmq10zlju2wQcSWqtLMFhMQiQYV/Wh+HyLWO+q6IUbBMLij2s8H0NpQNw2bzQaASTWhNKlrH/ZbpoVByoyinOKC5v33Pya4xAowIbIsFT705FXFru4JGpwSQIJzcqkgWM5OCpRwZCawmBaUZUlT18jYk2lJWWRoKen2lne+8JgqE1yczSnKDGUMSEWQGpVVqHwKKmcYLDE4ou9TzFqMBDzr9Ybf//1vIZBstztublY8ePAYkxk619/rLA+F+1C0PbfMn8Nn+mmF+4BlH35/gEden1ncvw/xqfd7+LrvGj7+8Ps8+OKfIpn6y8NI9B5N8Ic9DvS/w9fH7j1GErUuPf/De3JLOWUcnMfU5Y6P3/WOXR1QQdBbS9MP2L6naXuavmW3b1htt2z3ezbbHdeX1+z2DZ0XOJkhTcFg02MV1RKWDyiVwjc3hPqa2G2RfoCYLHSlKchmZ5jTp7jqFEeGzz4iHIruiGmlAWeSxxwvmgI8Hu0t0vVIESG6tHtQEilCMqqKAyL2ZEpQGJgWiiorOJ8V5HoUKcVxSDt+FFIpsixPWZPCsVrdsN3txm78zRrT/1S4f8Dxo3bh91hUn3G/n3fPPwhfP/z+qK67U7yJkRA8CkdJy4wNT7ItT/WeaX9FrK/ZXl2xvblmUhU0bQtCJotTHyCkQj0MlhgFUmq6tqPv0uCMwaOzFA/W9QNaa7phwLiCXAlmkwKT5Qw2oIRju1szySEYQZSgpeX0dJY6ESSZsuz2NciId4H5PEcpUEIyrTKMgumkGJkHQKmJVpHnOVVRUu/2PH3ygElhOFtOmM8moBTSGII06GKOLOfocg46JzqLUQIvI3bo8EQyo3j58hKB4hd+4Rf5/kcvuXz1isViiRCevm+PQplDl334570nSpnkzq9ZmN49DjTAoigYhuGT60GITxg13S6i9LM8z4+ftxDJu0NGT7NdY2RS8R13ciP7iPtykx/qSA3CsWceMe4ElRzcE4UUiHgYqt8xfRIRGT1CajKTsVrXyKbhQ7fh1fUVV5s9q03Dvm7Ydx27ukGYDKEMJsupO0Mf52TzBaaak0/mGJfUpiovkPkcFVPajOtrQmwI3qIRhODSTlIHrBiSn40YcKLFixbEoXC/PrhN77VUIe1UfYtyOSr0qNChcwGipKgKlg+WFLNTitkcbQxVaZiWhkJHTgvNJDNk2qRz65Z/gxCCoiipqgofbmPNsqxIzcYbHP+pcB+OT6miPwqN6t73nzZkv/Nwn5i//5CPd7c4vF4wjAjksWYhbriQ1yztK4bVM272V/ihRUVJrktOFicoY8iKnP2+o20anItjEUnQSNs29N1wLAZd32NSn0JWFOR5TpZlKK0IUZCZxESZTFK+Y54JtMqoyiot4hiZTtNW8Xq1ZlJoJuUJREG93VMWOW29Y76YspiXTCcFQ98kKEZm+OCYLaYoKQkjp3oxnzKdFFRTg9AKkWVgcmJW4VVJli+IqqDtLHmmsK7Du47gekye03Utq9WK6XRGkDlPguQb3/wW7733R5Rlick0rpd3cOdwD+rw3h/paJ/Hk55MJsxmM7bbLW3bHj/H17Hm+4U7FUOtNWVZHi8Yx9vHAN4iRqHHMTQgioMy/TOPz9Ma3FlpaTgaRhOpOA4QGWXw8pPP/QCVqKgQOifGyG7X89FH3+by+R/y/PIFVk+Q1RlFNUlYtAoU0xl5NUFnOX6zwdUtIq9Q0wUiKwlDT/ACLwxpWzv+C2mHKyNHsQsEvG0QzQ3OWXx9Q3R7Quwh2qN+MsFJ4bgbQgpUoZgucoqpppoWVHlOaSbk4oRcRcq8ZL48pZzNycsKqRRGi/RPwSTTLE2GVsk7PYixHhDQWpPnGVVV0fbJNsIPDueHkW/5g4//KAv36Vfg4Z8QbJ/B89+KHFSiKoMv/ReC6jRhSc0q8oe/Gnn8C4KLr6dp+LPfDrz6vU/e54Fid+9nPybm/QPx7R/jvj+/Iw+o2DNTDQ/VinP/HFW/z+76Y+rdHjeAiIYQI2094BaB9XrLdrvD9o4gNCHAMNjkp9H1xJjgkcFatMmQMhnuaK1Tmvm+Zr+vMcaQ51nqzNAIKZhMCooih+CRyiB1xmy2ACEY7MC+rlFGUzcNTx5dsF2vOVlMOb9YUhYarQVZVo35lel1T2ZT8IEXL17w8OIBJs/Iipy8ygkSsrwAlSOyCapaYKan9CgQSUhESJFTMaSk9WHo6LseY3KaPnB6esb5+Tmr1QprB8wIbxy67gNUdfwHY7L4LWR1/KzHglCWJaenp+R5/oni/mkF/65q+KBKvNuVH56DIpBnGqJH3O0WxOfW7Dc67naj6fEYZeSHzvo2wPvuhQZSoZJCI4QhhIj3hqbx7HYD3RDJpidky7eZnJzS+wCdJVRT+iyjExIvB4RMLntKJPc/Ey1CenKlCCKSCfBS4gT4GNJjAgTJ0HtM3aD1iqAaYr8ndE3KTJV6DLsWVFVF+eghZVlSVRPKskBNM2bLcyazc6pqSZFllJkg145cC0pdYPK0sxRHxg3Jk3vko+c+oIlYcYCLDsrT28Qe5xx932N9GnYPf1xhwUKBKWBoOK4SXYyDiH68jQSVg+tScZUKbJtuLySYMn0/7lyQGnQOQ/3Jx5s9hrd/WfD9fx15/POC+IuCZ785wgYOnv92RGWR858RlCcJlrp5L+KGyNf+lqS+/IzXIT6r+/jET97wnRm3rJ84cw58kx/jlIpJbRhJJmVhBM+SlzVIb1mKG065oWyf4ev3yP2WDE8dQQiNHzzlpCTLKkCn7k8qfLQM1jK4iFKGobckXVrigJ/M5ziSuY6Tiu2+OXaAOjdIpWnqHu8tzjrOTk+oqpyqzFBKsK87jJa07Q7nA4tFSVkl/+3ZxSlD03FxvmA6qxAiUhYZ2+2KrmuwzqHMNDENhoHNasViOmE2rci0pqqytBWVClNMiaYimIp8coIsJrjGIYQHLYjBYZRA5YZgLaurK/quo8gMJlc0vefnf/Zr/PY3fofdbptokV1PSKbKSRodAy4ehsH3k8xTsU0naZ7n5HnOycmS2WzGbrejbdvEnhg520qp8e8+uwO2dmAYUhGMgB/j0LRQVNWUSFISJmA7bfvF517g32ipMQoVb1/fHaqjkvLW0nQc8N1qvSQijuIiQVpf0mCFwUWJlialCEWdOlIlCUKPNNhxl6EkmRLkMmJUJJoUKK1lIEaHEQKvBIMUBAnIxPYQahwGug7RrlDSkEVLVebkT54y0TAZHiM/EPzc17/Oyc8tKcuS6XRKWZbIXGCKgqKYoVSG0ZrMCLRMjKdMagSSg42tUIkNBZEwCt9i8DghAHkbujx+Js1ux4tnH/HRs4/o+w7v02DTeftGn8uPVbiXX4Qv/RWBt3D93cjHvwEnX0iFNUb47j+PVKeCx38Shj2s3os8+dOC6OHqjyLPfxu+8Jdh9kiwfwnv/cv0++UXQGl48bupEN89Fk8Fq/dg8z4QIk/+jOD5b49FP8D+ZSr8X/wrgu/9s3Ql6Nbwzl8QDPuIvw8tHg9BKoY/6HjjJjzNb+6XeXH/9z/yIdICiELgBbgx2cMISxYsc9XwZf2cYniFcq+ItqZt9jgLBIXtLbvtlquV5XF4zHS+IESdjKSEZvAO65JysWk6iJ5plaANYzQ6U3gHlzc7MpWR51O2+y0+RtquR7iEO4Zco5WkKBQ+pG4ixIAPPVpr3np4wfPnz1ksFrT1mkxpyplBANv1JYvFHDsEmrphuVzy6PETPvzoOQogBr7w9luUucG7gUmRUWWSQEDlJZgJTk3JqlPMZEHvfSqimcK5Bu8HQt/R13v6tsHuG8o8YzGvWG92VEbz8Oycbv8u3/7OH3F1dc1gB5x1WOewLqRIMiHGbvvQScWxYCcVZFHkFEXBZDJjsVgQQmC3232CUXI4DsPmQ/Au3J1nOJqmRugEE4QIShmyvKKaLIgyw0k9dp0RGQMy/uCd5Kel19xdsgJx7BTvmkodwnWPu1Whxm78sMYj0QeIFknAYrFSMagsKVZFxAVLFA4lQNNhQqBUJVJI+lzTB4OUEYNFBZ8S2ZVAxIjGI3xAK8GQaVRZoAtBoUHlGdnilOXFGdVkTlVNyJWmUMkPZWIMYnPCb/5LwVe+/FW+8J+9jTHmuMZRAqnVOEiOo7WsRwiddpNjd58kTzJZHDuPDZ5gB0TwaU0ojcnLNJ8RgoBDxIDvG3bra+rtKu2gQsAIgfnjSHk/eUewfQ7v/a+Rr/0twcXXI1/9W5LtRxFdwtM/K1AmddN/+E8ij34hFdib70O3hUe/CNELfvfvRt75zwWPfhHOvwLPvhHZv4Sv/g3Bi28mAv/hUCYeO3HbHSS495/X8gvg+8j2+e3P3v9XkfU78MVfEXzrf47H7v54fAaz40c/DnLhz/r1jwWU4AiE8WpuAuRYKmqmquY87yjbG4bNM9rdC+jX+L6lt4EoC1SeMZkv6LqWrCjZ7fYEPD4EBmtxLjAMjqZpiDEwrSqqKsEdVVUS8NghUJUW61q6oWcyqXDB0Xct2Tg1jwhWmw3WD4RoGYaOspwgZBrAHPwh1us1WiXJsxssxMjp6RJjDN573nrrLbIs4+rykr7rOD8/S914nhGco5jPMEah9OhtrXKCzDHFjHI6h3GIl2cJrrHDwNAP2LaDUcqvdI7SBiHl+NglvQu88/Rp6mqlZLW6YV/XIAxSRbRWBOSRBmmdPdpyFkXJ2dkpk8kE5xzT6Yy+H7i+vqbruk8Ibe4OJA9QyMGQ6i784pxDIlHGIGWiYEqdYV1MJURKOJj7k4KQf1Dhfp3VdN+a4SBlv4VsEHdZJkk9+zoj5nCEBB8jRkGQAIijp7YEMw4BhRAYHdHCIUJyUcwYkDJdcDMGdJTE4JDBJS68iBSZpppPeLR4SiGfMDGCWZWTlwX5fE41XZAViSNtpKLQkkJLMq1oXuT8lhAsl3MePJzce/5p6B/Ae0Jwt5+tSLujLM9Ro449hEjTtuy7jrrrCN7i2paiLJkvFuiQmD7jm41UcmSUiLRzdYHgLBoJb7hD+rEKd/QJ/vADuD5BJEMTufxOwp2HGs6+LOg26TbX34WhjsyfCh48ENRXEdtGvAXbJDjFttBcJ5hF5/fNYwDaDZw8Fbz4ZmR6kf4OUpcdXIJhnv5Zyfu/lkJe83n6WbuG9gbU1/n0QSQ/GNP+YZWUqXDf75o+eZsfvoBHIMhIFKCDpIiBOY6lqin9M7LdS+zuI/SwJdOOECConHZVE0XE+pDEMEZjfaDteyAkwUbwo9mOYzKpUEpwMp8Tffo+pTZFRKZYLufkRcHNZsdqsyHEyHw+J1hH1zYIWWCtZ7PZ03YNs/kE76Fre6BntVpjjEFKxWQyTe+FDyiZuNqQMPTkZaHRWnFxcZam8nmGEFCV5dE6VGcZUWi8rpD5lHK2ROoCF0XKIwSGUTDjfcCFOE6NNMqk9/V0uWSz3dMPHYMNVEXGO0+fUBU5N6sb2rYdfZcj5xcPeOfdd6mqCavNlmcvXrBZr/nee++hpORv/+2/zW675Z/86q+y2ey4ublhu91+YrD5+joIIRxFOq/fJsbEnY4ihdEiwHqwYex4R3xOHqHuA9Pjs9fcp/qMHG7LbdG+Tw2MxJguiHGMDbur3r1dq6P/COn3CSoIicMvHIYeg0ZLhTEJ5pDeARHjOwwDmTaUWlGVGXlekhlDWRRUZUGZZ1R5RqElpR4Lc5Y8402eobIcoTKETBd1HQOSBKWI/WivqwWIlKJ0tBzwgTgWbGcHBpssdpenC4zJMTp15THCYB1X1yteXF/xR+9/n+1mw9A0fO0rX+ZP/2d/irIsju8mJJaWMgapDUEoohKEIEAptPhjoAMGF3n3L0jKk1SYX/0+CBk5/VL6sD/8t5F2lYo1QLmEx39S4AYIFl7+boJavv5/TIX3j/5pwrb9AMHD/tUnw0qv/wge/Cz87H8jyGfwnf8lcvF1OP+q4Dv/SySbQr+LbD5Mt5cSvvI3BbaGfAYf/Fq818H/1I4DzPjTuGshRsOaSIZnKjznauBUbIm77zNs3sM2WwbbJZ6pSEVKZTnbZmC/t3TWs287bIx84QtvUxY5iEDd1Dg74JynKlOHnWUao3MmVUnf92RSJ5GMEeT5lEDA+YG66dhtttjBYkwaAna9ZRh6tJbU9UDXOmbTKbvdltlszmIxZTabUtcNdV2TKcn52SmQBjdVVZFl2bGwKAVnZ2cJdxZpsauxuIcAQ1CIbIqZnhLMBCFMGqaGgHcczbl8AKkynAsIleOByXSO1gXzRcfLF68gJFtbTWQxnXC2XACCtu+xzjOdzVks5vR9T64VX3z3XfpHjxj6nrZt+R//zt8FYLNZc7Pest/vP9FlH/57gEaOAqqRo3/owu/eVmcZ5WRClucYk1MuH3L++ClRJjVmGrlFQBKFOHplvL6G4JPagE8W8NuFHA+A96iW5A6L5u6/2/sbm4wR49ZSIAgoPEZBaaA0gVwOKbMxS/7kZVGQZRmVCGPBLplWJUWRkZsMkylyrcmK0e5VZynkVyi0SrJyI0lwnVREkWinggg+0SfjmGyTjkDb1jRNzX6/p65rhrZjv9ux2azZ77es1jdorfgrf+Uv8/itpymHdGTYuBC4vL7h3/z6b/Dt734XhKI0hgcPH6f3bIxbS64dyfdGmYK8nJJXM3rniNJjspzC/KRNpj7lCA5efCPy6vcTtOEtfPzvYP1BJHhormD77PaDXL8Pwz6iDNRXqUB/5x9HJhdQX6bu/fv/35ElEtPvXi+yvoc/+J8ik7MEtwz71E2vvheP3f93/vEtFNKu4dv/MFIuodtAf1/V/kMdP1R3/FrR/rEZKndOqDi6PIjoybFMRc9C7ajcDTFsUaHGaEVrYbtrCCJiPTS9pxtgsJHNrmW7XfOV2RQhJcNgyXKFH4dls9kUYzTD0BG9ZVKVED1aayaTKQ8ePGBf79ns9pwup2ijqJuBph1YrdY459hsdqNbXuLMzudzppOSV68uE/e767m+vqGu07bJ2oE4dtsHWEAIgXOOxWJBlhmM0VTVBOtswh+lRGuDj+CihGxCtXyIKpc4kRPRhG7ADz1aF8SQFHtSKILQWC/oe49zMJ8vuLY3nC6X2N6S6R37/Z5Vu4MIQzfQD5a6rjFZzsZZXjx/hrWOq9WGgEQpTd92DF3Pi/1zhBDs65q67cZ0FH+PQXLkPL/WrR7sX40xx4IOCTPN85yqqnjr6dv88p/78zz4wp8gf/AVWqXHnESQcRyPj8KPz1p9P0i5exfui3fwxVtl5p3v70A6rzNMiAknzo3i/HSJOis5fXDO9PSC2XxGMVJKsyynKHIyk1EoQWX0OBg05JlOXbOWo6NkPO5qY0j3L0jNY4wk90Ap6ZwnkNSYwfUoAsoYYrwtf13X8gd/8Af8zu/8DldXV9S7HW3bjLYGPd47zs5O+aU/90scrADSa0z2D8pkTOcnPH76BZRJorBiMh3xpTTYjzEeZfN5WXF68ZA2yuQN1Fum5ZRJOfn8QjAeP1bh3r2E+iqy+ej2ZzGmAeHx+zuFNwY+wepwHcfuGFIn/mlf3z18D9tn9293uG0MfAK/Hvbp3/8/HSpIlO8xscaILcFd0rXPYb8hVzlucPhoQFfs93tcjAgy2nqH9ZJt3RKEoukG+sGNtLvkEW1Miu5iPCny3GBGH23nLfhA2zRY2zGdlhQxYrIM7zfEKPGLBbvdDjskXBskWV7gHNRNh4geIVKRa5uWsqhSt1PXPDw/pes6sixjPp+PA74iGTspickNbVuTZRohFFlRoExGP1iEV1SLc0y5oMcQRY4UifcdQyD6FA8lSAkpIkaqyYwQFdbVTCYZ3geM1qxWK+rnO7y1VJmhrCq2uz1d2yAF+NEVsNnvcSGy3axp+xRx1baHjEmbHPRiMuzyMRzFO3cHgoeB3wE+gdvil2UZk8nkqLaUUqGyIqXIdy1d13FydkEjNVJpghcHM9GEb3NwhvxJHre87ijCvXt/XbZ/8HCPIaIkvPPOU7J3T5mVgtmsYjKbUVWTEQrTCYs25k7nrI4w1zgGHv1DPMGmuYxz7uito00KsS6MSbF71rKtWzrnqJs9buiYT0tmszkHc8YYoessH3zwMb/zjd9ls9ngQ8K2I8nqgBjIq4rejsHU4+sSMWFI2uRM50vmLhJQyQogihSgPPKy0vshkUpRVhPOHzyEvGRwkd2+IdM5RV6+0SfwYxXuzYf8eGTk/9CO41bw7vHv5wXefRavIZKJNRAEOnh0bJBig9YN04lB61O67Zq6W9MPgsErbFD0vaXv9kiRXPHafqDe73j0+AF13XB++pi63kCMGK3RRuOsJc8Mgx3IM4MQYLShbRuqScliMSUC611NWeacX5zx8uUNxrlEjxMCqTVKqeTyRkRpiRssWifl5cnJCcMw0HU9MUTm8xl5niOlxDlHOWZbnj+4IMsztqtr2r5jMp2hTYGQCusCIQrKyZRiuqBD41AoleFJatDoHR6XWBhZhu8GovCEGKgmU/Ks5NWLF8xmc7abNCx9+tYT7DDgBsuLly/x3jGbVATvuFltiAjqZrQBsJahdynkt+sYxhxO78diBvfk7XCXp307lLzrWTIMSZV6UFxqrTFZTjWZYn2gKApevXrF9XrL5PFjrHVIld0yQRAIIblnV/iJ49hP/3DrMyZFZRDh3ms4vq6YhqXpdimvPc9z3jo/4WwhWc4MmRZkWo2Q0O2QU6r0PWMEshQk+G5INFM7DDhncT4N09uuo+kblFY8fecdRJBooRBRse9aXl5f8/2PPuLl5SvaZsuXv/guv/hzv3DMNY5BIEjGXV3vqJueKALWjZx9AkoKrI/JaVMlfUJSPwuEUKM+QcNonpUYKWZk4oznLbcXM6UzinJC5SIZkqAyClNSVdM3ev9/fAHOTwnH/eM+ZKMwGzUOKQ/IniSMobwHkCJ9He9991nHJzncb36kTEiRKIXjQxyjmYgIHzDRoEOOFAXoKfu2RfQTcAZjHuFDR6zXlNLh3A6GDm0KgtsR3JRcD4TuCcvpnyAOOaGbMs2f0luLdBrXdwx9JM8MXhVIIaiqJZOqZL/f0jWR2XxOIRw3qy1GGE7yJYoe356z39cIZ8FLhm5A6ozeBggOKwtyNaFea2IM1HvD40cPyTmn3yqc9ygl8V3OfD5ne5lhncXbBVnxkHarQGp0XqX7FBrkBe1qhpUFopgStwCeOCgIJVpn+BAIXmNdibeKoe/o+57tZku0GnKNqytOsy/Q2BpvPH3omZuC2l5irSWzJY/nT9js9kjZ0buBbCboishut6elpVcu9VkiZUvakev+euH23pPneYKEDoV9XFsxBLI8p8jzURMg0N5gupxZUVCpCafqMcVWUUwizimiMGgUijAmrCvkkdd9WEf3Vul9Gmx8vWmIiONCfh3/IykohYTRT1uK47O/fY3RAAmPnto5k15BFNiRGSUPGL88nGvHVT4KVQJtO9DUNfU+ZTru93u22y2r9ZrV6pq+azk9O+Ov/rULTs+mxDzRSjfbyEff2/K7v/ecm+0eER2PFnF8T9JxMIJC54hyjpwCwjM0LVleYJROSfJlCUGghDy8eCIKZERqhckL8qLCR4EkII3GC4lDYEi5myqmXVhW5kxmM5zK8UIShEFJhSn+k+T9hzpOvnEKv3P66b98Da77D+K4szuoidSCT6cSjT8qiBQAA8wUfPFivOw4weVvCj5DlwTAXb+yDw5MhcNj3VIN7j4ceYTs9RP9LvS1Gf+Nxxxo1oI//NanvM1vNB+4y718/fazz/6z+MkB+PFV3PnFApgfXnMc2ShVhOq1cjZ+Lj+9fuaQlDR+5wXiN1OPfcadX/xxH2/4sN8D3vuRnuLi3md16O5PYuTk8BQ+hm//rnxtvcyJ8S2+GP8iXxj/OI87+LM3qPFmElBKU80WLB8+Rk5P0SrS1A2z+ZIiL5nlhkwOGFOgpE47gpGOi4iYLGc6mTIbHAHIJIkZNQZFRECKlIkjREp8Og6fj5TNQPgsfPi1440Lt888qz93RVQ/mNb2iSAEGe61nzG+9vtouJ3w3q0/o4m6BP2vlxAj/i9dj+T3CDGgsagwJFvJwwcbx/ginyTABwzRmAyl9NGCMkaJEwYhNWLMrxttYBJHlYAU/vhcPvGao0oY10/hiDByyw8kokOnPy6DGBC2ZsKeOTsKtyK2N/h+R4ieet/TNQ0xeJSQNG2HVJrtruXZ5ZptE4jO8uUvPuArX3zCxfkCosPH5P98MNzJTAakrrsocnJj6Ib2aG5Vjj4NdkjS3cE6rHe0bUcI4Dw0bU/XWXyIDL3FOkdeFBBD8i72gcV8yulyyaTSaWuqFCfLEybTWeJnG41UCiE0PsY06BMCpUuyckqIis5JnMzRpkCanCiSAk8rlfjbzo44cgpp9c5itKKu99hhIBOgpOTFixdIKQneE2KkqWuurm+YVDPquub6+gbrE6tktVqz39esd3t2TUfX96Ozosc6N275xXGYlz5WAfE2EV1pRQzxGE93mC1IKYlEgh/TZmJgMplwsjjh0aNHnJ2dEYFyfsri0Rfo1YKgKmQUiTkBY5DCLVQixnV1XMN8Ss2913J//iXocFdyfO+EGNPdxUHkPcILRKbK8e7DiuXUIA8zlM+lIkpiCCAEV9dXfPObv8tv/fZvs6/rhGmPu5csUzy4OOfhg4f8hT/35zk9PacoSiKBrm1578OP+b0/+pCbXcPD/c/x9s3XCf7mWHGiSB7hy9MlX/ryl+m9QMjIdrtnOj2hKioKI/HtGqGzIzf+8JyVgEwrJlXBwk8TBh4ccqTXcvzsU6GWQqAEiJj85J2PCG/xfvQreYPjjQt3VJH2rYaYvUHhvksJIqbMuTsLIMRwZ3EIiDlEeSxMI4eGhC5FrPRkcoaIEf/4BdENRDfQNXtiu8X3G7bbDU3T0LXtKCJxo69EoKrK8Tkq5rMF2mRkWcbJ8hxdLsnyEp2XoJN1ZBjpQwiQRyOaFPl5C5oIVEzb19up+50T88c8Xi/cShwvKUBMNpPNihiuCP3H2PoD+v5DnNyQGY2SkfkCvO3Zrje0XUPEsPJ7Ply/pO4zzk9KxPQx0wc3FIucrtunYIK8RGuNkgItJVlmWCzmqDGZ5PG8SkUhBEAyDANGZ9R1wzBYdvWOvB+wLrDZ1MTQJQZAhFiCJLFX9rstmdFkpWH+6DEnZ6dUU03T7qiqCY+evsV0PicQKcsyDTiFxMfI4B1BSLJygSksdeuw0RD0jKIKCBMJQiFlggps3+FDUm4G7xKDxTts3zIVSbo91Ds++P577IoXZCNzY3uzYtADJ6eGzep7fHj1Aa3oKOYT3q8bdrbmplnzan1DN3h2dZ1scRFs9/WY6qLurY3DYPIwpDz4vRwK+WH93HqApHNBSsm7k3eR07cw+UuCWaKNwc4fos81tgp45VNCTvSjslYguB9ld18ZKe60TPfX8bgEuV/Juf+78fdCJDdHNaoplQQxWr+6qJLRrBmYfyFycZajs8QIkq9RHe/dfzoJkoPey5bh5fd5z/0ar3ZXCClxzoOASuTswwWy/BLl177Gg6dTphNNIFLvWp5n19Tr93gVVsyGh9CPUOTdx5KSoipZnp7Sj5xqdM5kMmdSTikzRb1yyDwnjN22GN8AmZAigh1othvavsMPPX5S4N9+SAypvqUr1ejvQiQ4S9/s6a1j6HuGrkF8Qhn46cdPBSq59wHEBP4zJqhIeVAH3eJuMkaILmFpwY5XKpdUUjii2yPcQ2zf8/E3/xXtfkPf7NmurvFDi/A2DXGUomlq7JDSmkNM0+e90bRth3cBKRXGJJMfrTOkNORFSTGZYcoppw8eszg94/TsAZP5KejJiHUnDM5HgVSJfSCVIAaLkPLeYOlT34cf9j0EGLuW5KKZwgCkSLl1QgSUkYjWEm3DrMo5Lx7TtxPqek+ZC9arG9p9nZSBJmPwgrod8FGxWm25OJ2wWMxw3tK2qRMtiwqdZWk4aJNbWZZl5FmO1ooYHIO1FEXyxu57i9Fpx+Rc6tYnRYlRhohgWk1Zb/b0gxuT3Qu2+5aryw2ZUSxPFpwuT5hUBeDph0A5mXJyuqSazcjLAmk0pijou54gBN3QJ9FHliF0RmcdnfVEoY+hEFopvFAIoQjWJSGPMvRDzzC6kh3SZbSW1E3N+uqay6sbJrMFs/mMel8zmc0pvGe9WtM0TRIDGUPXpzVW5PlIVctwvsdohbOJjVAVBUFAP1isvQ0/OBRk59yRLXI8Xe4O+MY1dAiyyPP8iJOHENhutyxOTojBE6NHyQO/P0neb+ckhw5xHFrKA8Z++D/uPf79dfvZToeRW/aIJOIJaQcaDtDAYUgpiYTx4nQLsR26z886QkxuhBGIQhGEwpQzZktJCNC0DUpLpidz+qCorad3h132uHmREjUOeI8Q0zjIOiKgMsnb8zxnvljghCHKpDotiimTaooKFmXMMbn1YHMgDj1p8DT7LTeXL9hsN8lnfFrQfe1dwqwcUe5k0kUEEQNds2N7c8V2X+Nsj+1agvsJQyXptb6uYzx8Bp8idb1TyCSS6AVaaqK/m1Qucc5ihAU/IISH0ONsy25zzXZ9xYtnH9Jsrvi5y4cQI+/91r+C6JAxYJSk2W7pBos2miIvuLq6QqrU0QggBEdPCrpVShOEot1uQECZF1S54fqyRmiNj4IX0zmDD0ymc5YXTzl98mW+9OWvUU7mKDNJWXk+YHRGiAEXb6OmXn9P7v73hz2O2+pxICnkiMWNnF8tIpmRZK3jZJLxsJzQrHes9lsQksmkwnYdtmtpY1L6rbY17eBAaqwLPHx4xnxRUZYm+YcojVb5kWtsjKEsS5RWtG1LnmdpwQ01QiQML89z9vs9dvC8fPmS1c3myK/uB0s/WJq2Y3Aeax3ILFGfMsnDBxeczGeURYFWo6Nj19K5ngePHyO0QWU5Umuc9QwuJAVbDORVSVFMkCanrR3eR4KMZCoVzsHV6KKiLDJMliMFBDx5kRPjlKHv8MOAFIH1ek1TR6bTGV/80peOHXEIkaurK54/f44UikePHhFjpG4apPMIIUYeek1R5DRtl1wEy5y67fA+wUOzyYTdPu0ED4X7eG7cEdkcP/vXvi7LgqpKaT4pNSV16wdhUhw50sSAGsU2t/tCbsNquf3vYY3djhHvr9u7K/Hz12k6ghiL96EpS5ux4w4xxoN7Yrh/rfgUcdDd+44jXIqUzBanPHryDtNuwPqAGwayPGe+nOPCQDYpiFKNxSoePcK1UqMCN0crfYSpDnETkVTgpdHozBCCxI5ikhAc3lmc7Y5fh5DUyFGkhJ+x0LDb3PDRB+/x6tUriJ7hbEnfNrfznxEhlkSInrbesbp6yWq9xtsBN3QE23/u+304fqiO+7OwqE+84a8pv0RwSHxyA7uDt3kXMAKk3WHbNavrS14+/4BXLz5gu75MXrrBE3qH9Q1aGbZXLyEEFosFz569IiIoqoqhHVhfJwm1UYbtZps6VHkQO0gkiq7rEaP8tihKBtux3mwQSjKbzbD9jt1mS72+5PrVR+j3fpdv/faCarJgef6Yr/zMz3Px8ClaTLGyQKninqDiJ3XcmauPHRRHbEyKiBYB4VrmheREKtavnrFbPUcryeAcV5eXyBg5OzujbS2ry1dcXu8Yoma1WTOdaU6WFfNFCXKA4CjLKcZMcNERo0WrhDEePs88z5IRk5odY7vatqfrerabHUppTpZLQhS0bY9UkBWGwSf7ghgF+6ZhcVKxPFmyPJlDjEyrjDwzvHz5Ei8l58tHnJyeUk4mSGPSySsFTdsy9JFqOkVKjbWeGAbaZiCQJZ6582SFZDpfYPLk/x2dT4EDUuDGIieVQmiNsz3T6RRnHW2MWOfQStEPA7u6YbeviUJgsoxXl5fEGGnbFuvC8QJXVRXWOeazGTFuaTcthEBmNF1vaeo93t02LIfC+3k2CAfJu1KKyWTCZFKS5zmnp8n/5C61UKsEUUR5KKCjAEeM+G187dz9DJLIj3JE7synScX5gG0TQN1X8HymzP/T7lkc6S4CqQ3TxZK3v/gVXJD0vWW9uiErc5YPzol4dOxRJhuDHRLTSMo0H0n8cI1S8gjzxXuFO3HkffDsmxbve2zf4IYB27XEocV3G4Z+CSMf36ixfMYwhkZE3NATXDLVcrYnOnd78RpfixDJIbBvG26uX7G6vkFET3K++SlAJZ9buO9QjuR4xSM6+qZlu3rOZvWKvu9ZLpd84QtfSFlxIbK6ueHy/e/w/MP3WK9eIbHgO9r9GmKP7SyTcnkMfFVSU80rPnr2nLKcMK0qQghsmj1SakDS1B0xpv6iazuklGSZTlt5n1zWZtM5wxDY1B1BZ8xnMyazKVdXlzRdR1mUVCbS7D+g3gh8VBQfnvD+d79BNTvl6dtf5Ku/+J8zPX2KlDptAcW47RUjts+dmKnDW3T87vWvPvGG3qMdxnHwGsa/8dainKXvdqybF8xFZDGtuFyv6HpH8HH0q37JarMjpG+5Wa9p2oEHF0vOzxfkuSQ4B/HQZWcUJkOIcYDnE/5WFAXOORrvUVna6u92e4bBUpYVWhlublbs9y3lZMF0XvDi1auET469jVCS2XzKdFJSlQXNfosPnuXiCbvdmsmkIJsvWV48RJkMkxegJH3TsK9r2rajKhYYZQguwWDeDngb0JnCRaiqisXJEmFyrPc4N4whbhHb9VjriNFj7YDtO5SAFy9esF6tqIqCzBiEkmw2WzabDU3bURQlk3KC7x19P7A8PeXy6oayLIkxZXBudztCaI7rX6tEJc2Nph/smAhzm3Jz6Og/tYDHFI0WQ+LUO2txVrM8OaGqymNmpTFmFK1kGGMIUuEOa+rOfOTeMPK17v4HHTEeVuCnHOIO4Hn4IkS8GJNy4Gj5eihcfhzUiUOrLz5ph3v368PZI7UiL0uWZ2f4aKibFqE0UivmJ2foTBL6XeJSi7vzBIVSOhlCBU/0o/XqPZHQwSY3GatdXd/g+5a2aXF23EG4HuFq3nk4w7t3CeEglEn3kXaZAm8t1qY1N/QD9p6/tjj+vxqpvq7vSVFrHu8HfHgzP44fGuN+XRkFQJBIMiAgYo+WFtdvePXse3z/u99me/Oc3eaam+trBmv5G3/9r/Pkrbf4+KOPeP7sGd1mnQzH19eJrB4DsXf0vU1WmEDf98ymcypT8Oz5x0ynU05Pl2xWG1arNUVZIoVgGAZiCAlfDAEJScbtRugmBDRpaNfst7jgUTGSS8X68hrb9kyykvlknqK56kg/9EymM0LTsG17rj78gOsPvsv33/tdfv7P/Hm+9OU/STV5hBMlTghs9AhJcvsat2QpZSPJY8PINJCfc/4cyrYQB+/thF/6yLgtNkSZITLDpFgyjRmXz/YMQ4ps6juHG9KWTgqNcz1NN9B2DinhrScXnC5Psb0l2sjp6QmPnz5GSIXrW4IDHz0Eh9IaIyVaKbq2pd31x1O53tdItUFJxWw+Jysq2j7gvGc+n3N9fY3WMrFQgk9dzeBoQ0NuMhaLGZnWUJWp2BjFbDZhMp9h+4G6rvE+0OxrjEkOfs4LrPVkZcngE+sAITAmJ88rvIuAR+kMNARnGfqWvusTTBAj7b6lrmuUEmhd8OhJsvV01rHdrrnZ7glIXPBMixkRwezsgtYGXr54gclKTFZCFOx3e0SU9J1NFxFpUoSWlmghkDGiPWNRjWNXOopMhCIS8cGhlUQCRmmCT8niuTJUeU5mJEaRksODSwVqHFgiC8AkcyZlcegUdDFeMuOh+x4H/z+sWdrnLNLbQhvGPaJIUIWPB2ggrXUVBQMRKxQOgQgiYeCfOAmO7fnoxjdi1UpgCkMxKQgqIxpJ19YEkbBwpQxi9DT3Lq0JHwVBZfgowHaE+ho32heEO66LMiSpjx9atusXXL34GL8fcL2jtzapKH2PDD03b59hhw5RzUakO21xopR4DF6UODFJtV5U9F4dQ7uVSC9GkGBjiYSoGPpA9B4ZSVDOGxw/XOEeyfWfmP4qgfOWTAGux3Zrfu+3/jUff//3sc0G2zZ8+MGHtG3LpKr49u/877z3rW8SgbZpkN5jypJmt+HBgwf0fY+znrKY4F3ken2FWiqapuHj/UfJp+HJY549e8Zuu+fk5ATvPU3T4L0/SrfT5x8px4w/KSXq4Akx+gcYmSwWm/2e/X6PlJLZZMnQ9/RtD1Exny0RQtCMnhrBB8xsyvbVc3717/9dHjz5Tf7ir/xXPH736+hyBkLhYsRzmAscZiKHFugeyPc57/f4Eg7/xu4nEPERQpTkZYkKhuuXN1zfpAtYbzvKKmPdbcZw30DdtGlI5jx5rlPWZF1TLnJm8xO++tUvoY3EeUfQgs1qhR+Vi3meI4Vgu92lIuMjXX+bkuGc53pzw9X1NcbkCFUgpMRaez8FHciznOl0SfSe6aRgMpkwDD1mHH6a+YLpdAreU4+GP4dEcEj3k0TdGus8bWcxxQRrB+azJSEE2rZFFwItFM47hq7F2QGjNUoquq47Qhyp+xVcXV0hlGJaVQyD4+GDR3zsLDOX8gTLrGS1qdnuG8pqymQyoW0amrqm7zqGYSDPi8QoOTBGSLarSkqkCxRKg5DUXUffu3HOk/yelRpdAaUiMxlBOIxO0u+yLJjNkyuedxZrFWWWIZUcB9US7xwyeJAOhCYJ+8eVI24X00+saB9X8Scx6sNDeCD6kJwBxwLsSeG5MG7KDyfHpxxjtTlChVrL43tVlRltkWGDHxlmFt/tccOQPlPvETIJ6mLwuKGl2d5guxYMifxwh8GhgdD3bC5f8erDD4iNw1vP4B0+JkhOhoH9+obo7P2h7jiESurJHKULpIgIneH8IYJkvKkQhCgQUqOzHGUKsnKKHXpU9FRVwZscPxxUkh75niwX0tU8CIfDo0XL97/7Tf7wD/536tUzrl58gO8jRTbli0/fYTabpXy4ECmyHHTqEFerFXmeMwwDbdsm3NBa2q5lMpmgtcIOnuVyidaajz76iN1ux3Sa8Na+T7aL0+k0mQAZk4p3TNLhuxP9g3XjwcTHez+eePnRP7nrugQRTCZMJ1P2u13aBo7mP69evCQiEVrzcfMt/tHNJV/62V/kl/7Sf8ni9ClSFnjUbcEVESXkkdKXkkneLF8ODhP82+9DiAgp8d6x3tyghp4sM+z3O4QSNHU7YqU6Tb9FukC5AGWZoY3EZJrJpORrX32H84tTQkw2lvv1BudTyo11nhD643vV1DX9WKQ2m80x+V3I5NzXdnt8bI/vtVLqWLjT8xEoIsWkYjqfIrXAyFS0syzj9OIiJb+vN9Qjtc7ojHrfgFRstzuUycnLGc53hJAggeATK6bvW0xeJWl0NzIZnEerVBCHPq2VQ0o7JF/w1XrNfLFIz1krNuvmGOy73+14sX3JdteipMSYnKurq+RV0jT35huH13l47YdBrcwEQmniyLgY+u0InXA0R5oUJUYbYkgmSGaMKvPhYE4VboMW1OgmGAPeDXT1niKfgSwQKtzu2H6YE/zHPD7tohBGPUAQgSDvaAR+4PXjAMummDQpEvtst12jiwpB8uOumz3OtuhM4vuatqmJ4SztLrxFIVAxoMTY+8v0PK2zGJmaCQmoKBHWs7/esHp+mcJAQhqMCgVERwx9yms9XgyPLxylJNVkwnK5JJCCkie5HvGe10IqpASTkU/mLM4fEHRO2zRoJVgu5m/0Xr954T4MVrgt2kfprpAIlSFjh5GSD7/3R1x99CG2vuHJ+QMImuXJxfgiwXmHQbJbrTk7OwMSt7Ysy2PXe1igeZbjYqAfBqqiQkTBzc0NSimqqkoUscA4bCyOJ07XdZRlSTv6PRxoV33fH0+qQ2d08D/WWh9P6GGcWE+rivVqdTzJq7LEec/QD2TSYLuBSZXRrD7mt3/9JR9/+D3++n/93/HW2z8DZkIQaeQQkccuSBLf8IS6nRsQD1vdw28EjHaqs0JhbI4Jc3wIXK+uIGp8gKbriYyG+lITI2ijOTmZMZnknJ6dsDxZpJ2PFvRDT9O2+BDIijy9H9GO7IYSqRW+i6w2a3wI5GXBMFiEgN1uh5AapTVN0xyHbIeYruVyydnZkvPz08SnjgE3BOaLeWL5lCVFOWHoBtbrLTFG+t6yWe/ouoEsr4gijjTPwGA9WTWDmD7/YeiRUhOtxFmHzorxgpWGd957drsd3vtjUe37nrqukUIwnU7Zbrd8+OH7vHj2jIuLM/KioKkbpBDM53P6ruPm+obddpt2E9YdcWo/+jkfhvIpTSVJmA9GWHXbjOKxcV5T5EQiWiaP8cNzgjSMdtYSQ3b0Ksmy7NiFBh9w1mL7BtFsyGanoBxCJUrHa0r3n2i3/drq/IxjHFTG9Jklp8jDUDAez4LPHuyPyTsJWEqQV1Pz8vlLpNLE3rLZrLHBEkk7ftt9PYmVfKJICqFS9xtj0ngMlljEtLOUI28+gpaKTGiUA+ki0fljPF2Csnq0dLi+J3h3Z956KMgSrW5NsuQoIvOvzzDGwi2UppjMOH3wiHx6Qt00RO+YTqo3eu9/ZB73rd8CEAUqKlRQ6CAoo0EMcL54QCYlXd+xWa2JITCbzfDeM38wR0uFGyx1u+fs7OxYTI0xrNfrY/EehoGYpe35fthTjH69Xdfhg8fo/Pj9wVENOJ6QB/jEWps4yXl+PIljjPdMjbquQ2vNyckJQgj2ux1uGCAEzs/PU2Bt1yXsWgZyLal3a2zssUiuguAf/73/J7/85/4LfvZP/3nyyQlDVARhxqFlGpoqkaCOz35/b7eJCZ5iVGneFu80a3DE6ADPMCSjI63KJFJxLdvdHp2VScnnAzrLePLkEVmuEDKSZYnbrGSgaXr2dc16vaFv+7GjiygpybIcOzi00WRFiUcgvE+UNDVgraWczNjvanwYju93chtMtML5fE6Mga5ryMsCHzxlNSEfLwjT2RwfYb1a46yj6wa6rqNte4qiout6grDkE0nX9yiTo5RiX9cEFMVshlIxMQzUwfNBHLnQXV0TQjg+t0O3XJYlFxcXOO/58MMPU+EcL/JdmxSX09mMfgjY8QIeY2S73SaYpB9oup7drjkOHyeTyXEdKqUYbGIXVEVB32/TRU0m58XgPEpEZtMKgSAz6njBiwSyIil+QVAUBUVZYb2naRsmkxkiOILrcH2Nzmdp4DcO/VLv/eY7u5/kcYAGxVh4pRyDjhEj6+wAYH/OPcR0GwW4rmV7fc2LF68S9GY9IXoilhgtzkhc34x2wGl3a8dk+gAM/tDxJ6fGQwpbZGQaSUWWFRhTJA1AJFm6Bo8xFZkO2DD6k3DLEIIDE0geC7eSSeKe7v9wrkYIgRAkUiXBz2Q6JUiNygvsMFD9NAr3XTrT7c+AGNACdLSYMPDofMmH8zn1fkNRLonCIZREGQ1ScHF2wb7esxojq7RORfP6+vrY2Z6enjIMA7v97mj3GAPMZjOklOz3e7z3FHmREl5COCZwH0x7jiq1O9l+wzAcbUKB0YA/vcFN05Dn+TEbsN7XdG2HkpInTx6nkNe6SVfzEJBGJKggelxIb4Zyge3Lj/jn/++/w/Wrj/lLf+2/Jj95SB8FMZoENR2my3ewx9ePeOf3SeKeaETHCX2MxOgZhg6hAibT7L1Pw0kkRZnRtR0RwXa3pywn7D68oe2gKAu0FigtmExLrO1AS+p9zW6/p+26RK2znjzPCKSFnuUZq9WKfdPjfaAsS5xLJk1VVTGbLZhMZvR96tAPhfEQwVXXNednC7LRebCYTJgtkstfOZ0QheDm+oam6ejanpubG2IUhABaOermhvnpaXIo7Dri4BiCROqM6XSeBELCAx6TqcRMMQXeOvbbZMReFAV936dAiCw7PvdhGNju9xRlwcsXzxMXfBgY+g4pJJOqouu3DMPAfr9ns93SdSn6bOgHhuF2PQkhjhx3pRTDMKC0omlbJJLZdEI/9CmJPngyk4z3c5Uu7koImr6j6zqKsmQ2S2ETId7GmpVlQd8n1o/AE33ymhbRE6JLW3wOjI4f/fj8NRpfu+1rt4vH7eHtMPbO+v7kY93/e0kaOhMCMQR8P7DfrNhcJxowNoU/SxGQ0qEyg+s7klgtMUoggjKovGQyX1KoKYQRJbjdvhKVAKPJZjMmp6cQFW3X0+9rtIgoDcZEvKrog7r3nsTxuesxszLLskTvG5vGu/UHkYaySgSqwrBcLlB5QWcdw9AzrX6Khfv1Q+IRfgd2w+/9zq/zu9/4NYLfU81yXHRkZUH0jmo6xVnLd9977zisyjIzvkBHnqf0hwMuCvClL36Jj188Jw7piijudNBpu2tom47tdstsNiOEQNM0x78/4PJ3g1k3m82x0z5scfu+ZzKZUFXViK062qahyNMAbb1eH/FcrTWnZ6dcbV5hlcVbiZYJd2vWezIj8SLyB//2X9Bu1/yFv/F/4uTpl3GoI1ByGIu86WklPiFUSGIGpSRFkdNvr0Z6nkcoQ1XN+OD9DymqCZv6mtY62s4SomawFqkEJycLlJKEmAQs1lmuLq9w1iVRjDZY68dFmbHZ7Bhsor5pYxicpSxLkIK27ygnFdVkgnO7lAozziwOisP5fJYin4hMJhVZWZDlOeVkikdwfbNiv2uwQ9oNdd2AtR6lNOvVhslsmvIaN2uyYsrFxQXonHbwmMyk1HTbJ62AyqnyCSEEuq5L8mig6zo2mw1aa6qqwhjDixcvEsyjFDfXN/R9z+nyhMXJHNt3FHmORNH2nvff/4CmaWiahtl0OvqSD0cVpJTyHlxnreWtt97i8vKS4D2z+TwNSKuKKARlWZFlhtgP1LstJstYnp1yUV7w7PlzfAxHmE+JOyk5o6WDtRY79ORZhRQhhSB7n7pCoZJIJC2Xf09H2jcme9Mf/iKSlIkHoDESrMX1LUKoZDkhPDCAt/hgcUMHjKpGpYkhIrOcxekD3v7SwMnH53A9xr4d7CxEClwQWcbi4pyHwwAhZ7dv0dsdUgsmVU6mA/n8DK/KJAo6PEc4Cn3UaFMbvUcqmdwo4206kIjJU0nLSJEbqjJJ6GU/jKyrN9sd/XCFOwJRHrfsUjhEtOD2DLvnfPv3f5vv/d5v4e0OH3oKYzClocgKbJc8dPf1HqXVqGCL2GFI0fTeMp1OE4wyn1PXddpaAz/zta9hvpMRXDLw11qT5xmz6Yzr6xukFDx8cIEPSQUHoLU6DiBDSIOdFOQqjsnb2+0O79NtqqpkOp2xXq8SBOMTrDOdTFlv1jR1uhhkec6kqmjqBussg3MU2YxcTRjaHhHA9i3GCHy34zu/8xtcbzb8yv/h/8JbX/l5hKmIqGRnOQ5uDrOOUSN5z0chLQ85bjsPt48QB4wMzEyGbVv2uy3lpESonBAFN1dXDF2HznJigO12Tz8E8okaO8gpZ+enaKMwUnF1dc2LV9dcrjacnpyASmZObZ+666ZPA95+GJjOZljn6MZUFyUVZVny6tUVMSTFmhgTwQ8D46LM0/NXknwyoZpOqWZzimqCHAtz03RpGEpMA8RhSAyWtsOYbORon1JNZ5i8REpJPwxkOgmDVJaxamo668jLE+xgicHRd92IFXt2uy3XN9e8/fbbaRA+hhEorfAhdbQXDy6YVOUIreX4ANvtllcvnnNzdZXwbed4+fIlRmmm0xmxTrxipQ3WWcqiYLvbMQwDL1+9Srxx69jv6uSzYS0mT9mFciwcMSRYwDlHt14znaVdCCKJfrKiSB2bSlv/A7QYYiQGS3QtigFwuGgQIgV23Ztq/3uo4EIka9hExWRc73dbl08v6OGAkQsxGowJfAzJpyY4TISU1OIQOLIsMlg3Uu5GoZ8UKJNRTWfMT07JrkqI4GOi5h6eQpQClRvK+ZxFNxBDgSp6ZFmitGZS5ikjs8gPNt53dhy3UJBkDHkYZ4Heu+P7f2x6Q/pcVBpU4K3FD8k7J7ifsMkURESIiJBDVCgGZNgT7TXPv/dNvvNb/5pXr15ihz5dUbICO1hOTyv22y3Lk2XCkYeOzCSxxmQ6oZpNjrBF13Uopbi6umIymbBarVgsFmy3Ky6kBBk5XS7SItaKer8lBsfjhxdHzDI3OuXBhQAyecUcunTv7bh9ldT1nhhTgvTJyQLnLNfXr44MlIuLc5wL3KxXqavxjrIqE5Y+JFZCtJJSTChNwTA0+DAQCBiT4UNMLARjef7eN/ln/2DLX/6b/w1f/ZN/EasWRJmD77gDnCBQHPK5o/AIGRBBIeOoQI2BKBwRj9EtpW8oXUtzeY1RGYOJYHtib6nXN+ACUUE3eJRJqevGCHbbmv3Ost3s8HZHW3fsdpbLm5Y2GGyUzIsK6yzaR0pjEFJgB0sgMVlCBBcibb1POxehWSwWGKnApWFU2zVorVAGTK44uzhnOpslvneWM5nNsYOlbQZsZ2n2NbuuQ2uDNga/rRl6S14UnJ6dcXJ2DjpjCBGCR+ERMVHoZBzom57YBZbzM6q8ou4t/eDw1kEI44V24OHjhyBhGAaEEkwXU5zzrK7XzKYzpIp4N7A8OWGz2rHd7Ll88ZJ6syVaixYSh2RWpQCGtm1QckBKNVJPx4IgBdU0rW8XwPqIbTuEEEwmU7Is4/x0yfX1NdZa8iyjrMp0Xkwrnr98hlapSZlMZynUWYoEOYZ0PnoiNgqyGJC2hn6NyiYEUaIQ6BBx+Dceh/9EjxHHl3giY/PkE/SVaIsSxGf7Tyd4e/TVUwZpMkSWI8ppKnw2DRlllkQ30ggchugjmoAQDoVCj3YRh5DoCFgn8Oo2eR0hxti0gqqc4nyeOOIqoywqClMhg2VSgVb+yD+XI91ACU+hBbkRZBlEYZB4XLDpuR2hG0GUMcE7yHEH0eP7DtyA9T9xyXvqCqSyqNiB3dOsPub73/4G3/7mv6XZvExDO5J67QBDvHzxgsVsztVlMqE/Ozvj+vqaPM8Yxq7qgAWWZeqimqahbds0/Ok7QvQMusfo/DhYjDGy3+95cPEgnYAj9v7gwQWbzYbdbsdkMmG/3x/jrw787rreH//m6D9R12kbHgIXFxdHTLZte0IIx9DaA7ZurcWMmJazdhxapWFfylPskDqj7VpKLVi9es6v/k9/jygyvvrzv0xUfhS4HpBIeYcRO/7mllBynMQTRo5IsGTSEwcLwVPXDc5D2w0MTcPQWyaTKTZK6qZB5Slb0ofAzWrN9fWKm/UaayW29+x2AzerLS5a5pOC9WaL1mmoVjctWZayD02WU6gSNRbY+Xyepu9+lMVXFXqkP05mBdpI8sJQTSdM51O0yakmM4SQdG1SMq7XG+p9zXazJZ9NmEymXNeXGKN59OAR08WCajYlqybIvDry48PYIWslE13UO04WCTOs6z1155E6SzLm7RapBA8fPEyJKU2bcFPn08kcE72ybVuyPJlfNXXNMAwsT5fsNztefPwRYlzfZVmhpGK/b7DWJe41HIfb/TAQfDhCgrvtjiQSMkc7iKP8e2RVOO9x3vH82XNOH5xijOHJkydY65IRWlWhtTmyMIzJQAhciIQoiHiCH4h+AJ1sHnz0n8uV/ukeo/gHRjZQHJOQ3sQ6I3KrqkzwotY58/kZp6cOkIiuw3qHmZTkRYYWAVRGFDqlj3MgcQiEJJ2ndoAY8c4Szd1ZXURpxXQyYd4FAhVZl4EK5HnBJJsSbU+e+08YYyVZyIFtFxi65M2jsLTNaVpfIY7Y++1gMwRP23VsN+sRVhvuML4///ihoJIoQMQ9wa24+uiP+O1/8y+pr5NDX55lmNGe8jBxB5hOp6zWKx6cX5BlGR988EGKMHrrLTabDX3fY4w5MhAOtKfJZMLZ2VlipGxWCMTxJPjKV77C8+cpiDU9jjwyTdbr9fECcKBVHYabh5MF0pBzMpmkROdhONK4Tk9Padt2fCMdQiiKokAIcWShHJ5nlmUMw3Ckgx1MgA4XBR8DeVEQnKXerKn3Hf/o7/4/YBj4mT/5y/jshIOyTHKIQorJW+IOXQoxKi+jh5gcE00cULFnaHeE4JBK4oaBPMsIQ482BhfA2YBS+jgYCgF8iKw2O15eXhHDhOgF+6ZjX7fklUFKhbUOpZLXg/c93qeLUtf1dF2Lc24M9Q1jHqSibWuGruZkNuF0eYLKDLPZlKJKJ5bUEqnyNNX3nt1uz83NGq0Mu10NQGYM65sbThZzzr/4JbQ2dIPD5Bl5kRGkOkq9B+uQMn0O3h+sS1NGYNc7vBdYH7h8dUmuNQ/OHiKEZLfdj6rJ5Fi5Xm3I8wSdASwWC2azKTc3N7Rty+Wra168eH7k8CcILvmZ7Pf7cWAokzx9nK3EGJO4yCZBiDaaPE9DcTFSCyFxyIWQVFWVknJsGmRmxqBNEmM8evSIV1dXMIptsrwYHSljEnrFlDQevcfIQJSeITpcMIiDsPSHOdF/gscREIlj9qYfu/9xOPiD6dwHeFCiVcH56SOimqGzHNvs6PqObFpRTUtEdBSTOdIUpDjtBJVIKRAxYvs2FWzGwj0KcAQRJZKvdp5lGKNxQY4U7HEGNgyo6NHajPj4nacoxBHbtoOlqWuss0TbsdussUM/sl/SxUjIBCWGEOiams36JtEUvf/pFG4ReoK94fl7v82L7/0+lx99C+0Fmc7wiiPksdvtKMsS7z37/Z5333mHm6trNpsNs9mMGCOXl5ecn58fi/ehQz8MGK214xZy4PzijLzPcdbTdR0ffZTSiS8uLlLC9uX1sSBrrY9MgbsiiKZpjq/jQNXa7XZYa9lsNpycnDCfz+8UbQuIY1E4nJAHzvdd+uGhgzpwcA8GQCrTEGMaFjkP0tOtX/L/+Qf/L2zf8tVf+i9R+QSPHCOcDkU7fYAiJgvJWxgwpqBdbzGhx9ATbcdsMqE8P+Xyak1TtwBU1YSsnPC99z9CSEU3DAgJ1nuGwdMPlt2upcwFtves1i27fYMuT7DWY91ACJGTkxOqasJ+t2MYLMGHJO6RghBaptP0XkopKMuck/mM5XySgn7zLDEhRoFCJOHeTTtQ1y1d16OVYb3eEEJM/jFtx5NHD5lVE0SUdMMAUpAVOUKrtNZgLACRoigwJmO3r3EBCpmz37f0QSJNSd/3nJ2dcrY8IcaUuH44kjXqjv2+5ubmhu12z3IxPzKc2rbl6vqatu6oqopoe4QAYxxt296zZe2tJTeJNdS2LXXb4EJAaTWuzXRhvri44MWLFwzDwHSaLg55ntO2bRKDBUc5qWjalpIcrTWbzQZrLVU1HRlTqXtESJQ2ydkyeGy/p+gLzLTHxR4XDRGF+mMq25/GE78FApMM3vvD3lHc8e75zHvkLldc64zJ5AQrSpTJ6LRCDR3FdEJRFUTfE5UZ48IgkxI8KKmOhTlZJMekfjze8whliEPAQcD2HV1bOdhmxwABAABJREFU03c1fujAeDQRXyXI9RA0AgfigBhnQD277Zah79B4hq4dbXeTbkGOPv9CpIgJZ23yHSLpK9QP3ImM78Ub3Yr0Ylx9ye/93r/ge7//bzmtNIUBqQSZ0bSjzeRutzt2E++++y4xRl48f8HTt97ixYsXNE3DgwcP8N7z6tUrjDF8+ctfBjiqIaWU1HVNjJGzs3OEIG1hs4J6PPEOsEdZlkyniW2w3++PPPDtdosxhsViwWq1AjjCIFVV8fHHH6fgha47FvkD++Hw2HmeBCh33dwO9MG+749F2xhz7N4SbOBHI6DkQUFIiT1KgGtrNn7gV//h/8BuiPzyX/qr6GxClEXimB6uyjFRAOXo+BbFIcohIIMljwP97pqHk4LTIuPy6prVek2m0meQZyU+BNq+Ryg92mwmubF1ns22ZruryYyHKBmsp+stzkWatqWQgswkH+70fht2ux1N02CtT685SwZH02nFfD5hOpuwXMwxIo5bVIkx2fi5SJTOaNuB3bamrttRYDOkzl5EmrplsZxCCKxXK7Q2+AjlbIb1A0YVmCxDAfu6pqomKGVSQvx+T1FN6YeO9WaP0CXTrOLi4oIiz2n2e+q6Y7Ae5wJFUbHf77DWMZlMaduOsijY7/cI4YnBsd/vcdaxODlht1qP3XXaTR6k+ELIo6pUCJE8uouCtu9xdmCwyUUxjukns9mM9XpNXdcpzOPkBDsMDKGn6zrOzk6J47Z+0JLpdMputyczSeKe54mJE2NKBtc6yfqjDJjoKWhh2KKoCIfO899Tu31LXmXkTqfdgR93fUp+tqXr8Q7GQwBZbijLjMZ5lNEYNSd3BfmkIisyCDlmpGNKqZBSEF1qtICjyVSMkaFrR/UyaRsaPUaPQi1n6eqeZnONbXc4BFGnjrtWGbatcXZOMBlyDMmIpB23kjLdr3NE4enbjuAdh2CYSJr/BBEoipzFyTzZUgtFlWfk5ifsVeK95YPf+7e8983fYv3yFUMhKXJDkFAP/RhVFY7eFocFmmUZDx5c8OzZM5RSPHz4kPV6jbWWL33pS0f5etd1XFxccHZ2xtXVFY8ePWK73Sace4zKOqSFvHz5kuVyyTAMVOXA+fk5fd+PQgt37Hy11lxfXx8hktPTU7TWXI54exoSTY688EPxns1SRuF+X99LJtFaJybM6MFxeD4H+mII4Sg4UVrhgksW8iEpQH2M9HZAS8HQbPm3//TvY7D82V/5m9goQOaJmhTT1lLE2+yS5HjgESLJd32zZZoJZmXGdv2Spk3BpvVmR1mUmKxi33QpREEborWEEYtzImBtoGk72k7ibeT6uma/byj3DWfTHF1llGXFZrMd2QuMGJ5AKTNyq834PiZnta5r2BCYjDOLZrNP20qhCH7Ax562HxJeW6RoKCnTYvc+sliUGM0xoaZtW6rpDKkEyiikTkWoG9eakILBDok62HZEIbFNR4wycZ/nU/Ii+YV3bY3WOetN2jkcime6EFnatqUocqpx/a5uUnGezWd4G0b1Zzwqa4WQeD+QZyPMZx1+dPPb7XZpKGvVce3kec5yueTVq1dHHYG19ii/9+O6Xa/XTOZTTJE8Ti4vL5O7nTHj2hsQUpLlObPZFBciSksKI5hkgSLUuGGDljOCmhClRrw2APxJKyg/7wgjY0qk8cwxgCDE28L+WUcalYxJ6kqgtcBkAiEtWZ6hY4bxGpkZtJZEx60DYIzHNXsIIum7lmzoiSEwdM3ISCFBJjF13c4NtM2eer2h363wtk6Re26bgq9bqDfv4i8uUpiKHI3HGZWu3o9GbDtkdHRNTfQHa9dAFIEYGHeoBWenJ2ipETElaqk3TBh/48Jt+44X7/0eX3jwgPbVJftNzVBFynnJrt4iA2lAM3adV1dXnJ6estvtuL66ItPJE+Ty8pKTkxO+9rWv8d5773F9fY1SiouLC5bLJVdXV2ijefHiRXrTleThw4cUqyRn7/qO09PTe6rKzWZDURTJV9k5nj9/zunpaTKrGtWQCVaxrFYrDp7KDx8+ZLVajTxfdxxCHk4gPyqt4JZ6dejAj17jIjkSHgZNR+m8s4QwIJAYk9zarEudV9P1KK0Y1s/5X//R3yOrpvzcn/0rIE3ieY/QiLhjzZtwyvThJ+9eh8Fz/eoFwjUoqSiKEtt2TMuCq+stXd8jhCQvSjaNTdtUmYYkPgR2u4ZMB9p9R9dHrAtYm1wZeyVGuqQ/Wrr2fWLlGJMTvEfKJFM/iA6khGHoCUPanXSDJQaByQqKEoSSSJEUgev1hslkSt9bum6g74fjbKJrWow2zGYzyumUrMiRmUmDtsEeB89Jrp442geRj8lzlstzTDnHBk/bNjiX5idt29H3Azc3N0f2UOr6U/EkRorFbKSHTvjiF2fgJc8+fkGMBxtVRd8PNE17hMxWqxVN1zEbDbKurq9TdiccB9jJo7wdAylyzs7OePXqFZPJBCHEcaDftg1t06KMpO/T7u3hw4f0g6XtUrZqyva0TKfzpKGAcT0ExGARskTqBmkGoirvVcdUs+9iyz+g6/0xj2NTy1is420Hfkdl9imH4HAiCJmcNLNcIpUn0tE0A7nIEm3Vpt0pYYBgkgjJO4JO0JUQSQLf1Hvy7rDT644YdxzVmzF4tpsNL58/Z311Q99sGXyCxIRXCDtgd45mt7mnmDzkgx5esHeO4BzapPtMVq3x+C/tCNLANISQRIcuILxHfEooy6cdb1y4g/e8+Oh93v3iUx48eMCLly/RWtE1A2VWEQebfDycYz6d4bxju9lQFiUPzs757h/9IVIpzs/OePjwAb//+7+Lc56nbz0BAR988AHbzSq52/UtWkvmsxl1U7Pbbui6jjwrIUYePXzIbpeGn1Iq+r5DCviZn/ka3/7Wt3jy5PHRAKlpap6+9RbWOfq+S0Is77m4OKdt6numQIeifXcIqZQ58pEP3fcB5z502gcY5QCZHIp7DKPoQEg8Ae/HBBQhsf1AiBId9/yzf/g/khnD137hlxD5nCgzHAKpIEiIMhm1qxjRMSQ3xWAR9BRVhozQNY56X5NnBR9/+AG6mOJiwtkVHqnViCtqPNA5S1mUo8G3pndD4gYLkQYwOqPp0q7F+kg/WAbrqco8JQdVJV3bIKMg1xnRRdq2p21bhi4NNsuqIi8KTFFigyN66AbLvm4AQYwNQz9Q5DmqzFnMp9jQ432GKUuqacLJjSkIQaDR1G0z8vIjXdfRdW0KP9AZRVGgssQe2u62oAqkythvW7abHbtdfdwhtG1D3/es1wkC0VojJxVSa7TJUaqnbzu6pmN1fclqdUXftKzXW2bzGdoY9k3HZr+ns5a8LCirgmcvnhEIDHZgMpsTY0wDVjuw3q5xzrGvdzx+9JiqLIAEGXRdw2w+5ez8La5urnHeMy0nnJws2Wy22MEitUmpL0WBs5Z6v6OsJmMLKzAqZ5JLutgTQ0sUA73wyOhH5WJMFDcO3u6jeuCHbsDjvf8cwOpPK8GJhj5yuKUci/eYdHlQE37q34n7lxSRdp1Ei5EJchjaJoUzS4UpMmR0NCoNp61zKKMTbZBkbKaIo5VEZHA22b3CUV0NKRj62bMP2bx6jgjJ0lUKmd5jZ8HD0N9i3Imf7pExkCnFyWTGg7OH+NkpxsBscQpCj8NShQjJHfCw7Ri6ls1mRVO32CHtvN7kePPCHSM3N2uG0CUgXydL1mTaBEVmaPb1sYv13nN+fg7AH/3hd5jPZzx9+pQPPviA7333j3j69CnWWrqu5erqFUWe8Qu/8Cd49uw58/kMay3b7Zb5bIqSgmxICRaVLHjx/Bl5nqiB2+2Wsqx49erlODjShL5nNp3gnWVSlYlSGJLySgo4f/jgyCo4ONedn5+PVMGEoR+2w8ARGjnAIwfjoLtF+y7Gfei+tdZExkFadIgxVNQ5n4CPqFAB9jcv+Sf/4L+nLDLe/fqfJmqdircIqUOWpK1cDAifrszKW4Z+h9AtMjqGzibjrrpBaEXdNNjgMUXG0GxT6HJIg84QA03fI5HkUmEVRJEoZ5OipMjztAWXkrYbaLthZJGUICXeDWR6gihy8iJDRMn6ek3TNjRNS1FWCBkZfMMXHzxgMp2y2W5ouoZd3dP3qWT0nSUzSSA1qUqMlgSvOTlbJIuErKCYTIhCIWJkaAc26y0yS0PPNAhOHfvydEKW5QQxisMkDM6m3UTjAcPQWzbb1XEgnS7sSdB1erpkebpkOpsxKUu26w3XVzcMbYsQkSLPuHzxalSR5tyst/gQycsCXZRoLUGk4ZRUmslsxnyxYLvdg5ScP7jg42cf4bzFBcfV9SVVWRJcktYrpVkuF6w3azabNZPZjCwrWK83SZDW1+gQKfICSUryOYQ0l+UUqUj+0z4QXUtedgyuAT0lopHHGXdIMW5idImP3COi/qDj9UJ7Xz7zaapqbgVlUYw+3SJpE0aI4tB1v242JUevnCjGHUJMASL1ZoN1ET+4BGfGMS0nesRwTj/0BCogpBQeSAPaGEYXyci+aXB+5GLLxNZRQhKjxw0DvW0wAmIY3RndQPAWqTSdTdmR6b1IkXFSQJFlPDp/QPulkHB837GYJ+tWUMiYCvcBCg3Ws7q+4uOPP+Tyek073Nof/6DjjQu31prFfMG2vrln4pS6VX20Rf3www9ZLBZorY+49vJ0SZHnfOc73yHPc772ta/x8uVL6jp1QO+88w5XV1d861vfGqXIJYvF4gidTKdT8rZASc2f+Pqf4OOPPz5i2EVR0DQNZVnSNM3RJfB1mqG1lhACb731Fuv1OkEyI03wwCY5vJ6Dd7fWhr63xw/3UIyBY/d96LQPg6nDlungWXHA0g/mRocrtXdJEmtdh9YZq5tX/P3/4b/nv/u/n/Lg6VcRKiYTqnHVH06tMFpUep+gnbwouHr+Ed3OkpspB2Oosizp9/ujjYD3aQjprAeRinJVFuSZoLMh2aqaDO8cu+0u0fdGSqVUcrQ71ZjMMJ3kSAWFyTHasN3taLueEJJ46PLqivl8zpfffpsHDx/RNA39YAlR0PeW/b6DGDFGEUM+QgmJQ1AUBS54TpcnZFkBUrLebum6AecCHkmVF8cdD6M4Sck014gy0m92yLxgv29pW48dIrZ3dF3Lep04s3Vds16vj+vs0aNHibkiRPJjGa2BX714wW6zZnWzYjqdpfU2QmtlVdK2/SieqRjGQWdvLW3bkRcDSus01+h7qmpCvW/IdEYIkb7txwxJWCzmfPDBB1RVlfI6+z511SHhtVmWjXTA0aBJyIS9DgPGDegiXfi0tPR+wLVbVHaKcg1OpQi3VPvGUhuTCCQeLQR/SoBJvIuG3EaX/Sgo+8Fz//LyirpuYZwTJDqkRxCYmIgbWoj37VHDSFs9JMx450eo5BA7yOgjItHGILMCEPjB0w0dShqkVgRt8ELdf4GJJjIaR1XM5nNsiCg5QdBjvTtCNklIlz6OSGSz3fL+++/z8vKGwQXET1ryLhA8fvKE/qPbjvQwrTVGkxvNdrtNghTn7vl61HXNzfX1KFwoef78+bEzPTk54dWryyQNHT8crTVlWbLdbo/+2SYzBJ+YHl//+tf5xje+gRCCs7Mz6rphvV4fmSD7/Z7JZHIUySS+cWQ+n99hRqSCvjw9Z71eUxTF8fGrqjp208aYI4Pk0FUfuOpiFFQclJmHvz9QxA63OxT8u7dTSoBMQp7BNais4ObyBf/oH/wd/tv/6/+Nk/OnCJERRieylI2SjPON0eRFgV1bmjpdGJbLJfU+wQBSCNq2oyiSec2Bwy6VwvU9WgvOz5YsFnMqHdk1KeTW6MStVTp5SDvvU8fjkwghkhzzmGUonfjn682arutTAknwzOYnPHr6hLfffpv5YkFdNzRdh8kK2n7HZrNLIowYULoiINhs98f3aTKfHllJ19dXdINlMpszmVT0vcPGxFSRUjGppiyXF0QEdd1wvd5iffI63g+OfTPgvKRvHW3d0fbt0Wckebmnx3r77bd58uQJSHGk6i0WC/7ggw/44P33Cd5xcX5B1ww4H9jva8w4z1mtVkQhWK03ZJlGG0OV5XTDmt5aYhR4H/j442dkmcFow2Q6xQ8Wo/RxrR3cMLe73WjdCqv1ipPlkvV6zcnihMXJMjUEMuWKHjwwvB3QsiQ3hjIT9G1D32xQxYbSTNhJj2ecn8BxWCcObewfG13wNkQcfviH9d6x3e24fPWK7W6PcmknHBCE6JFAvSjBO9Rrf6vGhi7Pc2QnUmKWTGv4IN6TQlCWJcvlacrulJrtegtZIhQYBUJ6hiDvPfko0vwGpYhKEKRg8I5MCqqiGOPUxGj8RfIw8WFUxeYUZcHJyQnSZPz/aPuTJkuy9EwTe86g4x3s2uzu4R5zApmJAlBd6K5is8iWakqzipSmUHrFFX8A/xd33HDTpLC5oFBItjQLVZAsFIBEIoeYwwcb7qzjmbg4qmrmkRkZEeikpnikuZvZHfSqfuc77/cOWn+7kvTx8f2hEu+4vb+ZOMtZlkX3skGRuN/vp4JVVdVklRqtVYkJ4cPSu9vtovfykEyTJHrK0uu6jk8//XQyAvrggw8i9WrrUCJyWvf7PT/+8Y95+fIl1lpOTk44HKKx0ejTvV6vadt28j0Zh4/GmKmwj4tKURQTV/ZhENcNzIGHYeRjoypgWqSijaR4ezg54tzfKNojhVAnSRxg+RirpqTG+AO//vl/4H/4f17xb/63/ztkusK7EJPXzZAmKOKEvSxz9ncW6yINUyJp6ibS67Si3u45vbzEBjFdHGHg0WaZJATL3e0bzhdF/HxSjVSSxWJGkqbRc3ywEYDYqXng/OyUNM3oBvc8FzwuBLyN5+75i3e5fnZFkuiIKVuHD4Jj1bDdHmm6HiEis7jr4+MnSnE8Hnnx/B3mcuBaVxWr03MuiiJyzo/HGA6ssoHO1TNbLKJ6sY7DTmehqhtac8BKxaFqMSZw+2bN8VgBAp2lkyKxKArOz895+vRppPg1NX3fs1qt+A9/9Vcc9nuurq/J04S+66lcO1yvCSGYuEUX0RWubhoKneN8IC8iO+gwPOdmu6PvW0a+cNu2lHlBY+NCcnp6yvG4xwXHvCyw3g/wWsTxZ0NSz7jLS7SO12NvQUU4ItHRJ8P1HYUGERx1fY9MCpQ8xwpFkGn0hw8j4hrhEv//z8It4n+iqnx0FhWjLOFbi/fYlU/d+VDrjTFUw+Kb+mhZEUQUy3gfM0jDo2HgKGObzxe8//77JP0V6mvN6cX5A00wDLROpSjLgusnTyhPz5BScXtzH3dGiSJLNX1fIXU21YA4Xx1CK7QkKXJmqyWlVJSFJlEOtAI5SOpkZGiFEMMwlsslz58/5+TY4oL4Rkbltx8/CONuhi3iuIUemRZt203dJzD5L+92MTpreXpC2zTTz4+8aWCYskfopeu6CVI4HA6888473NzcUBQFWmm8i7BEWZbc3t7y5MkT1usNm82GDz74gJubG0IIvHz5Mg6qBgx7NptFk6Cbm6mLHiGMpmkeiulQYMdCbIxB6+jfPaowH3O3Hye7PIZRxsceYRT4bWjFh3jLyOGCwXqkctC3/Pxn/5b33v+Qn/wn/xKdzGOCi9TgTbw4sVR1TZImmL4CZ6jrjsBgUNS0ZFk2DVGNMWilCcERPNjeEZxHCUHfNhG20PEzy3RC13a0JuY9ju+17TpOz87I84Kq6WjrYTDkHcuTBe+++4LV6pTZfEaSJjRNS9t1tL3h9m7Dze0d+8MRH4aOw1j2+wOCmHc5K2bsDkda0/Hs2VMur6/Jspy2i7MO6xzOx99tm25wf0vouj3GxnT36tiy3RwxAazUHOqa27sNL796je0tF9dPWJ2fcXZ2Nu2szs/Pp2txTEP6+uuv4y5FKT7++GO0kvyHn/31tPiO9EGdpmitYuhEkmJdTI/fHyN0tD8cCUSKmAgeISKHXgiBGFhYxlic8yRpSl3HQGSpZEzNkWqar4yMFjMIb3prhnX8IZxjc39LsVSY5oBHk0mJqW5Q6hyfDpCFyHDDbwBI8fthi99LHRTw+1Q04q0vxIDQjAWVYVD4e5/80f+Pjn5M953xjmBCVGdKgZbQ9Bbj3vZmEVJSFAVXV1fY10vcK0GRF4/w9FhUY0Oas1wuUNaD1BgbA8eLPCPVgt7EAfZbw1MhYgiyFOSzkpVKCUKRpRItOlSiI+nF+2ieFOJzJjphdbLi/PycJGup2+9nMAX/iCAFrfUk8x59r785VCiKgvV6PcECVVUjCFO3Mp/P6ft+6ogPhx1Sxu57uVxOntyvX7/m3Xff5c2bNyyaGq2jWvHs7Iz7+3tubm54+vQZ1sbB4UgRm81mHAZnthHKGPnWm81mgkUeDxNHD4nHkEfEqSN9bby5x2I4SmHH9z3i149hFD10Rt8s5NNqHQRKaJSI2LM3PdlMU23u+X/9P/7vPHv/jzm9KIiBsgqCQGmN8CIKTrqeMtfstveYxmPaeFGXs5JmfcQ7h7GRXmSsATxSQZoptIrinuVijpcJtRUkaXSU0zpBC4HdHzHG4kOUjre9wdhA6AOHQ0fT1Dx9dsm77z3n6dNLdBJDiXe7mqbtqZuWm9s1+0NN3ztAkyQKD1gXk3myPKVpW0zf8+LFc05OTkjTqCQ8HmvCgNlba3Fe4IWNBp9BcDzWww6v4c3NDZvtkc26QqQJRkiOTUtVN1xenLOYL7m4esLpxcXkkT3uuu7u7uJMwPTc3t7y5eefI0Pg6dOnHI9H+i6yV47HGp2kjJFhfdehlB5UjIK+t/Su5e5uTWcM3bhLIqpixy7T9A4VHImK18tms8H5qOSbz+ckWYoZhuHpkIpTVRVKJ+RFERdv64g5hzEmy/YdRZGxWb/hclnEXMvjPRpNbvconWGCwjmBUBkMrI6H1vf7Hd/0GPkG9+OtI3zjK8Hjrnv8l+//3GqctShFmmakUtE0LTqJNhmJlkidYPwwBB1enxRiisaLob7EAOBH1DuBiLF0aUKRFwPkmdIvDFmSkWVJtGu2Ec6Qw7yBgaXiA6hEM1vMEaXEK0mqwDY7HCHuooRD+xiIIYUgSVNm8xmnq1PywrKvmoes3O84fgDGHXGieELiBdY0DUVZ4PtoZDMW8t1uN0ELWZYRfMwkHOXjd3d3b/l8XF1d8dlnn3F+fj4oJFPm8zm3t7es12t+8pOfoP+qwJqofPz888/puo4PPvhggkjG4eQYWXY4HLDWslqtYmrN0DGPP5dl2QQDjK8b4g5ADJS4sft+DJNorSehzTgoGoe1kwe4EG8V+vF3xo4c4g5GCBUjmRxIND4YQm/wwvP1F5/zH3/2V/wX/4sn6DQfsvsiHte2DQWB84sLZNjTHQdxgIvyciei2b6QEoKjLArYViip42eBwPT9UNgtxls6F1VjxnskirbtMNZOOPd8PidNc+qmZf3qhq6refr0kg8++IAnT89R2lM3B9q2peskbWu4vV/T9Y6iKKkbQ55HGEBLmM3nKCXo2hYtJc+ePeH09IwQIu/eODskd+tBoBJNueZFgfWCw/GIlNFsaLPZcH+35vWbO+7u9qwurzi9umSxOiUQh8yr5SlZOScZsjLHQISyLGNocAh0baQHrtdrhPc0WcZht2O7vifRKbe3tyAkbdcPcFFPDHrwHAYsv25arA8YaxGDG1wMQJjGgtjg6YcZS5amhOApijQWAB+/N+LX8RoKeGIST04RdwYBuj4aJkkp0UpSFimXpy9wzZZES+73LX21IaR3CJEhZQoyjco+MQwqo8rl+5aB6foGvjF4/B2oRxjZJOM3H9gjTNS8bz9++3txeH2yWpEXlkQlqGNFXpTkRUZRZBSpRCYpYRjGTvcBcQfdG4P3gaqqMYu4WE4GbkCWJKxWJ+Q+oJOMTKeY3kYabJ6w32+Yz8oYAD103T4+EQHoTM/u2FL1Pa5vCKbi+fU5J2VBKtTkayMGHYizbpoJGtNPTet3HT8oczJ4izVdlG73LcEZuiZekMkg1RzpdKMx0zgwXCweuuzxGNPZX716NXXWs9mMLMvY7WLi++Fw4Fe/+hUftC3WeH75y19OW6VPP/2UP/7jH9O2HZ9//vkUNzbi2aenp9yv73FDl+yci5as1kR/XyXJEkWS6Lhl7aMKaizaXddPRVpKOTAAwjQd9o8ed0wmGd/v2HkDE0b+uEtXQkS8y0UPg4AnyZLoGd5DEC0//6v/L//iz/4T5ufP8bqIHgzWoX1HoqMT4O7uHjH4MUCD1mC6iDdnOqHvLImQnJ+sSNRLAsNzOzjUPcEbdCIQOqE3DpHmqCAJeDwBpMC6yD7oOoN1nvv9llmhefbOJdfXK7quAiPZ7Xua1nPYH6mblhAEWVpgnWcxK6NcOy/pjWG9vsf0LScnS87OViwWM9IyJVEF3gcOx5YkdSiVUDUNSZqR5SUqTakOR25ub1E6YbZY4bwgSI0NgXc+eMGHH/2I1lhUltFbj3UeEslytUIIjbWe5TKmo0Q6YML6fs12e4/vO2Z5Rts0vH79mnlZcnp2zsuvX0Zowzq6tqNuu8FHJio6d1XFsW2x1g+d2GCh9AhqCIOmxAfocCgPwggKlSFkXDiP1REhIztBqCEbVUCeleTlHJ1mICRpkkxJTEki8aal3ljSZyv0csm+rrh6suTNmy1m9zkhK6n1CpNChkGHliA0XqiHxvt7lYFvVOpv/u6jAi1EQProqh0VkANlNoR4HggTU+Z3uQXGxiMMTWNAKijKOWdXT/EkZPmMfLcjSTNm85J5kSJ9j1MpNkQUHxEjxYQI0ZuoqslCoDo2jA33EN+NwLHIFZxkeCmQWrFMMqxRFHmB1orEJ5SJAGJsmg8SBpZJMI5qveb1y5fcbu5p6wP4npn8Jzw/P0ekEJB4EfnsLgiMh/XmwHqznqyGv8/xvQu3FIIsTbDoKLIYIsCstUgVHdui1PfBNW/kPK9OV3RtM2U+jiGqYxeslGaz2URmxEDTms/n1HU9bWudGyObiskUSgjB3/3d31HXzeQ/cnp6ymKx4M2bN9HdrW1Js3SSxBdFMQ1RgamYjikmIxQUBSJvDxcf4/qPE+LHojx23+PvjYV7/Lmxax+9FMJgS+q9e8vu01iLTj1vXn7Ob371N/zT80u8TwfJtyTPMsy2xfhodXu6OuG422BsR3OoyPICoSW9sSgpp6CD5XLO7a7Deaiqjt541KJEyhhkoXUZjeIfbaGtdXjn2e721E1LluX0TcPTJ895+uwpfd9xOBxpOsuhshyrNhbawcNbDEZLF6sLtNJsNluqqma5mHF6+hREIMsSZvNyUC+CH/xSQt2QpDmzxZwsKylmcxobh8t3d7conSF1RttFy4XrJ084v77m9PyUtrcInXCoanrrWCwXE3zVNA3z+Xwwt4r4+M2bG4I3FFnGs6dP2W42mC66LXZtR54VpCcpVd2yP0bbYY/AuA6dppGX70dV4LC4T8XtgUUxcpqjNW2MhBvvrwjVxdlD7KJH+M1PuKoa7rXRkVGpOJScZRlZcOzu77h8siJJNXleMM9rhG1pbE2uPJ6Yeh9kICgdO9Pw7dzh31lQp4478Du+zaNvD18/xKiFST3pB4bLIyz6mw82/O5I11NKk5cly9UpyByZZDiZkGYpeZ5SZjp63GuNHDI6467gAV8fVZtt203UwNFmVgrQUpBKome2BHKFTwVaCYzpCLYjuHSKI/PDAwYv0FLRVhWf/MMv+OKrLzF9TZYqPn7+DsL7GLYQxPCZx+fr246mrtiu7zHOYMwf2I87hBjWW9Wxo06SJEIlRTHdEGVZDuGuzcSzLYqC7WaDlIKTk5Op0FVVxXw+n5RsIwY1wgmjcrHrujhUsBYlo8/1bDajbVu2223kw3b9JGsXQvDJJ5+glOKf//N/zi9/9Uvu1+uJYjZi3xBZIdfX13z55ZfR8zjL8J6hYw8TtW+08hwhj/EiG7vnERcfTammqKnhd0cO+QNuHn/HuweL2BF6GaGi3rQ0leHvfvEf+fF/8s+hLDEONJLgFc46qnrPPIvMmK6L2Y9CRbvRtofl8oTt7k0MaXWW5XKBlHf0vaWzCU3vONQdgp4kUSS9IckhLwpCgDzv8L6lMS0xlDjis0WW8uzZC6TMqKuGrvN89dVrvn59j04zrp9cTWlG8/l8gqL2+z1tV5PlijSVuGDIs5TFco6U0HWW9e5A10Uh1PJkxeIkRwpFkkWKnBri61arU8r5AuejTP/k5ISrJ0/IyhlFniOV43a9QaqEJ9eXlPMF3imqqmY+n0e206CIXa/X7A97TNvw5PoKZxw33S3OOHb1nsP+QF3VLMolXb+PNyvR27ztO7BmWri/9zFKv8f/hoC3bsKBtZSx5vswPfb455sFzpqO477hpx89RzT34AwKT6YEz64v+Prmnq7bkfVbXJYSdIEXGhskwf92Efhur+zpB39vpy6GnxlZJCKIt5ua77YHfOtI05h6dXLS4ElI0mxqoLI8ZVGm2GZwDglDk8RolyyGmLeeNPjINBsahfE9x6ADol9720bx3MAag+i1HpvJWA98iGrmcTUYz5vpDLazCC/AekzbI3zMXpAjdhQ8WgR837K5fcPrr7/EuB7/exbRx8f3x7iFIEszQhWmjmKEBEYMePQGGYUxYyHSOiaDSCmnDMJRXu4Gz4uRxXF+fs7r16+nojjm9b2bJJjeTrj0xcUFdV1TVRGvvr6+5quvvppgEq01P//5z6nbWAjv7u4mz25geq3H43Gg8I03hZo65cemUuPX47buAX98sHQdf2c8B+P7G39n9DeJXZSFIB/5O8up6AcCzhm8cnz+xa95/eYr3vnRJcEHlNDYOjBPU2ZqhrAdOtMkcsbq9ITb+w23dxu6LhY0iItg13Us5vPIpUVQ9Z591cfJt3JkeY7zgrpuBp9rmM8WmN5zMEesjVi1IHCyPGG5PGN9v2e7veP+/pbXN7forGR1voy+2zrmVPY2ZkDe3txgnaUscooioyxLlsvFUJTGHYcDJF1vOL+4ZHmyQukUqTVZFpPrGT7b8/MzpErZ7o/MF3PKcs7J6pQkyzHO0TZHDrs9l0+e4q1je78mkNIbx+vXryetwGjZezweOV0swMN6vSZVUS5dHY6sb+8i5t859scKYy29tVRtS9W2USX3+9gXj4/w218PkO+wu1MD7BUdAgWQKI0UcmoIxl1g3/dopUmU5LhfUx2XPFnkCGF5/8VzjlXPzf0dJ2VGb2ts/YZSF3QqoVcZQiWxpH5Drff7CvdvsUy+Ubx/Fwvl7e/zULx52J1822M/Piae9WpFkOkwq4kCsUwr8Ba8xZsO7wwhJET188OAe9z1Nk2NdQ+DwHEXbW1gu9nHkJFhJ962LX3fPlJQG/7oow8e4NGB3TP+0TIBC955EBJvHMLFIi8H5WoIDkW0snB9h+1aetsNQ+rvPn4AHdBHKemA646c6BH2GD2sRyn62B3EKKCcrnvAtheLBaenp9NJPB73EwNjVEGOMWZfffUVp6enJDZufT766KMpIccYw2q1Yjab89lnn03hr+v1euKa911HVdcT13u8OMbXuNlshg/Ek2cFxtih8CZvdVHjh/Q4DPbh+nrouscdw4iBP54Sj5AJgDEW/cgH5XEnH7ssh/Cwvr3h00/+gacf/gQlc3CWYC3B9ZiuiakfEhCCqq5xIZDmOW3X0LYNi+UC6p40dRjTgJT01rGvel7fbVFqQZ44fICVTLGuw1XRK8YYR9t2hCAIfkhb15K8yBBK0ZqWr79+zeGwpyjnvPfRx6zOVszmZaTJORfZP29u6YcA4tmsZD4vmM1mqEGAEEJgs9my3x9pGkuS5CyWJ+gko+k6ZmlGOhTkzrRYayIn3ceh+GI+5+LyKqaJ7PdUdcNufyRLU46HA8eqxnvB/eaID2KapXzwwQeTE+RHH35Eezxye3OLt47joaKuGrbrbVzsXOB+s40ipN7E3WfT0hk7Dad+3yEGzHsqTQ/zPbRSeGvjjNCHKFt3nrzIUQPOm2bpW83CCJkkaYK1HRfLJX/zH/8j2U/fp5xrPvvsM87Orjk/P2e93ZLYmtS9wesSqUpQc6SQhDB08MNjv836+O7jH+M0GOc/Kl5Xj37/mwtG8A9slPFIs5RyNqNpLX3X4m1P3znwPX2wBFNj2hox+NmEiJIgZVRE265jFgJVdcDabng94z0q6DvL3e2a17d3VE1D1zY0bY0bwojj+QqDSZl/WHykikyRJAYtJEkBSpFlYlBphoFgEHdZQsgJKhr5+k3foL6pHPqW4/tDJT5QDWY8Y5EpBlOpx8O70SJVKTUV8WNVDZ4h3eSRvd1uOT09HfDGBVIKvv76a549e8ZisZg61izL2G639NaQZxHfHgtzlC7XhAAfffQRn332Gd57Pv74Y25ubqiqitPTM/70z/6MTz/9dApOGH3DxyIrpeTs9Iz9vpocApshG3DsiMfO+jFjBJiwaXgo7o8XrrEwjz83YupJomFgJIwY+Sjocc5FJz0vwVh+8Td/zX/6n/+XlHNFgiWRga4+kome+WLGdn2HUpL7zZrWeJRKmS8WNHVD27UIFTtcY25JtaDpoOkDdefZ7htSGTs3Yx3OyyFMOUOpnqbpkFIjRMDZ6FusEonxhv024tUnqxUf/tHHrC7OaPueqo4WqMfDMapkg4/BCmnOYrkiTcRQJ0RcHJqO7eZIU1vyYsbq7Iy8mIGU2LrFucCxiQ6IiBgdVtcd682O/bHGWMexqsnznM12T9P25OUMZy1V1ZLPZtzerTk2hqY1b+2CZrMZs9mMTz/5JEYOBMl2u+GrL7+mqxus8VgzMGN2h0GYZNkdK3rnmTJUwu8oPOHt9nrcVT8+xMDvNb1D6yjhlwNdLEtTJA8OjA+7tfj6x13t3XrD7KzkdHHC7d2aVZhx8fQJn3/5FYnMMc4S+p5EOIS7xLg2agJsZPRENOP7Sa2/eYxMme/+qYcj3ge//VPfpBVP/z78/3ifdF1L0/SYtqatjrR9R99oJBbhGrr2wYhsfPpvdvXWGZx76G7j9aDwPtB2hu1mT28tu92G/X6LD5FO64OjLIvBo2h4vGFxEBNsU1DOFyjh0dohdUKQYvjD4FMUUDpFJSleSHrnsN4j/9DKSYYXNm4pVqvV5PkwWlKOmLRSisViMSSp75GCqVCPHtlFUXB7ezsM/jKePXv2YHFIvFjfvHnz1odqXVTrjekj8/kcrROyLJsi0UIIfPrpp5yfn/PixQtubm/527/92wlzHmGas7OzibYIxM5kvRs+YPEWC2SEQb7ZHYzwznhRjDuR8RyNMNIo4Hk8sHx8MT9WZo6PI4btlhSeV198yasvPuMnf7JCBYvGkaWK09mSvos+0tE7o0R7aFpHmiQYbWi2B4LyrLfHKDJQMefSC0XvoDWepNB0veH+fkuaZLBakKYJY46kd35gS8QYtLxIkSrQm47F6oR3332OUIIvv/wsdqA+wfSG29tbDscjy8WC4I+UxYK+d/Rdh5SK5WJF1dbs90eshbPTS84uzumNi1xvYxFC0jtL2/SUs9kAa1RstjuOx4a66VivdyAkV1fXNE03KC1rOmNJixm7w4Gq7tgfW5K85OrqiufPn/Ps2TOqqmKz2XB3e0foDcfDEW8d1f4w+GwbRBB0bUy7b7qOw7HCuQc82//WJ/rbnegD4ezRDw5ipGmIrZPotT3AecFHSKTIc8oiBmOMfvNTAbKWuu356uWBP/6nP2Hz1S8JCVi9RsgUnRYEb2PafbXHHe+Q5XMSEc38EyGwvC3h/iHHDyncY0rMNKT/gc8ViJTNu7t7jlWLayvquonGXiIgg0EFM4jKHqT14z3tfbQzHuFPa81bC6kg5njOyjldZ7m7v2d/2Aw/Z5Ayiua6tp0UjsH7yA6D6V5fnKw460JcSOhQWTrGJRNzmyQehQkemeSUixPOLp/gvEGq77eAfv+OmwcC/ThUHNNusixjs9lMGPYYILter4df9hN5fuy4x5gzISKu+sknn5CmKaenp6zXG25ublmtTgbfY8DE4hbl8iUvXjxnv9/z5Zdfsd3Ggtv3/RRbBvCLX/wCM7j3bbdblFIsl0uklBOXXOuEvu/49LPPeKz+VKqgbTsgYrAx6SQG1MbXLacOYdy6jsV3HEQ+Lu6PXb9G7Dv4yNEdU3XGwh4XCjGpHPuq4q///V/yo49+xCyRONuS5ynQMysLyKMBkfX3HOqWrmuo9huUTGKgrE6ZzUrUOnpshGCwPnCsGhKpyJOCpnOE0EZVbN9jrBuwPcdjhg2CIWTXoJXg2bMnpGnKbr/nbrvFuMBh39M07SBcElStIclmNJ3l9Zs7tAqRGWMEUiiM8XgHp2cXkfZXSJCS/aFC6Zh7KaSgaUaefs79ekNV1ewONW3bkxczPv3kU/Isx4VA01mCUKjOsD9WNJ0lyWc8efqE9957f/Ky2WzWHPcHgnPstlu0lBz2u+iXTBR9NE3LsW44doZ9VVF33RRwMXbc4juELOF3fDcQnfmCDwg9WACHgZzmo0dMNCOLtLY0TSff8HGAuT8eUVLSdYbXt2uuzq9pux3HY807zy9Yzlakacr6zdeUszlvrKfrtqSzS0wYfXAUE8daPH5133383sI9QDBT7QgPXe9vd9zjT71dSoGBZi6RQdDWFTcvv+Z+vSURkQ7pfMC6HhEsGkPTHPF+zJSMC4QcsfgwLCDOxx0kIzwUny4vcy6uzjk7P2W93cQi60HpBKUFQsQ5WFy4xfAZxq+i9UCCTjQ+BIyziGAjJdUHnPdDeLOIrBdhmZ+sePbiPUgyjHuwmPiu4wd13FIpZsWMEAL39/dR5ZUkbDabqYDN53O89zHJYzaLQ8u+R7kolCgf+S6Mha/roqnPcrnkeKxxzvP06TNevXrFfD6PyTVfJljrePL8GV3X8ZvffDrk8M0Gdonn3Xff5fT0lL//+7/n/v6e6+trPvn0U3rTD1j4jL7vp/AGgLaJNEE3iIXm8zn39/eAoChSqiqurFKOwwdQUmNt9EmAB3+S6RIcrsqx637caX8T09aJQgzhBtF4SaCUoLfxwkilxDUtn/7iF9x89QUn7z0D6RFacXFxyWG3xjtL19SkUiKsIxUCV2q0mlG3MQA3SQV5qTg7P+N2fQQcxko6o9gee/quZ15otFKE+YzotaZxTmAsw7ZOMZsVKJHQHFsSlZAnCYeqYnfoeHVbsdvXuGGIPFJFZ41nPj+j66EJFq0CTR8QKkdJT9e3nCyXCBF7kra3ICKLIC1y1IAbxmGPp2lrirxAyj1dZ9Aqpzp2cYDUt3S9pTOeujVIlYJMOD275MXHH/HkxXOMc7y+fU2Z5xx2O26+fsXh/p6mqnDGcNxtwTu0EvRSYHG0wXEwln0XfcsfY8HiewhYApE3PlWPoeMMIUbaJYnGmj4WciPxIs4TkkQNYpzowqlVLOjCeXQmqA87THPg+nTOoes5X54RfEOKxjVHitM5zWGLTiQiLcn2LUv7Gtsv2BfvYeQC7cdy+TYGP/7th0IhD4cfiufALBHjeYsMjjg4fLwDDd94LAFBIgKoAIkHmgZf7Wg3r+lcj+l7EBIXPAGLUo6q2YN0IBwhxIG3RJDKBCdjA3YyX4CNzxUHvxLje9CBuq+QmSSflyyR1E1DWc6iCZvyJHlBkAl+gLTUQPAU+IkG6pzBGYsA+tbhrSR69EiUCHgMQjryIuXyyTPSxTl177nf7L7zbMMP5HGXRYGTHa9evaIsy4gpDnmOY2TZuGLkeT55WBd5gVIPApbRmW/sVLMs4/b2dsqjPB6PWGt577332G63fPLJJ5y5lvlsyWazmbIm27bl9vaW9957j/l8zs3NDZ9//jmLxYLNZsOrV6/48MMP2Q1BDK9evZqKpul7TlYryjKfcOVRWjx2NhFHzKZYNinVQEXshgI8eGwPW9cRMpHygS3y2MtkhFIeQyujYGg8HjjmA3dIBIKz7Na3/PXP/j3Pr/4VaTBorThWR5bLE9ZvXg88YIcbvFmUMRAymvoGlaXUXUWep2Rpj9Yy+nNbT930KCHRMqEzjs5YrPMcDkfquqdpOwSwOllSlAl5ngBhiNqSbPZ7NvsDX76+4816H4OAD8cJ8loul4jBCEoojXMN81nG+dkZxji8hHfeeU5R5NE8SWuEEpH+5wWeQNW2eN/BMMwqyxlSpMzmFU9lRl13iLoDHKZvBp5uS5aVZMWc5eqMF+9+yNP33iUtC14PnjbH45HbmxtevXzJfr2JU/0+8sSliA5uvbU0Xc+xaaiaPpYZIQbl67fT4d7CasPY9w1/eXSooZDEnV0gSaIOIghBojU60VOHPdEBQ7Th9c5xf3uL64/MM0Ff5DR9z2I2Z7+7I0nAX52TaInxkJUlWd1xqLeEfIdMW5SOxlfj+xpGD9Pf4R8TtDCdBYQUg0JzCE+YSN6Ped7fdgQQHhEeosGC91TVke12Q7DdQPdTBBFQCrwKccc4uRDGe0hpweXViv3pEt1ofvzjHzGfz+OzDLuC8f3f3N1xt92hixmn5Qn6ULFcnlDOMoQIaOV/ayYQm7PoLx6pjgP7jhD1GsMgMx4egpiGmbP5DCdTEgv2+7EBf5jJVN00bI+3nJ6eIoSYDKBG/41RULNcLh857IlIAysXkZK2WAwhBWKi2FlrJ3rgp59+yo9+9COSJOGXv/zl5G2StTlSST788EN+/etf8/r1a05OTnjy5AmHw4EvvvhiOoH7/Z7r62sWiwXGRpOiGPggp4Jyfn7OsaoQwiBFtHwcu+BvGkfFoaGbFp0R+2aYDj9WTY4DzPHnHhfqsbiPw0rgLe7vWLTjghYtVkWwIALGVPztf/wr/uyP3uH5acKmvWe2UmRaslguub+5wTnHyckJddejvcP0jtOTE45dQ9c0aF1AcCQqobNd7G+GoUzXO/BxbmCDRDHI/AVkacrV1RlX12c09SH6OBNVY/uq4eZuw3q9pao6DseaZvA1L4pi2om0XUeSppH+5AP9YLl7erIizfMhdUdN8uS2jQu1DT6qbQORhYBDyejfcXq6QqpqyDIMaB0IIcO5wGx5ynx5hkpzVqcXnF9cUOQ5b27v4vbaOb7+4kt26w2H/Z7jfk9vO/a7HYlKaaqG3lmObcehbqmbGBf2j8WCv3kIESEANbCpQoh2ulk2DJLHHenEQyYG3VpLkiZoJamOB968eYXC8s7lGce64n7rkYuck9MVzhm+/PIrlmUJSQZdyyzXbPZHmsOapKwJukHqAv/NFzeYUImh8P3jj2hHLEQUn8hH98L4/r79CAO84iMQIRRCKaz30ZphyGqM4rxIydQiYB2EIAlj9JkIJIng+bvX3H1+RnOr+fDj96Aph11PFMEFD13Xs98fObaGk9NLynxB0FvyomS2mIF0CN+/zeoMD/mWaiBVxIEow3U7hqv4eC6HU6qEJEsTTpZzguzJvaD9QysnhRD0XT+pIkMIE5WqbdspW2+0eAUmPneaaNq2YbVa4b1/yznw5ORk4HrrqUP9+uuvYxBwWU4S+iTR1HXNX//1Xw8qwGhGdXt7OxXNrut48uQJP/rRj7i7u+NnP/sZSZZOMns7JNGPzm8hQDp4VY/UvVH9WBQFx+NxoPA9cKLrukaKuM1TOnKPHwcHj0X9MTwyYt3jgvAQqPDwwY//NnbmWmu87QnGoKXEu55qf89f/eX/h+Kf/ojz8+g6dzxWuLaZhq77Q8Nhv8d4h6RgsZhxt72LiwAB03WoGIFC7PKIxlHekSYZXibsjw3hUKGEIkkTLi/Pef+DF8xnKcc9A29dsjvUrPcHDnXHoYqT/upY0fUxPzLNC6TSk0y7N5YkAZUkEUPve1pj0E07TePNIONezBf0xtB0MWzgeKwgCMpZQZ4VWBtAKNrOsFjA8mRJkmicsxyrhqyYUy5WLE7OSPMZVdXy+vUb1rstnsDd3R33t7es39xSH6uoBjZxZ7U77mjbHuMDVdtzqBqa3g6d8+9mPvy+Izz676M7arg24tdCion652yEiuq6RiSaGdH9TxB9TsbElbubNzhrcbbj1avXnMw+YL5c4URP0xs+fPcph839sDB4TFtRpAmLLNA0a3J3JPgaT2SDPbipPCDX/6OWqamlfvjzAMmMqP/btNq3z9A4RRAxBUeAUAqVZKTFDCUlwQekdWRpilYCQQ9BE2Lm3/QJKC1YrWZ0i5JOCk5WMxqn3npeKWMm6ny+ZLEypMUMkSQkeUlSlIg0jfM29yDRn5oy4twr0ToqObOUXgRkEENogoOhIxeDL7pCoJUkJvMYhNAI/sAmU4QoDuiNn2h9kWL20Fl+kz0xigQEYfLaXq1WU3r7ixcvOBwiBjsG9I5UvSzLpvSbq6srxL3AWUuxLDg7O+OTTz6ZJPL39/ckScKf//mfs1wu+dnPfjY5A5ohmWc2m5HnOS9fvhwk9I5k8OM+PT2d3oNSipOTk3hytH4UfKAm2X1kwkisiyY1j4U14+IzdtLj995ijDz6+/g804Uz/HEDnxfnSXWCJYDr2d3f8ubrjI+Wl8wuTtiv73FdOzFmjscKnWjKtGS7bairhpPlAi8DLimjV3GIoKbUAms9XS+QmcIGGeEAMYTXFgVFovng/Xf56MP30NJQLTS3t/fcb+5Zbyvq3rPZV+wODVVVc9gfY4LI4DtsbBwCdW2PlJr5fI5SCS4EsiynLGeUsxlSatquZ3/YU87mOO+ij3hZDgk4MYVEySicqaqGNEu5uDwjywp0kpKmkXrqPHTGo5KCprM0hz37fc1mu6Oqaza7Lbv9npPZHO8czhhEgPlsRjvYOYQAbWeomo6qMxj/P6brnG6ioZjFrktJGTnbKiClGorn4ExZ5Mg0QSmJVopER5gtRmQlbNb3HPY7lACpE47Hivv1mg/efcL1xQW+2bPZ7Hhyfsn93WtWZxcRWhCO81nKtj4Sjjdk2SlVKBEiHVgfsdsWgmHc9nZX/E22zLeKZ6Z3PBTo4f988NPudeq6xbd4lQzzgGmYKQQqSVmsTjnznkQntE1L33bMyxlFlhB8S5oUSKGneykK8hR1PQwsAwT8IPgaGqsBxsnSnOvrpxxDilcJQiS4ICnKgiRRFGUGJn2gBg/3fTx3sX5opSJ7yxkCDmv7yOzBE8IwbB6S3kUA03d0bYUTCmua73Ul/TBb1wGPHYvyWKRG2fsY/aWUmjBuIQRpFoUQajDM32w2nJ2d8dVXX8WiLMTEqx47x6KI8WV1XfMP//APnKstWmlub285Ho+kaTrJ3p8+fUqSJLx8+ZJf/OIXkzoT4GS14sW7L/jiiy/46quvJnViDHvIWZ2uOB6Pkz+zlHJIeHePxEaj1audfEu8H1ZPKd5SjsKDH/fjmLPxnD0W2oyc8LHLHs/dyOslQCKjgi9RGhECXXUkkYI8y2ibduhO5/RtS7PbRy9n56nriq7pIGjKIqcPFqcLijyLE/DhPTjAuoD10LQWlfSU8zlJmuP9uAAr2uZIogxaesoioe562r7nUFnqzmKsHzj1IXZFOoHBa1wlCUINGYdCwOCPHISgHiwMXAis79eUZbT3NdYMqTkd3RBwUeSRc22tJctzlquC3jr6vqc3cRBVzmYY60kLSdM59oc9aT7jWB9pm4bdZkPbRf5ylqQTqyNNEtL04fNp2o6q7jjUDXYEfqdi8tvd4Q89RphqLC5KxmSfLEmmpigpcsrFfLIl9Q5IFHe3N/zDL/6e87NTmroeDMQEb27v2BwOPLlacXK64s1nv0GYHryhbWoWJwtmecpmu+e8TLg93CIXTyFdAbEZifuw8EAvGff7Uwn4w0BF33peHlNuHxMtIzWEJMtZnp7ih7SYpm5o65ZlOWc5L/C2JctnMC46YtghymguFj1KPPf3a0KzGj6H4X4MgjTNOV2d8VSmdC7QtnbIW81IEo1S0clTDUwfRhiLh67de0/XNlT1EYljv9d0fTctYmL4nxzglL6tORx29C7Q/KFZJWOxGv02IlWsf7iRsmwqiCO2OWLXaZIym80mHPvZs2fc3t5GZeNgRnV5eTlR9sYC9uWXXwKxEFJGa9F35+/y6aef4r2f+LjRdOhu8gRp25bVasXTp0/Z7Lb89V//9VsJOHZQXMbFJRanMd6raZrJPGvke3/yyadonQz82oipjR3AeLF900RqPF/j3x9zvMcPePy3x19PSfIBEpkivUegSHVKqlLKrEAFSVPXnJYlRVnSVEcO2y2BmJlXljltEwgzzW7fDEMQzW53oMhztEoQIgaaAjgPbRftW0sUxgWsD/jgUEXGcrVAysDxuMOZhu2+ojfRYMcG6M3wWCF2LLPFkvligdbRT0JpTUAOXtYyUiCzjGT4+/16TTlcMzEjM3qDhyDRymK9p+t6go/b7eOxoihLjLXUbYtO4vO0bYdxsVPuTaA10ZypH+iYo/hKDIvz3d0dTV1HX22gOrb0XUs/pKxUdYfxQ0KMkPA2EvyPP4ba9AClgZSKNE3I0iwOaZUizwuUVpFKK2K3+vlnn/H1l1+w321JteJ0tWK/23NxtiJJEr5++YrlLCF7cs7Z2QXeduRpRlPXBCyr8oon5ydsPrvHNuAPG8LsWSyScU8/3vG/txa89Xa+pdv+waflsc5holdGUAEYAqQT0qKkRCB1ik5yEt0xKwqKIsVbDchHdMOxm5c4C8HHQpsmGSHRE7MHAlIolNLRj14JOmvwtkMEj+1bGOCXeZ5EpfdjuCQwLRLeO+qm5ng8wMCi6rqO8UXJAQAXIS4vbduyXd+zPVaDh/t3Hz8gusxjhk5FErE2ax1t106Fa8x4HNPSi6KI3ZPpWZ0sY0zVMMgcIYixWL18+XIS7Wy324fIrKGoZllO07b86tWvOD8/5/r6mru7Oz759BOyLMeaKENerU549713WSwW/O3f/h27/W56PuccT548mXzAN5tNNLVXMSxhNptNalCIdLT1/T1qMPwZ06AF0Lt+wK0fivEIlTz2lBi/N+Lg45/x50czrrGoT6nxQkf/cy9RIlp7Khljse53O1TyhMO+wduG0LeUsxzrQelA3bSkSuG1QwqPVNG5zlhHlmqSVGDrgA+CECS98wQR0EiauueY9+SlY1GknJyuODs74+QkQYue3aZFq2Sw9Q30TTuxHpI8J00TFss5WRG59DpN0UlCniUsZxnzImE+y5EyblebvuWwP3B+cc7p6pRj3TIrI4Z9OOzQacKsKGNSkffs9wfyokTrhO3+EG8AoVEqQSqwtqfpevb7imPV0VtP0/Z4L8nSlCIvePnqJfWxoqqOHKtjVJeGwPFwoK4NVd1x7Hoa7/ETUCD4feXpu4vXWPTDxHwTUqB1XLQlDHx1SZJnpFlGVmQRIpMSqTSmbvj6y6857g+IENis17x4/pzmcOBwOJDoBV3TctgduEslJ5mmr2ouL5/z6uXXlGXOdrsnzTJms5S8qWmrN6T2fciKmKUo9ADnPPCU47v/Ie/17fcdpoUvQkVegBdDBuO3QS0hYtojYXDsU3WSUBQlQWpUktHpDiETlosFizyhqyGZFrqHc53oBK2S+J4CdJ0hDAIc722cVQ0bjSDH+yVaAksRxWDeBryVlEqCd5ExEsIU8CvjZhKCw9oWazrwFtMl2L6HwZPdj1VeeMBTV3vub15xt9n94aPL4gsTOGcwfUeapcg0oW7rqUBnWTZR6ZRSE5NDSTFElGVTiPCYPtJ13RQzNrIt5vM5bRsl5++88w5lWaLvFG0ToYj1ej0FHhRFwW4fvU7+6I//CCkln3/++TT8HIeNZ2dnE5wRzf5Hn4LY8Z6enk4Cnvl8ThhuDBg53NHmMQ4jDQIflYXD9TbCIY+L8vj3MS4NHiASeMC2H3fa4wWcKknwMdfQK4lQIJWncy3Z8ikv32y4miuWZcL1O2e07ZHb2zuE0JycLKm2G6BHJwFjDbP5CbNesexhsch4vanwaIJIMK6lKFVMo6naiK8D6mpF5yy393cIX+KNxXmJkBk6CWgZ+UvCe7RSlLOSoiyYl9E3W0g1DWquL045W86YzTOKWUGa5TgCh+MBlWp651gf9izygsQ4tts1bddysjyBAHVVYYxDqAwfJH0fo8z6vgeZ8vrmJUEomqEzz/MZTW2R3hE6w/FQI9KMJMs47g8c93u6psH2PdaaaK95MDSVZd/0VNZjBi6zCPFmHOaI0/HDOs/HneT48z7CR96Bl3HQmOhY2KTABI/1jlIpkAofBEoofGdJEknfNjhnosrV9Ji2pTloTGt4/foO/eSCJCv4+3/4NctZie0t5cUFTd8jgNMysO5uCM0aly4RyQInNJI+DsmEZDIR/47j2zxOokOLH0bjcSYey9VDc/87i7cQw288DEmFiDYAs1mJ1AlJmtMmGUpVFLOMLNP0tSP4jmD7gZYXz/N4747w36Fq0X4GxJ1MnDtYkAEXfPSjaTu6tqFt2pjMHgKdEEjTc9htcFfnODVATCLWCC08qQooCULE9+6NwfYGBnjV4RFy2JHjqI977t684na9nvxZvuv4AUEKIFKNJEExMCRCoMhzuqYlTbKYKt7GDrxpIsheFAUy0RO0Utd1TDQeDKXGoaYxhtksnkhjDJeXl9Pw8Te/+Q1PkholIr787NkzQojZknVTs1guubi44M2bN7x582ZaEJIk4fz8nKurK87Pz/l3/+7fTQvHGFf2wQfvIqViv9+zXq8nn3DvPYvFgrZtJw+Rkd5oTP8QoBAeItAed9OjTesIkzymC35zYDk61D3+XmR8PLBV4oA1J00zbu/WPCvOuJgvCEiSNEMIx/N3nvP6zS3WGmZlSWccRSE5dp5Ua7SELNGURYrWAmMGOqKIWL1zUZDbG0PXddR1y939mtc3dxTpFZmCJCvYVXucDxHDlpHC5pEEESjLHJ1oVCLRaUaiE5arFWeXF8zzlMUspyjSKB3f7XAhUM4KcI7jbkehE6qmxThHmuYY66g2G+o6CrNUEgv2bn9AJQl5WWIORw6HI/PFCYlKONQVTbPHO3DG0zUddVUR6pbOGA6bHbv1Bnygbzq8jZL+1hmqvotbZPGg7ntct35fCfuuQd037yfvI4PECYFW+UQng4dFHZjgoxGmlMMOUKsYu3Z+esrm7g7nPU3TRL+SeYZ6/g4vXjyjvi8Irqdte3a7PU3fsVid01qLtAbTbJGzBlT/6A2O2Pb/SEx7ghQjPBDNysJE1XvrlPwWfi55nIgppSRRiixRGBeTM5XwCO/wzkGQeG8xfYyWe8xiDAT2hyP73R5nDP/hr/+Gy+VHxPssTGwPJSSm76m3Gw67LV3bUld1DK1wHmctWw3vXaa8/+6LCLk8Yo+N7JnJYM57XIjRgbFWBFR4RCGUCojGb11nfosf/m3HD/DjBuMdrY3Bsz44XOfI04wsSUnSdPLhHgvcGFW2rSvyLJ28mauqmjDw0XfknXfeYb1eUxQF77//PiGESQZ/cXFB0Rc44/iLv/gL3rx5w69+9atoDbpY0nYdn3322cQMaduWq6srzs7OSNOUly9f8rd/+7eTF8oo+nn//ffRKuWTTz6Z2DBjDNpjbvrFxQXH43HycB5d/iK08Wgy/Q145HEhHmGRh8L8MDd4zP+ON+XoNhjIizwWxhDdxYyxvHlzy+40pz0tOVlk1F2HFtEPJgp6HH0bdxY6KZB9hzU9pydLpEq4PD8l/fwWZ0PM3hMgtUKnCfiYztH1lqbt6YynamJXa0LPfl9TNT2dcQQRFw1tBckgMlBao5KoJaubBqUd6eFI+MpRJIqnl2esTuZDJyvIk4TL03Nu725RBLxz9A7yvKTrWo5VhZQR723ant4Y9odb2i4m0FxcKnpbx+tsu+NwqOg6S5bmVFWLEJI0ySiygqbp2N7ex+7HxO6rb/vhc7bc73fsmxYzbNPjhzTd+b+Xzhy78R9QuB8eNl47MkI5I24qh/SbJIvBIz549rsY/JDlGcFbpB5sky+vkEpH6beHm5s7urogkb8h1QmJ79lvbrk4O6HrOrIsxfQdi1nJ3WHH/etPODt5hk5WoNLoTvkHm0F+k2Iopq6X3yrU3yjeA/tmPFMyBESISfZdfSRRKdZYTFfTyYAOCc4avJME//Y8IiA4VhW7w4HcOb746iXiyTkDvB1ZJUN33hyP3L3+MjLQuo6+6/DWIQNY59AK1h89eUT7jclZ41tK0iRaDCdRWTzL02FYP0BGgsEBNKo20yzjZHWGF8n3tgf+AcPJSGVTiZ62/omIRUYEJkfAkU0xOuRFJWKkcI2KyRFTHj1N0jTll7/8JR9//PGkohz9s621kTKYRivFv/zLv0RrzcnJCcfjETOE447PtVpFTDbLMl6+fPmWHD+EwMXFBWVZ0vc9n3zyCaa3SKkm+uAojb+5uaEePphxURitZyH6eY84/ThcfIzdj+6GI249ctwfF/ZxVZ4K9nDROu9QMtLFsixBSoFzFtMbDgfHSZlhnOdQt5SFoMwFh80t3kQmRpFnfPX6NTZAnslhzmPJsxy9WnBxuqQsNH1vcN6TaDH4gIPUGq0is0GoBB8kx7rnzX2MK+ucBJ3RVcdIudMpWgdyGYd3UqkYiLBdc3u/RSrNi3dfcHm+IpUC5wJCapw1GNNzslpEgyfvmeUlfW+RKgpT9BAVVs6izUI9dIx125IMVq/HuiFNs8hAaVqscQNFzGKtpyjmrO/fUFV13PEdjvRdjzMuctiNp+8t+0PFvn0o2nLY0seP6tFQabwfHheF4Xe+DS74rV8SD4uAgIlCFsbHGv490Zokj922FIK6afDOobXG9AZn45b7WNUUZUnfNrS9QaExNrKEfv2bz/noxSVFOadte85OV8znC169fk1azLg4Kbl9eUO3e0VSXGF9fD7C4xf8+5PgHx+/RRdkhFoGJcHQdRIimwf5No/7oXC/3e1HPNmDt/RNxWG7RonoI9J1Hb5vMbXENgdSLH6YFU1/BmOnMPpzi2islhI/41jAAzKA6Vrub97w8ovP404YgRgof85akiTWrxDeZoiNw8mT1SkfffxHSAHzMkcGz2y+QCqNUGqC3IQAqTTlfMHVk6fki1P67ymd/AFhwQJtA8LE0FKtNYHYcSZKs1wsqOp6KliPoYVEJxMsMg4fR670SBEcMyThQS5vjOHFixcxTeVzB0MXL2X0PRk7491uR5qmvPfeezx//pwvvviCf/iHf5hYJCEETk5OKMuSxWLBZ599RlVVkbwvNd5bnj17xnw+Z7/f88Xnn6PHWDIhODs7m0RFWZZxOBwmp7GRfzvCJeN7eiyDf5zsA0yLyFjkx8INPCrkgizVQBjcyQJt23OxuuBf/Iv/jMsi4LsNQiXc3W/IteTi4oLNZsd6twepqPZHpC44Oz2ls57toaIoF7z7/AnPrs857F/FYYqIhjjWelwXkEpzqBzbzT3H/ZKurfDB8uF7z/EOtoeKY93inEQojdIWPPTG0hxbOhO4udnw6naNTgs6+5L1puJkXnA41Oz2FUWeM5/lJFnJQuconaCTDJVmrDdb1ptNpAAWBT5E5eUo5imVJiDojUOnkrppEVJiew9BkiYpddWy2ewpi571/Zqm6TgeD9R1Rd8b6qbDWMf+UNG0HbvjEUdAqMedtcCJuO0eK9djJsHj7tAN7dbv77YfKnaAQer+9nxEaU0+MG4eBteR+7vb7ZBDlF+iE5y3CCU4HA88ub6mro6kaTl450e/FmPh5esb3rk+I9Gaw+GI95b5vIzGR+2BuWjYvvqEs/OPUdkMG9TAeoghAT9oB/EWnQ9G5WT8ZizikV07xpg9hhnePldveaWEELnQrqetj+zXd0NxZvD1iYNB39VwthpM7GI7HeLJJgg1LB7RYK2dOVJACDWFaMfbIQzOmAJQBBEbJyUEQiVIJTG9efu9joVbKVanpxTLM7IspcxTuqZCBodQERZ5KNwxd3a+POHyyVNmvcO4P3DHPZ/N+Of/5J/ylz//S9IQk8GllPgQzfa9kDx79oy7u7u3sF2lFFVdRVK6jJFlz58/n6h/j72xxwFn0zQsFgsWiwVff/012+2Wf7NqkSJevGdnZzx79ozdbsd2tyXLc3784x9zf3/Pv/23/3Yq1qP16/vvvz8tDF9++eUEg2itOD+/5OnTp7x69YrPP/88Zgl6j5AyGl8tFhwOh6k4V1U1DUYf/3mMcY9/HxexbwpuHkvhx/M0DjEhdutpIklShR+GoGrIH3z27B3eeec5ZvcKh6RuOoRpuHzniq5vscYihcQ6x3y+IEk01fEQ8yWR3L55xfLiCR998B6ffX6LaS1SCaSW9I2JTBMTO36tJMeqjSKW3nG7OWBNi/eWquloW0uezWLIgelo2moI0hXsdi3OaXCazbZhv2/JEsXZqmS7q0gTxazMef89y+W5ZbmYIVSKsNHytShmA3UvCnO6LoYn6CRhtjyJykbrsN7hfOR+7A8HFAnHQ8Xx2NB3hqZeU1U11bHmcNzTtDVJmmG8Y3us2Oz3UzI7Kg7EYoclSITCCkEfIiNp3OxLMXpuPJKky8hG+L5FbqAAT+pi69wgu/aUsxlaq6lbVErRD4lN43WdpXl8zSGmvXd9T16UBMQwA1M0teGQtKgQOBwrTt+5RmHw1iClYHWyAtezUD3rZoPrKoKOQ8lhrjdAJv+4wj38y0Tqi98fUuv9eDa/67EfhpNKCPCOvq04bO9pq4qAxLgoiQ/eIoMl13LQXgxGXiJ+5QdISkrFxfVTlstTIHbJCBd90BGkOiGfnTA/vQKga+NwMk0TEqkJof8dr3oo3APiIPOCPIu0QtPHOYoxjkQ7tFLTdSNVhBuTrEBjsf0fmFVSliX/zb/+b/jFJ3/DcbfGeksQjkRIdKJZLpfc3t4CTJBItGhdUxQ53kWxTuwKNyyXy0Hpd5xiyPI8px7Sao7H4xQxNZrIL5cn/OnTP2W/3/P69eto0DKbgRD8/Oc/n4aKXdcxm8346U9/inOOzXrNq9evMcbEAuzcxONeLk74+c9/PtEFw+BwuFqtCCFwe3v7FiwyWrSOi9J4YY0wSgiR4z0OFUep+2NbV3jYVkeZc6QbISJtKUkSdCoRwg380GgglaUzXr58xT/84pc8Oc3QCJrOsExTbm/vKFKNVAIEzBcLdrsDaYjCIes8WmdcnJ2ii4wn15csFzOq9mEBJQT6yg54Olgb8Kmg6x3395GlkyiJcx3HwxHTe5RMybPo8+KH4gaavvd4p9AiekJ3bcPhcETphKa9wduessw41A0ff/geJ4sZWZawWM4iY0nKyGxxcS6hdczS9GEIjc0lordUTRPhmd5QHStc51nfbxBIuj76eNvOYHqDD3GXhHMcqorNbkfVdpPvBcIPuYACBYP5lgIf6BgL9wOsNSrnpJQ4QRQX8bAwf/PGfnyM2/Nxt5WmUUcgVZRNj92oUoo0Sbm7j54qamgIjI3MLetiPup+f+Dy/Iz2eCCVEik1nXEcq5ZZpmnbjt1+R5EInBI02y15WbIoczZrC6ai3t+Tz98ZcFbxgDF/T7z7m0V7osnGicbUP08Y93c+8GPYhMn2tmsa9rsdXR3nH4648xPBowWYvsf5SJ4YH0cgmM8XLJcniDTlf/Kf/0tEXfLZiDtPyzKU5YyT0wsqE20IdtstBCjzgrIoMN2BJM2mnx/JBNH6OTZ4bdfS9x0iOPq2Rg306QE8isCRkEgRhVdJkpLLlKT4Aw8nbW/4J+9/yMV8yb6tETZS1UxvOVku2WzX5HkOBExvOD1bsd9tSVLNaGp+fn7O3d3dFPZrjOH6+nqCHkII/PSnP+U3v/nN5IcyepbM5nOapuHV/tXUrVtr6doOnaQ462mbDikEF2cX/PgnP+GLL77g9uZN9CoR0YM3SRKur65YrVb8/O//npdfv3zEwxRcXl8wK2dstlsO+wPJIHu31kyUH6XiB5XoQQaPR0kV3QLFgE0mKYFoF9sPnZKACSuPE2VJplP8gFdKHVWGaI0LHukirid8IE0TtPCYtuHXv/kN4f0XrArFLClomz3ZTIPUZLOcztckClbnGYdjFRM4bI/Fo7xnliguFwVXZzNu1zsEktP5Ofv+HhEMrfUD9ihwxvPq5S0EqJqW1ckCLTxd67DWczzUFGmOwCO8AQzWOwI2xjkpRd8bur6nnBV0veXm9oD3lrLIMGQcW1gt5lxenDOf1VxenFKUOZ6ENA0Y4+hNhDd0OouS9s6w2e7wAZqmjYHRdUffWrrO0HU967sNwYPpLV3X4wWEIDnsK7bbPW3dQCBqE2TcKKuheEoEauisBRqEwwsZOyqlSHUSd1NDXYnEroDSEKzDivDAI45X11CDIiVMAXmSkKXRbVHrWLzVAIUoIdAii/MGqdjd3tBWB1IlyWc51fFIolTcbXjomw4RAlrHpCULZErTOc/2UKNVINGBxUzz/vNnnF6c0dRx52i8QvsO1dxBf8BlOR6NDhaBxwfxOweJ37W7CAJ8AIFFhtj1WqEwDF72Y2F/VGDfPsaOPJb+IAQyzXAiwZLgVFTniqFXji6HPgYWhLiQxpxWiUJwslxgL845fKb58Z/8hP3Lns8AIaNXDAiQUeQzX56xsvHztT6+3lk5I88z0j5DpCVu8DGfkupF3K8552jbOhIhg8dbQ6ajjUCcCcoJn9dCUeZF9H0yFie+X3bZD+JxKy2ZzWeYV4ZA7FJ0qthud+RlhjU9WZ6TL3M2mzXOuRivJCXXFxfc399PWJaUkidPnvDq1Su01mgdKYM/+9nPKIpies6f/OQnkR++Sejant1uN8EPUVou6dpuCnUYRTz/7i//HSEEjOmnDvn8/HwKWfj7v/97rI04mFZyIPZHPvp2uyWEQJJqvB1dAOMWaOzaRxw6xnqNBlJRLBQ77YC1nn6Qv49T9Ak6cXFrZqShtW1kEehIqUulxPU93vd4axACZllCkaSoQd15bC0XZytaW6GQSJlQ5AVpniFkSlN3FCoOY16/vqWYLWnbnsVywW6zRqiUP/rwBb/4JJ5/hebp5TU3fY9zLU4Egvd0bUc5K+k6x/EYg58XRYGUCd51WGPp+468SMiyBCcCou1JUglJNlEmkyRalN5vdtRN3Ko3pqYxr+iNp24crYHTRUFVd8znBZdX5xRZgk4k9TF2OUopbm/v2O32Q4hzGjnaImZBru+3tG3HZrPFu0DfG3bbHVmaY5znWLccjxV905MmKT5E5ShCkOr80U5qsFwdqF2qldRuiOhLUrI0HUJ84/Xsw2CU7x3CB6qu/d2J3SNWDqQ6Kve0VtEZUYAashGLLCpOtU6xxrC5vQFn6aynKFJ0ouNzSYEzljJT7HZ7zk9PMV1DZ3qyLAUvBm/yHuMK0iyl6zuWJydoHbHwcrGCwxZXrylEDyIO8+Lr/cdTAiM8EVAhMrcDioDEBhH1DwJi7mT8+d+xNgzPHIafjcO8JCsoF6ckWYZWiq7t0VJFeqACnRW4aSAaz7USkiLLyfOMSkpOTpaYzWF4i36kBUWzr0SjkiFWLHiSPI/1oMjRWYZQAVQyCXYef7BioMgGb6PRm5LD+YzyezGcz3EHIoUg0YqyzCPHW/2Bo8uMs/y3/7f/C5++/Aq0oms6FvOCrmoYval1lsUbaOBQjxFMSkq++uqryexp5KN+8cUXE33Qe8/19TU3g1fyyckJq9WKly9fstvtuFxuEEJNsuURhjke90gZk20AdrsdL1++fCSAicPF0TDqzZs3E9yhleb84mKSum82m3jyBvy5LEuSMrodjgEIj8OAIxySTGKeUfYfKXmWvjdTkVYqDhqlIBbt4GPhNpaQeHwKUgcQHmc65AA9QAyTjVh4LBpponEEFuennKgZ/d3ndJ3hsLMsXORsV9bQNi277ZayLDk9XfHm5g6tJUWR0xnPs2dXPLk+o+kDszLjZD4jV/Dq7g27Y0UIkTXknePm5obrJ+ekqUKGiAM7F7Aq7ihKmaHTDOU9SeJJEo3pPH3fEVCUZcbt3T1tb+idRzgo8oy8KLnfbPn61RvSRPFHH77g3efPcCEgdYLpG2ZlBsFTFJ7NIUIuXWcQCKyt8T7Khutjy5vXN0ghMZ1Bp5GVUrctvfXUVYc1nuADp8tTgpC4EDnFQgiEiok3IqonhqIcYaogBd3hiJaKTCeRAqs0WkU1bQge4xx28OdBCKquxQ4+Nw9dZSyJWgpSrUm1Js/S6TOWw6KhtY6Od1qzvrvn/u4+GlIFh+kjOaBt+pFdNtFgu74nTRIIjqqqWMzLeI0Rc0jfffEu9WHD3c0NQmoQMcBB46l2a05chwoWL/Twav9gvMDpeCw0+0GHiAEMRVlwdnaOswuUSthtdnFnoiR5pkhT+bDwPDqcszgbNRyb7Yaqihaq04CUOFxM0ywarM3soIyOjVk50JmD1eT5w3wrPkj8jxx8mlZaDguvijBx30ZlLNFj3g87iCAFKIFKFamQePUH7riPVcX/8f/8f+IYGqq+I0kT6ip2exDIsmLqbkeGxCjI2QwMgVHa7b2f8PCxEF5fX08CmDEB/je/+c3EzBAimo6fnZ3R9z1ffvkl3ntmsxld108+JaO4ZvRRKYrob3x/f48ZhCUhxLiwJI2r23a7fRg4SkmeptOiU1XVJI6JCc6xI4vS/pgyXhTFtFCMeLa1cUrNsFUbt9TORKxfJwqwLLTkvSdPKPOUqut5s91Rj1tv68jThDRJCC4WnLg70DRdQ2ct7/3Rx3xW3bPfvWF+viSRmjxJafMUpT0LM0dIjRm6uLaJ8ECeJejW8J/9+R/xP/zV37M6mbPfbTk9O0NkGvvVVxyP7RCO0SCkHxYwjzOxw1EqWt5a56PPSTnHEZjbqJY9Hg90VrE6v2S733Oo6ih11pLVYkkiFfv9kf3+QG89SsXkkNc3tzx9cs356ZI0UZytluRpgrWC3fFI39uYiONDtHsluhwedgdw0JkeKSTb+y3HKtrwSiSnixOyJB8gHI11MfbKOT/cRG4q3ILIFPEhWvo656jbLg6u8pwiy0mVQkk1zimxNnZZqdZkSSzGx6bGOhul62NxIBZuLQXzsqDIhgZHqQjdJEns6Idr8M3r19RVFelqQg5agxwph9izsS8NnsN+z/XlOcbYOLh1ASMCxgSci7YHT5485esvvsA5w+n5JcZZSi1oTEVo9ySZwcrsdxa/f6wvyVj+fRgzJz2jB8nvOx73+2Md0DrOtoRYAhJrFSJAliWkiUIIS/jGY48sL2MMPgQOhwN9/5hu+IAEJGlCVuTMfRxyykQTfGA2K0nSFN8rZvO36cGT34mUMfTZQNc21N5j+g7hLOfzJU4lyCTCJl4IkJCkmiLkEUL9g2dOhkATLIemjhdWluNE3BYW5ZKmqyYIIUkSFosFdV3TDX7K19fXk5vfWIzLspzglJcvX/Inf/In1HXNV199NS0AjxPW8zyn23XsdjuAwaf5SJJEoU/f95PAJtqHRhhnDE8YBULj94/HI027nih7QohJ1bnZbDgej8M0OXp4jwPV0TArSswfwl4f87LHyCal4ofkrIGBVhQvQM88V/yrH/+E/+qPf8p1XnJ73PPff/kp/9e//Y/UHjKdTNt1QezU8QEtFdYYPvn0U/7JRy8QaU5WLkBGn4miyAnbDU+uLiMjRkRZr3OGXBdIrbHek6eSWa54crFAK9jtY3an0nHAMuL7IcQUD2P6YRufR1l88GgJxlg6Y1kuClLToYShyFK8daRpQd8b7reRTpnkCYuTOdZYbNvjjRsm7GAcvLzdcb/Zs9kdeXJ9yWpe4lzgdLmk7XbUbTPwnQVmkCX3vaHvLV3TghlT0w31/sjZ8oTzs8vIYRea4GKhRqr4GM7RWzvI/C3W2xiKLaA3BuMsiVCE2SIyW7wnlYpZnpPqBD0U2+AcRioyAkJJ+tF4TUh2h330pxjKSSIEeaIps5TFrCRRMg4ZQ0AM510Ppmd937NeR85yDJGQeBsx41QlmGBgaIiUlHEoZkyEYAYmktQZbW9xXvDFZ19Sfvwuy8WCN29u2G83ZEUBrieXhm57g16+hwg5QaTDFv8fV6xhKLaPMfIQxSejWhF+t6XrNx8DInSn1NhAaYJMEEKh0pzgAjrJ0Emk8LmBwSkGOqMQDHmrYXodQj4MF/0jTrZWiiLPaHpDCBpr4tyB4AjOIIIjz8qpjoVhljGSCLq2jalKxwNd1+KtZVkWPL+4wmduuH4jci+FjJ7c3uKNxXTfz8jsB4QFhymVY5QKz/ISax2Hw4E0jxdJMmDFI+85SRLmszlVVU3MCmsty+VyKqK3t7copfj1r389ScxHGfjz58+5vLxEfCXY73aTerFt22FyH9WNI1wxFuzj8ThAJUz0wLFj7rqOu7u7OMXXcYs6CnP2+z339/dRdagiBjnGso2Kz7qOobXOedJUTxL7ka41MgrSREVJcwgoqeKgUcWuPsXz02fX/Os/+yl/khaUTctZIgjvvsPB1fzlrz6j79UUchoGebQ1URAQnOX29Rv+5m/+jlUWgdpj21LmisPxgDE9TV1TpClSp9zc3lHms8g22e8p53N65ykSyTtPzqJft3NsdntWq2UMzOiaYeFNUIlAysFvPIRo1eolvfW0vcH7QJKmcWclKso8ZXWywIqSV3frYZeSgpbcr3do5zmbzcnygr094Bw4HL0F4wLmbsfx2HJ5ugQv6RuLkgKhBW3X4WzcVXkP+/0RAG89WI/tLc2x5r13XvCTH/2Yk2IRTfcHP3UfAr2x9MbSdj1N29IbixcREnR4jLUYoeicxfk4j2iyOAMp84IiycjSNH6u3uOFRSEQSiG1woZo5ZClKUoI1oc9LjhEiCZIRZqQaY03hqaNz51JiR6DPobP/dWrV+y2W6SINLUwxF6ZvifPMryzeIYhvs4RQlJXNWdnq1gQEPTWkSeKV69vuPjjaHG8nM14/u573Lx6TSc8q3nOzdev8avXLJ5UiHSGU9nAuHC/FzD5Tqn/xPob1MWMopjvVXimBxmpdnmeU5QlViiESMgHC+RZWZBnCue6SDh49LsQYwizLJ3g0+NAvYv3bJi0QEIIcD2uj6pu2zZY09O4CAFnWqDUPHbbgYHa+2CHZXrDl59/wSeffcLxeMQ7y4cvnvPnP/5JhFJH/5cQAzKwlvs3r7k/7Dg2DfzT/+l3npYfNpwUgkVRslyuSJOEum7RKeRlQdNU06K62WwmbvJ8PkcrRXVsp6Sc8/Nzuq6birn3nrIsqQcBj/eeZ8+eTYyTn//855ynLUpGrnfbxuCACIGscQNbZMTXRzgmQhfx6zFVZvQMH3cHWZZxcXHBcrnkV7/61dSdQ5SuvvfiXTaDV8a43RpjzqRUaJ1MvuNKqSltJ03TeFMNr8PDBLdYa1llGf/FBx/y7ixjkQTabhd9VPYVf1QU7C+u+ezQ0bYNWkYzfW8dfR/fXyEzrPN8/slnyOcXaGfIlaQyHWmmyPMM03f0fYdrOtqmIctKurYheMvxuMN0PacnJZ11vF4fKcuC7aGmbhvyoqBtbUz+EYKyKEFYlIpm+1onCBT4aCA0NVAMw5Y8Z7kIvFrXCCFJU03bNTgTF7XVYs4ym5HKBG8cxtV0JjICBND2AVxHlrS8fHnD+m7NfFZQzCLnuesiLOcd1HUbd2bO4YzluD3yJz/6Y/5X/+p/ybtXzyhUikaA8AgNzscYvqbtqZuWQxVFOJ2xVE1L3bU0XUvdd6TWRM0CgjLPEUA+DCezNEOJmIPoECRIZKJBxrBfpRRZmpKnKfr2DfebNcK7iG8rTaIVIsROWQ9Zk2mSkAzY9uFw5NNPYyi2HmisUkiSVNM0NcVgh9A23eQPnWhN3dSs/AI97CJt12F9oGlamrrl+nSOswbtA++9+4Ivvv6SRHjmmSLYBmlbVCawEwHy4fiu7vj3HXH+N3TYk1zxhz2A1pqiyJnP5xgpATUFM6RFNJoyZmBzTF30g7NnFP5Ec7PD3gBMHHoxLHRCgO0bmmN0KY30wvhYSZLgs4TjMZrpWWejv0wYSY/xf01Vsblf0/YdSsQoPmfdYFY1rGUBVAi0hwOf/fJX/ObLz1nvd/C//z9856n4QVAJPjBflJwul2x3+7gllzFuqSyzIXW9ZLvdYvqHdJixYI8FesSTR9721dUVzsXEk/v7e549e4a1lp/97GcPF0oa8bFoah6x8zdv3pBlOUmSYqylHwr62PlGR75hcPSo67ZDoO7V1RVZkfPFF1/wxRdfMIYahBCmBPubm5u3iv2YXD++3sPhOEEj405hxNKkj5QnKcXgSQ3WGDCGn370Pv/s6XPOyhQjWm6p+HL7klcv1yg540wq3uQZUkDwDq2i/4LtDc5atJqT6GjUZUykIZoQQwzqwVlxu9txenrK3f2ay8tLpNQ0bRu3m1pPRfn8dMl631AWBfe7irbteHp5SbABZ3qkFOR5ig8SqUbJsiRJ04GHbtnuD6SZRstAniWkaQLUaBlDEzb7faRzKQXeYTrL8nxJmeQINL2H3jlsiB1kpNcqeuO4X29RAi7PT/EikKY5TdsjhOR4qKjrGN12tlpRFiXPzq74b/7X/zU/fvEhJ1lJ6iUaiaPHCRcj1HxglqS4ssSslnFrLRM6Y9kedry6ueH13S1139K5SPsq8wJCINGaMi9i7N0wvPVCgg5IrXCAcY48SbHeoQrFi2cx0GJzf0eeKMqyiL7bUpJoRdCaJE3Jspw8y3DW8vmnn7Bdr8EaEqkGGqmf+N1d11MWOV1rBlsER9ARdx/vsWxgzlgb6IwDoVBJSts13K/vuLy8IsszDvs93rQI1yOFnyivPCALY+18RP8Ij39kYn58o3I8/BEPRcvz/WX00yP5MEGx2TAXiF5nHm99NJhyHucN1tvJgjDS8AKm72hbjbNzfvOrX2HWihD+fJo/xZcY/xeswbYN7fGAs2ayb7ZSYhPJbeKojh9yNp+BflBkBkY30UgtDIGYkWnizm0MFCYwaAYCwTmOuy3rm1vud5vvdS5+UMp7UWaU84yvX39Jlubsj1uEiMT2tonmTKbrOVksaZqGNE2jqU0ai/qIewMTne/q6moaAPZ9z8XFxZTGPtKyjLH4IgzDq8DxuB866HQynK/Xa4SUk5+tVCOHuCUwFOyBFXJ+ehGhAGv49OefDn7IYho8JUlC20afaDUUc601Z2dnKKU4HA4Dx7xDSrA2slROT0+xth/CkIncUikIOtBLgbGge8s7qeKfvfeE2bIgL2aYymKOge3rLfu7e9JZD3qBFAnn5yvqw56ubYYrK6Xre1xISZRHpQ0qcRHbNQLnJJt6zcXpFZ6GolwQ7recnZ1yf79GCs+xakjTEhVk9CvXBVfnp9xuD2SJojoc4Pycq4tTXF9jXE+aADLBD1QmYx1CeYSMHsdeSExIyFKFty1FkTIvUywph5sNi9UJTgSss5impXcelOb04hLjA63paNqazhgGIwCcD1R1S4sgkRLnt9GfZTbHD2yP3bGlaWuKPOWdd54w8wn/+l/+F/yLj3/MggQVojoNKfBO4xxI5xBBDoNSRdBJtBqVEmYZZ2XCqsiYZQmvN3dsmxovA0Wb4KwmSdTAQBHoYYvs0bHL8xHHFlLjA2gZbVrzNGWWZJxkOQGHs11UaqYKEo1W6dSdYw23d3d8/ekn6Jh8OwG2D/4YEmscvbJkg5Wylir6fyiB8VFVmimJ9hLnAnXnebM9IjUkwmLbA83rljSf0TsTz4HtcdagcGh8jCZ9wDp+q9gG8fY/Pv67IKCCI+DwEgSeSJzyOBHw8od376MDX9u2NN7EgN+2xlmHwuENBHqssQQnCNYjtUBicN2R+uDouyV//d//v0n7Jafhv0Z6jxoaU4gS+bZu2N5vqI4HTNeB94wyHSk8tBuq3Y/h6ozgFELqaecplRo47JLGxjpQG4/1Fk8HKo/XI54gIr3z7PSU5eKE/eEPHF0WX5RkuzuQ5TOsNZghtqyuG8qiHBRuelJBjrLv+Txi3ONgckx6Pz8/n9SRUkqMMdze3k5Wr+PjlWWUP5ve0rbtZGA1Zkca80gKPHxvhCh08hDoWxQFq9UqWl/e3sYPeyjMY9qNUoqvvvoKay1aRfrhyckJWZZhrWW/308skyzLJoVkpBq+BpjokWiFJ3q79L1BkJAKwbOzJS8uz0nTGJZgA+AC9bGOdEcR0EogjSM4S5ZnIMFaDzrBBIZ/l3FrLcGYHq8j/c1az939mvlsgZ0WFIsxEWaqjhX5xRylJPPZnLvdkbJYslzMWO+PVBXcbXY8e3bN4nTF3e0b9vs910+ucD7ycdMsIdEJQkiyPEdpQddbsiTyJpRUjG3Ms6fX3B8qZJqw2+8ROSRIeu+RWUI2K0maCpVognm7OGidILwfktk9ddNxqKMzoNIxZ3M5L/ngvXd4dnnFxxfP+U9/+mecJDmJAxXJsnGCHwLeBVQQZDqht4ambcmLyG8mUXgXcH3PIs14fn1NXha8XN/j1ndUWTeoRyN/W0lJIhRCS4IY5Pci0scQ0TTKD0CDF44sSVjOCvIi5eb2NdYblBpkz5NfO5M9cXAxHzSeywcK6mOnSWvjbixqBwb5NkOgh9Y0bcMiLSFYemO4vdtSpILL05I018zmsyhckyrywhk8P0RkMBk74tu/q8h+U+Iv+OaPSgb2hAARBFKMQjR+cM89WkrEoJYjx67Cu0BTtdFtz7QoGQBD3zbT7plxB0fc8YYQaNsG3yfT44rhB2SI0FDb7tluX3Lc7WHY6TIENRMCvYmZATHm7YE0KQdmmpASoVT035GRXmqcHRbfcRcST1BeFpTzBYvlCYtj973OxQ9KwDlWLUkpyJOc3nrOL54MBbWjG9JtxhScMd5suVyy3W7J83wK7B29uj/55JNJ1NL3/aC8fBgmPn36lPv7NYfDgXYRMe5RWQZMz9d23UTRGz1PxmLqnCHLM+bzOQD39/cRrhDDDaMj5j6bzXj16tVbLodJkvD06VO01tOCMkIki8Vi6r7H3x1dAqP3AZjA4ERnEEqSJxlzDy/Oz1jlGWWaoqXECJAqprY7AKVRApTvkSHGcgWh8MISRJQye1Ojg+JskZJpQMfJfdtFPM72Hd5FyGY8nyEEqqri7OyM07Mz1vdrFosZxWLJ3a7m3RfP+PyrlyidcmwtN+s9i8UKud3StRWmbaP/umfYEXmSgdGAFXTBUeHIRAyoeHJ9Rf31PX/6T/6MfH7Cf/vf/XeTnYEKsK725HcD7xpPUN9ImQnROH+e5bQDHS5AxBuHHdVyseC9d55wtTrlolzyP/un/ynLJCcVKnZ71o/mdNFWAMjzDCEl++OBPMuYFQXlbMbuuKdrWpIg8EpRKs1JUZI8SQghspac6ZBKkklBKkXsaIPAK4lxEmdd5IaLuICFwWTfi7iIIxUKRZnPqLsKraNSMwwUtTFSbSwoIyNilNrDOEzz031Z9x2zsgT80CzJSXlMgK43zMscby3HqqVtLU1rSaRAqthUWBsXnDSJ+HpnHQ43wQzffnz790aEXAqBH97DRC6Ziur3P0bfRO8dTV2z39/jjItzkwAdASE8AktXHwdoYiQUShBqYIFB21lsNwSdjzzuwe1UCjDdkePhnt12M7yXEZePi2vSJFgXEMNjSiEJw+8qKcnyguXJiqRwMRVqnk+iG+99FCWJ4TlFpKfOl6fM/tCFG6IfgtnXpGnKkydP2Gw20Stk+BBGMyaINq/L5ZLD4TAl4iyXEUKRUrIe0mXGYWKWZez3e7Is48mTJ1xdXfHv//2/p207tE6mizjCEPHTb5omMjSGIczIUinLMlL5ICbtJJrj8Ug3FPixKK9OVlxfXXF3d8dnn302UfnGEIXr62u22y339/cTbl0UBT/+8Y/54osvqOt66vTzPJ9el5SStutoTUdwBilAe4/uOwoleX62YpFIpHd402PHmwyJCwITQCnIpadrjnhAyASpFD7EzqI/3HH25IqPnl9SHTb03mCNoO1ih2a6yIoZDbWMMTRNw3w+Jy8KjtURj2U+X9E7T1q3zKXmvedP+Ltff03d93T3WzrnUdkM5Rzb7Z7yKvKTvTdYGy1gQ4iJ7kmSxoAFpTi/uGRfGfJ0xxeff0rVOs5PTnl1d0sInsUw4D72Lc45vr59Q2/M27xdAlpIZnnB2XzBbrelcV0UNch4LpazGaVOmauMP//4x1yXJ8xlQuIFYUg8ESLCncKHqFBEYI1FIXFDF1tVFfXxQJpkeGMJfY/ynmLwcXl+ccWxaujqJoYd65QESSY1CRIvPQqBCdFZzvHQUQohBsGFnAIrlFB0dU8dLEFA29ZU1XG6fr5pRDYFqH2DwRH9UuSQJJVOql2t4pA/+ICT0aMlTVKMNRyrhjwRdE3NiXFIGWPTgOgV5Fz0vMFP7JZvrwpvf/e3ZpchYr1CBESQiPAowu2t3/uWZ3kMxYTIVR+FZdt1zJnFR8phfGyHwNBURxweL2JUmpBRYm4HrLpuDYmJw0kfRNzBPdowSKlJkoI0jyPavjdIoUBEem+QsXD7AbIePyFBLNx5UXCyOiU1cVefaDGEj6ihSx+wdyFxgWihLDSr86vfc7Yfjh/EKgneEoLFGfj8008wJqaen52eoqSYtntKKRaLBbvdbhr0SSk5HA7UdT2xK8xw4sbvlWWJ1pqbmxt+85vfTGpBY8xbQoMRCpnc9wa4Yjab0fc91ZACH+GNKGF/kKILTk9POT8/53A48Omnnz6iDkZHwPPzc+q65uXLl5M1rXNuYrqM0WnjUZYlXddNMNHU5froZpACmRDMhOSyyHl2MkfbnvawJ9SSrqkJPpBkGdQatEZJwTyXmGNPV1eItAAfP4MiVZzPUj5+fsqqAHqwLZje0BtIE8HyZEmqk4nimGUZJycnA20yYFw/cOQN1bFmtZzR3u95dn3BVzcbjrd7mrZn+1VFohTXpwvq7T2HY8X8fDV4VVsgTNt0a4erWEV+7ep0xnMbuNvW+FSSpnkUP9RHlB5yNNOUVEq6kYHDcBOHKICJ9DnNyWzOLMu42d6xrSrQ0aHCNh397shP/vwv+NP3P2YuNKmPRdq6+Hq8Hz0j3GSRamxM7xbEWDSdJAPv2dG1daQWeo/EY42jSBKenl/gekNnerTSZElCmeWkMi5cddfQCYlTUZQUVZlxqDZK44OPVp6zYsZW7bh9c4+Q0PbVcCOLadf42Hky0knDWwV7PEausrWj+M2TJ+m080QGmrYiW+YkWqOShEBU+lrjaNuGPIkD2EixdCBC5ESHb0wcv9kky+8o7EEShI9sEkYnRfnWe/imRe7D+xq+H6IHych/btqW3W7H+v4ea1xki1iQMiDwSGGpm5qARyg5RaVJnYAY5O0qIVVlhC7i5RbPsYv/X5SnnKyeIcSRABz2R5IkB6lItUTJBuOG9xfERAkUIXrJK53EBCgxwE8qsplc8CTTiRxyN1XMzyznS3rxB8a4tVK8/+IZMou5kIf9IeYJ5jmvXr3h9jZu78Ysye12O6XJQCzOY9ertWaxWLDdbifP7CRJIudxgCMeqyW1TocL+GGL+DgxJh2k9qMwJxu8BQ77PVLLKcE9TVOurq44OTnhiy++YLfd4p0fKEYF7733Hl3Xsd/v2Ww2k9OX1joyULJsciGUA1vi9PSUoii4u7ubdh1j564FpAFKYJWmLJOC9y7POCsyRN9gIUIqfYx7y8ucpMlAJ2gtyb1Ey0DTxzBb7yxlKnmyWPE//4uf8EfvnbOv7sikQxHofKDtDUIqDocjVxcX7Pf76TMZ8cH5Yk633SOV4Hg4MCtLtscjwXWkKvDsyRmbQ013tHRTYEOBVBn72pAsDVpDNDRsIpc2z4BAliQkiUKKCIF5Z7Fdi5IZTd1SplnMIO06ur7jo48+Yr/dsZjPOWz3b1PPiIZdqdIkUlOWKUmiybMt690B2xlSmfD+5VP+5Z/9M87SktxIxCCyccEPHW5UdmqtabuWXCf0gzAsCKKPvFLR8dLHmURgVPnZAfuEeZbz9OIyDhWFIE8ylkVJnqQILVlvN1RNQ9t2HI4VvY0KWheiE1xMIBQEEeXQz548w7rAm7s3U+Mw7uDCN4rlFAgQHtKSxkM+mifEAhKpG+PjaBkQEpzvObu45OxixfvPr9ncvo5MJevZVtWw7Y8iMSmjb4oQ8q1w+x8MbwQ5QVUEifCPMO5vPNbvLN6PvhoLv/eOpm05Vs3wryrm7hJIlEAqMc29hplu7JSlRqmAlIonz16QuSXikziT9NPriTv3Yrbi9OIZadFgXcCKNWlWkuUFeaqwzRtCiN3ySAIMA0sk0jtTlNJINyyqweHGyDbx9lUupCKfzZgtPTbJv9d5/QEJOIJEBqQIdNWePJEsZgVX11csZyWr1Rm3t7fUdc2XX37J5eUlJycnMSl9vZ7w68vLS5qmmbqBkWM9CnbGoeKIWcMDNxseBjPpIEv33lPXNVmWTc9RHY8IGW8O66K7YFEUlGVJ27Z8/tlnE+ygteb8/JzLy0s2mw3r9XpSQCqluLi4IITA8Xjk1atXqGFgOZ/Pefr0KXd3d7x69Woalo4qT6UkGYpMWC7ylGVWclbOeXF1SS4hFSB8dL3r2oa+66Mvb5ohtUYoSZZo8lRTmx47ULWKNOGf/fg9Pn73ktDv0HTgWrSUD1s66ZnlDzmZ19fX0+ewXC7J0ow0S6MznXfMZwW745GT5Yz2fkumBSeLnEPTERBUnePV3ZazWYZzhkUfu3Ulc1rXYW0068myBB+g7x29cVw9uyYv57TmS9pe0HfxBpI6fnYWz/n5OT/6+Ef88ud/HwUpImL9UgjKNGNelpRFQZHnmLYll4on51cs5ifsdjtOVMr/5r/6NzxbnlGGaDTkXTR7MkNmZ4Qp4uAoSzNM30Ngmq+YvqftWpyOv9d0DYlO4zbWO2yIj6kELMqCi6tL0iwD5yNkIuJz5HkWXQzrhv2hom4ajnVD2/c4Z+KC4AfKmFIkKuW9dz+IQ/l1M93Pk2WsHOXPD0V7hE8evsdbNLyxsEddhyVJNEkaG4BilmJc5Pmnmeb5i3f44vMvUErTWodDoLWKdDYpMMENBk0PhSbWx4eCG7/8tmI+UuSGAhrCd4t1vvUYWNIi2vqmaUYxW6CkxhlP8NFGINEChB1mCiO9Ja4cSickKfRSsliu0GY+8MoViJi3GpXDiiTXpGWCER7pgINCFAl6ViBEIHH5ABON/PAR04/XmVQ6KnCJTCAfBmuIKd9y6LgBnabMFyfMrSKk5nudjR8EleAs3hi86QlCYPuWar+jbztmaYI4P8WcLLDWcqwbvvrqSxbLJUqqqUCPF+UoF22ahq6Lw8ZYtOMpEEJGK07viA5iccq9Wp1wfX3Nfh8HOcYaiqIkyzOq43GYpj84vF0/eYenT5+yvl/z8tXLSIIfZOrXV1d8+MGHvHnzhi+//HJSX/Z9z3w+Z7lcYq3l/v5+6vRHOX+e57x6+YqmbfAEmq4h2rvKaLTkPAsluTyZM9OKRZrz7HzF+TwnU9GEyhmiSKbrIrSCQCYaryRI0EqQpQm58dE8SAZ+9N4VP/noGhkqQuhilJXUaAVaxRSarnO0SYJrWhIp6PsWMwQgGOOYL5ecLed0XRTotG0Tjak6Q5klnMwyXB+FP0IEkjRnX3c4Y7k6LTkeW06W8wgFSY8zLW0tIJQEZ1BFXBj2+z13mw2CwOnqhDzz3N7ekylNHyxZUaKlJnjPanVKW3ek2hG6Fi0kRVlEN7g0wwf48tUrghYsVydcn51zWZT8i5/+KX/24cekLhCsxfSDnzg+ppooibU9znnkMCg8VhVJEpuGqqknZ7+Y9Rk7UKkCiDB4xHiCtSgfQ5VPFzPm8wVNVZGrBI2kMz1JWWBdRhJAGMM8TbhcLqnqmkPTUHctremxBOzQ5Wmt+NEHH+Bcy2a3iV15iK6TUgysjDCWvpGTPOKjREhpukHHYA6JH/jeUSik0cIzyzOuz1fMsoT72ze8+84zFvMZvrdkecpu36KJW/pESEazhcfB47FTnv42kiy+9fDEFxzEsCMQca4Q/ADDPDp+Vwc+dcwhsniUUhRFzsnqFItECE1bd1jnKLKUNBE42yJU8uh1xdeglGT0cBrhOAJ4bwnBEd0LA1IJkjxBZYrEK1QQLE9mCKXJC02mBFBORIRo3xvLdhCgdLQEkULgBwdSqcEFH02lHn9eCKRQJIN9r6Tn+xw/qONO04zGdIQQXboO+2PsTIKgkFB3LUWa4nXGk6fX/PqTT/nq6684PT1lOV9OhVEMSqLtdjspmtxgCD/CE30/rjzRK0GIaFr1/Pk7vHz5ksPhELereYoPlqrqSbMUIaNqcblc8tOf/pT72zs+/c0nE94upeTs9HSKMfvFL34xJb+PlMEnT55gjJmcBMfB55gYv16vef369XTRmmDxIqZOZ8JTIDjLUs7LlCzRA3d8wek84fKkJDhLN2yhTN/Ttz29czG5Ok1xUiCUJJVQ5hLjIBGO03nKX/zZB1ysBCLU0TbUK5TM0NJSZgKCpO56DiYw1xKJp+1qlAjoJHp2nyxnbO8bNrsNehCV5GmC84GudRSJ5Pxkwb45RNZICHgUtbVsji2ZztGip8wTkH4Y6LW0waMXc471kdSltK4bHNI81XGP0gVFnmCsxfWGZ+++INEakDx/9z263nGo93hnyZSKw0opscCh6+ilpNMCbQ0pgZ+++y7/5i/+GQsXkEHgnYl/QpiM9NM8pQ+O4C2NcUid0PYdxlnqvqc3PcbFAi+9xHcBbwM+Ae8dtjexYzLRXldJQeh7FnlGfzighEOJgHIWETzBOXLvEFphup4iLzBa0a5WdM5zbGqqtqHuO/b1ERcCRVrwx+/9mJ//+h/YVruhcA+FLHhUeCiASBWhkDDg2WJMTJeMTfjYjUsZB5c6SM4Xcz5+8YKrsxlPLlZY01Idj+gkfoYuWIIEmejY2LihcEqBe4SVjEyVUbZOUN/acHsR/allCHEQL8EpgfEC6wQyRMfMbztGD/uxZozzjyRJyPOCxUlOkAmy6Gi6lrxMmecpzjRInQ3S8rGGgJTRPyi+OIdtzfA8FoTDY/FI0IIkSZkVM1Kd4Xycj8QwhoJEKUISfVMmgy8pCQxdvtIUacYsz+Puzxm0jAKhyRkQ4rCW/x9t//VsyZWleWK/rVwddVUIBFQmEpWismRXVcuhTQ/5QDM2zWjzwhf+a6TxH6CNjZHWFDOs6Waxp5vTYqqqqyolMgEkgJBXHOlyCz4s93NPBJBZQE+Np0XiRtxzzz3uvn3ttb71re/TOOUYuo56tz0iD3/b8Y0mJ2NMtG17XBh939M0DbOy4nA4sNlsyKuKvCyJIXB+fkbX9Rz2Bw67A2VZHnW3JxxYmnz3fNBT55D7SUbJKZq24ee//Pnx5hljiCkyXyzoxqz10aNHvPXWW8znc/7iL/6C3ajbPE1tfvjhh0d9lI8//vjobTnh2ADX19dH3W2QJs73vvc9drsdX3zxBYfDYXzPqRRLWKWwMVFZzePlnMuyItcJYzSLxYLlrOJ8teB8tWBY3+AmV24vmix99CMmK3QljcKgyTVUmSPXBb/1rbd4/5230ak7ulhb5yhVxq7ekRcZgUDrB5qmJjMF1ipCtPjgubpaEpIRt3A/sFwuaPsBa2Qc3VqD0ZpZWXBxvuTpTU1mI2WeMfQtMcKhGdhlQAoQS8gzfIhkuQJj2e8PzGcFWVFQzSox/B1uaJqWqnLskVTTGo0G8sxRVSVPnjwh+cDt5pZ1VXF3LdrtMSW0Eb5yluVYA6us5LKY8Q9+7w+4mC1hHH1XY1nqvXCWffA0bXPkz3a9J3Y9SmvRzvYebQ356CgzDP6oHqnguG58kHH6pBV972mbhmHoScETkpTuRmviKKlLlqNCxCaRbnVGMqoiJao8Z4hLAondYc96u2XfteRnOfFb3+bHv/gZ+6EhJe4hnincjCn2m1Cw1mqsSuP4vAizARKDH5gvllxenpFnjodXl5AGijwXOQTvuby8pDnsMUaMGNQk7qaDbIKnIDdvUvnug9eXY4Zk2tNnmmKIDCpN0q6v0wJ/00h9GnsFzjoR8OoHkjYYa3FRstwsMyQdf22zU/454QePGrWOJohDcc/SyTPH2UqExbq2p3U1XT9gFGTWkJzDOXGcsnZK4+U8rBYHpdj3DE1N3zWQBrpDDSG8tlcpRCMlDD37/YZmv/+15396fCOoZNKknvSsQWh/fhg47A60XYtPifPLS+Fl58LdTqP85nq9PqrrnfKL7yGS+99zerG1Hh3I9f2gwnK5ZLVa0Q8D+8P+yB2fph6nTJooEq6LxYKHDx8eRaQmf8fZbPaav+XU4JwUAz/88EMOhwO3t7e8evXq+LmnLnJKCaNE8a00mseLJe+erchDIqlIXuQsqoJZbnlwvsJqqIMnaE3wMknYR0/nB/zYTEsIm8ImTUZibg22qPj222+RG4WO0qUXZoc8DMYoOj8IpukU9a6jqRPlaoYPidmoMbOva+6urzlfzGnahvXtHcvzC1IUW6X5rEL7yJNHD/no05cUNlE4zWFMXmJCGpTOcLvdMVQVi1nFUDdUxlHlJT5Erq9vWQWRSd1sN+RuRr3foZNscjrLafZ7zpYL/tk/+9/yX/9X/zXtbk81KzhfrYj9wNB2ssmHwPJsxXw+R/nAwhi+/fhtnlw8wAYp6wcf8GEYB43kvzJJK1/7FOgH0VUx1jJ4yX5MimRFfuxrTD0KGMWD4GhpJ96fEqZ223vqaxo5YX7UyQ7jJO2UeATvybSFEFApUmaOSOKsvOJyNmPftuz7jmWRgx/46ae/oAk9XuujWa8WK5nj2oR7vFh+fTqOWou5tMiLKgV5Znj33bd4/8kDdtsbLlYzMmtZLZfsd3v6TmYddBM46RzeP5vqy4H1qIqXfv0YTZr+HN8rAeEYuKfn/quYMl/9fsLOcZlMOFfBgnWY3mJ7MSOocoMmk4GqN477wA0aadgevwcoNBqDVoYyz1jOKzZhx66r6dqaum4Jfc/52YpMBbSWRmmM4b5BrAS/Vj7QHQ7s12uGviOFnv5wQI9JwSntVSMxJPme6P+Oedwi2CTBboIPpgekcQ4/iBZx6Duub64pypK333mXTz/51XEBTLolEw0wjtNwE0QyXdxpwU/d86oqRBwexeXlJe+99x5d13F3d8d2uznSi1JKXF9fc319LcLnVUXuMubzOX3f88tf/vK1z7JcLnn77bdZr9f87Gc/e40jfnV1hVKKzz77bFQCFChlgnuOm0tKqCCE+rOq4N2Lc1ba4HQkWYPNLbmGRW6Yl5YYO/qhQ3mPCoZu6Gj6njYK9hmVQEUGjRt1PSyJxSLnyYMzVBhQOojsp7VgJCOyzrCra1w+w1qRiWzqga7MyKzhsppTNy2b2xushqY+EIaB5WIuAkZWYVE4pzFJsW8j7zy6ou1v8WHg4DRNJ+Vu68EnS2YV20NDjLBciIEvqqWqCvI8Y78/kGWO1WJB30Xq/Y7oE2Yck8+M4ebFS/6f//yf86O/+iuGfiArc548eovnn33BuhHFxecvX8ig1Pk5hYe50nznvW9Rugw9wk0aLdKsYwAehgGlNf0gA0lh9AJ1WTb++3BcM4e6lp85YXPoUVBsEio6BqnASBOU0X8NxEGcTozSdE1L3/ay8RpRDgzek7mII2GVMA9Qo5FCllFpzYPVktZ7LpdzzuYV//7Hf8Xe9wxjKpjSPad7CtISEMdJzTH0TNTVmGTT1FpTlRlGJy7Ol9y0G3bbDdnFGUZBWRRc3+zvJ4D9/dDKFHSnqcLpeD3A3jvYvHlMe8BJFJFN5iTLPs22vzrzvp9+TFHkV8VzNGeuC7TLyAeP6xpWs4rCKarcsFjMxlhyL2qljUFrOTellSjzjZ9zsuRRaJy25M6iVSLFga450Lc1fdPSHPZoAquZONZMjVyRkZPrpJUiRc9hu+X21TV932B1oj7sZZeVFSafK45emjEQupZ2v/nqi/nG8Y0C96QpIt3qe+eXlBI+hFEnJNC1HaC4fvmKeVXxfJRtBY5yrac35/S/2aiMNgXtKXOJMVKVJWdGXHEmHrgf/PhQpuO05iQmdX5+TgyRly9fHifJpoD94Ycf8vHHH/PjH//4mEXnec7Z2Rnz+ZwY49FJx3t/FI86/awxRFQMZFoxzyznVcmyyJkpGasO2mGtwRGxyWPxWIUEk5BgUPRhoE8DvYoMKTCERNIGxgZV5uQBfXA2p8oNSg1YZ8gyJy7fKpE0zGJiV3cok7BWsVzMuLtb03S9mEJoMZbNMkemFdF7uqbBFQXTKG8/BBF28pHLsyXvvPWQ201DOwTK3Il8a5KJ0F0zkNmC4CP7usHYjPncCqtlNHsoipwYA/3QYE1OVeasrzdgEkplqBRpDgf++//vn7Hb7FAo6k78IzfrNX4YCFFMMsrbG7RWXFULlhfnrM7PRtxTFPF87wWLHEvwYwAbH5Rp6GG73ZKXJc45mq6lH3oYJxf9OMGb58I8meQUJiZHZi0mEzXI7XotioEuk2xai9TqJAKWYiSM61MDg2rFJcpaYWkosDGxyHI6FD5G5kXJWVXy8PyC1WLBv/z3/z/WbQ16UrNk1JCWgCFZtz5pGKbjuUtfSOGHnidvPWA2cxz2G1bLGbG3aBKb3R5nDavVis3dDaCOJIKBkf2g9a/NqBX31LavCrpHhPq15qZUDim+DqG8zks/iQtHTH3sCY00P2GNic1YBKzXTHaKDx5cMc/0aNIyvhcCH0l/IOGHHj3Y42dKUapclB6NN6A57Bm6Bk0ksyIuNQziUDUMmv1hS9e35E6YKWpkdmktjVD51DJ9aqwwlBjPeeoyK0SIbuga9ttb7l69+I1xeDq+PlSSEl3b0ft7s4LT0dtp0x/3RjbrNU0tRPkY4jg9dU+0f52Tqo+B2jl3hEOmsfWqEneIru95/vK5ZPnjAMz5xQX90NN13WvYeQiBL774gtF75piBL5dLLi4u+Oijj7i9vT1uCldXV0ddlWfPno0Vxv0mM71ueu9hGDBKUxUFC2dZWsVqUZHnBkuEEMmtMANU6Ek9mORHZoOM2YbeM8SBQQeiRYSBkiw+Zczo1AKEgbOzGUVuqGYWY4ZjlZJlGpU0ZUhkmSWqhHOabDmnqWvarqcoPIMPZJlmUVV09R4QRw9lLSFBYTPqZovLNEWecehaLpYznjy8ZLPvyJ3B6Gn6S1H3nrzt0V50HBQ7tHEsFjkhiTpejihCWucwSnG+WpK6QIqaaMUQILOGxWzG9m5N8JEwSNCbVRX7EBl6CdxfPH/GoanhyTuo6Pni+iUPqko68emerTQF7un+xRjxI06Ntse1ME0VpiTld9/3o7xnpCxLYZvEOJbCAoUkpcms4+7mjtl8xrysGBioZoVk+GOAiCEw9P1IIRSdirappReiFYwBHD+gtEBsg48oH0bMf8E//Xt/n9VixX/73/8Zr7Z3eBWPTXLJvjlm3XJOJxzukd00aeb40PHo4SW+2VHkjqrMSTFycX4GyvD0+QvyoiDPI4OzQqPl3prrm+v4/bpDCTyR1HEjfe27J/Hh9eGc118XY8QPA20XcKgRJvPi8uOEJWJMSSKN0gxCy5NgmY4OOLb1LLmHunSSREAlTQwDh+2Gu5sb+q7H9y3R9xCiCL6lnlevXoqIXZUDU6BG7OSMImkZuPEpoCN0fYuPwxs+lTI0RPTstxtur/+uA/e4Q0yBbJKNFAxM0QePD0HUusZMnJRGGpYaC4n7GzMF/AnDPrUBErZIccSS9/s94Vzee7vdHu3OFouFqPjtd8fAb4y5bzgaw8XlJbc3N5RliVKK9Xp9DMyThvfDhw/JsowXL15wfX19fI9TnW2l1JGnPdGs5tWMs7KkNIqVUyxnhchhKohEkQ+JkRgGfB/xXUtRFiIYFYLoR4dAyoQ1MISAsrmM8BuDB6xSZIVjNi9RBhgXQ2YzUBofE8nLAnDO4BOYAFZZqqri0HQ07cDteoM7m1NWjtvDjsxlVFXB4BP73R6fxNh96HuwkGc5b80v2NWBL17eMTv0rA8tfSe0xcFHtvuWmZMqs2477P6ANo6Zsww+0PUDmTU4Y5hXC+bVnNKV3F7f0QSPJrFbr/H9QJUX9EjjsOk6Aor5bEbvHEMnycLdZsOuPnCW5eTRM1Pw4dVDzos5FsEYpzUURo3lEAJd30lVRhDLsmGQ6lAJJDL0A10rr8lz4WIfcVfuN4Q4buTikFLirJPHdbyXKkkQaNuWrmnJnQOjhGqoA9aMGzFBmmNkzMq5JBtRND0MBm0czij+/g9/n7Ks+L//2f+bL25fMuHaahy7lkdpnBxklAxFv4bRJwxaJdr2gImepu5ovGdWzaiqOUmZkTKYkWcer0QqQI2/IJ2Csf8px2kjTjqsU2iYuBVvhJnXA7f8RYAprSHP5bPGGOm69ugbGrwnmETfJ16+eoEJ57TNA+ZVAbjje+oxix/6Fnpz/Iz3DVbZftu64fbmFU8/+wLvZd5imtJMSbghy1HKWq77PQMmIYlsUpBG8w+MiEwN8csG0kqNvrLCTfxal/Ub0QGrasaQarbb7WslqU7Cy1SjR11Tt6JolhTOGAlIKRIRitYkTQmMwdEcM/gJn5xGzWVIIhBCxFrHo8dv0fc9u+2Wm9u7sWEpEIm1Vviao+HC0Ht2I72mHzO3CbLJ8/zoLv/q1atjpj7Jy8riH3W0UxILohhx1lCWOfPZjNViwcxZZiZxVTjOC0tOwKYokFnoJQPznuC1NJSjPAzCekAofcqQtKH2ShQDjeBkaIOziiJXrJYVVZVjjdz4LMtou56u83QeUhodUtqWLEUskWVZUNcdMUS2+4ZyPOc+KmZVgR96fBrIcsXhbkdMkLkSpx3GJnyouVo4LuaO9c5xkzmaIRy1HbpBRvpLJ+PpTddi2xplDc4aeuNRSeGM4+Gjh6IbYjT7dke7FxnAtu5IfaAqCqosY7PbkZUVwXn2KZJpRbCWWBbYzFHMKxzw46e/Ivxrzz/+7d/lD97/kIfVUlwGjRaetIoMKtEnqWJQMnkbRj2UMEJ+etRvl2Esg1GKvmnkZ4LojyilhVHiB4IPVPOZuHUncaNJglgdjRxESU6CUkzCAkkjFhpDJNMiAWuNwThHIHE2m4ukQUqgNVaBIfFH3/kONiX+qz/9b7iuN7Ixa4UloVKQbE4JAxmSNECVES11PFgtG/jhwNsPzum2d2KmMQz0TcPF5SPeenCFCR3bfcsQe2zox+TD4NPUsPzquJB+Q2SfKhCdprxPjeJb4vae0GPl8Ho1fgzaarqM+giWOysGzaSB1HcSHENEDx3BK+pDpLn2dHe3fO/9twlhOb6RKFaOjzXKKOLUnFQKH0VfRinZZGPf0+9F2rVuWrENDAGjIRGJ2lDvzmH0ghUdlvEPoxt9UVKuVojmSyLZnIDIIxAnZ3lBI2xRYvIFtjr720Ix8E0Ct5zfsSEJHMfBZajFQBSXjhgCQ/KAuteEGDN2M8IpR/gqJbwf6Pt7sagJTwYJuFOtFELg+bPndOPUZZblx9fnuZgRN03DEP2ROrTb7cfuujrKQk5KgU3THPng0/mcNoDkdwoPM6VIUWSs5nPKPCPPMxbzkozEItMsSksWPTYE7NQtH9WrY4gMQ6DvAp3xBC+O4Ek7prqp9ZHrbc1SF1jjmTsosxxFy2yWYwxsN3cUuWG1EmXCvCiwhSX3irDZYdWBgCJ3jpQ0uXXCYNCKum65MzsMYPJK1Aa1YraoaK+vyXONVg5nHIvljPVuz3y+IpyVPHl0ztObLct5ybbpiV4iVQC6ILcnmEQcBjIfKKJgkQpQSWG04Veff0GeOS6vzrGlJvPioJOiJWlpUCcTWVQF3kd65GuBhOQaaWsxmXD1+1bzi5uX7P7tv2G32fKPvv+7vHV2IYJDWizE/NATAZNnDP1wzPCmhqEbqanHcfMQ8d0g/pxjtj5laD5GrDZUZXl0ZJeNPlDXB8KEhSNYagDBNJVoXzibQYoymu0lQzPW0QXP2cUlRVIMnWz0IUYJawoypfjD7/wWfUj8X//Vn3LbbSFJIjTO5UFKmAmCSJFRRJtJpMP7OPqySvKz9z1h6MkzR1vvubi8JJ4t+dXnTzHao9JACh6VKVQ0nI74nB6njcevZoQkNGOWOwZPyeI1MY6wxFf82JQQCg1bjcmeHjdKUET80FJv1+xjkF7IyKNXJKIfGC7PRjKF8NyVMmhtkcpELOrM1HhWIvsbAaMSaCiLktXijDyraFpZE33bYVQUUxMb6buOFBMGg4qjbR0ajbhkXT18hJ3PUcZAGKgWFWg3PhdpZHSLHIN2Ofl8xeL88Vde6zePb6DHDX6IDL0nBAHVpc8wTg6RTig+9xijUjLCbPSoUatEHCi+QTE65U3DJBs6PiATXudlglAI+AVd13FxcUHbNOwPh6MZ8FTaai2WX6K9oI9j9H3fH/0jp7HnqQl6ugAT9w4w1azi4uyMMs8octlguromKxwqWTJrMD6gwuvUJiHgB7ousd0fRpxYoJGoouCUWtF7ePZqz83e8/h8yVs6Z+4MZaF4eHWOGT0hXVaQGDfQMYN1rmCxWHDY70VCNiW6waM0zGYFu7ojBM/dXUfuNIuqwGaliA3FQUpzp8hsjmYKZlHw1mR57+23+PT5mjporu82DCEd+UxDhDiAC9CHiHYNLhO4ByVNmtRKyuWcZbc/kLmcxSJnu6ml/0FEa3BZQVlUR67/er0+QlUgsIZxGYe2pml7bIo8PdzyZ3/+5wx94J/87h/w9nKFURqdEFPlJInDEAY0FkbmyQSFTa5NIUg5bKTckSyRkSEwCi1NmjbKaIo8p8hymt2etm7wvWxUkpxorBZzDpVGjeYQ8X2PcYkYArP5HJtnXL31CIMibGvMmMhk2jDEwFTDRqP54Ye/xS9f/Ip//Vf/Qa7FFAy5t9ua6LrT2p90gLbbA7z9kO12T06AURSp7TpcVrDZ3NF2NflY+rddhyKSor/PtP+nwCUnbzE1GWOSTPUbvfHJS7uuY72+4bCvicFDEkGwicborDqy30A2GUkIZU0+fust7HAGP1XjwJM5biJaK8r5ApMXLC6uaJKivrtDl3MWs5IycySDKPolUR9Eq2NVobRAjY8ePWQVZSMIfYfyHfcagveHMYYsz6mqivli/rUuxdfX4w6CNU/as95Pk42S8XLSGJo+zFHhjBM61dhVnrio00WFdHSEP7UfM8ZICTryjKcbMeliv3r58ugHx/h77EizAnFXn35mNpvRtu1xiGjC0KfPC7zGRhCsPacsCorcsVrMWS0XKBJt0xDigIqKzGSYlIS+N6gxAzKiEDe6dw8+cHO3xijNEBNpfLC0hqAgaUczwM1hhx/ECm4+15wtzzk/m2E0ZJk90ra0Bh0T3RDZ7tbUXU99qHFGo5Xi0DYYm1MW2WiK6+nantu7LcPgyYqSInfYzJIXJVr17LcHGb8tCqw1hDBATKxmOe8/uaIZPJvzGe2rLYNPMAoneQTn7ocEhxajtyitqbzwoxfzGcoYmYL0EWMziiInRcVuV49MCZkWtMYQg4wgz2fVaNclk5DWOkJStE1L23ViJqEM113Dv/rRX2GM4R9/+D0uzs4wMaD6HqM1vU9HTvGUJk6w2CmHWCEYdQzCkkIrEZ4aWQd93zN0HS4X5b00jM7yQYSFThvZk25OCEHog0mRG0kUXJ7x6K3HlIsZ88WSw26HRYmWhfdEFNqK6XCMnjh0MPQUWmPHukES7BGHDqM+xrimTgWpvA/c3Gx49eqOVWlRTlHO5lilOBwOdDfXoxxBRjmbU/klPslcgtJiLDDpVf9PPk7ilTSGI2D+k96g77qjebgZqyKt0lEPpe/7o/46cEzcjBGU4Ac//F1Mv+Szf6lGt6zx/dO4NlJi1w0EbamWlzQeSJHV1QWLqsCoiIqiiQJT32EKy2qUsV5RjVo5oW85rG+O9NI3z2rC3yfTjL/t+EYu723bUXfNcecSArrc1OkhOOVnHlknSmh+PgZiEL0HKRXe+B0nWfoEa0z/LjuZPmbTk8v7KQ1pcqUJIRzNFpS6bxpMhr/iFfl6Q3MSlZresyxLiiInyxwXZ2fE4On7Dj/kxBDo2gYVPQyJTJUkL6W4STAJsssDPwrep8R2X4scaJbhI5j7kTjB8YxhwLNtBnaHHUOnOF89wTkZ1y3KgvlijjWWvmvF3zBM3HNh5GhkYUbA6IizUOaaoU8MQ892t6ftBlxW8uDqjESiH6RZ1nYtmc1wiJjU3e01CYvL57zz6Jzb9Yb+8TmHbuDFbS3zdEoWWpxwvFFf2MfAEBNdCNi+J2y3NF3Loprx6OEjzlarIzNivZY+RNt25Faw30wbUmaOG2zTtKgicWgbQt+Qxk1lIHGI0O02/H/+x39H2G35J3/897k6P5f11dQMo+CUYNAnFMFTOC5B8jIdGUemSRg37yng67FaJIFVYppAkuTAKD3ydyN2GhQbA0rXdSOF1qCNpprNWJ6fkZcFzeGAbztS3RJH+zFtxT0FpfFKM/Qtz59/wWeffoxWaQzWE4NBxt5Jr1PypiPGxO3djs3mQOWWeK1o9nuMGgeGnGO9viPLHFEZVpeP6OdndMgk6JGN8WuPX/89xesWDOnkmZ9iiDxvr1e6r73zGAxRUn1oLZrmKIXNCvIARZ7RdY18X8k0rhkJDBMrZYK29Cg+994H3yHWcz5Xos6XGOPSCD31g6cbPD4pZqtz+qToupbl5SPOVnOU72h2a7y0QohJnn2SxJtTXSajFYzCeBMMfE/b1KCkKV7NZsxmf+dGChxLr/vx9HtqVQj3+PB0k47DAkqdfNAx8xlvyHFs/OR3HLHzEF6DT6bv37/X/e+bXjc1NScJU7F1Mkeu9in3fOKsThhnP8Iw8/mcxWLB+dmKMPRcnp/RtS37/Y6mrtEK2vpAqSJKRULXYlxF8oKpCa3ovpDVEx4aAttDw3LE23QcpCQfK4u8yKDuCGGgPqx56+F7XF0uIHaEkMizs3EyMkMRacbxbD/yhif3E+89LndiK7ff40wSOp/R9D5QdzVt/xSX5ayW4q4TYkIDs6pkCJ6mbQkhslid0zQ7CqP58N2HWKvZNwObTUMbopjkjnnGsaq2hoAwjegQ0S9rGGLCZSWL+YqLi8sjF3m324gBcNNgksL30PfTfTTU9YEYE33X0PuO5Du075nPFwy9J3lPuViyevCAj9cvCX/57/hHv/f3eLi6IMRA5z1aDZI4jNdpWkvTWpi0uQ33gSH6UVUiJYzSZEVOClG0vvtBZAm0KME5I+s16XQckc+ynOWoS+99h80sD5+8xdWDB9RtI/MB/cBQN+gUsVmGG/XllRUudT/03Nzd8B9/8h+53l4T1MgL1mPPaPysofevMbWOUF1KbHc1+7rj9nZLrTzzQjF0wgqbGekz3N3t2ASHXVgwBQk7YtK/ISCo6dtf/aJfl6jLfnasgX7jL5gQIQneIgtrjGE2m3N+9UiqR+fYrG/JnCXPZILa6nB896mXdmTkoLBZTt8K20QGtEa9/7FhqI1mNq9YDAHlSqoYiXsN1hGUIc8KsqIiJGlEwsSSkc1D4s9AG0W2wHcNfmSlHZGH8cpNyWRVVVSz9m+5JnJ8Ax43J8yR0e4nQQyvB9/Txt50TCUcJ42/Ux2SN2/wxCaZvg5jCXrqKAL3N2PaUKYsfSqv8zwfXVDiaw1VuIdGTvW/q6oSnGk+J89znLMYJvuvTpoe0Qtjohft6vl8SRg6Qm/RWmGUSLqmMRDKjjsOE3nxTHSuYJZl6BjQOojbs4rMygytRVTrbLXkW+89osgUPon90WxWYp2VARfrsCFQmZxDu5OMRKsjeyaqiHUarRJnqwXW9nQeGajpPClFPvnVM374g2+jTcZ8oTls1nRtDS4DpTBGkeKA71tSclwsK4x9RFau2B8afv75LVJnqOMa8T6w29fUTUOeZZRFhg9eHMy1wUfxfdRaMV/MQAUG3/Hi+Q2Xlxfs1zsZZJn6DsbQti3OWsmqtMfheXi24N133oOkxgC5outb7l4+569+9Qv84PnP/+gfcD5bkA8DIUUa3xKUknWR0mtrJsaI01bMFMasFkTRbSq/q7IU7rx1wgtXI4at7y3rpvXlvSd4z2azQWtFXpXY3PH2dz4gzzPaL57SHmr0EDCDaNTYTMwcYpLnyxO4ub3lL3/81/zk049otadLA1bZY/avxgGKN5+7e157oG0HjC2IaMqqIMWWLC8IfhAxpWJG03r6QZOZiqQLUrIoZQXr5svl/X/KcdxQRh73N0Vgpu3BOUc1m7O6FHzaaEUfoSoL5lWFc5bQ7ZgmNKdNQipsSfzW2z3txkN6RD94Qnz992RWc362JCiDx2HzQtZwWZLnovCpYiBEgaxecwIaq3jnHIMPQt/NMhzlV0IhaVxD1tq/e6gEpmx42lVO9ESY1Mxe52cfPxiSdYY0UWBOHS++vFtPD1UYpzGNGUsZ1GsPx/RauC9NTg0DmqYZm6jHvXd8raiSHcebtTjfzGYzlssFw+CpyhJpmil2241AEyRm8yWbzR3BD8K97nsWVU70Hl3kWK0xGIKPKOWPG5QaMUPvPUOMYlc0PnhqvBEPzhfcrtfkTvGD3/6Q5WpG39dEHZhnsiAniVzrLNobmrqnqkoimnUIdF0vZg4qcn5+xnw+Y7VYslxCJKPpr6m7ht4Hbu42vHh5w2puJWc2Fq1F4UypcZw3Bc5WC3yy3O07VrMCZWf80e99n+vtn/NyM2YIY7kegjRGHZY0+l9mWXbMag51TT2OmPd9R9+3LBdzUoChD9wNLUpJU3WCw6oyI4aIsxqjFQ8vr5iXc9575wnbzZ6qWtD1PU3X0FmFyiw/+uSX6Aj/5A/+iEU1IxsGem1QWvoxU6U46dv4YcBoI7ZoSWRerTFY7Y5qg4zUvuA9WisK5+i9CDF1bXvsj3jvZc1rkVhNSoarsqykbWv22w2H/QHjI5V2ot3shHERxuGaIXie3bzir3/2Y/7qpz+iUQPRCN3sqPsxTk2eatiLhtDrutdaGdp24GI2xzqHbxphBcUorCoPIWjK+TkmmxN0TuK+kjp9dk4PqZd+03jO+BlOwtpRYTxNP6m/6gfvf2ea3gPSqOUzWRQalyMTxgrtcpTNwWZgLGh3zLQZIUvBkuXf2rajbaexfo49EDX226zVzGcVfVBEk5P7iDaGxXzGYl7hFNREjHPHS3N/thFjjTh/DV5opENH3zeikfOlHUsYRIok9OCvcXyzwJ0CaST8y0CYjNZqwTzkqmjFEKa5fSn5UKPEY5zKaVlMPgaMsdKwMuaIS8lVuIdXTsfN39Q4mLL3U0ZIPwr9C3wiO4oxRmhW+l7PQStNXhnOz894+8kTdtsds6rg9uaGejeM2FlLCANtc8BoTdeKrVhKibbz7LOes/mMAekuRwXOCO7og9DmGOlpWhtiDDR+oChEpN0oS0oG6+HJvCL/zlvMLxZ874ffQZUafMLpjGp+hrVi/dX0LX0/CK0tebwPDENHMprtELk59DgNYVDktqBwOc7A+bKkbio2uy1tSByajs9e3tGFFReLAlMsSRqyPDHLcrbrLW17oFDC5lBADJ7SeL773hW3v/tt/uW/+yn1EEhIpaG0guQIHqKK+BjYNS2zukY5g9WaV3evOL9aogjCwMgszCwvDjc8fmtBUzcMXU+eB6yxFNls9BCtUEpxdXXFB9/+kKHr8SHy8OEDnj57xtX5BZdnlzx/9oyOmr96+itMUfAn3/0hc5Nhjcfliq7v6IMnGo0rcrlFxoCR9Wq1JnTi6D6VtSF6mq5mrksyrSltwaKq2KXEXd+SGYP2gegHDImoofcdKlMUZSkSoc6R2o7YtNC2WJehMsGzlVGEfjRaUIrn62v+w0d/zb/+6Z/zItV0RrB3Nw7qaDs+H3CSFUepkpIixntZiX4I7A81d87zzpP3MJXicHdN1zZkuTx/TSoI5QrvKpLRKO0JWnjSr6v/vR6o3wzcaurZjJ9LpchkUkBS6Ci+k4OKeH0EE3ltg1DIcxPvg3ZMaeSAC90yMwZrQCeN0ZqyKMYET/TDTZbhx36TIaLxKGTDTQA6YUfBMKXBWkVi7HGohHUZRVlRBUO0OSZE2r4lKzNsZklEsiKT90gRlUT+1pMISpgrvu84bHfUTcPQt/i+Znj8YNRX5xhHtEoUzpBpsP9zBO77XXekAqrJiSONu6EEz6Rl3l8aVfH+J5USIjsyzw8nARheU2bz3t83h6YtUd07gJw2EoEj3HGKeccYxeCTcRBiXIIxJPKsYLmcszgruTg/Y7Va0rWNDEUoRfADbRqVEL3wxoe+Z384kLlJxtOL5RGjQ/tJZi8mxsKqiAhWb50jpEQfPCEGet/hjHCuwZPjuZxnfPu33mW5KLB2AAyZzcjzUihLGuazGUMhzj9TxrBYzGh94otXd+zrhnxs+lW5HXnHhsVizuUQ+fz5NcNYPq43W/zQk2dPMMrhCotSvVxubUQ7vO+JfaI+tMxXF+joyU3iw/ff5rOXaz59dkvTSxbofYAo2tVKy7Tb/gC7Q01W5FR5QecHXly/5GK1JPjAxdmCrj2QO8OsmtO3DVhFlc8IXvi2i7KgrCpcnvHee9/i4vycm5s7LssSYzUuczibUeQVxlk++/RTPPDL519wVs743pP3KPKc2PfjrEEkKi80sbHXoY2hG8WnwkhhHUbII+mE0xadEtF7fOroncjhKg3lvKJvWrQWKVVjLVVZsDhbsVwsWCznhH5gf7smdAMWRZXnZEUhOj9tRxgGsizjZrvmbz7+OX/+8x/xvN7gnQY94unqy7CIVqN34THZOcWXhQ0TQmSz2/P85SveupjTdj3WOcHL84wsm5OfXRHLBV4LJTIe2V+nx2tvLg3pN8PEa1TfY9IsPZ8kQrBi65t+DTz+2lZw/6/j58lcxqyqWHWKwUtC1xU5IHMiRZ5BjGPjbzoHuS4ivKU4P1sxUALq2FSOMaCU6M4Y59DWYbKEywtMAruzWKuxmZHBsiITxyA1Qj/j+ch5JvbrNS9fvGC9XtN3DRrPh+8+ETbNWAlMZ2i04m91pTg5vrGs62lme/pfPfG0jcGMbsZai5XUtPhfG8U9zaZ5fejm2P0dbcKON+6kc/6mqtiRt23v9SjUuIKNlSDuR254ljvOz1dcXJxzebWQ8rbvIUaiF1d2nyL1oUGlhA+iX+yMpW87rFISBJCmluhg3H8maXqK/VhRFGjvxUgXKMuS1Hb0w4ANHiWXapyqa8gyxcPziipXFJmhB4qqIstL8rLEGEVInna3x/tw1G3wUTErC5aziucpMAyJu/WGNs9IjLICWcH+sKfIM6IRLfTDYU992IvOioY8X4zGuZrZ3BC9p256hn6QQamuJfgWHzSrsuB3fus97jZ7docdUcZ7MFrYPBBJKdJ1nv2+oSgKSptR2Yy7uy1h8BAD+/2Ovj3gQ+Lli1fS2LOOvm0Z+gFnHWfLJbP5jAePHvLo4RUxJK4uzjm/uOCwP1Dv9xiX8e63vk39ox+xOF9ySImh8/zqWtQF33/0BJMgN5aoPNpmWKUYGId7tMb3smlZbY7sEeMc2ojHpNOG4D2tD2irhUViDIehI1uUnJUXNIeaxWLOu++8iwJ8P5Bbgw9wd2ggRLKiIDMOq8ShR/mAs5am7/j4+Rf8+c9/zGd3rxhyw5ACdmTvnPZm7iG4e3bXlw9F23esNxvMeUnXJ54+u+ZsNqfZbbHW0EVFcgWuXBDzGUk5orYkZblHb39Dp/H0mJKs8XdPo/PyvTFeaH3En7/5obBO+PRVI7BcSonMCclgNpOqzOBgjAsxCexntGTnpMRhu6G+3ZN4l75tCQOSWY9Ty0prsjxjpi22qIhKsd9XlFVGWThUCAydMIpCCtjRUELmVBIpDLx8/pSf/eQnvHj5ElJkUWXUv/MDcVQaK7kJotFKyBH7/e5rXYVvoFXCEVt6M3AnIGmFNhK8SaOMppeLNg07TD9/uuiO/42v++l574+u7PfHfbPhFOeePssU7O9V4RIQJGNKieV8RpZlnJ2diclvVUpW1fUkNXk2diIhGyNd3RCibCjRB1bLJYf9bpTpdIIXDh1+GNBlfv8px3PSxh6xR6U0bTcc+wRDEAnXPnqckUXlCDx6fMWDi4LceHzfoXROUc1QNqceIqFpSUmabcZaWRDLOSlpdvXAajHj4mzF+nbNvm5pug6MZRg8dtQqR8H5cs4wDOwPLXfrO27WW1azErfvKHLFfJZT5BXYyGZ3jVKa1XKJMo4+DrSbDSoLPD6b8d3332Kzb9h3ijhOuInlnLj+hRDY7w5Y68i1I9MWpc1xek0ThbvtB9wIbbVNT70/YLUmG3nrH37n21xcXbLd7bFWhrBIgf1+y2xesjq/4Gcf/ZRAQDtNNisYUsOz3Zo+JjKX82hxJnzZJEMSGI0fN30VEwZZQ9Y5ycAY9dFJVNaN8sJjbNKasqyYLeY0KvDwvXdYzucMbcfQdGhjyIyFIfDy86ci5+oDVmkcChXTOCLfY5RM7338/Av+/KMf88nNc2oTaREjCU6SltPn780K882ERmlF23W8ur5m6EqePLik8R2buzWreYnGEKOhWJxjqzmNcURtJJsYqYDq1wXt8Ur8WiBFyuyxzk3HjPkYN37tZvMVx2u9PzUG4ABhZAMpmVYscsdms2FRZUctoBDDcYhP+jCBz3/5MdsXQPpDgu9J0ZBCBAsKiXHGGkxIeN8LvBF6QufpfA/e0243HA4X+IsV1mrMeH4GZM3GJLIJY/NRxTSJpx8DNsiMAErRtg03Nzdf63J8o4zbGHvc8Sca3RSQRd9GnEV8FLPYMJYrdvyZlER69bRhl+fiJyi63PGYeR+hjlMdg3QfFE9v4unIets0R3w8xoBViarIefz4Eb/3e7/H7e0ti8WCZ8+e0bc1ZbmEQtTrqjJnt92SWYcpMvrGcjj0kuWOlDurpYmkkWERS3YstUMIBK2wxknQOqGeGWMoCsN2t6PtevoUyWallI0hYFVgvir4wW9/QFWC7B0ZupiTzc5QxQKckXMLipQGnFPkzmJQNF1PGFrmZcbbjx9ChN3+QErg2TL0A0WRCcMlJcrcsVzMQBmarud2vRN6J4plzIlJ4c5Lou+Zz5f4kGi6gboTPz+lNYSOmVF8973HrLcNn746UC0veP75rwijnVYadbDb1lMfOuqqZzGPMmXpNQG5P8ZakrX4uqU5tHSdNJat02RFxjvvvcPl1QUouH71gu988CFaG/b7DUXumM9Knj3/AvBkTopxYxW91XTG8/n2huJzy+zDH7AsKmlKWidNyPGhTt6Lo7xzR+bJ1Cspckff1KLnUpVEBdposjzn8uICPS/JlnPC4GnbjtD3vPriGfOyQsVE37TgA0ZNzCN59NquI6REFzyffPGU//Dzv+FvPvslm9jTaZEV0Cfrf1rnU5IDU+PulBt8UsGO0r/b3QEN1G1AB8GaWw82KYx27JuOMy3w5lFCdnr3E5z7S8/fSXz4MmQCKqnRZ1Gjojoyy7T66qxbcPtJnGAaiVfj/9I92yd42sOB3gvcRQziSDQMEAN90zB03REfD0kGqxQiy/vJz3/O7hreSYnQ9xDyYytWoAvDYbfjZr1l37b0Xcft7TXEntxYfNfju4bH53Pef/KYxGj5FtWYeevRSSgweLHOU1FT143IOxzPe7zQIyFjMnL5245voFUiI8suumNAnVxwfAjSaNSicDfRa47o9QkF6xjoT26YUTLRNAlMlWXJ22+/zaeffPJ6xj1BMl/C3e5LxxTjmPWLcPrV5ZLf/v53qWYztBEKWlFkJAQjtlZ26vpwgBTJrKFtay7OzsUcovcolYjBy2tiJHOCGxvUccx2qhpSjKAF61XpPnArLVOYAG1/y2a7J4bIxWohWblVfOe3PuDy6oxkOoxRRGXIqiXV+UNcuRDPyNTQN1t0t2doaoL3dF0vzbuUsDpxtpwTomH3y09ou4F218gDYRyKXvz2+paqyOl9YrFcst0fOHQDRaXZ7HuauqPIKwqrsS5HmYi2Gfv2jsHL8MNhs6aaKS6rkvcfX1AsL/lf/W/+d/yf/4//J65fXdOOTAsJgJGm7rlb7zBaJGuZVTiraYex6jAO5SL5DEzmKHJLWWS89eQh733wPhcPLtjcrVkuZrTdAYWm7ztSgufPvmC7PzDEyG6/x/vEfleTkiY5Sx8jP3n6KxSKH7z/ARflXIIcCTty0bWWJqEbYROSTLhaa1lWc3Ztj4+iUfHgrcf40UW+PhxQYWBxeYkxOYtqyeHVNb3ZcrjbiAuT0ZhMMnBrZHoykrBlTtsEPn75nP/hJ/+Rv/z0I259y2ClyWiR6kCW/73JyOuDbq9/7/S1INTCvh/YHxqePb+lyjVWiTdn51uezGYkpnmAgNJRNDvUl0LxVzx7J3g2bwZvdQzAUxw4oibcMz7efK/Er4G+p6bnuDEF3zOMRuPJD9RDT981YnyiIkPXS0Xjwkh8GLefmAhtQxrGhDLGozPNMXT7wO2Ll/z0o1/w8tUrhqGn72oIPUaJL6lWie99530i4fXzVhplHGhHwOCTIkawEXyQ758eE8ystTlKWv9txzeESu4z7mnxaK3pg6frPSalI+0LpY/QiB5pfBNk8qVd9o2T6Pue29tbaWZOARmOvOjXfvYUOjl5X+scjx8/4sNvvc3jRw9o2pb13Y3wZJ003Ya+I6VqHKsX4fu3Hj/m+bPnbLdb5tWcet8Qw4DTUnppxHHFmfJITUrA4D2lMyPEN9oTHTFIfaQputHIeH+oebneEpXh6nzO+YNL3vnW+9hcYwupXPCaoBwDDpvNcbOCFDJCCmgiTmv2mztiFOjGe2E3BCODIxeXV7y8XbM/tCiS3BfvcRqGrsXkM8kuiwLTDgwRPJrQD3gCddOTL2ds1zfM53OKXKql9a7jYrkk+Y7UN1RVznuPztl8esMst8xnM4IPPH/xHDU2hkmKYQg0bU/T9TRtJ0FTw6ws8F1L8ANXZ2cszs/GKqdnPst58u47nF9d0IV+/LcSlYJ4P/aeYfCQAofdhrrrWN9t6PvI/tBQVAuBpQCVBn7y9FOctXz/7W/hyjmZdWRZTjfIhma1qMiZ8TGOSUGI7DYbVIwYK1K65WrFarmgb1uuX77EH2o+r3981H/vDjXRB+y4cWUuI3MyqKPHMWiTOfLlnJ98+gt+/Pkn/NWvfsGrdkfnFNFodFC4qGSkW78+cPYa3fakqpuy8aNtWgwolURHHcvzl7eczQsKFwmh493VlXDm+57dZoO2LT40RIsEHzPBJr/p+DWQR0IyZHWfyx4rh3QPe06bD3wZMn/tUPfPVAiBpt6z3e6EGDCajUt8ErVESRwEU0crUpgkcCXwpSBaLGEYSClj2qtUApOg2+25efaMVy9eEvyAVgFCh07yLBmjqes9IYWjjKsa10xMFmULjCvQtiAh97xuhy/RARXSNC3LktXq7G+51hw//zc85EEcejFjtcZK6o/ETWOEC4sWg4Q4lmtTdg6vl1uSbZrj980Ikdze3h6xrGkAYGKeTCc7/fxx/l8xqv/NePjwEd/54APmpWYYOva7DVpp9ruNjHInT5E5msNBpCK1pu17Ukwsl0ueffFUFBeNwrkCQ5LXZvZIXkpRRNpR4mqTsoqkIKaIM5aE4L3ajv5/WiEsEctysWLbel6u1yxWBe995z3mqzkmG6GZNKCMI68WLC4eYWbn4CxpcMTOk0xgaHtxs7Y9vmtpu5bdvmW9a0jJsVrOCCnRdnJeJE1IGjdOSgo04MiMoSwyul424KEfsCpyszngrCFECRRd1zKrCoabHW0ndKloNIPvmeUzHq4Kfv43/yPLZUlMgbtNTtO0CJ9HdFvapuX65pa261gtZhRZxs3tmrauRRsFoeTNqpLF2RlnqxlXDx+y3u1YziqyIqcfevbbPTGKpvput6PrWoxWbO/WNIeGrheqaYyRummwWU41Lxk6z6fXz8iMgQdvcTFbsMznmJQYQpCpN5LgpwhrwvvhaE7dh4EH77zD5Ttvc3j5kma3g95DPxB8FD3IGHFKEYNIxboixxZONDHUmCQQ6YeGH//1T7k+3NBmA5t4oFEDSQvbQ4hyIoCKnqrUSeND1C/VyNRSE7YxoQljBSivl+DZNC1lkXMbOrTqeZJdsW89s3mk2d2R568YYkmTNdjFQ/JqjtbmRPj/q6LBKTPk3k/x9BWiaTOKYY39AuJED54YMr8pYsvvGc1rhCk4DPT1gXq3xg/+NdhFKQUxcDjsiERQohqo9aRUmAiINoxUGqdDgOPIOoh0L1IJWm2Ei+17gUCTKDeGIJ9LjZX3uFNgrCMvC6r5nKruiMFjlR8Zjun+OozrRGlDUVYsVqvfeB2m4xtNTg4h0o8Srr1v5YQFLMDYTGb9x8U0RXI1MS3eCNanO6fS8Ri4ldbiIzixSSYO0ZHOI6PIUwc3JdHIMEYzm1UsFgu++93v8uTJE5qmYf3yGbMiJ/QDLi8gROLgCZ2IT3VNj1muUNrgB8/Lly+PQkBNO7ptxyTwiNWivmc0RMiswjmFcSKROqRIoQ2BIE0341AorAVtAkpFghdj0MxlFLMl+/01eqZ469tX2BmEIdA2HtBkRUHEsO8j89UcWy3JSARzRrTP6YPwVome0Na4IicbEvNk0JnjULeoZY5J51zf7UhJEVNGHw0+RRyRIkuclY7YG3zXYZWm0YZmCJh9y3xWYQIoZchz0WdeuER/2JIvF9jZijBEVOd5cpHzav05i1nObr8nKzLqthOaE6BSYOilcR2iouslAIVRA70ocpqPPiH7+FMeXJ7x3tuPaZoz3nv7XeZlTnPoUDGx2dV4H3DWUZYVzu5YLhY0+4bzxRnnq0vqtmdXN+xrkd4kRqqqQJeRQ+f56PYLWf06kWnFIisosoopIKIlIHZdICoIyY/sjYApc1QK7O5uiXVLMQiMZDKLRZO8VJY4g8kdeVky0IOSaq2oFqTU8ze/+Etu2pcw1yQdiKU0aCf8OxLxKoJKWCUzAKCOSawaHdQliZSsVWvhO0ulKhOyKoo2Pg729Z68sPRDA7cZ0RpcnnF5UaD9Nbt1YJ8PzMsleayEvqtGTY2vyKyTOg3Vb7jljN+691GPJHqMjqSgINzrEd1bsZ2838hMOmbrSPNYxyCiTdtbdnfXeH8Pvx6reR3Z9zsiA1pFREF+tGFTCm9yYiYXsvWRgGjsmKkvl6AoK+YXV/Q6xwTF+vYW8hVRK3I0KvXEoCGAiomUPEo78aAloFUPOoA24OX8fV+jk0enAMmgtBUxL2sxWYHNy68Vjr9Rxu29Z384UBSFwARWoBOtFPFEEOr0z/EejpjbqXzrPR/7viF5LAWZsK4v78RTw8skhdaJxbJksVjw4MEVRVHyztuPUCqiEMwuBPHBPD87p+s6DoeDjFGPTah+dFiZNo8QAouFTFCGFMQBXQkFqTnsJcOxgnPnmRPMK8kfpdVoEutlIEUpRAM4iM70MG1Sicxp5ouSb3/wHqvzJagOpTVOZwQUtqyYnZ+TzecjTpvQKYoiWT7Hzs4IcSC0B2w+w5qCRIYyPY3vZcCjDWRZxsXZOTe30qQMxmAsoCLaw2w+463qId3nzzAGGNU867Zlu685qzL2dcPqbI6zjvOzM375ya8w1mBdTjVfEFLL4AeqzFJmCqsTeSasl/sHWNaH7weGwXM4HF6rvvphYE9Ap8T17Zq7uzX/h//9fymKkUqx2+3Y7XfCGgoDWiv2zU6GUQKcX5xRlQvuNhuUtnR9gNTijMEozWyxQKvEYbOjbgd+9eo5mTJMg92zWYm17rimlVLYIhMJgW4gtj1aKfx+T/3iJX3d4ALk1mG1TDUCBKUgs6TM0DlDKDS6AwZPtVjx/NUrPnn5Gb+6/Rx7bijKjExlrM5WYlTBaBE3ZbNjIJ6er9Nm/PRcvT6kNjGqpgB///rBJ87KxWjmXNOfLRn6nsN+zdXqnFJpYpmRZ1aYNcoQj8+geh2TVtP/3TdJXw/uCdSkpz82F7VH7K0DScXXXn+Egk42iVOLM+FL38eDIUAXFChDTIq+H0bpAQG6+l4s/iaKYprKEZXIy5Ky0sc48yVqojFkZcXi7IJkCkzQxKBJmSavSipj8N0eYx3anNoOq+Nnvac/j/FQ8ZVQsRqvj7MWZ/9nUAf0MWCdxViD0vnxAwh++NVI12kTRb12MveiVEpNmsL3OiZK6xG7u1fYG9Pf0QEjUeQ5jx5dcPXgjNmsEieTOA6AaI3vGxKRruvI85y7u7ujRu+kxT2rZnjvRYM6iiDWbrdnuVxSlSX73Q6tFUPfjZBCIbQ1Iwpw1hhKZzHRHwX4de6E+kPCOYsPQaazlGHoJ/ZMT6Ln4nzOH/zB7+Ayg8YQkqHvegalwVi8NiKjGyJaidlwUgpsgakuUH5AtQ02arrDnqywKBdwAW7XG5T1XD04Z7dviElzfX1L03dk2pJpQ+87bK85v3zA2fmCuvOoKOJcyQfW2z25WRHCgHYarSHLC1BiL2dtRt+2FJnFqIJ2qFkUljLTzIuMaw0xysPyJvvrzQ2+68Qt3RpNlZd8+L3vc3Z+wW6/p1URP/QUZY4xhs16zb7eo4Cri0tu725ZrJbkLnA41IQAmXM4Y4kpMJvNZEpSKyplaNZb1k3HL14+IyZoouehisxnFbPMSQBHXIV6FL1PmNLimz2vnj6nr1vKLMeN2iWESApRYAWtSBqi1VA4soeXVH1g8+wFf/njv+bVfsOrZs2dP+B3nmW5wric1WrF589ejqqL93Zbkx7PFKBPdXymZ+nNhOn4vCmZZj32gTy0Tc9iOZMEpmkZuh63KLl7+Zzlt96ivFjhi2yEH2QqUITivhQUXnvmpa9znzFLXI/33x0rBcmj05ewXvlrOvlz/3um76sRDtXW4qolxXIcwOkE/rHOjfh+L+sOwwQ66VHBUcFINZb3DcF/+dyUQdsck+UoO26KLqOYlSwvVpTa0B40aIOEpzFoJ9Fzulc3HaHcdO9REBPE48ToBP8kitwxK3K+zvENMm4JdnlRMGkGkETT+HXHNV57GE8nIU8nHqfXyWsUk8vJaUahxsUyXVOtFVWV8/DqillV8e1vvc9qNWe9foW1jrZtRhPfRH3Y0bc186piuxEJ16YRRbZuVNUry5LgRcnNKI0GnBHdjsNuR5ZnkKQMK7Ico2QiCmvQCpw22NFAVkcg+uM4q3UW4qijkO43LGM1zhlcZqjQ/OD7H/D48QVZBn0X6YMXd5wsRxcVppyDzSXLVpo+DMRhQCmNKxZkRIw2NOtXRHK6psGkhA2JWXJcPHiX29s7AlKK5UXF05cv6MPAEBMqioHA7d0dapRmdVbBIIG295G77YHlPCNre4pM4JmJa18UBX3fYa2mKhyZTsxzzapwdFVGbjVtH7knef36NQIK4woeP3mL1SznF7/6nP/Xn/5L/st/9r/mUG8IQ8dqNZeCO0T2TUOe5dxutmjryIqCoal5+OgR6+2OzaHBjHzavCywLiMZyIyh7TtMltEMkY+un7HrW7qm5nKx5GyxZF6UlKODe5a04LQGMU/oWkLbkRUVmRYGykBCjWunLEsKrdDOMhDobrf8+PPP+OLzz7nebdiGjnXY05iOECL+cODRgxmr1VJgHT0mqVqj1Zev1ynt73SSGO7VOk8e29cCX4yJw6EZMfuM/b5jt29Y5JZ8rhiaHQw1aWgJ0YDKUMqMn+WN6lchMMDps38SzSU/1qR0RHQhSu6tUMQw4vBmCsrpjeA9vc/ppGga+2gZ+fKcmRIXrLjbkVwv07XOkYYapUaFQ8wxq0Xdv38YlaX84Dm1U4Qk0IUTX9eAJF3aOGFDaQPGik7J6Pt6D+eoY09W7ok6Bm2S/M6YxBsrIiJlMvOhpK8zn/F1jm8ElQQms52pexpFkEhr4pvOLyed7onjfLr4pqxhajiKCWc6/myKk0+gmA1rpXHWURUF77/3Lm89fsjZ2YpXL57JAI0Xlb2qKLFKc9juaA4HFovVcTGLrrME7yzL5EKOYlZlLgJRKUbKPKdpGtq6xhrJcvwwCBNAQTYOhUwNE7FNkofJWAtGk1TCmlEpEBmzVWjy3EAy9H7AlAW/97vfJXOKoTsweCkri2qOqhaorCIgWhLYiE4BFQK5c2iXif5BcGi3xC0MOl/hfEddNxASbz2suL25QZcepzLyuUK7kg7FoWnY3l3jtKLtBul2owhJ4bQmqoC2loim8ZHcJ9rek2WW/aHGOXekdmbOUlhDlmfMC8vQJc7nOT5ELlZztrXn0HRj4Dgt419nSMznc95+/9tsNmt++vOPyHRiNZvx808/R6dAVTjuds8oi4LtZo/vA8vljJvbW5yxFNmcB08ec6gb6uAFX55V6DJRLRdkRUEfA0onqtUK3/b4pqPzDd36Gt137A87bjdrzmcLVuWMmcvJR8wZI7IFM2NG70MzNiwDdlYyf3jF7uUrmq7Fe89uv2N32PPi7oaXQ81dV1OHjkYN7GNDHJUh67Zjvz+QZVJNyCZ9FGgQiqu6lx9+c3jtq6rYY6BL9wnSdJ29D4QAfki0XWBXezZFQ5UStt4Sttd0ncObOcblKDW5w9wzW6a/Mw7rTBpA0yFUS41TloQiSHvwKEertUFFfYQp7huvY/eR+wROgur9eU6a2s7luFyuSTYEQkI20ywjGYVWGeIeZ0bXs1Mw535jOPUSuK9UFHnmsNZSZE6SxrJAZxaXiTBYrmZg7Yjzi1wsaQJ3lVR8Tir7GOOo/JdGqvR47lHqDw3kTkyiv87xjaCSEOO4m4yl15hdaiVyiZN0qnPuWJqdTnZ9Ff+a8SSB488cJysBl2XYEbPKi4Lzs7Nxr4ri/6YVy2p+tKHKtSX5wGG7R2lFfWg4HA445+i67uj2PpWcvhXGRdeKvddhf8BYQ+Ykgy/LHN/1BD8IWyZKJ1opg7NO9JOnc7Xi5Kx0iXMal8BYhdIOGf+Wda6NqMZdPFzw5K0rhr4mxBaXGbCGGDVdH4n1QCw6XBZBC4xQOYfBc6gPQkvUGVFBchbt5qShRZmWPGm6YcAtrqhUhutaUoz0SVENAVcu0dqyu7vmUB9QKCkLjcFpRbKawSvhnUaxKEMJ19QYS1nOiDGw224p8wyjQadAbqA0iWXpaLpAlWfk1Yp4fcfh0B7pWsc7P2aLjx49QmvNrz7+BU3bwJgU/PyTz/n4V5/zD//kj5iVGWel5v133uHs4iH77Y4+KFAZy7MLkna0wXO337K8vGS+3aGrGW3fM1stsVnG0DQkJQ4nylmhhbaKSOTzZsPLdsuqnXHZ1ywOBXObU2U5mTLkThzGyzyXktwYfIw0bcN2fcPw9DP2m61ou2howsCmOXBb71gTaAgkBx09XktT3kVF7ANd2x7dn+KYGasRVLjP4zg+J6f/PX3GvnqM/HVAI4TEfl+jlOZuXZOXGQ8u5pCg22/Q1YbdLtJTELWYP5zKXZz+iUmmgrU2x6pZoUZTAi20SmNAZ8fpZKOhMIrDaqA+zMlz0fyYCAioSW8ljdOOAqday7FvZK05JoUgiaBz2RECVSqXjBvLmOyOCbe6/3zqPlE8VTXVWmO1onCGqsgYukH2pypHFxmzqhS4cLBUc4c+TngLk47x2jgnVNPJW4AkFZEfrQuTkopqGuyzRglF8Wsc34BVMuoXO/0loacQPMa41xokpw4QxxswLZ3TAD42DaaLdwTvlcJljsViIQMSSnaw5XKBs5b5rGK9uZMLHqFvRRGwOTQ0dYvvR5Ni648Y2KSZrLVmvV6L1Gzfj44y3VHeM8WIyXNmVSU63NHLxJvVOG1xSjQPoveEFNFO47Qsyhgj/dBTFpWQYRiZMGOiqUdmjDawXFTEOGCMpqgqjJWA3beeIQVMVDibk7kclRVY62BoqesDXsvGk3yg7gJDH1BG0XqNTxmzvETpgTDAkBryWUGMA7ppuXo0Y7k4o6/3/Ogv/wMvnn1O3/XoMOByQ5ZLpRCSFqcVbfARut6z3mxoO4FXgu8hRQyR3GmMMiyqgjZ0VLmlzC3nZyu2XaIoSlCWw2GPNZqzszOyLKNpGrTW0njc7cbGcxwdaBI3dxuKIuc//PVPeXh5zn/+Rz+kKJfc3t6gkqVuPIOHZ89ueOvJI/Ztw6Y5oPsBU+Q4Y+gURCP6MilG6rYlxIizFuUcZA5tDXXs2XQtW7/ndtdRKkOlM+Z5ztzknJuCMsuYVzNWITAET32o2e5FAa5pG7oYaFSgtXATWp7u70hFhjYZWWHp0yBCVsljQ8JGRQqRzWZDVswkGIaI0mb0vVQjDe71YP3m19Pff3PgHh3plabvvdjrRXi1rnn2asPi/QfoFKFvOF+e41XGkBI+iklDHE2Ox9x4rKBko5mG3xifd0m8onCflSZqB2MlYTVkRpGlV+jhIVVVjYbeaZStuFea1FqTIuR5yWw2oywlSOZ5TlEUtF5iR1mW43RyIeSJIBLFUsmfxJsRMbHGYkz40nXTWrBwZzS51RRWc9AQoxd3KaIQBOCoaJqOQVgC99QQNsYc6c3eiwnz0A9jYiof5ojZJ6Yc/GuF42+EcSs0fhhoQ0TbXDrPXrQWlHU454471xQgT8uPX7ewJtxnEl8xI+Zd5BmzIuPtx49YuBkheJxWhKGjPhyOTBAJluI+H0LAOKHz7Q8HMgWkKDtbStT1YfxsiqapCUNgPrP0Qy/Snmo04u0HVmdLGYsehKJllMEZMVfIsgwTAsak0XFbSiStRJjJDx7nxCFQIVDP0YHWe4qZ4a23H2EsOKfp+4Z629F0EZcvMdWcYnbB6uyK6DK6IOPmXVND9EBAqV70FVC4omC726GMJssq6rpFp4TWjtniHFJku1lz8fAdLs4vyVzGp7/8iLOHbzMkePnsmfCo/YDLLcY4dEgovFQZyeCTaI1ba4nhMAbaCqUSWefITYYzGfNSs292VLlltSjZdzvK0oGGYbD4YRizkYztdsvhcJAVpjhy8iOC9Sag9QOfP3/O9e0NKgz86Oef8K333hEH+6Ej+R5rDC+uX5HQ7OsW47xsltqSZYmiLHBlwRADjkSpxhJZK9x87HUkS1QFwVgawCtFHT2bGMhDy61qyTtDediy2G9xRiCvbhiow0BDICjoUqQZAnd9TWM1LrPkJjHElrZvSMkLhZNEMAZrHCFpYhoNRIYWowT4FVLJvezpm4H7TZbJm3r4SU1KK8fHGG0Eggw+gtU0bcvtXc3uwpP0miqf8/id9ykuHhOVk1AdRL4A44kpEJMiieIKKt2reQbvx6+DjJ+nQSarg6hHhjCCrTFy++ol9fYOo0d4IYnssjWjGJSKYBy2mPP9732fLCsoM5Fjtq4kLwuKUWjNGMmgiyKjKDJUGLWCRibK5M95xONHBUQQdcj7xvn4jFoj4mIILbTpW3zoSUPE1A4RmvBYVWExYi+TRD5WuOkRqyz4BENPGmp0agl9i4q9bGgEBH+XJqZWmnQy7/Kbjq8duLVWrIqc6+0NxhZ0IaGjJjOaMnd4xkbcWE4du9hvLLLpmAKuQC4aRuWuPM8xGqqqIM8yFlXO2SKnSA4/RBYzgTpevnglQuVK03a1cIbXNTFGClWM+HvEOctms+bi4oL9fi/0wCiI22xW0feBpJSUO1rhfcBqgzWaoe9wzpJnOZmVm2OMIfqBru1Y5FaqQIRHbo0WWhiIwJYTYr1GhjK0HnnnLpAZy8XVGdYZYhLx/e1+zxAdZ4sCW60YsOz2NeX5jKrM2Tct2mWkqMEPhKEnJfE01FqTZQJR1fsDzSiG5ayT4aCUmK8uuLy8JJH4xS9/yWZXs3r0hGKxICrD9cvnxChGD8Y4QSajmDaA8K6tKyitJrMZh0NNUZVCx4qw2x2IMcqwS2bwGNZ1hzOJ87MlabOj73O0Utze3r5m1ixr5CTfGEvbpEYpUCMekJ88e8WAplxsyQxcrmZ4P6D6mpASIWU0TYd1ox2VkWlVrWTCN40a3EOUjFlZgQKS0djk0C6NUp2jaULw+JQYULQpoUOP8x153WJH0wkfI7WGPtOy+WPo+0C0jkI5MpVhaen7A6rvUSqNutnglZhWqAhqCJyfn3M4fAHRizTyONz2JgzyVbTbU3bJ6ZGOtL3x2ZsgzPH8+jDw7PmaxxcXKJ1w8xuG/Svc7BzcQrDiKKqPKQZhLukcpSqs4jhHMf2Oydz7XkZZ1v7RMm7SJSIwxEH6R35MEGIgjLrmabSdG0zCK4uxTiA5rXB5IS5VrVgRKgV+hDP1SJzQzqCMJqo0wpvqOEwUgsePsyJ93wsbbVyACennaWvJrNihtU1DJDD0Hl1P6zPQH0S3JJU5GD+SWKSitsbCEEl9R+h2aO3xfQN+wBAYBZ5IaZToSGKJ+HWOrx24q6Lgf/nHv8ef/ZuXXDcdWZmTjCWQSdNs/OVfRUmaMOUpIzhVBzTGYJRBGys0sDLHaMWDB1dcnJ3x+OEVu/UNQz+g0BwOB+bz+VHXZL/bMgw9q9VqpAOKG73okNgj1jSNnE9/B8msnc0I3pPnOZlzZNYSQxyx8PEBi4Fh6AUj7XsyI5VHyjRKG2GbnOCMZhSiYqT/aC3NLB8GYeQoxaPHDzm7OCOR2O0OKJ2YL1a03rDd7+kOT3n0rXOKqpKKop+mHxN+8IS+Jwz9+MAKbavrpALZ73fkVsrGu7s72eC0CCI9f/mCu7u1bAhlxSzP2O/3PHnvA2xecHvzijh0+MGjMKORKsf+xSxluDynLEuszagPDfOZ4Mi5tsyrkpu7GxazJVHDsirJnKXXmuX5JW3vjxnaMAyvqU2GEF5XjJOIJZ8jKowTnLTtB/7mJz8j04nz5Zy3H18RfYfe9xgjYkGH+iC+jjFyeXVFVRUMfYcepylJiRTCkW9rxz8qiTFI8APe92gF1sn6bGPCJENCmAQ6RcnolCYphbNCReu6jkQiHyUCINH33ejXGpnaV6dNRTGsDse1DWAy0Yb+Oip6p3j3KaxyP07+el9h2ghiSGibcbur+ejjzymr9+FuzXJ7Rz18ystaEfMVwYsBgssDLoukqCnyJZpEllmKonxtCEYpMQif5C4gUeSFSD/LfBNaJSx+tPkbTQ3iGBe0RusBrzTRllRVgTPquKEqq0Ys+Z6RNFUmMSbUOIBECmKwfEqtSQkVepQf/WeDCFOd8p60SuLiPnSEvpMxw+BFgjd64tBTWMXBBuLQkkJJjBY1DkAxskq0NbgsY/A5WmlCmgTA7qe9j5tFDOx3f8eyrkYr/rPf/wErveH/8Wf/luf1ltoNuKogoDEhfYlPChyD6TG7PgnaeZ4zm83wQV5fFBlawWq54PHDB6yWS2azima/gVb4kBM84r1nt9ux2Wwocim5p02i6zratj3yXmezmWTiRXF0Wp42krx0NF4yvzKfE+cztus1MXhms4q8cKQkQvcqCqNjkho1Bpy1or87qgF673FaBji0kWZmnDoj40OTZRnn5+fEFOi9lGlt01N3A1EXnD14iwcXT1g+uCIvcnA5+7bncGioDzW77RaDjPBO6nUT3VKc7gu0EnVAbSyHuqEsC66fPaMsSnofWJ6dM6tK6nrP8uIBXXNg0Q+UsxWH/R2b21v8ENBGHhTxOBT8OYQBtAhNbbYbzs8vyN0ovp8886ogpIBTitxC7Ht+9unnrB49Ybk6465/gUkiujXdy3tJ0tcFeIwyxCCaG/n44N/crQVvVImbm2tC8BS5xXdivhtCoOt7sYkisT/s8GHgbHXOYrGUxrTW5Fl2XIuyaYgue9s21AfB2zNnKfICV+boWSX4sA9SHJ8EKaM1xEDXdcdZAaUSMXli8EeT7QkDndbCxKRIMaGsPBPyeSYFQH0SnL76eLNJ+dWB+/Vj4oVr6/AJbF7xcr3nenMgukS9XXM1u6IqZ3y+b2gaePXyJQ8ezEmpwWpNmdWsN3csFguZu0jpyNAoy3IEVzmyuGZVdTRbUUphDVgjMKJUOfbo4Zk5R15oVJYRVGCxmDPMM8gzaRSq6c80MTqZs0RSEjU+P3QiDJUKjDoRmVIKS8Sl0TRj6CCe6P5LjUz0PV2z57C9o24aurYVk+UUxTzaKoZdQbP/Q9JqIfdrogWOrldKGwLQelEA3TUdnfcnCoH3cUFrTdf3f1soBr4JqyQlku/4p3/8e2gf+L/8i/+BrmtIhUM7K67B3O/4U5OxHz/I1KCcAueUaWktZb/RillZkqLn4mwlKmUKuVi9CLNYc2+SUJYl+/1euvHOst1uj8FranJOTYGJwz11nN2oS911oiHgfS8qe62TTYBEip7gezJb0LYDZe6IXlHlheh3DAPOiIO504o0DJDknP3IcDEWnBIGSdd1+DCAUdjC0Q+dKO4ZSwiaEBTOVdhyQV6ULJYrXC6mvT5GhtGFfFbNRFxqdJw/HA4YY7FWsOe6bmmamug9ZVkQYiTPc8BwefmQzXrNcrHCZhn7vYyKp6piow1vL1ZopXj2+ScY43j5/BXKJDGVtfpYTSSVRjF8hQ+Kw6FnOV9QN3sOu44iy2QzNzlnVcZq5iAMvHz2BW+//Q4X5ytu79ag0tjgGWVzkwzraC1iXaIoGanrBm0MeSYu6ymNA02Z4+133ubifMVut2W9vWUY/SyVFpcVHwLPnw8c6gOL+ZKHDx5SFAXzxRw7GXUoRdc1bDdrMY6oD/Rdi7OGzhj6vsV1Oa7vcU56OcrIZ1RJWAHE0dBirBqUVgQv/Y0Q/ci4mATaTt3YhRo3NfUmt++6HhUd1RvN/PH4Kt/VU1736b9pPSWaX6Vlr0ZFAkMXNJ89v8XkiudPn3F18YTv/tZvE1517PYJtOO73/8258scpxUMmqcvnjFfLXjx4gXWWlHmC4HlcknXCpOpvl0zW8642Ug22fe9ZOdhYFblNHWDczLJmVLCmIzlasV6v2Pfe7TR/NN/+Pd453IppgjTpug7uuZwpPr2XUf0Em9U7KmUY+hFvIzMcc8pEXvBbJxSVCkdDcnjREEZ/2233XL96hX7UT1UPPkCpIBVkdCWtE0tvZnpXo33VWmFjwGfxGMWrRmAwYcjciXBfhS+GgXIvs7x9WVdtaFLhv36jv/sd3+bl6/u+NO/+Yhd12BcJaTyMVB2XXcs/5xzlGV5zEImWt6Rx53u8WFpLgifuqlrZmWOyrKRaSDvn41Z0pShhRFGUOre4XyiVTVNg1Iy4TcN3UwmxFPmG0YhdqcNXdMSrSUfoRStFV0rJsGT+7L3g0h0juVejBFGk1m8GL2O1Q9D3wtOZizaiO1YYGLPeHzyqJhouo6EkRHtTIZVDk1DKDu8bmn6hroNDIM4ofRdR/ACwZydndM0DXV9z61u25amrgkxcnZ+htGGm7s7/DCM173H79Y8evgIBexqkTG4OL/g2bOn2Kzg7OoRdd1z8+KlOLVYQwgNTXOgzFfCzY3Q9YF93dEP4itos4yByRijRwW4XJa8/9Y5z9Yt1y9f8Id/8LtYZ9ntdkd/UOcEwrAmE2riWHZvNltIQWhVBmLomVclbz95wsOrCzSJtmk47A8MQ08IA5MBgkznReqmx4eB+nDg7vZWZFqXy2PfI89z9vsdu91W2ENmMoPw6DwDLCp4+s2OmGWEPKNVEH3AMKrOjabAcJ/hphTvaXQpMmm2wCg/PDGMtMIYS/CyvufzObvdjhDssXF1mk3/Olrtm/j26eveZKXcvzbilGZAETC8Wu+pFg7nMp7+6lNW732f9x48olkV5K7k/Xe/zcMHK1QIFLpkcXZBOa8IUfP40aNj0iTXdM+Dy0tevHjBfL7gk48/5vLqkmHwaKWYlTlV5djta7rO88mnv0IpzXyxoh8iP37R8tFnt9S7W77zwXfpvYGoR5EpT72+5e7FU4ER0yQlocbqt4e6GDNuL+wn7UaT80BMhs7LtTg0LU3bCzIQAkqHcdBG0/UD+0Mtuj9jFq7Ge2sR9k8/BFKacm35XhxhNGXFIT6fz7EmkozDnzYg0z3+bq3Ianyd4+tDJc6xfPcD9j96ShUT/+D736PF8vFuw8cvr+m9DCcURXHkcYPgPFmWHUtFCdT3tDwpmTRFkQuGZi19340LXTIOay1m0MdMPc/z0SW8PwarlBJVVUkDcvx6GAb6vj9m2kVRsN1u78vylMAPEEWTWxojA5mzIs+ZonjFaUXhKmwmhgt57iBqrAI1BmKrNTbLpGkYPKQ0Dgk4oTWNzjA+JNm4Y6TrG/a7gaFPNI0nYHBeMSjLwlbkl8JjF4dwgyYQB08KUpKlBE3dEoJYpe13e9brDUpBNavwIfDixctxA9Msl0sGHzls18yrnMN2Td/3VJVAAC+eP6OuD3z4ve9T7/dkNufVi2uRq9QKZ5x07JW4kHsfadqBvhexeGc0RVnioyUMLV19wCrLg+WMdx9foPOGZ9cbNpstP/zhD/nRj35E2zZ0XUfTtGO5LIMKWotTkHPCES4ry3KR8+Th2zy4uhInEeRBC74fFf3iKMQ0Bi8lm2+KIg4V/MCh7dBGVCL32w3WWfqux2WOEITemSWLdPnNuKEE+hBwOh9Hv4UONvhB8Pq2k/Ld6jGzVhyjt1JkmROaXRqJdCkhptv3dFmjpYmmlGK1WvLs2fOxWjQjzez1YPzmsMubDJOvpgXeH1PyYzSYFEhKE5Wl7T13u5rVouHFy5dcfPILPvj9t2B1zn7XULqC9tBjoqKcZfg+Ma8WvPf2e6xWq2OCVpYl7bJlOZtjldB6u6bn3XfeoeulWf748QO8bzE24269Zb1vMTbnBz/4IZ8/e8lsO6N56Rj6jDZWNJ2ia2VSuz801NtbttfPaNpWNuqTqh8CuZ6JVMMJs0wpYdj0SdEE+XqIMMR0zLYVwrPWNgebo1yOycYsPEqVLL2tRDKKIUl1N1EiJ72iPM+ZL+acXVxSDnO0DlgtZIgptgkhQuLCcTDwaxzfYABHsXzyPuuf/3u2mzWV1rx3uWIwidvtlthr8qI4ks2lU/tlXHuCSKZMO8syUhQ82WktQVNrhq7D+wGio65rfAw4mxN9PGbtdS3t3TzPj2VKlmXC526aY3Y+DJ4skyy6LIoxOx+kATWIbZRSEkyt0SijjpoobsS0rTE4rRn6Fq1gtlhgSHTtgeSFvZKNjIUUenEC8p5kRfbWjE2mabdNMbLb7aQkDhZrK5QytF1PEcSWrKkbot5TN55+AI3B95I5dn1PPzb4pmvtvR+bXJ7r21uxV7NWpryK0SG+aUbHnUQYOrRS7Hdb6rqhnFV86/33efT4EbvtjtVyxV/8+V9gkpehCK0oygJtxsCgNDFBXTfs9zVXF4VIyltL9IYsz2nbjuV8xtsPLmj6G7TN+PyLL/jBD77Hn/zJH/PTn/6U58+eEZw0kjWR4DvOz6949913McYw+AFrHfOqwqUgspqjcXQMg9Ajk1jUHeE3JQ/yNMjFhL+GSErCHjJas1gsaJoapSrZYDEkkjSqM0uIHj9E8ixHOQ1Oo3JLlme4eQk+UG9ApUAIwzHzinGylhPP1dxMk4USFiQzFIrc5Is43bvZbE5ZFhwODVobrBlxU3Uy+HICd3xV4P61T/G4pxwxbpDGm8lAO1rvubnbURU5mam4fvoZb739FLewFESefvIrmq6mrzvefvQOT6+f0nUtF5cX9E3Pze0tSsGDqwc457i72fDyxTUGy8OLh+hkafdbYkr4IbLZHbi4rFDaMfhEN/TYfEZUGQ1zdmmBNj2fv9jx8adPKfyc2azksNtRb9e0hy1914FSo6aPH/nkibqArhP7wRgCyY64OIqAZRj1YCKagB4HzAQO1CiyckZRzanmS5TJCUGgMJvnmHxGZoChpu0DYaQ6GiNaJEMUBy492uCFad5cK7p+oOt7tHEYk+j7xO5Q8+r6msOh/rsP3Kwe8ugf/hN+8t/+38j3W4rgmSvFLMupEenTEKXJI/q0wrlMMZLZDB88zliC8gxDx6yaY63BD5HMapy1FEWG1ZqhlQbDen3HZrMhzQUvTyNJXzDsRBh6nJLhirpuSD6QhkDb9Sitqao5WZnT9S0maXwQpkhlLVErdJGPUEzAWSN8UMCZDGs1ZeYw2sjkpLOUxRxtNIdmj1OKTGvRyU4RHyJZkVGUM6wGl6KEgRTxSYEyGC1ehr6L+FaRgmV5dkFIVhQWQ6KsKjKTkesMhkjoA94n+r6la1va+kDdNIDiUB+OQyxFUQiOrhSrxYKiLOlGFxrFyE8fBqpqTjFfsd/v0Br2h4aqKrl6+JDV+TltN3D18BHruzvOHz5g/eo5GI2z6jiUpEfpW200TddxONRcnpUiaap2YhpQLhhiom9bVrnhnVVGvBXnnV9+9Av+4T/8R/y93/9Dbt99h+uXzzlst8QYmC/mnJ+di/qgMSRKpoGOpEbsemIoIWP6Ni8xTtbYMOKV1llSFHlUCWoJPdLwJJOWdViWBX3fMpsvIUn1ZJQiDgPDIA00owsocshLbDUjr+bkeYnvBzzX9Ict0e9wGkyKDGHAxyja2gmsEtOI++B9Qs8LYqsldn0ybFIWC4IX84kUA87p1zxYvzRePm1Y43GvGDg2674Eo8hrhzh+rSJKSa9pGAzPXhxQqqb69DPefeeXZLuaj3/8BbU3ZFlF9IHNx59Sh45nv/gZ7777LkVRcHN9Q9u21N96n8XyjOt1w6effsaLz6/54IMP6PaBzz97Lq859GzbPcsXe7rO8+LphhAUTz+55vln16xf3WKSp7CWF59+wb8NL2nfX/Luu4+5e/YF+10NpsDNKrTLODQ1gQHjQOtAsoYhJaJWyACwbJQAZTWnWjihbJcLvMoZsGQRMfdOBh+CJD3ljGSkkT5EgV6LxQqrIqovaPqBfghYG4hJGvdBaUKK0otxhogDhGbaDQofLN4LrFI3DS9evuKzZ8/ZNt3fbeBWShG0pXz7W7z/x/+Yn/zpf4dXVnSlswzjh5GnrIjq3o1agoZBOZmGKsqcrks8ePAE73sJikPPfF7R1g0Q6dpOdAKMpu/a43ulsQEQQhiDlTzE2/UGlkusNnS+xVkZde26jr7ryfOCzDpiCMIXDcik1ohdZ5k8uMbIqKs1BqOEBkhK5JnD6yRi/UVGVc3QeYbynjgMZNZitfC5Y/T0vccW4niSxiZpCPdVR/SJ5lBT7wsWqwXDELjdrGkGjytKZssVl0rMS5WWEq3vOrb7A/VeNFgGHxjGgSO5Non1ek1K6Vh1tE1zhJemEf/FfM58PhdddeMw1nB+UZDllkePH489gpxqNgOl+O3f+R3+1b94Tjf0VFYgJGOtNIunse9hoO06vBfB+rLM6buB7aEhszltqnEp8XA543Y/cL5cjr6LhmHomVcz5u+9R/SCT78uUXpfvk6Z5iShG8avlTG4PCcrCnxXH0ld0qTU9z6n4d5mboLpuq7j8vKSrjMjb39kHfmI1dJ8zqwYQ5vM4YqSvFxQVivyokRVCWtz9ncFfZ7j2wOxO0hlCfgkcM5AIulJa0Tuq3wtlZjcJysUVC0Y/OFQo/X9dXjNZ/IkCH8VLDJVt1qLYQApjCyYN5tfoiESUgAlcILRjq6L3KwPLF685OOPfsbv//FDHpwXbA5j418nQrvHJE8aFJ//9CcYY+i6Tlg96xtS0tRDpGladi8+4+aLj3HWst5s8MPAi88XdHHAGIfRju31HSlpPvoLQ113FLcHvo0wk7LdmucfrWmf9uwP3+cQI6YoqbDgctHuuVsToyezGqMGTCbepm3nMSqQ6PFBoAjrHHkxVjLGsm862n4gt4bY9+zagboW0TprHYURb9kQAkVZklczCqtIjSQCgw8yTwAiqTCayIiYl0Z5iY0kGIJ4icpfE4Pv2dd7dvUBbf+urcsArS3RznnrB38Cfc6//dP/hhg8I8Lz2iKauNLGGBizHrQhM4Y+RQpn6Ual39lsxmKxYL/dsd8PWKVZLUY+64iXiYCTQTNl25HFYkGtFH3bHKGRCeQXemEheFjXCkRCYj6fEb3HaEWIAZRkxFUhwVslTYoBbQWbD17K8MxanFYUWS5fGzFPCGMTy2W5UOKicEKNus+q3qRrKaU47A/MmorlasH19TX7picaQzETznVVFmSzil0rtMdt3UoTp62JowrhqXjWKeY/NYjc2HOYKJFTEHfOsdkfsNZQliWzeUWeS1+iaRrm8wXb7ZbZbMbv/u7v8m/+7F+QgkhmxhAka42TrrDwmGOCQ9NROCVSqj7RNR0oL/CDUliteXBxxievPmMzDDx99pSqmkuf/4Rqe3qd3sRtp3PzJ5uW1vrY2Bma7L5xHaIoNsb7JqF+47211tzc3Iwqh/3IUnKURY4yQulKo4luQo1NZmlcJcBax2KxxBpD11Rsb1/RRuH2EgM6epQK4hp1ZIiIx+hED4xJyUzByFjR2nD14JLbuztoOyaYZLoGXwe/ns5RKY1ORpp3Rz74acZ/0vREnp0QZQNt2oYXLzt+9ouPuHzyHj/4wR9Sd4qQDCEogg8kPw3SxREiFa56DJGkEgF/ct88PrQ8OtNATog1jp7oEyEkzrNEiorDy49IUfF+MryblwQ8pXM8XF1SziKLhw/Ybg/Mzy5wIaFcCdqSjMxiLKoCrXqG9obNdk/dNOQ2B/zR0CXPHXk2XYN0pBmHGOiHjrruaJsGpTVFWYh/ZAgQg2Tc8zmF1XjlcVmGsaJf7lyGMiJXkGUZRVGQ58U4TRkEgs0MWe7IR/pzUeY8evyQm+2Ou+3fMY97uslBz2iykge/8yf8kcv5N//dP6e8ucX29Ws6wWakWllrUUkRlPAkp9mUQ33g/fffFW/JdE9jGvqe86sryrJgs9lgjJbmWTvyHJuOLMuo65rVaiUKXNZ9qVScrKYOhwatFFcX59zcXKMlNcZaPXKJC8muU0Alh2HkZitw1sggi3UkImb8u44JaxUqc8IkiBY/dFhlKTMZjRcsMX4p8ExBxw89Q98TvDAgjNZcXl6hrGNzt+anP/0pD94J6KyiG3F1YwUf7YeOYYj0vT+yMoBjQ3a/3+OcYzYTicjz8/NjJpTnObc3twTvefjwbS4uzqnrA5eXl3z88S+5vLykbVuKoqQoCq6urlgsl3TbkWalNS4zR+Nj6xx913FoOjofyV3G9m5HCJG8KGm7AWM1WVHRtA2recH3Pnyfl3d72q7j+ctbvvjic95+dMW333tbgt3JYMoUXE//Ps0FTFTP03ueFwXd0KNSwk1KejBmtZ6g7pkZ95rJ8m+r5UI0W4yMYihj0c7hioKsrLBFQZYVo5znmEEpydhMXuK7AbIZphyFgoaWFDqI0vzjtHIMpyp+wiyQSVIp51erJcvFnDvvCeF+4/mqoP3m8M3pJCWICFzEICPWCA4vqeGxOjEjvXFS4wTww8DuEHnx6oYf/+THvPXeB3z4vR+SFUtCNISoCV4YHSTwwb+xqQqPfVr390N443RkHPsVUdZy8NJ/AMXQD+he4QdFlyIPHix4cJHz8vYp73/wIXq9p1OO9fbAgEHZjCoqyqJgNZ+RQs0+Nnz2+VO+860PWMzSSMaU614WOUUm4+3WaJQWiuskGGVa+axVWTJERdLCBum7BjdOVJpR0EL0VUS3xDiLMkZmILQ+6oNLtcjYawkMIeBjZPS6R4/Whr/JJu70+EaBOyVQWHoFrcmZvfst/vB/8V9w23Q8bT5h8P4oYXha7mqlcFmONrJgZDpRaHh55uiHQNt2uMzRdQ3z+RyVorxXEsZEDNIB77qO/X5/bIDacTE755jP5xhjjlzSs7MzaVRM3NUYaQ4Hsszi+8BsVmKSsBiMdZROPpfV00CA6G+Lyw3SbFCgUhQIBzAqUZU5qnDoFLCG4wCOih490tqmScEpM/apRwNWG3zXY7TlsNuBdSzPHPvdlvazX3H+6C3KckaoW/q+pR+6caovHZk6E2umbdsjR9Y5R9M0Ykw8BvLVajVOlBrefecdqqqk6wRTe/r06Sj2YxmGgbOzc1FPHDQXFxc821yPWjKRFNWIx8aRqbOn7QN32wNPHj9GdS0pKZq2xTgZVUeBMhoTPReLkt2hxY74YTckuiEyX6zYb27GTe8+oExBaKJzTnTT06xZKSU6LWWBbQUiUjEd5WFQiZDiaxI+pz8v8FvNbFZxVHrThqTkD8aKPZ8RXWbQ9zoYKZGUERhl9CH1RjPs1wTfY1CE8YGUYSlRipuakxBRKoxY9Bg0fc+Dh1cc6j1954/a0afuUacBe6K4vnlu938XWqFATyNVWf6FSJABlSlDH4WeUIqkHK/u9hSffc7PfvYjvv1bH1DOzom65NAEEVkbNT8cGbm63wxRCpVGTf0Uj0MnU4OUIBkoacT5x00rhjF+hIYueKJxzIqMZZ6I2cB8PmfRQZbnlPOE8WpsaDoKl1HOlvhWobVjv2+ISZHlBUU5w2UWpSLOaRRTxabkuc8caE2eZ1QhUYzCVVqLdK+sf+kV2bZH6XFdIgNiISWGGFBJKL2n8Kg8L7Je6qbjULdjNZ/Y7ffcbnZsdzXb3d/xyHtCdk0XRL2s1wlvDfbsAd///T/m2b7mi6dPX8sMjgqBKWGdGfmpWxaLOZB4+eI5s/mMpmk4Ozsjes+Oe6ilrmuKMhfWRIpH27PJsQZgVpbHBzfLMrque637XuS5CN33HWWRE4OR7JokOCuK6AcKVzKfVfRtQ9+1ZNbhrCX2/qjXYZ3FaHHd1lpJJjVuQCoJvqvGhSBUYNmoTidKp+CNTmRZTn044IeBzvcErdEuOzIq9tGw323p04F2ECcfMSqVh3iChKbNYBpwUkpK73K8NqfYaFVVFHmBMYa6rhmGHucs1axEqfvMa9oI9rsdV5eXPPv4HpLQKhG9QDFDCASUGBvULa9u1lwtFkQiURu6XiCA67sbXJ7TdT2KDI1gn9XiCoxj17QidXk/TPZaAJoy7FPtZLjPnpVS2MyRyCnaUnTWBw8hjtTBaTT9/r1flymVYNm20hwsKlFjdFmByXO0dST0UXKVBCoize7x2oqsQInVGjKHd5beKkJ3IPkgejxGqrEQhjErjYAhRkWIRhzJkxplHBYsFgs2YXukut1PQ96f93Sdpq8nOq5S6mRyWYK3nmz2IkJ/TWIhlhTidTn6WGptBGYcICXNzc2aX378cz759COq1Rl3+x03645dvyMkSdiyLGO1WjGbzYTCawxGjY4uKY1jJqObDgkVE2bcW6ZJ0eN9JaF0S0+k8ZHd+pZZVvHkvbeZzyoWTeD/z96fxVi2pfl92G9Ne+8zxYmIjJzvPNTcVV3VA0lRFCW2RAk2YcGyYdOGbcEybD3KMGzIrwYMww9+M2D7wQ9+sQEBpiBRIgVZbJIaSHZXd7OrJ3ZV1711x5wzpjPuvdfkh2/tEyfy5q26t6spy4A2kJmRESfOuPe3vvX//kNTGy7XPcY0ZDLOGJq6pnY1BEfMCpQYpimtGRA5YaDlXUgFWQpv13fUTvQWfRBBT9/39H1HH7lqSFOi227xOVLpSLttOTs/l/fBOVISxszjJ8948uQJp6dn4qZZxDsffCAeQI2z9G3L+eUlp+cLnp4veHZ2/oXq8Zd0B1S44AmpR9nEOnrc6IDbr73NGw8/5dnz51hr2W63O6/cnEXp1LiK2joWMVC7kXh/aENTAg1Go0awZ2No2y3LrmOxWDA7uMfZ2RmpFsvIYXs8DJwqV2EPDsSStRSwQR0J0Hcdk/GIvmuxVtPYirbdMKobGZa6SoqtAt91jJuGg8kIcsZZSzQ9lbsS6lgtZvDGaJxxsnPIGe+jcHmLXDYXf4hh+7lvhdv3PXVVczCbiWVmTHgfMHXNjeNjDg8PUUpxcnLCxbrl4dNz+hBJqbiuxUhKCqXMjmkwhCsPF/XAB10sFsznc0kvKgERB7MDQHYv0+kEpSnQypjLy0tmswNSSju16Wg0lvst91+V3ZN1QnVEKfoQ2bQdz84vSD7gSghtQBwZY46FEinWu85UxTUuoa1js+3Ytp0wQV7wJN7fau9n9g3v6e691ZrsHNWoIVtL0D2xFwMjkVKrkrK9d1bvIBOFUfIcxV5UYZzD1RWmbtCuKpF9pvhKJHRGqF99R/B9SXRv6JSIf2wzIYdeBDppu6OIpmG2kq52C8MgcchTVVnT9z137tySWL18tWC9qJrcX4D2X5e1tlBFy2o4VK1CSUyJMuiNhYdMCR6WhSynTF8CF7Te8OzpM9770Q+59+rbPDzd8Ht/+BOenT4mZbkmb926xXe/+4uMnHhhG6NRWXYXgz/hlQkdoKQ2kGVwm7MsZGUpQkeNwnJ2cc5yuebWfMz4YMr0cMa4T0wnDc/PBDoka+bTOUYZcjGB6/vEvAR6bLYdMWW6TpOSYbtdE2MvAFIKnJ5d8uTpU8LxITlGzs8uefDgAaenpyw2PSErUs707RaVwdsIsaexiU8+/pi+W9GMxc/edz2+izw9u+CTR8+5XG8JMe0CV06fPOOTDz+FGEjR40Ni2wd81vifMb8Yji+XgJMhhI5uu2CRtiyXK6ooK+3rb77BTz54n+XlpYghknwAMYg8WXxGutIlypbbGBkWHR8dsV1vWCwumc8OSDGxXq85ODhgu2nZbDaoWk7M5XIpq2pVEXwgBM/R/IBnz59zdHi06zSHk8RYTcqBvmvRVIwP58wmDcH3OCvm5RLUIM5kOUVsVUvmYk5oa6hrRwwCm1irqZ0VkYjKZC0npUHSK6xSCO02o4yc/MLqEG7pcN3cvnuL+XzG2eUFOUesNczncxHJ9KIArJ3l+HDO5bqlu1yhSrdS1zXBQ4zS4RtjduIAa4RjPCwWR0dHu6I9BEkYa1gsFhzfOKZrtyKaqqQbNkYWvfV6JTAPhnrUUI+awsJoRSRTUmBSSSeJKRGzoveJs4sFmUQzqrHWkLViOjlguVpK/mdVMdMNjzdrcn1AXTdsl1vOLy64czSlj4Gh7RaudtqDFq66sqHo7iABpbG2koXGRYKpCKaTzjsjinOhp8j5UShxqfjMGCUye1s14uqoBR7RxqGMQ1th0YisuXSsZTA/qgXL9FFgu6RkIJ98B90Gokcj0JmxpnC+S7KLKiEjORNTIMVM0mLxMJlMuH//Hp9+8miHHStdUtspopEXGIbity1qYoHqymxgJ/4pWKqWBSJFBUFog9bJAjLsKkDSa2KCp09OefTwCR9/+DHRHvD44WM+/OgD2s2Kvmv57ne+DV//FlVUuKRwGVCiqB0aGZ2Li2Aevidfy4617EAK7m+D0GNNl8ltIicDrmHZday6Ldu2Y7sRVbGrPI2r8SGyjZnNesFmteEsJ97/yUe0Wznvzs5vE+MRDx88YnWmuZkz6/WaDz/4CN92xTG0Z73a8OmDJyw2HX2S159AtAIpo9NSoFB6zp8/oq41KRe4xHtU1viU6YIiZLk+xGAMDJrzYlKmspyPSSlQFeGaHcGfUeHGKFax43TxnMuLM87OT8koKmvo8dx77T4/+eEKnRJGa5ytaL3HWMPWb8Fk0IrNtqV2FX0baG3PZCpvVg6B8XRasFvFcrneGUalw0RlairryDGhlca3HZ1RXKhA71sSkap2haMrQF5dGypnaOoxVitU6qnrisY4iSRCvCSM1pANiiiBCVWFShGdNc4p1LDgRFGzNbVBpUTlKlTO9Ea6SQquZZQGFQgpgNLEnAk50xOZHI5566tvEHWgiy26UpgErpLU+PF4xMhZNpfnbHwm9z1Oa/oUCD7uOhKhWqpdijkIxDEosGazGVrr3QAzpcR8LlFutirSW22wVc1isZYi70YE74kp4qqGlDLTwyPmR8fo9pIQeknG8UHEDkRCjqhs8V6zXHkO79xkubxgu22ZzaeMmwbfeYiKuhpjqoq26zgY16w25xyMR2wun/P42QNeufVNum3BuLPaWYDKBa4w2u7wXG1eiOzSCnA4awgErI4kU5F9kAEQUpyvulxdpOZBwkAIJc+wxtgRyo1QbgymIemarCtQQiNV2ZNjIJVc0ZgNvpcdxBDDl5XGVA1ufEBKGd+LGESMkSSZHiCFRNYKXUkcXoy97K5yJgXP3Tu3iCnw4OFDspYcxxRz6cyR7l0lYmKXoKOMJhQDMzErKY+Vo+SWDni/0mQkzzRlseHQSiT6KiWSEivcPikWy5aPP3jMq6895N5rIyZOY0YTjDJUynA0nzNtaqxV2EoVv+vBCzHv/la7zr8cSpXnmMjSCYnuwCaUhax6Li8v+dH7mfGzJRHF2cUlDx5dcH6xpdtuiemczfISpTRt29N3Lb7dsF2u+P73f8B0MibEwI0H/wxH4Xt8+P5HqPaQkwyLsyWX/mM+/uBToRunjPe94NQpk7I8P1WYRaSMCey0KlsDKfXUzpJJu0GjUhLEoPeU4jKwlGaXlHn+7Dl926JiRquA+YLTyS/ZcUdSTpyfn/H44aesVguW6zV9iEzHI+68+hqL8wXrxXrn8WYQDvNms8UMJ3SMZGN3lLbT5893UtkQApeXlzv89ujoiCdPnoj3RfF+GNW1UJGKsU+rhOa23WwYNw3WWLpO6FjWKYxKEjlVObIP6JyZjhtRRzlJvxlk+ABOK3HfMxoVEykKfdAZ8fe1hX9syjCicpbKORTiBhhDKL7f8nxTLgwCpGO/ffcWb7zxOg+efIjWislkTMy6JHjUHBzMICeS7wl9InlP8GXLqYoTYDbShZYuamD0aF0UrM5ec2ZcrVZMp1MWi8UO+16tVty/f58QAqPReFdwNtst08mYmDPbjdADb92+zdmnK1LyO7+XFGVyngtTwKPY6o5N29GMxyLxdY6sFOvNhhRhs94wPzpiPG6oqjkP33uGqw/p+8j5+YLMFZZ4xca5YioNFMDhtQ5UP2DXuSZTfJ+TXGzJlVSdLANua8S83pQMyZRkt2UQOE5pi7IVxlWY4jNjBhogMqTOsfCrh6FTCjtGBIiE3TqHjhW5qklVRUpePs8UoQzqZOgYRHG3x5aR151p2xZXV7z19htkEo8ePRaPI5KwILISUVouw8ehu1XCeEk5owYWiRqIu3n3r5xUmsF+6dquZmCpIA3+cr3mo08+4v5HP2E0mzKZ2IIVK6qm5mA6pakkzo+BvcMLhWh4buU/14EBdfUj+YDl8zWa8/NT/uhHP2K53ZCypveerpehbQwCE54/ey6vV0s6lS12ruvl5XD3fLX7Goc50203mF7w9xQDoW/ps/jHxMImGU8mEqDiKolFq2q8Dzx9+ozNYiPiNsR64eTkiK9/9V2Ojg5pRs0OrnW71Hk5X1zlqCtxKX30+DG/9du/w4MHD9ls5L5+FtVzOL4cjxuEHuUso6bG2jkhBvrVmm0fOL55j698Q/P8ySn9ZonvWxSBru3JQNf3mKJK88FTV/XO4GdYkS8vL3f+Gev1msvLS8bjMSgxYI8hYCcT2q3Yto7HY6zTtFtZecfzueCTTc2oqhg1CpUjtbXUVgaMTmvGlXijjEc1NIIHDxeMImFySX63Uph0gUAEIqEUFg1JGCaKQiuSU4GUwq4I9T4KFS16+tAyP5yBShL263vm82PaLpRF7Bm9j4ymB6hqTFYVxsgCk8tgCYrKew/zHDDNgcUzzAIGetbAU66qSvjKXccbb7yxmwsMPi8pJZyVXZF29Y5CePPmLVbPHuBXG6zN0i4816oAAQAASURBVEUYQ900oBblehQa1+npGa+9do8QO3of2LYtOUsnU48afA4s1h3HR/f5lV95m7OLnocPHtF3rajhuMJu5fq9gkP2/btfxHb35eDDUHPgtctiF3c2Bi96s+ecxVdeK4FHbEVSEkorMVdGZNP5ShBjBrw2DYb4Q/dfCmEWm4BhcJdTDymWuUAma7nNvona8JkOr30QUo3GDW+/9Ra+8zx79rwM1vKucX3xtct8SRWefyiLnFguDFFjaRiml53b0FwMi6YqnXoK4smBUmz7lmfPH3Lz9JhRU1PZTJcC0osWvF0Lni7h2l+Q38YVf3/3/1IVKuekk95uaNdrMBqlDJOilvY+7K5drTVHh4ccH89pGosr4innLKvlmumHY7gEFXt07uURcizaC5GpjyvHd7/1Nd54400m0xmuqnFNjbUVz05P+Y1/9Ft84B/QtRuykqHoV999lz//53+VmzduMBrVxYSudNnmasdjrMVqhzGWw+mMTz/+lIuLS/qYZMjf/VkrJwFIxCAcWaOVxPvoIRizphlPePcb36RyFX/yR7/Ppx+9R1y06Dgotkp3WFUijY6Rx48fF+MiJT4aKV2jFGqtd8O1GCIZipucyFXnB3NcZVmXLawzstqOq4qmMjROchMbqxlZy3TU7EzzjYJxI06C1hgZ1BRL1oEVY7SwNSnubjmVQVfZeislnplWGzGYKTiWVqIw7NOAZWZi9BirePXV+9SVbPlT6Bk3FV0fWC4uqeqGvt2K6mqUoJ5S2YakLVFFlC8Lwh6zAK68J5wTTnsoQ8y+GPoMbo0pJZ49e8bNmzd34hNgJwAxRhNiwiAX+rbtGc0nuLq5Cg3gClIddirRC+vHKMViteL56Rm3bh8Tk6frPFpL5zoej/n48QPc/JCQIPvIeDTjcH6D1eIxq9Wa2bgukIXdddj7YpvhIt+Xeu/j3kNxvwookJ0HeSgOUpS0utrGSuGSV6aNFW727ufStGR2Wd5QFkhdvpbBXjEt6j2BjFNRTMeKR/hQVIdhKDmTU2SANfcZQLuggySzob5raUYj3nzzdXJOnJ6eEaOYGmUoyTsCwWg1+AGVAJMoV3BM7BLGU8G6ldY7SKPA5tLBFxzfakuOSdLSlabtO548e8SNp3Neff115tOG0Aboww46GGCua1GP6rqY6mfWm8LcGiCdyjnefedtJtMJ9WhEXdX0reef/JMf8eEnD3h+eoYPnpOjI/78L3+PN954lcmsYTQaywKrDe+/9xMeP5vAZSbHHooFrPeezrRyjaeeuyf3+eXvfpvXX3+dqm5wrhIqaBGQnT17Th+hqoUmXFnFW2+9wbtvvc1sOhYLZJVeGBgPby5Y5UhJcWM+5/hwzmQypY0ZT6aL/zQw7pwKXW4rngYh0LVbkSrHgLUV9199nTu372KdZTYf81u/8Z+Te8qFKGG8KUoHOuCvs9lEBpDlojPGsFwud3zkHcVQpZ2H8sHsgOViQQiRtt1QGYlWIkacAqcyNmdsIfnXWnMwEnVjZcyucE9HFaNGqF+ydZW8SB88MWahqA1KRGMkBinJ13UtjJgUZJBpSwEgJ7K2ZZERHroPHm0U9169z+3bN6gbyyv374qAyFmslq66rpx0Zb5n2Z0S9Jqje28wP7lJvenQtoLVii6113xbBphp6LSVkSIwhKoOTIRBYQrw/PnzIrZpCnf7EGsNfe/pPOioWG0k4zKmTN8HBq8H4FoB3w1frEUrQ9t2GOvYljRxCq+1D5nJ7Jjm8BjrGi7XHZPJnJMbJ7zz5m3mY0Xy3U5ANXCU97vnfYrgcJEPzJNhIRl+NixWtoiqcs5kbVC6pMsoLV8XaEGVxalwxq7YKjmhskHlgQctkESmMEKsK/4pVwtNih2x2xLbDSp5oVkaS0y5ZIUOxmtXIqJ9L/nhteQYaTcbDDAajXn37bdx2vDs2XN8SvLeK3GZk12XLs+xdP+lcKkMSpny0q5gqEEFOtQXXf4/cK6dsWJJnDOd9zx9fsrds1Nu377JwaRhdbEiBWlmhrlLUghkka7sCl5kvsAVX//lh9pBWgcHM157/VWOb9xgPB5TuUqsfDsvjIwoO5e7t2/y3e/8Avfu3qQaGQkV0fKeaGD7W4n+IdJglZR3tCZpi8oepw3Oau7eusnJ8RG2JMdnpUEZgu+5ffOYi23PdDahdharMgezKdPJWCyhdw6X1+0Frmis8sdYw6hpOJjP8UqGmeGLRU5+mSCFRLsR5sf5+Rm1kwxGpYDosVkwpWY0IVYjfuF7v8zxySEfP/iYpw8eSveCKCNDFIxv8M8YtjpDlzRclHUtUMqwnVVaMR6P6QtXe1Bn1pVIR3PwjEcN09qVANnMuKqZjGY4ozk+mKFTonYWZ20p3DV15SR3MGVULV1e12raPhCGQpzExyRFjWj4hS4YSsqKJFrr3UlKlml8zsO2X1EZy1e/+jbT2YjxuEKpExSKtg8sV1sJIIilQ0sbtKuITnF5cYbXNX2WAalzFXZqhXZUchuH3UnTNEynUyg7obqudz8LRSA1eJUP3t3ADiqpqgpXOTbtFu0TfYgslku6zYYQI0MK1A7jNgbrLLpLqOKQFrVm2/VCrwo947GE8fo+gh0zPbiJqsbEbKjrEXVdMZuNqZuEc8LG2IdDhuc/FOHhItinWe5zm4fbDoViEPGUalaK8xBgIEIaozVoSUkZViPxDpEOW5fPcdiNDRelLfftfS9Etszu4hwEJ1KArci/Y9x7rsOOpYg8+n73Z99QKsTEerUglWZHK8O777zNbDrjww8/IvS95GsOUMkAewzQjdYid1cKbY2YH2Vd4IcWq64HfF/x/pWISXImZ0PMCqUsF5cbnj095/69FbPJPTSJqrKk4OXaYBhCDmDH9eNFcdDnHVd0z8x0MuHenbvcuHFE3VQYbZiMGl5/4zWeL9ckV0FKHB9MODiYMj+YUDW6NGSi9ZmNR4yaSFCKyXhC6qSBceMJk4NjcmhRfo1xZpcwr4ckmwIGGetoxmMObxwxnU2ZNDU6B7GMSKlsXmTRH8RZVzWU8pkE2ZGQMM5RVxXT8ZSIgvzFSvIXLtwhRD7+yfucnX/M2dOn3L19o6ieMipFbEmuttaAtsxPboHJfPO7v4QzluePHrPdiItdDKEMiAZe81Uh3r9IBzFNSolURbSygneXzni/A6tKovq4qSWtps+M6oqDyYiDyUh2BAqauuZgMqGpxU52VIvnskIVS8iSsOGkwEVkcfB9K2wW5GILyZOi7ACsViWdWRakFKX77HqR9g5d23gy4eTkBpCIKWCNLfS8yO3bDvX8gj5I8XPOFrxVBBtd2xJNQ4xleBWvF6qc806Es9lsmB8dcnR0hFJqh13HGHfS92FQuS+FXy6XTCYTXHRcLhaYqqHreqxKnD07JcSEMxofxIEvxCJbLmdkLtS03guWP5pUKJVZLFc4KxhhMzog0rBe92xWF6zbJU29ZtRY2u0p82a2E6q82EUPF71cBFcClP1CsH+7/cHl1cUzdIWyO8opSxK6FrMlpVWBUPZxc3Y73cFkS2st50UGYyThRJXva53Z7Xiz2Lpm36KQ6LuqcpKAjohAFJkQ0q5oD4V913lrU871yGa9BiRU+/bt29R1zY/e/wmnl5eApAeJ6E2ev8w4Mr2XYGTBtxU+CrtFa7N7nJ10uxhkDT7WKQgEEwCtDJVxPHr4nNfuXXD3rftMRg39Zk1KZWHf7cV+vmOIQ5OdCVSVpXIGZ6SgagPNuOHwxjGdtqicaYx4gVinsBaMFrERWuIGnZUu/mA+p1+LB9JkNkffvE3oVoS1qCwTqiTZ72R1ZfBpqEcjDo8kl3TsLDrF4tMeCV7CU1AipEqFVLF7TcjtckrEnJjOJrzyyqv4ABjHtvOf825cP75w4e66lr/763+HbX9GYxXBd0xnEwmVVRBzYLVecHFxTj06wFrHeHqDX/5z/zy3T+7yh7/7W/zJH/8RyfeolHC2ImXpJnIQOp7Vmj5GrBFhzmazYT6d0bcdQ+RQt9lAjigsOQem0wk59oyaBkxC54DDoJ2hUplGg46B6aihdpamcjROM64tRleQPc7ICVtTlIje44OmShm0pe8VvS7GRcUBzDgnFDMl7oc+RqFfReGW51LAVWEO+JiY1rV09giDpm4qZmnMtvWgDYeHB1yutjgsbduxXa9JW08TNRWGZCOpE58LyIjXkQxqhi36ZiPueOPpZDcLGI/HXFxc7IreUMAXi8XOhGq5XIozYF3TBc/lYoWrejbbLbNGdjy2qjEZ+u26yLYTsdA4GRyHkxSiTGS1XpNyxFU1t++cUFUj2gibrkPVNdPZEdXY8fDBY2av3uFyIZ4edkggggJzFC5yyhjjdq9h2HHtQyNwHefe///w9YsYMghGnFLEGVeaijJsVvJepxjJRZzSe09CoBuhqWiMktlAyuLRYUq0GmZCMIrcZ8ihvKaSOZgikSyJLikV35qCdUf5WnwvAj0RV9ey60HUslZ33LpxRD36Oj/88fs8evSEmCSlXhLvhYIaspgnmUKvBDCqmKxBkbcPbx4kAs4YmeMoYX8lNWgzLFpbujbw4YcPuHH3LQ4mYy67bRlulvc8C3flxfK9r3h9seveH7SXbwgbSEt3mpNEfqmSGmStRVsjHjBK5gshJVHzxsL73ododIG/tGI8naKSsErGdYUdj+hVYht7TDWR5iSK86FDowaJJ0m8jULAdx3b0JN8x7Sq6LoNKjkqamLQVzOzMMw4ZCbhfUdKkdVqTbddkfsNTjuc1Yys4YscX6LjDnzy4U9QLjCdjpnNWg6PjplMpqScSMaQyDx98ojjE8VkMqeqZpzcbpjM5oxnU9btlucPPia0W4LvCRESBoOicg5ypnGW0UiyBWtnqY1M9p0R9YQlMR43ZXAYOTwYsV31NDbTVDUqCGxzMBJWyaSpGDe1uIE5R+Uso9owqi3OGnLSu6TvoQA4rXHGSKcEaKNk+6QUuZITORfa365gWIvv+7IJ0YToUSlKDmHKtD6QFbhKeOFdv4TsaLstlxcXPHt+hrJjjo5vsukzF6sVPkb6zYLFxSVuckpzeIdcz8nUpOyJsTiaxYxSBmOkGG03Wz7++OOd/8hsNuPg4GDXVQ8KSmDnirZerxkUmNVoxHq7xXmP7ztWfkNKUaCbztOHVCxcgRhROUqggZZcvxzFm2S77Tg4mnPn/qtoU3F2saKejpke3yBpx+liw6ePnoqh1WSGOp8QsdROSYhGGYIL9ISEJ6CvdddDER7+PxT0F4/9wdjwO7vdXBGLGUWx9X2xuItIJ0WhrxkngiZxChRPj5gzGEX2AWIgxyBOGOXzST7guzXBh6KQzAwqQU1xW0xpl1c5vGajNK5YBpPAe7FfBXA6o7PixnzKO6+/yo3DOZfLDeeXS5abTuY/RVRlrEaRqCqx4XXWkpOibTtQRSWcM7bS+NCDAudM8ZNxbLqAwhJiomtbcBL6cfb8GePJtOwsYhl6Dhxn2dm87LN4mWx/+Nm+EragDqQkhTQOrJwCUGojUGvbdvi+ozHQdT29lzg8wfO10B+tknR4wI5G1GEsXysR/7i6ojbHTGZH5ZMRQgEkUiddf7fZkHyLyYnsPZt1x3pxTpiO+fTTjzmYTmSOkaVmhgJH+nKdASXYQSwsfLthUgNKWE9fdKPy5UymQiApkZNuNusdOV0ZW6hHFOP3YgpfOJXN5IC3v/oL5Jj5+//xf8DjTz4k5yBKNafIUQ+fGq5ypCCdyWTUkKLHmeFC08K/NqrI1Rsp5JWlsYaRFbtEm4VXPqoqxrVlPBK7R0nsFv/wylmhKqniLbLr0IopVMnBjEnggeCutpSCayuUFdFFKthWXTlkB5xISvi1rnZ0bcdoUvPNb3ydk5MbeH9O8C0p9mTfM6o0tck8evopp6dnzI5vMa6NFMPKgEqs10vWQWNnCVVNES+HK2ggRYoNQKTtWoKX5zXMB4auumma3SA450xXOOzDBeNDYJwTfdvSKwUp4pPHKRl0bTtP3/X0IRbMzxILBU5bC1ljXcNoMuLweM7B0ZysLduQaWaHPHl2ilt1fPjgMfMbt3jjjTe5/8orwmqparq+p7E1xjhyCmjsDk6IKUJS14rzi655L8q+X8TG978/aAeG+zB7g/DPdOR7DBTjJLpqsHPQRnIQxbAr45yVTVGBlNq2JbadwBfaMNigai2FWZgj/W4guY/Pg5QoXQahKcowMgWPTj1OJeZVxeG4JvU1d09u0oXM2cWSi+WaR4+fsGlbaBy+l9dbaWEeWVcxKt4cb771FpfLJX2IRGRHOZ8fEPpATuJFs2k9266j26zp+5bVekvX9RwfN6WTFMWrzBC+PFTyGWqnVigGzyN9NRDOAt0oJXBF327YrJYSat3YHQEiFMVsRoRRORZDOWO4eXKDvhrRK8W4qVHTiUTMac14NGK9WnN+fs7ApR+Ovu9ZXl6wupDIvdC1dOsNi77lwxSYjsckMj4mQpRUpkHxmhHn0YH5ZYyh3uN671t1/KzjixfunOk3W6gCKifOzy94+vQZKWe6vqUZNcSsGU9nDIojXSZZ2tagDa++9VW+88vP2azWrM+fk0IHqQeK2q848snkPlK7mul4JGKYXih2h1MxQyLHQgmMuPGIUeWojWZaOUyOjGtHUxnGo1pimJzDOQlIMFqEQRq56PYv1uGCtUYTjJGuOie8grbEIonhfyrqTFGJDsVbKyVdonN0faDvO5qx4zu/9B2++rW3ibFnu15B7skhk6KnUoo7Nw6YNA3nq44njz9mG8AjA7M+ir9C6FviZolJmWzcnpBBQTYIf7wEGzu1O+kuLi5o23Znhzu46w349lC4B/OumBLbtpXttTYQeyqdiZ2n7QO+FxGO7EakC3N1jbE148kBR4cn3L57m4OjA5TVfPrwCU+fPubV198kPrtEx8T84ICvfe3rKFvx8OFDchav9H5zhp5N0Lqo+JCincpgVOsr6uPw74uUwBdZJcP/94v7wFbZp0lWpcgD10KlZXEUqCAjdqc6iUJu8E8JMRVhTqQf8iVTFCvQGBC7AhlCWqckjTwnvBcToyF2bVhQry0cBVvV5bqKIYBK9FkRnMJvFtyYTqnVjIvFmtrW3LtxyKt37vDVN99ksbokZgko6fqOyWS6e59GTc12veLGzRNmh0es2o7x/Bg7mnJ08zZWKS7OzlhtWh49O2W1WvPsyWPOnj/h5OiQ6cGM0Xi0g7fUwFgZ/nwxPcnu2C/cUnau3osYBz2ELbBlpN1u6LcrVOqZNhVNpUkx0Hc9RknD4kNk23ZcLpbEMAOgripsU9ODDNmjR2XDqKpxRnN2ekq3XeN9YL1ei8/IbsFPqKCoyNRVRaNnkAKh96zCArQWvYu1jJtmV1cGf+7r/jSf9Zn5IscXZ5WkRL/ZoJMohS4uMo8ej5jND+h9wNZCq4pF149Wkt1IoVzZmunhTb7+7V/i6ePH/NE//g1U9vTdhqxH1FWDKVvU2hkaVzNqKpIXRZG4+cGk0rt0nBi8bCWNoSpe2dPGYbMpOHbFpBZpe+UstqR3O51F/q6KL3eZ4IuYQjpZkVcLkyUG6XYqbYhGhlAxJfHTLXFUIWTACs1RQec7Yko044Zf/OXv8u7X38a6ROi3OCPmOdpmgs8kL1RBxiXWbD7i8fMFF4sW04wx9QxXNxhTE8nEriW5KwRR6F9ph6MNKPPA9R66udFoxGg02mV2Xgk18o6dknNms16x2bbCtjCG2Pe0BEySdOyUxbcmJUBpXFUzmhwwP7zBzVv3mM1vMJvPcI1DGcNJ0nzw4CmYirv3X+HDDz7k8OgmDx48wFQjjm/cEAw+J/BB8jGTFE2r5XNWGYiibHuxSA+7jhcHmUMB2IdFhmNHtSusD1Ngj3063vD7g+TeWVksjTKSH9pLTFUqHaA1JTC6FHnfF38QpUhK+OA7J8ccJfy5hBvvd9kvPrYyQudLWdH1HaHvZCPmI6HSdKueW/Mxr3/ldT78+CGPn16QvKdvW6pmxMHIkXPCzBrRQuRMVVeAEpn22AEB1S6Z1yPGo4qDWzc5vH2Xu3fvYIDVtmO16bi4XHB5ccaDjz9gu15yMJ1RV7VALwNjZw/H/oxykuu7ohchk30DMZnpXfl4d1232yUpBavVls1ygVOZm4cTnHVoEs+ePEGlnkkjkGrb9aw2G9abLdvtGyilaJwjlhza2WSMnUmAiVGQouf89IzLs6vnVte1iPecY1xblLJoJYZzsnNi5xqqrEFbW9hCA+NpN9/eo38WKuhOTfqzQzKG40tAJZnYbklFreVj5OzigqhU8a11jMYzqroRgQ0yLFBD6nUCtKGZHvKVb36bRw8/5vThh9C3xJBlqKLlQq2dQxOJ3Raroa4sNkonO3IKpyIjZ/EZnDGMmwZnJHW9MYraOUaVZToRnNsaXaLFSqHNCZWDbO+VKoZSg1ex0PoGAx7tNH3OwuF1jqDA6lpghRRpiw+IVhBzIhYhS9/3ZOt46923+Pq3vopxifX6guS3qBSonJI4LK3wJCKBCs2otkxHFceHM5YbzyefPuLgRFMdjLDWYZTGx0AfM0kPK/YVvi0pHsXfY28wM1wsg581sPM02R/0Ddv4VOCgru0hi5DEqoiKxfWjsCjQmtn8kJObd7h5+y4H8xNcNUFZcc4zSnN4dEwznvDg4SNevXefphHJ7817r9BM5mzblsVigT2cY5FFIWcl5k4K0BGVcxGZ7BW0/W313tBx+PnABR8KwX7nPfDer6iEyIxir4jsYBItNM8QIjrn3U5HlYuudg5rhVq23azLcFoMk1xdYawmhzHEiNWZ5Dv6zYrQbySeTl7EtQVo6DSNMbKDzUo8Z8oOQRFo6gqtMgfTmls3phwfjojhhPVqxfnlhpQNHslBzDmhoyUU1kqlxoAiBLnmKmdxqSe2nsWTVj4765iNRxyd3OTGdM48K272PdvNmuPjOZ9+9CGbxYL1Zl3sKAZsvrCM4DqjYm9ntD+cHM7bYdd3pR5VxOAlLDwEnj59WoaS4rm/Xm9ZXJ5TG2iqhqauUQrWqwWP+o2wvTK0XU/Xe2LO6O6eKMBFRQfAwXTM7OaxRBYWlazViMq7LOq2MIaG2YPsoIpV7LDDkjIpEM9eQ/GZQWzeaygG+qm8Q1+48/4SUAkQAtFHlLN0vSfbS5IxnNQNVT1mMpkxmR5Q1SM5qXXx3c1R8D0lUMprb7/L9y7/Av/g7y0IoYdOtlWDZ0ToUzGq0dRW01Qa1QkWPW2sCBEqTTY1ThsmTVnxU09lNbPJWJJrKsOornYYKcjioLOkgxsMZBmK5jRso+VxNGK4TkzEMrEWRzVd3AlkyGBL99z3HeQsnOUoZvrjgwnf/IVvMhrX+LhGCP+R4DuCT2jnqJ2cLBQZdN1UND4w6jKjasRqseHx2U84vpuxo5a6HjMaT0iV5ATKdj7i+7grQGUi85kLJOxtx40xEjSRJa5sNBqx2WyEjoko1VKGrt1c2ZmmLAqyqoauhSzc1vuvvMrxjVs0I0ncSSmQfQYj+KxrRnzn29/m13/973Pr5AYnJyc8fnbO0a27/OD3fsB6veH+/fvcv3+fp5++z7btiqWCEe5yUbVqYyGnz5zcQ5H7DEb6koVrgInatr1S4JZZRyjDoxe36UrJRZqjfEY5Rim0hYOdYmK9XdG1LZmMc2VoOVxkpkJZMR7LoSOSqJoGlb2ETORiZjQsuOwbYRmUMcVbpHSkSmLD+s7jphW3bh0xmzmM9kwmjvnBiLPzC5SqSKHDqCDnfkqk1MvC3haFZt1gTY0OPU4HEaflTHf2mHMQ343RmKPRlLpuUNZhK0fbbnn29Amry0tCCEynM0ajMW3bUvd9oQWba5/R8Pr2C/bw/2EnMkB5seDD3rdst1tW6yXr9Yrzc1H6SqGXmnEwGwvnvhS+nfCnFN7ZtGKKRhlD93DGVmvu3r1DXI94qBQ3jo+4fa84UuaSSIP+zF5Bl0H0wHZB781V9hXFmaKqLfeg2IM1h6PsRb4klLQ7p77MjVVOpBDpu56gFF3nWW+2zHqP0lY0/a7GuWr3CjLsUmZiViRtGU/nfPUbv8AnH73Pj9sNfe5Q6UoqrpUqg0RDbTRNZdC9dMYHkzEqxpLvmDEoxs7KYEFZodRUjlHtSuhBia4aGApZzKN0zoVLa0Q4o4uEWYtdqSqKtRi9GOMbERyFDL6cgLps5RUQAKukmHbeU1WOr37tqxwez+l9S9evCX6LyqFEQ2lihpjLxZkToZWOr2kaRr2hqToO50c8+vAJ55uPuPPqG0wmCh8SeTQiloIjk3vxylCqSNBzula09gt4DIHDw0OMMTvzqRDCLg6OGAERO3V9oKprKqPROWCyJxqP73u2XaBuxhwdHe+4rzklCAFjy+ejIfieG0dz7t29w4NPH/Dmm2/x8Mlz3vvxj9n6xLe+9S3m8zmX56cYa9lsNkwmkz04xJJUwtjiIDdACVqjolDdNFeFe5+/vd/pDBj+ABXtmwClKMPWF39vt/iR2SkSk1DdBgZF74VN5IzBVVVJkh8Mq8ocJWuIMvxVSoZtzlWYLHOOVPxE9iGcaxz0HS6fiNHT6Mx0PObNN17nzu0pzchibMY5xdHRjE8fPmHb9WhtqazwxZ3TGGVFKFJ8dWorOgRDxqmE1Yqmgku/Zn32mKcPp1BPcc2EeT3CugrnLJPJlFt37jJtGkLXo0o6vQzvIyqWSD5ldsV5+OO93/3p+57tdkvbthLcsVqJG2hKWCN8egUoLZFfq9WKQUU7Hk8F/qsroS8ayQKVeYBE1ykEygpJJP4XlaNVSgLFS5KCUHoB8g4h0C9hwwyL6QBD6nLbRDknCqSvkaKtdw3AdXjoz+L4Ul4lOif61BODBu1wAfC5dCIabSxaQ85RTs44rEQFpVbin2BsxXgy52tf/w6PP33INj+nX2+plMUqx8gZjE7FXlVLzqOS5JlpJYHBzkqSjU7QOEVTGaxRwu4wugw6laRslA5UJZEcq6yuIBIMRBEW2AF6yHKhpZzRzmJkCSV4Se0o/TZOSyhu7wOVsuSU2Wy2WK2oj+ecvHaboAM5tOjUYnIHKqEqh1IWoxzZGEkT0pEuCE3SgFAWx4bDwwmzyZjf+9EDLrc9915/k/nxMar4toiFrcIaoeIJQqKKEY/aDYuGi8cYQ0yJy/MLLs4vmB8c4GZzHj5+QOg809GETaEGNlXFtBkJNU+JIAEcuj7CjDQqb5mMLKODo9JdCSsn5rJQxExsA3XjMCi+951f4G/+zb/F5vaWV+7f5w//+Ee8+c5XePDxRzyuKhSKWiV0QnZDSbDtpLLwpbXAYSlGclACsmvI8QomIWdU0iVmKu/sCnzfl/QdiqhFF/MitYu3EwbCoDwsft1KiZOfKo8Fu/smSVFuKreDOjJl6ww7MUwOCax04dpYUrLyftkKgyJ7hcnsuPi5oA1pEOgoGdaHEFBkKmcYWTg5mXI4rxg14l4neaCZ2cGE+eGM7ukS0AQlO82shaGktaKylrqqS2ELaCtOh1kbnDEcKOjjluWjD0goKiNNzWh6QFU3zI9PcK7G9+3OejelhK0qgtbkkFDJk2Jb4DlR+W7bLe12S9t1Yh8cZffT9R2+9zsBknOWprKMTEUzaqgqR1UWDWNF+ewqkaNbYxji01TpfCmMNpAO2OrSSRfk1lpDNIMiWz6X/WMwc9svuKm0yNJgmh1+r7O4LQ4KegUi6BoKN/CiD+K12vqnKOpfqnBXFDyqFEOd1c5bV/wQ1A7z0UUiOjjNZKX2nrpmNJ7y2mtv8eZb7/LgJ4HzVsJ2B4NJcWSTFbeyQt3TCpxSOC2ZkFnJbqWyhsqWZBpdhBMFZ9MFNx/eHF2y92QbakHLEMFoUzoqRck+le0rGWUNOQayysXDuRj4FBGK0QpdYIPGWnBw895tpjfm4MB7SdjOZiQdl3HYeoK2U+r5DDOqiYW1014sWD8/Z9uek50ja422ium05nJxyfr9P+Hm+i43jm9K57gVj2qvfek0bRloiQXti4ZLuVgNRCVY4lobuvYTlpcL6romp8RyuUJ8ZPy1HMuBstQ4RzM5ImqxI7DVaGcolPOe4iznkmAuHuYnx0e89dYbfPLpJ7z19rvMJhOWlxfce+VVjm7cpOt7Hn78Mb2P8js5IOb6A2ShyYOJEVJTrSmQVr7qeIatqVDUpBhEL1a7Q6Ee4r32zasGSORzJ/1lEdwX9wyLQ0J8JvahqAEHVVZSc/oQdvmmphnTt8IQSQzb8Cu+uTJXvj1KQNlCRVQ4lahrxXhUMZs2HM4PCyqhySow8opbt29xftHifQZtUU7k/UonrBKXS0MR4agMSsIispKdW2U0RE9cnXH+SJSUMWaO7spn5WzNdG7JKRC8p/deIvi6js3lgrZrCzPH44MXJlIIdG17ZdOQpCtXWmGUppo0HBzIkLFuahonO+h9v6IX/6i9D2cHk5WTI+99buUWe3DyHrYs3c3unnLZSalyH/tD010dKYv7QARQLxRmtX//+0/iZcc/zcIN4JTGJE1Mu12GJH2UE3rYGuxkx7s56kuepDaMplPeeuertKtzNssVqguyFc5gtEMjrntuMCZnGKQYrNOgDRZNrYVlYrSIDMgJhZHvsdeNIYvKbnKdRQX14pR7/1+QDk8pYRUkIEaJn4p4lIqIFXYm6YR2CjdynNw5QTlHGz3BjEi1FbXhyDGeHTGZn9DMjtGjGq9k+2hCpDpuYXpK++gjutMV66BR1YjZ4Qy/2LBYXBCDp9u2HMwl3aZyDdutsEQODuaFY5xQ6cqAangPXoz+2mw2u0IVglCfBm5313U7f5MXT966GQnl0xjhXJeswpRB7c1qBsz21q1bLBYL3nnnXT76+AEX52fcu3ub9z/6hDfeepvnz5/xySefMmoqJuMZ55cXVDoxcla6X2PRmb3kGEqHLB3Q4O0uBk7ioxLD0Gl3u6SRoS3KOe9e125gqa8POK8NlPbOk31P8N05IhOnK054GYoO73fKMuxSCaxzhNjvHqPve3IUqfOwQOq9ZkPexyv83Vo5tw8PD5nP5/jgaVcbgdCUpa7G3Dg+Yjp9zunpgq4LaF1jEKpo5cRkLcUi+LFqhzMPvu5iPaGojWbdLtmcP+V5PWbbeULvqcdTuq4n+i1939G2wumOMewG4GJ4xpX2YU9WXxVL56p0zfv89YEfX8Zk196PFxfUl80xXnbsfrZf3D/vtvv3u/c77H1vny3z4mN/nrDopx3/1OiAUpgtOpuidZQ1JmnZysoTvTIMv/7Lsllg6MCVWFAq45gfn3Dz7n2WFwuWz57iSDincEbhtGJS1YxcJReFUtR7zn7aaKwyJZFKeONa6bKoJBTi6lYIFuWilKKiNWV7dT3D79obnuU2ytjdEpT3cEejMqZEM6EyuswY7aimmk4IyuK1ppofYl2Ndg31eE41PkC5mqRkG9uHQKd7ovKoqkbNDGbj0dOnuIM15rzDNR120+G0YrtasVp3jCbnzGYzjo9OGI8nWCvG/9a5Mhi+fuzzlge8cbiYhs9tuVzuzL+uTH6uD8x06cqcEyZFSqmYWulCibriIBsjVq6TyYTz83PGo4Z333mHP/7hD3nnq1+ndpb33/sxGcXNk1vcf/0+z5484mK1ZFYZUq8wCOygjSEiHeIOlSwFV4qj7JCCFww++LBTt2pK4s0ebW0fPtIFG1XqqmB+9jz+7Pd3ykt9Penk2s+UQilRIVprSF78ybu2pdtuhRe+t6AMlMSBzaAoCwMD/JIZjUfMD+copYrRWoN1GVeP8FFjbMvxjTkXlwv83gAwodAqU9WNeM2Tifn6QrQ/QNQ5UKFoz59yqUS0tFgsaGZHpKzx3Uqk+zGWCLhSC7QqLA3K3MuV4mwL+0Q66WHhzeV6GxZPVa5p9pqFfcx/vzi+OMv5vOPa5/lTK/fw+Ff1YOi8h/t5Gc1x/3F+1kLyuc/rCx5fIuUdMBXGBJKypKxKJH28elGKXVFgr9tWZbiTh+gfFAmNrUZM5kfcvPMq2+WKbrWgJtDohNMwdq4EIBiCEvnrQPszpZBrRaH3sPuwNexilxRGhqTF4nLAHfcTVl4c4O14wkoulJwjMQiLZLjQQ5Dn4Ir/QUJEOkkpXF2jm4YuGcbzE6bzE0w1JilLVJZtgtAGjJGiI0rHQOh7Uh/Ydlu2AfT4GDe5gOoUU9fYymGsg74j5rDzF3G2ZjKZ0TT1VWeir4rUvshk/8QeusLBDjbGWAZ2V6fF/lDzCh5QxJAKT1WXLfhQ8K78KnaMDeDRo0fSyWvF22+9wXvvvcfTx4947dX7/M7v/j7f++VfZbles1qtaJqG1XYFSoRZWSl0Ek+bhMiCX9xJDPhyzFeDsL7vCd4Xe+DqWlF9mXGVULiu6IOfp8bcf9zdewTFcfBKELRvlDVAR5lM7z3r1Yq268qg0EAK11gWg7BHa8HrQ44Y7QRCsZJmPptORXqfxGfFFE65D9L5HhxMmR1MWK5kV6URZotCmp5UIt0GiGZ4PfvuhE5rgZhyZvXsAe22xdsJzfwW1XiCMVDXDms1zjWlgx5odWpn1rV/XO9mP0uZ08PPszREL77fw33sQ1bXatVLPrfP3ogdGPCyIqyVKhGxQ20ot1Tl9urlv/d5x88qzv/UOu6MIlQOqCCpQu+TrerOhjMP3esL24QhKCkr8bMuU1tlK+rxlONbd1hdnvP4kw8x3RKrRWbe2IrGVFgNoRRmo8RgUWeRAWuFYMzD1oqhiGdhRwwnTllCM8JS0CCS6r3itn8yKCW4W2ag2Ek3n9TAA9aCrxa1YsqZmBVdzBwcHJJMRTM6pB7fJNsJK58JKeJTj3h3g9VRoJsYcUj8le82bFcLnp2ecXa5oYtQT6ZU6w3KOoxrqBorNEVEsn5xccF4PC1b0AaUcN6Ba/agIMV0SITft9Dd766tdbvufOhs9rezIlIqdqSmFO5dUWdniTnc38DNHR7HaMW3v/0t/uE/+k1u3bnL/GAmHjc3Trg8O+PWyQ0uuh7VFC/kInYqAI+IGlK6FiahdPmslMwxnKuwM7vziBjsU4fF6qrBuDr2u+0XRT7yyNdvfx1K+ezFN7yHkoDTSEHutvRdV+C2wpn3geA7rL069/YbCaVLEdkVPCUFsuD0A/YfQyDkSLvtySTqxjKfT1lvtrvXrIq969DVSxW/Ts0bHluCODytDyQ0KWmwFUl5VD3i+OYNxvMZ1hlMOT+G1nl3zeyRM4ahIcP1OXS2it1uSSGN3jBEHN7iz+uoX1bwftr3rsEfe+jJtcWZ6w35PtdavVDbPu94cbHfP76oyOanHV8c41bQV5aQhMWgihnOtYGNHrx8NUOCtTxTSThPCB6ed6uYwtYjJgeHHN444cbNExYPlruBotUaq7QIZ4YXHWMxilG77hr2Om419HvDm5N3uOZw5EKVG4ryTqVn7Q7jkwUoF5J+gX9e+AAkYNjh84A/OppxTTM5QLsxqDFdr+nIYsKlEkYnYmjpO09fPMpJieQjIXg2m5bL5YrL5YrFasOm61HWMJnPmbaBZgx9n/ChIyNqsr7zPH36FO89k8mM8WQiFL4s1MLhNam9C/bFjnIf1x0Swof0mH1pbggBcsY6SkJ4IhLR2eze031joaFYDx1kDJIwdOvkhJMbN3jw6Se89up9fu/3/5Bbt++wWW/oVhuIWQaKlQxZsxGfDotmsJK9JuYohXxIV1dIAa+bRj6nVFgFpWC/6EcyCD7235MXt9Y7nvBLIJNBdLF/7KiGKbHerNms1iTfo7MX2qlzEvKbI2RLKFYKVVVd6yZF0Xf1GUDB9EMU6t1eoEbXC9ZsjKVSloP5lOenl/S9xyqL05JalWLxcDdD6MJV86K13u3CxPFQQU7UWqFDiyaRtpd0y3PGsxF1Pb62S5VCN7w3L090uQZ1yIssUtyrQvoyrPinHfsw7YtF/sX72HXO5T+fKdxZFhDFQNcu91v+ffFV/Wngjp/n+FJQSdCKWFCQmJMwS5TGajHTv7LOpEivB9xO7E2FeSDlNiH+E1opXDXm8Pgm9197je78MVXqcEbtaD77CSG79yfnHQYmU32Z9A54+8AHl9vn3R+t1a5Qay1bzJSusgxTTDvcjWG7VrodimqL7MgpouMAEwlUoCvH9GDOzftvcHByFzc5QdsxXkGfgphGpRZyh1aJPlqxxc0QepnKX6zWPDm7YL1u8T7Q95LEMxpPefW1A1555U22m54nTx5wcXlGDJHVasNm24oP9sUFm3bLaDKh7hqmMTIejyVQoXS/0lnK++SD+K8IjDQU2lx8YNQOm9R7XZh0gRqUuCcOdpmSMlOEV3vd6pB7OezKKuvoveeb3/wGv/nbv43WisPDOY8ePeTm8Qkf/uQn9N0GnY+I0zHr7ZatF2vfeTNiVIz0Vek2E8OOoVywhYcekQUqDrunsuMaXsf+7uqqiF897+HiT6Xb37n2Ic51+1mCiXxtMfQliYgsg+cQM9oaxqMZVmVU9PTbFdvVklAWSrX3mGI4VC5PTRGEFJgxZZ4/P+XBg4fUr91mXDtSCqzXK3wMGFPR1A0hasLBlIP5jMePnrKNEd2MSuhIj+86XFVhKkPOkmKkldx/CKFY2bpCi8w4a9BaHPP86pyLxxDI1HWFczXGVbvr7Kp5uoJMB6hhgJZQ7CLSZCdQXm7pyJO64kD/tMI4/GSHjb+kyRp+vnsee52zLPLXCzd7RX/45g422b22n+PIu7/kuX7Ju/tyYcFKYVUm6ERUkawVOhtsNhhlS5q0vHlG592FkErhls9fPEfIIo4BRaKiOTjBzY/Rkwm6zeInUhmiTmS9YxXKBZLL4pyFX0pJR45JXYlpckk3yYqcNTlrUoSQB3GGJgbhxCpbtsJeIrp23U5KmJRJWpG0JikZwKSc0CqjTCRHT8oaxgeMDm9x9+vf5PD118njhuQqgUd8TwieGDo0CZIhpUzut/hWAnW7TrIZLxcrlsstISRiH8leQbCMxmNu3b/DN77xDWLKfPDhnD95/z22245q1DLuelabNV3rWXYd2xDRixWn5xfMD+bcunVLRDEMXB9FytKVJl3sTWPefX7RB5QVnrgpqkkxN1JEbYi+xyRTBsRWpOBcQQxG7zEETCmcOUOR0zuluHV8wNtvvcqz8+d8+7vfJGXNB+99yGazwYfA8sFTbt66g4+Zd77yLWYHB/TtlovnT6josbnHFh2rKg59aohW27vwMuIWnmK6VhxjuhIpyQxg+NXralOZa1ixHDAyM4nFS2M36NSF8rq3uOkhRcU4KicScmudFP2UUKYh48SvvZXfTylKXiiR2lXFwCyiUxHf5EQ0hjYHPn30nDfffJVkJcg45Fggwo4cNApDVWUOb8w4PT+n33q8z5hsCSFBkh2TSlK4Q8hU1ogtb4TGNfQxFvWsRRlDDoHGOLxfoRaeMBmxPJ8xmh0xcnUZ5CfJYyWR94InM4UfvQdTpOEHaggZzjvq8MuIDtd3IQqDknNNXxXl4cHSTyn2WsnQGygZsup6rdfi7gmFNQc/tWB/IVx9uOtyb6UnFGhIX8cJftbxhQv3X7r7f+d//8sNvtiexpQxzuEqy2y65CZ/xL2fnEunpktxyIKB89IXdbXa5QQpB34xLXh2q0O1nkaDNWu0UTgN4d6/g1KaabXYvcEajU6Cect9le4plX/Llu3a9hZ21EJQwiSQJ3d9KzxAL8iiERE8ctMcsq0OsBlCnwjakUcjbrz+Fne+9gvYoxOCdaQkvhApRfGtyGKMn6N0M6Hv6No16/WW1aaVEIasWC3XLJdrQhe4XCx2lpLWOqaTCZPJmPF4graWkBOPHz/lcrnEbju0s7R1R9v1pJDYbrdsL8TF8fnpKffv32c8HotqLKdd8drHurUW/5asMjkWEhBBBp1l91JOu6uLbw8Ogatu9UVYYcBUpXsHHyJ37tzltbfeZTyb8Xu//4c8ffqEs9NzUoZf/N73qJsRfr2h7XraZ6dUteP2vbucP/608O3z9e4q52uY5NW38xXGundceZ4I0+Ha7fMV8yZnEYvsv559vBwjEWhXu2/FMAw3xogCsHjKh5B2og2UQaliWhYiOQt8IWEXPdYKSyrFRAhlyc0ZTOZiseLjTx/y9luvkBPMZgckX6LPnEaZCiwcHhpOTo55/vQchSaW12StJcjUveyIAlWZ+Wiliw1EpimGVEaLbFwasUjo1vSnj/Epc+uVN8SnqBnJjrwMQvdhyi8EJrykUO+fT/vwid67Xl/EnvNn72p3fy97LLX3945U8QXu7+Uv4Wfc8HMw7mFH+kWOL1y4v3PjP+Q7N2qgfslPN8AH8OiDL3p3n3805c+Lx82/+/Lbv/g6f37c/6cf2tHXxzIEM2Mwitmd+9z6xrfQN27idYVCY5MiKPGQDkWIQIzFcrLD+45227LZbLi8XHF2eo62FefnCy4WS3LIbNstfQjUTc14NmV2OEdbi3GWW7dukrXQzIRbngW+0qIo67urAeRqteLJkyc457hx44ZYWu6ZUqVcIKfhgt7j0w4XuN6dUFf0wH0Xu4HlMWzz99kVA7Y+zA0i4lduTIV1mV//9b/H09Pn2MrhlOPVV1+hrhtef+01Ntstm82ai+dP2XYdo3HDpVG8dvcmy3ORmuvhhH/Bx2R/wDcc+9RG2C/QoHXeFdr9kOHh5yldxYldf02gijLSGIN1bvceKpTE2eWEijLIz1mKr4pDAo1h1IwQm9cyBI/S7YNg0hqB6QaYUWlx4Ty7WPKNZkJlJqyX58UjP7PebLBVJmGxVnHnzi26tmdxtgRd7bb8PkUIxQUyCAebktSSlEY72VUNiT0ZcFVN33tRnPYbNs8fcm4gxcDNV16nHk0JWQKD9V4Kzkupwj/l2IexXmwCPu/P9d9/yX0O/+o9OEWr0qD8l3PsIDvKX1qRy/P5onPLL5fy/l8fUAJT0YpcjTHjKXe+9i3crbtsrSMnhQsZFSKenpA8MXhSDETvJfmn7+n6VryNn53x4NFjlos1zWhC1wdCiBIEXIZHo9HoKq29YKbaWKaTCa+++prwwDtfktZ7Kq2x2u1M45VSLBYLFosF0+kUpRUhyZ5jwG+HrduwK9gpCAvNzu8gAwm+Ba51pEMhA3Y0tv0OaehOcxaVYV1XrLc9223Pr/3av8TT06c8evyQG4cnhD7y6NEjVpfnnNy8yeXZcwgdR5OGJ0+fcHJyzJMnT5hNGkK7LVhy3CvAn5O6wvWJ/n5R34l62BPkfKYwXKf7paLMjDGSQiRmXzws9E6KPSxiQr4xKO0Y/L210mDF3yQHgfVEczA4VcqFnEK5zAttSjYIim0fePLsggePnnHr+ACUI6seHxNt1zFyDfWowiURiZ2cHHN5viDkgNWGPgn0NQQg77B/VYRbRhbEYdgpQ17xHK8riwmibPVxS3v6BJUyTV1j7txHVyOxc86Srfl5rJCfVcxfVpg/73v7v4Oi0JC5/vNr9zF84vL9/b2B+jmYH194gVJlB3Vtl//Flo//unB/2UMpsrZEZ+j0iJvvfI3p3VdZaINH/E9UEivNlLxkEBbbx5wTwXes1yuWixWXixWnz884P7tgsVxjl1uUlqDRdivew9aKN8NoPJbQiq6TgV/bkZT4BB8dHfHs2XO2XYuNFqWTyJfzZ8OEvfdMphO0FXxzsN0Uuf8wNJKTKHOlemPofPIwYJBjuBAH2uHQrb5omDQcMSd0Jb7tIcFodIC1NSBe6MEHJpMp4/GI0+dPqSvDdFzhjMVVju/91b/C3/7bf5vbt29TOUcoHt1DOu9wwVwvyvmKt/8CDr1/xKiFW//Clvzqz3Wpu9Z6N7zNlCzPvsN3ndjiWkscAidy6eZthamciFBSEG56zqSkSlMwLHjDJkLtFh1tZVCfSQQBcWk9PH1+wcnx4c5mQmkteZdkNu2GGBV93zKbTbh58wZPn5wSYiSEHqcVtpQsXXZOxhb7W112XBpC6Hfnwc7+wGgUsmj5EGjJnBrJeZye3MHWI7LOO172T7+srt7X/e+9+HvXXBOV+kyDsPs9PSTe89L7E/+kcg6XP7xQyF9sf69BJ3+Kwr577GHQ+bLX+AXb/v+6cH/JQ2lDsk46pflNDt54g15LgKqOgZy9WNWmnhQDOQvNL4VAu1mxWa8JXrDvrpNEks1my3q1wbpIVTcYW7HZbglFEKOL85mxkne5bbf0XcA1NU1Tc//+fbbbFv/hhyi1pe16cszXuNcpJS4uLnZJ8NJNK7HfZeg4i8Ag7aF9ih22PeDa+9Lwobsc/j+IbvZlylfwArJgKEXoMr1P/Bf/4DcwVnPn3g0ODmalWkWO5gecPnvKxx+8z+F8zuRwjoqey9Nn3L97h8VqIwEO9Qjft5KSVDrifQhjf0cAXCvYuyHlbphoP5NZedVhiwpw3+nu2nmhirLXySKTc8b3nq33kKHSCmMc2iWU9wJ7JA+hI4e+4NsFn88DPq6lKy8hGbHv6WOP0uKeaayl85nT00tWq5bKZpytqGpHIrH1Hq0tPvYYCzlHbpwc8+Tpc7FlJkOSgaS1tmQ8XkFkve+plGU0btDG0IdI14q4J/osJk9aEwnkHPDrS5ZA1oqu90wOjxlNJzRN85ni+tJr60vAKD/rUEow+c8tr2XXAmWovNftDqyy/cXkWtH/kpDPi8eO1qn2OOVf8vj5Cndx1yJ+sUj53VGNoN/+XA8tEecGQv/TH+foLpw/hn7zkhsomBzC5uJqdW2mkpn1Oc8vpkxQClVV3H73HdJ4jA8JHTO6D6QsF1fGi7I0RCnU5QKWFB7DZrMhpUzbSqgrioIjQt97NttWlGfO4mOg8z2bdrtTBo6qEc5aZrNDBgKjj5GPP/pE0r37gE56V7SapqGua+m6i9mRLpQ2OQmvOhhSJscrbrNs7a8Xaq30tc76Cgq5flJrralrmYvEGOlTL+nZWfGPfuP7pKT41te/wcXiGZPxiM1yw2Kx4Pz5c7zvOZhNmM8m6CxipcXFKbPZhLPLy8IxLtTUwlB6UTg0FNiUJANwn6s8FKirheVK0LPf2cnrTPS9v6a+HLru/dd7hYlfdeTWWHTJQBQMOdF2W0LfkvwWQo8OffHEgUFNKI8XcVrk8llnYTpoJd7hGYwyLFcbLpcrbh4f4KNH50w1ctTacLla4XtPVVlS1KiRY3Ywo31+hrWO/dKWgRgixgmmXVeuFHTB14f3LBQvmACEAvuoFKmsot8uuXz2mPW2o7o4Y37zNjdv3mI8Hn8ODv1CYs6fYfH+acfLoJdrb8RLbvtn8txUec0DdPSnvJufr3C/8g2wFbz/W1/iESv4pb8Gv/03wXd/+se+/bYU5X/yn7785+M5/DP/PYhBFph/+O/A5vKF5/91+HP/bfib/yd5LievwT//r8M/+Hfg0Z+89G6TrbE37nHn3bdRN2/Tao2tHYREpRXeS1CCjx0pJKKPeN8JvJABDNvtmqqqURuPVhaFpM1npQgxsdluxXTKNMQkXGWlNb6YABlrmM1njMcTDo/mbNuOW7duEVNis20JT57Q5U4Kk5dw2WGo5Av10CkwBhmiGWGS7KANLTamaRBR7WT0CrQMQ6XAyHsyDCRt2RXsGy3tb2vFldCgm4bl5SXTw0PefusdHj/6lG67oFufE2Nmcblk1NTcv3sb37c4K5KenBWh6zg4vIFVhr7zNFWD0o6QPLoM1Qa/jAG3zHko6FeCK+myC4yShmLfE8PwNcBVR56SDBbJqnhygNKaytWMx2NRMlZV4b9fFXVbFa+RJJixTpnet2w2K/p2S+i2qNTTFBjEGEPKEe/zLjg2RFm01OA5nhRi9Zql+82RpqlJOVFZx8F8Shd6LlaXxCi4c/CZLogv/tHREaenF6QinIwq4bKcCzFnjNbUdVUSYGxxeJTsRq0NKkrKE0rhqoqu7TBKVJOVSuTQktZndKHjMsO0GVFXheetFJB2JnU799CX7GB2ytGfUjA/7+e7ofML9ylfXL9t2VC+9D6u/d5LjpdBPD/1uaKuPa+X4f5f5Pj5CvdkDq9+Ew5vw49/ExbPwDXwlb8AOcKDH8HlEymIr38bPvp9uc3xfdAWZgcQOhjN4P7XpHj++Delg7/xKrzxHXj2ETx+D4KHt39ZOuIf/QP5ncPb0nUf3YOzh/KYw/HOn4MnP4E/+LvwC38F3vlV+P3/ZO+5H8Kf+9dkIRmOqoF2xTWd7gvH9NZ9pt/9izCdEJ3GkfBdS99viP1WnqcPqBBIMeD7XixKlXBlUZaqnrJae0ICbSqUrsi5J0RIyrPt1igjaelKOzJS0EOMaGs4PDpkdjDDVTXWGWpqQpJUlVt3bnN6cS5m9GR8jPQh4PtATBLCsN32YherM9QaYpAEEa0g65IoPuwAMllngfw0JJVINpO1Y0gVcuZq6m9KGvqLx9DVrtvIN37pV/j0yX/B/NYJSScUgVdu32ZSW7LWfPDRhxijaWrDdHwAhfKXQ8RkCF3PfDLl44dPqVzNZDym6xOVUSgVQRf9QCnilNcSsxg05DLOl6I8SPLFY71tt/gg3XGMCd9LUntMkZBCoY9qUoLNZst22+Oco2pGTA5mTKdTRk3DuK5omprRzj8miQ4gebbbNanvUKFHp0gu9sFGq6KkLHMElalcJWpPIxj7kKziNGgd0caD8mzaFUeHN6ms8MZj61HUTMYTUr8lplaS4bXh8OCAyWjCZtNJI0Cg91E68MHLxWoUGVPi6RLgo8cVI66dz03bQQgoKwk0OQbo19i4pd8sUFXD5ZOHGG0YHx7jmhoKrFVGc1cQxQuF8qcpH4djv7hf22Wl/JmkeTVAE8Be37H7//7/ZPf12cf6eY+UMyr//OS3n69wV2MYHcDlU/iVfxV+52/BN/+yFOuD2/Dat+AH/zF885+Hj/5A/v/BD2TVfeVr8Mo34bf/A/gr/4Z07VUD3/1X4OM/lGL70R/I/f7gP4L5Hfm9zQLe+C7k0kn/M/99OHsAZ59ef26zY/j494EsP3/zu1c/0xZ+9V+DH38f3vouu4ilh38CX/2LP/Ulu+mUMBqL4ZZO+CgKsxTFpEkroWqJSCjhgygzE5EY5UIM8WorP55MqJsl8XxJVtC3nr73VNVIcM5S8Puu30EeBwcHNCMZVm62Lav1BpSRwm4Ms+mMi/NLeh/wPhCCbPN9+f+mbUm6qBqLs521oj6tnOREpsGaVYmSTtKMpAARFUpHEZKoq5NwGPIopXZsCuAadEHO3Lt7h8P5AZ98/BGLxSXvvPMOq7OnxBCIOXHv9h2UElhqGIQKbVGD0XQhUk8mPH72lPHBAQfzOXSaRMSQihpWumRdhlQ+eHkNSvD8ASaRKDNZmHzwZZHzhBDpymcRYkJpRd1IupMxDrJg1j5csm1bNm3H2eVlMbSyzMYjxqOGg9mM6XSCqwzGKOFM917OmSRiMtD4JEM+Y3Kh/2liTCSTsK7QK5HPRBJ/pL9QKConxk4xJWKUAXbdNJw0Ey4XS9ry2Q/eMqNRxcnNEz755KF8LkY42+IyWMncI8mDdX2PMoa+76mqareDghKFV95jbRQZ8aEZjRvZlXSBsLpgEaSharuWG3fu4upaGu3PGf4N/75oAvaZ44Xh8XBbtcOsudbZfpljXwvwZw3fvLgT+NMcP1/hjl4K8Xvfh8M70jWPDuA3/135/3f/Fbj7Fem83/s+GAv1BOa34J/9H8Lf+3/Adgm+hfd/B7o1/Nr/DFACVbz3fbj3FemKT16D//z/CduFdPWvfxu+9Vfg/AH81r/3WeJ66MCN5Ot6fB2WufO2LBzHd2Xx+MV/Gb7/78NesOnnHcEacl2TY8Jvt/jc431Lzkkm/kmgiZQzvY/0XrpZUFR1UawpTTOeMPaJJ08vyCWPs/ceHzqUsWK7OSg4lSbExHg84ejoBpPpDGMs68WSbduxWm9kgQC63rNte1LKAov0YnK/7Xp8L0kker3ZOdnFcuFZ64rcW+P2VK+7TqbQTBTiTy7G/iIoMVFMoFDi4qezCLTEbKp0ObmE/ebM93/zH/LJxx+hUqZ2kkBunaNbbVBKClbOCWMrcvFDQUlo7gefPuCDjz9h20cSmj5GUbZZje9aYup35k05ZXLWOyqjMpqU087l0XtP23e7gWbb9QQfaduenBVKO+ZHc1lc65qqdpALZz5GYkyMxlMePHjIarvdw8wDse9Yrwyr5YKmaXC1Y9Q0WC3cD1JCpbibkYWQ0THjrJK8VZ13VMyBsjlYFqvyPe+LgVVdY52j7zp0ZWmahmFHMZlMCN2Gvg/kJLTOGDPHN464uFzSrjfknKmqGl2gOoFlREBjzNVuCaSIDWpSQMRciP1xLP4nTms6H2mswVm4XD5nEXpS8DirmZ/cxtR18c/fcTp2979fhH9al/vTqIJflpT9Gez9p/zsi/z+/vEZCuRLvvdlj59/OHnyGtx8HY7uwCd/JEXx3lfh4KYU2PNHUmSffwwnr8KzjwWO+K2/Cb/wa7A8lWJ/6w1Awepc4JE3fhFOPhIc+/F7MkB87VuwfA6j+RW2/vh9+M6/LJh52oNKPv0hvPurcvtXf0Fue/MNgVge/Rj+3f+DfP3P/Y/hn/xnV0V7MJf63HfM0qaIS+KVEn1LDJ2E2irpQvoY6EMgZrn4YvEC2Ww7tpstTTMixETbSyRYPR7L/9sWNIwnE0bjCQrpkIyrQGu0q6iahs4HNpuO07MLlqsVm23LYrVi23b4EPExljDjjA+RbdvRdRLdtd22ZK1IRWxSx1B8n70MnbIEBQ881oEmKNhkGZ7tdhSKyoFWCWvl/dA6Q8iEFAgp74y7UoxkJbSyH/z293l+KgtWfXxICOKfjRJKoHhjGHwvis2YFY8eP+bH773P+WpB5wPZVKA0T54943u/9IucP+9ZbC5lWD1cFFLh6H2PqwQvTnnoWiVyLhZxTAhBxC+m5vB4znQyYzqdUVW1dNh7BSaX3VTXdbiqwYfE5uOPruKuyqmitSbEyHq9Ji4TVSlWRimsUVIcixePeNCbMmjOKCcGaxkl50/OYmOvBs9weT5KSwe83W5R0eF7KbS2qghJFvzFckPX9uKf7TMZy2RywPzwgL5tybHsborrYgiRunKEFNFc+bLvi6m6ThqhXAuuL0NZL4tljDTO4fseF1smKrJanbEs6mPnKkaHN1BVhc7X1agvHj8Nvx7Oy88dHO5BI5/BvPcv8bz/K7vfuMKjfwZk8+L3XlaUd8yUvef28xw/X+H+yT8GawUK+YNfF0x5dQbf/hfl5z/4j6VIAnzrX4APflcK+T/6f0sxXp4K86PbSKFePIfv/3vSeavyOx/+AB78UPDxb/0VWSh+7/8DZHj+kWDb974Ktr7OHHn4I8Gxv/7PSff+4Idw911ZTKKHdQvbFfzm35DFYjj++D+TYv85R1aIjaUO9Jst0XekJKksPiZClILVx7jrlNtty3bb4ftQwmQd6+IC2BUstfcelBazLudAa1EWWjH4r5sx1kkCz5Onz0gxs7hcsFiuWK7XtF3P+cUl4/EUayv6ENn2PZu2ZdO2bLctvQ+0XU8k04e+WLyKyX1VVWIuFCNNXYvniyq84R0zI++itFKyxMFxrAhFaleRlRQclaS4h5iwcQhrgMl4RPKdGC0ZQ9+36GwFFogyIEs5Cy3bOp6eX/D+Bx/y4OEj6ZxVIpXoDG0sTx494nd/5x9z6+SIdtti9dVFo7UWrD8mjKvoW8+Abgo/2lBVEhhsXUUznlLX40JpNGhV4r6KnFow86uFvWrGGOt4dnrKwXyO1prtdovvO7Qu1rEpFU6xwvcRT8AaQ7DCxjAadFSYqHA2U1nJQTVakax481SDJa020qXusVbqusZaQ991HM2m1O7KLMsYI9i1q9huO9nJlM+09z2T2ZjTUyMOg2ii96WjFyuIvg+YdD202Hu/K1RDQbfWYK0h+B6rtUQLGvHj8esVRmnGStNuLtmcGhaTKdpYzMFBsQH4/I71ZXj3TviVM2bv96442rsbvrwFy0L526/iL+Lk14GWn328+DxffL5XN2Q3OP95jp+vcC+ewm//h4IRD93u+hx+428g7055wh/+AD7+g6vbPPyR/Hv+UKhPF48F616dXXW+H/6eYN37XfQ//ltIoSi3GQrup//ks88tJ/iTfyTDzuH2w+MORwoC4+wfTz/4qS9Zp0ROPcvtkthvIAeslmTEEKQAd10HSkuMU4i0vWfbdfI0fOSsu+D07JzLywXL5ZqcJZ3aVjWusuV3E1UlLA3rHK6qAM3l5YLzi0sqV8t9LBasty2nZxfEmDg9u+RycclysWK9XnN5uWC13rJZb3fDuG3X0njxuq5rKeCj0Yg6JIzp6druati4C0sQvwxjZRfgSicdQmTUNLvAWAr8opTCFTqZ90HUmr4MAVOgcppt29FuNphRQ4yB2lkZAubMpu14/8OPePDoKctNK1JvbcXiVxkZEmZhjHzw/vvU6k000LNn95oiPoj/ek5iEuWqiqqqdzuBweVPaUNCo0wZ0GUFe8nxKuuSplMYHkoKqqsqRuNHHB/fYDIZY4zh8uKcy/NyLisxjhJYyUg9KCKVjDgXZq0FU/c9lVVoaipr5fERRaUUhuInwxA2ADdPbvLqq69h6em6FpWFux+6DuNUiXQT2KkZ1Sht8CHT9oHD4zm+Dzz64BPZRaAKjz4XXrmEKriCsQ9QkDGGuq7x3lPVVXExzMJQ0jKsJklKuzOGtvOMG4dVme12ybOPP8D7yI17rzA5PNwl/Xxep/qnOkrRfimrBK6KN8NLvhqM/mkf88o+4bM8/z/r489GgLNfXOHlWPGLt9m/7W/9+0LVe/H3PnO/L34UX+D4Arj1lzpCILZbun4jKda+A5RwrXux8jRWuhhhg0SxyzSGejTCWsfFxSVd39P7wLbdSpqOsaTC75TOVwZN1lLiyCq6vqc9bem6jnbb8+z5KYvlksvliidPnpGBZ89POTs7F+gBxXbbEnwUbJ3CFCGz3rZARq/WGCsXogQ0S8r3zrCrdHWj0ahwmsVG1RTKX11VTMYTxk2DDzUxJpFwA1VfUdc1rnLEXvIfjYHbN0949PSU5WpDzmW3ERNdCqw3G84uF/zkw484v1zRh0RAoBOlNabE06WitNQps12tOX36jJsnN3H1iNFoXBSNmrpuQEHlqt19DGk51+ciiqQHfq0468nFV4p3VmiMBCBk8cBumhpU4uTkJt57mqZhMp1y585tFudnfPLJx/i+k6FrMrvUqJQQOTklIFhpSQWPXs4JDU1liMmSEmVnk3cdtwxYcxngRhaLS04OJzR1RV0Zmqbh/HKBjy1ZSfqPUhalNL0XyEp8TzKvv/E6uRWLgaLHgSxsJAXFj31vARverdJpayMMjJQixiictjvI0GpNSpJSZcg4BSEF2tUl548/xcfILa2ZzmZFJDa45F0V1P3jp2LN6npl+FmVIrOnrOVnwyE/6/gvs2jDf1WUk6uz/18/gy985JyI0WO1IcZBNivbNq0gROkqrTVsNi1aO2YHNb4X/vRiueb56RnrTUvoI30XWG+24phHhiSdT8qR1vdgNE3M2KrBx8xiseT58+dcXCxp256z8zOePXvOZtvy9MkTfBCvEzJF4aipR44qXXUVMSeSEj90yuBxu9lgtQQEDyGyRmvqylHXDU1dU7kKYw3GlVg0BMNe1kumsxmT8YR62zKdzrDW0nYB1tuCWStee/U1bt06ISs4/bt/j6aOeB+p6wafPafnl3zy8CGPHj+m6wI+JpSyhUEhUm6Vi7eKWAOWQY9mufH8s9/8RdmhWCfdv1IIA1yGVTHmwnph97vDF5lCpGBgFOwniBeoQCcIYmkgaTuWuq65e+8Nlusto1HNbDZjPGq4cXILN5rw6MFDMpkUwfeevu8Q2qrgvRphmggTU+xz+xDZdp5xU+E0BRcfsPOEskMnnlmvWlIYaI+KHBWb5RajLM46bF1jTMXlxQXbzZoUAmgH2pK05fDuq9zhgAdnK1S/xsYeZzQpBXyMkBKjqhL7VCSWLsWEzmC1BR8lyFkrQu8xxu2G2jFn+hioRg3GiCpVp8BUKfrlKZsc2Uyn4D366Aa6qgW2JmOIpHwVgwdls1J81Q1qZw71Iu1vd/thNDN8pvlq/qD2aIifcRbMmSHVdIDI4Drr5WWeK1/oyMM59wKjZsdi+WKLxn81Cvf/Hx3uvd9mdv6wsEdk6wzlwy6DruFDDD7tUoG8F5qZ9/7KmIhMP+vxIwk32H2UBWPT5lxEHMHRPHofax2979lutvTJoxvN5nDLptqggP71g3K6Fex5+Pdq3rL79r4bWioYtAK6viuRbGVCL6DcNf4rGrQ1ZYuZ0LpH63OsW0p6d3W+Y2oIQwSm0ynzfIk7Fdvf79w5YzvfEmPAuSXe96zHG7ZHmvi1O/K8BiENlIHcSy6Q8n9rLa8dfHhFB8vDhSav4WqSn1/81c8/1Atf5KvPVzHkSmqiS6y+EUFtcK4vgbiaMFesXp/LhV+gmxgTfYj8337Y8v55W3DzgMpRdlvaknNg03ZMGkfjGtk06oF/ISIjZTRGG2JEEnOUou88SifqqkYZaL2XeYlNJbTXUFUVrc8YN6GandAc3eb2+B7jP3mP5YMPUTHhhsFneb+DD5JVmaVwhiC7i5wThIhFM27GtLTF/kDTFXvZrA0ETdt7yWM1DqcSqg/06wuefPgednzAK299hYOTmyhnZeifJBplKGYD6rz7RAtWPMjVP4MZlyI9RL6VF7Nzmb1WIwfcee935Q6uqzrh52eYlNPo+u3Lg+5TEH/W8YULd1Ka8+YGi9VauMEFArh6YPGMrmrheqYYsUYzncgWLnjPer2W7MCy4ISiXjNWPB5m0yl919F2W3IIqBhxRlKpQ/cKCkXVPGA4qcrrvSoyuz/7q23Z/g5vkpZswpSFoF9P57jxFIDQ98VTWe2m1RpVFIS5pIMk1PkTCXnNCTsManIugys5YkqYKGySlBMmRKwPuBiwxpJ0wqeAV55kM8LYUMVilWIMr4ghoqOGrtCyvEcHz0RbUDBGoSaD+ZHdO8Gk2O1HyO0PZIaeQnYQqUizDUpNC+i3VyTVcOnI16kMhmKMHB7e4NatW1RVJbdXQltbLpdsNhuG8N2cAmxPATg8OuL2K0d88ska7yNKRVSjuOx6mF3ZqA5b83ztLHt54QaYtGdMZwe77+2655f/5p/uyJkh8m54j7XTcDwq+DdIulCCSgI2vPcSuKvk919zLWsz5v/8w0jfd/R9i/etmDiVnYIPHatNK9iwNsRc+v7ymYbgMdoK1NT3dJ3ksUY0i8WSkCLjgylKa5w1TMYTrK1I2ZCiRo8PGR/cwjZTZqOKe6+8wnvPH+H7NTokdKEjGivXctd1u5zOYVgpHjr6Mza+Q3Oiih9OLBCQsW4XGK4VpL5le/YUtV6xms8ZjRvMZAbOgql2DK8/7RhPvfD1F//8i1vJS+CPPwsY5Ke9ni/6Wr9w4e7dmP/o9b/G3/kHv8lPPvyY1ban8xBzxhlFrTW37t7l3iv3UUqzWlxyNBvxF3/xV/jaO69z9vQJv/07v8v5YkUXMm2fuFisCTlzMK/56htv8Oe++z1+8v6PefToIyrb0T18wM3KUpmWi5/8bzHacv9r/ztUTlhVRjdZmAjWGLSCylpR8iUJHNbakdFkrYlGk11Fq2B8OGd88w6vfPsvkKeHrDct77//IbPjY0azGfV4hHMWlRLkROUMVWVoNyuUSmw2awl4LRP64IOkigdP1/eSndhLOMJmvWW1WnFxfsl22zGdTrm4uORsfcnDR4/our6oKQw+yoVorCNmuLy8wBhYLpZ0Xcfl4pK2bZnNDhkV/wc9BAAMnUMp/NZYSexJpXiXibmk3Ujo7vnpGXVV8eq9+8QYBQ6JkuUZg9jK5lxUh6VobUIk5MQrr7zCv/XX/5fU3/gGrtjOohSx95yePucPfv8PePr0FFDFJtYQc+Iv/+W/zI0bx/y//q//F37zN/4RXd8ym035/vc/4emzU7QxxFgsZMuFXhQbEvCQBzCW4lYoC8ZXvvo1/qV/+S+UM1aTU4FXKPaon5N/uDvydcXs9c4pIyIkCcIYQiGauqGpGxSGtm3p+07mGXW921IvVguWy3OMBpsD/8eTP2Iyabh9b0bfdWw2a9rtktVmw7bdklMk5chy3VI7Q32jJlJUqUogAluk8cH3OCePl2Mk9bJAGGMkMi4GYbmYCh8gmopmfoQZHWHGh3gsTVXx5le+wumjTznrOzQeZ4TxkrynMvZa8RoEOOPRWBKkyFxcXBBCYDQaEULAOSfU2K4TYzN7RStEa1KM1NrgbKZPWy4efYg1iumN24wOjrB1vQtr+6IeJtdw6p/ysy9yfB4r5It23vvP+WWP/dOUoF/k+FJQiXOuWIuKm9lV55XRhVKmtMF7Tx88IVRFMmtwzYhmNqM7u2S96dl2kbbri7eFRRuH0hbXjDB1wxv3XuNx15I3S6FlIXSynFJJepckc/E6NjuhR4iDWEEwSxM8ylR0WdGrhtHxPe6+9S4nr71FNpb3fvzHPLtY8Pj0nNff+Qq3ZhOcBZc9OiZCUpIAokSRJhetJyURLUCiMSO8ET/s3ovabtt2bDZecLqUqaoG61pU51mtNmhtUdoSYiYrTQiZRCTESNsH2uWa5XLJYrGk73vW6zWQaZoR8/kR48kUaws3eU+Z+GKgbM7sMF+lxAa27zqM0zx5/JjpeMLJ8Q1SSIzqhuA9fVekzUbvunbve3wS+06MZTo/4H/zb//bfO1rX5NIK6S467JrmE5n/Mqv/jk+/fQhDx88kuFrocahFNZV/Nqv/Yv87u/+Lsv1gm3b8u5XvsLDx/95yZIcmBfDdrVslBU76CGlhDNmd5U+efoMHxNVVUsMm5GIOorD3lVW0tWOg73/sysV5bjGL867PxpNVsUYDE3Mol6sG0fG4YPHR4WzDmUUk4MjGT6mQKUEPqtHE45u3CZ6T9e3tO2a0XLBcrViu1nTbRW5z6w2PdNp6Va1ER+ZgsjLep3wfU8IFaqEHSilsW7geyuqeoK2DWpck+yU5vAmG6/JtkFVDdkYDm7c5N1vfpsfXF4QlhcYolA2y3uwbyY2GI1VVYUziiG8GaDrup1bZN/3xOhleBkDrqoJpRNPOWONIvsNJiv8IvHg/Y7J5SWzm/c4uXufpq6w+roR08uGiC/ner/8d75QWVRqR4vcd5n87M1ezkB5cUD5YrG/gvPk+0Py1Oc9zsuOLxUWHEs4rnB507UgXevsHp4rTmfaCKZW1TWHJzc4uXmLH733Iadn52y7SAiZo+MbTMYTZtMp88NDDtfHnF4+5/7rr7F98pjNpxuBPcqT0Fm6DaMVVpdQ4CEqLWUwlqAtyllaxHve2IrJyW1eefNdxnde5cnzBX/8o4/40R/9EawfU00mfPU73+P+228ILU/DyEqHpl0jIpDQCy8WwRSbpmaIJQvBiwmPj+SskKABXRpBRdf35AzeB4x22MrS96EIWTI+JGGR5EzXe07Pznj69BnL5ZIrBSOMx2OOjo6o61oWur2Lar9gDyfFEGgwfD3Ya47qhgcffcx0POHenbuoLHmSoe/LALKi37a7zzsiQ6bOi/z56PCQ/8n/9N/g61/7JsbJ9jlEMWAaNramcI9ff/11bt28Td/39L0XDN0Kfezdd9/h9ddfZ71Z7nYCVV0XV7zhxC6AR3ltsagNM1eDowG3XCwWXF4uuHPnHs5pUhxMpUCUl6kUPbWbI+whQJBf8FjZMSkK9sbV1n2oFVnLa1bGUlktKs5eF1OqjNVCGZzMDun7jirLPKOqGiazI1IMNL5nEqZM50cslkvOz85YLyx+a8ihZbXtqEcNjbFkArpMKhWJ2gnTZ7PZkEMkewlmHk3GTOYHKGXw2TBqDpjObpDclG3QdEE428ZYkgbTjLj/1jt8+OMf83S7IecekPnNkARkyvXsvRcJfF2RIsW+OF8rPpvNBigCI0qsW1EXKy00Qa2VpN6XWcbWe1Y541yNP5hjGINzn3FklH9LV/s59Wq31v6solb+/UzBVNfl9jsBzd6f4bhm6VBum/Zg0/3bDr+7bw/8ZfDz4fjihTtnca3rveCYWqMSDB/uICHebrdst1tiStRVxWx2wGx+QAiB8WwmsU5VhUsBcmI6mXBwMGd2cMioZClODmZMDg5oJmPWWtzQBpzVWnNtyi7S3IwxDqUdPim8tgRlcdMpR3fvMzs6RlnL+XLJH/6nf4dnnz7EJcWtgwPGh3NuvfUOt15/i05ZVFWLND32+L6nmQh+t+17FJHRaAQk+q5Fa5EQd51Yy45Gox1kknPGGsdms6VtO7bblovzS7wPNM2I3nvWazE06nxP1wd6Hzg9PePTBw/ECCpljJGTdjQecfPkNk3TyECsXCgDr/bFwIJ9n4ecM3VdE0KgrmseffIpB5MZJycnpBDKAiyQQyrueNpoYoqiAk2RNnqy0bzy2iv8r/6t/zW/9Cu/IgtZ8FfdvhIGx3AyKqWx1jCZTLDWMR7LjGHw3hiPx/zVv/ov8d57P6LtWrGc7UWub63QIrW6mmcoJfBP37ZMxhM5J9dr2X0ZQwyRTx8+4pXX3kBroWTGkHbY8zCRGYrx0JFeXYj6pRfSMDcZ2CVaGbSKuwWVcj/aGJyTAIsQ/G5WYoyhNiLZtzmgkuw4xmYmToXBk/KYxnvq0ZTxZMr584qL56JF6/qetvfMUCJYKfQ7a2F2MGUymTBtHN22BR+IIRJVpus7dFWRzIjm8BZucszlNtLFSMJgUoIcUbYiRUM1nnJ0+y5PH3xM9L0UWOdw2uzUkdvtVnY6zhG8x1ZOrGqBpml2GLfwvHuBM42h9x5XOTHASvL8M+I3blWSxigr+tUFF08fUDU1h7fuwmR6zeP9xZq0/++XO4adCzs64LUuWV8V4f3OeDgfdlqBz4FUhmMo0HAVNjL8ntZ6B7sNNgJftHh/caikFOYco3S8KokIAJn+d11P225x60pSWlTaTd5lQBXRSlM3DZPJFK09G7qd10Ld1NhKQkl979luthIe4Bw2iPOYVkq28HtUMKzgmEJvqjDNiObgkMmtm4yPjnm2avmTP/mA1flTwvKcm43ha0cNJ3VFDh3x+D6377xCQKNdQ3YNXU5EnxjXI0AuQjdMy7uO4DuUEs+OGIQj3XfiA7JcrYtKMrJYrOi6nhhFIrxareg6vzN6GjxG1ust623L5eWCx0+esm273XtHKUqTyVT8NNqWuq7p+p7JdPKZ7eJwkgxdiuQWiuJNa82jB+LUduf27d2EnpwJ5eITuGmv0w6epBXaOepRw//83/w3+YVvf6eYUAmdUWmFsXbnMJiLmEIVs6pBsGHKBbxeb3j8+DHGGO7ff4X/xn/zr/F7v/cD/t2/8TfEL6XsZGSQnFCYHYvA+57bd27zlXe/Qk6J9378Hk8fP5HnrjU/ef99fuVXfhWlTEllB20i3gdi2C/IAgMNfuNqb9F5WXSZ/N5ATigUw9K0DCwHXXyrY9TkrMuuIO8WnKpSuNxDJz4vzjUC+USPUgkfAq4J1HXDqHJMRzWnTx+wWpyx7QN9SjS12BEoDM4qDmZTqqoCMs6W8GKt6MtcI6FJpmbdZ8Zjw2g2o2dL3SiMgqauqKYTWqXZdoH7r73Jw5/8mO6sw2hJa69rUddqrVmv10V4Fdi2WXa9BToZClvTNIQQSCngtCmNXo1zNTFlsoYcC2sD8L7HOEdtDFpDu7zgyUcfEBIc3LjJwXxOMyq+QwPxoFDqdk0C7Ab7w3k8sEOuQy17eoah0GaudcgAMQY5H0oohyrPNYZQBtQC26bBE4e8E6Hth28P9zsajZhMJlfnU+m6LxcLLs4v6PqSMJQz3/vVf+FnluMvXriVONON64YKjU/go7QxQcHGeyZdz7TqqGPCaHBao42FbCT8dr0Vj+rkifR0ccvF5pyj1Yi239L5Fr9e0z095ZnVrJ48xWWF0bJSqZyxoS8XkCVng8+WraoxzSE3XnkTVU9oQ8+T1ZrzD3+X5ScfM1GJr905YXz7iMrKMLNHwWyOevUNwvEx0Ri08pgB2iBSNWNS1+L7waAqM3gtdF2LUtCHjhDjLrGm94G+j7RDBiQKV9Wk1ZaYMz54uktPHyIhK1Zbz7PTS87PL1gsV7TbXgqKdTuWhqsb6tGYrKAeCQ2r7bbUjQzATHFvu4oPs6SQMJUVTFFlnDNcPDtFec/rr76BM5qubXcYdihsl5ADWCWqzyGLMCqauuZf/Wv/Lf7Cr/x5bGUxVpfh5eC1IZaj1hhUVZOLh3OMqXTNkqe4XK759OFDnjx9ivcyK2maOXfuvkGIBa/WmRC3NK4p7oUVOUtRrYzi7q1jaicX02uv3ubi7Dk+iKrz9OkTNqslN27clPmCUlirSVnsBwYjLaWGPE4p3sL+EWhGiRr9evej9tgtuiTVg0TTaaGvGTRis2LRWRg7uWDsRskgTkehXSqtMcVgSxULVe0SVYykumbc1IyaMa4a8/z5Iy4vn7LuFOOmxigJN9AqUjnHzZMTcuywyeO3a2FvBVDNhMmNe8xuvUbUFa331CZweDDGe4lMUwpMjKSY6THM7rzCwd37nG8vcLQoLylOXTdE2IFxroR/GHJO4ruiFSmKlmEybthstlgzhuhRRuT6fQhAIsdA8JHshzg9wb+VUtSVQXctcfGM9SND8mJOdXhbXAUrJVFrbiiO3qOMvfpsclF45rgzE0tD6pEC30nI8eJyQbeUVPL1asXF2dkuIEIpVczgirOk9wWauSrMMQZ2IRw5laIdd+ZjIRSzsRConOPtd97C1RXamh1K13WeZ2fnfPjhxzx89ITNRnbgf/1/9L/4syvcWmsO5ofYUU3UmWTLmZzkBNVK07iKcd0gZ03GWVdYARkfejbbNdt2Q9dtxefYd6wXlywX0zJZX7NZLlidPedHzz7F9htOJs3O7xkgGYuyFVFVYBrMZMKtV+6jxnM22fHeh5/w+NFDahO5OZ9x97WvcDiqcToRsyfUFbGqyLbi4PY9xq+8TrRiiVqpjO+3xBBoRg3ei8G9NfVu8eraFu99WbEDTdOwWq3IZFEphohzNev1FqUMh4cH5AxnRZLe+1D43pLS/fjxUx48eMRmsyVnxHpTidwhIxj1bDpjPB6X7lDeh8lkcq2bHjqitm2pKwQiIBfpvGV5eUH0njfvvyIdWRm07lgm6Srwdwj0TUWyTcp87xe/x1//6/+DMoDeZ7HsT9CHblVocuQowQbFWrXvOy6Lv0oIERChRwiBmzdv86u/+uf5T379b5GzJqUoM8XiTKeV4PQHB2NGTU3bbkSOXdWCtSZPiomgPD95/z1u3rwtzBlj0UYYO7v8zL1qfOVLsV+oNfs1e+8qYEdPUyX6bSDE77pzYcIkleTr3fyhdPeFuTLsqMQZUhgjOScwkZwtzlgq63Cuopk01M8cm+UCTI01ohhNueXs7JLFasONwwkOx8HBlHHbc7bxBDvFTY9ZtZ5EZDavGI9HpCwOfwOdL3pPCOJjM3KOb337F/nB2UP86aeMnCNFCWzIWSiCIQSsdfLZkjFm2GGBc7YMLh3B91SuEdOzXBwbdx1y3r1nVVWhlab3gZS2GDQaz/rsCb7oJerJGFedkLMlZpmvbZZLNtut+NykRM5KMPckDVbKYu/rQyh2BQn9fIoOt/nhH/+IsJmQ81/iww8/4uPuj0vRlefqk8yWpIGRc3T4M0AbIUaC97t/fbjy349xsO6NnNy4wcH8gKPDIyrnxNclCrljvd7y6YOHvPf+Bzx/fsZi9bKkrs8eXwIqgRAzXiVCjdh4AiYpdFQ0zjFpGpq6oisxU9LJSFfSx44+dOScaKoanQ3BBQyG2Hu6TUvfbtmuF3TrBe3ylDuzhsbWWEr9UAY/ntPrGj05ZHZD1GkLBTE5qskRX/nuff7irx1x0FiMgbqa4HTxQlYR7QwUI6P1Zk3IXmhiRhO8Jyto6hqrjURMeQ8577aCQz6hYPqBrgsy/CqYafCR1WpNSpnee2aV4+z0nG3X7Vz7UFK0LxeXPH78mPV6c21bLmKeuJsljMbj0k2zO/mbZrTbjnVdt+POtm0LQN8FZgczrNJ0my1d23L39m1cVRFDpC1+JHC1TRwMhJRWRcEXZPE5PuZf++/+dxiPJlJoytZ0YBoMwypgt4AI7n6VMiNwWicmTKWTjyHiS9GIMfLP/qW/xB//8A/49MFHKFIZrhopwFYK7AA9xSS/S5YhaM5i0pVy5oc//CHf/NZ3xLO8zAAGFgRwzZb06hgw7wFu+qyRvnx0RSdAJmsrW/6sdwMu59xn4tOGP0YbVL6aPQweMDusPRvACvfFpV1cmKkUdWN59ughPkTcdIqOCh2hjYqL5Zaqctw8PiQCs9v3mNUz1HhOGx0hGaq6ZjydkhK0bUvXd2SlSTHsfFEqJwPIV197naevvcFPzp/QRY8qXvPGGKwSzxbjHJErdk+M8coJsrAklJZQDU1GJYg6k31f8F2hhgKFHSWDTMHuxeK41obu8hRjFevzObPZDFNVog71PU+fn/L02VMWlwv6Puy8yL0XjUkk7jpmH+T6eKs74TX/Ln/n7/99dH/Id9K/zm/9zj/mifp7u+s6xlj45uyuqeE1xhjFZriw3IbjqusuA2wtUI7Kibbt6L0XOE2pncrVOUczamiahqpcN3/mGHfOmb7tSLFn1Giccfgu0caOmGBsHbW1KE1RFAa6vmW9WnJxUbNYXhBCz2TUUNmKtWqJXjyaVUaEN5uWrm05PDwgqo7xyOIq8T5AaZSpsbdeg2ZGHs1p7r7Cnf8vdX/ya1mWpflhv92c5t77OuvNGzNvw5uMvmFlRGVmVZGZVcXMUqlEQIAoQBppwIFmFPRfCBporpEAARIgDUhQFKkqQpBYRTKL2UXjER4e4b319trbnG43Gqy9zz33mbmHO5AFFY/j+bP33m3OPWfvtdf+1re+76WXuXb9OpgCpSvpX3AOi0cFz4ClVQZtkraPloJf0zesVIeJEph14r1mjqw1hr7t8ENHmSaj956+73ey02HwScxpSdcOLJcrmqZl0zT0LtA/fMzy4oLNpqXv85ZLaFP3791nvZbqe876tpNdtt3TwqPoQ1ici0m1T+5NXddjE0RZlsLHrkraTYP3nrOTp7z84gu4fqDV7WjtlSdZnmhjscQFXPC4wVPOSr75rW/z5ptvoYwRUwGiwGAp884ZyNT1XCmNtyFl9ZphcKxWK1arNX3ncIN0kwYfiUHhhkBVzvmTP/lH/F/+r/9nNpsVMYhQVecGFAJxtV3PydkZV69dAeVZrleS8WSqYQg8ePCA+/fv8/Kdu2KagdRZ8rWcjulpQWg7aab0v+mRi5SCXWsVCaK1SnbcydcgF6jHAlYy2DBR56r6OFGVSuTEtCBoLfiz1loExmqLLQ2zas6je58RdEldWnQocEpR719l/+p16sNDyrpm0wfM7Ij68CY4TXB9siMTCKsfZCekrDBSyqpAB03XS9NcMau58eLLfPT+e2zOnmK9S+wtklmDzG0dIXjNkMyMRanQjkFcKbBKJTnfbZEuL2S53ygnIEaL+1JVGnT02FKz6nu6kyeclyWLxYKiKNHFjCFozpcrPvvscz799HMuzoU2u1ptaJqG3nsGhBrsfMqUnUff/iG3rw/8+U//ijk3+c7LkU8/+5yPut+kvgFhei329sWWLdWmcgF23KVFOy6407EklFcJ3CIGJoqbOeEzOqlCpnhT1zWz2ZyqlgDe9o6vcnzlwK0QTvReDLw8qzDzmr51nA2RNW7UkSisVL27vqNtG7quZbM65/TJQ44fP6LrNjiv6IcUALWFKPSoTdvTukA5P+Tw6ADbr/GFJhpLtAW6qFnXVygOr/H2d3/E0Y3b9M6zCgqiQuGFeYIiJq0GrQ3KmEShimgTAYdrelR0RBUTPQ1igEIbgvNs2o6hbxE5Iwm0OaMaO8MUNE3H+fmSYfCcn5/TdT2r1ZqL5QplS86Xa9zgR33uEEVw/uTsjM8++2xsmZcBvR0YWQQIGJX4cra9lVpV40TJTu7z+ZwQRN1No3jw+eccLfaZ2RJlS5wbKAvJujMrJWfJIW19xQTCYcuKN974Bv/kn/xT9o+OAOHPK72lO+XCVM66dzPubHGVoZLE/w8xie6HRKFMhbTgef31t/jed3/In//5v5KtdsqSc+XfA/cfPgYjHYEPHz2hGxzKWIiMaoQffvhbXnzpZbzr8T5SVbNx8uVrNQ2s22svE2tsWhrvzfTfqV9KZY7xlt0gokxb2lw+Mod9ZLSwzcSls9uKFKzSGC2DUSmF8hplFarQ+HoBATYXJ9i6otA19UwzP7rJ4c2XWOztUdZzuos13pQsm56q3mN/Vku7vRNdkdlsJrBRlDb4orTgoK4s3gWaruPa7Zc4uPkiD89O0UlwyySg32pNdMPEGacYd4pjtp0Sg8Jouk2PG4aUTVus1jgnMsikx+VAVpWWqrQYZGGMGrTyrI4fcbp/QDWbU+5dxRYV9WyOLSu0LQgKeica9+umpek7vFXYohilJsR+LjkqRQg56CqNMlbs15TCALasqeoZEUPlIqgu7Y5UKpYX4z2cHjEGkZPQEaIXEoexadxvWSkBKd5nZc789bceuCFSuJ5v37jJ9dltCiInZ0s+sU/59GTF8aCIw0DbbIhKjFVlaxAxwbM8fsrF8WNW5xtWm4FN5xi85vCwlOac+QF3XnmTW7de5ONf/5Iy9KxPHlEvZpTzPezP9sDMeO27P+b2nVfBFAyDFP/QYqBrtUkdlRGdwp5RgArSBFRYtPK0m4bYr7CxIxotXV1p+xxCEIaFFwEgEYvajJX0vLVXSrFcrjg5OSH4yOmpYNir1Vr4ym1H51tcCNRVTT8MxIDIqjYNv/71B5ydX4wZOFymAiV++mRCSMDeNgRknnZudhBN7YT3AZv1hv35Hi/cuI7rO0Lc7hS01vhUiMkUNu/F/9AnS6033niD//h/87/lG2+/TQhQVuJ/aIzCuWF8nbFLz7mRLlbXsxTUi/Fv0pAxXajy58tZCygMf/iHf5/f/PYDnjy6L81daVHRylAWYnj8ycefUpSWtu3RFITAuGPQxvLr99/nhz/6O9iyRsU47pSm73v52HK2U6DeSbizYFUks0sAjDbjIprvSy4Y5yxL7q4g5NP3lVoAqaEnB3G9DRA67YooMM4QCkehLefW4t2GK1euMK81B1dfoD68gdcGb2fMD2cSmCJYA2VZ0LWewQ2EfsAHYQ75CGUhMFJRWvEj3SzpFFT7h7z85ruc3L+HWh6nZjfxlDRGrNVKK8Xk/BkzBFZVUhMqi8Q0yUyP7G4UxKzBeZ8WSjFTLoyWnQQBH4UFZKImDi0GOHt8D68UhzfvcHTzBfYPDzi6co39kzOatscHRdkP2G6giIyql4V1ieUSKAspgu7tHTBTBwDM5nP2wiEm+2YSqRf7zGZzorYEZajmnt2aiH42cCtGhklMTUc6DtIFPUKson2er4nRhnpWM6trgU3a/rnR9/LxteiAtXd88/p13r56gOpb7puSeedwfeDseI3rOtpC4aJHJe+5o4NDbhzu8RnQLVdsliuWm4HWg9clV+qS2y+8zO//+A+4+9prECMv3X2d0DUo31FVUkh88K+uEqLh1uvvMgyOMmqs76lmC7wuZOuKsFlUak1OMjVooQGIi3qItG1DdANWA2WB0gY3DEJbKyqMUgTtib2n69pxMmY4IW+fmqah2bQ8fXrMbDYfg3efKH+tc0nhrKNpe3of6N3AR598xsOHTxIuOsE7dy63NLR4L8WVIhTkh2RTggxLuOT+LhNAJgXasFwueevV17BJV6YsLGhxVNHocTHKgzoH8hA8ZVXzp3/6Z7z97jvJhkynLB6IatRPzsW+nHnnAK21xpqSsizYbBybzVr4/T6kQJ2ZHQVKye+UimgNh4dX+fHv/13+8//8Px0XJ+892mrJVLTIs3b9kNggiE1akqMNIXKxXPH+++/zre98LzFJtlv1fL6XD5XOSTD8pNaYZ1hUo37MWMLUarxeu9m72qmJCLTGiGdv73HC0ZN6YlSJlpgWBq2EHmdVgSkLonOUhdAqL04fUdQLbr90k/rgKk5J49Lj0ycAzKqK+azGu4GLrhs55n3vZNFNgRulUpHSYK3GWsGlZ4sFL732Bo9++yuOf3OBUWCtwnmhlergUURsUaYO3TiOpRzMrElWa6n7URyBAll0TXYnsivWOmX/hSW4geAGlLJYU2DcIEXszYrVyROKao4ylmK2YH//gIODI1arBu8jfefou0GMSMqK//iP/ojbe3vjvblRHXKl+Dmvf+efoal4yfxL/jC8RcPRGJRzwdUaGc9+R176eQv+5PeJKijUxCyXYXl57xrXjleUy07qNonPfLPreW22z9994y3+m2rGf7b54DnB99njq0MlSrE3m3FLzTkqK4Z+kOCZVp5hGDBlgY4i3lSWFZWtqKyVrNcLr3tvvo+qpKjS+sjVa9f4h//43+flu68yeFDKoMoFxlQYLW3UqqxAW6IDj6GwGhO9FOhg7J7UWkkwzjr4CpQXkj9GLuZquaRpWgrApG5PFwTzK6yhqqRa7oYuVdIFwz0/P2c2m40B+/z8HK0N603DfD4fvSX7vqXrpLLc9wPGWFon7jdu8Ny794APfvMhwyCFSkmyUpegyvxglTBQwVpzIJCCrx4z3Zwlg2QXYiclxcPzp6dcOdgnOkfTdRhjqasaFz1hcGP2aayRRaYXM2KUQtmCF16+w0/+4A9xPqZJbZM/pcZ5N2bvWkmRSSuDKSwxSGHUu4bZTDrzLi6WnJ2t6PpAxBBxoDRRRaGL6oiOoLwUeGKE73//R/z85z/jk08+FDPbOKCwo8yCaJVs3VN0brv3TiQUtOJXv3qPN996C2tLkRgYG25+RxFowpaZ/m6EvnNGPsIdMcFYefcklExjwrZJZzKPpu8xZaToCXyyJbsoUIFCFyhTogrP3qxib15wsF/yyhuvo4uCi9UalKLpevYWM+q65uhgn6IwrHuXWDB6tCVTSkEv8sRaawhSHLTW4rzDo5jtH/DCnVc5++xjhnaNGgYU0r+BEp0inLAwcuIAJDgvccqLAhsCWjtMwuzbrkd1UlsyRpq0rIK6rFAx0LVtYiMFQnAYJTtV7Rzrk6eEQHo/xawu2d/fZ7FY0vWOsuopipaAppjP+INXX+Wta9cu3eCHfIM3078/Ba6kr3/DRzPI1+XDFHDlKo+XK5HX+ArH1wrcqp7x4Pyc9XrFannBZ09P+fB8xf22o8OzV1eUi0NpoQ2BwhTMTEmBdI1FZVBFIQUQD4TAH/7kJ7z+xjdkQoeQ8mSFsiLGL5MlbUuIFETxYTQFwYjoTtZrNkblTlVGhYPkj6h8pGvXtJslArtasLLdC82AVSKWtVlfiHiPG6SoMYhgzt7eHsulFEAycyMbIog0p7BufIg0nZgkiGqyZrNp6NuB4+NTfv7zX7FcbpAmDoE0QojEpMcizUQmaQyLw7e1ZtsEEGVxkwaBbeYoXd3C8IjOQ9Nw64UXxfjACdbnYxSJ0CiFMheEyzsET1AatFTzy3rBv/vH/5BbL4hgWIzSrl8UBSpKJiiURglKwcvEkoKUZbPesFqdM1/M0Mbw6PEx5xctgy/ofCBoiypUYp1I5T0onYJxQEVFqff4oz/8E+59/n/CqICLjdC9VM2ojz2OD2TcqIiyqd0fx6MnD7l//zNefeVVwXijxVppVsnXbgubCP1R56Ccaog5dktw9tusbBLTc0OOUoYQ1Ci1aq38Oyb9bcFY8nsrtNVpvAeMsmgltMCdIqnSaBWxuaHNitTDlaNbLBaG+X7NYjETo2QfuH71CtZa9g72wZZEY7AVqbg+UGa5hT4Q3IAmUtsSbSwqikvRetOwatdoo5gd3WAwC3q/xppAqbw0wNhC5rPRmCgaOLmOYVJ2D5HO9WhrqOoKUFKQToXsyhoWdYG10uiiEIguiG4wnR9AyxypbEGBxgLd2VOaWUnwkaLeZ28+Z744YLnuKWuPsWt0jGhTwJct0P+WHcYYSlN8pcd+dVlX4Lhr+OzRPbqzE1arJScXK042PWdNz6Cg3ltQzmt658Ttu7BEo/DEMeDEVH33AQ729vnWN785YkUZF8yNJNNJRcqqs+qaMeJALe1MmZKUKIhjpgoqJu+7vmG9Pk9Fn0Sm9xEXGbfGWmmqqmS9XovKW2r1zcWcvu+TDnFMSnBSjOu6jno2o2l62Xkk+cuiKOl7N9L1Pv74Yy4uVgBjEH72yJ1VUpCbz+eJpSED0Hs/FgDHSrUx+CEFcqU5Pn3K7SuSQWTMcaRzWeluzAa5xhjxvQyJ2hUjP/zhD/mn//R/LGJNYdp04Hc6w4CdzD/fr/VqzSeffSbt+sbgg2ZwihDM+Jzpc+V6iL5HtMllxnneefebvPH6W3z44XtUZc0QUuHm8mS8PDcVgDRe/OIXP+fll1+GqCjKeofZ8Oz3bZFx+7jJyyq18/Vs2/NuMTMXjn2SL96m7dN/78Iv0+fnI9MprVGjC5GxCm0Np2fn1IVlSNhoPZtRlRURRTcMBKCoSoyJDENPl/jY1uZuVikMGisF1flMjKx9kELmwdWrXL15i+NhhQqR4BwhShE/Jnxfqy0fGxihN1kM3TifnXOjUJtWiqosKRIbKqSxba0VMbsQWNSlNLR1A9E5ogalDTF4zo+PqZhxeKNkfz5jf2/OcjWj7TpsWVIqCfb6f1CBW4/1gd91fC064FnX8+F6xen6nKZrWPcdQwj0MYLRmKoUHNk7IlFE0UtLUBL4dWGF65haTF944SWOjq6glB6DnQyqy6clA1tpRVmaMeAlltV4fhJAAqR27BgjeMGJ23aFdx3WCo5qtEAuQ9cnSy0xPO37ThzBVS2FtcFLg02UICpFySUhBK5du8amaZnP51ycry7pDUgWsV6vGYaB1WrFgwcPyXvt5+orTIJCDAFdaBaLxU5muC14bXFxlTK1iIj7+MFxeHgoFM6+Zzabjc/v+17w4ISTO7ft9tLGcOP6Df5n/+F/yNWrV8dFQjjrw4hjThkl+chb4xgDm3aD94G265NaowFVopUFI9CVwAp+J4hnbq8xBUVREZzjj/7+P+DjTz6QBaYdxOn8Kx5Kax48eMDJyQk3rt9MlEW7M14y7JRpXF+mf/G8ouZU/GhKDcs7pLzobgP3ziuSLFye87dLj1MqYeE6Ya4WaysgUtUL0SfxgX7wbJqLsdYxm83Y359xeHgoUsC1p+t6uq5jvW4IQSiudcqSq6qmHMRFyWjDwZUrvPF779Jtzlg9XjM3BaiULKCEtZMW7hy4fdLvns9nkNyUtJKCnDXC9gohUte1vH/Xi+9nSlpmKTnadEISKKwoafqo6JP8RLPZ4OwJyhRU+1fYX8zZW8zYNA1lVRI12NRZ/D+UQ2szXsPfdXzNBpzA2kcutKEvKhrjiXjBKq2RAmAUx4yooHcDq2aDiZoBqOZzKhVQQbOwFT/+/R+zv9gf30BwaqFFhcTA2BZ9DMRRZ36klEXvickuLGRLqSjYWDZWVQSGvsGKJ29qOBAYhETxy7S1qq5Zr1dJ/rSnaUQbRGtN3/c8ffpUukgPDhgGaXFXStH12+aS3A4v2iQdRDg9PaXvkx5IopyNCxCM+PJ0/s7n89HrcdocoLWmdz11VUGM9J241hAjfdNy69qNMYfLioC5iBijyJJ2vTRDRWRbH5FOsB/96Ie8+867QJablEIikDpGt5oOU7GcnCVJK7XQPEMI0rQ1DIToMbbA2GKL6SYPSBm0EWs9xsp9jiGi0Lz62hu8+tqbfPLpb4Q6emkifpkwT4zSkPHez3/O3/8H/166jpc4t0qNn0FlmG4SgPMxDdrTv08z7+nfpop6eVEbC5NbcJsvD9jpXBMOHpUiIN2azkM/RA4PDvAe5ot9vPecnp6O484NjrIsOTraZ71uWSz2Rn51NvvNGbA0mUDbdqlfoWM+X1Au5tx+9XUe3vuU1ckTQmjpXQt9SwRpyBkLsJJ1O+dYr9ep5qSo6grvRYEyelFMDERmVc1msxJ3eQrqekZhc9YuWbY1InkRghgXW23wCkqj2Fyc0XUDV5VhVu0xm1WUZYEtLE5FQmmI/6bidlHA4SEsl9B1299rDYdHYgYRgb6Hi3PY24PZTLLN5RIS3Do9jDHiY/oVjq+VcbfrDWLoWaAUWF3iYiv4bhABpMKDazuUkWx2tVljokUXBbaqMcNAQcHrb7zFD773femKIwgDe8wqJfhuW1kjIWoIwpvOBbkQJHATMhc4pgK9ZDqz2YzSROGODxlL1Ekcqk/MjVxIiXRdKywSIs7JApQz3hz49vb28N4nUr5kpOv1mrZpkrzrMIpK9SnQDS5wcnKa2rwTY2S6rc6fPbVGKwVVWXHt2rWxM3Eq3aqU6MZEpEgXvOi/DF1PHDzXjo5QKXBk6CZPqMtt396LvUAIgcXeHn/6p39GWRbZp4CuE5phhrHyIjINYttsO6u+SZASjr6EQ+c9Lg6YEDHabpthQgp2UWF0kSryaZs9eExR8/s/+QM+/Og3WFvRu5BYCHpnEfmiQ2vNR598wg9WS/b3CkRfY7sATjPmmDD2y1n0l2Vtl5tK8j2aMkzk2glLaHrdtvrg6pkFKP8cE3wlauIKMd/VOK9oG8dy1TGfVQzdms1mw/Hxceon6MZzOj2Zs7wu9MGjK4fS9p7GQd6VeR+YL/aEYZK48AC6Kjm8fYs7b77Fk88+xZ8/RmvL4FyySasRDrreQnFKjR29UWuslvTJaoM2kdJaNpsWFSOFsZiZdAbPKtEOaZOsRJEKkLmwH730VPjO03uPDxrfD6xP9zh6ccHefMZ8XlPWJW3raVMN52/9qCp4510Jvi/fgV+/D5vUqm4MHB1BXcFiAd7DT38qgfvaNbh5C/7yL74wcFfpGvyu42sE7kDbN6gQ0V5RYsEUBDoRc3HQNy30Ed902NLKY9EYW7B/eEg1mxHWA3fuvsKPf/JjDg4PGLoBY7Z6GdPGiB2VLV8QIzRNM1LPrLVoa7BapUCwLU6K/CtsVqd07RqtPIVNOt5Go6J082WGgTStiOypONDkZgzGltc8SU9OTkQBLcEWuWswT5ScyeTPIxnIhril++4cu3i+7CaKokgFnt0sLtP/VBTakh3bpWF1fsH1q9eSqascOTjtYLFKsHDxuZSOMoDvffd7vP3O28J/T00qGdsvy3LcmeSAOcW5R362gqgiaI02BdoaTNT40CfRH8EqY4SimGqIa1IcB6+IhKSpEbn7ymu89NIdHjz8nBj9iKdPr82XHW3T8N7Pf8GP/+7fHzsc83OnAfIZ6Hzyi+ljn3fPLuPf0+CttZY26aikzXvCPsnuRZFdbH33Nbc4t1DrDM5H+iFycrpktTyhWZ8LTOY9bdtKxhqFceV6j/eRthUefbh6lCzTekhdfEdXjiiKmtV6BamGFGPE1jVaKV545TWu3XqRz0+eSPHYJg1+pcZFOM/JnDAQIoPvKQspCisYO3utMVRliUIWUeFQZ5lksUkzacwXxmBNAf1AG8TZKiCDqHUDzfKcRbPBGs1sVlPPa1ZdS2w6ov+Cxf3KFQmiTx7DyYkE4zt3RWfp6RPoejg8gINDeHAfmmb73Fu34PwMPv4YXnwJXnwRfvMb+dswwEcfyq7qm9+Chw8keD94IBn3yQmcnz/3lGR3dPi7hjPwtYqTkQ0dQxggiMuz1hpHoO1bVITQD0RrCN2AsoZZVXGwv8d8XnDzhReYffgZ/+BbP+IP//6fcLB/BCFSLsQ1x/nIkDKAOJlY0yxGIIr98ees11ykNlJ5DikwSZBfry4AT2E11mhpHlBpe2+LcUXODS5N04CCMKQMTNsR4w1BmmeuX78uQvFpUcmBexvs/M6kzRnN9NiyFZJw1GSiF6VQnKwtxkmbg5XWoseROwlTCxJDP1CVJYv5HNK9yUE3aynnDCvrSAi+OdD2PYu9A/7sn/zZqKlMeq9pO3vOqKawzXTBBcbimbxGHIOABYLrCF4yaWmBZmzVF2EgILl4p81Euk6a7/3wR3z+n35GdguXa/jl+sUjDKI07//6fb75re+zt3+4E3B3CpHPef70+zQD/7Kgvb3H05b6fH/za2XoJDD5xU7gHu9VKlT7EFBKVv8QhcUUgkgadO1K6hcp21XK4IOXjsLesVyu0xgCWxiuXDlKwmXSD9A0DV030HZdSlQSDbUS6u/88IiX7r7G2b1P8aunDK6Vc0s87FyMzYG8KApc3xN6SQyqMjlVKcXggzjQG0uwci91et4wDFsAKQSslgK385GqsLRNlyQ1AspHood2veL46RPqqzeYLwTP36w2dMer5KJx6Tg6gpdeloC8vy/B9tXX4PFjONiHb3wDHj6U77/4hcAd06Oq4exM/r1ZyyJw+djbg7KA09M8mCQrn8/lvT//7Jmn1HXNiy++9OxrPef4WtZlMeHcQ/CJv+txQVSualtSVxWzsiIMLeAoK8tsMcdUBjY1L995nZ/8+I+Yl3u4TgaRMiaJQSlKW+DDrth4jAIFWKOJIXVCxkSNIkKAPongxOBQKjAMHSE4hr7FqoFZVRBTZ1Ze4a2xst0aBYfiSAOs60r0GLqWupICijGatm3G7OnifJm2jC1VPcPYFrTBh5gKcoIN+xBo2p5N2yamSDpURJpQUtEpgkK0DPbmM/YWc2IMmNQEkIuEUUBajLb4EMRr08DF2Rkv3bot6mwJzsgc4RBFgiCFewYv3Vti4iCi+u9889t881vfRRvRRJ/yxcd2+MliBFsdFRkbKUhpRVHIYqyVyHxihGpntWPwgqXn5+T3kLGdrOikcgIIBKSN5pVXXuXGjZs8OX6cnpuccDL8EDPVbro1Tvc1BDbNml9/8D4//OHvp27HXBTc7hyEiz3BvC/j6SlgqikbJEFc6QOMBcRkg4ncVTUGYL1TXM31g7jzX36mwEZCl1SpEzkv1QGFE0SJdeNYrzZiBRZFUqCwhXQeasWAS0qPYC+WVHXF3t4B8/kMH5JUQWkZhpZms6FtRahJxUC3WoouulZcu3OHxQc3OV2fUqEpvRdGiTUE72n7DuPFAb4sS7TVSStFOnJns5lAMEphrPQDaC3XXRqWRDF0S+21KCW6N4XVNOs1BKHZ2iAKlqUx4Hv8xTnF3gF7tuJoNmM9m+FKK236l4+DQwmox8eSAe/vCzb96CEMPczmcg9O0mMuH85BLiIWpfy8c1sV3LkD9+5Jtq3TFvPhQwner7z63MBdlJZre4tn3+85x9fCuF3ToxASfYyyrYkuYJWhLJPKlbVYK3xTVMTFgKHEY3n99XeoyjlD7xGbq4AzA4UvkhKagpD61eL4xqloJIGhaxqpqqcseHDiT6h1xPsO7zqM9igl9KnFrKbQCq2FV6pUpB+SzCRQlWUSoenxzjGf1dIQE+Bgfy+1uEtDjWCVA0+fHlOUlTSPrDfs7R/y8NFTKawaO+pwSxAXjLLtu0nQzt8SbxvZDmutKArL0cE+Wm3pUVMMWcaFNHgUhU5+g0kn2RoCoooWQ2rOUSTj4C3GrVAMAYLSdINjNt/nj//kH1HWc7L8KZMsOr/39P23mfJ2d9QnizZrikSvVFgj3apKJVa70mi93alM2+aLoiBVD1NxuSdGj/PitPLWu+9y/C8f4aJIwgpOnC9obkefZlhbaChGxy9/9XPeeef3mM32KGwlmstSCQW1TRSmmfJOoTIpxoUEQch9k0A9PlapkTU11iW0wRaZe7+9XtviZIS0VKUlRJKXzC0PSW1OiZSwKNcZAooQFcrWNM1AUSqIjpCUEwtTYbUmEKT9ejCsNy2Pn56ibYWPmr1FTQw9PvQoFSlLw2JxJB2IfcC1G0xZooxhce0a1195leb0EeVqwAwrXN+nOZos3YzFJY0fgtBspfFHvCaN0VR1KXHE5oRAalTi41qQdWJ0UgryQfTiffAUpaVMSctq8PRNR6E1amjpTo9hvk8RAiWRw6p8Ph3w4lwCa9tIZnx8ImPg1i04OBC/Q++ezbTzcfxUMvS2hdu34P59OLoC85kE56qSrPxpCvqHh3D1GpyewI0b2yz80qGUwIdf5fgaIlNiiKq0wiqDm0ACOlVDF4u5+N6Ril5BLr9zgcV8jxdfeJVZvWAYAl07MLgeyApyU02ObaCKaRI7d4B3kdPTkxG6EO1clWg04ghSjeYBEpS1FlOAshTLscz4kAJdZHCe+WxG14umg/dSYc+wSdu2zGZzrC1YrzcCsZQFh4dHPD0+Y29vD+ckwG4rwpmqJ8awX1QfeR4uWlUVi8UCycLCuP2FLfXMWmGQuGFAo3h6csyt69fk3mjJcEIKPJlHnOEFlQJLpmxZW/Dmm2/y/e9/X1zt1bbeMM2u83OnAfyysmC+Z1qbRN+UWo1P3PkttCCc1S2slLn1BhGjd/ggu6hhkEao4CNvvvkWf/0Xf57EqVzaoueTS0H4S47zs1N+88H7fPd7PyIEP8G0d2GTy4tUPunpfbx83y5n6JcpgUVZ4DZDKlBfeu18USbnMN2FRJBEJ+advyQgOcGQ3VekX7eoKNeutCXeRMwsa96AC2KTx0bx6PFjlNbcvnWDuszOVJK0OOeIQeH9IPZj1qTPUPLS3busHnzKsl9LFh8GTEjKfkoa70RRU4qcfQRlRFRp8D1VWWFISUpp2Ky7nWsxhfQAVBQ+ftd1hLxTSyYfIYCOsvCGoWd9fsbBbMH+vGZhLWXUPJc9enYm1/vWLYFHVkt4//0txv3Bb4Qpslo9fyBdXMC9z+HadXj0WLLy/X0J9Pkmvf++BP/8fnUtQfv8HB49ev7rwhfGisvH1+qcHAtdPmwDQXZaT9vzruvo2p56XqN1wf37j+gHz3e/8wOKopKioZH2Y+uEzbF1jpCFIAsCbZs+HM4tCF4aX3JTTFmWFKloJgXKSN+tWa06qjJl/gqU0SmD89jCpExr6xa+Xq9FilGRaExagkc6H+89TdOyXC45ODjkytEV2q6X17MFZ2cXCcseRjlPuQmRLAX7LC/4+fSyzFqxVraIMcYRV87X2DmHAYa+lzpBUTKfzfGDEz5sptPpXchpbJZJnN9m01DPZvzZn/0Z169fx9piXCjy+03v/TTQZOW7/Lex9d6YEfNUKiBwuWCz8ljRpYDcqJFcSpLpcgj9TuDOfOQYFfPZgjfe/AY//elfp3PMY3OaZX8Z5h352c//mm+89Q7z+QE7HZgJoZjeu2nxdWqLNZ0TzytI5udcfg2lVBIh2j5/++Zps5Fa5BO0P95HOTd5rFBiMwwU0dpiTcXy4hyjxTjDWovRIuqkC3GIcT4QOtkVKS3NO3uLBeXRPioavIsELTh8URSEqAl9NzKvgjUcXbvOldsvcvzwnpiPeEV0jkCkKsTdxyK/E2VOTdSaoCJ91yJdpAnK8WqHMVVVFW3bjtcym23IxxeNemMLbFGgjWHoeqqiIEQlnqhRE5K20FwD2mC+qAZyerqb+XYd/OaSTsjwJYJPx8e7MMpyKV/5tZhQBGOU4uSDB1/8el/z+HoYN4I3u1E4X6riIUpX1sXFBa7r6bqeoir59fsf8N6vPuDP/sk/5eDgGtYk492mp2k2aC0Sk9bm4o24ZAyDH4O2WIVZqqqEqHn99dcAGAXSh4F2swY8zrVE32OMmM1aIzoSwXv63jG4Lk2oIFs3lSl4AtusVtJYIwU6CSyCy4ki4OHhIVob+n5gtVxKJ1jTcnFxwdnZGavlOumFbBejrus4v7hIdDC2MMlE+S9P4DIVJcdipGYUK5pu3/PfC2s5Pz3jyuEBRNH/jUkQSiWopa7rSQCUYNg7Tz+ItdOrr73Gj3/yY5TWDIMY9U47NafsninunXnKOavPJgxaW9mZKVBaPrM2oLz8zVq51t5JcI6k4maUluysXZwzb1I1QymFj5p33vkmv/jFewSvRqsxKRCMqfd2vE6ureDvkeXqjN9++Gu+/c3vs4UqElY+ybwvFy9VgrNgt2j5vKLk9H7lBa0wOpksbIPBdjGXdnlGmmj6itv6R8wLR4K+JANXCeM3zOd7PH78gGKWzYodphTaXr9xCTe2GJPEvXrHZiMOOvvzBWAkg1U5yxd1u+AdXRAyonceU1Qc3noRfXiDNhriYLFhoDAGZwTOUcHRDIpBBUJih3jvabsW5wfmdYVzvZiFTK53zrZ32GTJRclqkfGtZ7XY+jUNpTFE7+n6QGksyiia5RneFBTeodXO0vxv/RHTDu2rHF85cPsQOD09ox/6na23T04tTbPh4cMBFSLRR4KH+/efcHjliDffeJfS1mmSRqyVDL1texSGqrYiuao1w7DFACXjy5meBKzNpmGz2aS29F6Ib9GhDczqgrKQQkZpteCrfU/XdkI1G+2TQio4mpFiRcwi+PUOVND3shDlgLnZbGg2W3qgKKIlxknin4rnnDA2nj59yv1795/NuC9N+Bgj+/v7k78zLl5TSl8e4H3XCze6H1jUMzRCIwwErJbGA9HL2Jq4jrsmFegSxe9P//RPuXb1mvBjE3k7M1jy+03hkmkGn/ngmQKmlDj7LPb2ODg84OnxEzJea61m6J14NJIwSz+k15SWcJcaeJTaLhhy3jotHJbDwyvcvfMqH3/8EX7otrpc5KLhdnWcQjtKKbQRE9if/eyveesb71IWs1T7gC+CWZ6Hd+fXft5xecEbzyO1q4fnPO8yZCPPz+cv8TvGbUDPAVtsAxVEzazepyxmeD+IlnuUXoiyqAgJKhH6pxIdHTPQDwPL1YaT43Pm8xlFOUs7IL/bQxE8PtnjuRi5dec1/idvvMPQtbQnjzl5+JDjR/e5ODumW1/g2gYVfVLwDNiEVwuHXrwpffTJ3m23SSkfov8jtSyd9FoW8xmmKGi7Du+kSBmcxyiNNgrnUr2nqjEKoglftgH7t+54dlf+xcdXpwMGaTpR2m63gSG1s2oNUZwxKlsxm8/QqmC9Oufm7Rc5PLhCtvqJRIrSUvuKrnO0bUdRCk1PTj4kHupW70Bw6oIY2MqpNg390BODw6jA/v6cqiwwOmCtdMH1w0C72VAUJSH4hN8NeO8Q6deAoZACnx84OjpkvV4xDD19Lw0MXddxcbGkrmeEMLDZNKxXG5TSDD6OnWpZfCpntV3XsVxe8Nmnn7Fab8jEB0iZGru4dVEU7O/vbzFjJbjgtOElNzUopSit5eT8ghvXr8trAlabtKWUgJFlNvOgyHrYfaL3vfLKq/zBH/wB2mimYMOUfjmtPVweWDkzz5Ou73sGJ1SvmzdugJbGI7wwMrYFORlPl/ngssMSu7QcKLdQSdbrKPj2d77Lb3/7GxmH+cxH7YPdmZohHx8ki1dacXpyzG9/+wHf/vb3iWFbILw8x5+h/00WhOcdl3dQ+TWmUNUUftp9XL4OeSe2bZOPMcMrubZAgp6S+mCAoqg4PLjC8fF9qkqapXz6vGVZSqLAVhPIGOlGHAYRP1Mq8sKLN9g/qEWtz0i4RSnarmUYeuFSG4O3Jfu3XqKq51ilIXh839Kcn/L0wWd8/tFv+fjDX7M8fkLtVsyTJ6X3kn33Q0AFj1eRotw6E12G52wyo/Deo4oCbSxN26CUxmhNHFyiCxb4ELEq0rkB30UimsW+WIL9//vYmTdfllF/xWwbvmbLO3kyJ2zN5WwwRBbzOYUphGViC84vlqxWa4wVBkrwiBa0c4lPbZjNajbrNq3uAm+UZUmMjIXBEPK2WfwHhWokBby2bRn6DSoOzOoKSZy9CNOnDHqxtydGnoMnhJxNxrQt83hk51CWJcvlEuckC9xsGubzGV3Xj/Sm4+MTVqs1WptUNJN2867taRuxXcsZ+nK15JNPPuX45JzccKFgFMzPkzYH6sViMcIPWksGEf2WI50fZ434ZbZNi/eOxXwu4vaFyL4SJQBZW8h2N0Ek2RPSe0/bdGhb8oMf/IDr166L8BfZIEA/k2HnxShnRtNmoxxcswOOsdJleXC4RzUvmC9mPHj4lGHoKAorzIgQd54rxdzcOq7JDAPhdm+/x3Qdb926ze3bL/Dg4f3J4GQbtOMuJ7osSzabNSG5kRir+dlP/4Y333iH2WyPL0rLphPucuC+HLynv9thokxeyxiD0TrRGLcZ+fYx8lkE/pj+LDTBKYY+lfbNeicHh0ecnDwiBChs0kgJyWzDbI2LdeLK98OAVhoTNU+PT4nKcytcYbE3S/KuAlc55yCCMdJ56pWhdZHS1iz7QAyWqqyY3zzk7vUXeOWbP+DbJ0948tnHPPz5n3P/kw9ZL8+xiPVdDB5DxOhM902mvn1yRveiAKqSMbaxFqvluWVZ0HS9sGSAwopUrdIGHSOFlh1c6wdu37zBtb09Pj0+pul6XIxU5kVqdZ0L9WsUBWX3Fqr4BK1Ox/mGUuKwNJvhlKbte4heurTTriWgElTbg/eUKKoIpUQfnFa0wK1rVzBW87//V/+cn/zh3+PuK99gsVdLN6lWhACnZ6dcLNesgv/KAflrYdwhavHY0xqtC9ywwVBQG0MZDXGIyaKn52x5QTmfizlt9KDiBJ7Iffl1ghUcw+ABcVepqgKS3GXXtamaLJxt0TSosEYxLHq69py2O6MqFEqJMI5SesTis9hUXVcpW80ypRIwjDW4EPEBQlTYosY5x8Hh1ZSdDHjnODk55+xUsOrFQlzFVxcbXBPo1z39ZsD3gb53qeFhw/HZhTRN6JQ9paxLmlNIxU1DjIHZvKKuRcpW6Th2ZZK42sZYQloom01D6Fqu7+9jY8DHiOsFYzapYaEqC3o3pIwye/spfFBEbbly/RZ/7x/8CaaocF4mUHYRUkaPwTpnizlo5x1Axrlz01FurbcmdXSisbqkuHaN2hTcu/eA4/4UazVt5zEqYlQikansWZRhEz9CBZLVy/jT2uK9aFd8+zvf4+HD+xJKQxZhJzloC1ygtOKdd95lvphzcnzMRx9/TPABpQMnx0/46KPf8O6730Yp8aWMZCpi2Am+OXBqvUvLlHNKlD8QmDDGJMMgGuPk3/tATI1NILWIyzuYaQ0DpgsAY6NVxp8loIvVnIwvjS5rdDmj7TuqekZV1+M80mhs0qwPQeiiUYti4xA89D1PT87xBF60L3B4KBo5pda4mFhcWelv8GzWKw72r1AXlqbtWDcDRmnKosCoisWNPfZvvMIrb32HB59+xK9/+hd89N5fEtbH1NExMxHvEe0aHdBedsLRObSt0GVF5xxUM0IQY25rLDEOGB1Z1BbrAoOLNDiCMsR+QGuLCRFLxKhAiJH/5Oc/48HJit5FbupXuK7/Dr+1/3eIR8wf/EeoG/8HquK/R7WJTWNkYSuvHNIWBaerJa7vcH6g04pBK3zX8/T8jKdnp/hNy21T8UYx54Vo0dFzojyfD/DP/vgP+PHvvcFfPHjAnb7jirWY+Uw47qlWseobTpqGwQUOv2Is/lqBG5IpapQtq47CdyyqgpiLSlF4xC4Eru7t8Z3vfodZXeGDS5mcBDGtwRiVHFI29P1AVqwzRlPXVdIdicSEhXof2KwbsfupZtS1xfsluo8UhbSzZ8hmcAPSwCKDNWeckjEWY1tt3lLOZjOcE1EeEYTq6buOGCKbTSsdf0nRLD9v6Af6TgqXfVJUI2ratmfTtPS9y8SvkSkwzcxMwiLn87lwmBUj73TcPgbJPokOQqQdBmZVxcnpKVf391GpKAlbt/YIxLaVFT0FX601Uh9VaGP57ve+z1tvvY2Ub3w+S3n+BBbJQfsy5S+/107QtnYSeCQgV0XJjWtXhfWjIscn53ircE7htSJGk7RpgJjrGcL1zq+/iy3LQvfiyy9zeHDIanXO0Du0Sgwl7zFa44aBO3fvcO3aVYzR7O/NGYaeTz7+TIpWCsm633ybui7EMEI/W3TMR4YG8y5hCiXtZN9RdhSXr2EO2HkOhLjdRU3fY/s5p7BLBkrG0XTptWVCaVuw2Nvn5HhDhiaLQroV82fOjjQypiRpalUHuiS0geHpgAuBu/olDg720MZSlhURKbT6riFGQ7tZM3QN8719VFXQpuDedgGdcGulDXr/Ji988zrX777J29/9IR/87M/57P2/4WJ9jh4GCFbc7TsnzTWKUQLDGk3TdSPe7p3wxU3mhScc32hF33fpvmiMMpRGj/NiHT19IXpJJpSooNgvZuhQ41DMVcGcAgesVeTCDbhhoF1fsImewXtwARcDXaEYrGJoek6XF1wsl5jBU17ZY1bX2NaLg0/0RI/Qo0NkvVmxGRq8EuXUsdjMliBxeQx82fHVG3Dy8JHUFB2iaPKqXRaAspb1ZkNVVdy9e5c//dN/LE0Lk0EaggTu7CeY6WR5OyzMBp1gk4jVooPQO8d6vRJIAMdib0bbZnEngy4LFEihs8icYNENKctybP/O235gDNbr9Zq6rgXHT0wJay3NpqGqKtbrNfv7+ygli0Dfi/aGDw4XpEDp09Rq2o7NuqUfdt0unkcfM8Zw48aNUYMkU/9yK75JeHfGc7XWbDZrUUHLJscpK8xFQqM1MXoGJ+3qymjpwPRSRN3b2+MnP/kJi8VipGNNj2FiR7a9Z7su3fnv04LpNKBffuzh4aEICc2P+ezzh2yahsKasRAWY0gZpR6Lk/k9totBoqUFzWI+5+133uHP/9v/BmsNQz+M1yPL0V69coUQAlVV0nUt169f5/69h7gQsKbg5OQJH3/yIW99493kvi2T6HJAjgmjmZ7X9LMppRLEvtXYuVwTiGlRskXxxQvDJWhl9zpemo+T95NQLlTL/f0DTo4f0bYdWgW0qgix36GUTu8pOLSytG2brp/l9OwMbeD27VvszRcIe0w6pXO23veOtt0wWywwRjObicN7l2CMEDxRW3yssEZT7V/j5tv7XHv5db73B3/CvU8/5qP3fsrF/Y/phg1VgIpIgUe5AR9aaTAaBBJxw0DuSJUxJwqfWmtMhBD6MXGLSmSOtRYa5Mlmzb3VhsEpimLNQRH49PSYI2VYELFnLVVY4oeB89Dycb/kvF3TEml1xA8e3/Q4F+h1ZDAGpSwDEaUt81kt4lAx4FyH71tcGPBtILpOksl2iXMNQQeCiolUITRHJRjlzv3+XcfXbHlP+GlUBBcI/YCJoEJmagRmZUFcNxRVyc2bN7G2xOhiZ5BqMVtJA1JwbZGX9BSFQB2whVP6uOWKl2VB37dcLAfQA223QcXA4HrKwhAJtG1H3zX4MQAp1uv1OLEvF4hyxgiM1DmbRG9yoF8sFhgjxsHZlLfrnPggRmFzhBAlaLcdF6uVUACVGouF2pidSWut5eDgYId+N5oj7GiSq1G0xznHar3mpes3Rm2H3A4/SmtWFX0nmivCh3UMg1yXGCMvvfQS3/rWt3aeszMojMEkata0cSd/v0xN3MWrt59hGviMMRwcHFBVM6wt4OPA6fkSrSIioC5jN/U/TsbKtuVe3s8nAaSCt99+l7/5y7/CBYfYhLnUIyDncnJ6ynwxpyhSU0cqpBuymUfg5z/7G1577XXKsoKkC3/5c8mHYCfgXcazM6FlGrin80ZqNSYJM209Oi8H+en37Xmk4u5YrGTcweXaCanwKx3Mc9puQ2EVgzU7kzwv8NsFUT6cyjuWEHCD5/jpGVpZ7AtlynB9gsYKlLV45zg9O2X/8ChZwynK0o79DCLtLCc3uID3kcoUFPvXqGf7vHLlRV55+9uc3/uIT3/zKz77zS9YLo+pYk/ZD+jgcInlFGJABYexpXT8RoHWtC2ZGc2m7aV5LGg654VymRyFANrgWQbHZvBcxA5vA582F7jZEQtAtQ6zWlMMLVZ1uP6c+/2Gpi7xdUk0GlPPUB6ckp2iUhqspq5K5uLITNf1bGKP8T3lMDDvAlWQIF13Lbptia6XeJClndPQ2U7Bv/XAnahkAYa25/zJMcOmH62gYpp5IbkcV1U1ikZJgUwCjFKScTuXvRa3dDMh31eAlgEOiaJXCCXIwP7+Hqv1Bf3Q0DSetl1jtJgEt10jFMBBhOKNVqMBwGw2G51sctYRQhgdbKy1oyVZdobpu36nGHdZ0vT09JzZvMIU4nYtuiQd6/WG5UpkHgWTZPvvSdCbz+cjBTAvTGMbeQ6Gic9dFAXRCyxRFmVyL9Hj9c2BIF9HDekzSLdeNme1heU73/kO169dG6mG00wsb+vzArZDp9vJfifQTNxSA8fhN8mY83kppSiKwM0byQPw4084ObsgBJ145QmvDdvB+yzDJUv4ao4Or/HGm2/x3ns/S3BhhjHk3I6Pjzk42KcoRK3u7OxcFqIEQWljePTkIR9/8lvefuudkYJ5udAowXw7BjIddtqUpFACdU12kFMVwxzHpzuRywvmlH0yPUJIfORUsBwhqyTMFbWoPZIUH/f29nn04Iz9xQzvI0rvLr45eMvnClvjE2UZBoEknQ08eXICUXPzxjWKskzjjYT5RbquoWk2LBZiJQi5ZbuQhco7itCitbT7uwAYIwt3FJ/QG9/4JtfuvMab3/4+n/zqp9z/4D1Wxw+wccC5jsJocIOoEuARezgYvBM56BDohgE3eIwtqQuLxjFExq5JW1hMadFemGQxRh6vzgn+jLtAVJ6ZVcydwtqSoOZc1DWPrGKYlWAKbLBorxliZAgOEwe01cxnFTOt6NqWVnlsEZg7xazXXFUwR2Gi4mjwmE2D6R0q5JNTY3KVx9dXTLi/euA2xnB4dMTxZw95+Nl94uBZlMnhAsUQhrFTT6hEitmsTlv3Au+2GYhsOSVFyQNVKv8bweS0TUUkkrZFmrwKKVyqOet1x3J1LhojOKwBpaSVPnhHVRZjBjRdGGazGW3bjll0HsybzWbMfjINsGkaXD9QliVKbW3TsgWTLS1FXVDPKtAaHwMXyyUPHz6maZI2ySTQ58kTY0wSjkdjUJpqZ+dOPaM1RVXhUtu3VtKGf5iadKbt5tNOPWOkuzUkZo1ASbKtPDw84vd///ep6pq+70evwB3qX5Ieha1k6zSTnL5fliuYBqlpoJ/uZKSVWeoOt25dJ8aIDx9zsVyhFPSDw8ftNcrXa/uVUoQYiEG4wb/3e9/kg/ffQxszNoXFhH1uNhvu3btHl+hsx09FE11bNS6ow9Dx05/9Fa+++gqFNeikbJgz752FYwId5SA+Bu+whUmm576lAyZ6Jrs51WVs83k/y6+mbJM4TvAYhZlADGmuGOazhWh2D57CGLzehZ2m55VeRVgdA6lOYRh6z9BvcP0jtFK8+OItXNKZL4oKYxQ+eM7Pz6hS3Sdn/dZKF2RsW4a+oa7E4KBLJiODM2kuadmF1AvmxZxvXX+Jt777+/z2p3/Jb37xN5w9/Iw6Rhh6KiQhi0ozKIMPChcEBpVeEk3wA9oUGCVYt/IiRDYrDPNkhLyIFqMUL1RzqoSCOwZ8bDlSnqtFwYGeYaqS38aBs+Dp0v0NIdK6QO8HbOwYNgNhrdDzOTbVD2xVggtEE9ExYKL8fqEMpg8iWZzvrVYpITVjfeXfAFQSefrkKR/99reoPnBl7xAdobB2HESKZPqZTuLKlSviHqMsm6H5ktcmZeMqmY0mqdMIUUcMk8liDZUuQS1oT5Zk9H0YetzQoYhUlWzdhn6gLIu04gvuuUxtqXt7e6kJSJpmrLWJyidFjvV6TbPZcLB/QC4gTkWRIhFbGFlcjNhJdX3Pw8ePOV+uRiOCsTnkUhC4efPmqP0NjDuDUaslisytCMoX0pKPBMC8gAA7W3vI23IJqG3fSUaWtuq2qHj77bd58403iTGOEMuU5ieND2EshD3vyDuS/Hmep489zShzMFMSddAaVFRcv36FSOTDjz7lzAsDJ/jcpbi72OUApkhZZhBj2Zs3b3P31Vf55JPfCEkryfCmGMLFxQVNs0ljRNQWx+COtOQ/vH+Pe/c+4+7dd1ATiGS6KOYxPY7DadAer/u2429n5sTcQRkpyUqQ2zrBlL0zfe9tgCVNbEWGSqY7v3yNUdLhaG1BUZRsNg1lYQnEncdPC6zydVkyYHv927bjwf2H2MJw/foV5vMMm3hiUKzXSzabvUkTjdQKytLgQ0kfA6tuoMJgiwqFZvABvJhzOx+J1qIWB/StQ9s9vvPHr3DjtW/z3/6L/4wPf/4X7BkDylMqhfOeIQY8iT+eO1MLm9yVNCqK36ZKHqULa5iHwJ7S7GuLRfFuXKBdJeMkDAx+Q+wHrpX7vDRfcCXCq87zSEdWCnoig4psdKSJCryhN4qoNYVX1ERZHFxkUDCUhrZzQngCfIw0zjFoTdhJRvJYepax9GXHVw7cbdvy/nu/xFCw2Fuwt1jgukGA+xiSeL4wFkzamh3sHwieht45oZw1TAddLkZ2XYP3BcYk8C6BeDE90STPwi56WWFVpEhYrxt66qpkvVrTW0NhLXU9A8QGLAfJ+XxOjKJRImyBiMfTNu2oK9K2ssXLc6OsSvphG2S1NsxmCy5WjQxypVmvNzx+/FSMd+U2kCfBNNPJi0bGp3Pgy0ahwzCIAiMIZS41oegollMCHaV9s9pOZJnsSYd7GBAWkOCLUSmKquL7P/wBV65dBbVrdjvNqpXOAWK33T0vEjnznsIjU0x2yj6ZZnYSLOWeKqAsDDeuX0Nrw0cff8Lx8QkxaXWn+ME0Bio1DoSdgvc77/4eH3/yG0xp6bthAl8INpzdXECPbfJyz9JnD4G//qu/4IUXXsPaMlHl8ivsFo5GU+SEW8QEDWYWSYh50cvFTBIjQ2zgtjnu82GR6WKXA7i897blXrp/t7ho2ruSNc21scwWezx+8DllZakqwdVF2EsnvH06Jt04doRhJJTLGCOYyMVyyfHTY+aJsiqt6CIi571jtVpSVTWzmWjBZ9qvKSwqVAyupW9aFvMFuqjQeAYv1yjEyLrpmS1mOCvn53zk9je+xT+6dpX/ev+Av/qX/5zWD8yUQxGIyoCx+EE0jXLtiLEjWkHvyUJ7M2uYESlCZKZBR3ix8ZgYOZ+D3nSE9QZ8ZK4NR7bEblpmPnDkPGexpw/QB82SyEYJPmXmC6gKNk2Ddp7CeXzT0uFYaehLxWBSPWs2Y1DgFLJzy/OWmFg//4YyboW43gQM1pYMPtD77DkJaIsPIjPpfcSECD4SXUQVohni3CCBV9sxeEsHWEyZZMEwdKJ1UggOhtFkWxutlOiaBHDthtpYAp6+XdN3Ik7Tx0hZlRS2pCwLyrIUt5rEHinLchSzAfDDtgBXFoU067iBWVVjC0PAMZvP6PqWrhcjAFMUlCGy2vQUZoF3ltLMePr4hK4Vj0mt7MgMmQbtsiw5ODh4ZsudxahyhudCkEw+bhkjZyen3Lh2DaL0C5ZZo1sQykSbkop+QESF2n7ARVC2YP/wiDfffhdtBbrKglJT6GPLMQ9jMIctBp+DyjQo5882dZ2fLla7xTfE0gwpapeF4sa1I1R0GOU5PrmgM44QoE/FUa1FSlW0bgtp3AjSPBVj4PZLL3L91i0eP3lAtB6lND5EtJLuv5gDcCrEZbBY2ijAaMWDB/d4cP9z3nj9bYJPkIRChEVVxGiwlIwgr5KArrQwTkLwhCiCaMK6Tu3uUx2rBOFksCQbVORxsDPfdiCNtJslgkoMHAWZey4CWNKXIPNPMV8cMMRI2/WUpagIeiefdeidPD6K4YI2eaHeqnRi5b72zhGi4/TinCvrK5SV6Pgo5YjBMbSRlRItfasNZTlDazNK31YKOj9IX0WjqMoZlRb5YZegsRg9Q9tTFwWtj/TOsQqR8voL/MF/8D/HVyX/8v/5f0OtL9ivLWWhiUOHjcI40XprtuCc1ErkVqeuYddR64jpW6wdUDZSDGtCqGEO1cWAPe1x2rCZS03gadScoGl8YOYjV71huW4ZwsBQKKKCg4M5q35D2TX4dcumaej8wMZGullFWyj6QqOt5eqtGxRAERGKoJF+mBgTSw/QYwH6dx9frwEnRNquZTGb0zTNWPsfi1RqWxzyzrNcLsl0JaFxSdt5GvNp+7dVvFNKU9d10iFJbAlEhjSmoauAtpWiiBt6vOvGxpS8/Z/P5mOQBtkt1HXNfD4HtnCDtZYm2YQtl0vquh6hkvl8nnSgheIkioKC61mlaFvx2syBKoTIetMk2GhLXxuxknQcHh7uODnnYJlhCsl4BXoJUVMkip/vB7wTMR+rrZhCKLXzvPx6wrUXlsvgnEjXLua8/sbrvHznDiFs3WtgF1eNMeJj2Pn71Edwq9j4LBPicqY9dYSfQjuwhYYE34ebN28InbG4z6PHT+n6Hu8GvBP5VaOlQSe/jk52dc4PVHXN2++8w6OH9+Q8oxhNSIDeQgyo3fsxzW6dc/z85z/l7p1Xqes92QWyLaoqrVDPaaffugD5HUXDEfbYvlt6DuO1mhY683V6Ljc8X2MVx4UjRsa5lmtF+XFKCf2zLEuatmNW61E8aoTixvsmuwGlJnaA6T4653BhIOK5uFhyfHzCXtptK6WIbjNm3V0riU1RVAhDJX9OJYtF5xgSbdGYIo0zSfqkm7cV2mAlhc3eSVPN/PAqf/JP/wPa8yf8q//yP2E4u2B/VuL6jr26oiyKJFgWyE1cos+v0q4JVAyUWgEhd6IRhwEVByBivMN0PUEplqenLFfnfDSPPPYtMTiu6YqiiXRPzlDe43Vkvajx85pQGjZNx7Da0GwaYiFQSAF4pfPIwwI6BhQeYhofMaa4lsbiJSTiy46vJeuaC49ChnfSvpszg+0DsbZAGz1KNJL4t5kbLVKUaud1YeuMna2UiqKQoGzEQSIk2l/TNkK499L84p0UKRaLxdjMMu3wyy7twzBMzildgIRtz+dzTk9PhdI4m4nPYlVycX5GCJHFYo+uk2Jes2lp257Vak3fu7FqLp2ZeXI+ewOKokh2Ubst41PsHCRTiclkQSEyAZv1hqooSRgBQ/SJe7z9HJDs5Lyj63wSchIa3Hw253vf/R6Hh4fALiUyX/v8PZtMTO/PFCO9jK9OhbBynSIHtcuFPpOKiJcXC2st165dpaznhACf37+HVooi3ccxUTYQg3QKxhioTEXbr3j5zl0ODq9wfn4u+LeKl0T0n70fuwwSxb17n/Lw0X1efulVTFEjcIdGpyKSurQI50UMSNl2eOY9Lh8xXdt8PS5L/j4vaBPjZExNC4ppzKjdwC0vJJDg+dlThsGKz2q6N3khnmL1efF6BmMHQORhHz9+grWGl196iaoqMdZiosYFz3q9op7Pmc0WGKtFAArpZFWo5BXb433E2nzNArrYFq/btmc2m1EUBW3b0XmPdpr57IB//M/+p9jQ8cnP/4LCNzQXZxgjvQwqL+qXajQhFZqsgnlhGUxWII30Q4cNIr1qY6SKHhsDoV8L5XEA7VuMDxirWK7WtG7NEIGoobOcPz4m1gXReULvKJQWU3MfsJ10bareEb2nPzsjNhuMHxKHe9uRK5tJWdS+yhiCr5lxD8NAUe09M3HVuG2UoW2tJbLV1c4BNGs4y8ltiy/TQkwOtFlfo6rq7eMR/nezWScNBllFu66jruuRE527+DKOnDHrGONY2NtsNqKF4jwHBwdsNhuuX7/Ocrkc5WKXqyWr9ZIXXnhx1N0eBnHvOT09pWkHNk3ParmkbbtRKnY7D3fx7fl8PlIS8yK2zTq3nN5MBxTd80BhLUPXcbR/gEm7F+8G0NvdQy40Oufomz6JcXW0Q09Vz7l1+zbf+va3JKNSChe3GfPljD+wvb+XaYpZvnUaYPIiOYVLpth2LsBNefQjnq7UeO4As7rihds3aduGx0+e4rQXzQzlpfoeBTZRKYP0PmBNSVXOeesb7/DZZ5+x2Ww4Oz9nKh34RayN/DulFF3X8N57P+Xll++iVG4pV0Ci2k0Cd/58eXz7sNUWn8JHl4u2meqoJr+bfs/Xe3p+cfqPEefOmff0+/b3RKhqmTuZGpvld2ez2ThPcmK11YUJYyOY1uJa5MOQZH8djx49piorrl+/llr8xQbP+YGL8zMOD44wxhKnn00x+q4Ogx+59igo6nKHxmqtGYkKzkXWwaGsYnHtJb7747+HcS12c8zq6SMuVhu6fpDYo5JQWtqJRCV0QwAdPVoFbCEgcwTWvscmwkTXbnBDQ2U0rg80vScqw14IgEeVThKG/RmD8xhluV5WDFbjdMTUBSgxbImFwWmD15bKRcqoxdbt0VOG0zN004LzxIKEG445d8q4/5YDd76ppZVgaFAoY1JhJGVhyIpez+YMztE2bRKQMaOmxXTrfBkHzb/PgXcYhgRpaJEljrIt2zRrRCJWMtWMW+cgNt0K5owWJANpkxDUtFCYC065izBnJe15hzEFTdNydnbB8mKVmoRKLi7W4jrSD1wsLzg/P6fZbCYTTpOnXJ6Ms9ks0amKnZ1G/szTYDfuGADXySbz6tEV8d/NYvtx27WYj7yrQAkDZ2Zm7B8e8o033+TOnbtSuPT9uNWeLpqjUzvbbfXzAtzztvPTrf7lpp78uvm658+fA0emCnrvCT5w7doVvJeF+/T8HKOTtoyWWknm4gptUuOdRLRvvP0u7777be7fv88//y//C5kXea8an4VJdoqm0aOM5uNPPuThw/u8+PIrEBQ6pMJ6lv+FnQV2hDqSQcBl7P+yKFemWqrUn5ATisvzYWdexAyV5M+xrRf44EcIMWebKopIU2ELVKKQCgxR7Sy8eZxqgwTbdD12OOgJbVJEvI84Fzg+PmFWz9hfzOVcEuy5adas1hdcKat0frsLuwhWiewxgLYa7c3OjqxpWsqyQGmF73t0WTMERW9Lbt99i3s3f0HzoOHqtasU9Yzj41MRhwsRlQxagmxpRgqyJuB9iyrFRi4oOLcROzgWEZo4sIoN2hlQmtnRPt/84d+hvHKd+z/9G9bLJa2KRKWxQRIzHz2NjXRGgq2pNNpbXKEpbAWhoFSR0hSiSOAibtMRBpca8uLEl5TJWOQrHV8r41aTnCPGOOpgVHWNS23k0pIqOFLTNHR9D2mQwrbFfBqk8iDKk1cpRV3XXFxc0PV9sv+yQKRtG0KQSdI0GxR+xIGBMcvPGUPTyOOvXr0qvOyUyecsN2epOVPMBaPlcsnZ2SlFUivMcq7L5QqtTdImd6w3HU+fPuXx48f0wzBeeAkYasykxdqsHgPbdIJMYYvclRmD8HKN1jR9K1rERhNdGKGFnMnmc+66Tha7sgIV6dqesq64fv063/nud9hbLBi8l2aGXPC9tNsBkpQjYyZ8GQ+fwiJT7HsarJ53TNko0/b0LCEAYLQIZN28eZ22bWnaNmmb90ljGXSAaBQxCPshqEFocKakMAV377zKCy+8zOf3P0droR9uqz7PYtzbQxq63nvvZ1y/eZuiyoupZGlTnfIphu+cS8XI3Vk3ff0xoLPNkPOimz/7c3FteTS5oLqL1sTxLX1eZNMiE5KSnrUW1zVjwAaSNV++R5qiFM/WaUDfnm8qjEZpzOnanot4wQOt0S+8wP7+goAS6CTJHB8cHmFtNRY/87WKkZGOGfL4vgSjdV1H3zvh1IcWHT1RVzTOs793lZt33uTX9z6iiJrZbM6NG5ayqjg7vxDVwOBQ2hAjY4D0rhdXelsTlCZ6OK4URQ8LBb1SdGhaJYbid7/1e9z5X/0v6Vcdxd6Cv/nX/5p137FxgdCJ4FUz0wzzgq6QRdikRHnlOlbtgNYFqrQMxhCVojOGVQysY2BGKlJm6CvvooIUn7/K8TVYJcJX1iZdFJ8wHJg4N2zpSz54Ts9OaTYNs/kcY/TocLErRvTsAM+HYN0bbGEhyvvm5pnoXdLdVjvb86ZpxgmRC6KLxYLVajWySzIFr+s62s12ULdtS9d1nJycCP+3bWlPzzg8POLk5ISuHVit1qzXGzabhq4fWK0bTk/PefLkiVTr09USfHC7Vd7b2xP82TkWi8UYcC+bHWS/PQUooxl60Re5euUqQ9dLh1yMqVNtq9edtbZ32t+T68mLL7zA22+/LQHCaKbUMthivRlaCikATDO/aaC+XIS83JQzpbhNcfx8Lfq+H6/5FErTWlMYkRMVTe/rnJ2d0/cDZWGJWqHT59KB0ZRAaVFPjIHxunznu9/jwcMHIvazM4q/6IgipRsCH/zmfb71nR9w41Ytsr9OEYMYAXwZ1RF2oZHLkJLWOpfPxucVRbFTxL08D8b32MG4p18kjFtgNT1CPPI+dV2xbC/GgnReMKeORZF+Z3cwvZch5tC9tZ3zPvDkyTGuH3j55ReY7+9hvcUWJW3TcnJywo0btxH9+yRklRYLpbZdgtpsdXistaOekDTK1RQqQHDEWNL5SKE1V194mdnBFYaTNQzS2Xz16lXKquL0fMmmEYKAcyEJjwEEgvI4EwhKGpYuKk3thXLbaU0DlMBhPUPVFbGc8fThPWY3XqC7coUH6zMedy2b0LF/sM/RK3c5fOkmLCphmWnRfP/tvc94/MEHuGWD8oGVFhvoJ3iIjjMDhxrqmDslJjWLGP72WSUCoAvO7Lwn+m0hUdqUvZgamGIUotqs16w3a27Ym4BKgzRTzLLmgmzHplZepMFalxUXy46hbYGKEDwXF2d4P5BVAL1zlNYy9D2t31ohGWOYLxbEEFgtVwKJOI93nqCDKPv14uzuUqNL13Ws1htOTs5YrlZsmob5fMHjx085OTlLzjvy1bUtzsP5xZrT8wtOTs+lmQAEn04DPQelvOPIcMk0050WJ8fsw5rRXWfoO6zRSFthFC3lrgO1VREUFor4+g1JmwSEG37r1m0O9o5SZ10x4ShP7u9054EUjoDJZNsN3lM8e4qXTrPzKcabaxwjJjzJXu1kx6QAJVRiqrri1q2bnF0speMuSH1BxUknZUwsCluKm3rCT1959TVefOllPv/805T5CbyUC1b5mCYN0lhU0LRrfvGLv+bvXbuGKRSuj+JfWKSrlrBIpfLMSOoqkyD93AVPiW95nlAKkgzxs/fiGcz62VsGuT8i5h2Pz8tCKnTF5OhEYn9EbKL+ZfhQKUOBuK/LwgOwXaDyZ7DGJOtBNWoAPT05o2nWvHjnZV584UWq2mCM4+mTx+zv7VHN5righDo8eEosxKwMKrIWwjrRlLagtAVGaVw/oGc1hbW44Am+J0RFh0EvrqIXV+D8KfRCM/QhUBYlhwcHFIWlHxxtO4zwmNFWmCxKZ2823GLOJkqPx7qyxKqiUorWVnzwwaes/qt/RRM1n977nA+HgY+V4p6KLDW88dItXv7hd7hx9yXMrBJeNorVekW7WeFv3ODMPcK1PY2OeBTntqII0DqXOP9BWErKQwhE71B+4KuarX1NPW7JsplkXZAwXBVREUyM6BASZa7hydPH3H3lFRRmsk3aYjlKqx0WQwgBFSKFtSitmNc1XbPBu0XKWBR916GUUJA0ERcjflIRV0rhQuDi7AxrCyk+Jod2rTV906cqdks/9IQYRijk9PSc8/MLTk/PMMYyOMXZ2dko9bper8cg3/eR82XLcrVhnVvcybKdMe16IovFQlqAJwFrCjNMt4ojvUxFXHA07Zq9ukYDtrRjK/x0DvsQUKnbMkbhgPde+Mx1PefmzVvMZ3PJQHwUSmNZbndHl7BtaUvfbmGnO6Qp93gafC9rlUw54FMseAqn5EUtv9dYvI4ekuTB3uE+h0cHnJ6doIJCxwKtRN8dHRNNT6OjIigwlcUoiy0qvvXt73H/3j1AghojOet5mbdCqyLpf/R89NGv+N53v8uNay+Slf2CFyoXpOAasr3WbrY8vZ8jUyhBHTsFyRS8hYHxHDbJzotOipWSHTAWFhO+TsL/lcoFUI3RJcaUxKAEe1XSgKOUTvesTfMZQOQIskKjFP91yrQTYyP7YCJZ7cnZBd3wEcFHXn75DlVVsRkaHtz/jDt3X8OFgqYbaLoBY2qU0hTGUNcWY8UJ3tqCwpRSN4uK4AaMAm0KVHBJJlWxiZa92SF2fpVVlA7IvOPrhh4fQjLrAK2NQIaAwkhh1PdS5Faa+vAKKz8DFGfzgrMrc5oAZ7qgbhx/+f/6F7SLmmM8q3nF42hZ+hlNVXBuS06UQ7VrzNCObJCmbViu13QxslYKFz0uMSri/IjgDWozELoel+oPgNQBXU8Yer5sCEyPr60OGEMWaZpYYykIuZkhbYOKoqBrOz777DO+/4MfieOF2bZIbwNDFoZHBlDaQuUJXhYlQ98RgqewJbPZjCePe7T2dH0H3hPLagyMOcPJkIO1lvPz83F3kANMdmzZtA3r9ZpV4mE+fXrMet3Q9wNNe4EtSh4+fDhaKGWIo+t6NpuBtu25uFjuBC4lo156h5Rsh6dc6HweeXJPi4Bjd6KKFMqy9kGEqGJM0pZp4k8f6xwutdx3g+DFWkkxan9/j9u3b5Pb/vNgiSEIKjuBq7YwyG57/nRXMIWy8nE5aMNu4M6vPV0ApqySPCZyW3geayBKhXt7e9iiwAfZGktTUt6lKJmYIVDokrIoMcrgBs/rr7/BtevXefLkHtYagg+gno+/x3xNQqAoDavVivfe+zl/8HdvoMYsSGiI+fymjUg5Fb+caW8HRb4Ou++bFzE/WRCmsMnzrvf0b1sYZffDCBQhgk5lUeK9jDetJNOFtJimtvFcOM66PNaatAtKS8tl7DvG0QGm7zu8/whrC1588UW01pycHLPYP6Dcu85ms6JrW/YXIqhmEnMEDWVVyYKSKIc+ebVmmEbep2dAYwqDKUvqxT4BLbLFyT0rBtG6cV5osCGI9Z9cjsyp10mZT3a+YX8P1nBSaI5n4o9pGLAKKrdC946liixXGy7cwJD2S588+gz3Vz3zxTwxZXqaRty6lsslm/WGdrNGJWkArTVXjg5ZLPYI3tO0Teoy12PQ732PC24bC3/H8bUCd240MblOorYrnjIqCbFsMUsfI/fv3xcWSvKqzJX07fZ4m70rg1h7RVmF8qDORb2YgpdwX3vOz85RRPZuLUYK4TQoih1YTBxSnQwbhIt9fn5O0zRcLJcslys2m4amaTk5OWO93hB8YL1pRGOgacbPFCMMg6PvBtpUDFyv19vJpraBO0bBnDP96jImnIuWU2eZ0SNSyfa7KktmZY2O0ihRVgU+yPYwX2vnt40MecHLg3V/f5+rV69OWB/p+oaAuUQ9G4NqolPBtmA8/XsuMl5edKZHPo9px+UU783PmwapXJOQBU6yaYt4ce7t7dF1J8+8j/CYE9xmpKu3MBaFYzFf8K1vfZv/93/1AO9EiOiLEhpJjPI9AhUjv/7gV3zzm9/lyuHNcZeYA/IUDsrQn1JMFr/J+ZFQ4vz5E8QyLVAO/vnyAV90bXcee2myx5TKG60lABeWrh3GGohKi4zW28CRx17TNHjvqes6wWBFysJ3i7I5gQmpdX2zabh//z51XbO3twACJydPuWJntJs1bbvGDYegwBaFGD8YiQeFNQwDDINQPzO3PQRwztO1LaqU8wnA3uERQZf4wRNc4mwr2Qn4MIhYmYcu2RAGZFeaeD+ohP3HKIF7XRTcs4ZeRYYgnZPzfkURWgar6Qg4knheBL9u+fX7J4RJvJMdVBQKYgyYGLh9+wbXr12lqip+9KMfUtQV81lN17VEvaszNLgBF56tdXzR8bUacBTQuwFlLHkKZI0DkWgNqQKdmAgKHj16RN93lIVkxEVhWa+3bIoYxcIKLSuuQAzbQKK1aJhoLYtGZoX0/ZrVasV8VrO3tzeyMUSkSqh3dV0n13DFcrnk4uJCWsfPzjg/P2e9XtP1g+h39wMXFysuLpa0jQTkwXk2rTi6i4peJLu394PDDS5lHW6C1+8Wo+q6Houh8vmLMejlxWYaBEZ5VSLnpydc2T+QQI9ggcGHMShba+U6IjKX+X3d4LCmYLFYcPXq1VEFcSysTQjB02CcJ6ZP0NU0a5xCItPgO82an4fvTjni+TNO3y+/Tr5eWR8mxixtK9nR1atXWa8bNut+y4jIRemM9adtt5CaFEoZ3nzzLf7yL/6c5cUx4nK+e+wEwdH4OhJV4PzslF/98hf86EcHaFWg9baT8suC6uU2dq1zB92zLJPLMNn0b182F3fO+3mPIY/FRAow250UbGWAldY4t20kyq+/hXmSwYTaeovumG9EUZ8k9pyfn3NyciLdj9HTNGu6+59zcX5CDH5UDTSFBa2kgcdsuzTza3ddK+PPGvrVQN93zKoa7wZCodk7uIrDCrUv5k7fgJt+BUYDbBdkQYhmy4tTRLJBuQuKoCuc0zjvCS7ilQfnCDoSVaSyFu0dFjFp6FKskoUzaQIFobMWRvHmm6/zk7/zd3jlzstUVcX3v/ddhujR1jD0PRApSmkUJIIKARXCyOj6XcfXCtwjR9cmF/KR1uYIKKw2idWQuumKggcPHvDw4UO+8eZh8ldkh12St+Z5a6eUIjoPMU4yPZnI3jnaTrqdNpsNkci1a9dEdElrVqsVIQQWiwV1XY96JFmidRik0/L09JTz8/PR8Nf7QN8PiYvdpgAlprqDc3jn0coQougrOCeuLdMMJRenyLq6Kejkz5i56dNuu+kkmW6vZWIogg/s7+2jXZBicCoQRZN1ScK4WLng02IjErCFLdnb2+PGjRtcv34DyAFy2+k63fZebv4JhJ0AnO91btfPn2HKRMgB5XmFuSnlcrozuLwIbBsQtq+VJXCfPHlK2zh0OmdDbraQay8NF0oKfqWmj5FZPeett97mr/7iv0t6319S/BmhjG3zzS9/9Qt+75vfYjE7QLo1n5+zq7R4THHtncWMDDWANIk8C4lMu2d/17ETvGPurGTE0f1kUS1sQQvjZ7NWTBOMMWgjPq9Tqua0MFoUkbLcHcd58TbGCKPMi+hV3w+cnZ2yfzBPkEuA0KNxWAt7e3Nm8xptDWgoyhKlNMPg6buezWbDZrMZCQw+6dWALB8hBnrnMdWMaCsiUssSeMTLNY0pw44hwU+R3g34MZkUyVXnenTa1eIDqvWUg6f2nqos8KWiHQa00ezP5yzqCgsoH9h0kugNXb9FF9JOwTnH/qLilZdv8+qdF5nXFUYbrh0ecbZZcXJ2hg+Oqi6Y1TPROdca5R2WZ3dPX3R8rcBdVTWbpqcopc1zSo0ibgdu2/ZEbTDA+fk5H330Ma+/9qbcAC2cz82m2WZ55C3fluQ0yU0muKAaA3rXdXjnmdU1SkkBMQSx5RITYi888q4fNVO01pyfn3N+fs5ms8F70TdwznN2doEbfMLUPOv1hrbrUcl8uO+HsXDoBmGnxMjoKpO30SNUkiZtzrhhCw9sGxL8ONFzh2cO8Odnp6OBhDUKhRRsUQrXu2T0Gkb4yfVh3L5aY5nNZhwcHHD79m3m8/lYSLS2QFvJVC4vIjt4bdyFXi5ztzN0dRk2mI6XfFwuTl6GZqaF2jymcmALQail8/k8cfEdMWGgESluS9DWwhqI6We11dV+6+13+OUvfkrTdb9jWkyCYXJvubg45Zfv/Zwf/egn48I3FhynQfbSdbmMce+yRNjuSlNwfZ52zBRXft4xxbjlemwZWWMzjsowB5Pa0uScYm7r1+N9mi4okrEXO5BXDvLiEpW6K1PD1Nn5GVfXR+zvz1PjnObo8AA3ILr1ClCaoiwpyoIw5B2sdPuKZlCRxnIEpanLEq0helG9tKbEa5t29yIN2w0O50WXJ3ghLAwpex281ICG4PHWg464ocMWWebBM/iWW9evcuvqEdcOxUczKqhswWI2pyqELdd1HfefPGH49HNOTz8j+EA9q5NHrXSHXnnhOjeuHKCD6AsFozk/W7LqGlarJSp4lKuwPqKcIxqLGhwFCvsFNZjLx9fCuMuqJKwFOsi1+WxyG1I3W9d3EiAKi4+Roet47xe/4O/90d9PN19RVgWr9WYcvMrJi6lcZZ9kEzFhylCMGiSjhrYx7O/vjwGhTEyJYRhYLpc0TcN6vaFpNsxm8zHryw0fMULXezabdlzpQyAVHlvB84uty0we2MPgBTLppCiRM1gZ6NviYeb15oCcJ0suUOYCaVEUYzdhPv9hGNg7PMR7h1VbDByEStWlorAYFQ9j0dgEKUjN5nMWiwV37twddzXGWEzaXjq/KxQ13dZzSUfmcgCaBtisRzJ9/PQx02uXH5OD9GXYRF4nLyghyQXLLsMYM4qHDWm3kamXSqfdmjGoqCEosc4KoLWlqmru3H2F9z94f7wzl4+YB9uUHx0jpjC898tf8I1vvMv+3jWybG7+rCMcZHRqFIs7i1x+nW1yvBu4p7DE82iUzz3XyWvk4MsYtGWhk0uzXVyVEr2Qvf29dJ7b3otsgDJdqMexgE50wi3TaKu9DUYJr9v3Hc471CZyfn7GjRtXEkTkmM9qDg9T05iRXXlZCYd6GETjZ3lxwenpCefnZ8xfvCnvpT3WGgwRPwwMXlFUBT5CN3iMC0ldUJQwBdsO+GRontU5Q0wu9WiiydfO0w+ykLexxx5V7L14xPxoj8PrR1RRU5qCqiypbEVZ1nJtI8Sy4LjpePzkCU+enggtOTcjVjWv3H2Zg8WcdrNiKBaEquD8/Iw2iMmLCYHQDfRREfqBTBhIw/krHV8z467SSr5d2UGwweAdKnUJCc44JJqP4TcfvM+T4yfcvn0bvAxSYzVDEF865SKFEbwr34Rp8W2kvsZA260YXEvbNty9c5fZfI9mvaKsa5rNhoAwRpqmoW1blsszVusVTbcBhHrog7Q3E4V7udk09L1PKoBiQBAI2MLgncAlShkZaM7Ru4EhRE4ulvROmBo5eE+LUFpvcegp7S8XFNGaWVUJt9wlq2GhehC6gaP5HspHookEDd6Ja7wxBl0IHhwGCM6BMng/EL3CVhWz+T77h9e4ev0mSltM6hLtnRuF9S8H7Z2t/SWcdhqMp7z0zM2+3D2Zn5sfP32tywEq/16kfFOBNoJGJIAHHyiMwViDssk02Zjkjm22MJuxgCY40Q3xwclEiPDyy6/w0Ucf0g3ddkFKZh3jkURQFCrxjTUxeJbLMz777EPeffcQ8ZzSQm/VFm2UYKWTXdZWA0QObcyo2z0Cr6Sf07iZatVcLuBCVuqRAK0UQvubsCZiUkGMaT7Kz9mKTmOsTVBEw97+Aq1tgi6FdqkAH6QtXe61Jq33aK3oe7k/Iti2jQlRa0oKIiXDAH3vOT25YHnRcP3ajEIrqqqgLzyzomBRVRR1CToytD1tsvo7Oz/j/OKEtmtTx6fBGGkoCt7T9J4uGmZzgwuOznco5wgu0A2O3kf61JLvQ8CFOMLFPhhcMHLF8v32AyGm4uUwEGNP367ZbBQPH/fM7ByrhQ1mTaIyK/EbaNyAcz2lNVSFEalnLfHr9s3rHO0d0Kw22Khpy0NiMafbNESjqFWCp5S4VLkA2chCa/XlUN7k+FpaJXZkPwTBWi+tznnQhuApywqjwVjNxfk5H/z2N1y/eQOTkBxbFqkRpRYeI9K1NuUGe+8hgjWFjKDEUe26DmMMr7zyisAySEdliHHEuTebjWDW7Yq2FTy8sAXiwbctiIhsrGKTAr0EVZe6RBXBicqcDx4fk62Xksdvmo44Kd5MD6HrbYtzub1+xCbjttOzTBk3gOuFI3718AgVoSyFJWOsRVkz7kZijDRdS9f1DINPOLJs5QtbUddzXnjxJa5cvS6xIrM42AbLaeD8su04sPM4rTMHePuYaeCePn76Gvn3U5Ep2BWd0jFKwq/NWDPAhZFmCoyFUzkXkwqamhhFp0KyLtHG7vsOYyzXr9/g1u0X+OTTD0HpBCtMIJ2Y/hdJaY8U9twgbj/vvfdzvvGNbyV2lLgqZcsprTNkcynTnnzmUbom/02ptPAIyyRDO5ez6Vz82tko7OwMxr0eo4StUmOBNmuRW1uiTctytaIoLbNZLTQ6QI0FsTgWC0MIyTgk1QxSAHdOj3h3CIG276R1vcjm0o7j41Pu33/Eres32d+bE4OiKg1GK2Z1SdSKtutom47VquHJk6c8eHCf5fKMg4MDFntzGUuJN+9DZHAeikqMFzYrNs2aIol6eRRRaXyAwUmtxwVhqWil+V/8+B+ODJNaz6j0v+YP4r9HpGQ2/Av+/e77dLxCMfpwCsMoX/ecjOV/o6B/65v0XS8JWIbGtNCX57Oa0hqMNhxVNVGRqIkq1Y/kEOm8vGMCFcWx/qscXytww7b7sR6FZOIIBUy3e5vNWjSxkW3N3/zVX/F3f/xj3DAwqyvqshBRpuAJSuPZlQbNgS5zTfOALooaN3hefukuZVnhBilq5MGWC5EZxw5hYFbPCSEmCVahCZZlzWq5pu+FFrharXZaguWzxFRsBOcHmahG0zcdZ+cXkrkrsxOkpgyLy9rG08CHEnZwUZZ4J9i0Yiv1eXB0hGJX22XExlMFe3vd7dgYlLOi+XzOlStXxkLw5eLhtqHiWYGjqHaLX89szdlmy5cLq2OGeAkumAbxHKQzZJL/5pwD7xNUI9mRBMZt1i5TJwe5dI2VIaLSFjlBMJNCrElFy7t37/L5vU8YUmH8ixarfEx3ScfHT/no49/yrW9+F2Iy29UGLXr4Y+DOxzR4P/Nvxc41y59tWvuYPv7y7jnyrCrg+Pj0/xi39yjDE0ZbmnbDyclpshVMWiaJipjH5uUxkjXqM1SYjbcB6uQPG11IuwbH0HecnZ2J8Ugs8F6Srs1mJdCiLWgbx/n5msePHvPo0SNOTk6Yz2uuX79OXc9wzidZCQdeIBC0p28aludnYpziAtGL+JVPu4wQEUOFEPjg4ef81x/8nP16Pl4cYyImarowYG2J84bDq9fRszlbZlyuu8n/xpqbUmPCVe9JHSXfo+mimy4mAOcq8km7JlaVQHoJmlJ5Z5dvWgS07GC+yvH16IBaim3NeutgnjOvfOLTSZmrzqD57W9/y6effsrrr78mNlzaYBMFqizsNrtQ22KXbFUnTQZaceXKdV599Q0O9uep4OVG3Ns5x2q1Sl2NydZIG/qEI1VVSd8PMtGDY73ejN2Qy+VyK2Wp1MgHD3h8TA4sqRh5enbOZtMhvN/nB+1twNgWhfLkmFb9/SDKf1UpWtt5N7G3t0dI5sGwO6mD9/SuRyXsVwqkkuFXVcVisWB/f58rV66MmXweVJex5inbZYs1Cywx5VpPM8AMmVzmoOf3uVxki3HLT5/i4Jd/3kIeAmP51Fa+u4XM2XBeMKwITYVIULtdqUBqQpFegGvXrnPjxg0ePHjwO4N2vm+Zyqm14r33fsrbb71NVe2htGibiKFDwonZDdCXYaPp9+k9mAbuKSVw+jl2IJ20O9heR7XzEKXyT4k2aiwDAmEWtqRpWqxdotSBJCeEtEiKW5C8t8bobVFyioFn9oksqFIk9GG7SGstzKizs1MODwsKWxNiz7o5ZxhuoKJiudzw+NFT7t9/wPn5mbAx9velyzjVqiJKKH/DIH0dOjD0HeuLC1zXYdL8790gzlXe0ftUhAzQNi3/x//Pf4ELSbtFK96c/0fcqX/A/7f933F4+Da37/2vOfij/wezN88oCouKgZhcjGTn5lK8UqnzW2oIWhsKWwJby0BSUkUQFlhueFK1Zl4fyshNYzxGgYB8qhdmamFUl5fp5x9fK+OOqZI8xWzlizFbjXFrQrutTitOj0/4+U9/xit37qIRzK0wW3GlMbtOr73FRVPWZRQxRBbzA27dfIGLi2OsTVq3Saq1bVsuLi7GTCHDNtZa5nNpxiE6Vus1TdPy5MlTnAusVivW6zUHBwfjgJQuP80wBAIelGLwnovVivPzi7Rq7mK3l7PKqfoZbJ3OQxCM1lhLVozeyaytpe8EQ5suhKPUJoKJDs4n6pRUxouiTNn2jKqqdhpvptlU/vnywpIfU1TluIDmezF1dpkWJnOAyTuVEMJIGcyPn7rd5OuUf74MrwjNVOh4IOawISZ8X/zLxt2QtYIzS41BLPBy+/luxi+vW5YFd195hcdPnuxk+tvjWYhjG6wGHjy4x2eff8K7b397hMFSEoZiF9u+3EjxRfWE6a4k746en0VPXus5mXbOwHOGqLXGR3l9n4yxBNcu8EGyWWMEMsnzVpgiUjcwRvQ9ZMezPdfM6ALRksmZqNZbHXytRP/+yZOnXL0y4+DQEKOj6x2r9TnonkePHnP//gPOzk7puo7DwwNu3LhBVVXUdc2mkfNzg/itusGhGLBonj5+iOs64jDg+yHBI27Etn2EwQeGIHi/j6IxL0oKaT6EQPBurGVkbRcpNBcoFdEmopwUSaf3TCV9GVukTuA0XmNaMD3SEKRiREUxcE6XCaM0Nu24e+8xiSkW04Kt7VcLyV8r4/Z+K4SUndF1Gtw6ifrn7VT+kM45nIrUSvGzn/2MP/7jP5ZJngKHmPwOO9vG3BoNEHVuHZcKSl3tcfvWS5yePmW9XokLTmpHPzs7Gw0R8uBaLBbMZjNihLbt6XtH03Q8eXLMer3hYrXh0aNHo0tODkCCv5vE8Xbig7fecHxyJn6G1hA9O8EQGDnd0QhGm5sVptvukQsdAj7GEbduG2G33Lx585mg0nXdyIiJMYLevcmSGenUXi/NN3t7e2ND0mVYYhqEp9m3SVzxvJ2bcnunwX660Ob7nLthpzDXlAI5pZNNA9gObBOkjT347KBjxn9vd3dWdhi6YAtViZ9isMKFjbEEPDEYvDHYoqAoS65evcrBwQFnZ2e72e/u/8Zzm353vuOnP/1L3vrGOyhtUSHrkWwpdtPnXsb25dV3oY8dat00w/6yYxKz5X0u/T5OPhM54GTNEYs1JcPQsV6vUUpRltt5PWWP5M8QQtzZVeXegRACZa2oq5qytPiioOsMfdfQ9z1Pnz7l5o0jqnoupADvOD55RKDm0WOBR5wTzf3XXnuNw8NDcWtP4zg2QbqUe4cbPFUBfug5efyYdrOiCNIE57wfmUY+Rlwk8bYTu4TEMFFMfGDj2Oyy2axpz05BG5SWcoTRWrokw5bGukuJhS4ZU4eU1I470hhGHFsrhU2MMaa7yhQbjN4mIigwf9tGCvnIMowZTwUJGrOZiLRPJ2fWvTbaMHQ99z/7nF+990t++IMfEJWmNJbWCyE+B45pBrLdmm9HaghQVYJZr1bneNdhkg7H6enp6JQeY+To6IjZbJbcYBrWq4bNpmW1EibJxcWS8+WaruvY29sbcTvRIulQStP2PeumZb0RAaqm66S45WUShrxSToqzRsuOoq63bfjTlnYpgHqUFtU1hSJEz6YRiqRNTQ4EaT7JNMauE844CffMmfJms8JaKeBKi710k2aK4XTRmP78vKwvqwNqs8WVLwf+qW5JDtB5my90yWHUZ5kWMqfb7S8qYmqlcN4RY0jnYEalwpAgM2MMWbQsU9a0Tn9TBsYd23bXoFJ9r65rbt68yfnZ2Q6U8bsOMUB33L9/j48/+Yg3X383BTk7JhU7j1e7tMfx8yUFv+m1GOfWV8Q3v/6xZcEYIwbL3juGfkj1oTlVVaYdZF4I1LiTyf6e20CeoDC95Z/nYDQGNxSr5ZqnT8+4cuU6gYgtNBHHyckjTk+f0A8tdVVz9+5drl69St93HBzsY4xOkJFY+PkQBEePka5tWJ6f0rcNgV58Z0NI+iSpXyBKAPchjoSCCAK3pQaqGALeiQ563/X49Ub6AHJTTgStbNITyWMvSwTHEQkYG6sy9TeI0Ne01mPM1rhkep+ndSLYnQu/6/h6Rgpatgd1XdMnvRE3DELTUruNGFOMEa0gBlarJX/1l3/BN3/vXTKlbDppp9joNmj7CZNCAneIYG3BcrWia9fMa/GIbJqGa9euUdc1d+7cQSnFycnJKCLVNi3eS4NNLmjmjDGL67hclXaewfX0g0Ax52fntF0nCntKb7XIY9LUsMKfDkE6N2/cuIGxaqQlTrna0oo/0PW90PO86IZ45zg6PExts0a2VDAWhzIEpbVQKYW+2LDZNOzvFxRlQT2boY3hypUrY+PNFLoaYSS77fLLQWSEQGIgDnHnHuUBlh83zchyN92Uuz2teeTHTWGwKRd6Gth8ENaONlu+eRYOypM5M0mMlqKjUhCCTCKVOMd5F5aLTEppiqLE2oI7d+7y4MEDlstlGm+kApHaxZInh1wzS9c3/Oynf8Orr7xBWRQJtuCyD/HvPKbjPcY4ui590WIyQiE5dGQWzPYRzz5nrAekgpjOkgJiJiy7vH6707LTXVkOTpqisDtjaMy8fRBjE+8pUwegMUa49v1ADNA0PRfLFWVlWezvU9Q1KMP5+ZLgPdeuXuPmrRvS7VsW1LMaH4XR4lyg7zvWm5a264jacPrwHsdPHuOHgcAwjjvv3LapLEg7uotCXQ5RZBH05CoZbcbiYuZhh6zAGJECuApCx425QCljTamkYLlzrQUalfsXR1myqCPRbzNxpRQuCkQj/HmIsRfPSTUR3Psdx9cI3Elo3gXKumDTrBjCQFSB0tidzr8dUaIQ0Eo834au4Ve//AX3733O62++AcqirB6Dy5RpsMVEFS5MtoNK0XQd7TDQdoM0WlTivJE1SmazGW0rgu5d34MSwSuMZRhaBu/pBseQihtlabd4rwvEoIlBzksZzaZtadou3czM4xU5TWPUSB2saoEosvdlWZbSODKf7+ClXSfbVFMUzGczms0G7xx1WXEw3xMjZqUJgxNhnORErxLGOHiPC0kAqCiJWJQtsVWNrWaYsuTqtWtjxjutS0h2JM0iPgYRCUpxwrkthj7NGKeFtmnWnjFP2DUfDmHXm3K6QFwO2M9mnttAP3iHD6mtOT1WG42OWWdim4mP9L7gITgISZQ+ZlqcxtqKslhweKB46cU7/OpXv0hSHOm58TKQMRn9QQqhPgQ+/vg3PD1+wAsvvEKMBucjJk102OVfXw7CcRt708/PYt/Tv13+GRIldedF8s/pd0mONQShyUk/gcY50niQ3Zkw2Txd5yisS/dIpFtj9MToiHG7WD8DYyaIwLuBLsjOsq5rgrZoW9B3LRfrC86WZ9xe3GQ+F29UfODtN17i6emKcn6IsgFlNHtHe5Tzkt4P9HGga6ST8mzToosS2g1nT++zOXtM6TscERdy38e2cB9Skic0QUVU28CbMS2jDNqn6xU8liCPJxnFKPERzfCZyjDLSEZ4NsD6zGhKiYICCGpL91NmnGsKBVlpOJMf1LPj5YuOr6fHHQJdP0gBKWUJ82R+q1Cj3+OW0ZHbaHt8FOrbyckJv/rVL7lz9w5lUVEWJc16s8PfvryVZrKFyL5/m81GpDzLktVqxcXFxcgEOT8/5/T0NAVHYZJIt6Wnbfoxg+37AbFBS5zUpk9dlY4QhD+72WxYr9ZApiimLU8UHAwtHZt7e3scHh6OUA1ss/kpPphb4JXW0szT9xhtWHcbDhf7KIVYsWktnYBaUaXPPCRKYVEWkPz0hsSq0QnHNdZSlOUoLJWPy9zpEJ+1qsqTc8poGB151ETF8TnwS772U0Po/LyM4cKz7KNnMu5RLCtniqCjZHKm2A5XOd+8uExa9XOBbjRDzlQtg9YldR1wbuCll17m83ufslotQUvQ05gvTJolwZUEYtNs+Mu/+gv+Ry/eGQuFmt0x+2zA3h3Xcppx52/T5+5cm2eC97Nnp2TlGROcmAqmET0JPhlPzSVxCTBZLK2eVeme5jqIME6m9236722iJYtjhlBzHSckcadhcMwXc+pZNfZkWONRusTFEqstBwcHHB1dQSlNPwx03UDXdrRNw+Ads6oCH3j86CExSMIVzRaiyjDkCMWh5WsbN3dCrUIlxhuU1rJ3dEQ0BSE5bfmkcZ7vwxQenEJG07Gc75/ASrsaPtP7vMvSCuP5abUlPPyu42sE7kkxSWlxHh8GYl2nQfgsbio3P2BMIQLnyLb/v/vv/pwf/Tt/h6IUudbBDZR+K+w/DRwoUeOa3pwQw2gB1q4vRJ714oIrV64SY2S1XHF2eibZ6WrDar1m6N2IcUkbfCsaCb1Uo9tuwLsW50MaXLBpW54+Pabvtx6J+YJrbbCFtDofHh5ydHS0w2XPGXb+d+ZX5zpAmeoDZcpAhmSSWhQFOiqsgqKwIxae9Tq6rsMlh3vvM/Yn75Hd3kWHe38Hc5xm3CGEkas9zYqnwSY/DpjYwG3lXGOMY/aVd1l5x5Wz6HxMJ/n0tfNjpv6T20KfQisjMggqueTkln29LZJO3yNrOWeoK4SAHjFEobjViBHH4eERt2+/yAe//iWRvGP44mxH4Lq8YzH8+le/5PjHf8j16y9SFMJe2hm3k/O6/AW7zJAdaDFltbmeEWP8krN6/jEGd5VhRz3uFuW+RxQBa0R1E1wKGFsoBXatBfO5TI00RsgkbF2NMqQnY0fhndSogo+0bcdslnZs0UthTmkO9ve4cnQFYyybdqBpHJu1Y9MKU8wNA10Dfb/h6eOHch8QX03nQ1I3jKkZLu88nr1q03szLermsazLCmNroTgaaX7LEGquMWXacdZCyklqfl3R/S8py0r6WJI14XThy8+fsuimhfyvcnwtOuB40yJUVcVquZKb4OUmXG7tzhMzBxlj5eTv3fucX3/wa27ffgGXsqLpSnQ5WwneE7EjXpkv5mazwXUD3kWG3vPSiy9TFjUXF4+4uBA+dzc4un7Ae8esXrDZCCbsEoVI9A1iohP2KGVwKjA4z/HJCavlJm0t07mELTSglOhdHx0djQEy/y3GOBZvMyNiSvXSk8Lkar1mMZ9z5fAKhRY+qJpMap2wxpELrTV9I12TprBkh5LM6MiFwXz983uP1XEjvNPLgXpaoMznmLOoKRd9+py8UOXH599Ps/TpYLxcEJ3CJBL4c1AQyNloA2rbtGQS9p3fazoJRH9le+4hqPE5OQMvipK9vX1C9Lz+2ht8/vmndF2bcM3tWL98KKWltdnIdnfTbPjpT/+aP/p714RPr5+dSnlM71IP4zOPmQb0aYa2fcwuQ+TZ09t97ct/F3oaqdaUdrBGY3WZNilSDB76QXB7La8pRr/bsZEXbdhCY5fhrsu1rhgVzaZNO2JZlL1PDDQvUs7RL7Ba0TY9m3VL2w20rWO9FrNon7jZzdkT1hen9H2HDSE126T7niCSkQ/NVgHzeYcwUGQ+tW1L27aU2mJLqXfNFzP5ms/HxCKPtUy8yDTkzLya7k5j3LK0tiyd3fg1/d32/v8bgEq0VphoEp9bglLTtuwvFkS/xaVtysbHbCwEjEkOzyqwWq357//1v+Z73/0+8719oX+F8MygFagh++oxAoRZy7ppGlTwrNcNt269wEsv3eHhw4es15sUjB3rzYZhSJNZSVdl23QCmbS9UICUpumlWBgiBB9ZLles1w1K2UmQy+7qiqKwVLMZV65c2clc8wCediwCY+FpOkm9cwyuo1k3XH/xRaJzqCJlQUEkZI2V69f30trvnEuSsVv3HKIene4zzpiLirnwNV0Q83O393U3g3pewTgP2Onz8ufMO42p8/w0IE+z7/x++XWnMJIsdFsmUdaVITuXTCLYuHOYbj8vLRjT7CovZFIktgxDz+HhES+/dIff/vbXoFKL/SQL21nYYpTHkGy+FPzq/ff49ne/z7Vrcq2t3t2VXYaBxnF86dpOj+kiOG3GmR45MOQX256nmHdIopR2IallPKKS5yIoIxICVimBw4NjGHqhz4WIiQJ/ZDbOuJXX+pnPM0Jvk3tRVdW22D94Vqs1T56csFjMMTYnDciC4R0XZ0+p6xplRIq5aR1dJ7th4XD3GKvYLM9oNivxt40i+DQkKdcsNhVVEiqLu+N5uoPfnr98LnG7agja4rxiqBxt37DelMzn8zFrnr6OtZb9/f2dezy9F7nIqNiafYjDUk5QpYiaOeCjGubfNh1QTrbAdw5CxFgJnt57hoR75wtyeUCWRckQhJ0huO7A+7/+NR9++BHf/Pa3xoLQZSxI8L2w05Emg18kTr33+KTXcefOyzx69JgnT56wGZ3bNd7JgrBerzk/X2JNwWYjbu4qbdX6riOEgT5JQl5cLGnbTop/42SUApCI32j29/c4vHKVsqzGSZYLtJezk/y36c0PIVBXNefrU/YXc+FOI6JNYpqgxJPPCF98SrMcUmbZdR2ByHy2tzO48hZtmvlMoZA8kC7f3ynGPR2M093QZQW5y52zGeOe/u4yB/gy+2iK6UJM2YuX7TCiP9IPWwbBNFjk79vzVePrTM9j8kmZzebEGHB+4LXX3uDTjz/GRU8Mz3Y6PnskeqqC87NTPvj1r7jy+1eJwRLYXr/LcyCfo/w+cinxfuZePA9uGWGAS1bgch0ZP/Ple6e0Fl/O1FtQJjhKKZl5weWscWAYkvRrMg2ROkLcGc/TxfF5hIJtV6UwN4YhsFwuOT07pSiFfWWtpS4KXOfohp7V8hivKpoOVptkKdg0dG1LYTRWRZ7c/5yha9DB42LAR8VIFR5XGJFsuLzteF7dwXkRbVNpZye7NoFQjTUYKzLQmV2VG4zy92mn9bT+A1FqM4llQ5R6mdIKa6QRaroA7j73qx1fCyrpuhbnwGop4sxmM+lUBEpbjCvR1FswhMSxjJHBOVBCh7s4v+Cv/+av+cY7b+8UJqcXId8Qk14blbrLfE9V14haYJ8GQsmjR495/PhJ0iiRgTY4cac5P7+g6wa0sknCNSDGqW5sbhl66SiToG3Zihdt3VistewfLDg42Gc+n6UsJYwNKNNVeYrjToNUDoBt29MPA7dv3hRiQ5A2WJ3eOwfCCCPNySV/ybbtZIJYQ1EW2ASPSJfofCyS5l3PdGBIe/Z2YE3PKwfaaQCaYuT5d1Ne71RwaoqDX4ZORsx2Ehyn10kG8bOCV3FSfFTsTsDpOeVMJr+HOLyAZPHZ2FcYF/v7+2yaNUdHV3nhxZf45NOP0OzS8Z63zZbEIVn1qcgvfvFTvvnt73CwX4mDyeR5+fpMr4vKPG6en6ld/jkH7GcC+ZRFMr7Os3h6TMFMaVGkM+xaZhE8HjDa4ZXUCLRWVEqhSGOf3V3X5aJbHh/TcSS68FKnENmJntVyxc2b15JEAFgNRa2paksfHF0zMHjxiF01PavVmqZpWFQlTd/x9PFDVAxp/VIJGoGU147XVX6+xLxhu1CBBG3tpQCZE9AQe1ARY8SoWw279zB/7jxvLjevZcqv7Cq2j5/uSnMSM90VTq/pV+Xyf02X95gKd3FiGSQDUSXjSx98aj1N1DItN6kuSowTIXStYHlxzvu/fI/z0xPKokonvx1QMihUSk6eLeTs7e0hLekOrQwPHj7i4YMHtG0DIVKVwibpNg0uhKT8p3C+lyCs1dgq23U9TdONQuiCaeXtnGQzSmsKazg82Ofa9WtAoO86tCl2WtGBrfFqIdrBecGR19Ijbcl7R11V0tSEBAJblhCEx6qNNPIMKQOVMWpYr1c0XYfWlqqYYW1NWdSUpUAki/kclAxsnS9j2J380wx7uj2fbodzZvFsRrFlluSAmz/z9LFTrPxy480UCphW5H3KSFXKoEw6H6sNhTZYo/F+GhBj0n3JGswhFeWEBqejcGNlG5qKozEwr2YcHR3R9x2vvPoaD+/fl7bqsaAH04mvMm8rh8y0+D49fsKHv32f737n3yFqQwgg2LBANyHK7kiYL9smosvH8wL3OBcuLVaXTk0eHyffIxBFM0MDJL9XrXXicqf7Ezyu7wiqHxk6smuUwmJZFkBIQloJj45DaoeXxdDa3FuQoULxe4wk/r+W3zlHknBdy+7SQFCRsjCUtsBEg7aa9qSha9YsT5dcXCxRMeBtz5OHn7C8eIqKjpC0RHbciKa7xBh3LsqYTE2ul6gnyHWY7+2hqhKPwf3/ePvTZkuyKzsQW2dy9zu+Id6LOSNyxJBAAagqsIqsYg00kSYSZNNk1aS6ZUZSLZnpg36F/kJLZm2y1hcZzdQsWYttbBqrm6Umm2STLKJQKACJBBIJ5Bw5xvTGO/lwBn3YZx8/ft+LzAiSJU97GW+416/78XP22Xvttde2MYoU9P58A80NtnV2kFkgeYvoCCU9e5o3SmuqxJQyJcullFFdUmYVyyp2cfri49kKcCCSkpgQAlIrjGdTNLFFmCkK8hhjM1AhZWyT5LFcU7FD1znIMqAqDT779GO89ebP8NWvfQPeA8aUCAFxYkSPTRA1RwiANSyEoFL2yWSK5dkCUmqsFis0TQsRCEtq64b0uTuHuqmhpIZ1HpCAEho2kICUj5xtgSgUA06u8q7toSQJFe3s7BBbI0jKYosh1spGjz1fb13f4CAK8PtAMpBGaaybM1y7do3wrkBVg5ABENQIoJBl5CiTwM06ykh2NgDSUFLMjKGLCZSuoBVVvxVlARc1WnyIic6YnNre2XPO/XbUkxtwzivkyUqGhnLlQ/Y+cqhgGx/PS+hzjZNBwlIE4swHGhITtW20VGhCGzc+H7FYEKQiAoTOGuD6QLoSAITwsQ6MCi28CLhycIi2bXHjxm0cHl7Hg/ufpPnFTYv7I24uiE57oA0geIufvv5DfOXLX0NZGOjITqFl4hFgY7FGxHYpbOjXVLbZ5RsbM3XysUXmZQ8MCmRs50YOgA8BcJ4IcVJCqTKtqSCJo+19QBAOQEuMGOTMEAcpSauE9s+AoHzEzgO8t3CO1khAk64nFxxzjlUTAREUOgvqGXq+xs50FvXhASsFgoiyCFpjOlaYjhQ++uAYbeNRFAbBtXj06YeQdoNg1xChI2sUZF+cR4NBY0UjE5PapFMjt4y3B9UHAMB4OkO5fwUeCtYGeOvR2hbO942y+dnwxhYwlG3QWpPQlo0FYplqqHNhsK5yT/0yL/5pjmcz3AJpUeaMA+sc6SXHkJlDZ/bYmraFikwGo8m4aG1wfn6GP/7e9/DSy19BNRqnweHklpQSSiuEDNMLgfConZ093LxxE6uzM2yWK/iuiX3pQL3q2habxqLzPnlBWim4OMENqGlDXdtUJMNwxwA+cB6jEXln0+l0CAUIakS6bbS998QhFz0Vjx8Me56L5RJAjr9GESlQkk46CR88dbiWinR/haAsu/cUAUT6IG0UJinh5Q2Jt5N02x4E/7wd+rFHnZeuP4khsg0R8X0x/snGJ/+sEIj/ztFKau8GLlePy8+T+p7RGmVZQmAZN8C+7FgGqmRVgtvfDWl56VkK0rAAPJq6xWw6w+HhVaxWK9y5+zwe3P8kJZWHkR8/IdpEBThZSa/56MMPce/eB3jl5a8hQMFFXXREwymFQPCRaRCGUqD8fQ6v8PzLpQI+F/+M0An/hzh6XC2qdJUwWg8yvNZ2cC1znod66iHQ+iF6KhlY54hyxzaAo+OcZQUMoyy6EMKhrSVdkaYlo6u1horVxhSVBygIyHmJm/4Kjo4eYfPxMZSQqFcLnB0fU29IF5DI2ZcMSZrf2VMDM0yAlC+zPmA0GkMsotZIHK/CKAgjUImSNEe2kvOpw71r05h576NEBjs/dN/b8y+JcMmebUJjGSAl5U7+jAw3NbBlJTuAIIDCGHRtFCqP/R65EIegFGrIKwSF7pRFJVrMu++8g3fffRevfu3rSdtkgDPaAKX71mCMY2pV4Pbtu7j37jvo4FAoQrk65xCEhA0SjQ2wluCJstBQ2iSh/XXTwFoPbQwODw9xdnaWDAgPnhQS5aiIGsFVenAhRKqfHLbqymmAUkr42JfzsiRa27Y43N9L46q1gtCamCZdByFlFMqiTHgQAp1tYyUo/U5rA6XIaDOLRGuD2Ww2MLbbWHM/gYY4ZZ58yjci3kzbtk2TOIc8tpOFOXaXV9pte948noNFvzVvyeOjhV6WRXQAogcVDbzwNPEDKLpgDnHPzSa8SgEIklg41lqsVivszOa4cuUALzz/At59++c4PT1OG9Y2G2b7kFKSQJpSeP0nr+Hu3ZfJsIdokGLxixABIVYzygh9sHJk7mVve2T5Rvp5ycxcG4OQGMoLKUm9HSENdFGCOkwRlOGdhXfRgEc9+DxRBlBbMa0vCmjl+DlplAwjtvTsIFKzCC4v36xrOOtgdIHReETzBw4elHOSKmBvv8RXvvIcSVMsajy4f4TNYgFRdxSQxs0gbKEKg80akmkmUSpVpJ5BAYA0Blev3wSW1BSlOV9ACAUpNEXHot8E8+eQHCVHtQEMmyWPWkRN8K6nqbJxZ6YdbyY5Bv5n6nGThKhMmePkcRmDer0ZeFeMfxZFkYyQ1kMj4ZzD/fv38cd//Mf40pe/khY1l4tzaOODJ8wuVn8R9CyxM7+Co0dHsOvzGAoSbtR1sbGT4Ax2BaUNpNKRWmfROQ9XBIzGU2itcXJyciGMqaoKB/tXMB6Pe1U+9AUjPCFzg5fvyiL0crdAD6tsNhtYZ5PHCU9+gI3sHK01uD2XUtS6KyCgbhq4QMJGKlL/2CviCVBVVeKVs8e7HZblOtr5hM+TVmy0chyaq+L4XrcXS/77fBy2k3XMDkmQUnwt/52+CLeWQmdQlIqbVTT89IHx3oAAheCiQse2MREOiEYfwcNbgbbp0FUW08kMs9kcr7zyMr777/4ohd+f5+XyHGdxpQ8/vIeHDz/F7dvPgxULIUQ0euQ8AIS50wmezCLYTl4x3p8+O/4vhIsMEvIuZfRmNUxRQWgDow15dQ7wlnofBtfBdS1cFGjK50A+n5XqN8q+VyUbK5nGmp9pnzuhwhsEICiSk1guVzg+PsV8NscosFYHPU2pBbSiQqorV6b45je+jPffuoe3f3wUISCKXEQQg/vP4aU0RjEJneApKZEonxA4vH4TN2/fxeZdgaIaQVcjMvIuUEuxQIV5+fmHm+xwc+X8gZAKRsnYbaunxeb5IKZadp1NEQvdy59BAU6cGvGihyT7wpgLFULsPXddG/vyxVDb9zsYX+S9ex/g8ePHuHHjxqBCsf9M3tlo85AiQBtqzzXf2cNpu0bbudjpQyCAJpDRGq6zEIK6QHddB8Qs93g8xWRC2tOLxSJJXLLBK4oC+5lQUx4ysXfrWHVMDBX3+AErSbAFl9iHQBnszz77DFcPDzPIhahTRmcTBKCkhtboQofVYo11vaHPk7SxsfgPG7NtetJ2lroPzYa7e26M8/scGtLYAGKLPZBXTPKRN03g++bnyp+zfa684pKZAVKKJHsJAFVFQkTsOLBUJ+LcoPXJlX+94WYPXEQoxTsLpQxCoBqAEAJmszmee+45vLm3h9PT0/T+/povrobcEW6aDX7y0x/jxs1bMFqDGmrlCd3LCmeQ/b3f2Ib0xjhe2x+cueCkjRUjDiEhQFohShcw5QhKF8Su8Q4AGQvbtUQDtF2C8vJ1nX82jW0/V1TmZXOHovza2fj7QJE2QDmhzhIb6sGDR5jP5hCQGI8rSn6qmJtqWoQgAR9QVQqvfOkO1iffwv9y9BBr26JrOuptywJSWWI7tylSCDLUDLRLBR9ICllrjdt3nsdoOsMGwGg8wWRvP+Gszjp0sYaAG3eznAPld3xM1A4jpR7+kIMoJV9X9B6CaemaZYp2tp/75x3PZrgFyRZyeJuHyDxw+Y3yQFYjVt4jBggX1pRlCeeB07MzvPPOO7h+/XqaRL1amoMqGD6R0MrAe4vgArQu8Ru/8dv4+MO3cXR0jB/96McQEAhRIL2QwCZ4dJ1DZzsoxXgtwSbaFDClwXvvvQcACRueTCbY29tDVVbJOwSQOMoDhovqDeO2l8abgJS9BvdqtYrSqyM6XwB0QQ+cG+8aVp2TAi4EtLajTu70EKAijk0wCX2xIacuItMY4g7pSjn9L8esedLkHGk2rPnPQC8lm9MFc552PklzbzynE+ZsFh6f3MvkBDi9jnQf+imYYekBUVaXKysBkYfxKYLykJIoXpLlLSJcR1Ek4e07O7t4/u5d/PgZJV/j08dbb/0Mv/Zrv46DKzcAwVzduKMgM4Lb79yCS7YX7zYj6OInUyJOxJJ1pTSMLlFWJbQuAEW0SOddMkC2bdDWNVzsxchNPPKNm68tB5PzYjTaUMXwmeT3E/p79j7Adg6191icL/HgwUMUxhAlsNQI1kNqBREUXBvgvUBZUjPeb//6r2J1eoo/+hf/Ai50cL6B84gRzZBy2V+niIlgMtoBElKT2JyUEtAaZ8s1EAJW6w26szMqSoKADEAXXNT07kvS8wpka/O2fxJCuGgfYk7G9Dxvfj9/CaERIk7fzwkRlUefZq49M6skmyzZQ1ZKohpV2GxIV4AHjvHoQQglVNyFY6gpBFarFX70ox/iG9/4BnZ3dwfvV5qwpN7BoBBIKQnrHJ5/6RXcfeE5/OE//acoqhHWi0XsbBFZBSCWSiEklDIoqgpKGZiyRFGUOD0/wYMHD9JGNJ1Osbu7mwxt8GHw0Kqq6pN0cUBy9TQeF8Z22RCz9sTx8XHSFEFGwRIA9HahCgSsbdE0LSXflIIHUhjMX8mTFhLj8RijUQXWqs698Lz8lq87T4DlX/x3NqY53psvFv78nJ2Sny/35HLPkuZND9WkTQTMyjEpQiMtCnfpppESS1IkgyJEv4mSZ0NYuJQqskx0EiqyXWRVBKAoS9y5exdvvf021ut1vPbtmZ8vgnxhBGzqNX7y+uv4nd+5BinyP/ZskCd5VPlz52vnKIrWVH+OS69D9OPIyUOjS0hJ3c0BmsdN26JtanRtiy5SOMuyhBAyhe3b1M3tD6N17xECw3F9FJ3nU6QgSQc28N572EDibicnp9jf28V8OsJIlRDKUM9Qa2G7AAgNXZJxM6XG177xS3jv7bfwwftvw3qCyVS2WeT/MsQKj2i4JbyQEComaEPAcrVBsCuMQDUe4dEj6Gi4hQ9ogksbg/chwUnsQBZFmTlMpqf4xS9jiCjAUaSNgnJdlNhwNiSbkj/zPxOPm8oyew+NBZO6eEF1U1MPRSEpMWIMiQK5AAuHUUXGkEMt5yyoS0nAe++9g48+/AA7O9+ANmXEsKhlmSClod5+C4GmcxBQ8EFjvXHQ1RzXbr2Ax48eoNnU6LqWrq910EKjjN25lY6wTqGhtcR7P3oP8NS8YDybYz6fwWiTeMkh9EUwUknogtgb1N2Z9CsI+xNEnQ0gDzEIop0FKmMtigJHR0eoNzWuHV4lz5Aox4RZx9592hSQQqCLmf+m7dC1DTrbwfsIn0gFpQqYYgxTVNBGQSjSSp/OplDGUMGFIq+bs9hsgOk59tgb45E8yTgBSPuyT88dGFZBbnvtudecH2xM6PMuTkw24E3ToDBxYwRhnfzZ3pOE7nhUotAKGx8AH7sHQQKBch/ikgKedB2gTtwCVCJNukoBwQLKjGHKGvuH13Hj9i289847CIISZpxOCqGnk4lAip0iAMKTx+tDwM/efAO/8st/HvMdUtoTkhLy0bYPucRbsAQfl41hXlDSY7tRWU6QZykEYawiRpQQKl2ztxa2rdE1K3RdjbatEYKHMSWMoXVJzQhc5GG7wXkRyLD3hpnsgRAidjAnKZS884uQMsGkXOLtBdBaj8Wqxulihf2DPZTBQ/oQHY8K45GGFAbCxKbjU4ndqzt46dWX8e4Hb8ED0NIA1qFPaESx5QgrSSFIc0UJ0mlRAqosMJ3vQLQCxWSC0FQAYrRhqpTYDlHm18WCOOf63pBCylhzQS3eBGvDx2pQow20oXoDIUmqobMdAgR0IPhGdARZOSYfid7Z2K6KfdKwI4XmAAEAAElEQVTx9JWTWYaVd5CULeXKOUH0uHqzwvVr15BK2cFVWEgQiJQ+LkYJYR026xV+/OMf4ctf/QqkpQGBkPBOoKDMExkW5tcK0s5VcoSicJjPD3B41aEczbFYLHB+doambVFZwhpJc0RD6QJFqaEU8PjoAR7cf5B0B3Z2diClRB156bRYe6y9rCqSY3WW+kVG/Wb2KLuui96LIEZIIP6xDwG2bXF6eoqyoL6Q8IDwQFH2nr0XNFYuLkgRMzDeO+pfJyjpYbSGUgW0KqC0hpCxbVlhcOXKYSz2QWagEVk9IvGvc6OxzeRxzmM77OSDvA+fJlqeNc9fu520HBp8NYBOiL3AlaokSMbzi/8VghoqT6cB08kE9aZBaFp0nvjeUmhAhMT5v3QOx/CdXsAeIkGh3gkU1RTVuMGdF17EvQ8/gO2aCMnwPfGsQGSwpBNTP0wJnJ0c4+e/eBO/9ut/kWA0GRBEgODh3IYTto7tRG8Pt4S0xoYhNksY0LhKqVAUZIwDKDko4NB1NerNCk29Rl1vIs+/QFFU0KaIRqND1zUI6MAFaCISAgijF9mmESLOSxu/CgCUgoxUzP4+HYAYNcffOw/UrcPRySlmO2M4eEwnIxitSRtbekgtIbxEoQ1OFydoXI3nX76L/cN9PPr0U3jroSFooxD52IWoKCkglIAXgpg+SuP2c3ewo3YhH0vsX7kCt5ljKQTG4wnkbD5wQFxsl8ewb+o+BZ5C1Jmnado4f7sU4Wa3P8Ctt+c0VWuyHs+zHc/kcTvv0Nk+JDbGJKZBXdcoyxJ7u3vYrNfEmLBUbNJZCxVC0uvOS+KllKgqjbbt8POf/xz373+G23fuUntTJWLijqUgew8xXVMAjBnjxo3ncHa2QtsGIGgYXaFtOzhLbYMCFGgLFjBGQsiAt37xVsK0J5MJvO976QkRG9VGTIsFnExh0LQh4fSuG4rMsxEzxqDuasgopM764M/fuQuA4CXvfGrzxcUtbcvQiEfnLZQ2CKiJfyoEpNaQWsMUhrRMpIz6KWrQINhnBRV58ihBM1sGYjsxlWfqt/HX7ZA6z67nR46fAzyJASF6bz+HXLgKl2ERPhg2sI7w9MlkTLIFjpol+EAbu2em7iV467YXm/B0a9NrBQhOu3b1OvavXMHD+5/hifAEeu85gSIRsvjZT1/H17/+TUymc7JXKm6MTwlg5uOd4/m5gcppmORpR2hFMTRGYxGCh7Ut2maDruFItIWQCmVB1bZ8LtJv4c8cfj7DRvTs2dvnKExeGN/L7iclw2P0VzcNVqsNptMxFp4qEauywricIPgaQQBN2yDEz5jOZ/jt3/0d/ME/+u/RLNfgIqlUNYosp+ID6dlH2OjKteu4duMG1BGpjHbWkgQCYqVz7FHL18tSFrniaX4vXHyWwxz5OLF0Q54nys+fQyPPlkuh4+lFpuIXLyiGErquw3K5hCkKavapDVbLJT2kiLUbGdWxwrDNVSrAUALaKJyfn+G73/0j/G9uXEdRVIMQIl8+uafiHRWj7O1fw93nLT744B6kWkEIA6laBLCRELG5r4CUAY8fP8DR8RH29nYTI6au68FDstbGSKxv+Glt7IjuHLzrGyMTg6bv+gJQCKbiGB0dHycD7axFiJtXYqhEY9VLtxL0YjuLum5hAwlcaaWhFWmzMI5NNDmdGgR75+EC3XdumIBhhWJ+5P1Dc2Ofv4e/D6H3KPJEJz8bnpC5V9mPTYZP+573zUlt5v3mFMpeTjNAK4nRqEBRGoQFwTgUuSooMFW01/++bFHki4XnpPcOzgoUpsJoPMVLL76Cxw8e4jLDfamnHKIkhJZ48PA+Pnj/HfzSL32LkmJPKY7/pGukNXDxNf09kNFSkjBXNhreR6JAXacGvtTwW8GYAqagfA9Cln/YTjZmBgkgGVX67Fz7eqhRkx957UMuzETiS6SNf3piMJ+NAJDGdnABWhXREaLydikllNH48ldfxSf3Psb3/u0fIXhPkWj8LCkosveCoh8rFITQOLh2HYfXb2DTWYy7DkUIWK3W8LWCDIGcgLOz3qMm/ClFF9vPPI8qt6FCWr+9A3HZXNleG3+mhptNd85N5Az1weEhdnZ3Ae+ho9iKcw5a6TTjrLVYr9eJwM6Lk2iD5C20XY033ngDv/EXfws3btykSaMIMx5mqbPu5ErCugBdlLh56zk0rcWHH34ICIkgNwgywhCOwlkRPOAtPvjgA8ymUwRPhjLHtHnRc2Pk8WQSO8xoNG1Dnq+U8M5hFDsAsXFjr9t5KiqQSuHRo0do2xZXDw8JJmHjht6bZCncFD6FAOeBzgWSD/CBOtyYArow0Yj39CMAmE6nAMiAuMg7zwWgtg1ZzhPOKydzSmZO2aNJ6gdGmz31NGZyWBmYj2fvoSB9Dhv9nH7IxzacwN3nTRsrRpVMGxSQaZXgoldzmWeTX5cUEsYQ5jmuJrh9+zm8OZthsTwDSaUqBP95SUryUm3XIgiHN372Y7z40ksYj+fwlhLl2x5/7nFtL/A+QUmSDAFPDqeFkNTYVvYFR9a2sNahbRv4tkXXbkiXxFuYokTFNMEQYkFLbG7hhzS3/Nmzd8l0N1IBHBoxnkucBO+ZFOLC37quw/n5MhIJOkzGJSXpJUkdONfBeofWWmijsbO7D+EF/sJv/TY+/vhTfPL+u7SWfOzxGMjh8QJwQiKYCgfXruLg2nWEWA9ho+1abzZArTEGiP6XqVqSQ3Fxs92O5PLfbxvhJyd3h+O6/fW0xzOoA3ps6g1CIC+xrqlb+tWrVzGbz4HA9Csy3KvlEoUpSKsbiEJAfRsgXvBsDJjYf3J6jD/5k+/hr/7Vv4YyYkUkGUuYHjML+oGiaqtAWUGMJ2OYsiAsLXg0ziFEFVPhPJTwWJ4tcX52SlVOcQLlrAU2MKxtXZQl2q4dhPwQRMvLw6ScUleUBYQSWJyd4ejoCIUxOIh9ILnvnokZ6Rx3btuWPBQpsOk6dNaisw5KF1QNpw2kpqa32jCrhM65t7dHhroJfZYIvUwBL5x8MeYJRn5tXsmYQ1o0sVRMKg+5qWyUtrVPcm+c2QXk9Q09+vQZmefO70mboSO8tKoKjCcVyqqA3bSx203EXMUQthlEZ36o352HuVIRlGY0MJnuYLdZ4cWXXsJrr/0wzk0NPMHz5YNyWh4SAh/dew+PHt7H7dujyBZ62pWGbKxYn+dz4JrY+Fcpkwy396TISVobHYJt4LoWATSni7KEKUoIoclrzTqk+8Hzo22AtaKdcwlfJ9kKDSF68aUcBs3XBNc+8FzoGw4AZQGMRxOCCqNkg1KCKjqdJZw+ADaQ1LEWGtdu3sRf+xt/E3/wT/47fPL+ByiVoo1RKXglACUxGk+xe+0Wdnb3qHJSsXpgNi/iuF6ugZ1hU7iYe7j4HLaNbj//cyruoEjoP8B4P5PHbbRGs16hrmtMp1O8+OKLAJAoNlKQEth4PMZqucRoNEqtt9gQlmU5oKABADUy9dBaoalrvP6T1/Abv/mbOKhKkl8UMkWseegSQiCPnOpgIbzHZD7G7Ts3cfT4CPakg7OaYBIZAOUgvMWnn32GpqljSNl7ZHkxiVIKZaZrLYSIobBB25E3qzKMlBcaY7XOOrRNi8ePH8Nai/2DQ5RVFUNEEr9RYlip2OsYS1hBuhptZxEgUJQFirKCKQpoYxJOKCWrkklU1YiMnLNQUg/6X/ImOdBhye6bN4+8NyRvXLkRJaMnB9edf0YOs+TYer7BXVahyfNIZF76thdDBTc+VoiWqMoSm6aNCny0KHPuen6ObWOdbzoUXRGuJxRgignq0QQvvPAi3nzzDTSxC4v4nOWSgIbgQZzeGj974ye489yL4O5P+bEdLg/OteUIfJ7nJqWEkiwD3FemWtvBOko2omsQvEOhNMyIDDekQQgSgIPv2jj/HEWK3oOLmJj6x4U2Llb90ZzTYBgj36BzXDh/7gBS5xheX11h4H3AeDzFaGQQvIV1HeAFnIv9SyFJykJLKiySEi9+6RX8lb/+HfzBP/rvsXh0RBWpApCFwWRvjvnBNZjRLiDpuXKwFBjmiF3ved75bLOnfy+Pjp4UvV02I3K7wJ+Tq21uS2DzvHia46kNt/ce5+crSEnaHuPxeLAw27aFiTsfAJRVhc1mkzqcM6TAyTgOk9mIe08l4J3t8OjhQ/z4tdfwO3/pd2GUgYs4NUMUPc8jUDWYpF3fFBrz+RTj8QjT6Rim1HhwtEBngWA94B3qZY0P7n2ApmkgBXn6yKIAHtDRaAQVDd2mrmPlJvE5SQmMwi7SfCYNl/xhCiFQbzY4PztDVVY4PDiAjg9OR4zcWYe6adC2DVj3mz2sAAFnYxQgdfSwqUpSK5PK3vsCnBI7O3MaV2VQ6CJNBI4iBovL+zQ1+W+MR24XDeSFBHxveSEP48/5xpAbx5zLDa7uiz/z5yVM27lYcUeLPyUt4334IMh4K9Iu4ToBRCxZZJ/F95B72XxsM2l4fgkIjMdjeL+HpjnESy+9jDd++hOi9H2Bx535cxAIeOftt3D07cdUkJMymNmrAycQh4U5Q1ip56Mn5wWIxSVZdBHYO3ewztKX7UjG2FmqKi40ipI2fhdYHtfH19q4FvgaosGSEhBxgw0eXdtQvseI4bVl155XwfLzHWj8gDfSQD1CLfVTnU5KdF1DcyBqG9n4PT1LCydjXYjSeOXVV/GX6wb/8n/8/6JerinPdngF5c4UohjBBR2p3BKBQ1DBz19BKppzRVHARDsFMF5/8ZnkycrBU7/UkPeOCa85jqp5I+BCxnztfZE+Dh/P2LpMYm9vL1VZ8U2GEFKPROLJChRliQcPHmC+uwNnLZyl5pqj0ShdXFURpqiCAWwAbIAKEsILvP6j1/DL3/wWDq4cwKNLC8uBZUpZF0CBi22kELQjC4crexqFHiH4j3ByegYvA4IDPnn8GRbLExK1CQE6cq+rqCusjUE5qiCVgvNEVWsdvZaKgQDbkXaI1Bo2Ymxaq9QIQSsF23V4/NkDCOdx89pVzEYTSEhoIVGv1tg01HSUAzLGFrWm8FVKCW9bSAQU2kALDSM0jCyghaZek5FhoozBdDbD3u4ujNaQEkl3WYC434EnTJwkpelLxxmLzMPkEEjnOkS4JjfKpAkjo+hU9HIlJ36J9knNJ4h94HxfYRYi/o/MGAtJ6n7Be1gX8WoPSpwhw38DJaNtS0ljowsUqoBT9AylMnChp1vlCdDtxcX3mDYa2beUqsYjjCc3UDcbvPjyl/H2O++ibRqolIwbWmEhAAgfs4SC2EtOYnF6jvfe+jmu/vkDBF9BKJ0xIAAVhYx4ow5ZMmxr5YEy/bRzBE8JeaKLSnInJeJYd/C+Q/AtnKvhfQcnSXJZliWkLmntBADBITgHaxtY2yDAEZMLvTCYBdVkdOsV0Kxhmw3keARRFPCC8kAI1CpNKaDrPFgJNE9c9hs3+qKVyIhq6hpt46B3RhhVE9iugXMWXWFRty38pkbbdEDoYMOaIlUtUZVjfO2bv4yTswXee+8DzGdzaGPQuUCMI/Zk+bkASStGMg5EkyPNid4ZpSiDjWyuepjfC9IpcsxbghuhkEF2IFpkFzfEXEhMpNdykc/THE9tuJVSOLx6iDpwyfrFUBfocVFTGBRlgU1TwygK25umSUU7IVBhS2EMbNuR5KrrUJoCx2dn+Pijj/CLN9/E9Fe/TQpnWeWZdTaKkhv4tgM8l133xk+KgOlkhjvPPQeEgNVigdq1ePPNn6KtawRQIkbEQg6tFKCIPcL3QRxROfAqB56gpwoaKSVx2WOlpnMO5+fnaDc1rh9ew97ubpT29Hhw/z6EEFht1gmPZQwQYGaCRt006NoOShfRq2ZGCXnaSilqrxSTpocHB6k/nhABUlECL09+bUNB/D2Ann0i5cA05eFh7kEz15o9LHotGe08IcqvT0ZTymS0Q4h+kMsbBvd5jByT7h2FkIS4RqMRqqpC1zl4iJRHuQxeuCy03cYUgwyAIx77fGeGW7efw3q1wO3nnqOCnAvnTO/k/GQyzCEASkr87I038M1vfgujSUmdfBKhOyBX9Ru44tn1SUkqd9b7rPR96ysZII8QGzckZboQII0miK0kFomAAKkEUuUoKdl5sCY9NwJAAILkDTeg3mxgmw100XvNQqiIg5NoEnmXOtvAe23zHIYr4poWQqBpWhwfn2BnPsN4bw6jFbq2gQ+AiedwlpqhSCGhYvGc1hqj8Ri/9hd+A/uH11DXLbzzWK02cN6jbttYrdj1EEccKu896T+DmDJ+ixFGaawhVr8NvT3puJhoHn7v3HB95CJ1T3s8s8ftu34ny79y+hbjwlVV4fz8HJPRGJ2QqKoqFeDUdU3hgnOQKiQGh3UUPiyXS/zgBz/AV7/6KiYpeRail0pefXAWrnNQ6HmVuVSmlBK7OzsoX3oJi8UZ/uR738XR0WMql7eWWBmSzmvKAkVZpJye9R5t26BpukF4xw/WeR91hKOeBqhKrtAGp6enePzoEUajEYqiwHK5JEPeMpYYmwCHkLBq1gLnkKntLFwAytgOSZui/9ImwSSmMCiLEodXD1PprVICQuSVkj2uy88uL2zJIaL8PXzP+ff8L483U/mAIZOEf+bXb0do26/h73uKYx8+DrFgGjN0DkVhMB5XWK3WURc+xKaxT0e12r6+WACJelNDXdnDjRs30dRrfPWrr+Ljex+lEvGnSSBJCQTv8fjoIT788AN8+dVdakQdmAfdL2iGSrbPvT2e23gxH5zc99721Y/WAQEEq+kSZTGC0QVkZIaRPnaHtmvROpukFLbzEvC0kUFKOE9RpimLBJG42JcyZxD1Y9/fA/8+L96TsTtO0xDRgaDVEjL1uJRQntVCTVLoZAooa7TM5lPcvfscPv74U5ydLWAKhdCFPt+Uwxu8J8WmLECUftjqldpvjP2z2I7gnnZePenv/fP74rm6fTxbyXus0cyTWGwo2cvKs8pVVWGxWKDQBtIUA+53WZa9x+6AsijAnTmqqsC6bnDv3j288cZP8Su/+m2a6JF1UZRlbIlEHWZcCMlDY0FzFsQnYyaxt7ODD+/dQ3AOShLkguAAoVCORuTVC8RwnbrDW+tQVqMLHqf3HlpKaGMoxOe/+YDaNTg/P8fu7i5uXr2KerNJuz4/JBVZBmXUPeEJyZsaAPIupIY2BZQpiDUQWSUqcbijoFBhcPXwKlXLxajDBw8XN4rLkoJ5SJZDBvkz5HvNjWceKubfb0MSjAfmxucy3DuftPw+1j7hz+Pz0hdV24aKIpH1ZoqzswVWmw18IC3k/DPy44u8JAEK3SkRKTAZT3Dj+k18/evfwE9+/Do+uncvXSuPTe8BA32cwtcQUNcr/PSNH+Pui6/AFKOM1pfh29l15F5eGhtc3ODyg6pjCQO2rgPr3QtBbCNiIbHQm4OzHaxt0XVNfLYCQiqaa7LXSveeuuiEQJWHTggYpQGl4DxJNXBJKD/vXHVSCNZBwUASuKePcguwgIcPH2JUFfC+Q1VqTMZjWidtF6+RnlFdN+g6B60NZqMxMb7aFpPJBIeHV7BarXF2dgZrHTrXIwJfZBRzx4Z+Hr6eN5/Pg97yc/G/T5pz2895e01+0fEMhjtEdbF+4K21qeJvO9HD4T8LLCkhU7EJe3UMmwgtUDdrmFBCawPrPYzROF+c4Qc//FN85dVXwZPcOZKGNAVNfWctTCzqYfCfPULvPZrNBm1b4+OPP8SbP/spBELE4T1JfGuFclRBG4MAYHV2isVyieVqhb29vQQ3cBMBhkmkIk+T+8khBHRdm2CbO3fuQAaCYNq2xXw+B9AXuLhAyU0bx4mTGCz+z2L4ZJyJv810QF5gzCaZTWfYv7KPENjI0oa0PUGAPizLDWc+gdiAc+KERaTYS2KmyrYnw+OUe4g8F/IFsV01y8a63xh6bDCnZvI1E/ZuIZWEayyMkdBGEUMoynlcxiW/bBHlvxeCmCX0GoG6biCwg/39fdy+/Ry+8uWv4LNPPrk0OdWfsDfgXASjNPDhh+/j6Pghrl67GbHoCEZFfIWitaHK5MC73vJaeSz7Z0tJPG61xX+XQkFrKrThsnXv28jxbuFcB+c7kgk2zHAgbDrEqud0hdqgmk4hfAcnSCfAmALWtZCy3+BzPJjqC2SaH0Mogta480DXtVh5i0ePH2E2G6MoovREhFZ5DjRNg82mwXQ6hVR9I+MQHExB0Nlzz93EYnGG07MzcF4gH08E3giBbZM69JSR5hz/jl+zHQFdOhXyz8zen5/z8zbjLzqeiQ4oBZXS5os/xyL5yDvZVFWF5dk5nCnSws8XDKn8tXDWkT4JBKTRUEJAKYOPPvoQ7777LkL4OpTSyVi7uMi5WUEuv8oRQAjkVWut8KMf/gDLxQK2a6EkaYhoRRom1hHJf7FcYrle4vjkBNPpFCorYQdw0YMEebZdxx4EcHxygv39fVTVCPVykUrRE8QSDbTWBgUIX8s9Yu89Hjx4gLZtUY2mEErH/p1UugupEEQP0ShJuQeShaUwmWBkOi8ng3m82avPPaPLaHLb9C6OoC7zIBgz3w4jc/w8pyPywZsYX0Oefedz5h1yCCsFtbNqYy9HEcBdwxFxZbc1Hy+75otwDoAgYhMFh/WqhnMBVVlhb3cfX/ryl/Hj136ER48eXb48wvAH1vBwzmO1Psdbb72Jw6vXLixQkYfkWws50Ss/1ziQ4aKvfoOUMko0aJJ2pcQ5kQSob2kH6ykK1MbAGGKbcI5GxoSvCh7WUi6iqEZwVqS6DNc5lukerOl8o1bKDeoCeJ6QxDONtVZcSUnn8s5htVqhcwQZWuuSpj1Hp+QwAta2cd4Q5XI+J131s/MVNnVLQm6XwUvpoWfPInvNtnHdhvi+6MiN+/a585/z8/2ZQSX57GSeb57Bz7073plGoxHWi1UyWEwH5EGwzkILgdGoQgDt0iH0fOj1eo0f/uCH+HL712BM1jYrBGpd5AOC6KllQP9eIQSMUlivl3jnnbfhPcEkShJjQWsFHyTqtsNqvcKnn30G6x3Gkwmm8zk6a+FiUwaecMnACAEfqy593CiUkNRaDGSsTFHAZbCQlDIxa6yz8ELARGOmtcZ7772H8/NzzGYzjMdjErJSGkJq6rSiVaS7MZmfJtfOzg5BMazdIGTsFdhjirk3zLSj3HjnFMB8E2EPk581exHJS81ogvnkzrFz9uD5fCkR63vKXi8P20sA59VsfDhvqfoNlOCyjuaYMQt4b6OE6dBTehqckX4pIwOBnmPTtJCCHITbt57D888/j4cPH6YN5eI5MshExORjrJ79xVtv4lu/8qvQ4xIXfb3Lj7T4P+fvRFujYhtO9vG4U79JDWpkQJ1urO2Fk4AAbTSKcgRtdB/hxHynDICEIiaPBxwAL2SUG3YIvgWEpYbAWSQ9jOIwiAL4+67rItPJozCx/iBGyvnc4yR43dSx4ckGZVlhs96gc6TaWRQFlFKpveDBwRXs7+/i/oMjwucvH7xkt7e9Y4D30Iu5vKcx3JdBJU8yys/qafPxTIabr3kbw8x3JQCJW8z6FOPJGCfHx9jfv9JrVsRQ0nYWISYjtDHwLQngSO8jVBDw/vvvYbe9jxs3bqGp65jQ0/A+iiWJng8uJS06JYmyphRw7977+OzTT8kbjeW6Qkq4ALSdxeOjIxwdH6MaVdifzTAajVA3DXRpIgTSUXPaeI9tRzS4um0ASZ21nbXU8qjrsFlvsCqWKGNZen6Mx2My5AJYbTYE0YSAD+59gPsPH6IoKzSdhTakpUwiW7ECUfTsDJ5oSmvMZnM468A9HZxzkDFEZYiHDRk1iwjxdcQEoGdGeLnWXMlK2W/eRHuReHnhufdaIkN9kFwsKsebGcbq6YX9pkhSof3z5NCbzhvzLJ6ut2lZmKjEeDSCcxs0LXGRGWKgzWQwiy+Z2eT3UqEXsSuCB5bLFSbjKxiNxtjd28dXvvpV/Pznb+Ls/CwyL0L27uGZqcM80c68tTg+eoRPP/kQe1/6coItgL4m4TIP7GkO76N0sO8NBGvXkEa7gLMdnOX+khY+wiBaUb9YUxD9VcbxkghQAoAIsKGNshDM8SYJY4LwA2H2MqS5GYKP6pSRYWVtUvTMNeq99+iCh1YxeoyssLZtoU2BwmigrhFCjMbjM22bGkoJrNcL+LUn3fb5HFppWAG0ETKtqgpaG3jf9s8khC1C5+fnPLaNNUNc4ZJE8pNguM87fw55PevxjB5332+RP5AXLO+27I3lhrQsS/gQsN6QOD0s4VY6akvbACBIiEBqe0J4jEbUdkwphZPjYzSmIcPpqIEpTaTYgUNJlJETLoRIST+lJHy3xg9+8CfYNGtorWB9gJcSTWOxqTd49PgIdV1jZ2eOvb19ihDWawQXsFmvIeP95vi57GRKKooQUgNlovwFOGuxOl+gK3TkVZOHzJ1v6rqG1ArjyQRN2+D9ex/g0eNjFOMptDGwQkILnfQniAaooCI2L4RPISqV0GtYZxF8r3VO2ONFoagu6qXTpCajRp55gBDM/OBO4DYmeSnZRQkwlvIchpA89rmB3vY4cmgtD0VzqIY25B7f5gIOgLrVeBerHB0ggoBWCqNRiXFVYnm+hIzQcfD0jXe0WClSAdKyDRnWTFdCHcTjwXxxaz2UMhhNJrh99w5u3b2Nk58cEQQnNQRU7G9I50B/toiniqhJ3+KnP/kxvvT8i3FcJAIouefhyVBm65w3NEqaEo59OeQTczXoIyce6xR12A7CE+Wtaxuiv0pFXVqKAkIW8X2ADB5aUs4xwAPBQaCD8BYiAIp6sQNCQigF7xWCt+keBEC0WE/1Fm4LvuRIPYSoGqpLqhB2Dn7tcHJ2hrPzc1y/fh1TZaDlhqTDvIftWpydHKOt11A7M9TrNToBGK1QlmMUWsO2jp5DIPrtYNcOAyrPYBzz6JATy/wlRO+U9tHEUIs+n/P5OfN/t/92WYLyaY9nbF2GRF3jD89xX07c5ZgmL0gWQOIwM6edKSlhQ6+JwOcAABEHzNoOEAJlYeg6FIWCArH+f2tHZ2W/xXKBH7/+44iPaiyXS6xWK6zXa/IG48AtFkucnZ2nzjdSSgozpbjw0BjH897Hjh02eTdVWVLi1VpY26auNuPxGNxZXClFQlFdi4ePHqGpGypqgoievUhdbpirTQuxX5B8jwyXkEoiTwpAyD6cz2GDlMyyvZHZZgLkv98Wf6J7d3Cu//kyqd784N8x3ZHnDZ8zzYOtUvhhyE3FTcEHCE3vN1pDeOrtqTV5j6RvQTxc0uamRYaIg3KhWBDYWrwEb/S/CwlT1Zo6nszne3jppVfwi5//jIqw2DsPxELoh07kNpzuUwDvv/8+Hj9+CDHr8Wkp40a0tWZTRKUo6gqc1L6kso4TirnxyR2oLnZaIYgJELFc3ZSGmpaAnx3NIaEUdYH3HsHH6mLEpF7aEGLFpCAnithdSFQ+ay3J7MqhiBblYnqGSddarFZrOGdQKIXFYonj4xPM53PszGaQYpxIEIeHhwiBukg1TQ2jab40dQ1nA8GedYOmqbGJSp88p5OHexlCtjVul3nA+e/p+36u5l9Pem/+XHMGF//uz9Bwh6SNzXhnvnvmTJN88coYBpVlic1mg6qqEtuEKG/k/dmuSwJLo9GoNzhCoCzHQCuwXq9QNxvM5jvEtIiMDgFWHaMdUBcFvCcv9Pvf/xM8evwYUggcHx+n5AYn2lzy9Pqu6IwBtl0LZQxWqxWK2AAhROiE2w6p2CHFRqGq3fkOxqMREIBmU0NGFsZmsxl4Q+3iHOPpFGenp1Q+31maDIo8bBMbACuZdwyniZdPotFo3PeoDD0NLbherS9PFtFE6ZOk2yW3PHlybz33ivvXu8FEHVKpYgVoZoBzFkoOpfBE5mpca3sYJhcjCyFEhcaeLROEgoj0wLIsMRqN0LQrBEdQFlVvklFzzkJGmWCw0c67jZCbDiEoz6LNsD+n0SWm0xleevEV3Lh+Cx9++B5i3WNmdJ8c8oYAdG2Dd95+C+6bHsJQhMMVk7xhDHFWNiT0Edsw2fB1cvAe9gZJX54YJyFy4JUkeYiiKKmqNqg0RiE40n4JDiH0Xci3cxb8+VobOC/gYYHQyxW0COSly54ynK8vfl40LqSN7Y2C1iT1ajvCt5PoWqBy+cPDQ5ydnWG1WmN/fxcA0PnI+hIKdV3H9w+bhSQn4AmFTpd5wPl452uXDTfP+0s/5wvgj+3k5fa/X3Q8vR63IFXA1vWeQMKqIm7Ni493el50AlTenodwXD3F/RZzBS1+uFR4YmAdlYqenp7iww/v4Vd+9c9RBlzSJJRggSJ6LMfHx/jZz36G73733+EXv3gTEMD5chk9bFABj6TVoLKHASDt7kIISCVx8/ZtfPTRR4kpw4m0MnrWrrNo6ho+eqZn5+dYrVbY393FfL4DpSROTk62dmtSo9tsNmiblmCeQsF7QBmd5FpTP0mtY9ebvkCCJ2AZO+hY66jTiqAyWoiLPOn8X6BvJJB7Jjnzgw1t7rlzUsuYXiyHJ1yenMwnc14pm28C+ft7ml1fyLFNLeTPDyFQjsJ1sLG2wBiD0XiM1aZB3da9B5wWIZCKNgJFJYM1IijJR7ovtJFoo+M9kVc9nexgf/8Ar776NXzyyYdk1ARiki12ebncpYMEKVG++97b6F6dAVUAUdkILxa4XCednAsqc3/CygS39hNbczk5VMEnuIgogsQ4oRyShoAkHBqxQa61sfyaJIbzOTT4khJSGUil0aKBt1zUQprawiO2Hhzqdggh0LYtlKLNAwjoOgd4j8JoLJcUEZfGYLNZp+S4EMQLv3r1KhaLBeq6QVWRvn1RjtF1JKvhnEsda7bXHQdD9L28cF/5z5dBGzKSA1hX/rKNNv+Zn0P+u2c10pcdz0QHpA/qE5O518YLcjsZxR6DjK2iuq7Dzs5OWrjGGBil0wbAuxtPOmstpKLsfNs0+Jf/8l/i088+w3f++t/A7t5uzHxTb7rv/+mf4nt//D384Ac/QF3X0EYjiIDFakX6GIKKBti4SCB11cmlJ/MHWNc1ZrMZuq5L1Z65pvDyfAGtNTaxc45RGqaqUmjnnMVsNsMybhz9YqKHdvvWLQACdUN96SDJA1OZZ8MGO4QMm42w1XQyJXgp8whC6JkhzNDgZ0KfT4aMxzvfUHN2Dj+L/IsMHnVF36b55Qs8L+PNKYbbHs0Q3+4xw5xpss1W8Z7mgvNcKUmOgXMBTdNF4a64ScTEnVCS0JJ0PT2onO4PAWWpMRpV0SMsUZZlLMrxKIoxZrM93L51Bzs7ezg7PUYAec5f4GDFjcbh5PQYTVMgTB2CIHw6QCVjss0b5mee/27bOIS4EfXPaAg3+dBvkjLmWrSJRVyCisGC7/t7Wmcjx9vC+4tRWH4uCJJekM6jC+SE+QBAECwV3JbDkl0jF9aQnAP1aLXWY72u0baW8mJrMtyTySTd9+7ubrQXLTrbQRcVbGexXm/I6NcNtQ7M7FBvxegcSmkgK8EPciiilo/v9u8YRsvnbn6P28f2c7vsOW5/3hcdz9Rzkgwc/ZxzgPlieLIwjp2wTaWTQeeLJnYDkerrrs5I+72GhhDE1oBQgCRD8847b+GXvvkNzGZT3Lv3AR58eh/f/+Pv4t9999/h7PQMQkqUZUF9CZsG9x/eR2ftQBiLtJf7Io/cE8gHXyqJ4+Njuo54X/x3bgLRti3q9Rpt22I6neLWjZuYzWYQPmC1WqbPmEwmiZPMUNF6vUYXMVljShIhkjIuICR4hnFsTrjyOAsRVRcddYRnjr21HlrqNBG2DSQb7p4f3Xt77I3lmiy5t21MASn757gtMcBGPJVVx3nABji/HjYwQw75kBWRs5dYrCyxT5SCkYq+9wGjUYXp1GKxWiaDHVyAkKwLIoCkJtiHtMaQsTaKelBOJuMUVdF9OyhVwGiJyXiK69dv4O7d5/Ha8eMYLWrq7fikRReoNJxqFqiyUSrEDZY6wSipBkbmsnNdBnvFV6cNNf9KVYOSwg1SpqTuSTp52wLB0dhQVaXNKjBtilryudRv5AqQFPmagpo3BO8huCoUIamF5tfcwwncNDwkrN/7gPW6xtHRMbQSqSqSSRHGmET/e+edtyCVwkgonK2WOD45xePHx6hbG6O7Xvo4jaGSMR+m4LveudzGqS+DToZR5TChuA0h5e/Z9t7/YxxP73En/JSSTJvNZlBMkSeT+IK5ahLZwwsh4Pz8PGHjzjmMR+MEQ7B3yeF5URRouhpe0wZR12v85Cev40evvYY33ngDruugQPoo850pjClQVSWWyxUeProfF4lEZ7ukoRLT/eSJ+N6A5x5fwr/FkDnBioZt2+Lo8WPU6w289zg8PMTt27dRlSVh7hBAcOkzOS/A5e/ee8K9FXWLVpJK6Ju2BXWN7q+Hkp9ksJz34GH3PurCBA9rPaRWsM7CGJLvDKHfWHk8+y86h1I90wPoN9Se+UHYOecGmGudC0lte9ucA+DX5xDHdiife5lk0Hu9GaYZpokf50OCd6RCECTZKSFQlgXG41Gkc9aR0UCbFDkeDsG77FqZIqkxm01RaNr8iqKMG6ZJm23wAm2wKIoKu7v7ePnlV/DGT38C77qIA/NaeNICJQVEytv016OVTEy73MseGGearheiwf7zLia6cuxVCAGhiDqqTQGjCwhB9+ScJxprTF46ZyN1sO/JmH/mIAITIjoMCkVZwtoSXWsRb5DGVg85+zmjCLHHp4xRJuXNgM16g4cPH2E6rmBtm6p1eTPlZ3Lnzh389Kc/xen5EovFGptNS45g06bX5zYK6D3uPBJk9CB3QLYNbz627Pykc14CtVwGGeav/w89ngnjLqsSzonEDR6EY5knwFgmL2AvqNO4lBJlVaJpWixOTmCtRVVVkBGjZKiCvdIEYUgds9sBrmvxo+99D0prahxQFBhVlPgsyhLaEHPko48/Rte11OpL60RTCs4D0YPWUsH6oYYCH0qpKCpPRTsAsTrqzRqnp6fYrNdw1kJCYGcyxSsvvpgMTqHjvYSATb2Bkir2x0OChWzsbO6cQ1nR6yElNusOuhAwpgCEx2Z9DmMKdO0azdqgHI0wm80hQgk1KVGNDIrCwHYtvAgI3kFIgc66uBlaBBtQmCKxOkIIEXsEgiCBLyVJFc6DquoYw/SBMNK8oYUIASwGRWPVi2NRQqlLmzAtSHr+DFNxYQ1tGFmruOgZ5l3o83+VoobBPpC3DSFTQ2qjNZqmgxRAWZBkqBMeQcbP9yHS2wjvZbVGxEWmlcZ4XELEghuldMJ5heBcpoeRBapyjuduvYjr127jk0/uwXtSt0TmVW07WFIForpEmmLbtJBVZHJEzzO/34HxpswkFWE5qpDsbbUgeh4zkyN0FLwAt34iz1OnLkqCqxe9RbBEE3RtDddu4GwN51p43wGk6BM/hqAREeWUI/2kj0BVAaNL2K4FZZFoXnGxFVc+prWVhK5aGCOBINB2Hp1tIaZjbOoWj46OUBqFvb09dF0DYyiPoJRC0zQYVRNcu3oDP/rRawiQULrAZDSGFArrTRMjFNrYrKMKU+e4gXlHZf0gNhvtnCLROAOPKCeOI7IWIBBECkKSbeRnRv9eVLUcvH6LdfTvczxbAU7Up2bDnJgVmVfFDwrIpEIFTVDG2uqmxvHJcaTABdi2xd7uXrrR8XicPkPHxU2UrwKHsyvo2hZSKfJuhYzdvgWMNlguV3j/3j3qb1kU8KGFEuTtCCFISyQ2HmBWS+4t5uEQBFDECkSlFI6OjrBcLsnwBEImp9UILz5/F/PJBD54FKbA+eIcpdGkb+0DtOmhIxOpjip6XtyoWGvKiLu2xqreYDTuUIxGKI2E1sBicQarNdbLE6zOHkOXFRbnO/jj7/5bvPzSy3juueewv79HxtaR5nVnO1RlBaEy70EKaKliko5CWS/JWCFuxNZRgtZ7qrKTijSZaQ54MgKZV0yGOaRxospOMfDEh5BKrwlCeHjvcVvbDSb90Gt3cUPL5HCjRnrXdZCC2CyzyRirZYWuJYkDss/Ri4o+V+4dOWvRtS3CuEjOA7XOcnGzc+jaDsERs6rQFWbTK/jyl76GTz79CEIJEPGZKStA7nmTAfARsiDj9emnn2BjVhiNTGwm/DnhdDytEJQwdy4MLQFyT5L+x1EVeduamnEIDQmJ4DxFCrZD8BbBtQiuAXwbKyw7IDja6AQ7LdR4gDYZesbgCl6poKVGYUZo6yauc4KDOI/FtoJJByLaBGtbdK2AqkpAAHVDXd3LqoI+Aq4e7qHrWhSlQtvRuY0u0dQdvHOYjueYjmd4/fXXcffu89i7OsfB7g4+/vQ+FusGkNQBq7MuRtnE63e8iQJRm1wkaYFIMBqMcUgeNhn37f7PQ7iFeeAXHlOaEZexW57leCY6YEBI6nt5WAH0oTTjxZvNBiGQpkD+sLz32N3dxXK5THCK8LTwOKHAMExZlrCg0luKREOEIjJB8xBQtw2mc0oAvvf+++hsB1OYS4NWNiB5CJ5DPM65dM1S9P0oHz9+TJEGLy4hIILAzs4O5rN5umYpJKqyQmctjNaYVXO6f1mkNm7VmLoBFaJK45aXkwtB47yM9EnWnc4lBurNBuv1BifHR/jT7/8JDg4O8Oqrr+KlaMR3dnYRgiQvJSW3aCMJMAihx5mFF5FvS1VxRhUIjrBHEupXsdI1igl1TRwCmnw5Rg70SdDtUnveEPOxzjFEusYeKx9i3wTr5CE3z7UeGiA/SQigKExP51MMx/TYZO4lWWux3mwwmVQwkUnCG0NeFcpz2BiN8WiEF158EdM/nWGxPKb3YBiWDw+R/R94+OABHlb38fzzcwg4ECXv8xNWOf562bnjU74Ibai+ipI25zZCIx2C7eC7Bp1tYS3BPiEQTZE2OzLUiBGYECpWSXK3oYh1Q6IsK7RNmZL4jLtrrTGbzVAUBU5OThItmCAotik9bBdCQNPU6KoCUkgiCMwnsLaDgIDtQoTryAk7ODzA2ekJ7rkOIw1cuXsHNw53UH/2GHXbwlqAmUHJAFMIFYePvw/DMc030hDSRni5u9zrrNPwP71h/veBTp7Z484zwmy02Zhv41i8KHgReE8a3XVdYz6f9/impSQle1bOEa1Ha43pdAoNgUIUKSTnG7XWwnrSglhv1nj73Xew3mwQEFBUFTXs9UP2Al8z84yBXuyIedoAy6oKPHr0AIj3m400cY+Vxt7+XoKOqIkBwTCcQGkiD5WrEIMPCDHB28XkplIq8VX7BB76IiEgYXtswAP65g6r5QqL83N89OFH2Nn5Lm7evIWvf+3ruH37Ng6vXsV0OkVRFCgMhckCREHT0kSKGG2AznJpcsS8PaCkBnsZACX7pOqLQfLinZxRxMaWk8J5wU1uvHOjlG8AbMB53vDP2/zxHKqjruYWEMBoVKHabNA5arbMfOT88/m8lHsgJkJZmnQP/Nr+fRE6Uwrz+Rz7e1fw4gsv4fWfnNGm+IT1xyZ7aBsC3vzZT/Hcc89DSQ6/L9IB+RryhOMFDDz/rGxce56+gEBACA7BhVhzYGOylwy3tRHWDCS3KqEiB1sDgoyeiJW8ND+JWsjCcN55aKNIXK1ZIoQO3gW44EiKOfZvnc1mWCwW2Gw22NsbUdQXaP0XhcFoVGE8HqEsK8znc1SjER4/fozRuKAoebOEcwHOApDUzGQ0GuFLX3oZr//wTzGrBMbaw4wnmEwN1kfnxNoRBWLYkj2V3FBnUQzjTf1f4s89pXAbu6bn0T/gzzXGl0RWz2q8n4kOmNOyGKvk3zVNA631gD/Jhox/VorgAD7Yo9GiT0wyTDKdTjGZTAgD9wGudkCkFDJrpes6dN5DGYOPP/kE54tzmLKClJSICRFny6EQfi8XxLB3zde7Xq+xWCxwdnoaOaycmb+4kCfjCaSQPZbvudKOkredsxG+WSAEoKxKIPTskC5S1sqyTDz31WpF+N14jGoyveBVrtdrutayTGMVoEi1LXgcHz3G6ekJ7n1wD0VRYDIZY3d3F9PpDNPpFHfu3MG3vvXLaJuA09MTrNcbLBYL7Ozs4ObNm7hy5Qq8c9hs6lTU5JyDAOGL3ntIwWyMPpHJzzg30JclGfNJmnvhucIgz5lcZ4WeN9HHcm88L/AJoMbTpFcu0TkLh4DlcoWuy6oos8/uP6tD09Ro2yJhsPzZAFXuWufhYlPrqiLD8sILL+IXb/0MbazUu3T98XoW6Fv8IeDDD97FenWO8WQ3wj/DzSy9PQwZDZcdQzx1u1gGyWiTVreLXxbedeCO6uytswfN9QBBEOODjDVh29T6i1uURYMWorCVUrAtAHiC7eImz8Z7PB7j4cOHmE1nsWaCdEry2oWiKCClwP7+HnZ351itzuC9x3KxhhA6YtoVmmYDIQVeeeVlHD/8FA8e3IdRAnuHV4HpHqQUcNYjCKqc3hq0C2OY5wr4MYho8KmVGT1QqXp7yJg1OdpZXiIe2xh4vg62HZinNeBPTwcMpDcdAlJyiRdNXdfporz3qYCFGy4w7t0y1zn+zNxoGQSWiwWuX7+eeMd7e3tkaKVCsBZSKlC3jN4zl1JChIBNXePo+JggK0mdPDxCqqrMK/Z4YwmBuMht26KqKpycnOD09BTr1Sr1P0zpfAwNNmOkbGgBYDKZ4PHjx6lcvygKKKPR6Q6zqMXN4+G9RzUaQUAMlAOFELGajDbFTcyOs1GfTqfET9caznZYr5a0+0cOehBAFcPL1WqB5SJgsSiwXCwibufxox/+AP/8n/1z1Js2bTJSEY94b38fk8kETV2jrmuUZYmDgwPs7lEx0dWrV/H83ecxmc8Q/FBlMKdU5nmDfBNnCmUOofB7c4+bN3SAWC7sIPiIr+ec/5Qc0xoxlk2l3aNRhU3dYL1eJ+bCZcaPDL/FZlOjKEwUKKJ52LYtwWBSQAYPUxgoaQARMJlOcePGLRweXMMnH3/4FIsIaUFb22G13uDeB+/hq1/9BiDN5741N8ZPxMIveT19LiVlfaDGI97FZgpdGyUCPCAo/yFjIREnp0McU8a1GdsGaG0l6CBqmQshUZgS9XoBKT2UJFiDVf+kpE5Y4/EYjx49wt07d6G0zIwi2ZW2bdE2LdbrNW7evA4fWpycnMA7oGmWmM52Ua8W2NQ1XNugHI/x7V//C3j9tR9gWddoHh9hHDRCEEkhMTHKAPTQBtvaXoNECAHvHLVJUyoyvzLdn+Bh/UVHJD3mHJLZfhYY2g96/VN46VvH03d5Dx6L5RIb34fBXArOnlZd15hOp1itVmmx8iLjhbdYLFAUBRaLBQCCO+rVBjdv3CD+sxCYTCbwMQTyzsWyXBI44oQR32hVVaiXS3S2g4sayB6AlqQOGKxPhi0vBGGO7tnZGY6OSGjKe99vtbwbxqbC+e9DoCSVKUzaQKbTKaSU2N3dTca16VoorbGpa6zWa+osH6GJ69euAeg1itljbxoyNEEILNebxOUGCDrJcXAgxNZREk3TEP/ae0Ap0nSBQNe1ODkhbQetiYGyXq/AybBQ0yZBUrM1PvuMNkemLnrvUcROP6PRCM8//wL+/G/8Fr797T+XPGX2TvNu8GyIc654ThHMk4491GHTzzyxm6YZaIhb20Mn+evoWfWGWSmJojAwhSbvu0OicOXv5Z957K0dpTnSdV3f7AMeZVGgKCo4BxSeaHX7e1fw/PMv4OOP7n3u+smbBAtQ0YntGrzxxut45ZWvQBejJ783g456PD8L1cPQGOT5Bro/amtGDoyj4hpHfO3gSQqANKoyvnNkjwQpSMstGWpJZNeUnSOmUQgBXpAiYFGUUFKhsw2gAO6ByU6SlBLj8RiLc4JMqhEVOUnJbdUENvUG5wuJ09NT7OzMMJvN8PHHH8cEsMbifAGHgLPzc9SbNSbjMQ5v3sYvVyO89tprcD5gve6gTZU8Zq0FVGRTlZWBCFR1XJYlRvMpWDhKSnIYlZR9oxQhYnERRXdN16LtOFrp9VxowCXyBjrbHvZlUMng709xPBOPu2s7rFuXwljuHdm2beqveHZ2hrIsk9HmhTcajZJGAUDYZ13XWC4WuHpwiOvXrqU+ilVZUuaXE3F1k5gLOU1QKgVdFAjeoyhL1G1LkEbcva1zUAFJl2Q+n6dKrNPTU9R1nYxhwj1DpG0hBU39oGZ84/39fRweHGJcVfCOGpk65/Do0SOKCrRCay3GkwmctZhMJkl5UMnYXNj5dE+s3cJcVR8AJSkJ6J3HdDZNCV8pJQQIsigiPEWvi8Up1kEImcaOp4LvOjghYEUTo6fe8C66Dbom5gXgoIRHVSoKS0OITluLt996Ex9/8hkeP36Mv/yX/wrG4/HA22YjzsYlx6L5e84vMBTCvxuNRgPaGN8r4/scyuY5lLxIJwCxMwp5j6RhQrz+tmnhEDKDk03taAzZUOe0NZIUEFBSkGoeBJQiXXBtqFnt3bsv4Cev/xinp0dIeam0OC9fiM6SVOpnn36Mx0ePcP3GfOsVQww2T/xuRw0JQxfDr3R/PopFOYZHLOA9kQhFenfmVRLFUEgJKJFeE0IPo/DrEeVdPUgNUCBAKYPReAK3bBBiswaeD+y81HUNrRTW6xWqURk3FREhHIOuExDO4vxshtVqjd3dGWazOR4/OoLWpA10vjqHc6Rv4yEhTInxzhUc3ryL5XJFqpqmBHXCIcnD8txACInd3TlCsYO1EJjOphgdHAyNZmz8zeOcxL28TxsRRxhaC3ifb5RiAJVQsrdPFrPx3o6c/mwMNwAEgbaNuhVCo9605NmYEk3dwhiD6XQO21ls1g3RqKxFNargA9H8yqLA2ekZmk2N5fk5tFC4ee06RmUJ7wMKrYHYyRveA1zsEQK0Mdg0NZzzMGUBLYC6bRBk7G23WBDE4QGpDeADVNRmAIBHjx4l9grt7FTWG9NuQNK3yI12Fg4FpptNMR2P0TYNVueLgYaIMQaz2YwKdWLUYQqDru1IV8H5xAqR2qSNrSxLKkXWGlVVRRF/qjoNArBNS0p4MXFIUq4koiQU6WV3DXHStQKc7TI2D3G0g/dUqdlSFp21KHgSbjYbjCcTVGUFFyeVhCDPorMwBZ1rtTjDv/5X/wJaCvzVv/YdjKox6raB9zSO3vWSvmxkuAKTGybnKnfsldd1Pay41T0/PMcDtRaJA58nxKmsPESZUwEtNabVGJtihY1cAUqgy4T1ByFqII+csO4mSgcTJqyidG7TtEmqtHUWuihQjiY4uHoTN27fwcnZMXWKB2HdIiiw9DC53FxqTzkTyg2t8PZbb+D69Tsg9l0B7xHxZYB6OlJymKGeQdgtKPEohO8pgYga5CHOa3TwwcHBwQUH5zviiMnIGkIRg0k22kgRDGLnd8rdibhGMiMlsvEEVfwKYaCrPZg2wG4ekSyFimJa8eVKKJRawW1WaOsRZFEiCAk4mqOlVhDeYrVqsF4RZ/vw4CZOjs9xdnZOzsZyAWMKlNUYZVHCuQCtS5TlGNYKmKKE0bovbhLUPFkIQAkDG8fLe8BaD1ZZ9D70TpDvi3QGSeIQIAIrOwZK0qbxjjUD/UNCSNz2OI6DiOjPECoBCKO1kccN9LSvpiGjvdnUODs7T80CpCwwUYp4riBFvq5pcXZ2hsX5OWxncfXwEOOK1PTKooDRJnluSmu0lhoMs9C7FBKL9Rq74wqt7dA5h01d4+zsjLBOpTGfz5Putes6Ki2PnhTjssw/RggprAm5d43caRIpVBIBqMqKNgUjUU6nEEJgPp8nZgpAeD5j+VoqbLo1zuoa+/v7KVrJqxo5N8Cef1WWULHaro0Zf601XPBoM02Xum5iUsckb4a78JiYDGKvOq9oLEuTsHR+jtoYLJdLNE2Lqhql8WLFxral526kwenJMf7Nv/nXeP6FF/Dqq18DNT/oIkM19PceDSzTKnNGCV8X/z7vFs/zLaf9cZOFHANnqMpaS2JMzA2XRDUL3qMqS5RFgXbdS31uM1t8CICjJHvXVVRgpKIBBWIJPWISD6lfqFQa8509vPDiS3j33Z+j6xqaSd6R1wogtuAYON/JuxXAO+/8Ar/+534b1XhO7xN5FWbI3IehV8ZGXElOjPVQEP8bQoAPHUJwcN7R2fp6HUAIYo5gaDh4bMiwy8G199eRyBb82xSVKl1hNNlF4zdoNuvIgQdpl3sPEUhQ6vzkCNIYlNMdCGMg4BGEp3yCEGiaDsvlGkJQp/f5bAcff/xJzHF46Mg0M8ZACoW63kTnKEZRtu+8BACqtTA+YLXawK+p4UNd12jOF+me84Q7z7HtcU2J3ziGTIIg7zqrWE3PiumEF+mC+fN8mvwF8MzJSWJjMA8zD984azyfz5N3BfTMkaoq0TQNjo+OcHZ2BhcN0c58Th6ldyh1BeuzrilaYb3ZUPhceRhTAiB8rLMUqi7Pz3H//n0opXDj5k0Kt+uaEhkxPGR9C/a0c8ydbi7NO2TuNt94+kcKiZ35Dvb39rC/t4eubWG0SR5zXdcpAUmiRy5tQpxky6UCGAPeDoOllOSRmBLrzQbWEwzgnIMuTBIsYkPNfSU5sZl0XqLB4+Qxe66cUBaCWDZ5EnkymWC5XGG1WqX7YLaNcw7T6RTT8RQPjx7j8eOH+O/+4f8Hh//nQ+xfOaAORggwMdHGY52zP3LtiHyh8N/ySslBuTto/+Qxy8/Xf68STZINOzFrJlgul1ise0ZTfuR4cdN0tKEDaJuOkmaSGjKk37fkTDBdtW1b3Lp5GwcHV/Hppx8hsVe2OoVvr6cQApTWOD4+xieffoxXvvQqhCC4xyeLyF+9IRBCZJHJdmIsXDTcPuqGxAIhTtT245prsYc45eOWk5gj/fm3ryU/8hyFUmNocRUeJ2jqNTrbQgVqsRdcB3gqj79//z5uPFdCegeBAAsHbyVEzImdnZ3FuUC6M6zzQ9dKJIPZdIYAYLlYxk7wHVwUzaL5FempcT7WdYPQFDCIYmtb9Sn5mhzmCz5HkyYdXK1K84De45IjmLNXeCxz5tDTHE+fnPQeZ+dnWCxI61ZrjfF4nBb2dn0/e3dKKRQl6UscPX6M46NjcLcYnvh5IpNhDW6XtWlq7MznKEUB5yxkoVAoicVqibOHZ3A+4Nq1a4niB1ASjz29EDV92XBfDL0zzHPgPURMSonEYp5Nprh+7RqmkwmaukmZZ8b6eeDTZ2eh1Wq1grUWy+Uy4cK5QcvV9ACgaRtoSZRG8nZbEsSPycycOpk3tmCvnWEElrnk3AAv9qIwyQvmwhL2XKmAioyccw6np6c4Pz/vhbXqBta2OD1tsVj+FP/D//gH+Dt/5+/BuQ4ylrUz7s6bB28m/CxyTj1fKxt1HgPWuskntYziWbyAcn49ifkPqYg8VsZQNGf95cI/hItT1elm02C5XKEoNLQuQOGzTUlgKWUS4mI4an//Cl566Uu4/9lnsJZE/il05om1vZ76TR2QeONnr+OFl16KSoQWQvLSTL52mrM8nuRxUwPvXFt8aLx9ej8b+RAifiv6saLzZ2ORPO5+48iPPOG27SWmfIdX0OMdzHSJYr3EenkK2yxJL90RJm5MifXxKT77+CPcuHWLZBe8g+0CfGeh5RGMUdGRkCgrIkN47zGdTlFFJc6ua7FaU0U2UWQR6aNh6wvkIUtSBOR7EJmB3jaeT/KCt+dP/zMz7AKoU2ffJIY+7zIa4rMdzwSVOEseF0MhbCS2haHYy2KD0HYtjo+PcHpyQmXgIA92Z2eHkpoVYeDeWnRxoXfRyGqjMZnNgBU90MVygcVqGcNUBaO5HVe/iDmp0LYt4PoqO++pJ2QIgTqlC+okPxx4st7M3JAx0DXa4ODKFYyrEYzSaF2byqPpwfiEy9Z1nXFR+2IVl+59qE2cY8xA5HnHQgetqciAoRQdRaU2mw2WyyXm83kyajyJl8tl2kjyYiASTiLDEIIfGHO+B2Kn9E0jmCkkhEiQk3VcJWux3qzxv/yrf4XvfOc7ODi4SoL9oS/SotJ5nwxNLmjFY8ILMd/8+e95EQ43xmX1QI4iculXSp71mGQvwk8RRR2ff75x9IaKdE1sZxMERc1me/YKJ97zzyjLEpPJHC++8Ape++EPsVwSBJeghIxW2hu86DAEMroffvg+Ts+OcOVKgRAEVCAPORnrzOvNx6q/NqR7yQ8RqXsIWeQS/9dvCUNlu4DMAD3hvMPPuGjYQwik9gdJnXZ0bHSxOsf56WN0fk0djSAwGY9xdnyEqtCYzucQStH6dC0WiwVUVAksCoPRmHJBFOFuMIlsruPjY5ydL7FariL0KNLmR5udGFzrtuFGdv95RJiP93Ykw/Mmd1hzr3k7Wuw97h6uy8//LMdTv1ophZs3b2Jvby8xJHLlrRwXYqiEF9TDhw9xenJCmfSY5DBaY2dnJ/WKlFqh8w4eJMy0aWqs6w1MUWK1WhFEU9c4Oz9D23VYrlZYbzbw0eCx8a7rGnXTJAaG8x5NXWMTjQ4PFhuyvkiBs+q5+hl9KUn3Pp/OIECMgHFZJXwN6JkSOY7MRx5as5fLdDuAwnmmS/HDZ5qfjOyQ2WwWN6MGH330EdbrNQ4PDxPEwTzpDUNLGWWONy5ODHJ4ydfGBo6xwtxwM9tiPB5jPp+jaRqslktoLdG2DRaLc7z/wXv4/p9+nzqNxw2T7z8vTsqpnGywc3YIG3B+bdK6SZP8Yvk8PytuupFvpJzPoDEuUY2q9Dn5eQmr5MVHnlrb2PS9tQ6sr5LPaympGQiNP7U2u3XrLiVpUzR8kRnCB5tRqhxc4913347JKx9x0iHzIH9/H50MDck2lBFfDS5f52a/VGCjozqfTn/LX9dzty9nrFz0ZofXAEE5JyU1pCqgzQSzvau4dvMF7F+9A1VM0VnKQYgQsDg5RrNexR6uATbyvzebDdbrdSyOo8TkCy+8QJFdZLWdLxZYrdZpbohY7dmPhcw2Ox7QNLCD+xk8o8yJ4Hm5/ZXP2f512Zd11NHHukyWeKjnnf/7NMczqQOORhU2ob3w8NhoAkhGi6soHz9+jPPFeewU3aMR48kYs9mMJl+GdTJOzN5iVVU4PTtFa1qEINBwx3VJynVNU6fQPN/BUhKybWG7vpQcoKQdwxnsXZPn0t8r/RuA4LC/t4fDK1fQNg01/+Wini2DI4RIUQb/PjdKuQAXY948WXqNhiYJ91D4LlKRzGeffYYggMVyiRdffBFVVWGz2aQxZ9w6Tx5vJwApaapT8nQymQw8WwAk6lOUydCzt10UBQ4PDnB2Srz3znZYrYmz/0d/9G/xW7/1W8Tmcb0kAvOvt3ML2/IA24qTubfDnrqOhRR8nXkeJQRKTEKoCwuJ77NzwGK1TpHZwChKQSwQhFg638J2DkVp4H2IHrhMz4ifOSdvEQRG1Rh37tzFL37xU3hPXZvoGgUug0vyw3mLX/ziTfzS138Zo/EueWXh8hL4HDLpI6ZhYnL79SH0RIahs3JZwdTl13jZubeNXe6FChEgQmxyLRUljqVHYUpU832YosDH757BuQ6FUmg3a3R1g3I8I4cl2DS+9IwVuq6n3t68eRMfffwJimpMTbodvy7eawDSZgRq5M2X6n2gJCnQ0yUvRCvDObh9v3yvPH69AeYo5vLNQMTnlZ9nO9r8ouOZkpOM3+baGnzhvJi4k/nZ2Rnuf/YZVjGJwAdj21evXcdkOsVyuYJHgA8BS6b3lAWaaFjqusHZ2TnkVQnvETnSGiz9ullTFtkYDWtd8ja9c+jaFrbtwEI4QpDnJaWMdJ8hqM00KH5oQlBZ+8GVK3DWUR9IGRvoIvd6huXTqdBESpiiSF4wQuTvhl7DJS/f5w2PJ8tytYSQEkordJ0gCKStcXh4Fd5aSrx2HZbLJX1GS82JZzFBvFqtqCAnEI1QKx2ryEiPhDeYsiwTdstSq9Z2KAqDEAzqepM2GmM0Dq5exfHJCWXjY2HPO++8DWs7lFpDyD7hylh3rr8+DCF7aI03nBAQEzsiCy8p0eRcBy6kIXiuT1ICgPU9FMIQnlIKPgRUoxKlMag3a1qoyDzTIFJXIu8smqZF23YoygJGaxDO7WC7DoUpkiforEXwHkYbjMdT3Lx5C7u7+zg9eRQpYDFM3lpPzFAKgtOPHo8ePcDDhw9x5+5Oov+xct1ldPBh1PB5q7dngEgpoHXvQPA8DxH7zxkiQ2+fnwOQZ/MHEGMg1T1mWhAEESC4OlcpBFBVs5Qa890rmO/s48GnHwIxuunaBt51EEZCCXomLHdQFJFS2rQ4Pj7G4dVDWGvx8MF93LhxE5uNijTayCjKrpvHKQS6Th/zXxJkxF2Kktl7Q8xssfZ2SNFNn8DtITY6dxQ6C/RwKUEd0vnSdfjhOdK19QP8hccz95wMXZvC39wz4nBVSokHDx7gwYMHPWVLSPjQ7+5lNYYpSixXawBAF3HKyZRU9h49Pk5wS13XEV6hllzwAsEGQHhY18FZi9Z1aNo6Th4Pbzs0dRO1mqnqSWmFUTWK1Vm0aJUQxPuNTWJp16PBlErAKI0bV6+hKqivndAaXex+rZSC0SoKE5U9E4YNiLXwSsOhQ2UKuIKKSGzb4ezklLzqwgy8H97ZmdPdNA1EALRQsF0LRfUQuH54AFiLdr2CURKzyRgCHkIErNZrtEctprMZltEbllLCRAviO+LIWyvS5sdQDucpGHbhDYX45w5d16CuO7hQYjKdY71pwIv35PgIx0ePcP3aTdLKjpEMRyAclTH2zfg3QzgMNXkfqAGtGwqWSRkTvkIBkhhOLIUQgof19Nz4fPwceCNECDAyYDrSWJ47aKPQdNzzMRopJUm2Vih0zmO5XtP1lyWCI8aDlhrdpsVqtYrcf6CQBUQp0boSe1f2cfu5uzg+PoEUnl4TNwbw97ymwDlFclya9Qa/+NkvcOf2K1EMTCEqgVxYj+woSMnG4WI1KB8hGX/Cyrm4hjVnfAjExw6+NxwpbA+goRTxmfaJS881EIET8aD1x5uyFHCKzqFFgJKm56M7DyVLXLnxAh4fnSKoJXxYARIxyS3gpYTzHs7TumqbFlVZwHUWm+Uap+UC89kM777zCxTKQ+kKIniIoOAhUl6VNIeQjDkAODawoM2ms73eTv9F9y2Sc5YzQ9gm0Q98/2zEeTO+HP8fWFZ6ZR80PdXxTMnJHH/JGQjMX/be49GjRzg/PydPkjnC3qceijs7O5jHpGTOIeaS7fV6nc7L//Zhr0/VhzQAIbb+YlzYEjQShfwBRD6uSl12tjEkekAKJKBPhpsy2xbT6Zw6tqPvDJMnGNmzZpohXzOfl71IpUiU6OzsLHmuTdNARqW5nL+c481d16UEZ9u2qOsat27dIrEepQkbD8SaaeoawfedTEKEIdgosjEbjUYojKGqsghnMXTB48MVnHkykWGPEJji6bCzs5NEuTabDT7++GMcHl6HdS207htj5HARe/nO9Y1d84Ql/z2viExQD6J3lDFVrLWAIE3txEfP6Ki8IfJzG40qaK3QtvwcEz5G1xCoCtB2Nj1XLnP2thvkK/I1IZRA5UtUZYXnn38Bb731czT1Knn/HEEM5l78N4BhD+Ddd9/Cb66WmM2piS6/Kr+fbQPDDu+TQ232pGnjEJJgQBErjElBM8DD97UMkljovZeZr5dMGElsfc7Wjz44CA84R5sXbagksiYgMNu5iudffhUfSgFdVti9cggoSb1EQRFC21nUTYPpeIym6dBF6LNYrjAdVSikwKMHn2Ey3YFDgc4HBFHQZ2/BuiHQPXrf63HnGHM+R3PMOU9AcrLzUhhEXHzOlx9b+Y6tfMgXHc8EldRNC2t7ScweJ+4lSNNkZwMZiKs6GY8xGo+xt7eHqqqoi3NZJs0S5huzl5ZDDyFQw1OiqRHzIkmgSmqsu47hL7NGJKg8d29/H8vlKt3DheFjryUlg8gLmk6nODw8HIjAA0gJNk4ysrFmQ8OFMvkEZ6PHGixSSpKqnE6SWmKOk+WwE3/W8fExfPDY39+nCtXJFN45rJcL4nCPx1gsl+Sd+r4aUimVONl8rVVZQk4naXKyEcoNbFEUaYPhvydoqLOkfGgMbt68ibOzMyyXS7z77rv4lV/+NlT8LN64ctiCvXh+vnxdfSZfpecL9HxuWjBxwWcbXD7G+TjmizXHgRPEtmlBVNAAcDFMBhUwJs+bmJZRA0frwUbDz9Z6mgPVaITr16/j4MoB7t07R1noJKHwuevLeyhpcHZ+insfvo+v/dJu9LQv1/hm4zKQG/78TwDfHLEa5GCN8Tm3PyPkXjiQjL0UVAr/RaYmeB/LUUjLXoAEuryn9RmUwcGN57Gzuw8ROpSjAicnxzg5P0NXn0GCiobOFsQkU1IiOIfpZATtA+R0jPl4hE29glYSEbVG17UAhonoHHrzIUAwu8MPDXC+BvOxeXL+oH9NPoZPg1c/Laa9fTyT4SajqJLH1DRN8px5orPhbZoGk+k0GUBeWF3X4fT0FOPxGKvVKi0CptCx0Wd9irTQncdo1Be1JI/Lxe4lEVvzjjQ8eAEpXaZs82UH7579RAYgBPb29gBgUKLNizXX02BGCHvOOeSxcbS5MfQwn8+xWq2SJ82b0Db3OoSQpF6VIjimaRrs7OygqqpYEl8THBTHQ0mJKkrUKqWwidWs+WaQaE0lfTbTqtYREuBnxPK7XICTG9qmaYBIx+Mo6eDgADs7O/jggw/Qti3Gk1H6XDaqnBjNC2d40vPvKMqosw4pWcNbQQuSvO7eEOaJI76/PCELINvEyNiNRiOqnLOIWGw0azIy9kOftNpsNtTIojCQKNIY5BREvj5mmBhjcOfOHXz66YdJwz5Xo9teV0IIcMOVEBx+/os38OrXfymG4gRtPClxRtAfiJOd5QP43zxxSY6Jh3NUIp9T0Pp1sFUMEpUF47sRbP8ZPhr13AMfGkBuFUcOkZMBwXlobaCUhpIKHgqmKGDKCsFZQHjMdkuU4z209THa5pzwaO9gvYUpCtR2g6OTM4imhWs2KLWGNwXmOzNsvMLyeIkgDeAu35CAiDPzOGE4zy6Lap7E7c5f///P49kaKYReE5ppaGxY85uczWa4du0axuNxKoxh75yNXK50l1PStt8DkCHRRpNQkOsLV6SU8IESRl3bkrgSgNlsjufv3iWh+CATfsq4LR90vVFLAiEZhzLyntu2hUePJ+ZeIB8MM7B3mTNHuF1a7k3z/ezs7ODB40epfdq298SbGasDrtdr7O3v9eyMLjZnKAykUvBNpMZFDqyUMm2o/OxSIrTtoEqSpOXmxwyNcLTA41XXdYqAqqqijcf1TA+OfKqqwvHxMe7fv48XXpyjbYfJ1mGFY9+pnimIvEmzOFY+FnkSmD8v96rzPAvDPTlHu4esdDLcpKToSB8DkRUkZUQcJSAClbWzV++HzRt44+H7axuWq/UYj8e4evUqJpMJVssFLsss5rh1CMSSChET/fTTezg6eoDDw1vxumLP0i3vkeeSs93AkOT3HT+BggnBmxs10ujzBz3zJX+fiCC8SEZ86JmSSBXdy/Z4UxLQA8HCOcALF2FLAQkDEfrScBcklCoQoGC7Gp0n+FKZAqUcwzsfGxeTUzabl1icneJsuYQPJXZ2JjBCYLHawKsRnBdbI4z03IL3lAoL/sJGl6/Vz/Oct73zy/6WG/7LXpfmwb+n0X9qHjfdlLqQZNpsNhCC5FUPDg5w69Yt7O3tpbCYMWv2uPKOL7zIOOwDkBgSvMvx4pdC9vBI/PymaajEdbOBtw5Ga1w9PMTzd+9Gqo+A7ezAo8u9pEsHRJIYPPOImW+da53w6wB6IE3TYLFYJAPRUyL7fohMIUsNkWPVqPc+6mP01ED2orXucWjnHUYVebLE5miIix2NWdP2UqxN3SQjzBBWvtDZg+dnAiDx3nORJ35W7F3yJsUFOUDPFqnrGg8ePMA/+YN/gg8++CCNeb555AaY74+Nf79o+mfBz543XGv7gp0cu5ZSpsIYhmQApDwBQ1k8vlU1wng8TvBIiImmbbiW379cLrGJsr+cl8lhns7a9AyJXUKG+8aNm9TT8wugkmg24ncey+UZ3nn3LQRwL9BL3hN6vDWnnl52dvo1N1CwkTbXRYaOja+hDu/cVIEScT4lT0W60pSBo8/Lot9cbK2/Th/Pa1PnHeozWaOtV2ibFepmjU2zQd21cN5DIsDE4qfOA04IQCpIVQBSQ2iDyXwHzhTYeKAVCtVsB6tNi7PzNYKXyNX68nXfb2XDI4fr8vH9D/Wkn+Ycw4To0+Djz8gqGU/GONm0aUFqrbG7uzsIp8/PzxFCSEk4HhAudWb+MBttDp9ZvH61WiXvjG+iaRq0HRkYPmcOoQCkPHj3uTvY29khD15IONuiyZo35Hjn5+2AVVXGxItImXf2DnNDwkYjf+BsJAAKxxj7ZEiF4YcQAoSiaODo6ChFIrl2CHvyy+VysPkYYyAUecM8PxkLp6KiDiEm19hocIm2tRZlxK8Zqso1Thj64ufH15Pfe9PZBGWx9koIVNTz/T/5Ph49OsPf/tt/G1/72tfSezmhnOct2PAByObBaGCEtkNwXoS5l83RSQ5T8WvZqNDnBFRVCWs9iRetGzStpTkkACAz3tGTtNZivVoR0lyVKcEbQhi0lgMI8iIddCqYunnzJu69/x71dhwSSoZzjgYGAgJeBAQf8Pbbb+Fb3/p1jCputDF8T+4l0sb6OVi34DmfdbBCxKljg4X0XHzfRAEhEDOC0nn0b8gcHxHZMpnBGRIAQsLDExQTyHu2cTOBFkCwgC+gtEalFQpdQPgOi1WAD/QcPHrWl/MeQSiU8114W2PVWcAUsF4gQEHCEPsoDAvhhrDR1hBtecdPwrPzsX/icD+lp/0fcjyjrCtSwQYzJZhRkOtK5BfOHhXT5rhoJPcSyrJMHjgbWKCHJFwUntot7+Dbh/9Hok41TUwqeEgBHBwcYn9vD23TIBjSBjGlQaMcbvnz5NHlC42uVaYFRcZLYjab0vUBUJJ4oyF6GuwVesVMgV4yVUoF6klIvF8jDfG9vYKoaWErqWElcX877eCmDmfuDMF7aGNgtIEPHlopKK8gW4W5qrG7e4aZn2JP7EMHBe8chBFRTtWjGo+wDms0qkWrOrjCQ84UNuN1Yv0URYGmbjAaxwYVUqKzHQpZ0GYCwFhNiWArsWlrKEmiXqKS6Rk54dF5CzEGwqgvXVeRr6juG/zR75/C/rrDwcFVdG2HzvabOD8Lfr6MSXN1W4jMEaX74ibaLKlEmp8bL+Tc+OeeaAiEAffRkY/RXoe6mQCnO0DXAY7CZqF62AxAMlSN1hBlia4sICGwiht3CPvJEVBakeSuc3CrBcrz63hJ30B79RU0Tc1kOpTKo5A/xNXR8/jl/btgMkGvUOkhhIZuSoT3Xoac7AKQEKo38PkhAMjgoVwH4Ty2BaTIK/a9wY2CU5yrJAcFfYfzuMEk4SkEiADIzAMdGEMhU55AQECHAO1dcqgEGDuWcaOIz4N4hKQcKhQgYyd5raOoVwezvAUVSQMItAmomI9ACFAxQgE8NlJABQEtDKwTcVPpNxA+VHMb8AbFg29D2DGS7O5THJfBIpdBdhyxPinSuiwh/LSbAh/PlJx0ri/L5Isinm+VsFop5SB5k7ct4wQkY7ZCULebPPnFi5pD9hCIpvRp/X08N/l1/NbB/yUlFdjbSAu1Cwn8CbMsQTPtl+MXPaJhBjp+TvXvh0PxQkubmRdAm71AAhAB4crlDyw9TB0QJjGh58Uwz6UCggKEFQhFAExAGNOfAgDsbCVodoaUssGYiIgLRiJDGMe/etIeJq1pQCj6Pp989L1ImxgWwKf/s8BnAKQkJkc++CL7/3/Uo7e7l/6cjFb8PvgwUDnF1vcAYAEshcAqM5pPunJ+rwket3zA9asuNk2gQ8sGlf4/4PnJb+N/deP/9MT3CwDibQkZpQmedPDrn7iQnwCfXPyuP5722WwP8+CHJy6X7T9s0eJ4iYSA0ROuIh+jy47LRiw9l7GAqCRGH/xV+AD48hS+enwpTZj/ZTuUw6PAUBt9O5e1/bcL15M9lzxR/x/dcPMFMBTAXjSH6IyXcgEHez+MV+fYo7U2yWGuVqsBlJHrU9BrO1hv8b3j/xKvHf8/0dQNgiPP6drhIW5cuw4Tk06dtbCeWqgtY2j+4OERuo7wb+99b5w4dMsOCWB3Z4ZRVaKIUAFjmaT3TKWxzrm4owOIVWkuYuoq9qcj746gkM52mIwnmM6mQAC0IczeR23ztutwenKCTU09D4mhJjGakPri48eP0bYtDg8Pqct7URAvXoqEZwNIkMRqvUbrPDpL1X3WWezv7dPkipGSlBJlUcA6C61p7MfjMaqSusV476InJtG0DcqyQl1vwCJOrB/BkVRZFNQ0oxqhiTkBowsobXD16lX8J3/jb+LOnbtUNh6bA+hYidpZFytSidVTFAXaroOKyVZrOxhD6pGIPSeVJEYR85dzD0dIMfi985HxFFt4WRfQdh3atsPDh49Qc9cb7vazBc+IyNjZ2ZnBGD2gMHIBkJIazvlYKRrw+OghHj76FG+9/VP823/zL+FaCwmFkQb+3rcmeO3k7+O/fvv/QXY1hNSQgIJ5CSkNptMr+M/+s7+L0XgGcHf1OHcB9vgIwiAM26dK0h7bDgihjcwMDwRHQm+J8YG+C072r5JxvQpFydp4dTzGISb4fHTR+b2ct6C13CGkCDegb3PPXxJC6NgmjW5LRe3+uq7h3QZC9BEyVzKGQJuugBpYbxmjZ/bI2VyHEBkwAKqz38Jk8atY/PJ/DSdaQHoEs7pgNHO1zm2jnf8uL6AbRDkYYtf58R+KmwPPiHHnHNqedyuSJ80HMw64sCT3pgHaYRaLxUDTm3Fd/jkxOGIiZLU+x8KeQAAwWuPurTs4OCixaR8CugJ0AQdKrmz8Eg1qNE2L0/VDCKkgw1ADmhc1HTSQSgoUdg1nC4xUBaFjsYiUsKFD52kTsY75wxxaZtl+109+EQI06J4a1DAhthgDdedx3kJoAedbFLMWi/YETUMwlISCbQssWsAph5VdYGw9ECbwoYAWGghAHWqoWMGplMLGn6NBjZVtYJ3DqiO1NNO1SR62FYTVoiEjaQTJFJw3p9h4g6os0UR1PCEEOtkCMPDGQcY8xKpdIagAbzqsXYCQE5iJwao5B7SADR02rQNaYPXpA/z+P3qIv/KX/wp+5du/Am0UuVayhRcSqoiwRtzUtAF8LBwSwkKFACkb0obRfdUezziCUzr4bA4lKmD0fpQB6T97h5E2GEuDugFqaLTHi2gSLJyLFDcpY8NoCnCsbuELCTOdoCwVfCytZ5G0EDpI52FmCk1To3JA1XpMrkgUc4eHnz6AEhIeEiHcQefXWNmj3shGYxa3HghZYHFyjA8e/BRfffWbgKBmyAFZJMbJ2dhdRwiBEHM6vbEI8L6B9xbBE60u5IY7kAnk6Cut4bQ+ZOrwDmTQgKBIjKsm45OAKgx8NGaqCHAdJTrZcDtn0TcTUBDQCJIlDgBpCG50bgOoBsg67HCThmi5s6Ru/LWUfdWm6Nc156eEEPCyoQ2kWkHIKIaWIPuLTBJe29siaNtJ4Tx/dtl5/mMfz6Ql2GbMBYBuitkSAFJyjD3tEEhLWggxUInj6jNOSDHdLE9g8s5uO+JpwwficlcVXnrhRRweHMJ2vcfVNvQQuKDFO4fFYpEGOse2L+6CjMdrmIK6pOf3tR368CaV76h5gpJ3Ya7y40ji7OwMgfH5+FpqMkFyrEyFpGq9vqR5PB4nHJgjF040SkkKddy4gSKPoZ4HgNRfs67r1JmexyQvcuFNlycmb76cXOUNYkDVjOyV4+NjKC1hjMZoVEFp8oCWywU+/vhD/P7/+/fx3/w3/y+cnZ1hPB4nhUIhiBWithpQbI8/j3nOYuDFlMvobjsWfJ1ddAbqpo6J5b77PI8Hz5ft0NlnSTleoNba1HO1bYn50zQ1rKU8R1FUmM/2cP367eSVpobFCAODJ1JJOSI65dB1Nd5++00AxPDI74fHhfQxLhqTNHagCETIWOauFOmGSJn1myRPnBKR9H3wFt62CK6jTcq3JBQXLLzr4G0L7/h39PrgM6ZKcJACpHYIqswUvFl4H7VC6D2I76Vzt3C2AYLFYIleePbDBg/bB+P8+bwZOI+in0O8pnIPmscX6KOIfK3n/37e5+TneRKO/SSj/3nHsyUnI2zQNE0q0Mgvmkur2bAxTp2H8jaK8nAXF6YG5nQtoO+c4z3JIhamwPWr13Dj+nWMyiqGewFFLNZAJNEnpbgQsNmsBxjzk2+L/mZiKThi/758QeQPjVkywPAh5QuHOb2khdFvHHVdYzKZUKVczAMwe2MyoUrK8/NzmJhl53thne3d3d0B9xmgDTPXG6GQ0SH4kJLG6/U6MXqEIA43a4WYDBZq2xaLxTLhsrypsrYIjyUbdGaWGGPSM3Suw2q1RllWaD3BH9Z2WC7P8b3v/TEePnyIv/t3/x5u334uvofGpTBlhEvoPnhD6DctnZwCnY1NLiPMzgQvBK4+tZagF6VYYZ02jPF4DG3OUDdNopDlURk/W2qwsMFoRB426UP3MgGUp3Gw1sN2HsEDZTnGdLqDq4c3UFVjdPWmNzYXHLHeQ4ag9xdFifc/eBdnZ8eYza4Cso9mey8vRM5Fr055gfIqiKsdhIIIHkFGuMRaBFjAdXFjIE9aZO8N0eD6CNOkdZQihd4QhRDQtRZeKQStKUkf4RkJAR88VIwu6PNCWiPUy1JS3wFnIWP5/efBDPSnbTGsfhwHQ8BreHvUMxQgX+d5ARd/7uWf0//98zDtz/Pmt3/3NMez9ZxsqRV9YnvEYpC8sCWn+/Ei4jJwAL0qXvQU2QjkFy6lTNV84/EIezvXsL+7R96dVPDWwmiDYPtKQ2cdmo66vMt4HW3bRTH1zzfa/FUWBayldlU6S3ryYgEwKGfn4p0c92IKmoiuU84hzZssGK1RRD0PNtyj0QgHBwcJ964jd5i9aoB47gcHB7Fse3Nhh2e2jzAGmyxhnBcu5ZWg/HfuaCSljF3iyYgzHs5eMG9k3LGIo6rcUyWtEoXNZo2us5BSw+j+9R99/BH+/t//+/jP//P/HV566WU4F7nrZex+EvMorCyYuN9SoI1GmQ1mrlaZF/jkRT48vkVRAvAI0fMlLN+jqkbYbOoUZl92cKTEBpsrJPvOSxzhaGhNFY9lUaEsKuzvH2J/bx+fffIRwhPbmWUZvUBVns51WC7P8O677+BXfvV6cnT4OaR55x11aorPJY88SdSJyswppeMhvYeAgwgSARIhWHhHmPWFDSUADnkE1Isv0f+zHp4RVvbBw4sAJaJ8aiBj7V2MHAR7p7ze+Zy8VqjYZit1vgUB9UoClxk/ZotdSPhdYnDz1+TrKdcryT+XbdSzwiCXedbbuPjTHk8NlXjvqdIs9KT/PNTWMdzIKwfbtkUAoCOHmL3CXEAoJYJ8L5redR1u3ryJl156CV965Uu4dvVavNio3qB0LHEntTMuaOGwVymFxWIZB+Tz70uIfgKZgq69KIv0gLlCNISQYAE2DpykYg+NQ6481OaQmhO3fI913NBCCGmxscHZ29tDQBgYME7osue8Wq3Se1gfhjeVXOsFQNogOVLI1R3ZW+diKTaGnH/gApoc36Nx6zcK1v+oqgo2euIANX2gTbAPb1lO9ujoCL//+7+PH//4NQgBzGYz6EzygMe+KAqKuIoCtutgo0YK0HtJXdei69r0et5U+D4ZNiFa6fD6jTEYj0axSfVw4fbeZfzH+/QsGNJp26jBEcfXaAOtSRpXSIWiqDCbznHjxo34fJ5uvQFcWejx5ps/S2uF59RlBoefR1WNtjxIBSEMpDDQskRRjFEUI5hyDFNU0DrKHQhx4dwXw/pM/1uE2MCb6x1o2RBfm3VqOPJ0xBeXrBMvk8EmzDuk15FhvwgnsOHLnaHt1/BYbEfI2x53DlXl59m2S3kxV/6ZfC0DXaYnHNvr5jJv/Unj/aTjmTxuWvh949lcBMl2FswHbbqONLYRSFXVWWhFvfFIatWjKAx5yXUL13Vw1mE+n2F/7wZmsxlG4xHxf7sOkAJVUVBBi7UwI4N6U5NRGBVog0PnCVaxPqBuOqzrFkJqysFgGPbm+BQCtUCTEvSlKAnkEWC9g7AiVeRxCJWKYIQAEIXTRZS5jF6JUhJUqTakTvKDQiApTx3PyRshh987dY3T8zMASElF56gh8Pn5eZJ+5YnB72fv0iiNtqVKvk6T8aXu8ORVMfuHr483p6Zp4LVJEzyPFnjcvPeJOcQ0UC5GghCooyerlInQmMB4NEVRTOJmTuH96ckR/tv/9vfx6Wef4Hf/0l/CeDxBUVUQVqBtO9jNBsbQZryKjX6VEpDwsF1MEEtJPVCVgncWbSwO4ggv906d6yEw63qFwUIpTMYVmraDjXxymhsxAQ0AAegQYG2A98DifAnvLLFMpEQAYj9QD6pdIe9yNJpgMpnj+vVbeGf8C/h2BQhOR/rI2CBvm/JpMYrzgjjLweHBZx/h9Ogh9q8cUq4nUL6HvFcHSERhL40A8vi1adA0RLlVXlGCUdH4KSPhvAashZMCMnQEVVgLHzogMVUCIIZsiu3KSMT2fh6B3ickBCKDBQERuif7ocnQU3ETsz0CQhBQyUjSvdN7uJKWePv8Pdu23LBue7H0PdPzACB69lku6jKDmxvP/H63Der2RrptjHPse3tDyZ06/v2zHs/I43YXkj5d1xENjrIQaGNlo9YKjesr7oQn4R4pBdq2QdtSsU5ZFLh69Rqu7O+nJrrWWvjOwnUdlIiJx2whdl2XmBRmVFJ/OqWw2dTYbGrUmwbUZVnChYvC/fmgaUXGezqZI2Y6YZ1LOiO8SeUKenweH/FbYLhTPuk5sBdIEQaHlr2nzR62MQY7Ozs4X1IZPVMmi6LA3t4eHj58mOATThaG0Fezrtdrkm1ViiReYzTQdR316Sz6hhB8sAHmJKTPEqFsrDlSYuVA3rwYVmnbljBSqeBjebrRBoUpIQSwWiwgEKhTPaj8+vx8gz/8w/8Bb7/7Fn7v9/5T3L3zAjbrDaRQUQnOwwYHKag7jRQEpwTvIZVC18YGEFLAOhInA5DyJnkExFRGn0WKJPhlMBmNsVw3cHXUdUevJEfaJQACbX6r9QaTqkJRjiAFoJVE5yzgZWREEHRhoCFEhclkiv39A1y7dgOfffhOvxMkXoRIn9mvN35FwGazwlu/eBO/8ZuHkETmSEYMIoALaYQkDW8hJLQ2aBpigkiQR6yUhi4UZQx1ALSDdBreB/ig4AU9P3gy3gHEBhnYaRG25ndMigoBSJUZw+hBw1HqVcpY5MPJWURHj7x4HwQQcsPZwzK54d1eg7lHvB2RXDyG43sZgrptHxIbZctjvjwa+eIk5GXHF+XgLjueyeMmdcCek80eYvAheR1t11F3mUDdJVTEpLnDihAi9Xq8du0adnd2YISKE0sNBj/H9PKCHjZ+4/EY3pNnfHx8gkePHqNtOzh7MYTMByh53iBJWKMV5rMZQQLxtUJKaHmRApQbMPbA2SPNd2H+7PzzOMnnve/HLF7TaDRKMIxz1JT54OAADx8+TOPdNA1OTk5SuTnnBthzZO1tElDqVf4YE1aKas2cc9CibyvGmwYbYB+hCcTXMhwSQkjStCw9kDNPhBBZJxH2aIgy1jQUIc0mY3S2Q1OvUVYjaC1hncf7776L/9v/9b/Eb//W7+Iv/uZfxHQ6R8I/gRgdOLRdC66A5LHjpDggYF1IcBFfA89Vhn342fFYdV0HUxDUwxAW9X5kJkHvubHmhppOCQKSdM9108CFYWcjhtPm8zl2d/Zw88ZtPPzkHnrFjCcdGd4d5+3bb/8c3/5zv4ay5DXSM1K4Y0AIbOwkiqJC02yI5aECpCKqnTQFmJ8vAQTbwRsPBAkvaR0Gjwzi4FxOfnnD6+f1CfRRZfwDQtZAZdtzzdcF/5uvUVpv/c8yWy/56/Lf5YfnzTCqPnKnLQCXPoMnGdptI/1FuDTPr8vOx1//Pl52fjy14ebk1WbVJG+LDZiM3raUErPZjChS0ah469DVDZQQmE1n2N/bI9pXZCgEH6BLDYSQsNm+BFok7NY5h8lkkop+2MAtl2vcf/QIdU3dWBDII1NKR4bCxQHvsS+B4KkhgNEaKvPOlKCuOWy8c4yN75uvgXVAth9YPgH5tezlcmKLJ/02jKOUSjKwy+Vy4PEXRZF0MmazWcLQGc6oqgrnS+7IbnuqU2ApTppcudAX66e4WAq/2WxSYpKxePawGSbLoZ/VirrtdLaDCz1NUApAa4nCaMIxYVEUAkoXhOEGAWcdgpfYrNb4n/7wD/HeO+/iO9/563jxxZehlYF3AXVNbcKKqoAQ6gJ7oixLOB8gpE59S/Pr75kfPczFRp3vbVRVWMVxlUomGGM7yuJzaVnAWofNeg3rLFSkZTL2yRvIfD6Hu3YDx7eew713ruCiq3fRAAznUcCjR/fx6NED3Lh5B71GNxlqLgRCAJwjiMqYAlJqOG8RZIAXnr4QaEOCjBWxElIZKEUJQRU6BKEhhAN1Btq+sm2jTdfHLBGlciNPmt2X4brb97p9z/x+flv+t9yQbsMOyYjHKxUi94C5LiRGNJ/jEW8X3PA1bG82n+dF5/e27cFvG++nxbb5eGrDTd6iS7xiDq1DCPRwEkWuN0rEKBC4dngV+7s7tJiNiZoFZATLoiDFsK6nDrJxY1EjgAYyL40vigKnp6d48PAhWmtB2Bg9EMbD+szykNKXPAAAk/EYs+kMHFJa7lUHgeA8XBgySRgm4ERfvonkXO6cnM+Gnu8DAJq6hu8oyTWZTAZKfCEEOE8L/9q1a4k9woaex8U5h/V6nQS6UsGMtZDxWpumge36ruvBBwjdX9/2OQFA6b4PJidO802H7ytvzgBwc4sA6z20lNBKwDmLqjIwBSWSCy3gXItCG3SO4ItgqAJOKYP1aoOf/ewNfPLJJ/id3/ld/M5v/y4mkxmkEDBViaIiKISTqnk3eq0NrAuJ8cFzKWc/8UbJDkFSuwQwGo0xGm3SPO7DfoIcuIkAVw0TsZDGtaoqBNmrBvIzr6qKIILO4fDgOm7fvgMlH/Vwg/AALlcAzI1E29V46+2f4eat5+Jcd6DqVsZy2buNHGOhoJRGZ6kohbqPkQ53cA5d5+Ad5RpCt0Fnazhbw/sWIthkiOnojdd22XeAhw+ARKxKljFaCNm7nwhdDKPgbQwYuCgwxuNymWEdeLQAguwrTUMICTaMrMfB9Q0i8Us2mdy54ih3G1d/0v1tf39Z1PF557jseOZmwTmWmhcsAJmGtDaYjsbYuTqPSS+P8YQSbHyZucqflj3vmxcZP5yct8re5GazSdrPNgRAaCBONBE5q3nTzm0Ph885GlW4ceMadc7wPtGetNIQiGXsW7ssh3y88Pm6+UHmXmDuJTPkwOPlaPtP92mtxWQySZ8jVI97M5uEDU5eoJIniBmqmUwm1Cgg4tFNZFwEa6mUXOh0jvy6GSqxUZ6UaX7MomiaBpvNJgmN8cENGZbLJYQAjDaQgjqXa0UJ7emkxLe++Q0cXtlFaRTOF0vc+/AT3H9wBLeq4T1gHSUZR1WFer3C//zP/hk+eO89/N7v/S3cvnWH5kNU8mOdcvamGQZiZhOzZ/hZSSlTkhdASszyc/I+YDSSscnCKrFP+rlDBonHw3YdUBbp/aPxGDZ7/syymU6ncNahXTW4engDt2/fgdYn0bFIKeCtzxoeQgLOt3j3vXfwG7/xOyiKHroRkuSWRepmLsGKfUppSKHgQRupDB622cB2LbqmjrCWg/c1nOvARThSBEhB1aMihfZ0fZR/7oWshBAJYweiQQzoWRtbhulJhXDbRo2Moxq8NzeslxnXIdMk5imA1ME9N4zeBwS53QLukg0gg3ny687/fhkskh85Dp//u/333PH7ouOZDDfEMAQIIfTeh5Q4jz0Vb7/0CkqtUZYlurrBaDKCCIASEhKC2CJth7IoYl87Oid7eJzQZK+KQ33WSDk/P8fjx4/Tw3Wc6YCAYL6qIEZLSEHTMNwajUa4du0aqsIgONLKED5AapMeNhvZXD+FPWhOWPL5tkti88Te9njlE4OrEQGSr+XwHhESEULg4OAAH330UWqs0LZtgqQYw+YHz9K4ZVmicuQJTyYTtF0H0bYEYfmQNqk8ecebkXc9P543K44I8g07RVwhEBXQWtRtS35o3EilkpiMR/jGN38JN29dx7/4n/4pptMKr3716/jbf+v38O+++3388Ic/wflyAwRAa2qaQd68wv379/EP/sE/wN/8m38TX/va19NYcvTFY+QjVQ9SpzHONyaWYuWFxlTBHqoKCJCpw9B6vYlGJ6NFoIfLeOMriwIiwoTSe2LFRAdjNBpRslc57Ozu4fTkBLu7+xEPzuABzzHe5YeUAs4HPHr0AJ/d/wR37rwMLpgh1T0Z2RL9JiMAGF2gFhtIT06Ca1vYtkbbrmC7DbyzENLBS4sQmxSkpGw8b4jJyaGx7J0hgr/ZKPaMj94IDm3ItsHN18L2ay4zhttG8jKPW4jYADlkuYAA+NzLfsJgb19P/vsvek1+jU96L4CBnPH2ZvS02PezdcDxAXXdpInPBocWdCxbb1oslwuMrhyQ52YMurYl2cuMpzuOus9MX+OBYI+Jb6IsyyhuRMmmhw8f4vjkBFJQpj9sTXchBJgEgOh1c0sqZk1whx4RPSjekY0mKiCXpEshBw84RQhx4NlAb5fA88Ni48ebTr7TOufgIqWNv/g8pigA54C40xtjMJvN8Pjx42SwWBaAnwUb1DwiMFpDjEYIAulnw/CA6ntkhhBgIpukbVsSmsoqYMfjMTabTUpYek+8fa5+LSOFcTwew4eA1hLNTRcltCJj/OKLL6DeLLGpV2ibc7z77tu4/+ARXn7lq3jl5Zfw5s/fwVmzBCBSgdV4VME7oF4v8Y/+4T/E4uwUv/ztX0NRlVBSUe2AoBKQEAIJUjnWTTfJUyTYh5KXzL/mjYfzE23XwQaRPOXNps68RfK2CTOVqXwcQqCILBYIoCpLjEajVEzF3YXqTU3MCghMJlNIl82XBLZszePBuqOGBsE7vPP227h9+wX0hl9GCEdk4b8ARIgeNzGrnO3gbQPbrWDbFULooGSAMoBF5C1D0nrxmccMRO71EOOPrwB3r/exTbkPIXK6aRE66/LbusSoEZS55Zw/0cDnfxvCKtuvJfaQkATRbY8pRQqXbwI8N/LfXWakt7Hvz4NAcngn55Vjiy3ztGjJM3jcwNHpGc5r8uKKooQpow5J2+Lo8TG8C1BSYL3awO5QBSLCRdZDjlvzDfFNMSSQvO62RRGhjM8e3cdisYIXmrpAC8bTPFScvNaSql1haFGXRYXxaAQBKgRiXWpvm+RRURKtx9eCp+3AGAMHD6U1uraD1AqFjln9yMvizYBD9px9wg9su+qQ79lJic4H8o98gOg6CG3gOwutuXycJv7e3l7qtJM3O2AVRjbwbGyl99BComlriOhxSUmKgF3bwgfuMuIgpEQXeeJaa9Rti8l4DBmx7qZrqUWaVmhtBwkBJ0hBbjQaEa9YeJIMEkQ3K8sCSgWw+FNlCvwnf/1v4dbNA/zRH/0LbDYdID2sbTEalZAIKDQxZ8xkhFFVAD5uPhLwvsY//5/+KU5OjvFX/td/FaaqoA01RSC83SAIBx+oRZn3lF9pmhqAj7z3As71yUmecyrqd7SWxsJOJ6jXm+ikMJQUIKUGqddRO8MgJbxQEAIoChM7yFOkyTCTcw7rzRqL9TksOqhCQNTEpw7OQ8oCCoBHjynn2wUnR7ml2/vvvI3f/I3fhjKjlBcIQiAIxASkgwVprCttoEyFzm4QfAtrV73inqQEsdQS2vUCUkEEOlfgAiAy5D5ICJHpuAQy0pyM5IpQAcLUtxvwsoHKjVMPOQzx5d756Y35ZZ55Xr2YR1fxF5SDCESFDIjQZIgQqvPw8qL+S26X8r/lUW0OL+av3zbkT8LNfZaLY/30tPGGixvRZcczGG6P9WqN1jEmux50aUEg3WUfPBaLBZp2D4XWUNEbY0w71+RWSqX+lbmH6j3pFLAhaeoNjk9PcHJyDkiNwJ6wEBAhQCoujAkoywLz2Zyq/0YV6TGEHr4QCLBdm3A6ZcpMRJ4+uypLCr0t8Z699yjKHhMNEcawbXfhQecaGnxwwipP7tF7ZFrc/XtETDaqVCSjtU46JavVKml1sJeeM2/oGiNUEY25cw5lVaFu6gSn9LQompRNxkoBMGCccERE2K5FYQygNYzRsJGap6ChfYGREGibDkIAnbUQkjDvP/xn/wy/+mvfxu/9p/9b/IW/8Ofx8Uef4YP3P8KDB49xcnIKgBZiVVUoiwKTySTprNAYeazrGv/m3/5rPD4+xne+8x0cXr0O5xnrJQElY3TytEXc2HMNk9QgQAwLJCgiIditLKk9G+UNGJLgOUJwHBCpapKonJPxCCzjy1Aat4hbrVZYrpZYLBeRctpDMJ6bCYc4ny9dfQIIVNhzenqMTz75CHeefxlax+44rIlKp0BqHqE1jClQ11Q1ygUoUmkipghFnrlklpRPrdYuwhrDsu+QxpDtQ0iXyhEK/z03xNse5WWeNK+pbS93Ozl5Ge6c/z69HkjSsbzWvfPw6HNWlxledoJyWJANt3Mu1Qxsbx7b17W9MdDmn2PrPSHjaXHuZ9bjZs+Rk4hd19Huy+FFCGi7lkLr+TwxTPhGc5aCMYYEl0CBl5ASinfHQMnB08UCpycntOgkhV8+VWjFh+0cjFTY2Zljf3+flM8CVZdZ6dA1fd9JrkxMCYPgEdzFxp5SSipg4W40UqGLAkgMEeQDzQaboYt8InFREZ+fJ0EvyuQGi4UmTMBoVA0obN57HBwc4MGDBwCQ+k7mHFopZZxQGkXE2QMCuvW6n1RCEGwSPc9cgoA/i9kzfF3MlSajTxDLar1KvRv5novCQAiZNGuMkfDBwlqP/+q/+r/jW9/8FkpjcH6+xKeffIrlcoXVaoPZzhzTOQAoiAA0bYvFconlcplwbGsdhHB4/fXX8PDhQ/zv/4v/AodXrwNCQJsiVj32+ukctQFI458nJZkHn6piEeAs5VnG4wqbTUlYN8/PuMhENLB8Hk6M8sLlKte2bbFer3F0dISzs1M471BWIwgnMJ3OoPQpbBt57zI8EeUWkg0ksUvefucXuPvCS6Cq3Sy5jB7KcN6lDvNGF2hdQ1IRQUMKBw8H66mlmkLvSfPz3s5lAUN55m0oIP+X35evJf5+2xjnHik7DnkOYdsI8nhv4+B8nbmxzc/dG0TG5vtI/zK8Of/9ZYY5/34bn8+N7+WYNX8ewBscwyV/Nhh3GNbdp6YCCRviPpGUgOTijK7rMJ/PEwzC9LXURLhzyXvhir7lcomTk5PERBFSk4EXIO8jUrSkCJjtTLG7t4fxaIyiMLDOwVmH2nbkHYYwaMbLk4M88CG1jSsRRdxAghcw2lD7KSFiuy8Ln9H/2BDnkEnORc936/71gNZDsSB+PXm7vaY04+pcuHR+fo7lcpk0RubzeUoQO+di/0Xy+kxRkFys94ldQg0UMp2Y0OcXxuMxysy4MVMo7ytKZewB09kUm7rGOmySRkhTN9R6rTAoCg3AQUuDpunw4OER/vk//9eAkzHJ2kBK5pQ38WeD4GMOICYf66ZJUJdS1MX+8eOH+Cd/8E/wd/7O38FsvgvvAaV6zBpAgufyhZW6tmfOhvfUEMD5LiV/q1GJ8XgUdWCiq5iF7T7Od650zYvSAKQ5fHp6ivPzc7TWQhcFxsUe5EbhysEhprMznJ+d0VzaMkT5IeNm67yH1grvvfcWNvXvYDQ2CBDEtIkJeikdtO7nOcnLlnC2hkaADxLBd+i6Bl1w1NDDDw1v7mDwcRmWPLQNF5OLfK5t5tK2Ibzs93kxHh+5tOr2kRvTy7Dw/tro9VqRguHwb0O4JvfwL4ugBw6g/yLp6Hyc+sg9hIvt9Z7meCY97hCTeRzviK0H0nsiLslccsKMjQwPyGazSdS2ICRUWSIIifP1Bvc+/gSffHYfq02Nzge0zsMJCaE0SZVqDS2BQgkc7O3hheefx3Q8hpIS9aZGcI60UdBT/8qyHIQ/yWOOk4H/noc6UioYSVtEoQwUJGQAKlMQhTHD6tjgsuHnjYKjjXxisOASP/j8AfOYtG2L5XKZmuDy2FVVhStXriT4ifVChkJQtHDHkwl5nAGoRlVirIgIlwB9l3ZjiP5H1ag9k4TPzWF/XdfYbDZo2iaJXS2WS6zXa5yenmK9WWO92eDs/BTL5RIBEoWpIISBgIa1As4LrOsWLkh4KHgI6uJtDKAUVFkgKAlpFKx3VAGnSOhTSpIHFRJ4662f4x//439MOLYIiX/O98UeNm94HFkwG4c6x/evL8sSVDFIpd6j8QhFaYD4udxjtIdYhl4YRyycizg7O8Pp6SlFKoXCeDLB/pVDKKWwM9/Drdt347ryly5yPrwPIOSLNpezsyN8dv/j/x9t//1sW5Kdh4FfZm533DXPVtXrquqqtmgPgAANAJEAjQAQFCQKkMQByRlS0vxDo1+liInQMIYiQU+KYGBIgrANQxIQ0I3uRrvy79Uz995j9tkmM+eHlV/udc67ZR4D3BW37rvHbJNmmW99ay0w6Y3c7SyEQkxMFSqzGtYWyGUgvMfop+cEnraWtTXKvxmI1wL9WNjqinqyh562UI/3mRaeOpivcyGu+9yx1auNH61MgaNmLglmPZBtcWKHaXKEHlf9/Px9HSyix0I/8/TsqS6SNXDOqN9AWX44W/rZ6nFPd6ifOEMW8iNvCzYpqbZMvSZMwQUurr3Ddr/H1XqD7XaDcfTwqcMMtTEL3UgwpICJAWVV4tbNG7hxfo4QPPpun63e4Ec4W6JwBsPgMx+b2pg1QZxzqMoSIQlaYsoUwogRhRPNWlRTPRBnbKomZ4RilD2OqccmhS0XjuZ9M9jl3FTJT9MEZXw8TDo3WQoU3icnJ7h79y7eeuutLCioeKRutiw+P46p7krIBbqMMZg1DXZtm1lBQ9/DJuX28OFDtLsdbt26hfl8jhhjbhbARKB91wm9DsgelbUWJycn2cplCdRd22K/3yMGEYR+DCic1MeezeaI0aOZNYhRrMkyJeNUtayV3W4HWINu6FFXFbbbDdq+w2w2R1nV+O3f/i3cvnMH/8Wf/bOomvlTbjTHU9xwtkczB/CV9x7b3RZVU0pjnoS1l2WVPIEeIXADJyocMf8k+K21eYy32y0ePXqEzWaT11TVVFgs5jifz+FcgdliiU984hxf+ervQ5JnPiSdAFJH5+tf+yo++akvYhwnLJkBRh88bPDcnnC2hLOlBOTTPcYQEE1AgIcJh4lp11ne2kvR73Gc9W8NPehg3vs9Iz9zLCzfz+rXMafjg8JTEwYAZDjKGiM1xo+uo69/nTKj4Xf8WX3P+vcxbp7uPKfcG4jxiBSI1dVV3+/4TxPcR0fmRiYhbp1LmX/Ii1vfEOtSj+OIh4/uY73tMChMi0E7UQIus0dCiCgKh7os8fKLH5FgUsoKXM7ngvkWBdp2jyF0CMyoPMLsOKl916OAFL/h5taWMQsu6ZopucSrtYCR4BwwWa5FUWC9Xj81kcfBFhHUh5uClrlQJKX0pfc+ByO14js/PxcLN/V9pKXTtm1SSsnKt5IObRTe26YmGBS6RVni7t27mM/nuLq6wnK5zFCVzjrkxvXe42q9RtvuEKM8y2K5RDMMeHL/vnhbMaVBx6TAXJEyZj0KB4xjKj5mJosOsJIen4KTrIDIIJCxFrDyPR88/H4P50b843/8D/EHX/kD/Mif/VF8+lOfkYSY2Qx1XWdlI89LquAhq2mz2WC5WCBYqRo4XzQIXiIvs1mD+XyO3faQHhhx2OxjGAbsW+kwdHl5id1uN/UsLQvMFzOsViucn56JYqgbvPTySzg/P8OjRw8+YIel6xqpZW2NweuvfQdXV5domhvC3CokwBljEmTZGzCIUWqRd+NGYL7ggVQsivEkLayOhezxv6+zlPVvbYken4/G2HVCUSuDY6z92lEx5j3vh5a73l8TKiC9Vw1jQEfXORbEvG9tPevP8X6Pse3rhHp684iaKFPsfcDoVa2X9zmeLTiZfuvB4uNO1b8AWEnB9QGoK8FGfZSUdAuLtuvx4N1HWK/X8OOI3gsHVw8AN1cI0i1HODQBs9kcr7z8EqpCumt4K3Qf4sAiZAWHplvLyWGAbbFYyGQ6mbAi1d2g8Ca8QeubEMRUm2VqAmxi6tTSSnPi/X6ftale0IQ2yDooCgdpNCvlRgVWmix1KQlr4VwBYMR2u0OMMddrsdbixo0bcr0kUHU2all6lJVY81VZIkSPRcocNDFi17aoU7XB+WyGWQoynp6eAgA2a6lMOCSLcbFc5lou6+0W2+0WXT+1rN9ut6l+yojkKqhVI3iwcHyBbpQSwL6butpMqJ2UBnry5EkWuNYKY6SpayxmDawrUJQFnjy5FDirqrDZbvB//f7/hRdffBmvvPIKfvAH/yReeumlzGWOyRBoZjO0ux3IOx4Gj7qW+tTtsEVZVpPQc0BROsznkksQolS4FME4tS7b71sYI2PWtjtsNlvEGFCWEgBeLpdYrhZYLJaYz2Scm6bB7cVtPH/vHh4/eTglT77HxovgjyTjPLl4grfefAOvvnqKACMy3VxntRrp61lWgHPofOpmYyyMjUBkmvqEr07xjWQJG8WsgAj7vNeN1COBFnzWHgjoEGJifZucfyHzbLK3HqHLugZpxqBYWNf9FlEzKdNDwZ06+sgtTt8xE+wRnUvv2QwvytvmyLI+7sQupRpIb6QnptvLGSOMYS5rYxTLJYYpM9VIwLssCpjSwRX/GaASbTlmLUXhZMAajQgB8NFgGAFrI6Ip4Cppk/X6W29jt2vh/ZgmVIo5XafFZIAtAA9jI1arFV547jnpwN73cMZiPltiGHp4L9h6WdYYxxaIUqfEORlYRvrJwshBymQ16UOzOCh0teVtraRGP3r0SCL+oweCWOHBpgBZCACmPo7ApLX5nAzmOie8Zxap9568XaDvBzgnLBoR9NOiouC+vLzMQTi+J8KQTSo8qrJE5Rw651AYgzAG9GZAke5XXGcDHyWJyoeAoixRhak2zGwmVuN2u8X9+/fxKGWvypiNeYWKcMv/S4KcwiBm6Kuqa7zyyit4+O672Gy3SWFNQUQgVZtL62GzWeOqEsXqigJjgtrKqsJud4X5YgE/7vHmG9/Gb/z6L+P27bu4d+8eXvzIy5jP54ArcXp2A2dn5zg9OUWMBt/81rdT16ERpoyorUudy+Xeq6rAfFGjHxqsNy0QhfXCzb7dblHVBaqyQNe1GEc2D0i8+bpC09Ro6gbz2UKSvCDNQOpmjpdefhVf/cpXEHx/YIVxjQBJYBsDYZDItUcf8M1vfg0f/9jH4aODDyWcnRgZwYniN8ZJF6iihKkaDEbO5YxhRdg0vDq4iLRe056GqsynLGOBMQ1MYkGFlP9gCidB0yiJWCTlCb5s0jq2+Zq8LqmXsmakfr8WutprFvnjQSGrGSAatiV8NL0ulygKC58VkoNzJnt/+dnUNbUikHN6CKeSnoTJ7xsjNWAAoCxsenbAOemcVBcGVSketLMO1gn0CoO8Pj7o+E+CSjL2zNs+hiGsyy60sxaj93j30UPsdrs8gJOCngaDhwyWuHkhBFgTcPvOHZydnqIqq/SasD36rkPXT7xsVqxjCraJMVO5SDdiwFRKWE51RABM76kAhJ7ELuG72+02v5+x7GSRwBuEKBxw9pbUuKo9skioEHOJ0bLEOPoDAcYgJel+1hqM44Dz83Ps93t0XZefXXOJGWwZFC/bpKSjoipz0LEg1h48xmHIc0VLg1gtg5g5ezTG3A0dR26kXhv5oEuesMe+71HVNYqEiR94ckffjTHmufaJHjr6EWM7ou87tPsWTx4/wXy+xMnJKbz3eHD/Pr78G1+G9wH9OOLGzVv4yEdeRDObwcDi4sklVicn+MIXvogXP/oiXn75JQAytqYUhT+fLzCOAZttJ5REJPrkMMJaoN2ViE2VoSfCMfP5HMvlUsE+RTZSnHOomwYvv/wKFssV1k8evf+mS6wRk/GQgO98+1vY73co62VmdhFy8z5AEoFT/06Il+KcwzBKlUhreE49PZMV6ZwDrJSpYCals06MlRDhDaThgysARIwxUV6ZbhyNNAjGZPUyjT4e7XlADK9IloWxgLPZ2tVyY8q0nJp7XIcrA9N3s/BGwpWtRTSH3zvG1nXsSsMgXIsM6vsDmFcUj7OScbxarXJOgtQVcqicRZG7QfHZRCFnT+YDjg8vuNNExn5QLx3BJcZkeh0H8OrqCuvNBmOYqDJPYUFHlxJYwyF4j6oqcPvmHdy8eUMoPD4gjCOaupFyoGmSmDpPAR1jlACjtbBOBodFiQAcUPX4t8axGSzUFD6t+SlktFUe1aCXZQlrbKphPuHXOsCiLQEAB54AixzpxUMe9W63w2zWZPjm/PwcDx8+zF4Fx1VXECTss1wusV5vUIeIbuin1GZ1jSEFIqnEKLCJd6/Xa2w2G8xTbW6pQDiVLjjeLAc4JZ/ZTjWyiWkz2eZ4XalFKCJEdu2kMNScIIqX0nV7DEOP2WyOohBvph9aPLl4F48fP0DfS3C0qmosFkvcv/8Wvv8H/gRu3jqHMVNHH2ddqtvdYTZrsB520z0a4a/vdjsAMStpblJ24pFWcBWqqkBZuGR9OVRlhdXqBC+++BK+cvH4aSV38OTTgEQEOOuwXl/itde+g0988vO5Nkf+wTTu1lr4ABROKKVjL/vUGBlRvQO1tyvPmC6chEuMXop+QJB+Y+w0p4RCMs4ulimzkuU3AR9k8T1dj0QHZCjheN/J8XSAkIfOjeB7ej0SFrIyCXlvHcC/R3DTMbbNNa4tfcoNeQ2oyhLL5QKr1QpN02S6rCSrRUgp3CkzehxGhDBiGP+YMW5jDGbzOba+PYjGHy+2SRBHvP322zIRzmXDWtfsyNoOEdFLDWQAotG9x3w2w927t7FczGBihB9GLOcLgUmsRT92MNbkGhoMBmksOprJCj/mVzvnAC8whIYYNLXuwPpI5+AEMMlkv99j9CNMUhAhCnMCTppPHAc09OLgQZiDWLh4LP6ATggg1ygZxyG54Q1OT09hrcUbb7wBH4THTayegWEmPhkj1MdoDPa9BDW7rkOfBKhYmxLEGxNMweuzoNUwSCPjk5MTLBYLOOew3W6z16ATOfK9c53I7hehawzu37+PxWKRn1N7ONl6yt9FFtrQv5G62qThlOxdiQvMZnOcnJwKHgmPbi/ZkEM/wvses2aOy4tHmM0WgIv4oR/5IZyengkjKsFVXdejqWeYzeZodz3GgUkuAu30g0U5OAQ/UU/5U6QMU5PamYXUDq1wJZpmhrpq8OorH8fX/uD3UjPdpwsxmWRty4/EeqwN8GOH73z7j/CpT38OwdNbTHVQ8ucz0gRA6pZ3rVTTNKo58LHAzn8T7kqfI2kAUIkn2nNMgj4ELynnhDsggpmcdC0Ytbers4jF2p6CphqnFsseTx0aTjm2oon5R2glIMd11Nz3O8hKY1yMUKIojgBn5Rrr9Rrb7TYrc2stSnlTauiMQ2a0kV32YY4PL7ghWmQ+N9klpLYycQpWGCvYGfdVtq7NNRMApE08Qjpjh6z/T05PcOv2LSkhOg5YLVci3I2cP4xemsuGkDcMlckUFBHcVtPwtIZ1Vix4a6Zi+hoWmbC0KWmH2ltnRwLIBY7qukZtGnR9J/eX2BtaIHGB6PNxAU8WKrHASfgxuUYErDSwIA1wNpvh1VdfxYMHD3LTX0I7VFjL5TJDNUVRcvjRD8Kx36ZNxebDOQgXha3CzuG8533b5mc6Pz/H7du34b3PHGZuxPzsWginYxxHXF5e5jHn53Sw+hA2OQwyHUiljNPKOfwYsNttlDcWEMIAyeyUGEtZVLDWYbncY4geX/7yr+HHfuwvoCwbtLs9AAdrS4QYcubvOHYSn4DUGx8HqV1eV3Uus0slLFZYAe9H+OBAa7EoS8znSzTNHLdu3cbJySkunjx+792X3Hww6IUIE0e88dq3cXV5iWZxA0jKnqUnlIme92FZlXCFA7zNQVsdGNVeqMytcNh5Kmc4jSFZ4WJpx9SwxAKwzqKwwtywqdNSWZYoXPJeqhJVWcE6NpCWHqc+eW9t26ZcgTGVNIgpe/RoT+Jpa1wLZP15PpvWR8fC+9jSPn5PezDHyUDMdZC/GcSeylloxeCSgee9tODzIaSAbDzwIt/veLbMSSAvSGKcObEm3ZhNzQtsSkmX78X0+mE2Eg+brPTCOURE3Lx5C88//1yqjdGL5TN6DF2fK8J5L4I7xojejwcwQ9M0ePLkiWygsoQPU/stYOqvGKLUKeZxbHVoocoAJS1i4JCQ7/2YceKgovOcXDJajuERqQU9lY+lkK0ql+ESCl9+hosjxpiTamIUDvu9e/dw//79PM7H/PDVaoW6aVA1M/gYsN3tMIfwtd98801pPReV5k2ewK1bt0Be9S6lz4c4ccyff/75A/eRjRgOrAhlIec1pcZCB8A4LhzH4012/epUR4q8heDR7dv0WlIKuc6zzOV8ViXlHvFv/+2/wXK5whe/8H1wrkRRlBiGqVzCcrmE90AMIrwRAdbJYUYw55Axla7boygk0MnO5izl6lyJ2WyB5597Ho8fPXwKS50eR4SjAeubeRjj8OTJI7z9ztt45dVzACYry+DZZ5OwUipElvIPjBWcFTEi+sll13NBvNZAxjLvX8OCWw4wYkAUrsjeRlVX2csr3FRewSXYqCiKpIRMrjIJyDj2yfsTCKrHZrdLWcKHkGNRFNJU+H2OYwFM1orhcypLXK/D4+8dW/E6S3aKKfgMn1oLIB52gH/Ki7rGsv+w1j7wn0AH1NYhIQoAk+DO2lnwL9IEI94jbdaIwDYQIfDcc8+lriE2J7+YCPQqFb2ua3T7PZyx6JNQ0vRB1vCQCPuICOSuPfyscw5lUcCGCabQODcFJSeJBfjJfwam+hfWWhSmgE91LEon9+IxZmiFY6Y9Aj35x4ERCm3i9cySnISZKBHW8iDnmS27Hj8W6017Icx6nM3mWJ6cSnOEvseuFS74crVCu2/R7tpchAppUV9dXgLGTLWuIVb2vXv3DjLmGFw9PT3NUNLV1RX6rjuEOfQRJ7YCN5EIEoVPZnjkGdardumNdIWZvm9gchfxRMFsd3jw4D5+/uf/PhAtPvvZL2AYIsbeYzafJa9lga4bE9SSlGJ+jMki4xpLj5eEXRLaoDKS7NyqqvHiSy/hj/7o69Js+3gDT0iR/DN5ITK3A771zT/CSx/9FAxIH5UvydqUa45eoChnJ8hAn1ULpcnqFpjEWWHBaENFirjVKEuxIIuyFAFdVajKUgp+FaV0b8+ZnUhzKta4O2oLCAMEVlUMAW03YL/vc7LYer3Gvm2xT4bM+yV+awGrX8vC2R4K7oPhfh8jgecg6qCFPn8k03Uq+KarIuZlbJ7tusfHMwhu8dGMk+AD6yuUZGoE4Yda62AFRAKMVCIziPBh6hJDQcl6H1XpcLJc4sYN6UcZQkC/30tmXQho6iazIqRMZoumrlFVNfbjAPgp0UcHIGOUzMch4ae6MFRRFElYAGPfp40ADOOAsqpyb0ZbuFzcilY6IyjOCFTjg7y2mC+w2W4QRw8XDVxRCqyTlIAEV6XdlCEjI06tzbTV45wFS5PKv+Veyfcm5ztGoCwrxAhsty2sNVitpC7M1dVVtnwBHNSevmq3WCyX6PZ7jN5j9OLqn5+d4uLiAg8fPUqWYQrGFCXu3L2bSu12qBOmx8WWaWjKc2BhsdVqhYuUxSmCK1kwdqqRLkwhiwiLYRizoJbyojaZmQHA+DS2+R6WitxakHVrAKR600jUNOYHRERpNBE6GATUrsQv/It/hru37uDmjTtAMPDjgKJ2yaMr0XXCzjDRIAaDcQho2w7GOMzns1x8y6dmFk3doDAlrHFJVJJVM8C4Enc/8iJWN2/i3bffkjVq2BgtYcKZyW1gbIHCAIB0vnnjtW9hv79C3SwBIxhroZgbHkEsdAB+HGGiBNJ9qldvMQXXaClL5miJqrSoSim4ViReOq1x8WhNFkKG+z9R45y1cLYU+NMa5XULnOMKMdhCnJJtjLEorciUWTODXwZpvDIM6G7eQN932Gy22Gy32LZ77PeE9YCJk26SZ2UPBPckGJNBoDzq6yxsbWnzN/99XYLQMQwcUrnaCCaZEbaJKTybPHsybULM3voHHc/AKgHgLGyI8Kn3ZIwRNm24kDSY7Avpfh2BlHTBSDJrPjiMfsRiMcfJaoXVrIGFuFtlUWYaGxLm6ZNly/6KgOBhu3aXK8LRgmXZWHK2hwSjsBphnZoEWCspyhHIEId1U2Ebum993yMUIddlGZLF6Zw8g0uB1xgj+q5DkYpkEc6RYZM62OygzoXfjVMPTeCwhZHcb5H6KgoromlqafIQhSs/jh7OeazXGwmgNQ3KsoFzDnfv3oX3Hk+ePMlWOjHqaA2iNXj46GHOxpQgo0XX7YW2lotcGcAVaPd7PHryBOdn5zhZrlDXVRbOFNi7nWQOXl1eYpeyPRl4DGqBF2WBppGMRM3k6fsBu3aAdaKEfcp8FWaYwFFx9IzWXbNAj3Bw/mWO/zBJBAKuKJICSZ1m+g7tdoN3+gH/6B/8PP7n/+n/iWY2B5yR+izDgLK0WC4XkJo8Ps8HogiqqmpUHETqTzTVDHXZwOmysgDG1Nx3dX4TH/vEJ/HwwX2YwBoiFNzItLo0gSA9Hibi6uoxHj96By+8+CoChF/sQ4CPTGsntCLNu6UCZ4GIgGhi6p051deo6xonJydYLheY1SXq2sEpj8gm403KxCpFfCQAZWMkxZO8b+ccTEjnSgwPZ3TuwQRTlqaAweT9so9td9Zh3+2xbvfYtS3W6zWuLqXdHC1beoo6jnQAucUJt9YC972wcs0e0Z4VXzs+YrSJG349PDytUwZLuXo/nEv5zB1wENMmClP01/tRAhGWdC0pHCU4d4QzJtdJBqRTyPn5c4KbGoN2u0GdtD0hCW0dMyuSric5ymR/FK44sKgZaPReCuNreh87u0z9CA9Lf/J7nEwKfE68xl15L8Mw5MBV27ZZgRDv1ItmwgmnWiw5KJcOdrI3xuTuM5qDLhZ0PCj5qqveCYxV4M6dO7kiIwVJjBHGOYwIeTxPT09z7Wt2jM+L3BjAB7iyxOZqje1mg7OTE8xnzcFYj+OIJ0+eSGDUe8zmc9y+fRtFUeDNN96QeW8aVHWJ8/MznJ+fHzTVkCSgiH3v0bYdrq6ucHl5ibZt88aJEM9DusO/l/B+n/Ubk8WqLMSpjZRJnppH8Bs0TcC3vvkN/It/8c/xX/2Vn4azlQTdokvKzsH7Eft9h2EY81iyzrzw/CUBhy3M6rpOQhkKDpJEpNmixMc//in8x9/+bQzt9vCRDiCiQ/c+RilF+/p3v417L34UwY+IkJIAwXuEWKQa2x5mHBH8mDL6DGJSIjbEfHpmgxZFkQySGtbWKOfzvAfpIcYY4Yr3gSuSYKKhwhjIZOUiY+dapmX6XYQQHyBYfFkVaGLE3DcY/RKrwWPf9WjbPTbrLXa7faKqbjEkr1sbRmkVyOsxHAhyPZ780Uk9eQ3GQ4KDZqJoBaGt/ePrHCuF65TFBx3PhnFbAxgx6Z2b2kblrD1ilCFIdDkNkPcxc3VPT07QzGZyo2HEru9RJ9yYD0GrGEgYb4ho9y3qpsFut8NivkCMYiE3TYPtThY6BTqxaVkgh0pAl0qlVc/BdsripgDkOXl+YKpLQqXC9yhIQwip0lzIdTZonc5TTZUQQk615+Iq1Djoc7LUKDnCxpgUrJnOSxx+GAYsFnNYKxXx7ty5g7fffjt/pixLlHUF4xzqRmCMxVxqoq+vrvDuw3ex2Wzy9WM0MEWBumkQQkTX7fH40SM8SQJFY9PjOAJR+jt+5CMfQVVVeOONN9D1PebzOT7ykY/g7OwsWevCNc6YfxDIpx+7nCbOI5fLHCKiFSvuYJHrf78HbDJ9bHKNdfBZ1k2qjV1abLcbWGPxa7/2K9jvW/yV//q/wWy1RMEstxAxNrW45MbA2SJvYrIilsuF1Napa6loWRTw3ZgDmuM4gMH0+bLG88/dwwvPfwTf/dY3JmF9zV7WsQDECBM9vvNH38CXvu8HUDYnkAbAUpMbAWJ1ew/jkxeTG2vT5pvGWQeyt9stZrMKy2WD5XKF5XKJ+WyGZubgChZTiwc3eYyV63HRP9ybzLHgntPCUJoNTZAEvxNjAR8iGhQYRjFkTk96dN2A7XaLi4tLbJP3t9/vM1T4tEdwCIPo+5hwfrX+0vEUXfVgjT3d+uy9Pqu/cwyzfNDx4QW3vqYR0p5NODWQGmokoj5CgC0LWVQh4oV7z+H55+6kpIsx1diWiPIA5C4ieuAOquzBA86iH0dUswa9F0qXdRaDn8qn6og+BWA/DrmOMz8DTEE/QCxczT8+HmiNy+skE9L8dDCTDQhoHbM7Ot/Lk6oWseax6gnktWiZkgoo79usMHVG5mQ5S1alCHkpz3p2dpbhiaKStPxxGFAnL8NCStYuF0t0fZfrrjgyaZK7S2zeAIje50AZIP0yb9++ja7r8PrrrwMx4oUXXsDt27dxfn4uVLUQMQxS48P7ZJ0Yh2HYY7vbH1ghTdPkOZnPZ2h3Bn3f5QYe77UZjl1fJFSR7jo/c/jvApKVJ3GEq/UlQoz48m/+Gnb7HX76v/lvcfvOXSAGlM5hMZvBwaA1Fj4ZM23bIkSfKh2W0uKvLFGnJsKaRjsMU6ne5WKFGzf2+MQnPoXXv/OtrESESfL0M+rnNvBYXz7G+skT3Li7gJQDEZEcYhShHQJiGBG9ZBMbk+IHSe5qAaNZEvv9FtttgaurdYJPlgfZoE7VkmZvR2uFWGAU2+Q6oZThkghIl6qUU5nEyGgSZzwCnl4BIQXDmvYkGtSYzyNmszlms7mURE4BzYuLiwwTUhvGIOC+hju4j7n3D5LBlPLQcZ3r5kV/V39Gf/dA+aZD10f5oOMZLG4ZMQYaTJw0k0upqQDSopD6GKvlCi995CNomhJlOSVp2OQaicURM2SgU8/50H3fT+2xmLyTcDbvPaJywSi0uUEYaIESkLQ8qUWbssKYLC5+l8JScy91V3eWUdXCmynhGq7h/dNarqpqquSXnpWfp5CmkKclr6PuxILl9em+6GWw/Kpg+SUuLi5QFEUW4MvlUpQc7zEtLkIzs9kMbduiSdaaKKhEfUo0sGyfRWF6GBxaLbPZDJdXV9i3Lc7Oz/HSSy/h5s2beQF3XY8h8Z7ZeFo8jTELcQoOzsHUxMGjrizGUSyr9Xp9uETfQzhMfxz+TWVLZbbdbrIiDAF57rpujt/93X+P8xs38eM/8ZOZCdLUFWKa4xgnLm9RugyNzGZNZvwwQMWYyJhiHHXdwKBAUy3w8Y99Er/8b/5/6Dpi+Yet055+PsAZg2G/w2vf+SZu3n5BvF1rUrERI2UfonCGDYIEBa1JAdIIxMNmB9pgGUep3d31Pdq2w3qzxXK5E+E9n2GW+mtWVQVTTNxmk0ofs0kAz39098hh1/yeSQF4qYQolM44BTQdreCIEMZstPgxYhzJA99nY2W322WjJlvs8nQHVvWxUD5W/Ncy4q5ZZzzn+0Eiev3x9yF3/oOPZ0t5LxzKlA7shzFnTAGSMcVCXQbASx+5h7Ozs4SLB2wutwIbGIO2a0V4F0DlisQucdkazm53OtkwjogGkuDS1DAwGEZJqkDAATzCB2ea9hgC6qbGdrvNA+Ocy/TAfbdPC2zC6nQnG8IXmgaoNSmxZ2stttvtgYWoqVPAlFZP3BoK++O96Q3K95hAwg0gSi7m5BsAB7i0bJxJ60+dy6c0dioapMYUwzCILRIm7K8syxz9jsk6o6COKaJi6IEYyawFxEp+6aWXskC8uLjIMYmiKDGO5BhrJS2mH5+XipLju9lsIFl4ohxmqdJh13XvgXdfFwy6vtxojDFx+w2k/kXKTPQiOLfbNSKAX/3VX8aDB+/i537u51CXFcaxh/cj6qpECYthlA3Y1NK0ok7MJ00xhRrPMXVAn8/mqOoZ2t0Wi8UKq9UJuq5V960U5nXPGQMsDN5+4zV83w+EBF/IsPhUiS6GgBgk09kgZU2C2YnuYO9o4WGstDI2RpT3drvDOEqp4XXTYN7UWC4WmM/neV5ms1meU5P1/CE2zPUU49M1tye4Jk7Zw2HqtjWMI7r9HsMoOSRd12McPLyPqeyDGD5jUqTHnixHFEf3o9eNtrp5/7pMhoZdaHzo7xwrgvdSChoe0rzvDzqeASpRC52BiYQRg5zt5NaUZYnVaoXCOYRUP7iqS/hAqzbVDEjuUQgGZSoeRQHJhxsS+6QfBpSVWJtsegsgU4mstWjbNlukMaZJRITf+YMAJy3aoijgCsGZ66bGkOqwcJJiWki8H24+bSkzoKmhGg4+hVCIUluC5wZEOQSDjOVri5r/1kk0XAy0QqVamc3noqKj52LMVDyLSoUeg66bwu/6JERmsxl8jNj3Xb4vwmHWGPjA0rdAbrNkDMqqxo0bN3F6dorFfI6yLLHZbLDdbjGOPjFjANHd9mCcxhGoKoeyrHJQiQqPwdemrnG1ucLZaoHnX3guBy9pcWUpkFgY02Hy7+s2DGu5kLdshAQBKf4jws2HgLbd4t13HyDGiH/6T/8xfuov/xU4R36+hR8mr7CqStRVhaauswAnBMFDQ3JimS+wdk9grMPp2Q08fPggszU+6KDAeHD/Pi6ePMaNu0tRwN7DBwvrAhDGZHEDyNTCmOEKHVc5oNAJ92RSPjGi60fs+wG7do9NYXF5cYHZfIaTkxOsVic4OTlBlTsKIQnwicnDuddQjU/dsvwoEE0/DOj7Mf108D4koTwm78zDB/l7HEcEL9eRtT/1Vn1KMCfjwwqN6MCj1etl4l5Pljmf42msflpXmmxwnNSkhTQPGlJaMXyY45l43Ew1jyGisBbBB5goNbYNHFJDSMxnc5RVAZiIqioRggdsIZaAtVisTrHdbhGj1BmpXCHWnLMYg8+ZkGVRCHUt1Y3w4wimxIfRI5CPaSBFrJyFjxExBthCBHRTSTH9JmGMxhgpxZlqd8RUhSzEKHVNRqk5YooknK3JbbNijLDOSvd3wzuZuttoHLzve1jW3A4GQ6InRkzp8kVRHghqAFOlQeDA2uf7ZJUIX33INLaqmpgzIYwYBllUfM6iKHB5eXnQkIHX0xbDyq3Q9gPqeoauG+DHESFKZmxidiHAwJUi8KORYHTXj3jrnft49OQCz925i6oq8eDBu2Cnm6aZpTGS+9VeSFay6dlIpzRRAt5IruS8btD3Ay4v11hfbaTeRz3DdtyJkBWXQTZfRKKoSmsv2TjmwDqPMWIMAcN+DwOgLJxACkeb0VoL4wyGfovN2uE3fu2X0bUtfuqnfhrz2RKIFiZERIwoS4cq4d/zppZKcEaqGPajNFvgxg6jR13VmDU15vMaxhoMPmB1fhOuajD2LRz56++zn71x8Cai3+/x5ttv4Oad54HQA7GCNQUQ9gA6ONvDwMNaoeVG62T9B9ILnw6gGWOE5w1JhMtlGXzE4EeMQ8Bms0Wx2WK9bXGybXFxtcZiLnPeNFLjhcYOg7LiVfmceT2OI4YUXO/SWqC1PQ5Dpv36ZH2LYTMFU2m5a+OKFrVmgAg+LhmksZgw7QNrPEbEVFPGWsY9dBVCWtouexRCRTwsBxvC5E3IsCZ8PRr1mk3fk/O9V8zm+HiGIlNSK3ZMXa8RY06r1VrEmNTHEYIzV2UJwKYBiEmIOqlPkNypzvcpqDce1MsOyV2nSzyfzydtZSfrwKa0WVq+wyCBNk6axrE4SZnBAWXFJiFmrIUJIfejFM62JJPkAlVFAZOsUcIKXJhN00giES0aZTkbk4K6YWrIwHNy0giJ0NKm5b5YLDJezr6eVBjWCuVSgjCTJUAlQYpXXdeIMeZnIX2N0Al58LwPIHHxYxT32gAm2uRepyqLlsHVgN12hzfffBNFURzEApwr8vlYfEkaL0zuIdfSLGHaPPq+R5d6X7btFpvNJgl+UX7EwMehz2sTeYMxtJesJLWmD7ZIirmEMFlJx9ZYjB6b9RW6/YD/+B//A/wY8Vf/6s/AGocQJVnLOYvFYoaGTBJXSGnjYFIykVyXa6UqpW6Hc5KIZKzF6dkZVienGJ70YoQc3bc+IlKpU2OBaPD6a6/hs5/9ElzZZDw4xhFI/SWtSX0VqwLRGPRjeMqSPOY7G2OmMT0kkSSsOcCnssLbrUCi8/kcdd1gPltmj4PZvxTUVNSap60tZC10j7FmnZXKW71eAMeD8+WbV/vtGP6Yrst+AFOdIZ5X6giFg/vU148cN5CvoeCnJPemZ4p5ff6xF5lCsm5ZZ2Dsh2sHxhpJYReepM8bkHn8Mcacpk3hUtf1QUU7MjN0oI8BHvKk27bNC4IWNeEArfXats0Cj4E4ClkdbKSVTCWkg4MT13eyEIdhgIXJmWT8Lq89DAOKqszXojXMtHRNRQMOO5JrvFEmdoKQNFOFBY2Oa6fo+2CAlIuTLi/56X3f50AaYaEi0Q6BVP6SrIMU0ec9a2ZO3lxxSs9HjAjJo+j7PlcybJRg1gHgLqcyI290YIKKuLBjKvjEOeT1x8Rvf6+DdZynJT1hlK5wCKmkJptKaMHtg4cLFkMfUNfAdrvBV7/6+/j5n4/40R/987h56xZmsxrL5QyLxQxl6aaa5Wljc+3oPCEd12maBtZZnJ2d4fzGOS6vHkvp4vfBuDNjMAr75K033sB2u0FRzdDtWxSFRYgeMfpcm17uJSBaxhaQ7+FwvJ6mqGlBOhkbhByAYfDwvsV+L0luZXGRhayGETRUps+nDZhj7Fl/5vr5PfzegQLKr+c/8jNzPxzLMv2M+l6BwxpA2ni9Lsiov589liOBz3Xyxy64I6ai/j4EYZaEiQ+bB9RIZlzf92iSMGCQabvdZgvWGHMgUPgQDKKxPjNZEmQ+AMivccDrulZW2JT+Ts40Gw1QcJAaxGJUWnhQGHLSeM7ZbJYtxMkjCMCRICTlryxLlFUNHyaqHhcwrWxtRVDTczzIpeZ48bmOlQBhED1+B5UbzVRfhBb/crnMljitbApC6yzKqkKRGkaUVYVxs86LninYnFcqIt4rF+rhxgbatsVqtcLp6Snats0VDMm0Oa6TznunZSpKixZZOBgLAMnbmqzuLBuNZB++H3bIMXYGGBHhMW3Q/AxBYDUp5dpiGITWiq8ZvPnm6/jil74XP/GX/zJOT1eomyrXZgYMBrr845jiBZNAcslb5Fw4K7kJy+VSYgppfTBdXN9Xvn9EmBgBI1j8O2+9hbOzW0IYSCyNEDxMsrqFjunZ4ia7+8fPfN21joUpIRAt5CVulRqAtJ2CGJ5mSdFIIbzB15l2r9lSek0dry9ixJq9ciy45R5EcY6EAPM9H2LTh1b609a7Pq4T+Mfv67jXdYKbf/9nsLgnk1+Ei0vptVNiC4NmdI9D8NKaJ1mw3Iis4zCfz/Ho0aP8fVreFOq00nSCSSbnu+m84zhmDJuBJgosWupcFMJOMDkoR03JDD2yM7quw+np6YEQ5M9iscidy8l3XSwW2cInjrxPnedZL4QeA70Mwh4AsF6vD4KMy+UyL6q6rrOVDkxMFi4Kaawwy1UPCXfoolRc6BSMHDcAuYN8URQoYoF+lMBkmYoFOecwdB0Am1gkgiMTqqnrKRVfH1wrzCp1zmG32+HRo0cHiUdaiV1nnfV9j/V6jb7vJPPP2ewdsIzBbDbDOPQHcImBSXGFZMn5Q6obz18URQq8HlpZwCHuOykVj74PuHgyIMaA7fYKj//tI+z2W/zcz/0cTk5XqOsSMQffp0SjMdUuyaVOVXG0GCVoXxQFmrrBYrnExZPuQHC+x84kqQ5D3+GN11/Dxz7+KdTNDOPQIcZeBGn0MAiwLj1/iICJuawxn/dwzz+dHHLw2chiXWTMqHoccVoHmhKo50BbtlqIaQNPrwntqb7XHL0XtTG/hpg49BMTLSeCHSks7Rkcr+3jcdLvvZ/3wmtpS11f/8Mcz5SAo4MBFI5603k/onBS9Sv4AFdVktKeOo9zg0/Mh8lip8UHTBYzS6HyOlzkFNoUwORPd50InPl8nul/1lpcXl7mxBUqAyqCCSubNDbvQ7eiopLgAHddh7qscsswLkzCNbvdDtFIOjOVgq7TrBkTxgjFDUC2QLUlMJ/PDyaVTBR6KlRYTDzivfJaVFzHm4ILnAKeipPfGYZBgrUpAg+ozaotvuTmk5rHmsJaAYcQ8ODBAzx8+PBgXrWHQxogFzeA3FNTW/V8PvKH6dEVZQmzP4z0O2thi0KEZwRKlezEJJ75fI6yKnH1ZKqoqF1y/pZaNmkzQLzQy4snuLq6QDOb4dd+/Zex3a3xP/7t/xlf/ML3oSikeuY4jImuJgE3bYGVZZmKMdkcjDPGYHWywr1797C+uoAf3j84aeKUsm4M8Pabb6Dv9lIXp47ohgEBHs4AE1ou/SiR2GBaYOm1pq1hLRD5Htk3lDfTvw/hj+NDC1SOsZYt7CxEw+cYqtCQBPeuvo628vU1YxQ4b/Qjijjte52xrO9HQ3f6PMdQSIwT80YrEv1dKgL9THwODR1+mOOZEnAofAAgjj4LGY0XV3WNspLeaty4XddhsVjkDUcBxpZaWhtqrcTfpFRxkCigNDSSHygJBd0UgUKR0Ie2XnXii4ZMyLwg1svzcMBPT0/RJ8uW8AiLKsUobA4fI4ZxyF3lvfc5Q5RQh74vPi/HUwvh2WyWIQUd1Oz7HqvVCtbaHAyk0jqGVLQy5HWdm/jzHDcLYEguqkljOvR9YpWwwNBkPfG8VSUJKT6zW0RB379/PxcuOjk5OaSbKcuIz06lutvt0LZTxyUR2ofQXL5usrD1JrHOAcZgHMbEJChy/ISKihtsNpshDEtcXV0ixpi9Ru2pIFmWNGCMEeFtbIS1QN/v8dpr38WXf/M38JnPfA5FUWZFn+/fiFVqjLCSsuJCCo6mJKSbN2+iqhzeevN1PH70EO8tuQW3NonK6KzBZrPGZn2FGzfuJPpd4m9bsbJlnJLgthYxTEHB98OPjy3R6Zh6Qx7CLBGZMpqOYxjmWLhrz5ZrXXtf+Yr2EDq6zsrV9z29lzzVIFa3rmTJ++PB9Uhj4YMObfwdr3Ee2tK+7n3uxQ86njk4Cc+o6iRgnbVp4Rg0dSUMACddmmOMWKTehIQJyH2mMKLbSLxsnxgE1L6A4NG0kGmtUUuRHjebzXIAj9Ys3Wk9gcdYVdu2uba4XiD8t7Y0CFPI4ANNapzbJdx89CNmsznY8LQoi6zRdYo8YRzeL4ONumGutRbBe/SdQERVWcIaIwuOnkBqWDFrGvRdl+mSDCLSeqHFxOAuXUQGT+m15PZKw4B5SqTo+l6ghBhgExH22OLmggWQlaawduR47vnnsUxNU3e7HeqmQZfqo7Ps7n6/R5fiEbp5hE3ULlc4OGtwdnaa4xOr1SobEDZhyjDIzRgW8zlcUeD27TtYJM/l8uISfd9h9FKPw48eV5eXcHYqfVuWZV63nC+hiIngFjaNkT6SyWsqrEW73eLLv/Eb+O//u7+Gpp6LQEgElxhjqpI4cYNd8hR88Njuthj9iGY2Q91UmM3nuPPcC7h4cgHE64KC3JnI4UsLoNu3ePvNN/Hiix9FDKNQANNeHL2HjRbGekmNdxYI/kBw6/Nbaw+yY4EUsD4KrvN59Gva678OijneX/R2NSlBW776mRk/mDygQ7xbWBtPM1IEKkn5Dgqu08pD73d9f/r+tUVPY5LykNfi54+9ixgFEjOpeNYwDpASIpO3/0HHM5V1dc4BQ2oZNo7SICFGOGtQFaJ1n7t1Q5gKzSJVJZsCSTHGjFnTNSYTom3bHEwkLqoHVbsWpK9pbJ2CXFti1HzU2hRQejPSuqYQJY5OQc6B54DSSg4hoGrkO7AGRS2Cz5Wl1AHxHsPQH3Cm9Tk1BZDPQgu5rmv0XYeQXOemMYijx5goRqVzErSCwXw5E0U1epydnErp26pGMJMnwvuny0tIgspSKxQA6NsWxns4RMCPKAxgkaiPRqAHPe5amQV5QLHSvc+1TGAMqqaRQFOy0McgjZ+HYcgBy77rcj9Ka23qV2qkQH9d4Wy1hElsDHac4fhKwEkyAU9OTrFaSWGktm3RlA43z0+xXm+wKwxeeP5FxAi8++4D3L//AIB4SXWao/l8nudjonnWOTitN6qUrhXYpS4r3L5xA6vlHD6MKYHFox8HjMHDsztSjICVzRoR0XY77PYb2MKhdkvUVYUQPF79xOfxR9/4Nsy4O9j8+uArIQgDxceI737nj/ADP/j9CCNgxg4OkpBDoWVihINU3nsvSEC8gsOgM5AaHTupORPi03jv9H2A7fc0nKGfQa9L7XkdW+JaaU17lxmpgqczE1Wwa0moOrZw6QGMfsToJ3nB+yJywHvKz5sMG8oBvea1nNA4OZEFenhAgkIM0/wTuyem2jE+wpj/DK3LDiYoysNL9qFD8CPu3LmNEALOzs7yYFMTaxdVC2Bgqi5IQU73np/lZtEwii4apQeZgpcHA34cRN0+TFfdo4VHYcTXNeVtqjcxKQ9OGt+nZU0FMfGup8ALKXhUNGz+wBjAbrcDYpS0puSF6LHRz6ZhD2ulrjaALCB0Ki5jALSqOQ4a1854e9vCGKld4qxFVUqMgP3xfJjG5Bh/pAVSlmVq4mvw6NGjg9RvelXjOEr97u1W1otj4wqTuyc1TYPVaoX5fIboRwASZCZvn3BKCCEDCvP5HHfv3s3BaACpM1LK6k1xCPE6ptKyuvIjDQOyG7SnQjiL66Msy9zs45133sG3vv1tfOzVTyGk+T6GDBCnOBFL6foxoCrrXBYhhIBXX/0ETk/Pcflwp3jZ1wWwTC5PYI3Bu+/eR9+10gJvHCBp64eCkAJJ86o15JAhKRx6otxLRWEwerHipYSs9IwNceKGl84eCDO9RjREep1lex1GPTGsPMMuT1m1k4IxB9c4XqPGPt0lh/uN59RG3PH9A4cVFScDTzLJtQKQ90Py2BjIldwIA4D8+A+bLftMzYKNsbBWuoXYOAncECIWTY3lconZbJYXMxc+F6fmaXNj0MqlhU1IhIKKg6MLxejAIgU+B0hbgMf1F7gotYVGAcMgIydP35MxExapGSK8x/1+nwOeDILqIKeGInICjxLmvF+66N6nWjA45IbyeloJUHHR47DWiucyDrkZBAUSMXpSI3UCRNtKYpWmM46Eq5xD09Swg0Xb7g/cYb3R+dw68MYu91dXV3DO4fT0NM/Z1dUV9vt9VoD2yEsivZJBSJ4TkNKxTdPg4cOHB9z0CBFcuob6bCYdabjWpGbzBm3bZtoln1sHqcZxzM07CJNRSHNOtdfUNA3GccDDhw/xh1/9Kl568VUUZYXlYoFuHOF32wMIgmwbGUfZR0VRJuiwSu8ZCVI+fvs9Ldtj/NuHEbt2g7ffeQsfX34szc8hHY9KiPGSYxyWv7VQo9LNzUsAjEFKAvCZQowYvaK59ZPXx3MeCz99X9fBQXpNTFbuIaVSszLkeQU+4ZrUssMAUpq3NFn50uPVxiLvkfJHX0PLteuexZgA7wdYS7mRKh0CQGpxKF7lFC6O8cOK7Wetx82EgTjVrzBGUp6XyYrJfGCFd1G4aEGuJ2qiD0oXFQo24t/sekM8WE8sB342m+XrcuHlTjdKi9O65T1QcGhhqDMStRVNC4/8ct4XFRCfrSzLqSFxmmjdWOFYodCD0OewTgoJ8L75GQ1R6IVOy5cLolD1JShgKNz5OpXNbrc7KBHLwCdhgABg2E2L2iAAdlKqvJecyZrG3DknWHYK/O73+wyd7RPWzmJgHDcKsmMvS8bN5mp7nFPOBemIWtGt1+tMM+37PiuK63BE7YZzQ7J3KYADxcE51Os6Jr6+gcNsPsPv/M7v4M/9ub+AoqrzHolRsQbUtUII6DopjuScCO2mmWGxWMD7gJc/+lF8/Q/+fbIyr6+yl54i/RUR4ojXXv82PvnJV1GURW5Bxx9ds+f4OAg852Cb4NqpmgAGPwpEoSxL770I7hx/MfCIT+13fp6vE3riOtfwhg5E831+hsexApqUTcxGEX/KshTYrq4QUkyDwW1CiMfn170CtKWt16m23I0R2Kpp6hygZju3EENq4zZVUdRjw16zH3Q8M4/bey8aNglNWsJ3bt/BOA4ZBuDi1kKRrhkFFPFiDTscTxaFyHE6rNa+ZGBQ+GkMkufgJtTwDQedApY/mlurqX5a6FF4aAoQv6cxbdbg0AKF2l1r+uOodvBBkl8SzsqD5+C9a1eTi5TKiB4EFSoX/nw+PxDUmiqoC3zNZjNgD9RVBVskrC4+wX4/IsbDrDMKMK2gSQEFphKpu+1WLPi6xlnqgkMBQoXK3yGETPeTNHkHpzINx3F8qlg+YswwhIaSHj16JIHIpGi0V0brF0BuKM35YxVJnodKkOuSir0oCwz9AGtl3X/nO9/B1XqN2WKVLCkWsJINbNV60VRHdn8/PT3DYrHAdrPFSy+9jNmswXo9YaUaRogxHshu48TifOedN9H1O5ROBRrVM+e6MEeBNu6PcRxTQNrBGWVsRF0s62nIQKf2c71quIJ7SzMo9Oe4LvmdYwbJJEAn6IQyh7JG5nnyAqeYlwOSHOuHiZrMNcp1Q1mjZYGO1em4Ge+RSt37AUXpclG8wjq4Qthkfd9LxdKqknK+2VOUCpvjNUbFdcczsUqKopAek9bm8p/jOOLG+a2U6VQfaHDNNACmnoeEDbKLbKXmMl1OCittKR5PrLYc+Js4Mc/NBUrrQlvjGibQG5Ubm5ANJ4SKg4kkXOiEVDTerhkj2iKm5UnlduwO6lR4vXj53Fo48zW9yLgwgAlvpyCix8DnJAwATAJY82WNMShK8WSMc+hHgTaqskLXBRUQO2znpnFI3jst+20S2jFZTfv9PkM4rCZIITxPJWJpJTEd3JppLAh70DM7dsEJX+x2u1xJkPNLSx9AVjBN06CqKrz77ru5Aw8pl/qcnE+OcQgB4zBmYb7ZbjH4iD/86ldxfuMWIpBps+IRYeq/yPVtpPGvtQ7WWJysTnDjxg1cXV7h9q3buHfvI/jGN77+3nAJJ8TQG/W4f/9tXFw+wY2TOSjktGVLocOxu064Rkwp/zLXh9Z+CAAs+6uaDKHEZJnDCPVOe73AYXCPrKpjuCE/mrq3wzk+zHTU3xWPaMo9mKXu8SYByuM4IiBkK1tb5PQAeQ/b7fbg/qkINJxCOG8cR4xe8HXnbKar0sjdbrdA02C5WKCuG/hxxDAOAIzUdVLP/X7HM7FKjJEu6GMvxaNi7POgiKWGLDgpLDX+RFedQtqPYy64o7Ulg2d6EWlcTgcOtQXKjUjhr4NwFJSsSa21Jq0MfW5SF7lgeD5CO8AUbQYmGhktFQacNCxCq1svWp6Xi4LCU3sMGuZgKj/Pq70X7V7CSICO3gjhGgrxY3dVW/yZkpggGwC5cltZVXBuyMW1JkxRDv2sejNRQPtxhKkqnN+4kRU2g7Le+wyVEasHkLNfvR8zQ4VK6SDpIQgbpSxLzOfzvK622+1BfIPjLN+dkpCopIk9e++x2WwOPCtaZMxU5TPnIGQw6IcRRVnj13/91/EDP/inpMfnOGL0I2JK+vEJiqEntNvtMAwjrJV7Iu/97OwMF8sVXnzxRfzRH31D4c6aa3cIlbAc7W63wZtvvoYbp98j8KbybLQhw/nWXmc2lgykWFpEromt51VC6IJtGyPxBRZhjCm93kBX1jsM7PE+qBC1cuF6Pr4vjrnem9qLmlhaU8Ymk3nKURpgW2tzLX+Nc1N+6BiEtVYFwH1y6qY6SwAOPDjnapSVzcKcsnE2a6R2uyswS0YCjVXE1K+0+HBdcJ6pHrcPI4rCwRopMjX6ASF6NHWFuqkxJoGgk0x2ux2cdamhQkRT1vD9mIIEFn4YYEojHdOtg3EmkeMTO6OuEAFU1dRxxhiLxWIpfOC6yULWuSLV3WgQQovtdif3lWl2FUYvZSUBg2HoUbipEBAXNReOpigxYMcFZK3FqPjRhXUorMsdsNt9KyVvjbRoa3cpFT5Z7+Pocx1kTp5e2D5M3e1dmKCf0pWpGw1yqrJxFj6K8KiaGn70YBu5uqowqxv0Qy/jOorAC/GQxUNPIgTpaO8Kh27o4YJQP70PKJzDOHhUVQk72hwMzILbTAwEegxaKWRcGAHLk4VYvYUow3a3hR+nLFUtkLmZQgiwVQEYg30/YLtr0Q09Ri8bygepVFg1NZr5DN2+w3a3xb4XfnuMAIzL+HKAAUJAYUp4hT83TYPLy0ssFovMoODBILXGysV76AT3j4BBwNXlGt/4+tfx5NFD3Lp9G2VZIBog+Mn11op36HXeQkRVliiLAmenJ5ivTvD8Rz+B+cl/xNWTR0AigwJItWMSizvBRIWdGCZvvvYGPv+ZzwDGYhhHWDu1LIspIBoS4yUGyShETEFgKl8fk3Wq8fCEXSMi+pDgKQMj/MAcnxk5nyYxhRKbIoQAH6Y6RhwLjVFrI+jYOCBPW7/unHgsEy14KoSmyQ3GGMxnM9jkmVM4ixeSvP2ylIJ5hYU1FayJGP2Q2i5Oa5lrs2lqlFUlz2cipCsYPZGI0jnM5zNp6YaAJuWdGEiNe66tspgS/t7veCaMm4072XLM+wFVVWC+mIHlMGk1EbooyxLRSz0E0oSqKiXEBNZJgPBBxxFxYNZbSrNORffLssJ2t0t4Z4Fdu8cwelytNzLpfY+ilNrfV+sNDMQ9HRO3dbvb5U4vMMg1VPpxQJkWUmFKBEjh+MJKcoRVWBdd+4xxDiNKJwtvJBSRlA47y1gjgR1rDIL32G22iclSoEzFsYDJsqYi0BhfiDG3hHNlAR8D/Dil57MbjEkYWYgBhbHo+qRYCoMmKb5xHLFarrBtd9hutwdVG/u+l9okRjZchHQdYkzDWamR3jQLXF5eYdN1UqfbSp3jGFLMAFPQTVtaRVEI/uqAfuyxWM4x9D3a3Q77/Q591yIk+h2V6WKxmOhYiBiShdh2HfpENfTRiwufrL2bt25hvlhg17Zo93sksBMIyVpLkPA4JqoWLIyl9R1ygSO678elFmKMOd8gf6asRZRGqeFcFAUevvsA3/7WN3Hr1s08x9wnDKgzQDX0nbANYFA4i/m8AeCxWMxwevMGbj73Em7cvYfHTx6hQMDUh1KeG5GosvxyzsFZi0fvviv1c1KP0dxaEMhek7Zkpa+okZo0mq0ScZCZGuNU44REBaQ5RxSqHYWzCRHeHgaOfVpfE1VuYp3Qc9Vwjr6uhkz0OZ2bMlvltcN62/K9qUrfrGryvFCuhRBSL02LspSMYe9HeN9LrfVKLOXCSklhKXgmxgy9vH3XSYaqMZg382yEzGYzMPPXOemZK5x4URyFK1CUf+yZk4BzBULoMAw95rVUoVutVtk94UIOMUrNksTJ7ccezhaANZIlN8gE9OMgHPAYcscVAAfuWDEIjnmxvsLl1SUW8wVC8NjthJXQdVJ/mpPOuhiZpRGnQJcONBSldCkpHLPrHMoYMQYPM46ANeh2WxRmai9G113XJ4FNrmFyKZ2xEokvCngv7ZNggKIqM3TiyiK1Y5uSe+giEuPNfQEjkgAVy6AfejhXwDppEFA6Gb/BjyiJu0XA22TtFDLuIkRF8I+jMEfOzs7ys+RaCWms6kQdZGEsbrCiiOgUdzwmK082lVhtxk0RfsI4zI4t6xJ96HFx8QS77RaL2Tz1B2zRdx2qusluZ9M0B0LcWodu7LHd7YQ3nAJQvL6BlBSumwbr9ToHFfPGRYQ1UjOba4xCYgpoT4EsVo6kcD47O0NZlpmtAmCCa2yAcyXKqpT63H5AUSzw5S9/GZ/5zGewvHET/WaTrUqjYLO+36FNxdWovDPTpioFMjk9xd27d/GdbxSIY/++UGiMMSfOXFxc4PHjx7h5+9ZTHqSmt2koKLvvR+fkby1k9fv84Xhq6/m6mI00jj5MbdfwiYbv9H0DU4ckHRPS8Rkdy+LneK0YI9p9i2pOYXqYyFcmb0csdocQHJqmQt2kYGPhUl/PQ642rfCmqfPrFfuNQixqoatOc68xdXofH+Z4Now7DUpZVejTRpfaHFKHl5NhEVEUghE+ubiALQoMfp+SMSbBTKFhnMN+34LFxbtun9yMgL7r4BN8EaJYsbrdFzmkFCA5iJACqNLdK2Y3ntlj3Dh1WeLxZZHbbZVlicKPKIYCTerJaNJzUjmRqz4MA6xz2Kd09dF7UUwxYBz8gfUQgqRuhyg8eJ1aTatB05CGYcjNITIGTxwtddZxTiAoay1mjU2QQZDqeTGibmTRsEmzKwpUdQ2YXgRMwvHGccSTJ09kwccAZ1x+Vk3ROy7La6ZFkcfcqFIIwNPBy3EcEZNrz6JUm6s1hq7H6uQEIU6de2iR8nyj92i7VuYZ4g2wUBQAwNmU9i7XYsIRD5ZGBSalw03e7feonFhCfGb2BqV1zNiHDoiRtloWDlVhYSEFo5yTjk/f+MbXD+I4vFWdkTiO0siXQo5rIi1sVGWFVcK7rbMI3oJQyXsdUwB3wP0H93Hj1s0DvPj6YN/hdzlOB5j30Wf5t/7RiWlauOnrM0jbDROMxjm5zsrW16Fi0MQHxm4oQPVeouWe7xER4zAidhMVlwFwVhmlN1LXEvyvqgJNU6U2hBIk1zCN3itF4TD6KStbQ68y97I+NMnBpjVT/vFb3ImDaAycdejDkBfuMAo+HaN08S6KApuLK4QQsNms0fYdrJt4vFrji1WcWBEpuOSKIvfHK6saddNI0CM9YJWoeDZ9dhikxZZ1h+m1MUaMQfBPk4Qnk1J4H13fI6aa3dycBoArCiyaGYpocvpz0zSYzWbYbgXu2Hd7zGZzbLapFniUContfo+qLFOwKSU/mCkxpCyr7OgyUEu2CYVWP/TwAEyc8P6y73M0exgDFvMFypIdg0Li+Tq5rkmMkxjQs9WaE+HufcAsJeBwHHheoUtNiStkVTC4aG2Prt/loEs3COYXkmNtrYWzE71TW3AxRkQb4SrxJvpuwG4jbeRu3b6NqixxcSnQEZkmxMllLW3Qe0lMiilQNA6p36S1iCHi9OwMRVGgbdvJuk0CJMRDQUSrcL1e57o5VVVm6AkQSINwDb25Y/qYMYCzEYumgHMFqmaGzbbFrt3inftv4+377+Dl5Qom1ZV5ylyOrK0hOLEOXjMYenp6isVigbquseu2B6fQ5+Tz5sAxgAf3H+BTn/50xly1sNKB+mOlpoUsrUMytjQX/ljoa6Wmg576cwLXRFjgwNqnAaMFnfYKjj0DPZ/Hgl1b6jowLef08P2QczaYC0D2lQFyfkldVyjLAlVdJAZSBaOuo++vLMsEd5DwUMAREkkGEKJ4y3xWKhwGOj/M8YwJOMS4JmrMMAy4vLqENVJoab/fo03JJ6zwJgXlBAsrlDURQkBZFFjMFihTCy262KRmGUh/SZoqbLVFoVOWZa5HURQFRu8zlr3f7+Gjz4WexmGQIFLCtLuuQ0xZXl3XwVmHfSuJMvt2j93VBrOywnq9PqAANanmRogRRVlk5oFw3H12hay1OVtRB2zZCXveCEWJ1fxIGey6DtEaqW8xjmjbvXzG5Pw3xGhRlhWKtCBi+n6MUpO5sOLSUYBqt9NAMsfI9R7HEXfu3JEMQe9RFhWsk+qNy+Uyz4kINAY0E44anPT5DCKUObdcK/oHkBKnve/h0hixOBjpUmVVwvuQO+WUZYnHjx/j6upKgo9ILeCipBVrGNYV7kDZZOGVrm+dFPbRKcwTPNVjPfYoCpd58PSWeG/arddUsKaZ4faNJe7dvYXzm7fw3e++Ae8rDKNAaL/9O7+Fl1/9mJwrCQVee4pn0IKeBFaMMQdSyxTYns1m2F09tTGTU/k0fhIR8fY7b+dsWWCqBU5Bpi1qbW3rfX8dK+S9Dr2/+ft4LvisxhwykHRg8vh1/d1jJcA1muG7a86hvx+SoWiMeQpedc5hlthO9Lxmsxomee8yF1Nij4a2yEzKfU4hsSF+Ru6d4szAGCleJvDvHn3f4eWX33d4ZQ4/+CM8ZKN4P9UCGYYBb7/9NiCBZPQpmuu9NHuVPoMORWkT/aUUiyQVDPKjz0G6ru9hrZH+e8nimM/niN6j27Vo6gZ1I70K212LoixRlpJYY6LByWKJrutSZT6Lq73g8PPFHO1+B2OoHX3uBl8WZXJziykrsu8wa6QMrLOSvcg6JlwYFK6jT0WDjNTwyK6ksuYDJJV7l7BrYwx26frnJ6dZ+WkPJIQAUzisd9uJ+YGYS36K4gFiP6CHsCsm1zIFWq1wb621KeIvnW3Y/ZtBVQrNYx60uIfVQQGqXQoOA4eKgPW3nXMpCHtIvTvYbGnPFkUhPUwTU4EMGsHeV3kdbbdbvPvuu5LIFAJs6eBDQCAun4RbjBHLxRInJycHngTvMW2T7NLy/BQuERCDwyCvD9IQGXfQRYOASeAURYHLiyc4X1T4S3/xz+N7v/f78L/9v/93DN5gXjf42te+lpgcUuclQmp7k+s/Jpoj71PTFPkMNGoW8wWuyiLVH/ngw8Dg8uISm80Gy+Uyr2GNpWqM+Nh65g8VvBbs2toEcLBH8nwfnYvzYUxqQmxw8FkKW37m2Bs4Pjj+/J6G5rQy4nmsJVxhcuehvAbilEcypucdBhoAHs1MitGVVQWnygsTYmXRNqnDLn13QxAuvMhIUbD7bo/9vs1ypG1btG0rRm/b4otf/FMfOK/PGJxMboybUqKl44x0MhcLQjDg+WyG1eoEdZ2swoLNNSEMBedQpKCVrYR9UVYlYoi5RVhpHfZ9jzCM2HRX8IO4s5vNBufn53DO5c4x1kqCx/mNG5mrvZjPsdtssN1Kj8uiLPH40SP4EHB+fo6+3ePy4hKnJycITY3tRoj283qGrttjs97g7t27AJBdKDa6dc5hsVpi9B7r1DatqWvs2hZ1Su64Wq+fWrCFcyirCsF7DPsus28A5AzPq6sr2FKauW42m2TlmcSVZXYd8jlpLXDhO2sBDKhMJSV3rUVZFHDpvgtrcevGzWxJsoFCFiIDUCSFwsxBwftqjOMuRc8Dul7qg8cQ4NKijUC+H22RENO0zqKqK9Sl3NusmQkNjTSrssYiKeFHjx5l1g1hBGG2ROz7XmqEs9EtgFkqzMTCU5oFBIj1U2ruf/KO6rqWJIjEIuC4skmHcKxFUSyWyynXxZgUfzEwIeDRw/t49PAB/vxf+kn87/+f/y/6Qe7xrbffxuXlZWplF7Ii9d7nTYuIDOMRfgEwJa+kFwS2qbEbB/CpPqjARQgB77zzDp577rn8t4YXrsO6taWqcetJFkwZx/yMFph6ffJ8T1nyR3U69Od1EJIetlYKWjno6+nz8J64BkVwMx4j+4kGiLbOCdvKvPfY7/dYLGY4OV1KsbPZDIv5LPOwtQEk91IA0cke6cYkkHdo2z26JLR37Rb7dp9bKw7jgBgxMXQ+4HgmjDsGg8Il0vgQAAgeWrgCq/NlDiixOiCFQhhHrFbLzC4YxgH7VniwXb9HaFPSiXWoUrBsv28BP8B7qd5G0H82q3H79s0sDE5PV9kqvXHjPPWfLGGtCJ7aljhZrXKn8Lt37qAqKwnk+YBFPUNZSjfu1XyBsijR7lvMqwbuRCaSrcE0r9R7j67dIyKiMBZ1IQ0IHIxQ3LZSeW70I05WYgVeXFxgPp9J55z9VKmPxY+qqsLNmxJE6ocBt87PceP0FI8fPZbelcMIYyVom7YIYIBSpYGHGFBYwKJAVZUoqwrL5TJFyS2qqsyWJ5WG3nx918MUDqOyuAGoTFKDCA8YjxhHAAEwccoBEaQb3oeM40kda4FuqqKEiQZ9K7j7rJpjPpvDLlYAgGGQ+1mv1zkQyKOuaoxjD9/tYWJAHIV2GS3LKQi9kun13FR8NmNItfbpmaYmHmXlYNHkKoWaiSBKx8AUBdquR4xAXTfYXD1BUxrcmBc4md1AYT2+8nu/g09+/BN44e4tfPv1d+CswfryEm+//RZe+ugraTzFKyFvWDBdi5h6QpaVBQy5yhEmGlSFdJUqqgbz5Rk22y2cBRCCQJHXCO9s8caIN19/Hd/zyU9lCh5zDHDU4V1j29dZ4HmWk2KHAYpSgu4UOhGpY4+ZWtH54BF9ChAnL9D7MFEZzWEJWWtEsOqA6CHMgkxGiCFkL92muQKmOjraigedPhpU9GiU4GZPXSAIhLYe0XUt2n2LzXqLxWKB1WqFO3du4/RUmEb7bkB3tUHX9djve/TdmNhSe7T7Ft2+Qz/0GEePYWjh/YBhEA9/GAZUZSXY+AcoYR7P2LpMqpd1XScVAo3UEpYSmndQpdz8upbf87lQudZXHXbtDvsn+4ztAUKlWsznWC6W2G42aJI1O6tr3L558yD1HRAaHmt2ez9VZ2Nx/qqq0LY7eD/C2qnPZPAePlHbaKEWrsAYRzT1VG6W56urOgUABc88Pz/PSshayaIi4+HYdfal0I/c0mUrbZ5w7ubu3bw42FOSwa8YpxZiN2/ezIHcpmkwbyQzlRmA4zgiGAgUoywTyF6RSDYmOt1BjRblgu/3++ytEDpgRN3Yw/rg9Di89yi9R1k6lKVDNwjeHgPruniEkcEg6QzDQI33IQdsQwiI1uLy8gpd1x8oErrmum6KsHZGSZcfBuzbNgezU64RHr77EEVVZuuQ3lFmAFmLk5NVxsCNmVrFyfzXqM/PD7jtHJOyKGEKaYFWJmpnVVUojcdiVuPjr95DYSOutnv8+3//O6jKElVZIqSA9ZMnj/DKxz6OJtWnAJDhECClkhtJ+BAKpAGshfERzgmkNI4eVdlgvliJOx6kb6Kc49DK1QLOWot3H7yL9XqNk5MTEZrjiNS2WASVEtzvdWirOQfkShHENsGl2eLNFF0vzSLsVF7YJCaSgYFTFvSxpc7ApQ508tr6nnSQ8PgZjoOsTDayNvVPVTEZ/pZrTbx470e0rQjizVq895OTEwzDiCdPLnP5iLYl/DFgHCcOOn+mgK6Hsbwv4YBLxzDkZJwPOj58WVeT2oKtN1PAxg6YzWZ46aWXUDdFjlazpjSj4iYC8JItVKuSrvWdO+ICw+AsdV9nLWtGenVWEzMXGYB6moMrA8+SpccYFxeHnkjWDyG+rFukrVZLDOk6Z2dn2G63WbBQgegKcsDUeoiuNoOkxMB0xUKtxIihTpzlKWpOrJWp7sMwoKhKbHe7jMVZa9GnczR1jW2apxBCvj4wpfNSWPM9Bnp9CIh+zBYrlSQx1lXyXkCs1BWw0tMMIaQMNUzULu0+y9gL9zpbN97j6urqoIwBn1cHeyRLc2Ij9X2fcWEGOdlol89CJgzHkKVgqegPWtzFiSVAXFtTGl1RwJUlhpRpt9+3iD6gcMDVtsXLH/skHj+8j3Zc4/U338bVZgdbFNjvO8zrGq+99hr+xA/+KUlUihMDQeOvVHB1VqYWqawfri6vMI4eTTPDarnCYrHEdn0Ja12ujf5eB5X05eXlQa184q+E4Ka9fr0w1es1W8YwsCkdKP9OnpbUY7Ep+S4CQTIw6fEVlUNppxrzGlak0OEa1nRBfhZ4GuLgoYX7wXfSR6yxgHNPfecYS9c4P2UHK0eu1+u8fmhopRsHcNiPV84FWGtgTMxxIZ3voPH2Dzo+tOCOEDdWrA/BAmnNdF2HGIa82ZfLJRYzSVapqkqEMgOCKQhojEFTNxgSVY1WDwH+UVnIdMtWq1WGFagZ+dC6IiGVBydVB9h0JUGZEHk+slU4mEVRoOslndo5J7hzEiK5IlzCiGkpk8KmKyICOjNr6qjC6oJUGnoB8nya16vrcjRNI9aZdShnUzeakjxWazGbzzL+q6l5xOFoDVARZLc4DYh+jTQ0Qhjee8nchElB5wab3Q7tvkvUtENaGJ9flJpYMjpjrigKadZQ11nAEu4AdN13j6Hb5+bLHFuAwTtZO7zf559/HjFGtG2LW7duIYSQKyPOZrMMx6QToR8GzNzUYFkLqjLduygygYGMK+ExYtt2+P2vfB03zk/x5v13sW17jNFin6yvsh7w1a9+FQ8fPsTc8bzC2Q3Bp7rnJkMLTDoCRBn6EBObp8B8vkDXbrBYrLBZX0L6PU788OsOrsUHDx7g5ZdfPoAfvPcTD9+YAyGlf94bNjmkEWoLWOIxAdEmQRVjtsRJG9XX1PPJOdE4NQ9NAjg2xN7rGfI9T4QW5QHosqqsKsif6RxaQbBg1PH4yHrhfj8sYS2/gRi9wEnAwfvHY/x+xzMFJ1kURwSLNCgdxxGFKzCrK9w8P8/CoChL7FPG3dgPUscDRmhgqVg8ohSvOdaeFLbHrhHTjLmpaIUTquBr263gUEw8AXAg3IGp+PrxQrNWMuW0i6aTaI4td1rWDGDxnjSdjPdGa1dbDroOAzvEk0bI+6DQ1gunqRsYpAYVM+nmspwvMsWPAUzdGECPJe+HvFxtGWscn++zpoMxBiZGNIkmFaKBdcJfjuES+66ToJNajE8nGshYUvmVpfR3vH37dlZoDx8+zJAJCwHt93t07W7a6GouyrKUbFNjcHJygueeey4rXMYnKBBJhWuaBm+++ebkcbgpE4/3zWuFIAlUdVXDukISr9otLByq2uH3vvJ1VGWJR0+eoJ4tcHJ6jgjJfISNeO2172Kz2aBarJLHIVYZlZIxU/JSlQpPjcNUyni93qKqGgkW7+Y4PTnFw3fvA0HqYh9bivrgnL777rt5LCnsrLEwxcR55trgOuffXMeEJEJIdUasQB4xStawTRCICQlqiDEzYJw9pPo5M1UH5Ln19a1aM9ozoQEWk/VLz4lygc98zE5hMad0kWzl6meV79oktOPButXjefw9bZFP+23qBETihlCGp2blWj5xvX2Y48Nb3FGyiPbBSlNaKy7S3bt3cfPmTTSVzR3GQ5CMRwqhonAoXJE3ISvc0R3Vk6EfaBikQ7pO3DHG5FKqhFN0Rb08qUnosjkuX6Ow0M+VAyhJSPEaEcLD1ZNGOCVbuUlxUChwU9BL0DQ7XoMCkJawdE6ZovYUvpqbSoXQJ0+nSzzybLG6KdtRl+nUVq9OSNFjzAxD8tCjugd6MBJZX0gDYSBVx+tQVjViFLZMURQwXZ+f/9iNFY+qAJu4amtps5GaM7du3cJ+vz9QhCK41mjbnQgKbrJk0ZWpJOvJ6SnG4HMs4uLiAuM4YrlcZi9su91iNpthtVod3GdRFPD9dL2pUJHJNEdngNmsxuXVFkVVo6xn6HcboItwpsRu06Ool6iaOQapWiVFipxFP/S4vLzE+XwJJEhBvIohpe5P2XUMlFE49F2Ptt2jqWfw8yV2zRpn5zcwa+a4unySmRIyJO8twB8/fozdTlhBHH/rbKbFcQ3o8+R7clOhLV0GlRmf+TNHlnMIU9IbjNjbLo0339d7UV8X1zwL76eqKvgkSzQvnfem96w2tvJ5rH1KUB7i5ePBNY89Ar2m+fdk9UuA1lik8ZBM3xAFmtLURSqP47H4oOMZg5MBwxAwjKMEFpzL9TusEc6zicmFL6VzdVVWiTfs0G53WCzmOFksJaV0FMpftFM3cgpDbuj1ep0nRmu5XCsEU+YVK/sVRZGt7ePAhdbKmi/LiSX0Q0y1TEI6BCk+M5/Psdls8jkJl3DyCIfQO9CV5Ijd0vKmsGVRLj43hYy27InBGyOlaavEww4WiD6gKau8cPthgD+ybiiQOK4HFrSCG4h7cmwJVxBSubq6AsaUGVcUuH1nAVdK1UUrGAliFGGqF6NWQMRy9fyM44j79+9jt9vl7uohSGIUO79bK7kB4xiytQ0j0BEr+Q2dbOarq6spxmKmSo/aI2KmHD9HrFsrPN5fZki4QhRbSLmirsAYPJr5DEUl/P+yKiVTeOgR/YDKVhj7EW+/9TY+87FPyDgkV5vrOHiZg6JwUwYwkCmDtCqbZobZbI7oB5yfnePq8iIJive21Ph8+/0eV1dXmM/nyiK1B5/Vykrju3xPCxcJ8iveNSaDVgvgY6tUv8bvHq+T9xVFaX50IwjtQV53Xr0WkZ79WExq/F7LGu1d833tSXOdZEPAiTfFNQxMChE47PlKg1R//8McH1pwW2tgnYMNU60R5xyWi4Vks/UDVosFDAyauk51RaRAUVPX2Ld7nKxWGMcxc6/zg6d6G4UrEKJsVmuS9eqnlFsKSkI2zIaMaqJY47uuRJgYTM0OaEFSgDRNA/gpe4oBrqquRRCZiSPNjX95eZkn2Dl3UMeZ7cm2223mRl9XX5vwS1VOjXb1BEvarATkHCTLy1jBTHkfKCRl2I9SHzj4KY3ZGGnNxBoqxKUpuHhPDATr1nCz2QxFVUqtlxjR7vfYbjZZmY2D9BstisS9LwqUVYkuJUTVdYV9PyAGnzBKEhcnRktRuDxfunmFKO8e+z1bj12JZ5GstrKqMJvP0O52YEdv6wo0sxlilHILdd3g7OwMbduirklhdCjL6qCkwLFH4L10pBdlIAky7JrO+em6HmWTCgnN5tKkYbvG2O3RDT4LL4wjCiPeow8RQz8AscB3vvMtmP/iv8g4a9/36IcBIXW9MZCu6NzEIQQM44DLqyvs9wOaZgGDiMVyBWMCbt6+hTfefB3ASEM3jfXhPyaGR8D9d97BR+7dmxJ+DBsmiPA3Rgp1UXn4tIdiDECU+eRnYIBSQXhcY4ewwyE2zD2vLU39+lOCi0pDTpbXsPc+Y9x5T0Cxq5Tw5etcc4jSYcrHCYPWn59wbvPU/Rx/XiMB2tMVFWYg9dWnR9GUR/5bYD9+4I9ZcMMYFHUFG1N3mcJJookrEMcRi9OlMBkAIETUqaqcCRFjL1aF7sBO4U/ogB1Eoo8orcOu3SGGiNl8BpeEEV12AJmFYIxBHKUi3qKZ5WQRBrDKusqLkNQvBuiMMRiCcDZ9DNgP0keyH3vUM0lrr4ryYKFlyywthl4Fafm+xt1zadt4WIku+U5wxsDHVAfZSD0Rb6QJaz96jFGCdMF7WOdQVAVmsxqlFYaGTam3TNV2VSk/TjIMGchlUFZbodT0hKhy44VxhIE0YjhZLNGfnOLRw4foEhfeADg7OcV8tYSzQFMXKIoTbLdX2O8jrAkYh04KPkW1adLapHLSPHIZtwJlVaDdb5NwFkzSOoOqKnF+4xyAxXqzQzRSU2a5OsF8eYJmNk9wXg1nS8SwR1nUGPoR3X5ACGv0/bR2ABzwxEMI8KmsqrMORVViv08ZmMbDuQIODl3bYV5VqJyBCyNmRYFdLz0ny6qY3G/vURcluj5ibHs0C4c3v/tNXDy6n4RRChD7CMSUuASprCile0eMfkA37PHw4RM4O4e1Eqhs5ktE43H7+edRfeMP0W7XONjuCjrJlngQofzg/gMgClxhjIGxQMAkcBlLkT0POGPFeGIwLUqJYRhRxEVZwNkJ9wYOMXIKba0otfUpouXQuuU5vCpWpeMkFG4hTkpVY+/6Whq6zII7PZv++9izmIRtfPr6OPQk9WuT8rFJME/PmJWkj5DgnmwIeqqFKz40XPJMwclxGGBghRNdFKhTJS1jjFRXS617tHCgFtJNYLUQY/EeY4RZslgsxH00FqaQTUTgXkeONY7skiU3dakI0wK0FkjKgZY6B1uq+6WqfFGUDQeOpUxpRVDg0rVl3RJa2nTV+JyZQ34UhCN32nuPQGUVJdruQ0h0PI++F4I+FQZx29F7lJAEnUoVCWJ1M7JpSKNkh3IuTI4150dbKBqu4Xg9evQIVVVhsVik5rUeZycn6LsetnBS93rfpgSIlHyROrAg0hKLydqIqVHqBONo13YcR7Q7ySqj4rDWom6aXOt4t20xplR3WxRYrU4wn80zjZB4OWEIWWdi9YQgGbNcp1S6ueMPcPCb8++9GAYUglzv/L5s4ICicMnSrzGOU+NnYsEPHtzHgwf389pj8D4YgLJsSt92GH2HoR+xS/W0nQVirNHMFrA2omlK3Lv3Ir7xta8g5WJNhzLzBIqRCzx58gRt2+Ls7EzWugFcjuNI13ERtvx6euq0RpPBCgYeY4gY/BQb0NgyD40FH9MJjz/H97QFrD2jw0ecLGodFNR483tdS5TW1A2JMCSDiPL96b5oiOm1oe9ZC369t65/Tp/JA9wLWlZ+mOOZgpPMvTfGIIwes6pG6Qqpc2xdhgiIw3IwGAzRUV6d0aYnZ7PZ5NKKs9ksd3vhADMYASBvHBOnSm3aIhaLbeoZqTcj260RO6Q1T75zVVW5pZZeHDyHTrohr5yCg6VUaVFSiAKYoJSqTlXEkusWD6lZVFZcnIRyQggiHIqn8ThdApbKsu/7HAjWfS4pMAmXEHcjR7ooJFv1zp07eUx4TzYCs2aGVIUhX4dBo7btnsJHYxArI/iAkBpycLMfYnzAyWoF6xxOTk4ONuQ4elxdXuVnXK1WODk5ycJOdznhfHPsJa24x3w+y8FPFv8qiiLHGXgvTdMc0E3pYnPMuL54be8FM2dZBMYoMqyYmi2//vrr6f4GgfKMEUVnhCpWpVjFMHj03YDHjy7QdwOcq1A4gxhr1H6OsrSo63O8+vFP4Vvf/AaC76/ft0AOINLrevz4Mc7Pz6exd5MyFY+jmLBXY54K0GuLmvATDRttTR+vAe4hjQ9fK2fMIc6ujbXjg+fKLBnlTWpFkO8lpU4aYzKnnvfPuZZtKF1suC7fS2kcnPtIcR0rIv4b0eQ4kg76/mdhlQBAXVZYtztEL5hjU0m7srKYMt4YxKN1S0yKgpE3y4nQAT4KwX0qKi8PHxAisvVEa4mWkrNTR3EOHrmwu90OcNPAc3Jo8fJ8unIaMwSByZXWwpGLRwdQtTsGTA1lName2DItwxgC+s7Dpc7llTEYU3ZWkQRwrqtgzIFlSj40LQV6ERwHALnOtuZw67odADIjh8/Pz3KMOVZkzFCo5/RgREiWqs3MluAP3WXeP+lvIQYgTjxxjqP3HicnJ7h56wZCkHGgp0I20sXFE6GWGamyd/PmzbxRuHYoPJfLJR4+fIjT09PsJVlr8ejRowOrr+u6PC+8VpXKBPC93W4nbbbMYcBX8HpRcJvN5Blpb5Dzv16v4WyFt99+G/H2oUUolq8BIA0+rHHo+wHjGHF5uUGIKU3cGMA4GFOgqua4dfMcn/3MF/Fbv/EruHj8QLnpSmio/Uvv8Z133sErr7wisZvCoSgL2NS0wxjB2WXPCD+ccYoYkV+XfWAQwyEr4lhQ6zXAQws7LdD09zTM8l7n1N/TMMUx/HFwbTUi170/ecqHCmiqQzJdV3v+11nYGlI9UFZGLO3rkrCOYaT3Op5JcDN13BqDqiixWi1RFSWcNXCFRdPUB1aUjuBzUDTDgcKXmw6YNnSGXWKELVwupSp9JussyGd1gz50U8AiWZ65kaufanEvFouc7Xicyaj51MCETXPz8ZnIBdccUB005aTS7dFMF2CCiqqyhIU0pbi4ukSV6I104UWRTYFUCgQ+Hxf11L16SnKhkogxZoVEIUWlSPeP96ktJy7SOiXEaI67tRaGDS9S1yIW7AlBkpDarofvJn6yUNwkXdzEaaOSBZDrtQx9Uj6HUIr3Uuel23dAyso7OTmZArEJnuLa4TjpUgLGGuz3LYpiyhFgNiqfzXufIS3+m/CTHz1sOXlzpIByzUh+wz4bA7wXWvI+eiyWNb72ta9hv5KmIVw33otxEiPSsxgEH7Fve+y2HUIECmsRDBCNgSsrVIXFydlN1M0ML730UVw+efcAd51w6kNBZYzBo0ePDqrZ2RzzOWRMaLFPJpLm9gOAx5QFqIUm/9b/Pha+x/CH/vs64Xt8Dr7P72qIhXtNXz+/lxQQPT8e3KeynyYv+wB6xWGGJe9NU4x5Pe5BfZ8xRiBKJu5xvOxZjmeiA/phwND3GIcB1XwhTTjShjXBwPvhwLXQacvajeK/NbyhhS4FY66xkQJvOokmByTi5Habo0UaQoBxUwo5cevjAZs20NQV/KDzDFkgyTqngNRJQnwuCjm60zwvFxY/M45jDnyygcNmN7m7uSBXshbpSWQOeVHmiDvrqDD7lIuI1oMe56ZpMkWR8QQtQAHk+z1WUHyGPgnsjBUnLniMU0suw0ikoRIfEQIAO9HKuAE499vNBpd1idlswuW5TqSEa4A1DquTE5ycnGTcPyjBwbXElHZmSu73e4x+gHPmAArS8BrHjTkCVP6r1Qrr9ebANdYKQuAwaZChITEGwruuQ9WI57LebNB1A0iJ5Proe12iQXoybjY77HYdrC1SmzuhIFpboaxKFEWN0ztnePXVj+P3f++3D+IV73UYYzKf++TkRKDIFLiUebMADpPStEVNL07WzQCDAI8xC1iNZWvX/1ggX2dpH1vL1z3L+71/7OVdd7wXFEGPlHMsa+Lp7jz6Prmf9T1xPXEuuLaPr8V1w/MdX+ODjmeqVWKMgR9G1FUNA6EECXYZEMKUlk6suOs6/OiP/RhCCPjNL385C1AyGGhdcnCstTnxImcsuslCIj5MOMVaK6VYFRRC4UPh6VDkFmC0Fhi800KY2pHYNwdX41vaUtOukqYoacuAv3XWY8a1Elww+lFqWiihO6QA43GUXkMyIYQME7H8KJ+B1ybuzHodxx1c6KpNG3HMwp2Kgxg9vSMqpGEYYGLqzJ32iHMOSO+b1NWbi1e6v9inFrle3D5I3RI27OXn8v2WJRZzEdp8L4SQYR56TTw3m1dofi9r6NCr0JgrvTJtcCyXSxmbYUS73Uswz070UMYNZHy6HNja7XYAZJPWdY26kaL80cu8GUw5BV3XISJkCAoAht7j6nIjRblcRRKSCG5XwLoKZTnDcnWGu3efy8lvx4Lx6X0s9Wnu378/xRBUbIBjqo0Frl+eM3teBoltcpjoxescW818/VjZauhKK8Tjzx8/k7a29TUOhZ8weI7v47px0eyTGKWMtVZa+p71GOkx0Zazpinq8WCtEn2/h57OBx/PVNZVXNoeIQbUtTTPjH5E3TQYhh6LxRL9MGAYRwREfOYLn8Pf+Fv/d/Rdi69/46t48uSJ8Ky9Qbf3yVJspFYDgF3bJq64dDYfg0cpoXR0XQ/npNb00PWZUSENGUZhYAQp9elS4Zq6qVPTXp+VCWEW3USWhaI0JswAZEipu1rYD8PEHtECnpY0YRzAJC5xB+luPwUHXVGgHz2ki33EMIyIBnClcGi9D1PQCsgZjTEG1HUDZ4SaRdiEwoiBQh04CyHktHkq1BwjSItLWxwhhMxOOc7C7PsefSpJa73DMA4IUfqEhgSj8dwa/zMGKIS+kGpzKLeZi9taDP0owThbJIgLcK7EfL4EIg6gH2NMZrrwvmkMeO+xWCxgjMmNEfbdHkVRCeNjDHCzAkUxwU59P8KYFl03YLVcwrkSy8UCV+s16maGfkjB8arIbA1XWOnq00uVNy1kNFuhbmYYhhG3Ts9RVi2MNajrCuPoU2cfWnACnez2LS7XV/AhwDk2hkvMjrQfjXXwXjjcVVljE7ZwJYUJScPCPOMfDAC/+eYbeOXVjwqUxViKSBFESM33zO6OU1ayS305hX1i0Js4GXX+6RRyYzDdD6jLp7+5hyYhSEGJ9HsKOB5bvQfSSQl4rtecQ8BgZIwHiUrHgnMiBNCwOLymvrYW8vo5+DltQB0/Yww+OcuSG2Mg3Zuc/c8UnIQRvjMQMZs3GH2POHq43sCYAn6MElwpCjSzGn/7f/rbMAVwtjjFX/jxH8Pf+7t/H0Vp4AfBMauykQdI5y1TY07fi3YrXQXvg2DBye1iVqa0GktuZYzSbT1IpTNnBcdyxVSpT0eNdWCR7hytbHoA1LrDwGJXFn0vtZQBk4R3iRB8tkxZs5qLgGVMjZHmvl0nApUQBazF2I9Sm8JaBAhPt6xqBFW1MMSEoRNTNhZwUvdFw0DE7IGJdkUBzmvSq6AlyMAkCy+R/04Ln5Z613WTsnOTK00Y1FkLP3oAQ+Jrx6R42NhW5iZ6UVTyvkArnCdCY23boSgquAIwkBZtbPRLC/o40Mq5ZYVJjaEDU82W5WIFay26bo+yqrGYr7Db7bDbCZVUGrlGXIW10MVgRci7AkVdYISHKaSeti0s2v0OXStxg9PT01wgi92CaJUPvdRSL8saQAuXFGWutAhpNFynWvHb3RZX2zW8iTBGAoGTABaWztB3uLqSzNLn7j6Hq8urSTCaSXCzG4uMk7C03nr7TYxjj7KsEPwg1M2gaHjWIsZU3tSWkMQbbXULt96aAOdsVphUnvI5Bti1AKQhJPcSc8BTwwRRrNI4wWjaQ9JWbIZE1VrQSoN72aY69oZKIwo1VePnhxj2oQA+9ia4/vV3uA75W98nX4sxAqkuDb0NObcThflesvfoeCZEnNlKdOnKSgr7RESAfSWjNA/42f/+Z3F2Ll2pu77DD//Ij+Dlj76cM+CscxiDzw2IaQWHEKS6YAos0V1ZLpeZusVyr3xoWpp07/X9AlMvRj2gxMz1wtAwhLw3ZuiF72vXiPeri1wRkhHBaTL0QGuA7jvPyQxJEWZyzxQ8tHiJ5TJwJpzhMgmgLkMc+ZxqkQM4gEF0mVzepw7EkjvN59MYHWGi+Xx+AKcAYgnXtVAcK1ZaPNpox5vOKjec46cxb2clWFS4Ak0zgzEW69RViIFBegb8PjM86TXogGXhilwatyjKTIHTHOSp5oVH8GHKfo1SZIrzyBZYZapIuFwuM/xHCI7riOsLMeJ7v/SlFBC1ad2L4JZnT7kCfS+1WXY7sfpwyMLgtcdxxOXlJXb7PV56+aMwzkGSMIWTzf/0Ifoy4urqCrvdDjFOMB/HbbJaJa9AFx0jXMbPcE0SrtNCStZ04vQDWZgfC0QK+2OYJMbDYOn7WaNU3BwjNujN8RYcJtwYcz28weP9oJ7j62qhrtf54bNM5TAYBOVaogzRUOQHHc8guMUq5dCxIHsMktruCpeF9/d9//fiz/zQn0EzaxCCh4+S4PJXf+a/RVFVKKoyt40avQfMtGm5+Sgk+HAaw9RBBAnSFAdCiZOkFxxxXm4m0tc4GbrCGAeaHVwytTCdlwFSPSmsL6IDhEUx8YBZ6Y/nE8uyBZK1T+ufC+A46MFru5SOHMJUP4UBMC4OnUVGjJLYvj4Px5IWuC6YpZtOHAoNVZPB2oN5E+GEPI6cF46BCO2jZ0m/Ccnw3BxHfX02beb8a5aDDkjyPTZj4Bxzbema6DpwSytd0zlzAAkmrRlZVzBCp2xmDW7dupXxYq10jRFmTtM0qWF1wPMvvJDuB9kr84HUO3Hl1+u1wIohZE8DySiStSGFq2KMklDTdTi9eRO37txFiCbBKsIXvs6Eo8K4f//+UzAA50YLriwBjgSnzMuk0Cm8OffH2YbHApv3cnx+jp9NnY24jvgeX9NkgKfPBXj/PmVSj57tujG67r6ASTDrNcb1rRU2/9YWvTaoeG79+Q97PIPgNiJkAdRNjbKYuoFERPRjDx9H3L57C3/rf/xbwiYwAWMY4WNAM2vwsY9/HF/63i+hG3pJMe9FmBlrMnapteA4juiS609LSgfYrLUY+okVQQGqrQEKBFqdwNTsgJgvrzcMQ+Zu8/vee+HgpsVCragzI3UnHgo+gS6qfE0uZgpsXehfUxPpcrKJqBZefM2PkyfBhbRarbIQpKJgEhGDZ1pAAZKZqO/DGJNZJ1pAs7iW/u6xkOV8UNiVZYl79+7h3r17mM9m2aqMUToSZdaIignoBZy73SfhenFxIWsveR98ft73OI6ZNcTz0Irr+z4nhLEKIT0NbQxo4UDhz2fNyUeMafjDuMBxMS5+Z6IXyjVfevFF+X7UTChap0lBbTa4vLxMeDMhBWYuTpZ0iBGPHz+GDwHNfI5XPv4xsbil6kmy6m3+HlLmIz2Kd95551qI4SDgroQT54ljyx9+nutnsVhgNpuhriu4VCr3/QKPx0Kegu44KMqDAluzXjKGnX+exqCzEE+MJ20pa+NIYUwHr+tgpL4n7blfpyi0la33Dj/PfXus6N7veCaoZBykBGVRlKhS0kddVdh3+2RVB/y1n/u/oW4qwAK7dpc7jXd9D2Mt/tKP/zjqukFRlpIm7RzGVG2O2WoU2mVZHhRl4YNxE2nX+9hVorDiJtX0Ql1sSgugY2udmC451Fxk/N48NaellQcgF5ei8NHBCe2S85qk0gFTuUtOcubZKsvWGIOiLFCrFli08J1zBw0IYow5KEkcW5P+SXfTC4hQDbFuClKOGeeBShRAToSR5wuokrV+48YNnJycYDafSxDGHDY6DoEZg083rKXyadsW6/VayrYmCqBujMFuS1dXV1kQamiGz8U+gcTyjwUCA9e8Pr+f58xNnVgkRqLqzgAHHH69tpg1vL66wtnZGW7evDltvmtcdCoXzo2+H6IezLprdztcXF4iGgM4hxdefAlFVQpUkmh9BhO7h8KbZ3n48GFeq8feTbYejyANbSGKxdkfxECm+uIT9VVb4MfQ2PE1j61PzieNs8Pg4+QVaYWyT9Uk9XrS64uZytqLPPYwtDDWe4TzpuXAsVI6gAPVOuP9a8//OPCquefvdzyT4OZNSmuwEXVTYxhHrFZSHP6n/qufwhe+9AV0Q49hHCT6bgHrbC5p+vGPfxyf/fznJCBlph5wFBYccAoCDhQ3FQOB/I4WJjqqTGuAtToYkORnKYy44WhxaS2urTAtMCggmEZOq4/3Z4zJdcBpYXNB0yLjeI7D1EmH5yVjhfd4bDVQqOma0fybz0KaH614Wn+03KVbeJXHOOPAycvYpIqAOvjCzakXMzdKPj8mgcmSvPfu3cPJycmBNXKdsNauIq93dXUF51xObY8xZviB90ZBpzFabnauJ7ryzDKlwCe0xM2YN4Y9rNc8eXuHOHO7a/P967EaxxHn5+eyFlJdk89//nMZ96+yt1UcCLLtdouLJ08OcgRifNpdH4YBTy4usL66QjQGwVrcun0HZzduZqvbJLhE23A0fACDi4sLbLe7a937LKjU/PDZtMXtvRbiwwFWq7Fw7g0KcD1WWlBfBx0cQyvaOqUhRq+Pn9cQi97Xk/Y7tIy1EXedkOY9U9DyGtq4OcbF9XxxfLQS0t89VhQfdHxowc3Fboz0hyyLqZ3Wrt3hxZdfwk/+5Z+EMVKPuEzUKOnVV8AWDj4G+ODxoz/2Y4gAiqpIm2qq1qcz17Q2omBicgwHYJqH+JTbBiBnCvI94pfaMqKA5QbnhGmXmQJLJ9ZwYdA1BqZAly5epAVzCCEn3NDyJQcYxPaMQEDaitCWO5S1fGy9cGz4jIRxiIdzM2gBTG+EgVNjDM7Pzw/iBPw8P6sVFTfMOI6pW7XM39tvv43Ly0tYa7FarbBcLsk5E8aJClwdb9g8v3HKDgWQMVQ+22azyQJYrwFgyoSjAuaY6d6hGbJR3tCxYEC6ZVqY/Ow4emxSMStjDDabTb5/adIsSmKTyup+/vNfyIZCSPtJyrg6MI183+6xSXxsMQKOBRehBCl7u95sJDkHQFGWePVjH0sy6b1dbu6pvu9xdXX5FAT2fj/ay+XA6Nf1Omd26MHaveY+9L/1azovQcdE9HrhODHXgHO+WCzQNHVWVBS07DJEL0Qfej1wnKk0tdU8jlMTFTJmuJ9JmtDe8LEQ5yHrnePmD5TVBx3PJLhDkLKXpU2dLoJwrW1V4G/8P/4mTm/cgKtqdIMHTIWrqw7WNAgeaNsdIgJG7/HKq6/glVdfxeilwptPAofXAabuLDAG3dBjDB4+RrhSilr5mLIi42FhF83CAJCxTAoFrT058dpl0pteuKpS3F7abXmQ2jaOfWZdaMtfn0MvWKZP04r2fgQgfHhrgZPlEpWzaIoCfbtDYSXNuSwcmqqEiRHBjzCQwj9TQ1mTFyctdm1Fa4hlnyw/3jOVD61Qus1ceCxDQArlfD4/qDPOuaICz+5iCLDGoE9CCtbg5u3beO7eC1idroSqFgNgIkIYEeIIxBGIUx3kbOEoWIZeEKEOsRinKoBa0OpYCY0OXYdGBOuUmq7njQpaw2dN02BWzlCiRBgj2u0e7W6PcfTo+hEwDm3bo+9HxGhQlg32+w5XVxsYU2C5uoGXPvpxFKUIk77rsdtsMfRScRMAjDVYb1u0+xHWVnAFE28CEBIdMAZYM8LaEbvNE4Sxg/MRZjAwscQrr3wKxpaIpkhp9MdWnIWBg4GDHyMe3H+Y1/u1sIGBVHVEBKJHCGNWujEI80p+JJNSrhfS/thjGPo89nqetPXqnMuC9/BHqKTGAEVhIRRBj77fS97AUSyLc+tSHkTfT3NLgU7Ryetyvo+teuG8Iykfqd7ofYSITItxDNhuW8m/iAZFUcGYAoL+OVhb5N/OlTDGwbkSgEWMJp9HGrkYCBGiQFFMjcff73gmVknwHmUSfHVZoZk12LQ7/NCP/DC+5zPfAxiD3bZFXTb4w698Df/kH/0zjJ1wNEP0GV4pqwp/5od+GNYViFEKruSmrUAuk5otHysCmskePmGjhbK8+XnttlDZkCVBNodmGuiggbYWaOnKhIqwds4mvE4mfDZrpgWhcCret7ZCCH9M1naVlIrwnsuywKyuEb1PAruANZDqbMkCqMoSVaIDHluKhEdoWWv3kIKPWPdxtqQeJz0eHEfNCdeWL6EWppVry0RWDLDd7bDebLDvO9SzBtaaLLRtYkdYK9zwoipQHm1gXpuWNlk06/Uam80mw2u0IHloehv/rYW5xu618j7GOvO6GH2qlxzR7aXl2Ha7w8XFFS4urxBSM5C6buBSd6K+H+BTQbZPffozODu/iV0rAqcfGGhORcCcdGTZtnt4H2GsVI5MokTYJQCMiQhxRLff4urqCYrSACFg7AZED5yd3cTy9Fy8N/d0YE+8L6Qfg4cPHx1gs8eWdQwBIQton9qFDflH2E3jgVEz/T2d6xhG0Neg1axhCcZ35Bw+GToxrX0PTTHUMNsUd5isZipv1j7iPRzDIocWN9P/TUZVYgQmGucIaeYhQt77kGoBSYJebo5hpERvUZQoCrHQx9EnyG0KIMuaKXHckei9jmeyuP0oQcHFfAEfPLqhx527d/E//LW/hqurK/Rdh/lc3O2f//s/j9/+rd/Cuw8eADBomjmsnep7fOpTn8B80cCkRAHixNxYhBcoxDnxmgES4xQg1JbCcRIKsVqdXMJJ0lxfWnS6hoWedL2xacXREqTw1Ja9hhCGYcB+v8d6vU7CdARrjDBoSqE5m81QOIemrtHUNQprUZVSm8QAqIoCVTV5KDrwyUJSFNS0cLQioeXJjcSgJp+Rv0nJI5MHQD4frSeNJeqNyX9vNhtIXERiFDdu3sTy5AQujbNWdsLZngJY3MRN0+D09BRnZ2dYrVa5dyTT1/Vzcm6P6Vl8bbfbYb1eY7fb4fLyke1C9AAAp/NJREFUMr+WXWkzub56zDi+2iigot9ut3j8+HGGqqgYud7aXYvv/77vTwKQJQN67Ls23z9g4Ec5l8yJysjjurOi5IrCoev22O42YPr00EuRrrqu8MILL8CPPtXxeZoSp3HfJ08u0O7a/JnjIJtWgMevH48z39PxmutYIccCE0CGvhjHKIoiN/bgPfNzNo0Da4lwnWjPWdbqdP86T0TLNH0Pes9rpUI5og9t9OlA5bH1fgx1cr/qOdCK4489OBkjYGLE6eoExgCDlxTsn/vrPyebcb6QrK9+xN/7u/8HvvPtb2Pftvjt3/ptIIqbQY3jvcedu3fw0Y++hJzGrhIljDHYbreICd/UVqWGQGKMufoaB4lCXAtmfp6Tyu9y0HWAjQkt2nLXi/SYAsWFpYODZ2dnGXejMuA9sPQoBTsX0mq1wnw+zxb5YrGUYFpSIrOmQWEtiuRWcgHoSoEM2mrFx2elMKfCs2rMGUidzWY5gHcdw0Jb9botG8deKzDCLOMoQWeO08nJacbP9UbKnP04Rfu5IXa7HR49eoS2bXF1dYXNZnOQrMC51ri0xkQ1DKbrqBeF1L5hIPYYw9UUQG4omZtFtggZPwgJTuLcEj7qug7L5RKf/8Ln0O532G638Gn81usr7HYbcfujx5hqess9q/RpCCWQsJ0xwOXlRYImEkshxszueO6554TnHQ4Fdj6fGuP9vs3GhPYc38v74D44DgRrwc01f8yK0jEMLdS573heLYj5GZ1Exv1eFJORpbFwQh2axJ6FopjNBwaCXjP06I7vWx/HkBKvfUzp4zXJtqEhpPMc+B3usePxfq/jmVglNj2wtYIbf+7zn8ef+eEfltoljTzwt771Lfzqr/5qbo30u//xd/H40RMUroKzU2lTA+BP/+k/BWOBvp/KrHJAmIXGYJgWyBSgOr2cA88BpLCkFh+GIXOmOUgaYiFMQM4yFzbdc16TE8ff/NETsd/v88ZlkJJCAEC2yDhp7GRPvnFVVVKExsvPYjaHNQaL+QKzZoaqKFEW03Nws3PsuNA0HMKDf1Po8v5JFyTbgkW8dBLNscWux5wWvE6aQpqr7XaLwhU4OztDjBHn5+e4ceNGtq64EYqiyNAQFbS1kh361ptv4pvf/Cbefffdg2AwFYiecx1g1MFJ1tk+OTnBbDaTrvWps87V1VX+LIUYz8UxYvmAEMJBEKosy5xVqbn+/PnEJz+BxXyO9XqNq/WlWMjDgN1ui3bfIgTZD36crHptCYYg2L88Qwkg4PLqAlZRjikg9vs9Ts9OU5bxFHc5Xq/chyEEXFxeZAF0vL7193hMXom4+MdBRy14gUNhr79/HZzH9Ulhp699nVV7rGz5Oe09aRzdOXKpj5/FHcw1DRee9zpL/boffX19P5Q1XFdTPSMcBFb/2AW3gcSUVoslQqIA/vW/+Tek56FzCMnN+z/+7t/FdrPF3/gbfxNN3eDRw4f4w6/+IQChUJVFCWsN2n2LT3/PpzCfN1l4AchChRsNmMqManogrQNatpw8biitnTW+ScuQAomWoQ5YMkFGLJJ9FkzUxpxIJtzQFeI5hb0xZe9xMug+i9CcNihhDSqOqqoEIkmCpCiKDFPV6Vl5PW2hUOFwbIApSYf3rZOSjBHaIjcE4RxuMo5jjMKxJzVRlxvQi5DKgEWjhLstzJR33nkHl5eXMEbu4caNG7h961ZOAjq2Xo5dbiQIbLNeH9TEoFfGuanrGqenp1itVge0SrriTdNguVzma/V9j8vLSzx+9Ajf/e53sxLQLCQdB2AsgPNML4r0Ss4zvRxrLb73e78X/dBhvxeYRixPCepZa2AsY/2HhfejundXWFR1gbJy2GzX6Lt9qncBCK48eYuzZiZKEk9nQR4LBu8DHj16fIAR89CxHu1dTbgxA/eHQgrAwRw+rYiO2SeHkBYPbUkfC22uOx2n4X6nccH8EN6XKHCTEpuO4jHq+pq1dqyU9HMeP6t+Dk3505/VY6LHi3DOHztUAkgZV2csEIEf/4mfwMsvfxQ+BLR7yUr7d7/0S/jqV76Kn/yJn8CP/eiP4pWPfhR93+N3f/f34FyVQfrZbIamqbFaLfA9n/k0AODq6grAVFeEDAdSvWhJandMW5f8rTuQHKdR64HUQloLd/ZX5PsUEhT6WlBSwFPoacpinQpm0RqmNauFKl1A3jstRC68pqzgYNC1e1SuQGEdKlfIv5VwmXBSZPec98Ln4+Igls1nJhRFPFYrBM1UYUJUbsKsYBMKRXmOCJ+64BRpE3Vdh4vLS+z3e6xWJ2iaBk3T4M7du3jxxRdx48YNWDu1HuMm1Viqcy47vzmD1PssMGm18DwMlh5vfHofTdPgxo0bUhMnBPhxxNXVFR48eJCVLZUmjQPGYbyXxhZUGPP5PDdk4Dog/r5YLPDFL34Rfd/hwYP7uLq6SPcUAEifSkRJZ9ddy7UFDCNFnWZNDSDi8kJgEpNeZ8BMK7q7d+9mmOX9DmMMLp48eYqVo/cN1w49nUlgTTS2LFCsPRBOWhBr4XidoOY+1mtP04K1ccA9w+8/vW7Go3tVQt887U3oPXhs7OnPHXstx0Jbyxcdq9ElIHgdfl8roD92wS3u9AynZ6e499I9/PhP/JcwNjEtihKb9Qb/9B/9E9y5fRv/9U//NGZNgy99/gtwxuCN19/Aw3cfou8GXF5eYbuVmtt13eATn/hk3nScFFqJU2QZecPRUuVDMwBhU9VAvfB536zuN1kKh6R57WYzaYPfp2XJCeLAU3hpy56QCM+jYR5OnCbh837kucLBBHIjyjMIRxdATt0ex8MSmhrz5SLnwqGQo1LQAldvVt6j9hD0c3OceK/E+Pl+WZaSlZZcf2vFlAzeYxwGrNcbvPvgXdy/fx/b7RbWSiebu3efw3N3n8ONGzfRNLMDIQxM+Dlx+e12ixAClstFFqYxToXDKLi1h8YxCSGg3e9FAQFYLBd44d49LFarbChcXl1KfXS1TkKM2CcK2r7b57o9NrGeZrMZYgi4TAqK1/34xz+B8/MbUoFwu0XX7tN4c/NH9IMomRAhVQKNwmwNUCaPdLGYo+87bLdrwBx2UY9pnMVqC7h1+w7KooY11wfWyPO21mKz2Wb4i+3yjq1bLZC4XhmvomLVeDMFmZ5HfX0Nk0y4tUmeKnFhrrESwne3IO/dueJg7er7EuvbKW9AvH35PFIawWEsRRfJotHIWBLv+Tqv5Rgi0UFHbWXrdUgDjR7fdYysDzqeiVUyWy3gXcSP//R/ieXZHD4MqAuHwlj8wi/8Ih4+foz/9md+FheXl/jua9/F5774OZycrfDg/gN842t/hOABZ0sYFDCmQtsOeOVjn0RZFxiGDt4LDi2umcdut4c1RdLqAcPgsd93AKSZqjGpypsVWuE4erRtB4FXNe2JtSBkYRjjQC4lJ0TXsKaw52ToQIn3PgsIDTHQstbYGrPi9ALT16B1wQJWtGoIDZjCISahHQ0w+BHBAEOQGs4aoqGC0wuRi4FWOBWBxhsJ02RcGsh4/7Fwp/cD4MD6ijHmwAtihIlSQdKlynYIBn4I8J3Ho3cfo93s0e16XD1ZY7/rYGFxdnKGF194ES889xxu3biBpqpACNemn8I5GARYeMzqAqWzcCYi+gF+6DD0+4PnpADhpoE1GKJHO3S42FzhjbffxINHjxAs4E2Eq0tEZ7Dt9ti0OwQDBGeAwmEIHr0f0Q4dNm2Lzb7Frtujmjco6kSv7Hv06fqjj4hw+BM/+Kfw+OIKF48u0W87jH1iQtgCq8UKVdXAGAcfI2Li8oZgEcYIGyPq0mK1nOHm+RlM8NhtLjEOe5SFQ2EdbHSpF6YIkNEDYzCYzVaYr25gCA6AA0sLiwEzCUFpgBJxebGGtQZFaVFIUjNIO9UKUAs7ee2wWQgD17pI2PF3KeSlY1AJY4TzrLnNgBP4SJYUhONcoygqOFeiKKoDaEpDL9OeM/AeYFefEKbkG+5l7VHTO9TJZloB8TXgEO4BDi1oDePxs9yb9Pr4o7NL/7MIbmOkRsbHPvEqfvhHfhhlVcLAYOhHfPOPvoVf+IVfwPd8z2fwfd/3ffg7f+fv4Jd/+Zdx+/ZtvPrqq3DO4T/+h/+gorYlqkom4SMvfgTn5+e5XdXFxUWyJpmCLPWYhR/rcllOowaf1m9VTeVPeYiFqOsNTNaDWPSHNbtZz3my8A/rdutIMCfIOSnrSW1LvJXCmefifVEJaKFIi1gH2IpCeM0hTtxzWtz7ZDVyI2iGA115wjjaWtIBXD0OvE/itrQ6uPgIq+hgpPY4stWRn58KDIIpqnNxwXZdh816g/XVGhcXl7md1s2bN3H37l2cnZ3lvAF5PhHkVJ7jOCSXeKohojNa9YagR2CsQH1d32P0HrP5LFtXZ2dnEvOIghkPYyo3YIA+JZJIpyKPfpA+lnIth67vcHl5KVZvPyDEgBfu3cMrr34M9+8/wNXlVUq2SVablaYJ9CCn4JeB9ECQetfSyX6Fwjm07Q677QYxSoJTLtuasiuZ4xAj0MyXuH3nOfgwpczHKYMdjGrSs3tycSH34X2GZnT97Sww7MRgoser4Y0YY2YmaahSw5d8XQvbjAoZGRex3h1CiKkO/mRVMzbFNazhUm1MjSO9Tpc9sfz8at9o4oFmEWmlQ+HOf2tlpr2eY+iGe5I0XZ0MqBWZRgI+zPHhBbc1uHHjDP/VT/+VTGlzCQv9e3/v78F7j5/52Z/F7/7u7+IP/uAP8NWvfhXee/zAD/wAClfga1/7emIrkPYjAzVrZvjCF74AY9gySzqYO8eCR/0Bm0NDGBwgDepz8rhpNb7L703uPzmxXR5E/uiAh8ba+Dm6VqxDzYmYIuOifHgOCiqtkWl9aytdB1p5LgpxJvLooOcxg4HXOw746M2lMX8AWflwY2w2m4PgilZS2hrXMFG2KoAk+ELekNzgXNi8f3oYTKS5vLzM1fuWyyWef/75jIFrCh6AbNWxNjvvg5Xprt1A3sP3g2SfRsCEiMJYzOoGs7rBYjaHMxZNVUuw/WqN7XqDYd8BieHjII2y53WDpqxQlxWqosDlxSXGccRu18IVMpY/8AM/mKEdBqWttVngVmQiWfZjVQYGIqqqxmq1yoH7tm2zd8au74RYJg/SZcPohXsfQVFUB4WijjFlQJqFPHr4SBp9qIAh70UfGjaUtfR0li5zITRLhwfXzXHFQa5JzQjiNbQhxfnfbreZdcK9qGHMY4NGC3gAmSrJ6+k69ZQ1vF/Ci3yW4710/HM8RvqH+4n7jbDJMTXwg45n6oDz6U9/Ct/7vV9KNxiBaPD7v/8H+P3/6yv4wR/8QXzk3j38b//r/4oQAt555x28++67+NznPoe6kU4r3/zmN/HZz34GzDSqa8m8+/SnP41f+je/lHiwW8SI1BkkTWRhD4SNtqK0oNaVzrTQpoDjAHFA5fUuD/R8Pp82hroWLUtteev74b1QiEhXmRp9LwE9whFcTAxqavYL6Ud03fhDQem9x3K5xG63w2KxOChPyufVHej1IgOQNxEVBrnbZVmmYOp0fQptnkfj45pPa8yUpKPHmwLFgHM0bXgt6OmSEvvnPHFjskwAN5UkzmxgrcnPnzdijFgulggwB11wOA4xRqmqWEmzhzBOmDggQW0DoFFVF62TbEUKF5YepnVfpzZx0tyBgW4LZx1Ozs7w+c9/DrvdLsM3Mv8pOFWkXqBFgc1WGhrATJ1qCldgNmuSh2mx3m4Oqt4xKQdIle6MNKYoyhJFWSMAODk9RTOfY79us1V+bEHHBPput8Jlb2Zs7MHPP13Kl/tD9sSYYJXJi5vOO1EBtXepE1J4Lu4F7jnt6QKTZcs1rSEMnQCjg4zHln2+ZlKMtMyBibkG4EA+aDlz7MEdKzdtLOhra6OQz8tx4TPx9Q8Ll3xowb1aLvE3/4e/jnEYEaNHVdUYx4B/+A/+Mcqqxl/9q38V/+pf/atc43e32+FrX/sa/uJf+kt45ZVX8JWvfhXf+MY38PnPfxZVNUtRcSno/tzzz2OxWODi4hLjyCp2ySUvKoy+zwuFUAInmMJAF6bi4FOYA8h1QnRQUATSBBlQGGiFoBcFGQva6uOAU/ju9/tsHWtYgTjzJGA9Qpj4ntqdZCKHFr7UyGTNUJDy+svlMlsAYvlNCohjw6YB3Cj87AH3GsjX1AwNfW98PgZf+e+u61I/ybTIEQ/Oy/ooPLjQ+TpdykmpCq+ddLuzs1Ocna3y5tBCXhRcgavNlE1JdkxW4JBxskbavq2WS9R1jeVyiRBChp7YB5CKqVmIMN/v9xku2u/3ePjuwwmyiqyAVybu9idhjMF6vZZAbLQJ97cwYVKk3Ti58IWz0k0qUQMXi4V4cyMzbxV+D4YXBcO11sG6EsYJXm6iNBW+efMW3t4+gRjo5mDcuW4BZAWzWNTwgWyiaW8AOPCwCIPJ9ycsV8d0NNzAvaohvfdSClrgaXhCGyq8fy3sNMSh17AWjmnEDgQwv3uMyet707kQtPJ5LW2lE86dz+fZQ9IG1DHZYhqL6+ma73V8aME9m8/w4osvItZlTl/+P//Fv8Qf/MFX8ZM/+ZM4v3EDv/Irv5IHwDmHX/mVX8Gf/bN/Fq+88gr+w3/4D3jjjTcQo6oJEj327Q63b93CvY98BG+88SZyhxFIJ/h2t0dZFXmTak2o3X0dkBvHEfP5PGtT59yBpUhhY8ykablwKOB5Xi5ACl7ixjqtXk8wO45L9tzUrZ21WKqqytYuEHN9aADZOieerPFpLZSrqsqp37SydbKChj0ofPTBolK0IPTz04LmNY/rhWjLk5/RSsk5O3lKyfWTQjyqcPzRwqflwxokOhHLGJOhBlHaAeM44OTkJJ/j9PQUy+US212LW7fm+fnHccxdc0gnLMoSzkomatf32G63IkyTUCXV8Pz8PCdS7XY7FMmafXD/vnDKuw7rzQZjKoRWF0WGiIrC4Ytf+AIuLy9zBjC7ucTUrrYqBQde7y6yEEMWQiZnyDpn0bYDuq7HbrdFr7JFY0xItXXS+b2UQH2IQD8MMMbh7MYN3H/Doijswd7hITBAge12h/2+RVneROylPsixgORemIQeg53Ie5NegfbEuOfI/+f8SiJfyB4Nr6E9Mw1/8HWucQ3j6fwKXa9dQ0QaKgohwGGCTvVnNebMZyC8w32qhb5mcNGI1OwwXo9y6vjcwCEr5sMcH1pwizYaUTixhHbbFr/4i7+I+XyOn/2Zn8E//2f/BG+99Va2CHe7HV577TWBSz77OfziL/4ivvKVr+Di4gLn52cIwcMmVsd2u8X3f//349//zr9HCMyGlOpezhUHNbP1IANTg1lOvGY90OI6Dg5OC8oBCFkza0tSf5aLg9j+bDbLiTm8HwpVKgnSkIBpsRHrFkt+gk40lENLkdHm40XEz+qaKrSmqZD4W8M6VFp8X7t+fB5ifdqC4FjzWpLxtztQhlx4eWMoHI/9SWkfjuOIMs0LLZeu62CTl0ZaJedLe1S73RbGCN1QJ0fwHLtdi7Ke5X6lfNasXGOEiRFdglKKosDm6gptKvPK+a3rGo8fPToIuvbjmOtkE+7Krm5aJxJItVidnGI2m2MYplhECAG2tEBMhkaZ6GBk41inxluCiLLuYrbcaL0ZGERrEKyBS8FRU5SAKxCNgQ8BfvQoLXDrzm18sxDW1tOWJ/LchRDw5MkTvPTSvQwjUDlo3PXYxZfzCauIsYpjgaYDxxxPgTgqGDPmxClCeHr9acyY61lb/trq1YpCwzJa2UTVYf7YG9DX0j/cP9qLplDWApyf3e12Od6kPQk9fvpv7ZXyXB90PAPGLWnRpqwwjh6//Cu/itdeew1/7X/4OUTv8Wu//KtoqhqFK9B3PRbLBbwPePDgXXzik59EUTqM3uA73/ku7ty5mwRTwn+cxcc+/jHMFnNsdjs44zAM3QE+SXyWVh4Dgvv9PluQWstRABEe0IKVC0X4wONB9FtreV5nu91mYQggb8ZjF4janpNpbUgLv0DXCSwUQsydwGczSTOXxhRTcs/x4tMKgh4Bn1sLdS52YuqEHcgwAXCwqLRi09ihPjTeqJUBx5HjlOGdokTbdxPmmAodmWgwjH1Ow+YYEaoxSeAcX1/j8tp1btsdXCE5BJeXbXLrAbfvsUs87xgjeW0wxmCWsj9Z4IvPLrCdTYpB6ncYI2nPfT81k6AnFZUy115OhHCQn793D9Y5rDdrZZUW8NHAJsFZlAXavsO+76WethFPJSaWiLUW1jhEHzAOHbpuA++HnNQUYoR1gHWFVBJ0BYKxGL0UInNOxun0/BbOzm/gwTtvwbnklqcO41O6/AhrHR49eoy27eD9ZF1KGdL4lNCf4BbmLwQ0zQxS4W7yHMqygHCuJ4xdIB+Pup7iBdyrFMDHjBFtZfPfFNycG40lazx62o+TEWGtPVhvGj7Sgl6vVUKenHvtbWvolutKvJlykqDKsOTfPAKf60MK7mficffDiF3b4+LJFX7hX/4r3Dg7x1/48z+Kf/HP/hnuv/EWrAd87zGrZ+jaHv0w4DuvvYbV6QIvvfQCYoz42te+jhiQFkiAKxw8ApZnKzz34vOwpUGAx2wxQ9e1Usc7xtxthpYl6zBzY2sXSGtFYNJieqDX6zUA0gXDU8KIC1fX5eAkhxAybY4LmlYIrVbS18qygPcjjImoqhJNU8F7yXqjINRRZmLKmRetFgUrnGlrQgdvuBj4DPqctH543zoxgouMz8bv6sWpPRAG5GjpcH6891Km1TBw5SE1lT1gA4Zhn4TEIROFikG7y9pDyVlnxkrMYxxRVg4h9Oj7FkVhEXzMpU/7rsPQdRj6HmPfo9vvMQ49Li8v0LZbSDOEIc+LMYBzAOs9AwHeD9jvd3LuIFDPYrEQQaAsJI59CndhDB7nN25gvd7ChygBR1fCuAoeBmCHdj/iarvB4AOicYjGYUyCmyVdx2FEu2vR7rbY769gbIAtHIqqQVnN0MwWqBdLVHWDwhVwAAoLOBNhrEW0FrZscPf5e4BxiGBLM0gCj5VnBkS5Sr0cgSlFSE0wCJ+TkCSFGMuT1vUMdT1D08xRVQ2qqkHTzFCWdVJe049zJbyPGVJhiV4aGnpd8ZrMttVJYvzsMdTCf2v44hAPnyxmHd/RWLOGMfR9XEcH1gqc3/UhpFrqqf0bhAlkZaFh9B6j9/AhYFBGCcvOftDxTDxuay2apsa/+3e/jDfffAs//hM/jn3b4l/+n/8n6loGNWTaS0BZlPjaH/4hDAxefOkltG2Lb3/r29jt2hQtFyoUotANf/InfuKg0L9Y2hK0ms/nufbDbrfLC4dMknEcs7DTLo2u0UEritYqA2I6YMLrHuPEwFRLm58jnKHrkfDzwzDkQv2sbaFpQVycpIvpe+d96wWshSfLkG63W6zX68xa0I2UJ4sJ02Ly/sAaKIoi1zehYmLgTSexxBhVjZUp25Qwixbu4zhKvXQIM8I56TrCFG0qIG4UHU/Q3eYBHNwD4SU/7uFMQBx7LGY1rAnwQ4cYOvixz9zuru/AIKlzFlI/eQAQM8XUGNJE41PX0vPI9cwx1VYgvyOfEUPgueeex5DiNCyoL1X8UvDRGPT9gF3bggX0rbEwlh2QhH0i3PE21WcZUZUN6nKGsmjQ1HPMZkuURSPftw42CWVrpDWD7MUBq9XqwEM43NjpOcyUrq9TtIvisMIin//YO+M8anobhRyFJ1/TwlJzuTmm1wXqaBwQRtMFqShkNdxwHSzkvUfwIVVbnAqZMaCoayNxn+j9p2FLTVOkAshkgqPPZ+9T3Sf367S+ptT3D3M8cwJO2+7xS7/0S7hz+zb+4l/8i/hn//yfy406i92+xZBqBBSuQPQBr3/3dVxeXOCzn/ksqqrC66+/jocPH6JtJRjS9b00DTYGr7zyKs7PzwFAdSeJmSpEgULKGnnFxJX4nnMu/00hTmHBACMXsbXuoHY1J1JjTawsqDUr/013SC9s/X0KWwb09OKiNckgmA6UcoFykXNSaZVwsXFRUfBwUej7pIWrg0u02HVfSY4l70EHJWmta8vm2OJwziGqkgRI13dO6nHEGDH6icPLczCgq3mx+mAJghg9CjOishGf/dQn8EN/8gfxI3/6T+NkXqPAgNJNzzd5CNx4kxs8ucwTe0BzwfWaJ3wlySBp4/lDru8UdwHu3L2L+XwhvSJgcqEtWnrWCuEv+AADB2sKAE4CjCbh3KnwVNfvsNttsNluEKNN1uwMddWgKhuURY3CSau4HB+xVtovhBF+6DB2eyyXS5yenqTxOLbokiUKEYYsJ+CcSzkKTRayGkfmc2uoTXuh2sqlEgCQ2UfHwUht0HBs+T6rHmqhdowF87N877p7jpGhYcnCPY6NUa7w2Y6tcN6//pxWENlbtfbAM9CCWqe3Hwt0Xbbig44PjXFzwf7rf/1v8Nbbb+Fnf+a/w9AP+PJvfFk0jwXqpsGYIrrDOMJZi91mjfXVFV5++SUUhTAMfu/3fg9/5s/8SRRlAWcFj+u6HsulFOT5pX/9SzkA13X7FMSYqHNaQFIIUPCyih0ngzgugIzDak7zfr/HYjHPOLqeTD43MXQuDC3kafkz2EXrlAkImp1C4a+De7wfYn0aa9MLmhatFvbaY6By4aLQ8A4FPYXxOE4NHIApG5NKjckNgNQJJyTDDcrfjN7z+oDQ2JxzyeJEepbJYpOFPlHLrLUHcYiiKPLcayErzzHi5tkcf/7H/hw+97nP4vatW3ju+efx3e++hv/l//W/4I++8wasm0ltbAWrDQPjGJPS0jVWaI1SCZMhc8hOCJn1Q9eW88RnLIsSr7zycQAWIUpnJ8TEFgESPTIlhMAAUdKwi7JAhJ2w5yh5Em27wb69wmZzhVmzQggxC1IKCu89hrHHOPYTDOB7RD8AfsA49LDBY7FY5v6f7FQDTJTCiKnaHgVwCCOsPVyL2orkuub6PVa4fJ/jpAU19zE9UQ1laMtWK4lJQcYDYcnPADjYuzouMwWoSRlAbtR9HNvSa1x/l6/rPAbt4We5co1nfbxeNC1Qexj6Wd7v+NCCW0qx7vHvfunf4cb5DfzUT/1l/IO//w+lVCcLtwCYLxbYbreYNQ3a3Q7OWnz961/HD/3ID+Ezn/kMfv3Xfwu/+Zu/iT/3534Ey9Uc/SBcaEl5j/jSl76EX/vlX4P3XChF3kxaSx/3e+R7DCRS0JEFQmub7cu2qSEr3WUKBx3h1QuKk6Cz8ujmeO9zMFTXNNC4e1EUaNs2R91pRVJQVVWVcXwK1uNFyn/TSqW7x4XDICHvFxArmkKTi5iLjlATlQCvUVUVTk9Pc/Nbrby0ctHXnv7tYNI5YowIZSlCYUxVEKMIObKP9D3Rs6DlT6+LC72uK3z60x/DOOzx27/1m/A+piqTS/zJP/Un8OjqCu88XMMYi2Ho4AoLmADAp1T3/397fxq023Wdh4HPHs7wTt9850tczBMBkhIlgiIpSjYVDYksR4lt2V1uOXZVul39p6tS9s/uclfcLnWcLnelO6l20pU/cSxZtsl2JNsaSImiRFIUQYIACIAAMV1cAHf+pnc85+yhf6y99lnvB0i66NKPqOqeqouL+w3nPWcPa6/1rGc9S0HF9QIOnkfJUOCLv08HWt8LUBob/rcxFvVgiDNnziKGSEYYmvohK0CZPukIpRBDhPeAVhYxKMAgF99QwrDDqmnwxpuv4bVXX8eTT/xAOswcjOkbJocQ0DmLzhUoXIfVEvB+BYcA+A7BtfBdm+ESecUYATZW6WvT6TSN+XrrLwm1yNoGvo9MHr8fRMFGTUJy0ivmz5FrHFjnmktjLvMg0qjyvfhZJcyRnxep0AzknDDL6uR9Ze6J7Yf0yCU7hCNSXk+879kZkLkmfg/+PRn13en1gSonn3v2Obz40ov4z37xb+Pg4AC/+7u/2xuF6PHUpz4J3zr80R/+IRaLBXQEQufw0gsv4tM/+mmcO3cewXu88847uHHjBgbDD6UEETCdLjAcDPHEh5/A5uYmbt8+yF4XG0j2oHlhSByZjRVPYFVV+evMoWYPmA0pLcb1BsG8+NirZYPFi4irDOUiresas9kse9+8cPgkZ+PO+N/JhcQeKy809r4l84G9bVn9yVARe638NXl4yBCVPdnVagWlVP6b9V8Ys5N4ItPknHPY2NjI0QIfEsB6tSeXvNOA9Ruvz+L792wQucl4gfO/ZaFRUVgUVYGD4yO8+MLLmM0Wqb7gPLa2xnjo4QdwMHsRQGLWKI3lYo6Nzc10UPYJJTnWcrNLmIgNAj1TB2oGG9Y2LNCHy6dPncbGZBMhAkZxIlwlQx0QlKcWfg2JnRHf3QLKgtX+6A81o14sZ3j66W9ga2sbITpEGHSuQYSHD3TYWGNgrAG0gtEKvluhKgq4RsMjIqiIoFSWDGjbBtKuSuMMkOGmCKinrPIelA6E9H55fk56yBLflfMtmRa8H9nZ4pwR77eTkTb//EkcW84Vf/0kxp7fM6Z3Vn0jaQmJSGcN6D13eTjJiyNctkkhJSb5e3It8QEhDxz+miRH/GnXHWPcq9UKX/zSF7GzvYMf//Efx5e++CUcHh7SQxiDjc0Jfv7nfx6PPf4YQgjY2d5GkR7i5Ze/h+l0io997KOoqgrL5RKvvf562phF9jgjgPFkjHsuXUJVlsm76Oljshckv6Rkf/AAMRWOQ13+PvPBZTJTHgw8cewFS6PLG1bCH+z1z2azvOF5EfS47DqVjw0ke9bMzeUDiKGQ6XSaG+EyU4Wfe7FYZCiDvWD2Dtj7keX/0kgtl8usNy5ZJQByb0cuCIoxZqriaDTKWty8UeVil4uTo4UcsgpcnXUzqNlsn1hiT0QecKvVCi5tBO9JGfLajZu4fOVtXHnnXUznC9y+fYAXX3oJ71y9hqqusb29nb27EAJMWiPv5+HwH46WiqLIERUfmgAnq3r2wsnNS/fTuPe++3tvUymQKl8yLmS/yXPPm5UMt8oqlT0WrhTw/PPPAgh45NGHoXRE51bwoYPzDTq3gnMNQqQmunLzl0WBYV1iNKhQV9RgejgcJn77iY0d10u2OXHbNNxuq30PY0Mm7XhvSuMv1yKvF1kAx987ienGGNfGXkZ2J6NOyZiSNQ+sm85Jc1nwkiMq1WuUcD2EVNNkZ0Lm0mT0Leef78v5geVySTx6ka9hG8KMHL7kO0lywZ1cd2y45/M5Xvney/jkD38CVml85Xe/TC+rgOFkhL/21/8qzl04gx966gfxj/8f/xX+2t/4q/DawymH/cNDfP/7r+PBBx/Eo48+BFtofOMbX8dyuYLWFtyPMoSAsqrw0R/4KJbtEqYwiAhoXQtTWHS+gwsOq3aF+XKBgABbGMToMz8YUASzuIjggeMjatDAk8sEf140JPcKlGWVNqdL0rHUjRnosUSeTIY65Ikuf449fv4dpVTmbgOEG7dthxgBkqgs4FwA8V01FotlTsrKxhBsjNhr4QotTjBKj5kPPMZq2YPgyk0eAy78kZtlsVqi6ToERLTOoaxrzFdLRK2o21EK/9ioK6XyIRZB/UVDYOU4rvBLUAWAqipAlXkOXdei61oo1cM0fJhy5NB7dxpX3r6BrnU4f3YHp7ZKbA2BgQnoZseYHRxhWA/RLBsUtgSiQmFLdK1DWVCNARuWk0wEnivmlVdVtVYFy+wKNiTyd51zqAYD7J05iy4ERKUQEBDgEOGJKKgibFFiOKLuOwFAUBEeHZQKKFUBEwGjIwCH/ds38K1v/hHO7J2BUQaN69AFj5DSaz4E+DTG0TvAt9DwKC0lJ7u2Qdu08C112inLEnt7e8loKiAawt+zjCppypDBpr3CHcsldMBrKhsQ4QDInIHcFzxW0gjmPRVJ0TCLW8WYO/8w+0MeALwWeD03bYtGGDzNEW+M6ATDKcSYFSEB4QmLuXTMIElwVr4UFTrx82SIRuv8/MsEOUrRLN5PJ1kqvN7eL2q5U8N9x1CJUhpVWeE/+pmfwde/+jVMj47RhYD/8C/9LP7aX/8FVMMCMAq7p/YwGA7wnX/5q5g3C9RVjcVyheeeew6f+MQncP8D9+OFF1/AG2+8QUm8qsRoMkbXtvAh4Hh6jHvvvxfGEu1vMhojKo1mtUJVE5WvKEgw2BiDILK7Whs0qxZKsedG1Vm8oNj4yR6QrI1CZdkRRVGKBMR60oDvwd49G0tANLsVE8AGjj1gY0j+lbxhj6KgU365XKWFiHwvIKKq6HRmYyYTGrLdmUwoyXCRDwrJGuHQrKoqLBaL92ifTKdTGGPQug7QGi54LJsVNjY20kHnMRoNMZ9RN3Iel+FwmDqUK7RNmw49qoAlZUB6N2qK2yAiwhgL57hyLCKEdf2GoijQeg+jiaI4HA6wXHk0A4dzZ0/j3ounsbu9gf1bx3jrratQgQ5brQ2WC4LHtCLRp7ZpYUUpvQz/Tx6MPKa84WiDkYGT4X/GKpXC7t4p2KqCMoYYJVohZPlVwlWNLVBVdU5UQkUEeKI3+oii1PC+gXcrPPfMt3Bw4ya2JpuoqyE6bZI3XcLqJEZFlgQxdDDaYzGd4eBwH7PjI2q2EEIqgKFCmNOnT+HNN19HCCc1MZK3Dw3X0biMRiOEsF6KLWEH9prfz2OWxlXCTxIm6O1KX1HL91RK0eHkHCDgAwnJyNoDADlhXIQAp3teNs9X7zWndRiIbOHDur4KNywJIWBzawujlLPjyDeKJKRKn5nfTew1GRlI4yyNtIxKJcZ/J9cde9wheDzyyCM4e/48vv71r8Fai8FgiKOjY+JGL5ZYLVdomxbPfPsZPPudZzEejSlRA+Dll1/GdDrFAw88ABLMWeGll15KCbCQKU0AcObMGWxvb1Mp86qBhsJoMER0HoOyyrKaKnIvyDIVSvgkqSlwJY01Yj8n3NjrkpiqzBjz9+Xpyd4sLwpZQSlxUT5lOckG9KEZQwJF0fdtZKMpFzsnDruuy+JHfFpz+MfeoKQjyjJ4mQCKMeZ2WnRYLDMuxxswL070HGZexJm9Y23umMI/s45Hk6GNMSKGE2FvjOgE5cxam8vTJU4ux5gPPkpQt+iCwvXbhziYLtHBwqka8w5ANcSidbhx4wYA5IhgDSeNfeGF9CB5HXDyicNa51zGXlnVb23zpA1flRXuueceisBy6bro5JtSf3XNGtVgUkdao4qdXygE3Lh2Fc8/9yysMTh95hyqaoi6HmFQjzGox6jrEep6iKqsYQ11rbl58wauvH0Zh4e30bkGxmjYwqAoLKqK2vGdP38O4/EYxClPLxGxZjB4nfRGutfQ5nmWBkcaa56394M5eE+s/TzWPXb5DBJikCJn0qOH6qmG/PNcvHbS81VqnZbI/T3l/uWcGs/7xsZGjhR4H0uOu4QHgV6RkMeKmSZ80MhqSv6Zk7j8+oH6x1937HEXRYHP/cXP4bvPPY8333iTJhAR3/zmH+Hb3/42Ll48j8lkDFMZ/P5X/gDL+Qpd12JYDwB4vPHGG3j33Xdx//33Y29vD8fHx3jttdfwmR/9DFq3wnK5QpUE2IuiwH333YcbN27AaupyErxHVfS6JdoaFFpDG43Gs8GlKsW+TDeVY5fFmgGVmFPWrJjNwNxV3rxlWSEEl70BLk/nSWIMnY02G3ZOjDBnkw2DxISHwwGm0zkGgwGWyyXquk7RhFQENBn7ZoiGFwNj6Oz9s5HlZ+DFx3h6jDEXuPBzS6ohHxZN0yCkDQDQocfqeQz3GK3h1brAFN/Lh4DlkjjpnesF8On9PXBiAwNJUlX1OCQbWv6ZzCYAELUBVI3L79zErdsHOLWzjaIcYLZY4fr121Cmb6bA0FCOgsTm5PniuWSDztGNxHVpPD3iCUZKDxlVOH36DBV3aEBr7rCkgEjgNjNppOAWGQ4y8NQw2MP7Fs98+49wfLiP8+cvYDgaQ5sKRhfJe5ddygkqOT46wHI5B5W0E9XQVAVUCChLi6ouMdkYoyxLnD69h1u3biB3wTHvlRtl1cse8uhzJ3INszGSvy89XWmk+X5sCOkdemaGTFpmSEHg0oxDs2SDrPyVUYH0aNlRYqdCerMhBETfa6lIOIPvt7+/v5bjkoeRdOwkp5sPehnN8ff4OdhJlIeRxPHv5Lpjj3s8HuOjH/konn/uufSwXAwS0LUOO1vbqMsaq+USG+MJECIGVY3ZbI7Fcom2bfHcc8+hKApcunQJ3nu8+eabZKxSg17GFq2xuO+++4g+hAhlFKIKmC9n0FahqCyqQYm907u459578AMf/1jyZsjDGA5rGKsQYo+/ygKWk14dGz0W8++/3mZD6b3PBS8Sg+UFxKpoQC+ORFHJIE8UezGcvJtMJvDeZwYMs1V4IchCFd4knIxhb9EYg3kSSWLjy14B/wyXFi+XS8xms7UNJsNfXniy5ya/n8TG+bMk35n/3xqbDJVYkCdCQEo0rjCbzbBaLdPXei6sPEj4HXgDrdoGMSqU1QidN3jrnZt4+bW38Obb1xA06WJIvF+GyV06SCX/XCa6AeRkMc8fjz8XgcgEEie3NjY20tpIhhoq4/rkXVOhlzFECQ3UXBJKE6c9JiTcR4ebN67i+y+/AN81+NCHPgRjS0AX0MrCmBJKGSAqhEBNRpareVqLBWzaP1VZpRwIRV/kEJWw1uDM2TM5COAyfWA9UUZj163tE553hv34sJZG+aTXKL3vk2Xqxpjc3Yh/X0ZHfUk9GTfW5eH78b0B5GYmXCjG+06SGfjAkIwgThbKd+e1xqJZsspXfq6kBspEN9+H1xCAnPTmCFBi/RKClc/wp1137HHzIH7r299OD0sLfrla4ezZM3jrrbfxxd/6bfzoZz6D0lZoVi1aEhamJKMGnn32WfzCL/wCPvKRj+Dpp5/G66+/jtu3b2FH7cDoXikOAC5duoTJZILN8QSjyRjnzp7D3t4e7rl0Cbu7uzh9+hSKosSgrnB4cID//f/u76IwGjGG5HWTxGgIAb71WeeEB5o9Op4Q5mDKhBgNbMj8U54ohkEk3Y5/VyYkAWTeNhvATBeKEV3Xc6SlQQSQsvm9gWaPnDHpvkluzF669BCNMTnk5Ys9b+a282fyeEiMXC4oCdWMRiPA9b/H3HM2bjF2Pban1VrbNaU14prX3SYclbq28HxwxMILOXvG1mZ1N98FlLaELguU1sCTygdM7AsomMHE+QdbFPCul/wlEam+mo03kux4328wQOpT86EdY8TZs2epi03qQAMQXsx+UU5mKeR7M2tbqeSRWw2EgO+9+Dxmx/vQKmB7ewvaFORBW5tyLoHogL5F2y0RQpfGbgAVFWLwqU2cQ/T0t1LAcEiCZmfOnMJwWOdcgNbvDdeps1CX5ZtlmM/rWnq58h15H0iPVO45Se9kqIM9XvZ2T2LlMUYcHx/nyIj3UpscDBmd8b9l0Zw8XHKCWmso9d6koDS4Mv/BF3+f1wx/jdeqtDEMz8iDgx0BCRGx/hC3P7yT6wOpAz777LO4fv0aECh5UJYlRuMRvvlH38TvfOmL2L91G3/41a+l7jURhS3g4KGMgSktbty4gdu3b+P+++8HQBTD6XSGcxfOwXV9wnC1WuHjH/84HnvsMcrujwbQRnScCFQ67TqHLpVQl6VNveloU0gvlpNObPxkGMNhGHOaGR8jg1qCWB6LDDsw5UjCJydDZy4i4d9jAyEphxxOSyyPFx17+0Vh14pDGHflcJ8nnQ0u0LNneLEwvVDi6bx5GGfuq1SbnKmvqwrLRCnk3x2Px/T5WmNnZwcHBwfvgRaWyyW0pcUafdo0fBgEIEK2ulJQYAXH3uuVmCHDHQQHtfCuQ9DExolRwdgCq7aFLrl4o6cU8ljxuBlr4UNAkQwvR07vh3HzBupxXTK8J70rYwwuXLhAAkIQDXnBXhTBJDzmq9Uye7l88WF0PDvE669/H9612N7exrnz5wFlYIsK0ApIIljBt4ka2EIbOrgRFQwMqOInIgZPDRjaFWIM2N3dTYctcPr0aVy+fBnG1KIZQ48fs2QxORouH5yyizvPoRynk8k1HiNeu9baLA7HyTyuMOZxlx41Thjw4XCY95c8SKQ8BBtICVPyujfGQBudTETfm5JtAb/zSSqjhDTku0nIh1le/PkcNfAelBi5zGXxPaqqys7YnVx3bLi9d3jl5VfgPXk6IVIIDq3x+c9/AYvZHNYYHB9N6VSLGjEqxACUtsB0Tt1lrl69ilOnTmFvbw+Hh4f4/ve/jwcfur8/OQOpsCGQoTDWYNU1qM0AurCYz6gyMiigHNQwkcSJirJEjGQQQ4jwLoDGOaIoSTx/Op2tVSRqrTNXmsMm5g9T6XwLUrhbr/riA0JCIuyxSaEn9oSZUy0nnhkr0jtomhViBEajUZYT5d9bLBZrXjsbW8YFT24SPsU5xATWO82wUWNcnY34bDajDYN1MaGNjc2e1dJ2aGezbPz4Xbuuo3ZfyYvM3r/WCFrDp/6EPZTSH56r1RKRywzTdRIrraoKtbYobYFmxfxuOuCWK5IZcN7l5hQSKukxbWKekNHmzU1jzwabsWhOclO0xlKnlEzka3NrC5tb21BKZ60Rzbi16gtwiM3Uoet6KQDQ8oRWgC00XnrpRVy79g5c12I8GmM0GoNGJAAhQqsIgISjKBpT0NYiKAWFEtF4KEW5J4UI71o01iJiirZtsLe3CyDgnnsu4vXXX4VS1Zr2Nj9Q17ZgbnjTrAD0Xi175ZJVcjJxzxRTvudgMMh629KYhkAMEIlFy0tCUoxx01rp54rXh0yAsqFlh0bi6LT+KN7JVEFhtCXNlp+XHQF5OMkDgdcM554kpCLxf3a45HhLZ+Xo6OiPsb7vve7YcLdNixdeexEqWqxWHSbjDcLrfIBSEQYKVhvoVFBTlAU656AtJc4KY4EQce3dq3ji8Q/j/NlzODo8xCvf+x5+9md/Gl3n0ayYJWEBraEtbfbCWizmU2phNRhAG4OwpMW8ahp0rkE9KFHVJba3trG7t4fd3R1sb+/g3PkLGA5HMErjH/6X/xBHh8do2w6FNmiF0BGfjOzBzudzGKMzpXA6neeJJWPQgftmsqfK35MneZ/ccmshJH2uB3U4WWRDTgnVDkVBnG72TGmNaVhbZoPExQaz2Sw/N9MAJc7IFxsxGdoxa4PhmqqqMFssESPgXIBSJm86ou85qNiXOANYkxiIMcKnPyF6FIVBiB4mKrSdB+vYx2TcgQjWXveeZD+LooBNhpY/h73uGBWcV4T9KtK37pyHUQWCC/BpnNu2hUpjYYxJHWF0Gkc2NCoZZPJEq2qQx2o0GkAp4vez8aLogRjaSgVoo3H2wgXAlAigZ4cijjZ1Yk+sixDgXInOtdAgyVYEQEcDBIdBUWB6eB0vP/8MQSna4PSFi6iGQ7Rdi7oooRGogUKMiFHD6JpgDk35H2MjVEgt1xCIIlhZbJ/axJntBxDhMBoMELc28PBDD+Krf/D7OaGvtIE1GgYeBhoqOnRti6IsYSzNBV9sxJjVxNz9nu/e850zJztGzFNS0TmHINaP9j1/XsKOSinYoiBtcWuhtEaTYC0fQp57GfnIRCBDn5zT4uiqbjuMwLoxOn9dMozY4J6MIPpDvM0O0mQyWWOFSWiPo3kJlcjqS1kcJO3GnVx3bLjn8zmuXHkLMSqUZYHj6SFiiDDWIEKhrko0DcmuWqPRrBYgUfUU9iia3Jdffhk//dM/jfvuuw8vvfQSbt26RQkhozAajnJCqO1ajEYjGK3QLpcw2qJrHVAkLyZEaEtVYmZrC/+3f/yPYazJzBBrDBbLJYwp0LUdXn/1NXSuJfH9WEDHpBCmejxbeuI0cb0QlJxY9tD5NGfvlSeNT1f2PNioZagnY1zkddapmXJVlTkKICPT6zZwRR8vMmNUXpiS0cKbR34OgDUdFGlkZVKIN8F4NMIiSeg65xKnN2Y4pdC94BUvQPbAiqIAvIN3DkVh4RtPnmsqn46KSr0R+8YVPK7OdahrOvxafs+0idu2TZuxf3aGYRgWAyIa3wCqZ/3IZ+OcAheV8ByPx3V+dtZ6DyHk+xIXnTjAOZmnKfF4/sKHAG2TaNR6M17plUEB3gUkpIhkXBVgjUJZGLz80gt4+8pbdA9tMJ5sAIr57QFG951xtDJQ1pDh0hpaU5ETIumRq+ihoLC1s4UnHn8Yk9Li9Ve/D9c5nD59Cg8+eD82NzexXK6AwHCO6jnnKfGplc5VhhKDZigCoIKXKDxobW2GOJDm7iSlliMpa202sHIPsictIUDORbBHy8lI3hMS+mMdH1YTZaO+Wq3QtS0UgLIooMpea+ckNMJfkxCm/DlO2EvYUfLQT+acODLhd+WcEo8T25w/c8PdYzoWznXY3NzsS94VoGJAdB66UIjOoy5Sx/HOoRpWgKHJv3btGpq2zT39lsslolIoqwqtc+hCQNs0GI5GWLUdCmsxGIzQJLih6zysoex5iAHp8MXO7k4ydHRAzJmzHKhq8bvf/a4ovLEwivQi6tTPUp6iEjtjbw/ok48S75JGW4baLGjFJzp7tAxxsPGRCRDe6BSqLRKO21edyQMDSY+DP0OGorzYuXuPXHj8HpxI4U2yWCwyy2WZnp0phcvlMjcjHgwG0DGgE5CQPKC00bDKouk6kjVNG7CvbusNW97sItHlPXmzbNC7roNWlOTk+WFRLF78TKd0rkvQUH8I8SFGjX5HqWI15sOQjTNvfpnQ9d6vMWms7Y0cIrC1tY2d7V3C7lWEUiHPDXLZDdK7pXfNLA5Aq4jxeISj4wO89OILBM1Fn0S+tlAWJYIzMNqmCuG0xtS6wBLtfXomhQCkpg8ffuJRnDt3Ct1sieF4E+9evYzJ5gbuuedeXLx4ES+9+AqKAfU+pQAoQQ+BEthQJD8rcd9+nvzaOLHTIrFnhgFlPkkadP66vCT8IesI2Nix48Gf1ztZPdbO88jrUu5pXn5lVUGXfm1/8b157XBEwfAJwZk9c4zfnaN16fXLQ0CyR04eYjKByvN7J9cHMtzWajSOJvLmzeupwMSjrAdo5guMBjWcpy4oMYSkC+wRvMdiSYb0+vXrWC4WuP/++7G7u4uqJMpgPaQEJBkAnV4K8IEbsKY2UsqgbTu07QraaFIVdJQshQJWPLBJ78NqmpQ/+IOvAgAG9QDL5QrBky5DEKR4XgzyVJX8a/ZaeZE0Tc+o4MlmfIwNzMm+kEqR4A93YQf6ykiedEooltnjZ9iFsUC6D2DMIC8KNmDcRJg9E3m6y/uz182fOx6P86KUyZ+TGfu2bWERM3bOzS3quk6yoWSk5QZlXFepNE8ZTiUYIQovlUNm/myGPfhZeV5OUrt66IZ7ifYHFLOAThZMcTEW5w14nCS7p09OIWGjlPwOMeKee+6FMSUAgxi5iITzDRFaGQTQYUSVpOQd0xBEVHWJwbDGV7/+Hbx15U20zQLE5aZCoq7zMKZCjP0zA8m4GWqcQIdU2sYxQCmHuhrisUcfwMWL52A04G1ENRjDR439g2OcO3cajzzyGF5+6VXwIUOHrILR9Mxd2+UkHnu+EpflPcMHKq8TzvGwwWSHQbIpThopmRTk78v55USfnI+TOR6Z5GdHjL/OcFld1yjLKqsDRt93mpJrXD4D7x9OXvPnSvycHSB2nnify8P1JJ/85KEl7c6dXB9IHZDoS0ghbQ1rDWI08M7BFBYuevjY41V1PUBVljh74QI2trfwwAMP4Pz58yiKAg888AD+yT/5J6gHNcphhcVyQXh467BYLClx5QNWywa3bx3g2rVrGI0H+OEf/iF4T0UlnOxiw8iZ564jSUwuHvj+K9/HtWtX6WQFN3ow0MbA+5CTc8xg4ImUBRqSg9l7AHrNy2XDygaCvQ1e1JJXzRg1T5qcUF6Qq1Wbf46xaA4v23aVFwdDIJwc4fBQ4usS/+MNwdAAtyKT3ebjYvke6IcYNy3KRCVsW5IL5Wa2HOoFYVxjpOSkT4egT6XwtKAI52bjSePaoW37qkbeENlYOwdlbS6mkWPHxsBam2mYzE7olALR8/o5lOPCY845AmC9jyDPjQ8RKgJ1OcDFi/fAOSorV0j6FpG1P8iIB58SYc7DFtQ8WYFK0M+c3cO7V9/C009/A8dHByRDmzYu8cYbDCebCFGhC5REhdJJk5u7rAPB+TSiAcNhiQce+BAuXrwArYAQgKgL6HIAWw5xcDTDaDTCww89AmP/fYp4ei+Tci0aTdtAaQWDdW699Kg7YVwlViuLWtho8vpnR0EaKbl/pUFjo8eJP46A2aFiB0rCOLz3ZCKQnTLJ12+bBk3om0bI5+Z9/n40Xn4+PjCYeMBV0vzZ0gDLiFdG2NKZktTcO7nu3OPWCrYw8KkRbNuu0DSRlOaMxtb2HnZ2dnDPpUu49957cebMGezs7mJvdxdFWeVigPl8nkPdsixxfDxFd3sfy9US165dw+3bt3Ht2jXcuH6dOuWsGsznDaAUfuRHnsIP/uAPwmiDVbuEMdTYlZNrwQe0rssc4rKuoKPG1772NSAmupCLVBHpkpeg+gUnJWKlEZWLjr0LSjyQpohMkLC3zZ44X/w9picuFou88Ngo8QKmRdHDDGyQWUOCNw+f9HwPGZaxoZWnuzToMhKQGDy9F+GH+/v7GY6ZTqfY2NhAUZRYzOfZo2IogSMD5/uScv5MrC3G9YXJm7XHEul9BoNBDpV5k+cI4QQeye/fNC24d6LcGF5suLbtFSPlYSlDX56Pk6G99x5QtI62d3YwGW/C6AJtm0TOYgS0bIXHeKdOeHUAEo94PB6hqku88MJzuHnzOnxwiAnmGI8neOCBh1DXQ1AVsIIPxCMviiJprrBOtIcxASG02Ngc4sEH78X5s6dQFgW8C6Q94hWiKlBUQyyWM9y+fYAL5y9iWA+xbBrE0BfiUN4gMUsicnMHhi6kNxlSAlji0Tzv8g/PnSyo4fmT5ewnE4y8Z6TSJxs/CWdIHj4bVY5iea3z3giB8H9jLYw3a5/Fcy1xePk9fhd+1v6w61UKpRIlv6csy8+V38KIy8KhO73uvANO6k7+wLmL2Nvbw8ULF3HfffdhNBrh9Pmz2N7dwWg0oiaZMcJ1qdVYDJju76NpO7zz9tvY39/HarXCzZs3ceXKFRweHqJrW3RNkznWbeJB0wHhYcphwrMj0VQNUFcVoCJ8apXWciJKazjfq+DNZjN85zvfWQv1qqrCdHVMLJHkNXNoxgYa6OVf2QvjxcvKcVoTDMB4MIf0PPnD4RCzRJuTniFT8E4yPHgySea2glI9jY09T16cLIfLetwypGMtGN5IyyX1+GS4AOi1xzmJCiDDO7wQJfzjvc+yAIXuG7hK/RN+v6ZrEWjl0kZmLws4Cf3m8eLn4jFYLpfZAzLG5O48w+Ewb4AYI4bDYZbf5E0l30t6SaRCuW5A5AbjzSp/R4azWikgySicPnUGWhkABloVoH6SxACicnd6WSotJ253joIQMZmM8e47V/DMd76FZjUHMwyNVhgOhtjY2MCgHgCmglcKxvYt5Hi8aU0GaHQ4dWoTDz98P3Z3NlMiUyF4g+Wiw7J1aLuAoqwBZXA8nWGwt4v77rsP333hhbUDiueM11w+/E541hnnVutdbaTXyf9mDFgm7XjMJdQnE3syIcpzxNdJbJ2hPYYwJN59cn4jIV0obAHYKt9PwpnS+WEjLaE0aXSlsZc1ABJ7Z6MsZZplhMi5JE7438l1x4Z7a2sL/83/879BZyqMxyNSXOsIS+qcw82bN1ODhOu4cuVtvPrqq5hOqW3ZatFgdjzFakV4kk4vX5S0uWLnUBUlVk3yxJWG9tSFui4LrLwHVMTW5ibKgrqkd87BFgZaF4D2GAyGcN5j1awwHAxzaPVH3/gj3LxGwkNlWaFZttmoWWNSCBpSIoUrN0kDgheqDKnZ82qaBqsV6YmQEWH2Q5cz3kdHR9mgMfbNJ+zJhSWNLxUKNfkQ4UUlT3tmoZA0rsJwOMr3Uspl+CeEgM3NzXwISUyXk5KcRFosFiS+o/rmv7zgOBT03pOao3gXNpwMNSilEJxP3GMNlahsWhFVrrfcFO7rjAECznko1XtXMmMvNwi/37pxjnmcqeilyActHaQlmNYnoyEZvrOhYOyTL6WQoQdjC9x77wMI0EAgXD0ED2Wo/Zj31HGHWB8sNmQofxgJ1pjNpvjWi0/jzTfepMhJUVecqDQee+JJjCcbmM7mGE2GsGVJCUki1yM4R70XlMfm5gj3XLiEs2dPoa6oXgEB6JzHaumJZts2aNoWRCet0LkO167fxIcu3YsXXvoefAy5u3iMESoAXZJ2ZQ/f2L7Vm3RolF6XbuV5ksaZ51DCG/249jiwNF7sKPEf6ZVL3FiuQ9kTlY2jc32vWvnZxho4T5DIeDzGcDhE0zQ4Pj7OUbP8DHZUeJ8CMv+hsj2RYyExff43HwbpB3tnU3Dc7+S6Y8MdYsTRbIEWLd56+x1cvXoNV65cwdtvX8GVy29hOV/QS7sO3nlMNiYwSZymWy0RvQdaj8IUUNFgMBhge3sDb719GdZQq6mf/09+HoO6xi//838OrRWaZYOyHqAsB5jNF0CgpMnh4RGuX7+G+XyOt9+9go/+wJO4/757gQDURY122SIYj9gG/NoXfg3BEeVuNp1DKRKzd9rBxQAS/CGmCWfXqTAkZgN3cjHyAmyaDtRs2CUj6xLLI6Bt+8QGh5eMT3NYxV64DP3YuydPp/ccGbufz+fJQBqEANR1mTyang5IGsshJ+VkIkhWDDJ+x4uLBa9mi3n+Wtu2GI/HayHy0fExRsMhAGTPmL/XdQ7B0ebX0DAKcPDQysAoCx+9cLhJQbAeDqGVRdu1KZHn8nNLGEpuFJmw5Oe2toD3EcYUaFsywEVRgbTOi2zIeZylUThZPCUPaq01DBS0D7BFja3ts9jcOgMfNQICjOoAZQjTjqnCMgZEKBS2gDIaSV0aw1EN0xpcu/Yuvv30FazmC6igEFXC/nWBjc09aFvDB4/p9DaGgxHKqiRcGwqliRiNLEbjEg8+9CHsbOxBqxLc0BhRoWtJ5M25Fu1ijq5ZUeFYtIixwHy5hK2GgClyB8qoUvO0GBG9hwZSUVMvIMYHv4RIGE6UipEcsTFtTnrPPI8necxslNnIsxHn++ZVE9eTnGy0JcVOPgPfnxwXB0Rihzj0cBgnNPm5AKwdChyp8Vq0xqABcrOY/F6rFVrBSed3ZYiEqlx7mi6PAee9zImD7Y+77thwL+Zz/KN/9I+wP29wdHSUNRe0phLS0vRVYx4eXdth69QWgIjbywU610EbItKvVg1+8W//Ij756afwf/kH/2fcvHYDznl86OJFjMZjFGWJoixocViL1nWYTIg2b7TGv/u3v47f+I3fIGW2UYlP/ehTaDvyWsqqguso9Pj6V7+GGzduJuPZZU/Xe5+aGfSe4nw+X8OL+WKPWy4YDv0k04G9DZnFjonaxRojMhxkgy4XKZcaMxQijbEM26XxYriAn6cPwei9WGdEa52rCfkZ2OtmD4qxwNFohGVD967rOoe9Gdfz/YLnzSVzAPyzEUDXOpAedxSGuDfdZbr3YDDok81pbGTxjTxA+f78WbLgiKmRwLrXp1RfwSo3OFfhnczqn0wSZXWRCHzoQ5dgi5I42Sn0pp+Ja1zuPolG2txKRWxsTKCPNa5euYrLb7xBRh4RComz3XZ49+238fBDjyAGhRBbzP0K3g2AMExdijbw2GMPYTSy2NwaYjSYYLUiCQitNNpk7AgfJjGvJgn9K8XwFK2Jqq7hHIfvFBmF4KFCRF3VGAwGmVorYRoeozIJxJ0cRwkV8N6R+QSJHfM8socr17lkmsj7SIiF14V8Rja6Ejfmz4XQidFaYzqdrkV3/HnSDvC+VkrlPSFL2tnTL4oiV2RK6FOuCbmy+H0kxn4n151XTnYd3nn7HUy7PumQE1yu53EqpfC3/tbfwo/9+I8nQ+Dxe1/6En71X/wLtJ2H9xHKaGxsbuLChQt48KEHcXRwBB8Czl44j3fffRedd4BLWFtwqCpaPM51MFbDFiS4M1/M8eOf+ywJThmmRCF39v7qV7+WKjv7cIU38/Hx8Rq/k7FSxrkJ1+05mZImxv8GkLFXnjimAIZAVZVSzIgPCfl7bIBkGDUajXB8PM0ViWzQuRiGZTf59yUeSQau1+MeDAapwUEvgsNQUdu22N3dzR44/0wjcG6+9+nTp3uuakdFDNI7raoKs9ms92I5PMR670H6e31d1fUAMQZUZYVls1rDD/kwYM9NJnck1sl5BNmVhzcfb97MKEgHpswD8DgCvdF+z0bSGtAG5y5cAFJxChvrXn/kvQ1nlVJQMULFCKOJend8fEz5Ge+gAOhIEYq1FtG3mB8fYDAaU34ABqumQ0QLpSaoB3sYj8aoa4t2FRDcAoPBEAo6G1A6jCnXQS21ZsTIAR2MbIhGoyFu3ZohxlThF1PfUPQNuXEi9Oex5TV5dHSU4QjeGwybSY48G0eZvJd7kueboUEAa1pDSqlMdZUePYC8TvkPOzHyoKH9QsVQxlqE2NP+eO75fry22Cjzffhe1qxz/dloZ6aYX5cFlpHEeDwGgDUIh9f8nV4fSB0Qijyjv/k3/yaefPJJvPnmm/hn/+yf4WB/H65pc3j7xJNPorAWV999F03T4NOf+TR+/dd/De3hDKPxGAdHh4gAmrbFT/7MT+Nrf/A1VHWNw8OD/JKeD4e6wnwxT5BC4gW3Ddq2gdEKn/70j6AoLFznUJUl2oagmjdefwPf+MY3U5jWh2Z86DBrgb1fNqrSg6Y/ca3xsBxcmXiUWXX2+kj8qswnLsMgpEXSZsxZMlA44cgQCkc23nuMx+O1AhHW5OAFJtkM7Hmw8fbeY7FYIMaYOdtSJyFTF62F7hwOj6coigK3bt3K/ftCINpT4z3KssjJSl7wHBK3raPuIj5l8I2G9u8nXakwGY8xHo/RdZTcdYFYNbPZLM8Bdb/pFf2Y6ueco2a5J9gKPWzTreGkcv6Wy6XQiGmysedLJrPp3xrKGIzGE2xsbqWy61QliLBWOcm/1xs5JIJ3xMH+bTjnsFzOe6MNMtohBpw5cwYfe/IJKBUQ3IryAiFQG7k2wBoF1y7QtQ1iICeja6kn5iDldmazBZbLJebzBabTKRaLORbLBYxRUDHAKFpPFAnWaNoG3g/A/HeW4b11+xbJzYaeTcHzx2tS8rPZWAO9NCqPt9xTstKR50omQTkRzz/La1vqn8h55t+TkSH/nPTmpePVtS287mmocv75Xfi9+ADK0EuKUNno8/NlFoq1GfvnKEQmbdlJ5N+X1b136nV/AJEpjxgi/vO/+5/js5/9LA4PD/HZz34W165dwz/7n/4n2KSix8bpV3/1V/H1r38d4/EYf//v/Rc4c/Ysbh9+H9P5jDRCEDGdTnHp0iX88FNP4Su/93uwRYHlaglolY2U0hp1TZt1Y3NCGLShDtT33nsvHn74QSgVUNclvCMsaTgY4Rvf+CPy7kMfenFYJbErPr3ZqNd1nU9QMrbvE+pwMsL2jYNlqAQgUfV6z9o56pbOuthseNhrZq+axeJZlIgNKneq59L3+XyesTxeODJi6LHvntfKho8313w+zx5tCCF7As73SmaLxQK3b9+GMQYbGxuYTacotMqHkmShnAwv6eoTvSe9bYBUHmNkJUYFU9jMummbBsH0hQ7WWjhxGBpjiDOu1Jr3zc8h+b/eudxvUCZoeU5PJpx4nvm5yQ1V2Dt1GsaWCFFRD06toSL1eeR3YyOzBhMED9e12F8coQttKlDjSkqKUJTS2NndwWiyAWMKIFEjNdLnxwDnqFHwcjmjPpq2gtakCxMjsSW6jnj5zapLbbdaxBAREt2w7Rq0XZv2QAGjDThSIJye8gSrJVFtI/qKRGk4gb7RtLUWw+EQw+Ewe+HSGMqDUx6gMnqV3ik7QMwe4gYm0mBLjzp7woLWyZ8tHau07NA5h6B7r53vORqN1lYv49u8b5UiDRU24rLEXuZM5EHHl4QruQCP9zev1zu9PlDl5Ief+DCeeuop/PIv/zK+9a1v4Wd/9mfx1FNP4Quf/wJC13dVuXHjBo6nU8xmMyyXC1y/cQNdSBS9poMtC4wmE7xx+U2cOr2Lz/7YZ/Hcc8/Bh4DheARbFDg8OsLP/dxfwi/89b+Or3396/in//SfYj6foShI3rNzLf6T//TnYQtDna49aVEURYGDgwN84w+/CWuKJIjU5jJ03ky8gHiDsfGWWWliIJA3OxgM8sEkvQVJHeQwnTHZENyaR8pGjieUs+CSb82eB4f9zJOW/G82YjIU48+QxU9Ns8qwCi9MfmbJ6eaooW1b6pNobI4KWMDKOYf5nJQZh/UAPmXr2fPiZ3NJq5uFhmKMWbsi470iIuwNZo918gFbiO41MpQ26AtzeKzYo8q899UK83Ro8iUlbtkj500jcVPefLxWaNw0fIy45957wfp7wQcoaGhFxjXGHttcn59AuDGAK29dRnOqoZ+NqboYINhFK5w+fx5bu6cAaERo+EDVpd51gPJA9GjbBabH+xiPt4iSqBR0BFbLFcyIqIcHBwcIHpnqmQ1d8hARkdd4URZr+i0KlKCPsV83vEZ4fZ1M3ANYM9g8JycT++9nyLkakcdbeuR8sXPB+0cWBUmMmCNUZkTxxTAGzX0q+ol9rQZ72czYYgeI55Kfkw7hvtUi35MdQF4/nROiWwI6Y4dE1k/wuJ6s/fiTrjvncceIjzz5Ebzyyiv49V//dTjn8Fu/9Vt46pOfxD33fAhvvfFmXvhVVWF6TN3Vn3zyI3jwoYcwnU6xahoMBiNo5+CDx0vfexW3bu/gM5/+DCabG9g9tYfl2ytM5zPcc889+IW/8Tews7ODj3/8B1FVJUiRj8SLzp49g4985EmEGBAVaWCUZYkYFJ555qt4992r1O8yebFc9CNPQva4maEgq6UYJomRkn/Aeggmk4qMUzOMQUahRVkWmWbExpyNBHsox8fHUIr0VBjOIYOC/Mx8cHDoyQcEY7RS04GSnEtYqzPjQhakyGRJXdd5wfGh27YtiqoXged3Zm1xY6hSVo4TeyQUzbi8+VOQSgdifH86WPAhVWBSf7/WdXnDsQFlrxnoDydm5/DmkbAXY4eMQ8oNLw00H75sGKRxOelxG2MwHI6wu7OXDiNCP2JixiSwZI2uxveNMQAh4ODgFp579jtwPx6yAUCSYY3GwgeP24eHgLEoyxG0LgBlgBDgmwV8bKCUg9HAfHZMjZCVRqkrIBK2ynIIzjm4rj8ISeytgxeHPCckKRojWIbFryTkgbRWeJ7ZC5VjCvQGlw9Qyal+P3ycoRY5ztIYyzXGh/pgMMDW1lZ2JLgIjfeg1M3h+ZUJTpXKv8uihFbrcq8hhFyXMBwO8+HEz5A/QxQD9QywsK4OKg4u3kNsh7rkCMkcG6/rO8W579hwj0Yj/NAP/RD+5a/9u4wPXrt2DfPZDE88+SRef/11uOChC4s3Lr+JH/0LP4af+Omfwsd+4GO4ffMmrl+/CWsNlosZiqpCZS0unjuPX//1X8OP/eiP4wc//kO4vX+AoihRD4Yoywq2oCTj8eExXMtZc4PpdIYf/dEfw2RjE7PFEZQJWHYNClvBaouvfOXLZLhiwKAaYLlcoCh67nRZFinj3qavczab9Eus5cRK316Ik2K84WVSkf9mg8MetHMeTUPFNFyxZ22ROr4TVFHX1JmEkyC8YPn32FNgSISNrdYam5uba82Pi6LISVfvWbNDYzyepGiBdCnqegDneglbXqCcIHXOIcT3JgB5DKqNDQAKxlgYg9SlnrL1g8EArSO9jQjiy4YYe5pZrsKhv+tBjRA9Nbi1GsNygLZtkqGhylT2vpzT2YuR7IM+6dmruXE0w1ebvG82MtJTlFGLDMP53zFGBChs7p1CMRwCippCqCy80je+tbaA0ZbYGd4jpvxKiA1eePFZ3Lx9DRGn6L2SsFMEiH6nLFH/iiGMqaCLGlAaKhKkEUIDpRpsTDZQlRaxa9EtFzAaCCmEb1PP0OFggKViz07DOQXnA5Qx8F2AMgq6sFBGoywLrNolOUExPVMgFUXnPMrUbDjGmBX65NiehDfkgQj0IlE87jKhyAczGzjeQxzZyjJ3Piw4IchJZnYo5Hp1JwynpHsCgDYaRvUVkfJ5qqrK77tcLvPekLkUPkxoL5tkV8o12BAAHc6RJDY4r3ayEpTX2clx+5OuD5Cc1KjqCvv7+7ns+vj4GPv7+5QwSjCAdw4PPfYIfvDjH4fzHtPZDP/9//A/QCfhqMIadKslmuUSzWKFy69fxh9+/Rv43Od+ArPZDDdv3kTTtLh1ex+/+qv/Eqf3TuH3v/xltKsWw3qE4CMGgxE+/ZkfTSI8BaLyGA4HMNrgzTfexIsvvoiIgNF4gOVslTznHppYLlcpebiC98wKIQ+bSon7CZKdbGQiS3JOebIZL+49h4jlkvizdBoTw6UoShRFidVqkU9bKqjpW5jxguM2YzzR7NkqpTL3czQa5R55vBjm83ny4rmcv0oeUcyGjTsC8UGUC5OsQT0cortNn8mFB3kDRqToqU/wUnKxg/MeIQZ03lPDAaVy+TR1QHdInXEBAMsVCWM5n95Z62wMtQbKwqBpuSONh/c97UvCXzISkfBXDrlFckriorzJTsJkJ4258x4XLt0LD0AF0kzXypLHrICYqiSNtkmPhBpOABHRO7x7/W1cvvw6FqspYtxF1BGBdf2DQnQOOzs7+ND5e7BatigHJUobYQoNow2MKqFgsTHewqV770GhgGbRQEUgOofgOihrEB3ppW9sTpIhDmibRIF0gNIRLjTogoUuDWAoqeq9g+s6wBLmSm3meviO+5rGSHx/ri+QOSJ5qMqoRUIFPJ5soNhYc5Ga9L5lYlFyvqXRljg2e/u8H/mebLRzLoNzQ7HJ60juOQml8QEgW6EVRYEYwnuSrzIKsYa43vLZvSOtHaDXxpGOgnRG/gwNNzXgvHXrVjZcQGpo21KrMn7hzY1NfOvpp/HOu+/iJ37iJ/KJxxuNH64sCjTNCs985xn88FOfQNd1uH37dk7A/at/9a9Q2gJwVBm5SMUeFy5cxPnz5ylsq02uxAw+YDQc4fz5c3j7yjuUBDQGoV3vCs2LZTQapeatfYsvNgpsCLjzDCf+mD0hFyQvMv5b0pGAnlsc0mSzceXJZqPMz0CwSJvDLxZw4gnnkFQmAxnz5SQmJ0ykdkqfhCPclT189uL5mXkjjcdjvP3O29jY2MhGsRCwCHvhsjqRnikZ6LQ+1hI1JyA8fgYAeXMxFggATehxY5qbHjdkb01udjbYkuctjTj/njQKJ5NlEjfNiaN6gHsuXYJ3HloFxED1ClCAUiT+REnMCB8cgndwvoVCxOz4GM98+1uYHh/DKtbMBlSKQEKgcvozZ89gY2MDi/kcPknFDuwQxlbQiNja2sJ9l87jwtlTcG2L+fEU8+mcIjyVtLEjoeabG6S37T01lzBGoSg1CkewSVlSdFaWFXyI0DqJONUUmRqtoQ1rwDSYz+fZE2XpBMmMklg2R388T9KQs3Hi8ZZYtEy0S/hCzq1kovC8LlMSVRptuU9lxXCMFB1559CFnonFe54/kyiUlF+aTCZZ+4cdA957EgeXrDX+IxkjHD0wBCmrm6VDcSfXB1IH5IGWdfvD4RCdcxjWNYn5aA2jNX77N38L33/9NXzkIx/BT3zuJ/DS8y9knKdtKaseQsB4NMa3v/VtvP7a63j00UfQNg1cR9VNWhGGVGhqDFrXNebzOY6Pj7FYLLCzs4PWLTFfzmG1xXg4xtb2Fp544gm8dfkKJYxCf9qTBgh5zsy3ZgPMi4cxYcbzWIdkOBxif39/LZRh48ALl+/Fi4gz4ZyY5CQeebpLWNt79kz3896nxqgW1hZr+r/slUvqFHvezCrpOejrOuDSWyAjbTLTBUA2lEVRQBkDZag/YGELbG5urhUvjTY3MZ/N14xc3qDiIGFvJeOWJBi9dnGoK8NVNvScW5Ahs7V9cQ0bVz4YeXMypi3ZArxJgB4akRCLhKpObp4YI+ljlyUOD6cwGijsAOsatYCx1IDWOe596jGfz/DiS8/j1s0bWC2XGBb9PWPIZT0YjSd48MGHYK1B26wQIkAFMR7ad9g7tYcH778Pp3a3UZUljDLQG9R1x0+ncM5htVxSc2FFtQ5lWWI2m6MobaIjAtbWMNagaUqcPXMBH7p4G9fffhfdcoFV01JtvwIi2Jvtddt5frj7ORsyNmC8ltnblXkECaVI2ITXBie6eY3yvEuPlfcw7wdJmWXvuMfue71uvieth1QAk9YFy1NwL0w+gDgS5b3JOkrsiFRluaYIKOEYfj9Zxs7sEX5/+f8fxNPm685L3kPAcrHMD8UDcerUKRwdHqYEmYLVGsF5bGxs4ujgEC++8AI+9YlPporGLieW2KtarVbo5jN87fd/H4898ggGVQ0NCjOrqoIDkh4ElZdubG7irbcu47XXXiP+ryfB/l7atMDnPvc5/O7vfBldQ13EJazBGWwAGTPmsIsNHsuo8obnhAXfg/nK0sPmiePFwgafvT+m+nCIWZZFXqi8KKV3zJoaALKXzkkhnnBeoGx8OYx0Ihybz+fY3NzM80ilvQ207p9Hwi9FWcIWJY5ns2x4+cDpug5lVWGxWOY1wYabQ2YoBeff2xGcFyjwXo70bDbLhxxz6vkw3NrayoeU1mYNNpL34DHhd5djzUZkKMr0+Tl4w69FBemSidTVapUNFkwBRAejU+d1BRSFhTYc9nqE4LBcTvG9l1/Aiy8+i7ZdwWiDIjVjMMagKksAGogK4/EE2zs7KVcQ4bsWnQZWKqAqFM6e2cHe7jYZFqVRljW0oua32locHR2haVuUpQK0QdMGjEZj3L69j8JyPoaotWNr0DTE4S5sgdC2+O6z38LxwY2kLUNNiQGSfGVDzIZTJuh5nN8PEpFGSdYVyEPzJC4uf1d6p5w45KiU1wqL0cnP45/ntSlzGzzFxhiUtsx7RlKAZc6KHSPe49JD5zXETgqvPTbovLY4wpc4NsM6fADxgSCZMH/SdWeF8UgbA8CTTz6ZT6CtrS2sVitcfvMyogtUGZaqFI8OD1EYi6999WsYjyf48OOP58k2xmCaquyMMVBQ+MM//ENcvnwZN65fR/BUrUWYEBnGVbPCeDKh5EsIePrpp5OxLbGxsZFwTLr/pUv34pFHHslGjo0iGz82zHLj80HCBne1WoF1qrm79HA4zJ4nHwLSKHFoJLt+yDBMKZUPAWocS3+4JJ6NIy8I+Vz87NPpNC9qqQEhF7rkssoIQ3LBGfrhAwtAer8CPlEDecx4kQ4GAxTW5nJhucEkLKRPbCT+HLlh1xah7vUq+GCVRnVnZycxRPpwM4oNIBd7jJQIlZVwfADJqjse+/d7Ph5/njNyMJb43vdegkIfeudEV04yUXLb+Q6z2RFe/N538fzzz6DtFiisQZ3mWCmCRrTW+e+269C2Haw1KIyGih7Rt3DtHAgdrAZWiwXapsNq5eCjQlFXMFWBycYE29vbJLGsqaWa9z6vV8rv1KSPX1Wo6wGGwzG2NnfwwP0P4ZNPfQoffvxJIPaURqgIpQm/N6bPb/B6OAlP8VxLKh+PM19suHn/sTEzxmA8HmM0GmVIT3LhGZLjZ2D7w/uP+ePs2Mj1JaOoDJcBOVCSxpUPDd7D0tgyLMROBENFvP/YKZFYvLykcBYb+aIoMJlMMBgMMqRyp1zuOzbcXdfhypW38FM/9VM4e/YsyrLE3/k7fwevv/46rlx5C8PBAKUt4DuHN157Db7rYI3Bm6+/gXffeQcPPPhg5jF77/FH3/gGvvnNb2Zu9NHhIf7Rf/kP8f/9whdQlRVURDoEUvKvrHD71i0aTCh89atfxY2bpPrHxpDbLFlj8Ff+6l8FkHrLiZO967q1E5YZIAybsKHnMIq9cBkG8eLiyIEPBp48Dr2lF89fYyPJi4nhDF6QTLtibFFWdLI8q4QEOJt90ttkg1MURc4tAMB4PM6HlxS84ncInvSruTiHP4N53k3bUmVYMqyZhRLWNR5OetXGGFKZE2wOoE8qsQHmPABj7svlktqODYd5jIqiyM0a2EDIsFMlzJG9L54XaQDYMMjPPbnZJIbpnMfly5cxX8yhtMqVoVzSz4dz1zU4OLiNZ597Bi+//CJcaGGsIs52BKIPQExyAR0lBLu2w2A4xKV7L2FjMsFgUGNQlyisJjZ39OiaJabHR2hWlOxumg7OR4LUklPBuYii6LFlY6hZ83BIuiNVWaOuBihsiboaYXNjB2fPnsOlS5cSzKUyRVFrgmv4IJB7Q+Z3gPUONGyYZLJXzjevETZWMv8iD/eTB4Q8JKQ+CD+PhL4kY0M6UFqTo6jNukgWt7GTfG+5l6S3zWuJYZCTh5XUIOL7sIgVO0RAX3zDnvdoNHqPU/PHXXcMlTRNgy//7pfxf/gv/j7+wT/4B/DOYWtrC/+v//a/hdUm0568c3Bth9u3bmO5WGAwGuFXfuWXcevGzTUu8ze/+U3q4qxJ8tImTHWxpHDIaAPnHXa2dzAej3Hu/Dl8/OMfT1Q1GqDf+s3fwi/+Z38zsREMyqJEs2phjcHDDz2MRx59FC9993vwCcZhOIWxcpnc4pNVerwMAfCA8qJjnE1OJE8in8JsjCXPk+8HIDFz2pz45HCef4dK7es1DW2lSLeEBbJijJhMJnkhSa46G6ajo6O1Ck0qew+5XJ4XDb9P11H3IE76cCUcv09ZlDBao0lf456WEVQqHUKgRJnAl2Wp8MnkpNyYzvVh9dbWVmKs0D23t7fTQbJOM2Ojy2Mgk5N8GElRfaDXtZaMFDnn8uoP2BZhscSN69dRf2ic3k0DKKBZztW1uHbtKl544VncvHUVy/kxIhyMAhQKBO+yOqICK/HRkJw9ew6TjQ1olCgKDe86BN8hBPr7+PgQpA1o4H2imamAoqA2gexIABpxtcJytYL3Lksv2KJASIaeektaxEiaHfVgiLNnz1HRVtvAFhVhwFrBByqnl94vr3U5RnI+ZVKY50fy7BkS5Dlih4p/ZzAY5HmUyUw2sADWpCByDkUYbkkvZPiyh2IShdf0GvYyYmQHiJ2iHr5ET4WMvf48P99JuIj/LR0sNu4hNWRmkoBSfVn+nVx3XjkJ4MVnn8Nv//q/w+f+g5+Acx6/8s9/Gc/+0dNkwLSB6xxiiPgXv/wrNKGdR2w6PPPtb8GnEKxxTcaAjdHQRYHhZIjt7W2cOUNZ9QsXLuDMmTM4d+4cRqMxNiZbZFyUgjLEC3bO4cUXX8ThwSH29nbIOHo6aRfLJQaDAT77Fz6LF198EQGOsuepeCeEAISI8XCMpmuyd8ZsFvZupbGTST+GNHjR8OJkQ7G+4ft/MybdJ84MmoaLa5j5olDXQ5DOd5vL49mzldonAOHDnLBkMSuJuTET4FaKVmhhdhkSkgwXjiaOFwssV0t03qEGtcbyLT2naxqoZFwXyyWMtWg9Haatd/CpIOWkZ5I9INXjp0h84eDpkKLqyYim6aBU3xg2hIjVqkVVDfPG4s0qPX1+Pw43ZfMLecj2m6c3+O9ntPkQ8d4D3kG5FW5dfwdn9k6hqIbwoUM5quCgANfi1rV38J1nvonDw1tomwU0mL8eECLpt5jIrB4aB6a1j7a2YeoJFEpYVcF1K4S4QggLmMpitVzAGosYPMZdC9cO0LVE6bQFKTFCG+giwnQGWitqRjwaJAOY2vDZCrbQcJ4S9z566KrGcGMb5WCEVddio6igUjMGat5sU7/GMkesJ/MV0vtlT7ePVnpNHmnMpNHmCJfnieFKnuOqqjKkwAdCm6JlhlX5vnVdo0xQTNd1fQ0B6MCLADHhLB3qFVc6e5/F06zt9be1psMRoAYutHbI+NJ7KhRFKSDLdYdEwjD0b40QeE5idiaViui65o7s8QcqeQ8h4H/+5X+O3/vKVxAR8eYbbyKCymhDDHDBwZYFOgbqFRBiwNbONqIGLly4gAcefBB7e3v40MWLOH36NE20URhPxms6AZy4NMZCqyJhki1+98u/i1dffRUA8NZbb+H3vvx7+E//ys/nhcCDYK3FZz7zGXzhX38e16/fRHAObddR/0MfMRmPEUO/yBiaYK+WPU0+/RnS4JJzHhNJAWKvhz1oNqI8ibIKjBMtJ6mSxpikLd17zhzey/CLPRCZQLXWruHXjI0vFot0UJps/OVn8/szDte21JKKqU+5IbJ4hyg8DmMtmtUStizggkdwPcQiq1VZ84JAcprnCMCHgOWyyYej1rw5CGMlxkjI4wpgrZiBoyZ5aLFRljQvCf3wJn+/jL4MV/m+ABBch+nhPg72b2J77wzqYQkXHJTrcHB4C99++g9xfHyErlkBwUPFCGrZFHK7tb5mp8fTI4j37iMwqAapow6V9Rirsbu9iZ2tncTomKJpWozHGxi7CbqmRVmXULZvqBvRl5Nvbm5guWryvFOfWGr8QA6MRYgK9WiMwWiM4/1rNDlKo6zqZEzLTGdlDjVDChzpsUcpHQE2wCchFplTYMMtGVoyZ8NjxJ46Oy0ncxsAco6HcwknIbsQAkkHp5oCUyqUKa91MinJz8NRcowxHyxaK3jPxXo2J/8ZXuS1JeGk9SglpoIqKlSr6xrD4SCpLC7/dGOMD1jy7hHhYsTld65kQ6GUgo8BdV1hd+MU9vb2cPr0aZw6dRr33ncv9nZ3cersaVhrMBqP4VL5Nk/K4eEhJhtjuOQRnEz8TKdTWFPhlVdewb/+1/8azz333Bp++ZWv/B7+4ud+HDs7O2sc0BACNjY28HM/93P47/67/zeip1PbeQ+jDZbLVWoP1mO1ADLljrEqxsH56rouq3tJCdcYY/bM5cRJ48CUPl7kTFFjz4PvJcM7/n3eFCe9Sj4oGC9jIy29Gu78LhcwMyxkEpA34HQ67bPfsddz4EOEoSbWHebfa1L/Qr4kBMELNtPCAlWU8c/LkJjfmw9VuZn5QOL5l+MisU7+fLlx+DNkMk1CKOvP2kNhOYxOY3Tr1g1sbO0A8FDR49bNa3j5hecwnR1TUZfrAHgSkIqK4JCQusxoFk3tIQZjDfb2TqVnoaYTtqKGB1ubE9x37z0YVgMcHR1jNqNCmPlshq7tUFU1qq5GWVd5rbA+DUc6dV3j6Og4qzxKRT+O5khXe4wb7zZwzmNQ0tdYApbzSDz+0hEAkHW52Ylgffu6rjEajdZwYI6EmEkkuc4nPXcJfzDkws5LRN8BXsoinMS/ZUGN1gRr1YMasH3/UV4vbLjlOjh5yFDE18NuvFfZkWpT9yCeA7mOCL4poTVFy0w1lo7cnVwfSNZ15/QpnJ1s40MfuoitrS2MxmNMxhOcO38Op/ZOoaorDAdDaKNzYil46jCzWMxx/do13Lx1C/fdey8A4N/+23+L2WyGn/uP/xK2t7fzYLGGCLMo/pd/88/xe7/3e5jPF2miSwyHNfb2TuHUqd1cRMOwBkuAdl2HT3360/j857+Aq+9cRYwhQypVVaJrHdrQ48sny1CZ1sM4IU8qY8mycIA9YP5bHiL8XrLzOC8ENuY9fKLyu7DHz/ga/y4vfl70/HvsVcVI0q3MjeWQk72GplnlBSnZI5wYlAk/pQDnOgyTVgrQNy7gKMV7atvlPSlIaoH1AevSmjmhRS5lZgLJA4sXL38ej5PcWJIjy2OZPdjY66fzZpLYoTTY/Dtyo7JRY2NirSVpUwBQATdv3cCZc+dR1TWOVyt873uvYP/mNfhuAde1AAJUCEnRr1fco8/qQw3+bK01NiYb6NoWoeiga4PSGgwGE9x76SL2dnegYqrMNEWmJbpFh7Zr4ILDqm2ywL9MyhFcViOEw/x1qSKptUFZ1hgNx3jowYfw6kvPw7kArS20IviT+mb2uQDpVWtN+tKMJ7NjEQLRZtlJ4z0j1wDfR+Yc5MHK/y8PibX5FlgyH+LslUvWGB/sck3yPLPDwvCbLBzSWmc2CXvgDH1aS5IPvH/Y8eP3kh43zwX9m6ij3rv87tIx/DNPTm5sbOCX/o+/BNQjFLbAqllhtVyiKErqbpO8xnevvotbN2/i9v4+Dg8OcOXtt3Ht6ruYTo9xcHCAwWCAX/qlX8LVq1fxhS98ARsbG/irf+2vZJxLqV5o/pVXXsGXvvQlAMBf+Is/Rk2KL34IZ8+ewd7eHnkKRQkf+k0oie7WWoyGQ/zMz/wM/sf/z/9ISZbCApqMozYa4+E4Gw1eEHLhSKPDRlxWC0peKy8QaaDZCPP3+T6y0osXLRsY/nxeiJPJJHfpYMPMYSEfOHyI8GKXmW1ekLJxQNu2OUJgg82LXi46akSRWoUZk1USM36fsEmXtKGjirmsl58zL0aBSyMZMd48/C4S2pDVp30Bjs0bU44vUyols4fHhA85vk4eJPI5T27uXrQIqYekRtc2uPru2xiNhrhy5R3cvnkVbbOACh0QA2IIlL9RQAwqK/wlhCSNRW+4Y4jo2i5VUjpsb00wHg2xuTnG6b09ciBchBpSXkQpbsRAHvp8PoPpyjVoL89fWgMnKZa8PwCVIsAKP/ADH8fXf/93QXruBYwpwAcN7wsWX+Kxk5GqbCrCnwn0jaD5551YH7wv+MDh52Wng9eDZKPw3yExvaRXzYc635+dGV4nSqkMU8moS74PRyUyPyNpfkpRTw3+DD6omDZsrcdstljb8723XeTnZAE6CQuxk/anXXcOlQC4df0GnCXDdeP6dbz99jtYrZa4du0aVqsVrl27hrZtcXh0hFa2oTcaPpBBGo1G2NzcxPe//33M53OcOnUK2vRVWZSEpN/7yEc+go997GN0omtNGrqBO8vQ/Vw6ubiYhk/QvOmMxac//Rn8y1/5VXSdh+8ctLbouhZVWa9R9ay1uWiD/2ZIggfWGJMrMBnTZmPCMAovGBke8uKS92DjI/FBGQ6yQZOHxEk4iC/eHIz9Sry3E/AURQ7IesD8HNbarEdhJHsgkljWoNawqaCHDwGAIADnHXzKjmvVb2p+xgw3xLj29SRJkjz/Ds75PH485vy7VVXlQ5OfjQ0sby6ZuOQDjj2mk961LGTir0lM8mS0EBWoViZ6aAXMpoe4/MaruHbtBoILiL6F1qmpQvBEV7RURRyjAXwvysQbKorx0Iokb++9dBGPPPwQFJC531oZaEssFsoTANYarFZLNG2D5apFt+oLPnisOBlYFFT9ys4IMy7y/GgLrQ3OnTuPDz/xJN658kZ6LsbNabzG43Eu6uJcCBs9HkOZh+nXW48bn4QieHw3Njagtc5UXQk1SNaHnD8HkJBXmlv2zHl/SaiMqbF8WPEl6y54DbCTIOEafhaCIQOca9fWKHv8BHusUFV9fQA7hnQo8J5Yr/5l5cA/c6jk+OgIv/QP/6+Ydtx7TWOxmGeWg/e06ZRSgAvQsZdBbZoGgxF5Ag899BCMMXjmmWegFJU1M+jPHmjbUoNa9gQVSIyIB5p+pmeDEC0L2fjyBubFub2zjU889RR+8zd+C4OqzjBK1zjU475sVS4kDu04WSgNA1OSJGQiecTSsLAnKT1HxqAZI8/Zb9UL78h7rXkZoa8wY0PGhwxj3OxZSJyYNwLPFf9h75rHfDabYZY88xhjLqap6xqLZLRDCJhMJlikDbaatTnqUUZBhd6zlhsubwbeJMlyk/fXUyFZdoDDbR4Lxln5/U5KekrPScJDPK4yRyD549JgA324y3hujBGda1EltoV3HsvFHIgBrl2COtOnRGQktgh56AY6asC/D8VLbNyiKDAeTrC9uYWPffRJjMdDHO0fpMQmUQcjNIwByoLaASoVYa2GWWlAGbSu5xDze/JaqSubYT8pocCerLGJ26wNPvLkR3D93bdR2DLVANTZAeH7ywYcci3ymMniGR5fdmYkti4NKz+XFK3iseFm0LLgTd6X/8iciozG2KByBK0UtR6Lthe24jXGNkSSDqTeTk9mMNn4Ar1oFCXMV9n2yFZ7ZLcCrCXpXH5/6c37kwf8H3PdcQEOABweHODo4BCu7eCaBr51mE9nQMI1m9UKi/kcrmtRWJslDT/8+GM5/OGNxvzaRx99NJ9YVVWmbCsnMAjvPjw6IgORNiMbKed8Vt7jAWXWB4eFIUSEzuMv/+X/OC9e7piidC8OxRtZYswMJ0j8mI04V2sydZCxOICKXCJijgCkZyw53cx7Zk9JNiyWnqY0REBvALnHIxs13kxd1+Xv8ViHEETnnTRmHIZ6j7KusFguMUu8bPZcjSGVM4aJOOxcMByUNmJVltT4N/YqadlGCW+G/l8zixmAytACKxbyocsHmPS6eF75nZTqtSok/ik/V4arEtOXf+ggEc8rnp/WrIVzxGnWOjkZ3lORWGKQRE+kbKUUfIwIpI0LpalhgbxCCIghibfVQ9RVieAdbt64ibZpobWC6zp4T7RJpRW0oSKmsiRq3GA4RFVR8m9YD6jvakqEtk2D1WKJtmkxn81QVxUU1psUhJQYdm2LmDD0c+cvwpYVbGFRFBZG91ou8/k8ryuGNySFL8NgYp2z0cvrFsjep9bEFV81KxweHmA6PU6sioiisBgOB6AOVA3x6JOnShW0DbqWxmk4HGIymUBrhdWKPXaPqmLdcJUP+uCZgqnWsHX28tkD5z+DARUuMXpGeHgHKkzqDwwZrfP6KpJezGg0xGhEFF9rzVouQrJ1Tjo6f9L1gbRKYDR828EgQhuD8/dcRF3V+MSPfAK/8cXfhDUGn/r0p9G1Lc6eO4ujwyMcHh3ib/2tv43/+3/9X+PZZ5/FhQsXsFgs8PLLL6NtWzz88MPQGmjbFaztu5UURYFmRQ0FirKAUqR85jqqjNPKYLlaYjQmidm2aWGsyWFn0zbwzqPUFVQ02Nncxc7WLq5du4bNzXHCjNUa95nZGlxYwoUu7BlLHup8Psd4PIZzLidEmd9aFAWGA2JtMD1PcqbZK2ldh6BIBjQF5Fh1qbQWJB9A/Ri7DJfwBpH4dIwxS+2ygWUjzs+27v0DbesQI6C0RQRwNJ0DSqEYDtEKgfrReIzNrU20TYsqhXPD8Rj7B/tZgzrGCN95cFkJb2z2hOVmJuOmEvagElYYgUgMjeD9ezxojtpkGAys0/v4j8S4eZxPht0SH+croTaEw4OU+0LaREZr6GhSF3oFZQgCcY70rVWWAabKwxgjIhRc0tQKqq874n2pEss7eIXhcAyFgFvXr+OF578LxIjxaAznA2zrYGyAMtScGEajHA7RtS1UAMoasMaj0B2KdKA459G0S4QiaWGUHmo8hFaA9/R9alhRIvgAE23qBlNhsnUKZy5cRIxLBNVguepgTJ0jFYbfeI+yJ8kHvby8p0KVYeJfy96e1hjEYHq6pKf2bnRoJrqeJq75YrlA17YwxkIh/U4MsFahritUFdEnnWvRtiTjXJa9xonWtM6spYMiTXN2UPhdZDRLr+KhtUJRaJQl7eOm6XIOQOZiGLtfpcKn5XKGsqxQliyGBVRVia2tTYQQMnNL5lc4UrqT6wOxSjwi/je/+L/Fgw8+iHfeeQePPPooXnv1VVy69xK+8Gv/Bp/61KfwEz/xH2A8HuPKlSuo6xr//t//ezz99NM5qfH444+jaZrsyW5sTERxRMRq1SSansZw2KuEeRdgTYGmIU99sVpiNpthsVhha2sTVTXIodg8wSpHh0e4vH8FN6/fxPPPP49bt26h6zocHBzkUObwkLLt3FCXQxs+FReLBSaTSerd12RRJoaIZEJGJgg5ScIVh7xI2HtRKml9J6naEFMSMGHYMREQptMpeVepypELIfhZZUJK8tDZM2Wjxxj60dFRHu9F4ou3XQtbWDRtm0WqZPTQdR3G4zGWiwWKlDAtBebOfTK5go8NqoR6+kW6vq5kEi2m3ottwvokk4QjNg5jOaTN+Dl67FOG5ZyIk1IDEiKS10l8+z33Nv3zyHwFORkkIkWMGqKqhRDgQvLwiGIiDHiS5I3A7u4eFXCEgOs3b8K8/Aruu+8+bGxsouk6VDEiuvWGtFVdkwOjDYJxMHq9O1OIlPSMKTHaQ3EJUlBUXOM6B5243REKxla4dO/9ePvtV7BcrVDYGsMhedUMkcixYeiNYUWZdzDGoEhRFB+6UgWQxlK2iEtkoxgTlJCE3LJD0nPQyaASZjydHueDmOdaCsGpxIzK0F+M8M7DhJ6RwnuYi5W8p8/pIz7+dwCw3oWebRs3NeF3a9sGzJfngh727lltUI4LHwB3ct2x4Xbew8WAe+6/F1fefQdnz53F8WyK7zz/HFwMWCyW+OoffBWPPfoY7rl0Cc45PP3009jY2MDx0TF2d3dRliXOnTuHm7duoW1bbG5u4sKFiymxFqGUyeGGcw4KqRw10IYurMVwOMoCM6+9+hreePNNfPjxx7FYLvDKK6/gxvUbODo6gtYaV69exXK6xHw2z9KNdU1FBavVKtPwpHHlhcfUJOZsc7MC/trx8XEOsXkzcaKPJ4KNp1K97sl8Pic833uUyZPh0IqNinMOg80aKlUgStyaG+nywmEvmmEQLh7SWucekfyMslmDxMyd85Ac67qucXBwkGVmY1jnTzddh6h63FzqFJ+EhU5u9PcLBdlwc3UsX7wRmSsLIEcunMzh35fJWgmv8Jyy0eODk++zdsVI1bmqFwY7+bzSk+f5NcagTslfALAJl2dYrnu/8Ffxc1ucOnUK3kcYq+B8xP7+EZS6gosXA3Z3d9E0Se8EvUEEJM0tGSPfa4MwnKjWojybG5o0bYuyGqTvOWilYcsSIbY4ffoMbty8ghCAtiWIRHrcEsaSuQKZlOT55AbUDLFw0hBAUqnEWrJSRk48nieT8fw5/EySt81zKtcJ04SdcygC0TRZq4Sflddaj8MDnH/hcZd4NO+94XCYe8PyZ8qmC7ynrKXG22xzZNKW15Pkxf9p1wfyuEfjEba2twGl8Obly/jUpz6FjS2qGhoPRnjkkUdw4dwFrOZLlKbE7Ru3sbW1hUcfeRS/+tyz2Nvbw2QywVe+8hU45/Dggw+iLAnUXy4XaNsV0Qu7FkVRoVmlAphlixvXr2P/4ADXrl3Dq9//Pg4OD3H58mU45/Ar//MvZ2MYEq6ujYHrOgxrSkpkg5loeHLT8sTLzcpFK+yxLZfLDEesVisMBoPccYbxM2NMNupyEfIml4aT4Q7eWLw4+G/nHIxQouNJlgU/cqGyR89JXX4fudFJn7nHKBEjGt5Inqpc5QYhRk3MXrdWCk3bomkbDFJRxXg8zu8uf1fiy7zZZB6Br5NeLeHuTcb+pLfIY81et+T18jvzZuR3lvg4bxb+Of5+HnelcjL2ZFJXeuP8eZKnrzUp/IXgSc8leXFQIIiFnF2BdKfDqiA4DMogRA3ngKZ1OJ7O8e7Vm9CmRFGW0Nog6j5akInGsiphxcZnJhGPD3v2OmHlq2aFtuugtIGx9Ix1SQ5NRIft3T2Mxptouxlc2wDR5EYaMi/AxpnXOBtTADkS3N7exmw2w+Hh4VpEwDaFEnU9DZaTfDIxyJeMcBh6yUU16fCX8E1RFPngyJRQRRAd7cme6860PDKyRnj9PeuL78O8bUmFlGMjJTF47XFyld+f1w6PAzt+d3p9oMrJGIl+c/PmTdx///3QSuH46AjuzDl88pOfhFYKi/kCzz/3HK7fuI4XX3wJ8/kcv/Eb/x6ta/EzP/Mz6Lou0wbPnTuHwWCA+XwOIKbNGnF8PMVv/ua/xrWr17F/ex/HB8c4OjqEUhrz2QxaYKBIg+0TSbZMTVetIeGrtm1JgCqFTux9sBfBlDt5UnNjXp6AEEL2PnlymqbJ1YfMyJhOpxmKYEYEez/MlsgkftWzNqRnwZPqOkeJLeGpShaExMslTxVA9vqloeSNwckY5xy6lATsnEMEqQLKzxgOh6irGsfTKYn9j0bkQToHN51muIhDPPbwJQYtcWfe4NH30Q1vYt48RamyRgQxHvpydskLlnxzeXjxBpAsg5OHHOOxJyMAObfAukTnSfxWHgBaEy01Jiik8w4u9PCBtha605kTL8fCWovRaIIQFTz1FIb3gPMRi8UK+/tHmExGKIoBrOolE9iA50MsxJw8ZroqGxllNIqSNawtmlWDyFGOUvAhwJTUfzJG0jPZ2NzBwUGHoi5RCC/zJPNBn1ij0mFgZ4VhUY7A+sOcjWffM3UwGGRhNfaS+XtyHhii4TUtDxO5P1gWQTKQADbYIR/o3vscjdPh16EoTIbeJFOG1waTHSQsx2Mh/1/+jFyrPJ78TDxud3J9oORkt2rwO1/8Erz3+O3f+E1sbGzg9ddfx/PPPIdmSYPzO1/6cu8BOYfd3V3MmzkiAu677z4sFgu89NJL8N7jsccfR9t2qOoaZWmxWFBXmO9973v4tV/7X+BdRLNqoHwffnhPkpOu80nLmBaDVQpd26GLSaK0cVBaoyxsNpzcqowXW+aNo5f85NORDxSGOKbTKZRSWVaVJ5jDIMZ6+d05sckGdTKZ4ODgIIdvbUeyt1B9Ka7ECJ0jw82LgCdbJimZZy4xRglf8LOxngdvejbmVVnSprUGTuDybHidc1iuVjBao7AW89kM1loM6gECYj68uq7LjCHJfmGjJz3qIP5/7evJuypTroJhkJO4qcSneROwoZbeL69ZflfpoZ80wnzJ+8uDgu/1fnuC59cYg1LrhKUmRweA0gplVSL6DquFYFiEAO88ihHhsc5HhOhhTIBxAV3n0RUB09kCN2/exqA+k9+Nm3UzN5+NAo8VJ8rqukbTElUTWsO7gBB8avlXQStKeBalpWeMEUpbGFtiPNnEbHaMwkTSXAFyvQJ78RJSkmPNfy+XS8wT7st5GAlLMK2R2SksNcy/y1GmMSbnXGQkwePBlD7J4+eDX+p4p0nOUjkyuchibAxH0ryWa/uGDxZZI8DQJa8d/pujAh4POUd8qJxce9LJ+dOuD6QOqELEl37rt+mhmxaTjQliaohrtSVqlGeeLdA4j4ODQ2irMNoY4rHHHsPBwQFu374NYwwefOABlGVBFWaRqWsOb775JgBKKBS2hDEa3iUxJCisliuUKZRerZr0sx6j0SglySLqVIjCLAvejHzqn1x0bOh40S+XS+r/l7jD1Hg3rC1eALksnz1rXmD8NTl5ax53jAB6b056ioPBgISa0HcX4WdlOVpeADLh05epK2xvb2eaHLddk15RTHASza2C9w4qrnss/cImT2A0GuHw6AhFVaJIvR+5JZsc05PetGSJsKKaXLi8qZihw3Q7fl6pdcHP3ie31rWb2ahI/JA3MB+Af2zmno2t6ttVcdSUE6jisJFYrNUEOQQIyAkRPkZUacO36TDKe0orTCYTOvyUgQ9A5zysD3A+wIeIznkcHh2hrjVOndrLhzGPHzktOvdd5efhNVVXFaICKTc68jonGxPU9QBaW3hEaEvUWNc6FGUBk6IAbQqE2EILL1Aeovw375uT0hHee/jk3LBBYiPWOVLtK0ubVf96VkZvvHj982fx9+T64e9rrXONxdo4i7XIB6oPAUFEofx77LRovQ7ncfTA0SU7K/xOvK7YmZNrUzpW/K5MbGAjXxQFyqpEs/ozVgcsqwo7O1s4fOcalNKoygJd0xL9y3sEpdE0Law1pCwXAvF6UxZ7d3cXp0+fxnPPPYvlcoFLl+7B3t4OCPjT6DoHYwq4zuON19+Abz00NHE1bQ3XkXdsrEURgdVy1W9aa1CVFWbTWb94WvJu2q6DLXqdAll+y0k/mTDgpOJgMMD+/v5a1peTEAAyp3u1WmVdEIZj+IAoCu6VR5xrIMIYjaIYEIMClPTl55EJyohIqnlNA6M1ZgnaIaEsghAAZJydFyXzoLmHXlEU2N/fB5fi84brug42UtLXCwPbti288300khe6BxxQ1RVcCGhTEpSNJuu58OLmQ0TifP1F5DulmB7HxTcNGS5D0r10oHRwHVEBg6Lnpb6mxIpgloBLh4I1RBvl5FwPQ2koVeTfDyH0FEB5RdGHUmiy9AcZGxH2uOkuNlLor5GSaiHR4QJglUZpC9iiAELCbFkFQFNFsCoBhdRt3Xdoug6F61CEgKbzuL1/CFsU2NzYRF1b+tzo+25ECui8T0yGVLgU6L2N0jA+EmRoS+zt7sFYC+88Ou/I+0ySzDrxtouqgCkNfJOqQSPJ+/Kzx0ThCyFiPBpha2sLtqAGxOzYeO+hTaJfRvLcA2I+2CReTUa7EUk7Q7TABB+smiW0VihKm6EFBZIhMLZvJ9ZXLMdE/ZMRSRo3MOOHcycVVqtepoKxbRnJjUaj7GHLqJK1RhhuJQNN+aOisMRE8p54+Cp1PFKAtRptG2GMgrUak8mInJH3K9Z6n+uODfdgMMDHPv5RXL5+Iy9W5xyi45Y9GnU9TjoWDmVpEQKFxs53+ORTTwEIePXV7yNGj/vvvw8bG5Tsm87mcD5gNBphejzF1bevInogdB6VLRBjgC1ITnG1SoJSVgvvKqBzLbRRgEqSlc7nBc1MCeZZ82JgiANAZgfwPSUbxDmH0WiUjX+MVPXITBP2tJlpwtQ97x2ahgzgYFBnQ0acZA2jzVonF5nAI9w+QkcyDkVJiz9qBRcjdEoWsvwsex0cuvHzyRJ1rXXuOMTViUrrVDlnsnyAAoBAPHJ+r+FwiDZ5rBw9SCxYStmyN8zRhmQI0O8TiwUnTCcZvA5dkJ18gKA1gBLaKNiqRAip5lIh0yiVNVCeDkbvOyhFnewBxmEjiop6eQLIG5xzDTGF0DJK4J9jj1JrpgNyGT8V4wCAdwGVKVBoi+hCVj2MCOgaB6sNBqMxTFglRgmRA32MOJ7OsLUzgVaACiF31+k6RwVmVmPZONy6fYyiGGA4GMFoQEUFrYl3HoKHCx4+UiMLH+lgCj4iOjLKvnWoiwrGWqyaBjARMWqEEBG8R1WWaJolIiLKRHNb+Aax69Y8XaMNjFHoAjGOuPp5NpvBdV1y2IDOdbT/rIZNh3dwEQGBjHckT3i5XIloUcOYlAdARFkyewfJO9UYjajgZjwc5Si9aVbZYXFdQ2sgGqJDxgDSFu9FvkzaX7T+Aoyx6R2JUWJtlaM83peyYprhN4bUOFJXSiEyXdES8gAEdC1h9WVJDSyC7xAD5dcKq+G6BsvlKlfL/mnXHRtuaw0eeOABWPu7tCijgtEKjSNPZ7lcrunaMofZahLPf+TRR3E8nVFjgxDwIz/yI3CeQqa6rrFKBvDVV1/FfEZwAEEfJGTF/GkJdXAozN4ve0fsJfNz8OnPC08qiPHPcNjPRhfo4RtbWMxms7UkAoBMO+TP7Hv+sQRlz/dm48BGoKpqNF2HerKB+WKe3yl6YlIoTQUfAetYcS7FB2AKynT3jZJ7Oh4X/jDuzGEoPwOPlzEGMfFcmZGwXC0zNs4ZdT7wuOMNM2hkiTLPjzyAJIxirU1FLH/8xdn8/t8pv9K1dMiFVIGp11tiAYCGoZ6Zvse4ZfIMysCH9SQvXzLBJhksjL2HEFPSVGUMG1hPsnKklSUMACAi5Q0UbGEwHm5ApwOb15frhPZKFDKigXsbalhbYDql6KosSmxsjHrsuSBGFTshOkW85MERY4hFTpRSiF2vkU1j1K/rkPa2tQWGwzGWs0NARB3GGGxsbGSIcLVoMJ0eYzabwlqqhvQpCWu0RtOtAFjYqqL8RiqeKQuLsigRQy9wFkLIWvpAhDbI1bQMIW5vb2N3dxebm5sYD8mZOjw8xI0bN3B8fLzGEPGRDgkoajRellVO0mpjYGGTUzVIEE7q4H6ipZhM7nNSVKoBsh1iCIUKstxaPk2uLYaLuFaE82q8/+7k+gCsEuAjH/0o9k6dwrV3rwKR+NWUWHFZLosxXNYGcM5h99Qu7rvvPnzvpZdw8+ZNDAYD3HPPPWjbDqvVEmWZdHmNweXLl3Ot/8HBQbqPR9OEXBBDz9O3BOJuNbwRT7IY2KDIUmcmw3OykDcRF6sw5MITxT/D32MDySctURqX+T5kwKocpkmNb3puomitlksgRNRllbHvwlqwBC3Qe4eyIMU5D9ct1hYOQzwMtxBbB2uesUyerpomFd9QGbVklbjYi3fxu3NYywqBfPE8s9E4aRDZgJ5MyPzxa+29vx8CsV4sNFU3dj2WnWl5QA61Je0yF5+oCOd5/Nx78GqZ8OSN2POSPVgqIIS+OEQl66yFfALfky/CeMlT9wVTwCyUMpjPl7h69RrGm3uwRQktNrZ3UlOGMPTDoymsvQFjzmE8Gq6Nj8yF8B5wziF2aa+k8SqKAgO1LkcMRHSdA5f062BQVwMYYxGDyaXtDNex8xNTG0HCopHzRXRQElQzHNQCPnMZQozRo3NEobTWwNgyJ/+GwyE2NyfY2dnGZDLJCczJZJJ1UWKIcClZv7Gxga7rsi0AgADavwoh044ZXqmrCivf5AOX54mjbF5b7OwAyOwYdkw4EcxrpU+sLhBSQnY4HOZiG/49a3Wur5BCXTIR/6ddd2y4gYjtrS08cP/9uPruuyiswXKxgo+Ef3e+lyjlh+CHevzxxzGZTPDaa6+h6zo88sgjOHX6NIxJp3wyiCFEfPe7L+RkBhka5Jfnr0nRF9oEJuNMsnSVw3fpmcmwnQ0KG0OuLuTMNU8Sb36GS/g+krFBGHafHTZJn1pGBAzPMOVMK3qu4WCApm2BGFGVJSKAtuug7bqeN4D8XkEpVGW11p2Dn5sTOvz8m5ubuHnz5lrTYOaVVnWNVbOCsiaX1vN7MIWRIRbG8aUSIxdLcXcgecnDTRp3GTWtY9/vs+rE92MI6FruExkRFKCURvSpZx8Uol1PJK7h3FbDoGfxvF9xEB9u3lP5vc7JVqBpG1D5tILShP8T9dTCp7Z5kgEkx4BK4YGuc0DKRYxGE5RFz6KoInVj5/Xl0p7yAfABMGUB5zrcunUAoy0unD+HuiqhVJ8ck+9DOH5/GDnvYVItQFSSUkfNj8lIAYWtEKPHoB5ja3MbrumV/VarFfb393uDk0r8CRr1aW+ybrrBYFDBGI2uo2ikKgu0bRpfpVCWBarJGJubm9jY2MBkMsFoNMLOzg7quiLygpgrtisAcqcljgJktD2bzRBVRF1XaNsOMSo07Qq6a1Ejda7v+qiL16T8m8gPFIXzGpawJh9GMgnJkabktPNhyfdYJSkPdiDYRnGu6E6uD2C4aWF86lOfwu9/5ffR+iS+73p9Cabc8SZnT+gTTz2FxWKB5557DlVV4YknnkgLwcHaAs55mLLEwcFtvPvuu7TxkmFkgRgO+fl047+lR8sbR4b2HObwppSwyEkPi7u7MD7Lm5A9L24pJkMdnmg2nJwAtXaw5uHu7OzkknutWU3NZtZL13XwvOlCgDUGnVis0sjQ1/oMtmRYMG0yBOoAtFqtMJ1O8xxyOMceMBklDWogq9NYAWWZWAJYlwJlD41hGF4X8qBgaIifVxpGYwyg+sPv/Wh2f+IVPELkajYAUIjJsCql0XW9d8/v1ysMUpUoHxrSqMcYEb1H1Bp1wv+5bD1XtxqFxWKOjY0NFCzDqQyxt1UqMRfvzfel96TN3SoPTpRtbm3hw49/BBcu3otV51MewkKnue3aDl3RkbF1NYpSQ+kCne+oHV+I2NvdwebmANb2CpJ8cGdPMqax0Dono/lgpoa1Q0pAJ4y5qgaICKjrMTY2t3Bwc5aNGFNrM5yEiEFdoawojxKih7FUil+WBYL3WLapUGg0QlXWGA0HKIsS48kY48kE29tb2NjYwGAwzBx+ckK6vAdPRnRaa1hjYHXfg5K93sFggIPDAzhPIl2z2Ryz2RwKgWR2gdxxi9cIv5Nkn3hPTDVZV5DXSlyn//F+aJoG1pBgHlML2dFk+zUaDd4jdCaZMXdyfaAu71euXMHjjz+Oc+fP4frVG4Ay0KAEoOyOwickVy49/PDDOD4+xuXLlxGCx8c+9jG4rkNRWsRIiY/FYoHvfve7mE6p6jDEmLPYs9kMSiVtDyGuxIk4/jz2jHlgOeHIBQmcbefwXxZxZLzR9Z1VpMfN/8+QhYReOFHHXngIAbPZDEXRJztZ+Y/5qk3TwLUeg6qC7zpURYHg+DDq0IpQVzIbMk5GQGsOk/mg5IVkrc26yWxsGc7JCyUtWGMNNre38daVt9bw3xhJ04E1Kk6fPp0PARmW87jxoj6JH6/dE/F9f+bOr5iVBfl+WaSa4uA1rro83GPq5CKldvOfwPodZNjrul5jphRFAaVJsnXVrLC5tQFmCxGeS1x4eZCub0hKriv08xoCsLOzi9OnTuPG/gGWq4bU8bSCLasMkRlboHMezjEMR97jrdsH8M4jhA1MJgSRDYfDzNao6xrBB/iW+iy2ohhFaZUMcQMfHKwu4RWxRKylPq9VNQDCBMfWohMFLxw10nouME785xhDzot479A2hGVvbmxgMBhgc3MTu7u7mEwm1GdxNForPQeQE/rSsZIwlsTay2K9+bAsMiurAtP5FPP5AlVKrhZFAVsSLMQ/K+E2Xs9sZAHS6pGQRj93Ia8tdtA4Iq3KAmVZrOXc9vf3szPFCqhSOZE/+/Dw8I52wR0b7uVyieeefx4//bM/j0996lP4F7/8L1GWxI9W0NlAstdpkpfy0EMP4ezZs/jCv/kCVqsVzp8/h3vuuSf9nqy8Ap759rexXCzhukSjSgukbd2aNoVs9cVGSnIlJYTC2WA2eL0kbN91RWKw7GHx+/Cml/0gpRAVQNgXe7LMMDk6OsJ4vPWe4hCe+LZtYUAZcaVI47lI9DujDQqt4eJ6uH+SF82YLo83vztDG+PxOPcGjbEvmGFlssKSNkiIEbdu3cweB4d9bOjZAPK9+H0lJMN4KbBe+JINbPrD3vaf5SWhpJMePP9baw1jS0QIGEF628lwa2PQtA1GwxEJayWISyVNjcEgQURNg7Nnz+DmTTqUSRa153afDJcB8kKt1VmPxTmHN954Aw888Ag2NzcR4iHaxlFnqUjvVbg+N1IUJWqVjBU0mqbDzVu30bUzXPzQ2bzO2aiQgqGHQdLbZsjQdSkh3SeQy0ID8IkNw12TKviuwHg0xu3VbaTBgtak7meLAtb2mLrW1CGHW5Ztbmzg9N4utrY2SSitHmTqXow9HbZp+lqAfo0nWh3Ueww2AFhjUwFeT4XlCN9ai6ouMRjWmA/nOEoQaNt0CJYkdo0hHfMYubiGojJbWPiUJGQaMUEgPcWQqX1Kq0QCaLBYrjAajjAY1Nlp5GfmpDUV+CDveZv2j0225oPkge48ORkivvzlr+DjP/Jj+PgPfwKf/8K/QQgeMfVeiy4QD9uTQTSFATTwg5/4OHz0eOY730FExCc++RQGowHapkXnHSKA0hZYLRq8+vKrqIsaHRzm8yVgFGLsKXm8Kdiz5I3HEAeXx3I4J5MM/LPsNcuQiD2qjAWmzHSfZOwFpHp4QWVq3dbWVmadcOJub28XTdMnNuQBw8bWeYdqQCp7piAohvH8siiwaPqmr/y7vQEnTzN4j9C1sCEAWkG1DbRSycB0cK5NtDKGL2JaXCmx6onLG7pey8MFj4CIg6NDTMYTAOglA0B6HhyGc7TB79k5RzQ9xIQ9U3We0lTlitjjrjKiueNLCQKhov9E/vr7ePDsJZHHTRl/Yvf63Ag5Bg/oJCSiIrQCVs0Cg+E2PvrIk3j11VcxqGvqwtS1GGxuwRqDo4NDXDx/ISXUXaKxEfQUPPUF5gYTITg4p6AcHxQRy+UCb115A1feeRNnLt6Puh7Ad1O41QIqODgV4EqDzig4YxAKi2AAXRjYgsrsXfA4nHpUN49x9kyNwgYYRVRaaJ/ayBmCWwpLJIKGuMjWGFhTklQqkuOiPYgeZwAf4GMBXW0h4JiS4XBQ8NA2RVw+IGhgYzLB5uYmNje3MJmMsbGxgeFwiEHC7Amr91hyf0eQAFaAPETJlpBudS/LCmDNSQASf1vrROekxG9ESJKwGkM7QGUL1EUNFYDoHNqywbK06BQwHhboVDKwymZtI60UYCLq2pJuUrukA11FUEqKDvEYgLq0SX5DYTSoYQ3gXYuImLRjiKpsrcFwOEiFgB5NM4fSBhsbm2gzREat2O4sNfkBtUreeOMNfPVrX8NP/tRP4WM/+AP4+te/TkY0ePjWJfGhAZRWWKyW2NjcwEd/4KO4dfsW3njjDRhj8Mgjj8A5nzZaymw3Hq99/3XcvHYTMYCE5BWJ13dtj0VxVpdPZsYuGZ7gSWY4ggtC2FuWp7ZMKPC/OZkZY8y0QD49JW4omSRFKjpgHLSHbojrPJ1O89ekKE5ZlvDawwcqUuDwNYJOdW0NCltkLE7i2TLBWhQFOudgi4ISmoblUH3ieFOYOBwOsgg8NY/tKw61MVg2qxyJAKSeZixJvm5sbGAxX2A4oMIh5wOKkjxw9vJYXKuwFk2X2jql/8aYCmcCC+HTJRkYJ7Hh912D+Rff8z/iJ05wCdMVQkB0DtC9VgZ16iYdaAAwtoAxFHUQVNLg2rWreOyxR/HOO+8gdA7DAbGlWu+xSiXd586exVtX3kEESylQb9MQQw6Ll8sVsSBS1/e2I+3o2SzihRefx6WHPoxmuYJrG7TeIbgWzUrDlBbWGHhboGsLFKVBWVGRW+djYk543Lp1gOGQ8NjoIzqkHpYqwliLAOpSz3TMEALqqobWBhuTLQBIsEvqNK8VnIuIysKUIxTlEL5coS4qDGqL0cYY440JhvUI29vb2Nraym382NkJIWCZilUk/MZ1IEb34lQSDpEVxzLZexLicn5dc4b3NECCWsZqmCFxyEeDCovFDNeHNaZa48zpPXSqRZeqdWezGcqqSI5dRF0RtbkFOXUMbxJrhesTHELwqMpefrrrkiZKWcJaA4Dh15CZM4gOtqQWjV0geQOrFSyAwvxZe9yJWvMHf/AH+OxnP4uf/MmfxDPPPIPpdAprSlhtYYsCy8US9ZDwwQceeACnTp/C5z//eezv7+Pc+bP48Ic/nCeIStot2jbgG9/4Bo6Pj0ANEyKoNdoCWhl0rjeoHJJJMSMODZkaxwwTXhBSdYsxXzbk7MEyLigFY9iDZyiANzx/HuPd/Jl1XYu+cTHzpzlTXNc1NjY28sHDyU5+do4sYoyYz+aIQE7EZmz7BKbMG2WZdL0Zn42aknIM53D1JKm8USVcSm3DB5/flxN3Wpu8qUjVkA7Juh5Qf8nQN06W4yMTfxIqYeiE7bL0tv//w7rf51JKdNZJhl4cCBERCDFz42UySiYrGYN1zuHw8BDj8Rg729s4uL2fmxIztrm/v4+9vT1sbm7i9v7B+p5JczaZTADovOmRGDAc9l+7+i5u376GU7unEVwHhIDlagnXNFALA6MtqqKCcy28rxAjoJSBtSVi1wHKY7lqcHR0jK2NDZSFhVWEFxutAR3gQ5fzMHyNRiMMQsDm5mYmFAAQlYAm0Sob7OzsYve+i9jdHGJjY4TheEjNHSLWjCz/yY5U7OE3iSkDvaiXNL6SFqcUkvFDgk1ihjZCCEDwWc0xr6FI0R0XU2lN0WdRaIzHQ8zHYyyMxpnTZ2AHCsvVEvu3b6OydNA2TYOoe61x3usyb8LvwslQtkvsOQ8GgzVUgMdEwpauC2gWM0AZlEUBEwNKYxC6O1MI/ACsEjKKr7zyCl544QU88cQT+NSnPoUvfvGLKKyFW3l4z3gtGbyPf/zjmM1m+M4z30GMEU98+MO5kGY4HPSCMd7ju999PmdhyYvuPVcuw6UJpIlkQ7U+0T2GzWE/G/CM5aWQnw8ANpoSl2LaDnvR8nMA5M9QSmWPnkn8VB1Vkn6L1blLDi/Y4+PjTA/kw0MaTC426PwSVeJ299TInp/MxoYXuyTvxxDQOr+WMC7LMrNByHugAhHnSEgf6FkeUSQ+K4ZuUneioiwxPzrMhps9bsbxuOWLpEm9HxySWQknPGzpNb13BVK15J+4SsXvvuf/tcqFL/w5SilETY2QmY7VF2TQeF65cgXnzp3DqVOncsKX2UsAFWKdOXsei+UqV9UBfV/H7e1t1PUQ169fh7Uq76XsFLgO33r6D/HTP/kfYbI5gfMeq65D9A7taoml1qiKMjWvaGCbAnU9yBTamOpaDg6OMBqNYKzGYFASD1x5VLaCUuuwEYD0nj0FUiZznXMIMWS++Zkz5/DEo/ehMhFKeXS+Q9O1Cf/tIcE1o6x0bgHH2LOcF2NMXntsCwAJiyD3J1VK5YrSkHISJJlNlcWS/qkjFf2FSElZWmvkyBD9koyrrpJtCSHLNCOSOJ7z/Z7sOesxO2m8TmQ7Q6kbzzZGkh3YBhmdwClFOYi6qBBdA+0DmuX8T17g6bpjwz0ej/Hhxx7B08+/hC/+5u/gkYcex8/+h38ZX//qN7CYrRC9glElbEltemJweOiBR/HOlWt4/bXLsLrCD37sh9EsOoQILKYrRNDmOLh5gJvX91HaAWKRhMW1JRA/IIebPsQsplOmAhqVqr7gFbS1MLZACBE+OFRllXBZoCjIc4w+wrURWhuoaKAitaEKIWJQ1Ql/I6ggRqBOIkPOOfgutSmyFggKwZPxMsrAu4CiSJxRr7E52aaMfedR2BpNs0qfaaGixWS0mdgnc5QlVdQtlysEp4CgMawnWDUtjCoxGtTwaSFpaLSdw6Aa0b+jgWsDrE5tqFDAdRGjagDfJR31wQain6FrOmhVwKgShdEoTIloNObLJZoFlQhbTdrPk9EEpakRnMJkuIku5QzalcOgpqRdVQxyuTKChooaKgBGGejoUWgDk5JXCIZ0QFIbKeccVPTEH4+cXVcMW+dLQaEe1GljVOh86hAUKFRmhTsAiRdPUISxFs1qBZuKPbq2gy0LdJ5odrSeKFdgjYI1BUYjkrGFAowGUNDGAiJuXruFYTHE1sYulAJu3rhJvx8jXIi4dWMfu9uncf3aNXh4lGVNUElRolt5IGiUpkZVmGSMNKxOapJdwLW338bzz30HH/vYJ+DGQPAas9kx4D26VYuFWaAsalhbwqgWVlUo6xIGgA+E8zcrj1s3D1CXA1htCbIxtD6MobkNIVAputc5UdssWrjGQ0fqMalqk8TMAB+B6DVW8w7t0iMohxA4P0WQB8NuRWEzrTBGBWUMEDUMDLQylCTVGkaxoQXtQaWgYiQxK6+BYKC0JWgtxkRJ9fl3gAgVkamqxLBKZiB4BNV3rCESREooamp9RlHQGEE3iMFjPBpiUJeoKyo/R4yYLXt9bnbqpFIhR9HT6XSNzcIkAKksKcWnSEDOQSdkIaADneUK6FqEE0Jkf9yl4h3Gqcu//1P4/Lv/PQ6mAdZY7OzuQCmFWzdvpVNGpci795j2Tp1CjAG3b9+GUgq7u7s5rOKwI3gPHwIO9vfBAjBrp3cKffjfKtEP+aKwMb0Me6BIWHEOhVPYHkngJv10Pwj5f+hniConBklRkoE+MH0tlT7zF2V2O/9/iPk+kh0iIQSGZXMIGfteh+Hkz9KbIATqu5nwDvQNsVLIj3VtXxmKAutcWIZhHOPmke7G78BholYqQxHEDkkecH4PRrSx9rz4Y/7NydX4vt8TY4/+ECUO7gkcW/6s4vVA35f5C4DmLKRWXjHyqNF64Qgg3+TEc/F48eblsJjXMBQl1jrXJS+vX5vEk09MHd3iFx/5e3jl8Efw+1f/Rj9nilgGw+EIAIjGJ+QBtNKJOmdSz1Wd1iAbLTKiSlEjAIbr+N14shg+4jnkw5IjEd4nLDxGdEuCKKpEcUOMa2uuH/+82PO9T36Pv/J+My7XK/18XPvh9/vM/t1P3lkJqmj/3W5hYeuIz/yf3kLQi9ySMAQS+FrMFzg8PsLt/Slm82WeN44YGYrkeg9ZDCglNBi2zQwyQxIR1lo0y4YcRlsg+gCrIw6uX8X84BZKo/D3/qt/+j6js37deQccG3Hpoy2KG1N873vfw41rwEc/+lHce7HCd59/HsdHUzKWNGZ49NFHceq8wXPPPovbzW3s7e5h5/7HqBINRICnk6zFi999EQdHh8nA9K3s+d9mDbBnQ8bNWftJoywuGyia+BiRq8OAdWlOY8jThqJye6nfQJutDy8JOiHBKzJqZEApHObmpBbeu/w8znWwmf5ERrBNyYsYA7rO5efqT2WVn6lLiojO9wp7UVCvfKJUKmH0wfibYc4y6Wc75zGdTvP70P0IB/UhoO06MhSRdBwQI7Z3dtDOm5SAqdB2HeqyIsZIGkdS8UN/2CT2ADMn+Oo3Jf07xJALVkIIYlOqNbOceblJO/wkRq51jyUyNBYD4faj0RiL+Zw2rlJYrRr4QEyLmO7BuQ0qJiGmg1I9pZHCcD7UUnVijNjc2sLx8RGAvjuKjQWatiWlOWGsCf4iyMpqBxeWuLl8Ey/sfwnM9IEOULpANZjgsUefgFKaEpXNEl3XkvyqtqjqAeqqRlnWKKsKhvtgBoZBPLwCRsMhJpMxtNEJcuhZPF0ncxkabdtBJeYUl9yHyHkgosx17RJlZbE5GdHzKjakMR1OfX6B55MPLJP2Cx8CeQ/z0SnWToy9rrhiewKxTiTUlb5HRp4T3Wm9QR4A6WBWBkCLnYcalLVGCBYYDKABkocIdDjtbG1jMNjE/uFRbo7C9Fg+gBhKk7kcyVYDergEwFqJu+scogdsVJgeHuLy66/i+ltv4OF7L2Jzbwd3ct2x4S7iAX5k8XfRVh0+9xCVNo/1GMorfPLSPOtl0+hRmXq5KvHxCzO4M8TAGHZDqKShwiFPiBGfuW8Bd9H1Lpw4bHk23ssfiHjPV0/+Hv9s9gBO3rf/d2Y2ZFcp/UD2JHsRIOkFS2ZEfw+6b/6+jAjC+vfXvieiBXl/cUvwYSRf9X2GK3veXBGZ2SjJC+FkHdkN9vLlHVnbJKTDlJ6dMMveWz45YTyv73Wi3zsx/LP9veSnY21s3hf3PrEu8nOm+2ptELLX2jck5qhCpXto3vh5qnpvLXtt6L1BAOKQRnIg+jmUmzciRQoi4tkqNV4++Co+//pvJs/fw8climoCW23jLz3513DpQ/fCreZYTA9wPD3EbNUgQGNjso3t7T1sbu1ic2sXg+EIGjFVQHp418AgoNqcYPPSPdjcGGe1PonRZkGsooD3EbPZUS4m4iiMGi7UsIXG0e1rqAvggYfvhTER2moEADF20HpdZ0Oq6iGqbPAkp54PfRmRSl0gYwwMQoZVGB/u//ZQsdeOl9RdgBwDU5gESQAhKAAaSJrzbdsBcNkpkB3o67qGKTU632v1S10Xpubmd0zvxJLPPIb8dfbEs6ogCty+vY+j4yO889YVXH7t+zi/t42N8QRG3Rmr5I6hkrvX3evudfe6e/2v47oz8373unvdve5ed6//1Vx3Dffd6+5197p7/Tm77hruu9fd6+519/pzdt013Hevu9fd6+715+y6a7jvXnevu9fd68/Zdddw373uXnevu9efs+uu4b573b3uXnevP2fXXcN997p73b3uXn/OrruG++5197p73b3+nF3/P7YIABKEZnpbAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "box_annotator = sv.BoxAnnotator()\n", + "label_annotator = sv.LabelAnnotator()\n", + "\n", + "labels = [\n", + " f\"{model.model.names[class_id]} {confidence:.2f}\"\n", + " for class_id, confidence in zip(detections.class_id, detections.confidence)\n", + "]\n", + "annotated_image = box_annotator.annotate(\n", + " image.copy(),\n", + " detections=detections,\n", + ")\n", + "annotated_image = label_annotator.annotate(\n", + " annotated_image, detections=detections, labels=labels\n", + ")\n", + "\n", + "sv.plot_image(image=annotated_image, size=(8, 8))" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "WWz-v_YO7Ndq" + }, + "source": [ + "### MaskAnnotator [๐Ÿ“š](https://roboflow.github.io/supervision/detection/annotate/#maskannotator)" + ] + }, + { + "cell_type": "code", + "execution_count": 66, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 653 + }, + "id": "3fRTEo3P8mK5", + "outputId": "6715fcff-392d-4341-8b3b-9cddbfb9740a" + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "mask_annotator = sv.MaskAnnotator(color_lookup=sv.ColorLookup.INDEX)\n", + "\n", + "annotated_image = mask_annotator.annotate(\n", + " image.copy(), detections=detections_segmentation\n", + ")\n", + "\n", + "sv.plot_image(image=annotated_image, size=(8, 8))" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "ouQYHGWy9t0-" + }, + "source": [ + "## ๐Ÿ—‘ Filter [๐Ÿ“š](https://roboflow.github.io/supervision/quickstart/detections/)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "9i15_uHAAXaA" + }, + "source": [ + "### By index, index list and index slice\n", + "\n", + "**NOTE:** `sv.Detections` filter API allows you to access detections by index, index list or index slice" + ] + }, + { + "cell_type": "code", + "execution_count": 67, + "metadata": { + "id": "yuskE3obCS_-" + }, + "outputs": [], + "source": [ + "detections_index = detections[0]\n", + "detections_index_list = detections[[0, 1, 3]]\n", + "detections_index_slice = detections[:2]" + ] + }, + { + "cell_type": "code", + "execution_count": 68, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 545 + }, + "id": "uhIWfsboAfGL", + "outputId": "bf61029b-1544-4a80-fee1-2cfe4cfc7860" + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "box_annotator = sv.BoxAnnotator()\n", + "label_annotator = sv.LabelAnnotator()\n", + "\n", + "images = []\n", + "for d in [detections_index, detections_index_list, detections_index_slice]:\n", + " annotated_image = box_annotator.annotate(image.copy(), detections=d)\n", + " annotated_image = label_annotator.annotate(annotated_image, detections=d)\n", + " images.append(annotated_image)\n", + "titles = [\n", + " \"by index - detections[0]\",\n", + " \"by index list - detections[[0, 1, 3]]\",\n", + " \"by index slice - detections[:2]\",\n", + "]\n", + "\n", + "sv.plot_images_grid(images=images, titles=titles, grid_size=(1, 3))" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "ERFzXIoX--WM" + }, + "source": [ + "### By class_id\n", + "\n", + "**NOTE:** Let's use `sv.Detections` filter API to display only objects with `class_id == 0`" + ] + }, + { + "cell_type": "code", + "execution_count": 69, + "metadata": { + "id": "ZMsM2W-E_a3S" + }, + "outputs": [], + "source": [ + "detections_filtered = detections[detections.class_id == 0]" + ] + }, + { + "cell_type": "code", + "execution_count": 70, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 653 + }, + "id": "4OBATMKC-saQ", + "outputId": "214be556-100a-4f24-ef82-678f8e755a4c" + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "box_annotator = sv.BoxAnnotator()\n", + "label_annotator = sv.LabelAnnotator()\n", + "annotated_image = box_annotator.annotate(image.copy(), detections=detections_filtered)\n", + "annotated_image = label_annotator.annotate(\n", + " annotated_image, detections=detections_filtered\n", + ")\n", + "sv.plot_image(image=annotated_image, size=(8, 8))" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "815MjxC1Dguk" + }, + "source": [ + "### By confidence\n", + "\n", + "**NOTE:** Let's use `sv.Detections` filter API to display only objects with `confidence > 0.7`" + ] + }, + { + "cell_type": "code", + "execution_count": 100, + "metadata": { + "id": "iaoKiE2WD-1V" + }, + "outputs": [], + "source": [ + "detections_filtered = detections[detections.confidence > 0.7]" + ] + }, + { + "cell_type": "code", + "execution_count": 101, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 653 + }, + "id": "CJBG_rZFECII", + "outputId": "0fe354c9-5aca-4f2f-93d9-e4a75037e156" + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "box_annotator = sv.BoxAnnotator()\n", + "label_annotator = sv.LabelAnnotator()\n", + "labels = []\n", + "for class_id, confidence in zip(\n", + " detections_filtered.class_id, detections_filtered.confidence\n", + "):\n", + " labels.append(f\"{model.model.names[class_id]} {confidence:.2f}\")\n", + "annotated_image = box_annotator.annotate(\n", + " image.copy(),\n", + " detections=detections_filtered,\n", + ")\n", + "annotated_image = label_annotator.annotate(\n", + " annotated_image, detections=detections_filtered, labels=labels\n", + ")\n", + "sv.plot_image(image=annotated_image, size=(8, 8))" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "5LGZV71pEajp" + }, + "source": [ + "### By advanced logical condition\n", + "\n", + "**NOTE:** Let's use `sv.Detections` filter API allows you to build advanced logical conditions. Let's select only detections with `class_id != 0` and `confidence > 0.7`." + ] + }, + { + "cell_type": "code", + "execution_count": 103, + "metadata": { + "id": "iEVlSoKDE01n" + }, + "outputs": [], + "source": [ + "detections_filtered = detections[\n", + " (detections.class_id != 0) & (detections.confidence > 0.7)\n", + "]" + ] + }, + { + "cell_type": "code", + "execution_count": 104, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 653 + }, + "id": "1XLDs7FZE9Cq", + "outputId": "1936d60d-c107-4619-bf30-62043a8342fa" + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "box_annotator = sv.BoxAnnotator()\n", + "label_annotator = sv.LabelAnnotator()\n", + "labels = [\n", + " f\"{class_id} {confidence:.2f}\"\n", + " for class_id, confidence in zip(\n", + " detections_filtered.class_id, detections_filtered.confidence\n", + " )\n", + "]\n", + "annotated_image = box_annotator.annotate(\n", + " image.copy(),\n", + " detections=detections_filtered,\n", + ")\n", + "annotated_image = label_annotator.annotate(\n", + " annotated_image, detections=detections_filtered, labels=labels\n", + ")\n", + "\n", + "sv.plot_image(image=annotated_image, size=(8, 8))" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "fZizqu3yG_Im" + }, + "source": [ + "## ๐ŸŽฌ Video API\n", + "\n", + "**NOTE:** `supervision` offers a lot of utils to make working with videos easier. Let's take a look at some of them." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "v7uZZMlqIo1i" + }, + "source": [ + "**NOTE:** During our demo, we will need some example videos." + ] + }, + { + "cell_type": "code", + "execution_count": 75, + "metadata": { + "id": "MWUiG8oiNljr" + }, + "outputs": [], + "source": [ + "!pip install -q supervision[assets]" + ] + }, + { + "cell_type": "code", + "execution_count": 76, + "metadata": { + "id": "2ZEtjEZXImNd" + }, + "outputs": [], + "source": [ + "!mkdir {HOME}/videos" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "UBvWehKLI7vW" + }, + "source": [ + "**NOTE:** Feel free to use your videos. Just make sure to put them into `videos` directory that we just created. โ˜๏ธ" + ] + }, + { + "cell_type": "code", + "execution_count": 77, + "metadata": { + "id": "oNaYuFMHJC0X" + }, + "outputs": [], + "source": [ + "%cd {HOME}/videos" + ] + }, + { + "cell_type": "code", + "execution_count": 78, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 101, + "referenced_widgets": [ + "99013c035fee426e918cabe629af0834", + "725da1a5fa2a47a5830a61a48638b624", + "fe47dfdf40f54e6cbd7a79ae00971672", + "37267d61c3284b12aedd2ead04c477cf", + "89c2f98ca1b5443db8b51352a12ad770", + "e78521990143473f8566b900d72d48aa", + "cba0aa366f824752af48ecce98168365", + "7ab55a2f73a14174b6ae3914ae3eee09", + "fea2e2fec6a641bb9e55219c08ae0dfe", + "c42cea9bcc794b63a76d868c3b9c28c5", + "0fda7958d7a9439f914a40b059fc5f7a" + ] + }, + "id": "uzNDUj27Jthd", + "outputId": "4cd67e49-f795-4580-8894-3f721dd36349" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "/content/datasets/images/videos\n", + "Downloading vehicles.mp4 assets \n", + "\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "99013c035fee426e918cabe629af0834", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + " 0%| | 0/35345757 [00:00" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "frame = next(iter(frame_generator))\n", + "sv.plot_image(image=frame, size=(8, 8))" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "06kDsh4EK0Ht" + }, + "source": [ + "### VideoSink [๐Ÿ“š](https://roboflow.github.io/supervision/utils/video/#videosink)" + ] + }, + { + "cell_type": "code", + "execution_count": 82, + "metadata": { + "id": "D2zLo2thLYSE" + }, + "outputs": [], + "source": [ + "RESULT_VIDEO_PATH = f\"{HOME}/videos/vehicle-counting-result.mp4\"" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "5l4Kj0g8Mb7x" + }, + "source": [ + "**NOTE:** Note that this time we have given a custom value for the `stride` parameter equal to `2`. As a result, `get_video_frames_generator` will return us every second video frame." + ] + }, + { + "cell_type": "code", + "execution_count": 83, + "metadata": { + "id": "8IQasqt9LKjH" + }, + "outputs": [], + "source": [ + "video_info = sv.VideoInfo.from_video_path(video_path=VIDEO_PATH)\n", + "\n", + "with sv.VideoSink(target_path=RESULT_VIDEO_PATH, video_info=video_info) as sink:\n", + " for frame in sv.get_video_frames_generator(source_path=VIDEO_PATH, stride=2):\n", + " sink.write_frame(frame=frame)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "Op6K0HAzM10I" + }, + "source": [ + "**NOTE:** If we once again use `VideoInfo` we will notice that the final video has 2 times fewer frames." + ] + }, + { + "cell_type": "code", + "execution_count": 84, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "_wxeHV7OMXb8", + "outputId": "e062b2ac-68fd-44cf-d494-5f3f258e98c8" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "VideoInfo(width=3840, height=2160, fps=25, total_frames=269)" + ] + }, + "execution_count": 84, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "sv.VideoInfo.from_video_path(video_path=RESULT_VIDEO_PATH)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "p-b6BRKuNs8v" + }, + "source": [ + "## ๐Ÿ–ผ๏ธ Dataset API\n", + "\n", + "**NOTE:** In order to demonstrate the capabilities of the Dataset API, we need a dataset. Let's download one from [Roboflow Universe](https://universe.roboflow.com/). To do this we first need to install the `roboflow` pip package." + ] + }, + { + "cell_type": "code", + "execution_count": 85, + "metadata": { + "id": "0cY3p8WXOX5R" + }, + "outputs": [], + "source": [ + "!pip install -q roboflow" + ] + }, + { + "cell_type": "code", + "execution_count": 86, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "UU6uLh2COwTg", + "outputId": "584371d8-ecff-419d-8a13-a4e904861dd8" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "/content/datasets/images/datasets\n", + "\rvisit https://app.roboflow.com/auth-cli to get your authentication token.\n", + "Paste the authentication token here: ยทยทยทยทยทยทยทยทยทยท\n", + "loading Roboflow workspace...\n", + "loading Roboflow project...\n", + "Dependency ultralytics==8.0.196 is required but found version=8.2.54, to fix: `pip install ultralytics==8.0.196`\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Downloading Dataset Version Zip in fashion-assistant-segmentation-5 to yolov8:: 100%|โ–ˆโ–ˆโ–ˆโ–ˆโ–ˆโ–ˆโ–ˆโ–ˆโ–ˆโ–ˆ| 122509/122509 [00:03<00:00, 37319.95it/s]\n", + "Extracting Dataset Version Zip to fashion-assistant-segmentation-5 in yolov8:: 15%|โ–ˆโ– | 187/1254 [00:00<00:00, 1860.52it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\rExtracting Dataset Version Zip to fashion-assistant-segmentation-5 in yolov8:: 30%|โ–ˆโ–ˆโ–‰ | 374/1254 [00:00<00:00, 1609.45it/s]\rExtracting Dataset Version Zip to fashion-assistant-segmentation-5 in yolov8:: 43%|โ–ˆโ–ˆโ–ˆโ–ˆโ–Ž | 538/1254 [00:00<00:00, 1529.93it/s]" + ] + } + ], + "source": [ + "!mkdir {HOME}/datasets\n", + "%cd {HOME}/datasets\n", + "\n", + "import roboflow\n", + "from roboflow import Roboflow\n", + "\n", + "roboflow.login()\n", + "\n", + "rf = Roboflow()\n", + "\n", + "project = rf.workspace(\"roboflow-jvuqo\").project(\"fashion-assistant-segmentation\")\n", + "dataset = project.version(5).download(\"yolov8\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "968zz2JDPR7A" + }, + "source": [ + "### DetectionDataset.from_yolo [๐Ÿ“š](https://roboflow.github.io/supervision/dataset/core/#supervision.dataset.core.DetectionDataset.from_yolo)\n", + "\n", + "**NOTE:** Currently Dataset API always loads loads images from hard drive. In the future, we plan to add lazy loading." + ] + }, + { + "cell_type": "code", + "execution_count": 87, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "1QsLZ_L4Piky", + "outputId": "7ab19ee0-414b-4f23-e237-c18def9ae28f" + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\rExtracting Dataset Version Zip to fashion-assistant-segmentation-5 in yolov8:: 79%|โ–ˆโ–ˆโ–ˆโ–ˆโ–ˆโ–ˆโ–ˆโ–‰ | 989/1254 [00:00<00:00, 2606.19it/s]\rExtracting Dataset Version Zip to fashion-assistant-segmentation-5 in yolov8:: 100%|โ–ˆโ–ˆโ–ˆโ–ˆโ–ˆโ–ˆโ–ˆโ–ˆโ–ˆโ–ˆ| 1254/1254 [00:00<00:00, 2505.30it/s]\n" + ] + } + ], + "source": [ + "ds = sv.DetectionDataset.from_yolo(\n", + " images_directory_path=f\"{dataset.location}/train/images\",\n", + " annotations_directory_path=f\"{dataset.location}/train/labels\",\n", + " data_yaml_path=f\"{dataset.location}/data.yaml\",\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 88, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "AbQkgLsjQRBQ", + "outputId": "7742b630-dbbe-4963-95c1-a929852b51a3" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "573" + ] + }, + "execution_count": 88, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "len(ds)" + ] + }, + { + "cell_type": "code", + "execution_count": 89, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "7Km8UkqwQWih", + "outputId": "0f865c22-3f42-4b93-eee7-17a7a23b411c" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "['baseball cap',\n", + " 'hoodie',\n", + " 'jacket',\n", + " 'pants',\n", + " 'shirt',\n", + " 'shorts',\n", + " 'sneaker',\n", + " 'sunglasses',\n", + " 'sweatshirt',\n", + " 't-shirt']" + ] + }, + "execution_count": 89, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ds.classes" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "8lO-SX0MUOeP" + }, + "source": [ + "### ๐Ÿท๏ธ Visualize annotations" + ] + }, + { + "cell_type": "code", + "execution_count": 90, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 653 + }, + "id": "FxJk1wZkRAM9", + "outputId": "16999196-d5c8-4ce6-c6df-9167a53235ff" + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "IMAGE_NAME = next(iter(ds.images.keys()))\n", + "\n", + "image = ds.images[IMAGE_NAME]\n", + "annotations = ds.annotations[IMAGE_NAME]\n", + "\n", + "box_annotator = sv.BoxAnnotator()\n", + "label_annotator = sv.LabelAnnotator()\n", + "mask_annotator = sv.MaskAnnotator()\n", + "\n", + "labels = [f\"{ds.classes[class_id]}\" for class_id in annotations.class_id]\n", + "\n", + "annotated_image = mask_annotator.annotate(image.copy(), detections=annotations)\n", + "annotated_image = box_annotator.annotate(annotated_image, detections=annotations)\n", + "annotated_image = label_annotator.annotate(\n", + " annotated_image, detections=annotations, labels=labels\n", + ")\n", + "\n", + "sv.plot_image(image=annotated_image, size=(8, 8))" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "RUolPtmKUZBc" + }, + "source": [ + "### split [๐Ÿ“š](https://roboflow.github.io/supervision/dataset/core/#supervision.dataset.core.DetectionDataset.split)" + ] + }, + { + "cell_type": "code", + "execution_count": 91, + "metadata": { + "id": "6y5abqWVUkda" + }, + "outputs": [], + "source": [ + "ds_train, ds_test = ds.split(split_ratio=0.8)" + ] + }, + { + "cell_type": "code", + "execution_count": 92, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "L6HvedueUwVH", + "outputId": "c98a2cb0-925a-4319-e249-90036e6ed0c6" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "('ds_train', 458, 'ds_test', 115)" + ] + }, + "execution_count": 92, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "\"ds_train\", len(ds_train), \"ds_test\", len(ds_test)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "sydRyDMtVBOb" + }, + "source": [ + "### DetectionDataset.as_pascal_voc [๐Ÿ“š](https://roboflow.github.io/supervision/dataset/core/#supervision.dataset.core.DetectionDataset.as_pascal_voc)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "oJjkgaXBpE4-" + }, + "outputs": [], + "source": [ + "ds_train.as_pascal_voc(\n", + " images_directory_path=f\"{HOME}/datasets/result/images\",\n", + " annotations_directory_path=f\"{HOME}/datasets/result/labels\",\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "CwWCrBe-01Qi" + }, + "source": [ + "## ๐Ÿ† Congratulations\n", + "\n", + "### Learning Resources\n", + "\n", + "- [Documentation](https://roboflow.github.io/supervision/)\n", + "- [GitHub](https://github.com/roboflow/supervision)\n", + "- [YouTube Supervision Playlist](https://www.youtube.com/playlist?list=PLZCA39VpuaZaoGIohe9aXVMm24MRvfu1E)" + ] + } + ], + "metadata": { + "accelerator": "GPU", + "colab": { + "gpuType": "T4", + "provenance": [] + }, + "kernelspec": { + "display_name": "Python 3", + "name": "python3" + }, + "language_info": { + "name": "python" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} diff --git a/docs/0d5d9799b1cc4a39825146388c6781eb.txt b/docs/0d5d9799b1cc4a39825146388c6781eb.txt new file mode 100644 index 0000000..4c8cc29 --- /dev/null +++ b/docs/0d5d9799b1cc4a39825146388c6781eb.txt @@ -0,0 +1 @@ +0d5d9799b1cc4a39825146388c6781eb diff --git a/docs/CNAME b/docs/CNAME new file mode 100644 index 0000000..5e6d8fd --- /dev/null +++ b/docs/CNAME @@ -0,0 +1 @@ +supervision.roboflow.com diff --git a/docs/_headers b/docs/_headers new file mode 100644 index 0000000..0159518 --- /dev/null +++ b/docs/_headers @@ -0,0 +1,6 @@ +/* + Strict-Transport-Security: max-age=31536000; includeSubDomains; preload + X-Content-Type-Options: nosniff + Referrer-Policy: strict-origin-when-cross-origin + Permissions-Policy: camera=(), microphone=(), geolocation=() + Content-Security-Policy: default-src 'self'; base-uri 'self'; object-src 'none'; frame-ancestors 'none'; img-src 'self' https: data:; media-src 'self' https: data:; font-src 'self' https: data:; style-src 'self'; script-src 'self'; connect-src 'self' https:; diff --git a/docs/about.md b/docs/about.md new file mode 100644 index 0000000..e5d00c1 --- /dev/null +++ b/docs/about.md @@ -0,0 +1,27 @@ +--- +comments: true +description: About Supervision, Roboflow's open-source Python library for building reusable computer vision workflows. +--- + +# About Supervision + +Supervision is an open-source Python library by Roboflow for building computer vision applications. It gives developers a model-agnostic toolkit for loading predictions, annotating images and video, tracking objects, counting detections in zones, processing datasets, and evaluating model performance. + +The project centers on a unified `Detections` API with converters for supported outputs from Ultralytics, Roboflow Inference, Hugging Face Transformers, SAM, Detectron2, MMDetection, YOLO-NAS, PaddleDet, NCNN, Azure AI Vision, and VLM parsers such as Florence-2, PaliGemma, Qwen VL, Gemini, DeepSeek VL 2, and Moondream. That common representation lets teams change models without rewriting annotation, filtering, tracking, dataset, or metrics code. + +Supervision is maintained by Roboflow and an open-source contributor community. The library is MIT licensed, developed in public on GitHub, and published on PyPI. + +## Project Links + +- Source code: [github.com/roboflow/supervision](https://github.com/roboflow/supervision) +- Package: [pypi.org/project/supervision](https://pypi.org/project/supervision/) +- Community: [Roboflow Discord](https://discord.gg/GbfgXGJ8Bk) +- Roboflow: [roboflow.com](https://roboflow.com/) + +## Maintainers and Contributors + +Supervision has been shaped by Roboflow engineers and community contributors, including Piotr Skalski, Borda, onuralpszr, Soumik Mandal, and many others. The complete contributor history is available in the GitHub repository. + +## Citation + +If Supervision helps your research or production system, cite the project using the citation block in [llms.txt](https://supervision.roboflow.com/llms.txt) or link to the GitHub repository. diff --git a/docs/assets.md b/docs/assets.md new file mode 100644 index 0000000..dff0114 --- /dev/null +++ b/docs/assets.md @@ -0,0 +1,26 @@ +--- +comments: true +description: API reference for supervision's assets module โ€” download sample video and image files for demos, testing, and tutorials. +--- + +# Assets + +Supervision offers an assets download utility that allows you to download image and video files that you can use in your demos. + +
+

download_assets

+
+ +:::supervision.assets.downloader.download_assets + +
+

VideoAssets

+
+ +:::supervision.assets.list.VideoAssets + +
+

ImageAssets

+
+ +:::supervision.assets.list.ImageAssets diff --git a/docs/assets/roboflow_logomark_color.svg b/docs/assets/roboflow_logomark_color.svg new file mode 100644 index 0000000..1725e11 --- /dev/null +++ b/docs/assets/roboflow_logomark_color.svg @@ -0,0 +1,29 @@ + + + + + + + + + + + + diff --git a/docs/assets/roboflow_logomark_reversed.svg b/docs/assets/roboflow_logomark_reversed.svg new file mode 100644 index 0000000..f3c4fd9 --- /dev/null +++ b/docs/assets/roboflow_logomark_reversed.svg @@ -0,0 +1,29 @@ + + + + + + + + + + + + diff --git a/docs/assets/roboflow_logomark_white.svg b/docs/assets/roboflow_logomark_white.svg new file mode 100644 index 0000000..399abf1 --- /dev/null +++ b/docs/assets/roboflow_logomark_white.svg @@ -0,0 +1,23 @@ + + + + + + diff --git a/docs/assets/supervision-lenny.png b/docs/assets/supervision-lenny.png new file mode 100644 index 0000000..667b945 Binary files /dev/null and b/docs/assets/supervision-lenny.png differ diff --git a/docs/changelog.md b/docs/changelog.md new file mode 100644 index 0000000..f4515da --- /dev/null +++ b/docs/changelog.md @@ -0,0 +1,1801 @@ +--- +description: "Full version history of the supervision Python library โ€” release notes, breaking changes, new features, and deprecations for every version." +date_modified: 2026-07-08 +--- + +# Changelog + +### Unreleased upcoming + +!!! failure "Python 3.9 Support Terminated" + + With the upcoming `supervision-0.30.0` release, we are terminating official support for Python 3.9, which reached end-of-life in October 2025. The minimum supported Python version is now **3.10**. + + Users on Python 3.9 should upgrade their environment before updating supervision. + +### Breaking Changes +- `sv.JSONSink` now emits native JSON types for numeric and boolean data fields instead of stringified values. Fields previously serialized as `"True"`/`"False"`, `"1"`/`"0.85"`, or `"400.0"` are now `true`/`false`, `1`/`0.85`, `400.0`. Downstream consumers that compare field values as strings (e.g. `row["score"] == "1"`) or use strict string-typed schema validators must be updated. `sv.CSVSink` remains textual, but its custom-data slicing now matches `sv.JSONSink`: NumPy arrays, lists, and tuples are sliced per row only when their length matches the detection count; mismatched-length values are broadcast unchanged ([#2400](https://github.com/roboflow/supervision/pull/2400)). +- `sv.mask_non_max_merge` now computes exact mask overlap at the original mask resolution and ignores the deprecated `mask_dimension` parameter. Code that relied on downscaled mask overlap should recalibrate thresholds; passing `mask_dimension` positionally now emits a deprecation warning, and the parameter is scheduled for removal in `0.33.0` ([#2400](https://github.com/roboflow/supervision/pull/2400)). + +### Fixed +- `sv.hex_to_rgba` now rejects multiple leading `#` characters instead of silently normalizing them, matching `sv.is_valid_hex` and the documented single optional prefix. +- `sv.box_iou_batch` now upcasts box corners to `float64` before computing areas and intersections, returning `float32`. This fixes integer-dtype overflow (e.g. `int32` coordinates around `50_000` could previously wrap to a negative area and produce an incorrect `0.0` IoU) and gives full `float64` precision to callers that pass `float64`/`int64` coordinates directly. It does not recover precision already lost when coordinates are stored as `float32` before this function is called (e.g. `Detections.xyxy`, which is `float32` throughout the library) โ€” such callers must upcast their own arrays to `float64`/`int64` before calling `box_iou_batch` to benefit from this fix. Results for small-coordinate inputs are unchanged. +- Legacy COCO prediction loading in `sv.EvaluationDataset.load_predictions` now raises `ValueError` for image ids absent from the ground-truth COCO set instead of relying on a bare `assert`, so the check is no longer silently skipped under `python -O`. +- `sv.HeatMapAnnotator` now exposes a `reset()` method to clear accumulated heat, so a single annotator instance can be reused across independent streams without carrying over heat from a previous stream. +- `sv.TraceAnnotator` and `sv.DetectionsSmoother` now expose a `reset()` method for interface consistency with `sv.HeatMapAnnotator.reset()`, clearing their accumulated per-track history so a single instance can be reused across independent streams. +- Fixed [#2416](https://github.com/roboflow/supervision/pull/2416): `sv.process_video` no longer risks hanging during shutdown; the sentinel enqueue is best-effort and worker joins are bounded. +- Fixed [#2416](https://github.com/roboflow/supervision/pull/2416): COCO and CreateML dataset loaders now canonicalize resolved image paths and reject duplicate aliases for the same file. +- Fixed [#2416](https://github.com/roboflow/supervision/pull/2416): `DetectionDataset.as_pascal_voc()` now preflights image and annotation basename collisions before writing, so exports fail fast instead of producing partial output. +- `import supervision` no longer surfaces the deprecated `ByteTrack` warning; the top-level tracker alias now resolves lazily when accessed explicitly. +- Fixed dataset export edge cases: `DetectionDataset.split()` and `DetectionDataset.merge()` now preserve in-memory image payloads without re-emitting the deprecation warning, and COCO/CreateML exports now reject duplicate image basenames instead of silently collapsing distinct paths into the same output key. +- Fixed: `sv.Color(...)` now validates direct RGBA channel values and raises `ValueError` when any channel falls outside the 0-255 byte range. +- Fixed: `approximate_mask_with_polygons` now defaults to no polygon simplification, matching the public dataset export methods. +- Fixed: `ImageSink.save_image()` now raises `OSError` when `cv2.imwrite()` fails, and deprecation-warning control accepts the correct `SUPERVISION_DEPRECATION_WARNING` environment variable while still honoring the legacy misspelled alias. +- `sv.Classifications.from_timm` now softmaxes model logits before exposing confidence scores, matching `sv.Classifications.from_clip` and keeping timm confidences on a normalized probability scale. Thresholds calibrated against raw logits may need retuning. +- `sv.download_assets` now verifies MD5 hashes after fresh downloads and retries once when the downloaded payload is corrupted instead of accepting a bad file. +- Fixed metrics scoring edge cases: legacy `sv.MeanAveragePrecision` now uses COCO 101-point AP averaging, `sv.ConfusionMatrix` rejects invalid class ids instead of wrapping them through `int16`/negative indexing, `sv.MeanAveragePrecision` preserves user-provided target `ignore` flags, and `sv.MeanAverageRecallResult.recall_per_class` now exposes per-class recall for each max-detection cutoff. +- Fixed [#2408](https://github.com/roboflow/supervision/pull/2408): `sv.Precision`, `sv.Recall`, `sv.F1Score`, and `sv.MeanAverageRecall` now score size buckets by filtering targets only while leaving predictions eligible to match bucket targets. This preserves bucket matches that would otherwise be stolen by out-of-bucket filtering and keeps mAR top-K ranking intact. +- `sv.ByteTrack` no longer mutates input `Detections` while assigning tracker IDs. It now keeps detections at the activation-threshold boundary eligible for matching, avoids impossible new-track thresholds above score `1.0`, ignores invalid zero-area/non-finite tensor boxes before Kalman updates, and does not emit unconfirmed `-1` IDs from first-frame tensor updates. +- Fixed [#2402](https://github.com/roboflow/supervision/pull/2402): `sv.KeyPoints.as_detections` now accepts NumPy arrays, tuples, and generators in `selected_keypoint_indices` without ambiguous truth-value errors; empty index iterables select all keypoints. Valid zero-area skeletons are preserved, while all-zero and non-finite-only skeletons are filtered out. +- Changed: delayed `sv.ByteTrack`, `supervision.keypoint`, `normalized_xyxy` for `sv.denormalize_boxes`, and `supervision.dataset.utils` RLE compatibility removals from `supervision-0.30.0` to `supervision-0.31.0` so the deprecated APIs keep a full transition window. +- Fixed [#2407](https://github.com/roboflow/supervision/pull/2407): `sv.ColorPalette.by_idx()` now raises a clear `ValueError` when called on an empty palette instead of leaking a `ZeroDivisionError`. Non-empty palettes keep the existing index-wrapping behavior. +- Fixed [#2393](https://github.com/roboflow/supervision/pull/2393): `sv.CropAnnotator.annotate` no longer raises `cv2.error` when detections extend outside the scene; out-of-bounds boxes are clipped to scene bounds and zero-area results are skipped silently. +- Fixed [#2393](https://github.com/roboflow/supervision/pull/2393): `sv.HeatMapAnnotator.annotate` no longer blanks the hottest region when the per-pixel hit count exceeds 255; the heat mask is now derived from the float32 accumulator directly, avoiding uint8 wrap-around. +- Fixed [#2393](https://github.com/roboflow/supervision/pull/2393): `sv.get_video_frames_generator` now releases the underlying `cv2.VideoCapture` via `try/finally`, so the decoder is freed when a consumer breaks out of iteration early rather than waiting for garbage collection. +- Fixed [#2382](https://github.com/roboflow/supervision/pull/2382): `sv.Detections.get_anchors_coordinates` now uses oriented bounding box corners (`data["xyxyxyxy"]`) when OBB data is present, instead of falling back to the axis-aligned envelope. Anchors on rotated detections now lie on the oriented body rather than drifting to the envelope. Non-OBB detections and `Position.CENTER_OF_MASS` (which requires a mask) are unaffected. +- Fixed [#2396](https://github.com/roboflow/supervision/pull/2396): `sv.BackgroundOverlayAnnotator.annotate` no longer leaves detection regions tinted when bounding boxes have negative coordinates (extend outside the left or top scene boundary); boxes are now clipped to scene bounds before the detection region is restored. +- Fixed: dataset IO/export edge cases now avoid mutating caller-owned `Detections` during `DetectionDataset` construction, reject non-integer and out-of-range class ids with a clear `ValueError`, load COCO annotations that omit optional `iscrowd`/`area` fields, expose `DetectionDataset.from_coco(use_iscrowd=...)` without changing the existing positional `show_progress` argument, export mask pixel area to COCO when no stored area is present, ignore folder-structure root clutter and non-image files inside class folders, and accept PIL-readable YOLO images such as RGBA or palette PNGs. + +### Added +- `KeyPoints.merge` โ€” combine a list of `KeyPoints` objects into one, mirroring `Detections.merge`. Empty inputs are ignored; all non-empty inputs must share the same number of keypoints per skeleton. Completes the merge-then-suppress workflow introduced by `KeyPoints.with_nms` ([#2412](https://github.com/roboflow/supervision/pull/2412)) +- `BaseAnnotator.requires_mask` โ€” class-level `bool` flag on all annotators; `True` for `MaskAnnotator`, `PolygonAnnotator`, and `HaloAnnotator`; `False` for all others. Integrations can inspect this before materializing expensive mask payloads ([#2370](https://github.com/roboflow/supervision/pull/2370)) +- `CompactMask.from_coco_rle` โ€” efficient COCO RLE ingestion into crop-scoped compact mask format without materializing dense `(N, H, W)` arrays ([#2367](https://github.com/roboflow/supervision/pull/2367)) +- `Detections.from_inference(compact_masks=True)` โ€” opt-in compact mask representation for Roboflow/Inference segmentation results; masks are cropped to detector bounding boxes ([#2367](https://github.com/roboflow/supervision/pull/2367)) +- `CompactMask.image_shape` โ€” new public property returning `(H, W)` of the full image the mask is scoped to ([#2383](https://github.com/roboflow/supervision/pull/2383)) +- `sv.mask_to_roi` โ€” explicit exclusive mask-bound helper for NumPy slicing and crop extraction. `sv.mask_to_xyxy` stays inclusive for compatibility with CompactMask and current box-based adapters, so the coordinate-convention migration path is now explicit instead of implicit. + +### Changed +- Performance [#2383](https://github.com/roboflow/supervision/pull/2383): `sv.Detections.merge()` on mixed dense `ndarray` + `CompactMask` inputs now returns a `CompactMask` instead of a dense `ndarray`. Previously (0.29.0/0.29.1) the mixed path fell back to `np.vstack`, allocating a full `(N, H, W)` array; the new path converts dense inputs to `CompactMask` without materialising the full stack (~2 500ร— less peak memory, ~13ร— faster on 1080p / 40 detections). **Behavior change**: code that checks `isinstance(merged.mask, np.ndarray)` or calls bare ndarray methods (`.astype`, `.reshape`, `.ravel`) on a mixed-merge result will need to be updated. The all-dense path is unchanged and still returns `ndarray`. +- `DetectionDataset` and `ClassificationDataset` equality now compare the ordered `classes` lists directly instead of treating class labels as an unordered set. This keeps equality aligned with `class_id` indexing semantics, where class position is part of the dataset contract. + +### 0.29.1 Jun 23, 2026 + +- Fixed [#2353](https://github.com/roboflow/supervision/pull/2353): `sv.Detections.from_inference` no longer raises `TypeError` when the Inference package returns a mixed batch where only some predictions carry a `tracker_id`. `detections.tracker_id` is `None` for the full result in that case; fully-tracked and fully-untracked batches are unchanged. + +- Added [#2275](https://github.com/roboflow/supervision/pull/2275): `show_progress: bool = False` parameter to all `sv.DetectionDataset` load and save methods โ€” `from_coco`, `from_yolo`, `from_pascal_voc`, `as_coco`, `as_yolo`, `as_pascal_voc`, and `save_dataset_images`. When `True`, a `tqdm.auto` progress bar is shown (works in terminal and Jupyter). Defaults to `False` for full backward compatibility; no new dependencies. + +- Added [#2027](https://github.com/roboflow/supervision/issues/2027): [`sv.InferenceSlicer`](https://supervision.roboflow.com/latest/detection/tools/inference_slicer/#supervision.detection.tools.inference_slicer.InferenceSlicer) now accepts an open rasterio-style dataset in addition to in-memory images. Each tile is read lazily via a windowed read instead of loading the whole image, enabling tiled inference on multi-GB aerial/drone GeoTIFFs without running out of memory. Detection is duck-typed, so `rasterio` stays an optional dependency installable via `pip install "supervision[geotiff]"` and the core library imports no rasterio symbols. A geographic (non-projected) CRS raises `ValueError`. + +- Added [#2338](https://github.com/roboflow/supervision/pull/2338): [`sv.KeyPoints.with_nms`](https://supervision.roboflow.com/latest/keypoint/core/#supervision.key_points.core.KeyPoints.with_nms) โ€” non-maximum suppression for keypoint detections. Derives axis-aligned bounding boxes from valid (non-zero and visible) keypoints and applies `box_non_max_suppression`. Requires `detection_confidence`; supports class-aware and class-agnostic modes via `threshold`, `class_agnostic`, and `overlap_metric`. + +- Fixed [#2342](https://github.com/roboflow/supervision/pull/2342): `sv.Detections.from_vlm` with `sv.VLM.GOOGLE_GEMINI_2_0`, `sv.VLM.GOOGLE_GEMINI_2_5`, and `sv.VLM.QWEN_2_5_VL` no longer raises when the model returns valid JSON of the wrong shape (non-list top-level or non-dict elements). A non-string or malformed `"mask"` value in Gemini 2.5 output no longer triggers `AttributeError`; invalid base64 or non-PNG mask data falls back to an empty mask, keeping `xyxy`, `confidence`, and `masks` arrays aligned. + +- Fixed [#2341](https://github.com/roboflow/supervision/pull/2341): `sv.DetectionDataset.as_pascal_voc` no longer mutates the source `Detections.xyxy` by the 1-index offset on every call. Previously, repeated exports accumulated a `+1` shift in the caller's bounding boxes. + +- Fixed [#2334](https://github.com/roboflow/supervision/pull/2334): `sv.JSONSink` now serializes NumPy scalars (e.g. `np.int64` frame indices) in `custom_data` as JSON numbers instead of raising `TypeError` at close time. File handle is now guaranteed to close even when serialization fails. + +- Fixed [#2333](https://github.com/roboflow/supervision/pull/2333): [`sv.DetectionsSmoother`](https://supervision.roboflow.com/latest/detection/tools/smoother/#supervision.detection.tools.smoother.DetectionsSmoother) no longer raises when smoothing detections without `confidence`. Confidence is now averaged over the frames that carry it; when tracks in the same frame disagree on confidence presence, `confidence` is set to `None` for all smoothed detections. + +- Fixed [#2332](https://github.com/roboflow/supervision/pull/2332): `sv.approximate_polygon` now returns a polygon within the requested point-count budget (at most `floor(N * (1 - percentage))` points, minimum 3). The function now also validates that `epsilon_step > 0`. + +- Fixed [#2331](https://github.com/roboflow/supervision/pull/2331): `sv.Precision` and `sv.F1Score` now count predictions on background images (empty target set) as false positives, and count predictions of classes absent from ground truth as false positives under `MICRO` and `MACRO` averaging. Previously both edge cases were silently ignored, inflating scores. `WEIGHTED` averaging is unchanged โ€” absent classes retain weight 0, consistent with scikit-learn. Users relying on previous scores should re-evaluate after upgrading; no API change is required. + +- Added [#2299](https://github.com/roboflow/supervision/pull/2299): [`DetectionDataset.from_labelme`](https://supervision.roboflow.com/latest/datasets/core/#supervision.dataset.core.DetectionDataset.from_labelme) and [`DetectionDataset.as_labelme`](https://supervision.roboflow.com/latest/datasets/core/#supervision.dataset.core.DetectionDataset.as_labelme) for loading and exporting [LabelMe](https://github.com/wkentaro/labelme) per-image JSON annotations, following the existing COCO/YOLO/VOC convention. `rectangle` shapes load as boxes and `polygon` shapes as masks; unsupported shape types are skipped with a warning. The mask round-trip is a polygon approximation, not bit-exact. + +- Fixed [#2322](https://github.com/roboflow/supervision/pull/2322): COCO export now preserves all polygon parts for multi-component masks. Previously, only the first polygon was written when a non-crowd mask had disjoint segments; all parts are now included. + +- Performance [#2339](https://github.com/roboflow/supervision/pull/2339): `sv.HaloAnnotator` now uses the same CompactMask painting path as `sv.MaskAnnotator` via a shared `_paint_masks_by_area` helper. On a 1080p frame with 30 CompactMask detections, `HaloAnnotator` runs approximately 4ร— faster; annotated output is unchanged. + +- Added [#2284](https://github.com/roboflow/supervision/pull/2284): [`DetectionDataset.from_createml`](https://supervision.roboflow.com/latest/datasets/core/#supervision.dataset.core.DetectionDataset.from_createml) and [`DetectionDataset.as_createml`](https://supervision.roboflow.com/latest/datasets/core/#supervision.dataset.core.DetectionDataset.as_createml) add load and export support for the CreateML object-detection JSON format, alongside the existing COCO, YOLO, and Pascal VOC formats. + +- Performance [#2330](https://github.com/roboflow/supervision/pull/2330): `sv.mask_to_xyxy` and `sv.KeyPoints.as_detections` are now vectorized. `mask_to_xyxy` uses batched occupancy-profile reductions instead of per-mask pixel scans; `KeyPoints.as_detections` computes all bounding boxes in a single batch operation. Both produce bit-identical results. + +- Performance [#2323](https://github.com/roboflow/supervision/pull/2323): Mask IoU computation now uses matrix multiplication on flattened masks instead of an explicit `(N, M, H, W)` intersection tensor, reducing peak memory for large mask sets. For masks larger than 4096ร—4096 pixels, computation automatically promotes to float64 to preserve exact pixel counts. Results are numerically identical. + +### 0.29.0.post0 Jun 17, 2026 + +- Fixed [#2335](https://github.com/roboflow/supervision/pull/2335): `sv.KeyPoints(confidence=...)` now works again. The `0.29.0` refactor accidentally dropped the deprecated `confidence` constructor kwarg; it is now accepted and mapped to `keypoint_confidence` with a deprecation warning. + +### 0.29.0 Jun 15, 2026 + +- Added [#2314](https://github.com/roboflow/supervision/pull/2314): new cookbook **Oriented Bounding Boxes** showing how an oriented box differs from an axis-aligned one on a marina of boats: DOTA-pretrained detection, the effect on [`with_nms`](https://supervision.roboflow.com/0.29.0/detection/core/#supervision.detection.core.Detections.with_nms) and [`Detections.area`](https://supervision.roboflow.com/0.29.0/detection/core/#supervision.detection.core.Detections.area), and YOLO OBB dataset export. + +- Fixed [#2306](https://github.com/roboflow/supervision/pull/2306): [`sv.Detections.area`](https://supervision.roboflow.com/0.29.0/detection/core/#supervision.detection.core.Detections.area) now returns the rotated body's area for detections carrying `data["xyxyxyxy"]` (oriented box corners) instead of the area of the derived axis-aligned bounding box, which overestimates by up to ~2x at 45ยฐ rotation. Affects annotator z-ordering inside [`MaskAnnotator`](https://supervision.roboflow.com/0.29.0/detection/annotators/#supervision.annotators.core.MaskAnnotator) and [`HaloAnnotator`](https://supervision.roboflow.com/0.29.0/detection/annotators/#supervision.annotators.core.HaloAnnotator), and any user code that filters or sorts OBB detections by area. The mask path and the non-OBB AABB fallback are unchanged. + +- Added [#2277](https://github.com/roboflow/supervision/pull/2277), [#2286](https://github.com/roboflow/supervision/pull/2286): [`sv.VertexEllipseAreaAnnotator`](https://supervision.roboflow.com/0.29.0/keypoint/annotators/#supervision.key_points.annotators.VertexEllipseAreaAnnotator), [`sv.VertexEllipseOutlineAnnotator`](https://supervision.roboflow.com/0.29.0/keypoint/annotators/#supervision.key_points.annotators.VertexEllipseOutlineAnnotator), and [`sv.VertexEllipseHaloAnnotator`](https://supervision.roboflow.com/0.29.0/keypoint/annotators/#supervision.key_points.annotators.VertexEllipseHaloAnnotator) for visualizing keypoint uncertainty as covariance ellipses. Requires models that output keypoint uncertainty (e.g. RF-DETR keypoint models). + +- Added [#2303](https://github.com/roboflow/supervision/pull/2303): [`sv.oriented_box_non_max_suppression`](https://supervision.roboflow.com/0.29.0/detection/utils/iou_and_nms/#supervision.detection.utils.iou_and_nms.oriented_box_non_max_suppression) and [`sv.oriented_box_non_max_merge`](https://supervision.roboflow.com/0.29.0/detection/utils/iou_and_nms/#supervision.detection.utils.iou_and_nms.oriented_box_non_max_merge) for performing NMS and NMM directly on oriented bounding boxes using oriented-box IoU instead of axis-aligned IoU. + +- Added [#2247](https://github.com/roboflow/supervision/pull/2247): [`sv.ConfusionMatrix`](https://supervision.roboflow.com/0.29.0/detection/metrics/#supervision.metrics.detection.ConfusionMatrix) now supports `MetricTarget.ORIENTED_BOUNDING_BOXES`, computing IoU via `oriented_box_iou_batch` on `xyxyxyxy` corners. Previously, OBB inputs silently fell back to axis-aligned bounding-box IoU, producing incorrect match scores for rotated detections. + +- Added [#2252](https://github.com/roboflow/supervision/pull/2252): [`sv.process_video`](https://supervision.roboflow.com/0.29.0/utils/video/#supervision.utils.video.process_video) gains a `preserve_audio` parameter. When enabled, the audio stream from the source video is muxed into the output using ffmpeg. + +- Added [#2302](https://github.com/roboflow/supervision/pull/2302), [#2289](https://github.com/roboflow/supervision/pull/2289): [`sv.DetectionDataset.as_yolo`](https://supervision.roboflow.com/0.29.0/datasets/core/#supervision.dataset.core.DetectionDataset.as_yolo) gains an `is_obb` parameter for exporting oriented bounding box annotations in the YOLO OBB format (9-token lines with 4 corner coordinates). + +- Added [#2312](https://github.com/roboflow/supervision/pull/2312): [`sv.xyxyxyxy_to_xyxy`](https://supervision.roboflow.com/0.29.0/detection/utils/boxes/#supervision.detection.utils.boxes.xyxyxyxy_to_xyxy) โ€” vectorised utility that converts oriented bounding box corners `(N, 4, 2)` to axis-aligned bounding boxes `(N, 4)`. + +- Changed [#2286](https://github.com/roboflow/supervision/pull/2286): [`sv.KeyPoints`](https://supervision.roboflow.com/0.29.0/keypoint/core/#supervision.key_points.core.KeyPoints) now separates keypoint-level and detection-level confidence into distinct fields: `keypoint_confidence` (shape `(n, m)`) and `detection_confidence` (shape `(n,)`). A new `visible` mask (shape `(n, m)`) controls per-keypoint visibility. The legacy `KeyPoints.confidence` property still works but is deprecated. + +- Changed [#2286](https://github.com/roboflow/supervision/pull/2286): [`sv.EdgeAnnotator`](https://supervision.roboflow.com/0.29.0/keypoint/annotators/#supervision.key_points.annotators.EdgeAnnotator) and [`sv.VertexAnnotator`](https://supervision.roboflow.com/0.29.0/keypoint/annotators/#supervision.key_points.annotators.VertexAnnotator) now respect the `visible` mask. Invisible keypoints and their edges are skipped during rendering. + +- Changed [#2286](https://github.com/roboflow/supervision/pull/2286): [`sv.EdgeAnnotator`](https://supervision.roboflow.com/0.29.0/keypoint/annotators/#supervision.key_points.annotators.EdgeAnnotator) and [`sv.VertexLabelAnnotator`](https://supervision.roboflow.com/0.29.0/keypoint/annotators/#supervision.key_points.annotators.VertexLabelAnnotator) now support per-class skeleton definitions, enabling correct rendering when multiple skeleton topologies (e.g. person + animal) coexist in one frame. + +- Changed [#2303](https://github.com/roboflow/supervision/pull/2303): [`sv.Detections.with_nms`](https://supervision.roboflow.com/0.29.0/detection/core/#supervision.detection.core.Detections.with_nms) and [`sv.Detections.with_nmm`](https://supervision.roboflow.com/0.29.0/detection/core/#supervision.detection.core.Detections.with_nmm) now use oriented-box IoU when `data["xyxyxyxy"]` coordinates are present, instead of axis-aligned box IoU. Callers relying on the previous axis-aligned behaviour should remove `data["xyxyxyxy"]` before calling, or recalibrate any IoU thresholds. + +- Changed [#2312](https://github.com/roboflow/supervision/pull/2312): [`sv.Detections.with_nmm`](https://supervision.roboflow.com/0.29.0/detection/core/#supervision.detection.core.Detections.with_nmm) now computes the merged oriented bounding box as the tightest rectangle at the winner's orientation enclosing all corners from every detection in a merge group. + +- Changed [#2325](https://github.com/roboflow/supervision/pull/2325): [`sv.VertexEllipseAreaAnnotator`](https://supervision.roboflow.com/0.29.0/keypoint/annotators/#supervision.key_points.annotators.VertexEllipseAreaAnnotator), [`sv.VertexEllipseOutlineAnnotator`](https://supervision.roboflow.com/0.29.0/keypoint/annotators/#supervision.key_points.annotators.VertexEllipseOutlineAnnotator), and [`sv.VertexEllipseHaloAnnotator`](https://supervision.roboflow.com/0.29.0/keypoint/annotators/#supervision.key_points.annotators.VertexEllipseHaloAnnotator) now draw sigma levels level-by-level (outermost first) across all points, ensuring correct visual layering when ellipses overlap. + +- Changed [#2256](https://github.com/roboflow/supervision/pull/2256): [`sv.InferenceSlicer`](https://supervision.roboflow.com/0.29.0/detection/tools/inference_slicer/#supervision.detection.tools.inference_slicer.InferenceSlicer) now detects OBB outputs from callbacks and automatically falls back to sequential processing to avoid thread-safety issues when `thread_workers > 1`. + +- Changed [#2324](https://github.com/roboflow/supervision/pull/2324): Project-wide deprecation policy unified to a minimum 3-minor-release window. All current deprecations (including `KeyPoints.confidence` and `validate_*` helpers) are scheduled for removal in `0.32.0`. + +- Fixed [#2252](https://github.com/roboflow/supervision/pull/2252): [`sv.process_video`](https://supervision.roboflow.com/0.29.0/utils/video/#supervision.utils.video.process_video) audio muxing path now correctly creates temp files on the same filesystem, decodes ffmpeg errors, and avoids muxing incomplete output. + +- Fixed [#2282](https://github.com/roboflow/supervision/pull/2282), [#2317](https://github.com/roboflow/supervision/pull/2317): [`sv.oriented_box_iou_batch`](https://supervision.roboflow.com/0.29.0/detection/utils/iou_and_nms/#supervision.detection.utils.iou_and_nms.oriented_box_iou_batch) now computes exact IoU via convex polygon intersection (`cv2.intersectConvexConvex`) and uses an axis-aligned bounding box envelope gate to skip pairs that cannot overlap, improving both accuracy and performance. Previously, rasterization on a discrete grid was used, which assumed square dimensions and introduced quantisation noise. + +- Fixed [#2239](https://github.com/roboflow/supervision/pull/2239): [`sv.Detections.from_vlm`](https://supervision.roboflow.com/0.29.0/detection/core/#supervision.detection.core.Detections.from_vlm) no longer returns `None` for `class_id` on empty VLM parses; now returns an empty int ndarray. + +- Fixed [#2270](https://github.com/roboflow/supervision/pull/2270): [`sv.Detections.from_inference`](https://supervision.roboflow.com/0.29.0/detection/core/#supervision.detection.core.Detections.from_inference) now preserves `class_name` as a string-dtype array when predictions are empty. + +- Fixed [#2269](https://github.com/roboflow/supervision/pull/2269): [`sv.HeatMapAnnotator`](https://supervision.roboflow.com/0.29.0/detection/annotators/#supervision.annotators.core.HeatMapAnnotator) no longer crashes with a divide-by-zero when called with empty detections. + +- Fixed [#2276](https://github.com/roboflow/supervision/pull/2276): COCO export now emits 1-indexed `category_id` values as required by the COCO specification. + +- Fixed [#2267](https://github.com/roboflow/supervision/pull/2267): COCO annotation and image IDs are now sequential across train/val/test splits via `starting_image_id` and `starting_annotation_id` parameters. + +- Fixed [#2289](https://github.com/roboflow/supervision/pull/2289): [`sv.DetectionDataset.as_yolo`](https://supervision.roboflow.com/0.29.0/datasets/core/#supervision.dataset.core.DetectionDataset.as_yolo) no longer loses OBB rotation when exporting oriented bounding boxes. + +- Fixed [#2296](https://github.com/roboflow/supervision/pull/2296): YOLO dataset loading now sorts class names by numeric keys when `data.yaml` uses integer class IDs. + +- Fixed [#2297](https://github.com/roboflow/supervision/pull/2297): Letterbox utility now supports grayscale images. + +- Fixed [#2298](https://github.com/roboflow/supervision/pull/2298): File extension filters now normalize casing (e.g. `.JPG` matches `.jpg`). + +- Fixed [#2321](https://github.com/roboflow/supervision/pull/2321): [`sv.DetectionDataset.as_coco()`](https://supervision.roboflow.com/0.29.0/datasets/core/#supervision.dataset.core.DetectionDataset.as_coco) now round-trips polygon and RLE segmentation data. Segmentations loaded from COCO annotations are preserved in `detections.data["coco_raw_segmentation"]` and written back on export, preventing data loss in train/val/test split workflows. + +- Deprecated: `KeyPoints.confidence` (use `KeyPoints.keypoint_confidence`), `merge_inner_detection_object_pair`, `merge_inner_detections_objects`, `merge_inner_detections_objects_without_iou`, `validate_detections_fields`, `validate_vlm_parameters`, `validate_fields_both_defined_or_none`, `validate_xyxy`, `validate_mask`, `validate_class_id`, `validate_confidence`, `validate_tracker_id`, `validate_data`, `validate_xy`, `validate_key_point_confidence`, `validate_key_points_fields`, `validate_resolution`, `validate_custom_values`, `validate_input_tensors`, and `validate_labels` are deprecated in `0.29.0` and will be removed in `0.32.0`. + +### 0.28.0 Apr 30, 2026 + +- Added [#2159](https://github.com/roboflow/supervision/pull/2159): [`sv.CompactMask`](https://supervision.roboflow.com/latest/detection/compact_mask/#supervision.detection.compact_mask.CompactMask) for memory-efficient mask storage. Masks are stored as crop-region bounding boxes plus RLE-encoded data instead of full-resolution bitmaps, reducing memory by up to 240ร— for sparse masks. Integrates transparently with `sv.Detections.mask` โ€” filtering, merging, and `area` all work without materialising the full array. + +- Added [#2227](https://github.com/roboflow/supervision/pull/2227): [`sv.CompactMask.resize(new_image_shape)`](https://supervision.roboflow.com/latest/detection/compact_mask/#supervision.detection.compact_mask.CompactMask.resize) rescales all stored crops to match a new image resolution, enabling use across frames or after image resizing pipelines. + +- Added [#2178](https://github.com/roboflow/supervision/pull/2178): [`sv.Detections.from_inference`](https://supervision.roboflow.com/latest/detection/core/#supervision.detection.core.Detections.from_inference) now supports compressed COCO RLE masks. Inference responses with `rle` or `rle_mask` fields containing a compressed counts string (as produced by `pycocotools`) are decoded directly into binary masks, avoiding a lossy polygon round-trip. + +- Added [#2004](https://github.com/roboflow/supervision/pull/2004): [`sv.Color.from_hex`](https://supervision.roboflow.com/latest/utils/draw/#supervision.draw.color.Color.from_hex) now accepts 8-digit hexadecimal RGBA codes (e.g. `#ff00ff80`). [`Color.as_hex()`](https://supervision.roboflow.com/latest/utils/draw/#supervision.draw.color.Color.as_hex) serialises back, including alpha when not fully opaque. New utility functions `sv.hex_to_rgba`, `sv.rgba_to_hex`, and `sv.is_valid_hex` are exported at the top level. + +- Added [#709](https://github.com/roboflow/supervision/pull/709): [`sv.BlurAnnotator`](https://supervision.roboflow.com/latest/detection/annotators/#supervision.annotators.core.BlurAnnotator) and [`sv.PixelateAnnotator`](https://supervision.roboflow.com/latest/detection/annotators/#supervision.annotators.core.PixelateAnnotator) now support dynamic sizing. When `kernel_size=None` or `pixel_size=None` (the new default), the size is computed per detection as a fraction of the shorter bounding-box dimension, producing consistent visual results across objects of different sizes. + +- Added [#2186](https://github.com/roboflow/supervision/pull/2186): [`sv.InferenceSlicer`](https://supervision.roboflow.com/latest/detection/tools/inference_slicer/#supervision.detection.tools.inference_slicer.InferenceSlicer) now emits a warning when detections returned by the callback fall outside the tile boundaries, helping catch coordinate-system bugs in custom callbacks. + +- Added [#2103](https://github.com/roboflow/supervision/pull/2103), [#2152](https://github.com/roboflow/supervision/pull/2152): New [`sv.Detections.from_sam3()`](https://supervision.roboflow.com/latest/detection/core/#supervision.detection.core.Detections.from_sam3) classmethod parses SAM3 PCS (text-prompted) and PVS (visual-prompted video segmentation) response formats into a standard `sv.Detections`, both from the local `inference` package and from Roboflow-hosted server responses. + +- Added [#2154](https://github.com/roboflow/supervision/pull/2154): The library now uses Python's `logging` module instead of `print` for diagnostic output. Messages are emitted under the `supervision` logger so applications can capture, filter, or silence them through standard `logging` configuration. + +- Added [#932](https://github.com/roboflow/supervision/pull/932): [`sv.ImageAssets`](https://supervision.roboflow.com/latest/assets/) for downloading sample images alongside existing video assets, useful for examples and tutorials. + +- Changed [#2169](https://github.com/roboflow/supervision/pull/2169): [`sv.MeanAveragePrecisionResult`](https://supervision.roboflow.com/latest/metrics/mean_average_precision/) and related metric arrays (`mAP_scores`, `ap_per_class`, `iou_thresholds`, precision/recall) are now `float32` instead of `float64`. Reduces memory and speeds up computation; numerical results may differ in the last few digits. + +- Changed [#2178](https://github.com/roboflow/supervision/pull/2178): [`sv.rle_to_mask`](https://supervision.roboflow.com/latest/detection/utils/converters/#supervision.detection.utils.converters.rle_to_mask) and [`sv.mask_to_rle`](https://supervision.roboflow.com/latest/detection/utils/converters/#supervision.detection.utils.converters.mask_to_rle) moved to `supervision.detection.utils.converters`. The old import path `supervision.dataset.utils` continues to work but is deprecated. + +- Fixed [#2178](https://github.com/roboflow/supervision/pull/2178): [`sv.rle_to_mask`](https://supervision.roboflow.com/latest/detection/utils/converters/#supervision.detection.utils.converters.rle_to_mask) now returns `NDArray[bool]` as declared in its signature. Previously the implementation returned `uint8` despite the `bool` annotation; code that relied on the undocumented `uint8` output (e.g. `mask * 255` producing `uint8`) should wrap the result with `.astype(np.uint8)`. + +- Fixed [#2210](https://github.com/roboflow/supervision/pull/2210): [`sv.VideoInfo.fps`](https://supervision.roboflow.com/latest/utils/video/#supervision.utils.video.VideoInfo) now returns a `float` instead of a truncated `int`. Previously, frame rates like 23.976, 29.97, and 59.94 were silently truncated, causing frame-timing drift that accumulates over long videos. The type of `VideoInfo.fps` has changed from `int` to `float`; callers that pass `fps` to APIs requiring an integer (such as `deque(maxlen=...)` or `TraceAnnotator(trace_length=...)`) should wrap the value with `int()`. + +- Fixed [#2209](https://github.com/roboflow/supervision/pull/2209): [`sv.Detections.is_empty()`](https://supervision.roboflow.com/latest/detection/core/#supervision.detection.core.Detections.is_empty) now returns `True` for detections filtered down to zero rows, even when `tracker_id` is an empty array. Previously this case incorrectly returned `False`. + +- Fixed [#2199](https://github.com/roboflow/supervision/pull/2199): [`sv.CSVSink`](https://supervision.roboflow.com/latest/detection/tools/save_detections/#supervision.detection.tools.csv_sink.CSVSink) now correctly slices numpy array values in `custom_data` per row. Previously the full array was written for every detection. + +- Fixed [#2216](https://github.com/roboflow/supervision/pull/2216): [`sv.CSVSink`](https://supervision.roboflow.com/latest/detection/tools/save_detections/#supervision.detection.tools.csv_sink.CSVSink) and [`sv.JSONSink`](https://supervision.roboflow.com/latest/detection/tools/save_detections/#supervision.detection.tools.json_sink.JSONSink) now slice plain Python `list` and `tuple` values in `custom_data` per detection row. Lists and tuples matching the detection count are indexed per row, consistent with `np.ndarray` behavior. + +- Fixed [#2217](https://github.com/roboflow/supervision/pull/2217): [`sv.TraceAnnotator`](https://supervision.roboflow.com/latest/detection/annotators/#supervision.annotators.core.TraceAnnotator) no longer crashes in `smooth` mode when a tracker remains stationary. Duplicate consecutive points caused `splprep` to fail; the annotator now deduplicates anchor points and falls back to a raw polyline when fewer than 4 unique points are available. + +- Fixed [#2218](https://github.com/roboflow/supervision/pull/2218): [`load_coco_annotations`](https://supervision.roboflow.com/latest/datasets/core/) now rejects COCO annotations whose `file_name` escapes the images directory via `../` traversal or absolute paths, preventing path-traversal attacks from malicious annotation files. + +- Fixed [#2187](https://github.com/roboflow/supervision/pull/2187): Extreme memory usage when loading OBB (oriented bounding box) datasets, caused by allocating full-image masks for each rotated box, has been resolved. + +- Fixed [#2188](https://github.com/roboflow/supervision/pull/2188): [`sv.KeyPoints`](https://supervision.roboflow.com/latest/keypoint/core/#supervision.key_points.core.KeyPoints) boolean mask indexing now works correctly when all instances have the same keypoint count (uniform-count selection). + +- Fixed [#2185](https://github.com/roboflow/supervision/pull/2185): [`sv.DetectionDataset.as_coco()`](https://supervision.roboflow.com/latest/datasets/core/#supervision.dataset.core.DetectionDataset.as_coco) now preserves `area` and `iscrowd` fields instead of silently dropping them in the round-trip. + +- Fixed [#1746](https://github.com/roboflow/supervision/pull/1746): Precision loss when converting annotations with `force_mask=True` in dataset format converters. + +- Fixed [#1991](https://github.com/roboflow/supervision/pull/1991): [`sv.PolygonZone`](https://supervision.roboflow.com/latest/detection/tools/polygon_zone/) no longer double-counts the same object when multiple zones overlap. Detection bounding boxes were incorrectly clipped to each zone's ROI before anchor computation, causing the same detection to appear at a different anchor point in each zone; anchor is now computed from the original bounding box so containment is independent per zone. + +- Fixed [#1868](https://github.com/roboflow/supervision/pull/1868): [`sv.LineZone`](https://supervision.roboflow.com/latest/detection/tools/line_zone/) no longer mis-attributes crossings when a tracker reuses the same `tracker_id` across different classes. Class-aware bookkeeping prevents a new object from inheriting another class's prior crossing state. + +- Fixed [#2022](https://github.com/roboflow/supervision/pull/2022): [`sv.process_video`](https://supervision.roboflow.com/latest/utils/video/#supervision.utils.video.process_video) now raises immediately when the user callback throws, instead of silently swallowing the exception and hanging until the writer is flushed. + +- Fixed [#2156](https://github.com/roboflow/supervision/pull/2156): [`sv.DetectionDataset`](https://supervision.roboflow.com/latest/datasets/core/#supervision.dataset.core.DetectionDataset) now populates `data["class_name"]` on every loaded annotation, matching what model connectors produce. Downstream code can rely on `class_name` being present whether detections come from a dataset or a model. + +- Fixed [#1364](https://github.com/roboflow/supervision/pull/1364): [`sv.ByteTrack`](https://supervision.roboflow.com/latest/trackers/#supervision.tracker.byte_tracker.core.ByteTrack) now preserves externally assigned `tracker_id` values instead of overwriting them with internal ids on the first update. + +- Fixed [#1853](https://github.com/roboflow/supervision/pull/1853): [`sv.ConfusionMatrix`](https://supervision.roboflow.com/latest/detection/metrics/#supervision.metrics.detection.ConfusionMatrix) `evaluate_detection_batch` now matches predictions to ground truth correctly when multiple detections fall on the same target. Previously, double-counting inflated false-positive and false-negative counts. + +- Fixed [#2136](https://github.com/roboflow/supervision/pull/2136): [`sv.MeanAverageRecall`](https://supervision.roboflow.com/latest/metrics/mean_average_recall/) now computes mAR@K using the top-K detections per image, matching the COCO definition. Previous values were inflated relative to `pycocotools`. + +- Fixed [#1086](https://github.com/roboflow/supervision/pull/1086), [#265](https://github.com/roboflow/supervision/pull/265): COCO export and `force_masks` behaviour are now consistent across dataset formats. Empty polygons no longer raise during `as_coco`, and `force_masks=True` produces masks regardless of source format. + +- Deprecated [#2215](https://github.com/roboflow/supervision/pull/2215): [`sv.ByteTrack`](https://supervision.roboflow.com/latest/trackers/#supervision.tracker.byte_tracker.core.ByteTrack) is deprecated in favour of `ByteTrackTracker` from the external [`trackers`](https://pypi.org/project/trackers/) package (`pip install trackers`). The update method is renamed from `update_with_detections()` to `update()`. Removal is now planned for `supervision-0.31.0`. + +- Deprecated [#2214](https://github.com/roboflow/supervision/pull/2214): `supervision.keypoint` module is deprecated; use `supervision.key_points` instead. `create_tiles` in `supervision.utils.image`, `ensure_cv2_image_for_processing` in `supervision.utils.conversion`, and keypoint validation utilities in `supervision.validators` are deprecated. The `LMM` enum (use `VLM`) and `from_lmm` method (use `from_vlm`) were deprecated in 0.26.0; this release migrates their deprecation mechanism to `pydeprecate`. + +- Deprecated: `normalized_xyxy` argument in [`sv.denormalize_boxes`](https://supervision.roboflow.com/latest/detection/utils/boxes/#supervision.detection.utils.boxes.denormalize_boxes) renamed to `xyxy`. Passing `normalized_xyxy=` now emits a `FutureWarning`; support will be removed in `supervision-0.31.0`. + +### 0.27.0 Nov 16, 2025 + +- Added [#2008](https://github.com/roboflow/supervision/pull/2008): [`sv.filter_segments_by_distance`](https://supervision.roboflow.com/0.27.0/detection/utils/masks/#supervision.detection.utils.masks.filter_segments_by_distance) to keep the largest connected component and nearby components within an absolute or relative distance threshold. Useful for cleaning segmentation predictions from models such as SAM, SAM2, YOLO segmentation, and RF-DETR segmentation. + +- Added [#2006](https://github.com/roboflow/supervision/pull/2006): [`sv.xyxy_to_mask`](https://supervision.roboflow.com/0.27.0/detection/utils/converters/#supervision.detection.utils.converters.xyxy_to_mask) to convert bounding boxes into 2D boolean masks, where each mask corresponds to a single box. + +- Added [#1943](https://github.com/roboflow/supervision/pull/1943): [`sv.tint_image`](https://supervision.roboflow.com/0.27.0/utils/image/#supervision.utils.image.tint_image) to apply a solid color overlay to an image at a given opacity. Works with both NumPy and PIL inputs. + +- Added [#1943](https://github.com/roboflow/supervision/pull/1943): [`sv.grayscale_image`](https://supervision.roboflow.com/0.27.0/utils/image/#supervision.utils.image.tint_image) to convert an image to 3 channel grayscale for compatibility with color based drawing utilities. + +- Added [#2014](https://github.com/roboflow/supervision/pull/2014): [`sv.get_image_resolution_wh`](https://supervision.roboflow.com/0.27.0/utils/image/#supervision.utils.image.get_image_resolution_wh) as a unified way to read image width and height from NumPy and PIL inputs. + +- Added [#1912](https://github.com/roboflow/supervision/pull/1912): [`sv.edit_distance`](https://supervision.roboflow.com/0.27.0/detection/utils/vlms/#supervision.detection.utils.vlms.edit_distance) for Levenshtein distance between two strings. Supports insert, delete, and substitute operations. + +- Added [#1912](https://github.com/roboflow/supervision/pull/1912): [`sv.fuzzy_match_index`](https://supervision.roboflow.com/0.27.0/detection/utils/vlms/#supervision.detection.utils.vlms.fuzzy_match_index) to find the first close match in a list using edit distance. + +- Changed [#2015](https://github.com/roboflow/supervision/pull/2015): [`sv.Detections.from_vlm`](https://supervision.roboflow.com/0.27.0/detection/core/#supervision.detection.core.Detections.from_vlm) and legacy `from_lmm` now support Qwen3 VL via `vlm=sv.VLM.QWEN_3_VL`. + +- Changed [#1884](https://github.com/roboflow/supervision/pull/1884): [`sv.Detections.from_vlm`](https://supervision.roboflow.com/0.27.0/detection/core/#supervision.detection.core.Detections.from_vlm) and legacy `from_lmm` now support DeepSeek VL 2 via `vlm=sv.VLM.DEEPSEEK_VL_2`. + +- Changed [#2015](https://github.com/roboflow/supervision/pull/2015): [`sv.Detections.from_vlm`](https://supervision.roboflow.com/0.27.0/detection/core/#supervision.detection.core.Detections.from_vlm) now parses Qwen 2.5 VL outputs more robustly and handles incomplete or truncated JSON responses. + +- Changed [#2014](https://github.com/roboflow/supervision/pull/2014): [`sv.InferenceSlicer`](https://supervision.roboflow.com/0.27.0/detection/tools/inference_slicer/#supervision.detection.tools.inference_slicer.InferenceSlicer) now uses a new offset generation logic that removes redundant tiles and aligns borders cleanly. This reduces the number of processed tiles and shortens inference time without hurting detection quality. + +- Changed [#2016](https://github.com/roboflow/supervision/pull/2016): [`sv.Detections`](https://supervision.roboflow.com/0.27.0/detection/core/#supervision.detection.core.Detections) now includes a `box_aspect_ratio` property for vectorized aspect ratio computation, useful for filtering detections based on box shape. + +- Changed [#2001](https://github.com/roboflow/supervision/pull/2001): Significantly improved the performance of [`sv.box_iou_batch`](https://supervision.roboflow.com/0.27.0/detection/utils/iou_and_nms/#supervision.detection.utils.iou_and_nms.box_iou_batch). On internal benchmarks, processing runs approximately 2x to 5x faster. + +- Changed [#1997](https://github.com/roboflow/supervision/pull/1997): [`sv.process_video`](https://supervision.roboflow.com/0.27.0/utils/video/#supervision.utils.video.process_video) now uses a threaded reader, processor, and writer pipeline. This removes I/O stalls and improves throughput while keeping the callback single threaded and safe for stateful models. + +- Changed: [`sv.denormalize_boxes`](https://supervision.roboflow.com/0.27.0/detection/utils/boxes/#supervision.detection.utils.boxes.denormalize_boxes) now supports batch conversion of bounding boxes. The function accepts arrays of shape `(N, 4)` and returns a batch of absolute pixel coordinates. + +- Changed [#1917](https://github.com/roboflow/supervision/pull/1917): [`sv.LabelAnnotator`](https://supervision.roboflow.com/0.27.0/detection/annotators/#supervision.annotators.core.LabelAnnotator) and [`sv.RichLabelAnnotator`](https://supervision.roboflow.com/0.27.0/detection/annotators/#supervision.annotators.core.RichLabelAnnotator) now accept `text_offset=(x, y)` to shift the label relative to `text_position`. Works with smart label position and line wrapping. + +!!! failure "Removed" + Removed the deprecated `overlap_ratio_wh` argument from `sv.InferenceSlicer`. Use the pixel based `overlap_wh` argument to control slice overlap. + +!!! info "Tip" + Convert your old ratio based overlap to pixel based overlap by multiplying each ratio by the slice dimensions. + + ```python + # before + + slice_wh = (640, 640) + overlap_ratio_wh = (0.25, 0.25) + + slicer = sv.InferenceSlicer( + callback=callback, + slice_wh=slice_wh, + overlap_ratio_wh=overlap_ratio_wh, + overlap_filter=sv.OverlapFilter.NON_MAX_SUPPRESSION, + ) + + # after + + overlap_wh = ( + int(overlap_ratio_wh[0] * slice_wh[0]), + int(overlap_ratio_wh[1] * slice_wh[1]), + ) + + slicer = sv.InferenceSlicer( + callback=callback, + slice_wh=slice_wh, + overlap_wh=overlap_wh, + overlap_filter=sv.OverlapFilter.NON_MAX_SUPPRESSION, + ) + ``` + +### 0.26.1 Jul 22, 2025 + +- Fixed [1894](https://github.com/roboflow/supervision/pull/1894): Error in [`sv.MeanAveragePrecision`](https://supervision.roboflow.com/0.26.1/metrics/mean_average_precision/#supervision.metrics.mean_average_precision.MeanAveragePrecision) where the area used for size-specific evaluation (small / medium / large) was always zero unless explicitly provided in `sv.Detections.data`. + +- Fixed [1895](https://github.com/roboflow/supervision/pull/1895): `ID=0` bug in [`sv.MeanAveragePrecision`](https://supervision.roboflow.com/0.26.1/metrics/mean_average_precision/#supervision.metrics.mean_average_precision.MeanAveragePrecision) where objects were getting `0.0` mAP despite perfect IoU matches due to a bug in annotation ID assignment. + +- Fixed [1898](https://github.com/roboflow/supervision/pull/1898): Issue where [`sv.MeanAveragePrecision`](https://supervision.roboflow.com/0.26.1/metrics/mean_average_precision/#supervision.metrics.mean_average_precision.MeanAveragePrecision) could return negative values when certain object size categories have no data. + +- Fixed [1901](https://github.com/roboflow/supervision/pull/1901): `match_metric` support for [`sv.Detections.with_nms`](https://supervision.roboflow.com/0.26.1/metrics/mean_average_precision/#supervision.detection.core.Detections.with_nms). + +- Fixed [1906](https://github.com/roboflow/supervision/pull/1906): `border_thickness` parameter usage for [`sv.PercentageBarAnnotator`](https://supervision.roboflow.com/0.26.1/metrics/mean_average_precision/#supervision.annotators.core.PercentageBarAnnotator). + +### 0.26.0 Jul 16, 2025 + +!!! failure "Removed" + `supervision-0.26.0` drops `python3.8` support and upgrade all codes to `python3.9` syntax style. + +!!! info "Tip" + Supervisionโ€™s documentation theme now has a fresh look that is consistent with the documentations of all Roboflow open-source projects. ([#1858](https://github.com/roboflow/supervision/pull/1858)) + +- Added [#1774](https://github.com/roboflow/supervision/pull/1774): Support for the IOS (Intersection over Smallest) overlap metric that measures how much of the smaller object is covered by the larger one in [`sv.Detections.with_nms`](https://supervision.roboflow.com/0.26.0/detection/core/#supervision.detection.core.Detections.with_nms), [`sv.Detections.with_nmm`](https://supervision.roboflow.com/0.26.0/detection/core/#supervision.detection.core.Detections.with_nmm), [`sv.box_iou_batch`](https://supervision.roboflow.com/0.26.0/detection/utils/iou_and_nms/#supervision.detection.utils.iou_and_nms.box_iou_batch), and [`sv.mask_iou_batch`](https://supervision.roboflow.com/0.26.0/detection/utils/iou_and_nms/#supervision.detection.utils.iou_and_nms.mask_iou_batch). + + ```python + import numpy as np + import supervision as sv + + boxes_true = np.array([ + [100, 100, 200, 200], + [300, 300, 400, 400] + ]) + boxes_detection = np.array([ + [150, 150, 250, 250], + [320, 320, 420, 420] + ]) + + sv.box_iou_batch( + boxes_true=boxes_true, + boxes_detection=boxes_detection, + overlap_metric=sv.OverlapMetric.IOU + ) + + # array([[0.14285714, 0. ], + # [0. , 0.47058824]]) + + sv.box_iou_batch( + boxes_true=boxes_true, + boxes_detection=boxes_detection, + overlap_metric=sv.OverlapMetric.IOS + ) + + # array([[0.25, 0. ], + # [0. , 0.64]]) + ``` + +- Added [#1874](https://github.com/roboflow/supervision/pull/1874): [`sv.box_iou`](https://supervision.roboflow.com/0.26.0/detection/utils/iou_and_nms/#supervision.detection.utils.iou_and_nms.box_iou) that efficiently computes the Intersection over Union (IoU) between two individual bounding boxes. + +- Added [#1816](https://github.com/roboflow/supervision/pull/1816): Support for frame limitations and progress bar in [`sv.process_video`](https://supervision.roboflow.com/0.26.0/utils/video/#supervision.utils.video.process_video). + +- Added [#1788](https://github.com/roboflow/supervision/pull/1788): Support for creating [`sv.KeyPoints`](https://supervision.roboflow.com/0.26.0/keypoint/core/#supervision.keypoint.core.KeyPoints) objects from [ViTPose](https://huggingface.co/docs/transformers/en/model_doc/vitpose) and [ViTPose++](https://huggingface.co/docs/transformers/en/model_doc/vitpose#vitpose-models) inference results via [`sv.KeyPoints.from_transformers`](https://supervision.roboflow.com/0.26.0/keypoint/core/#supervision.keypoint.core.KeyPoints.from_transformers). + +- Added [#1823](https://github.com/roboflow/supervision/pull/1823): [`sv.xyxy_to_xcycarh`](https://supervision.roboflow.com/0.26.0/detection/utils/converters/#supervision.detection.utils.converters.xyxy_to_xcycarh) function to convert bounding box coordinates from `(x_min, y_min, x_max, y_max)` into measurement space to format `(center x, center y, aspect ratio, height)`, where the aspect ratio is `width / height`. + +- Added [#1788](https://github.com/roboflow/supervision/pull/1788): [`sv.xyxy_to_xywh`](https://supervision.roboflow.com/0.26.0/detection/utils/converters/#supervision.detection.utils.converters.xyxy_to_xywh) function to convert bounding box coordinates from `(x_min, y_min, x_max, y_max)` format to `(x, y, width, height)` format. + +- Changed [#1820](https://github.com/roboflow/supervision/pull/1820): [`sv.LabelAnnotator`](https://supervision.roboflow.com/0.26.0/detection/annotators/#supervision.annotators.core.LabelAnnotator) now supports the `smart_position` parameter to automatically keep labels within frame boundaries, and the `max_line_length` parameter to control text wrapping for long or multi-line labels. + +- Changed [#1825](https://github.com/roboflow/supervision/pull/1825): [`sv.LabelAnnotator`](https://supervision.roboflow.com/0.26.0/detection/annotators/#supervision.annotators.core.LabelAnnotator) now supports non-string labels. + +- Changed [#1792](https://github.com/roboflow/supervision/pull/1792): [`sv.Detections.from_vlm`](https://supervision.roboflow.com/0.26.0/detection/core/#supervision.detection.core.Detections.from_vlm) now supports parsing bounding boxes and segmentation masks from responses generated by [Google Gemini models](https://ai.google.dev/gemini-api/docs/vision). + + ```python + import supervision as sv + + gemini_response_text = """```json + [ + {"box_2d": [543, 40, 728, 200], "label": "cat", "id": 1}, + {"box_2d": [653, 352, 820, 522], "label": "dog", "id": 2} + ] + ```""" + + detections = sv.Detections.from_vlm( + sv.VLM.GOOGLE_GEMINI_2_5, + gemini_response_text, + resolution_wh=(1000, 1000), + classes=['cat', 'dog'], + ) + + detections.xyxy + # array([[543., 40., 728., 200.], [653., 352., 820., 522.]]) + + detections.data + # {'class_name': array(['cat', 'dog'], dtype='Nov 12, 2024 + +- No removals or deprecations in this release! + +- Essential update to the [`LineZone`](https://supervision.roboflow.com/0.25.0/detection/tools/line_zone/): when computing line crossings, detections that jitter might be counted twice (or more). This can now be solved with the `minimum_crossing_threshold` argument. If you set it to `2` or more, extra frames will be used to confirm the crossing, improving the accuracy significantly. ([#1540](https://github.com/roboflow/supervision/pull/1540)) + +- It is now possible to track objects detected as [`KeyPoints`](https://supervision.roboflow.com/0.25.0/keypoint/core/#supervision.keypoint.core.KeyPoints). See the complete step-by-step guide in the [Object Tracking Guide](https://supervision.roboflow.com/latest/how_to/track_objects/#keypoints). ([#1658](https://github.com/roboflow/supervision/pull/1658)) + +```python +import numpy as np +import supervision as sv +from ultralytics import YOLO + +model = YOLO("yolov8m-pose.pt") +tracker = sv.ByteTrack() +trace_annotator = sv.TraceAnnotator() + +def callback(frame: np.ndarray, _: int) -> np.ndarray: + results = model(frame)[0] + key_points = sv.KeyPoints.from_ultralytics(results) + + detections = key_points.as_detections() + detections = tracker.update_with_detections(detections) + + annotated_image = trace_annotator.annotate(frame.copy(), detections) + return annotated_image + +sv.process_video( + source_path="input_video.mp4", + target_path="output_video.mp4", + callback=callback +) +``` + +- Added `is_empty` method to [`KeyPoints`](https://supervision.roboflow.com/0.25.0/keypoint/core/#supervision.keypoint.core.KeyPoints) to check if there are any keypoints in the object. ([#1658](https://github.com/roboflow/supervision/pull/1658)) + +- Added `as_detections` method to [`KeyPoints`](https://supervision.roboflow.com/0.25.0/keypoint/core/#supervision.keypoint.core.KeyPoints) that converts `KeyPoints` to `Detections`. ([#1658](https://github.com/roboflow/supervision/pull/1658)) + +- Added a new video to the `supervision.assets` download catalog. ([#1657](https://github.com/roboflow/supervision/pull/1657)) + +```python +from supervision.assets import download_assets, VideoAssets + +path_to_video = download_assets(VideoAssets.SKIING) +``` + +- Supervision can now be used with [`Python 3.13`](https://docs.python.org/3/whatsnew/3.13.html). The most renowned update is the ability to run Python [without Global Interpreter Lock (GIL)](https://docs.python.org/3/whatsnew/3.13.html#whatsnew313-free-threaded-cpython). We expect support for this among our dependencies to be inconsistent, but if you do attempt it - let us know the results! ([#1595](https://github.com/roboflow/supervision/pull/1595)) + +- Added [`Mean Average Recall`](https://supervision.roboflow.com/latest/metrics/mean_average_recall/) mAR metric, which returns a recall score, averaged over IoU thresholds, detected object classes, and limits imposed on maximum considered detections. ([#1661](https://github.com/roboflow/supervision/pull/1661)) + +```python +import supervision as sv +from supervision.metrics import MeanAverageRecall + +predictions = sv.Detections(...) +targets = sv.Detections(...) + +map_metric = MeanAverageRecall() +map_result = map_metric.update(predictions, targets).compute() + +map_result.plot() +``` + +- Added [`Precision`](https://supervision.roboflow.com/latest/metrics/precision/) and [`Recall`](https://supervision.roboflow.com/latest/metrics/recall/) metrics, providing a baseline for comparing model outputs to ground truth or another model ([#1609](https://github.com/roboflow/supervision/pull/1609)) + +```python +import supervision as sv +from supervision.metrics import Recall + +predictions = sv.Detections(...) +targets = sv.Detections(...) + +recall_metric = Recall() +recall_result = recall_metric.update(predictions, targets).compute() + +recall_result.plot() +``` + +- All Metrics now support Oriented Bounding Boxes (OBB) ([#1593](https://github.com/roboflow/supervision/pull/1593)) + +```python +import supervision as sv +from supervision.metrics import F1_Score + +predictions = sv.Detections(...) +targets = sv.Detections(...) + +f1_metric = MeanAverageRecall(metric_target=sv.MetricTarget.ORIENTED_BOUNDING_BOXES) +f1_result = f1_metric.update(predictions, targets).compute() +``` + +- Introducing Smart Labels! When `smart_position` is set for [`LabelAnnotator`](https://supervision.roboflow.com/0.25.0/detection/annotators/#supervision.annotators.core.LabelAnnotator), [`RichLabelAnnotator`](https://supervision.roboflow.com/0.25.0/detection/annotators/#supervision.annotators.core.RichLabelAnnotator) or [`VertexLabelAnnotator`](https://supervision.roboflow.com/0.25.0/detection/annotators/#supervision.annotators.core.RichLabelAnnotator), the labels will move around to avoid overlapping others. ([#1625](https://github.com/roboflow/supervision/pull/1625)) + +```python +import supervision as sv +from ultralytics import YOLO + +image = cv2.imread("image.jpg") + +label_annotator = sv.LabelAnnotator(smart_position=True) + +model = YOLO("yolo11m.pt") +results = model(image)[0] +detections = sv.Detections.from_ultralytics(results) + +annotated_frame = label_annotator.annotate(first_frame.copy(), detections) +sv.plot_image(annotated_frame) +``` + +- Added the `metadata` variable to [`Detections`](https://supervision.roboflow.com/0.25.0/detection/core/#supervision.detection.core.Detections). It allows you to store custom data per-image, rather than per-detected-object as was possible with `data` variable. For example, `metadata` could be used to store the source video path, camera model or camera parameters. ([#1589](https://github.com/roboflow/supervision/pull/1589)) + +```python +import supervision as sv +from ultralytics import YOLO + +model = YOLO("yolov8m") + +result = model("image.png")[0] +detections = sv.Detections.from_ultralytics(result) + +# Items in `data` must match length of detections +object_ids = [num for num in range(len(detections))] +detections.data["object_number"] = object_ids + +# Items in `metadata` can be of any length. +detections.metadata["camera_model"] = "Luxonis OAK-D" +``` + +- Added a `py.typed` type hints metafile. It should provide a stronger signal to type annotators and IDEs that type support is available. ([#1586](https://github.com/roboflow/supervision/pull/1586)) + +- `ByteTrack` no longer requires `detections` to have a `class_id` ([#1637](https://github.com/roboflow/supervision/pull/1637)) +- `draw_line`, `draw_rectangle`, `draw_filled_rectangle`, `draw_polygon`, `draw_filled_polygon` and `PolygonZoneAnnotator` now comes with a default color ([#1591](https://github.com/roboflow/supervision/pull/1591)) +- Dataset classes are treated as case-sensitive when merging multiple datasets. ([#1643](https://github.com/roboflow/supervision/pull/1643)) +- Expanded [metrics documentation](https://supervision.roboflow.com/0.25.0/metrics/f1_score/) with example plots and printed results ([#1660](https://github.com/roboflow/supervision/pull/1660)) +- Added usage example for polygon zone ([#1608](https://github.com/roboflow/supervision/pull/1608)) +- Small improvements to error handling in polygons: ([#1602](https://github.com/roboflow/supervision/pull/1602)) + +- Updated [`ByteTrack`](https://supervision.roboflow.com/0.25.0/trackers/#supervision.tracker.byte_tracker.core.ByteTrack), removing shared variables. Previously, multiple instances of `ByteTrack` would share some date, requiring liberal use of `tracker.reset()`. ([#1603](https://github.com/roboflow/supervision/pull/1603)), ([#1528](https://github.com/roboflow/supervision/pull/1528)) +- Fixed a bug where `class_agnostic` setting in `MeanAveragePrecision` would not work. ([#1577](https://github.com/roboflow/supervision/pull/1577)) hacktoberfest +- Removed welcome workflow from our CI system. ([#1596](https://github.com/roboflow/supervision/pull/1596)) + +- Large refactor of `ByteTrack`: STrack moved to separate class, removed superfluous `BaseTrack` class, removed unused variables ([#1603](https://github.com/roboflow/supervision/pull/1603)) +- Large refactor of `RichLabelAnnotator`, matching its contents with `LabelAnnotator`. ([#1625](https://github.com/roboflow/supervision/pull/1625)) + +### 0.24.0 Oct 4, 2024 + +- Added [F1 score](https://supervision.roboflow.com/0.24.0/metrics/f1_score/#supervision.metrics.f1_score.F1Score) as a new metric for detection and segmentation. [#1521](https://github.com/roboflow/supervision/pull/1521) + +```python +import supervision as sv +from supervision.metrics import F1Score + +predictions = sv.Detections(...) +targets = sv.Detections(...) + +f1_metric = F1Score() +f1_result = f1_metric.update(predictions, targets).compute() + +print(f1_result) +print(f1_result.f1_50) +print(f1_result.small_objects.f1_50) +``` + +- Added new cookbook: [Small Object Detection with SAHI](https://supervision.roboflow.com/0.24.0/notebooks/small-object-detection-with-sahi/). This cookbook provides a detailed guide on using [`InferenceSlicer`](https://supervision.roboflow.com/0.24.0/detection/tools/inference_slicer/) for small object detection. [#1483](https://github.com/roboflow/supervision/pull/1483) + +- Added an [Embedded Workflow](https://roboflow.com/workflows), which allows you to [preview annotators](https://supervision.roboflow.com/0.24.0/detection/annotators/). [#1533](https://github.com/roboflow/supervision/pull/1533) + +- Enhanced [`LineZoneAnnotator`](https://supervision.roboflow.com/0.24.0/detection/tools/line_zone/#supervision.detection.line_zone.LineZoneAnnotator), allowing the labels to align with the line, even when it's not horizontal. Also, you can now disable text background, and choose to draw labels off-center which minimizes overlaps for multiple [`LineZone`](https://supervision.roboflow.com/0.24.0/detection/tools/line_zone/#supervision.detection.line_zone.LineZone) labels. [#854](https://github.com/roboflow/supervision/pull/854) + +```python +import supervision as sv +import cv2 + +image = cv2.imread("") + +line_zone = sv.LineZone( + start=sv.Point(0, 100), + end=sv.Point(50, 200) +) +line_zone_annotator = sv.LineZoneAnnotator( + text_orient_to_line=True, + display_text_box=False, + text_centered=False +) + +annotated_frame = line_zone_annotator.annotate( + frame=image.copy(), line_counter=line_zone +) + +sv.plot_image(frame) +``` + +- Added per-class counting capabilities to [`LineZone`](https://supervision.roboflow.com/0.24.0/detection/tools/line_zone/#supervision.detection.line_zone.LineZone) and introduced [`LineZoneAnnotatorMulticlass`](https://supervision.roboflow.com/0.24.0/detection/tools/line_zone/#supervision.detection.line_zone.LineZoneAnnotatorMulticlass) for visualizing the counts per class. This feature allows tracking of individual classes crossing a line, enhancing the flexibility of use cases like traffic monitoring or crowd analysis. [#1555](https://github.com/roboflow/supervision/pull/1555) + +```python +import supervision as sv +import cv2 + +image = cv2.imread("") + +line_zone = sv.LineZone( + start=sv.Point(0, 100), + end=sv.Point(50, 200) +) +line_zone_annotator = sv.LineZoneAnnotatorMulticlass() + +frame = line_zone_annotator.annotate( + frame=frame, line_zones=[line_zone] +) + +sv.plot_image(frame) +``` + +- Added [`from_easyocr`](https://supervision.roboflow.com/0.24.0/detection/core/#supervision.detection.core.Detections.from_easyocr), allowing integration of OCR results into the supervision framework. [EasyOCR](https://github.com/JaidedAI/EasyOCR) is an open-source optical character recognition (OCR) library that can read text from images. [#1515](https://github.com/roboflow/supervision/pull/1515) + +```python +import supervision as sv +import easyocr +import cv2 + +image = cv2.imread("") + +reader = easyocr.Reader(["en"]) +result = reader.readtext("", paragraph=True) +detections = sv.Detections.from_easyocr(result) + +box_annotator = sv.BoxAnnotator(color_lookup=sv.ColorLookup.INDEX) +label_annotator = sv.LabelAnnotator(color_lookup=sv.ColorLookup.INDEX) + +annotated_image = image.copy() +annotated_image = box_annotator.annotate(scene=annotated_image, detections=detections) +annotated_image = label_annotator.annotate(scene=annotated_image, detections=detections) + +sv.plot_image(annotated_image) +``` + +- Added [`oriented_box_iou_batch`](https://supervision.roboflow.com/0.24.0/detection/utils/#supervision.detection.utils.oriented_box_iou_batch) function to `detection.utils`. This function computes Intersection over Union (IoU) for oriented or rotated bounding boxes (OBB). [#1502](https://github.com/roboflow/supervision/pull/1502) + +```python +import numpy as np + +boxes_true = np.array([[[1, 0], [0, 1], [3, 4], [4, 3]]]) +boxes_detection = np.array([[[1, 1], [2, 0], [4, 2], [3, 3]]]) +ious = sv.oriented_box_iou_batch(boxes_true, boxes_detection) +print("IoU between true and detected boxes:", ious) +``` + +- Extended [`PolygonZoneAnnotator`](https://supervision.roboflow.com/0.24.0/detection/tools/polygon_zone/#supervision.detection.tools.polygon_zone.PolygonZoneAnnotator) to allow setting opacity when drawing zones, providing enhanced visualization by filling the zone with adjustable transparency. [#1527](https://github.com/roboflow/supervision/pull/1527) + +```python +import cv2 +from ncnn.model_zoo import get_model +import supervision as sv + +image = cv2.imread("") +model = get_model( + "yolov8s", + target_size=640, + prob_threshold=0.5, + nms_threshold=0.45, + num_threads=4, + use_gpu=True, +) +result = model(image) +detections = sv.Detections.from_ncnn(result) +``` + +!!! failure "Removed" + + The `frame_resolution_wh` parameter in [`PolygonZone`](https://supervision.roboflow.com/0.24.0/detection/tools/polygon_zone/#supervision.detection.tools.polygon_zone.PolygonZone) has been removed. + +!!! failure "Removed" + + Supervision installation methods `"headless"` and `"desktop"` were removed, as they are no longer needed. `pip install supervision[headless]` will install the base library and harmlessly warn of non-existent extras. + +- Supervision now depends on `opencv-python` rather than `opencv-python-headless`. [#1530](https://github.com/roboflow/supervision/pull/1530) + +- Fixed the COCO 101 point Average Precision algorithm to correctly interpolate precision, providing a more precise calculation of average precision without averaging out intermediate values. [#1500](https://github.com/roboflow/supervision/pull/1500) + +- Resolved miscellaneous issues highlighted when building documentation. This mostly includes whitespace adjustments and type inconsistencies. Updated documentation for clarity and fixed formatting issues. Added explicit version for `mkdocstrings-python`. [#1549](https://github.com/roboflow/supervision/pull/1549) + +- Enabled and fixed Ruff rules for code formatting, including changes like avoiding unnecessary iterable allocations and using Optional for default mutable arguments. [#1526](https://github.com/roboflow/supervision/pull/1526) + +### 0.23.0 Aug 28, 2024 + +- Added [#930](https://github.com/roboflow/supervision/pull/930): `IconAnnotator`, a [new annotator](https://supervision.roboflow.com/0.23.0/detection/annotators/#supervision.annotators.core.IconAnnotator) that allows drawing icons on each detection. Useful if you want to draw a specific icon for each class. + +```python +import supervision as sv +from inference import get_model + +image = +icon_dog = +icon_cat = + +model = get_model(model_id="yolov8n-640") +results = model.infer(image)[0] +detections = sv.Detections.from_inference(results) + +icon_paths = [] +for class_name in detections.data["class_name"]: + if class_name == "dog": + icon_paths.append(icon_dog) + elif class_name == "cat": + icon_paths.append(icon_cat) + else: + icon_paths.append("") + +icon_annotator = sv.IconAnnotator() +annotated_frame = icon_annotator.annotate( + scene=image.copy(), + detections=detections, + icon_path=icon_paths +) +``` + +- Added [#1385](https://github.com/roboflow/supervision/pull/1385): [`BackgroundColorAnnotator`](https://supervision.roboflow.com/0.23.0/detection/annotators/#supervision.annotators.core.BackgroundColorAnnotator), that draws an overlay on the background images of the detections. + +```python +import supervision as sv +from inference import get_model + +image = + +model = get_model(model_id="yolov8n-640") +results = model.infer(image)[0] +detections = sv.Detections.from_inference(results) + +background_overlay_annotator = sv.BackgroundOverlayAnnotator() +annotated_frame = background_overlay_annotator.annotate( + scene=image.copy(), + detections=detections +) +``` + +- Added [#1386](https://github.com/roboflow/supervision/pull/1386): Support for Transformers v5 functions in [`sv.Detections.from_transformers`](https://supervision.roboflow.com/0.23.0/detection/core/#supervision.detection.core.Detections.from_transformers). This includes the `DetrImageProcessor` methods `post_process_object_detection`, `post_process_panoptic_segmentation`, `post_process_semantic_segmentation`, and `post_process_instance_segmentation`. + +```python +import torch +import supervision as sv +from PIL import Image +from transformers import DetrImageProcessor, DetrForObjectDetection + +processor = DetrImageProcessor.from_pretrained("facebook/detr-resnet-50") +model = DetrForObjectDetection.from_pretrained("facebook/detr-resnet-50") + +image = Image.open() +inputs = processor(images=image, return_tensors="pt") + +with torch.no_grad(): + outputs = model(**inputs) + +width, height = image.size +target_size = torch.tensor([[height, width]]) +results = processor.post_process_object_detection( + outputs=outputs, target_sizes=target_size)[0] +detections = sv.Detections.from_transformers( + transformers_results=results, + id2label=model.config.id2label) +``` + +- Added [#1354](https://github.com/roboflow/supervision/pull/1354): Ultralytics SAM (Segment Anything Model) support in [`sv.Detections.from_ultralytics`](https://supervision.roboflow.com/0.23.0/detection/core/#supervision.detection.core.Detections.from_ultralytics). [SAM2](https://sam2.metademolab.com/) was released during this update, and is already supported via [`sv.Detections.from_sam`](https://supervision.roboflow.com/0.23.0/detection/core/#supervision.detection.core.Detections.from_sam). + +```python +import supervision as sv +from segment_anything import ( + sam_model_registry, + SamAutomaticMaskGenerator +) +sam_model_reg = sam_model_registry[MODEL_TYPE] +sam = sam_model_reg(checkpoint=CHECKPOINT_PATH).to(device=DEVICE) +mask_generator = SamAutomaticMaskGenerator(sam) +sam_result = mask_generator.generate(IMAGE) +detections = sv.Detections.from_sam(sam_result=sam_result) +``` + +- Added [#1458](https://github.com/roboflow/supervision/pull/1458): `outline_color` options for [`TriangleAnnotator`](https://supervision.roboflow.com/0.23.0/detection/annotators/#supervision.annotators.core.TriangleAnnotator) and [`DotAnnotator`](https://supervision.roboflow.com/0.23.0/detection/annotators/#supervision.annotators.core.DotAnnotator). + +- Added [#1409](https://github.com/roboflow/supervision/pull/1409): `text_color` option for [`VertexLabelAnnotator`](https://supervision.roboflow.com/0.23.0/keypoint/annotators/#supervision.keypoint.annotators.VertexLabelAnnotator) keypoint annotator. + +- Changed [#1434](https://github.com/roboflow/supervision/pull/1434): [`InferenceSlicer`](https://supervision.roboflow.com/0.23.0/detection/tools/inference_slicer/) now features an `overlap_wh` parameter, making it easier to compute slice sizes when handling overlapping slices. + +- Fixed [#1448](https://github.com/roboflow/supervision/pull/1448): Various annotator type issues have been resolved, supporting expanded error handling. + +- Fixed [#1348](https://github.com/roboflow/supervision/pull/1348): Introduced a new method for [seeking to a specific video frame](https://supervision.roboflow.com/0.23.0/utils/video/#supervision.utils.video.get_video_frames_generator), addressing cases where traditional seek methods were failing. It can be enabled with `iterative_seek=True`. + +```python +import supervision as sv + +for frame in sv.get_video_frames_generator( + source_path=, + start=60, + iterative_seek=True +): + ... +``` + +- Fixed [#1424](https://github.com/roboflow/supervision/pull/1424): `plot_image` function now clearly indicates that the size is in inches. + +!!! failure "Removed" + + The `track_buffer`, `track_thresh`, and `match_thresh` parameters in [`ByteTrack`](trackers.md/#supervision.tracker.byte_tracker.core.ByteTrack) are deprecated and were removed as of `supervision-0.23.0`. Use `lost_track_buffer,` `track_activation_threshold`, and `minimum_matching_threshold` instead. + +!!! failure "Removed" + + The `triggering_position` parameter in [`sv.PolygonZone`](detection/tools/polygon_zone.md/#supervision.detection.tools.polygon_zone.PolygonZone) was removed as of `supervision-0.23.0`. Use `triggering_anchors` instead. + +!!! failure "Deprecated" + + `overlap_filter_strategy` in `InferenceSlicer.__init__` is deprecated and will be removed in `supervision-0.27.0`. Use `overlap_strategy` instead. + +!!! failure "Deprecated" + + `overlap_ratio_wh` in `InferenceSlicer.__init__` is deprecated and will be removed in `supervision-0.27.0`. Use `overlap_wh` instead. + +### 0.22.0 Jul 12, 2024 + +- Added [#1326](https://github.com/roboflow/supervision/pull/1326): [`sv.DetectionsDataset`](https://supervision.roboflow.com/0.22.0/datasets/core/#supervision.dataset.core.DetectionDataset) and [`sv.ClassificationDataset`](https://supervision.roboflow.com/0.22.0/datasets/core/#supervision.dataset.core.ClassificationDataset) allowing to load the images into memory only when necessary (lazy loading). + +!!! failure "Deprecated" + + Constructing `DetectionDataset` with parameter `images` as `Dict[str, np.ndarray]` is deprecated and will be removed in `supervision-0.26.0`. Please pass a list of paths `List[str]` instead. + +!!! failure "Deprecated" + + The `DetectionDataset.images` property is deprecated and will be removed in `supervision-0.26.0`. Please loop over images with `for path, image, annotation in dataset:`, as that does not require loading all images into memory. + +```python +import roboflow +from roboflow import Roboflow +import supervision as sv + +roboflow.login() +rf = Roboflow() + +project = rf.workspace().project() +dataset = project.version().download("coco") + +ds_train = sv.DetectionDataset.from_coco( + images_directory_path=f"{dataset.location}/train", + annotations_path=f"{dataset.location}/train/_annotations.coco.json", +) + +path, image, annotation = ds_train[0] + # loads image on demand + +for path, image, annotation in ds_train: + # loads image on demand +``` + +- Added [#1296](https://github.com/roboflow/supervision/pull/1296): [`sv.Detections.from_lmm`](https://supervision.roboflow.com/0.22.0/detection/core/#supervision.detection.core.Detections.from_lmm) now supports parsing results from the [Florence 2](https://huggingface.co/microsoft/Florence-2-large) model, extending the capability to handle outputs from this Large Multimodal Model (LMM). This includes detailed object detection, OCR with region proposals, segmentation, and more. Find out more in our [Colab notebook](https://colab.research.google.com/github/roboflow-ai/notebooks/blob/main/notebooks/how-to-finetune-florence-2-on-detection-dataset.ipynb). + +- Added [#1232](https://github.com/roboflow/supervision/pull/1232) to support keypoint detection with Mediapipe. Both [legacy](https://colab.research.google.com/github/googlesamples/mediapipe/blob/main/examples/pose_landmarker/python/%5BMediaPipe_Python_Tasks%5D_Pose_Landmarker.ipynb) and [modern](https://ai.google.dev/edge/mediapipe/solutions/vision/pose_landmarker/python) pipelines are supported. See [`sv.KeyPoints.from_mediapipe`](https://supervision.roboflow.com/0.22.0/keypoint/core/#supervision.keypoint.core.KeyPoints.from_mediapipe) for more. + +- Added [#1316](https://github.com/roboflow/supervision/pull/1316): [`sv.KeyPoints.from_mediapipe`](https://supervision.roboflow.com/0.22.0/keypoint/core/#supervision.keypoint.core.KeyPoints.from_mediapipe) extended to support FaceMesh from Mediapipe. This enhancement allows for processing both face landmarks from `FaceLandmarker`, and legacy results from `FaceMesh`. + +- Added [#1310](https://github.com/roboflow/supervision/pull/1310): [`sv.KeyPoints.from_detectron2`](https://supervision.roboflow.com/0.22.0/keypoint/core/#supervision.keypoint.core.KeyPoints.from_detectron2) is a new `KeyPoints` method, adding support for extracting keypoints from the popular [Detectron 2](https://github.com/facebookresearch/detectron2) platform. + +- Added [#1300](https://github.com/roboflow/supervision/pull/1300): [`sv.Detections.from_detectron2`](https://supervision.roboflow.com/0.22.0/detection/core/#supervision.detection.core.Detections.from_detectron2) now supports segmentation models detectron2. The resulting masks can be used with [`sv.MaskAnnotator`](https://supervision.roboflow.com/0.22.0/detection/annotators/#supervision.annotators.core.MaskAnnotator) for displaying annotations. + +```python +import supervision as sv +from detectron2 import model_zoo +from detectron2.engine import DefaultPredictor +from detectron2.config import get_cfg +import cv2 + +image = cv2.imread() +cfg = get_cfg() +cfg.merge_from_file(model_zoo.get_config_file("COCO-InstanceSegmentation/mask_rcnn_R_50_FPN_3x.yaml")) +cfg.MODEL.WEIGHTS = model_zoo.get_checkpoint_url("COCO-InstanceSegmentation/mask_rcnn_R_50_FPN_3x.yaml") +predictor = DefaultPredictor(cfg) + +result = predictor(image) +detections = sv.Detections.from_detectron2(result) + +mask_annotator = sv.MaskAnnotator() +annotated_frame = mask_annotator.annotate(scene=image.copy(), detections=detections) +``` + +- Added [#1277](https://github.com/roboflow/supervision/pull/1277): if you provide a font that supports symbols of a language, [`sv.RichLabelAnnotator`](https://supervision.roboflow.com/0.22.0/detection/annotators/#supervision.annotators.core.LabelAnnotator.annotate) will draw them on your images. + - Various other annotators have been revised to ensure proper in-place functionality when used with `numpy` arrays. Additionally, we fixed a bug where `sv.ColorAnnotator` was filling boxes with solid color when used in-place. + +```python +import cv2 +import supervision as sv +import + +image = cv2.imread() + +model = get_model(model_id="yolov8n-640") +results = model.infer(image)[0] +detections = sv.Detections.from_inference(results) + +rich_label_annotator = sv.RichLabelAnnotator(font_path=) +annotated_image = rich_label_annotator.annotate(scene=image.copy(), detections=detections) +``` + +- Added [#1227](https://github.com/roboflow/supervision/pull/1227): Added support for loading Oriented Bounding Boxes dataset in YOLO format. + +```python +import supervision as sv + +train_ds = sv.DetectionDataset.from_yolo( + images_directory_path="/content/dataset/train/images", + annotations_directory_path="/content/dataset/train/labels", + data_yaml_path="/content/dataset/data.yaml", + is_obb=True, +) + +_, image, detections in train_ds[0] + +obb_annotator = OrientedBoxAnnotator() +annotated_image = obb_annotator.annotate(scene=image.copy(), detections=detections) +``` + +- Fixed [#1312](https://github.com/roboflow/supervision/pull/1312): Fixed [`CropAnnotator`](https://supervision.roboflow.com/0.22.0/detection/annotators/#supervision.annotators.core.TraceAnnotator.annotate). + +!!! failure "Removed" + + `BoxAnnotator` was removed, however `BoundingBoxAnnotator` has been renamed to `BoxAnnotator`. Use a combination of [`BoxAnnotator`](https://supervision.roboflow.com/0.22.0/detection/annotators/#supervision.annotators.core.BoxAnnotator) and [`LabelAnnotator`](https://supervision.roboflow.com/0.22.0/detection/annotators/#supervision.annotators.core.LabelAnnotator) to simulate old `BoundingBox` behavior. + +!!! failure "Deprecated" + + The name `BoundingBoxAnnotator` has been deprecated and will be removed in `supervision-0.26.0`. It has been renamed to [`BoxAnnotator`](https://supervision.roboflow.com/0.22.0/detection/annotators/#supervision.annotators.core.BoxAnnotator). + +- Added [#975](https://github.com/roboflow/supervision/pull/975) ๐Ÿ“ New Cookbooks: serialize detections into [json](https://github.com/roboflow/supervision/blob/de896189b83a1f9434c0a37dd9192ee00d2a1283/docs/notebooks/serialise-detections-to-json.ipynb) and [csv](https://github.com/roboflow/supervision/blob/de896189b83a1f9434c0a37dd9192ee00d2a1283/docs/notebooks/serialise-detections-to-csv.ipynb). + +- Added [#1290](https://github.com/roboflow/supervision/pull/1290): Mostly an internal change, our file utility function now support both `str` and `pathlib` paths. + +- Added [#1340](https://github.com/roboflow/supervision/pull/1340): Two new methods for converting between bounding box formats - [`xywh_to_xyxy`](https://supervision.roboflow.com/0.22.0/detection/utils/#supervision.detection.utils.xywh_to_xyxy) and [`xcycwh_to_xyxy`](https://supervision.roboflow.com/0.22.0/detection/utils/#supervision.detection.utils.xcycwh_to_xyxy) + +!!! failure "Removed" + + `from_roboflow` method has been removed due to deprecation. Use [from_inference](https://supervision.roboflow.com/0.22.0/detection/core/#supervision.detection.core.Detections.from_inference) instead. + +!!! failure "Removed" + + `Color.white()` has been removed due to deprecation. Use `color.WHITE` instead. + +!!! failure "Removed" + + `Color.black()` has been removed due to deprecation. Use `color.BLACK` instead. + +!!! failure "Removed" + + `Color.red()` has been removed due to deprecation. Use `color.RED` instead. + +!!! failure "Removed" + + `Color.green()` has been removed due to deprecation. Use `color.GREEN` instead. + +!!! failure "Removed" + + `Color.blue()` has been removed due to deprecation. Use `color.BLUE` instead. + +!!! failure "Removed" + + `ColorPalette.default()` has been removed due to deprecation. Use [ColorPalette.DEFAULT](https://supervision.roboflow.com/0.22.0/utils/draw/#supervision.draw.color.ColorPalette.DEFAULT) instead. + +!!! failure "Removed" + + `FPSMonitor.__call__` has been removed due to deprecation. Use the attribute [FPSMonitor.fps](https://supervision.roboflow.com/0.22.0/utils/video/#supervision.utils.video.FPSMonitor.fps) instead. + +### 0.21.0 Jun 5, 2024 + +- Added [#500](https://github.com/roboflow/supervision/pull/500): [`sv.Detections.with_nmm`](https://supervision.roboflow.com/0.21.0/detection/core/#supervision.detection.core.Detections.with_nmm) to perform non-maximum merging on the current set of object detections. + +- Added [#1221](https://github.com/roboflow/supervision/pull/1221): [`sv.Detections.from_lmm`](https://supervision.roboflow.com/0.21.0/detection/core/#supervision.detection.core.Detections.from_lmm) allowing to parse Large Multimodal Model (LMM) text result into [`sv.Detections`](https://supervision.roboflow.com/0.21.0/detection/core/) object. For now `from_lmm` supports only [PaliGemma](https://colab.research.google.com/github/roboflow-ai/notebooks/blob/main/notebooks/how-to-finetune-paligemma-on-detection-dataset.ipynb) result parsing. + +```python +import supervision as sv + +paligemma_result = " cat" +detections = sv.Detections.from_lmm( + sv.LMM.PALIGEMMA, + paligemma_result, + resolution_wh=(1000, 1000), + classes=["cat", "dog"], +) +detections.xyxy +# array([[250., 250., 750., 750.]]) + +detections.class_id +# array([0]) +``` + +- Added [#1236](https://github.com/roboflow/supervision/pull/1236): [`sv.VertexLabelAnnotator`](https://supervision.roboflow.com/0.21.0/keypoint/annotators/#supervision.keypoint.annotators.EdgeAnnotator.annotate) allowing to annotate every vertex of a keypoint skeleton with custom text and color. + +```python +import supervision as sv + +image = ... +key_points = sv.KeyPoints(...) + +edge_annotator = sv.EdgeAnnotator( + color=sv.Color.GREEN, + thickness=5 +) +annotated_frame = edge_annotator.annotate( + scene=image.copy(), + key_points=key_points +) +``` + +- Added [#1147](https://github.com/roboflow/supervision/pull/1147): [`sv.KeyPoints.from_inference`](https://supervision.roboflow.com/0.21.0/keypoint/core/#supervision.keypoint.core.KeyPoints.from_inference) allowing to create [`sv.KeyPoints`](https://supervision.roboflow.com/0.21.0/keypoint/core/#supervision.keypoint.core.KeyPoints) from [Inference](https://github.com/roboflow/inference) result. + +- Added [#1138](https://github.com/roboflow/supervision/pull/1138): [`sv.KeyPoints.from_yolo_nas`](https://supervision.roboflow.com/0.21.0/keypoint/core/#supervision.keypoint.core.KeyPoints.from_yolo_nas) allowing to create [`sv.KeyPoints`](https://supervision.roboflow.com/0.21.0/keypoint/core/#supervision.keypoint.core.KeyPoints) from [YOLO-NAS](https://github.com/Deci-AI/super-gradients/blob/master/YOLONAS.md) result. + +- Added [#1163](https://github.com/roboflow/supervision/pull/1163): [`sv.mask_to_rle`](https://supervision.roboflow.com/0.21.0/datasets/utils/#supervision.dataset.utils.rle_to_mask) and [`sv.rle_to_mask`](https://supervision.roboflow.com/0.21.0/datasets/utils/#supervision.dataset.utils.rle_to_mask) allowing for easy conversion between mask and rle formats. + +- Changed [#1236](https://github.com/roboflow/supervision/pull/1236): [`sv.InferenceSlicer`](https://supervision.roboflow.com/0.21.0/detection/tools/inference_slicer/) allowing to select overlap filtering strategy (`NONE`, `NON_MAX_SUPPRESSION` and `NON_MAX_MERGE`). + +- Changed [#1178](https://github.com/roboflow/supervision/pull/1178): [`sv.InferenceSlicer`](https://supervision.roboflow.com/0.21.0/detection/tools/inference_slicer/) adding instance segmentation model support. + +```python +import cv2 +import numpy as np +import supervision as sv +from inference import get_model + +model = get_model(model_id="yolov8x-seg-640") +image = cv2.imread() + +def callback(image_slice: np.ndarray) -> sv.Detections: + results = model.infer(image_slice)[0] + return sv.Detections.from_inference(results) + +slicer = sv.InferenceSlicer(callback = callback) +detections = slicer(image) + +mask_annotator = sv.MaskAnnotator() +label_annotator = sv.LabelAnnotator() + +annotated_image = mask_annotator.annotate( + scene=image, detections=detections) +annotated_image = label_annotator.annotate( + scene=annotated_image, detections=detections) +``` + +- Changed [#1228](https://github.com/roboflow/supervision/pull/1228): [`sv.LineZone`](https://supervision.roboflow.com/0.21.0/detection/tools/line_zone/) making it 10-20 times faster, depending on the use case. + +- Changed [#1163](https://github.com/roboflow/supervision/pull/1163): [`sv.DetectionDataset.from_coco`](https://supervision.roboflow.com/0.21.0/datasets/core/#supervision.dataset.core.DetectionDataset.from_coco) and [`sv.DetectionDataset.as_coco`](https://supervision.roboflow.com/0.21.0/datasets/core/#supervision.dataset.core.DetectionDataset.as_coco) adding support for run-length encoding (RLE) mask format. + +### 0.20.0 April 24, 2024 + +- Added [#1128](https://github.com/roboflow/supervision/pull/1128): [`sv.KeyPoints`](https://supervision.roboflow.com/0.20.0/keypoint/core/#supervision.keypoint.core.KeyPoints) to provide initial support for pose estimation and broader keypoint detection models. + +- Added [#1128](https://github.com/roboflow/supervision/pull/1128): [`sv.EdgeAnnotator`](https://supervision.roboflow.com/0.20.0/keypoint/annotators/#supervision.keypoint.annotators.EdgeAnnotator) and [`sv.VertexAnnotator`](https://supervision.roboflow.com/0.20.0/keypoint/annotators/#supervision.keypoint.annotators.VertexAnnotator) to enable rendering of results from keypoint detection models. + +```python +import cv2 +import supervision as sv +from ultralytics import YOLO + +image = cv2.imread() +model = YOLO('yolov8l-pose') + +result = model(image, verbose=False)[0] +keypoints = sv.KeyPoints.from_ultralytics(result) + +edge_annotators = sv.EdgeAnnotator(color=sv.Color.GREEN, thickness=5) +annotated_image = edge_annotators.annotate(image.copy(), keypoints) +``` + +- Changed [#1037](https://github.com/roboflow/supervision/pull/1037): [`sv.LabelAnnotator`](https://supervision.roboflow.com/latest/detection/annotators/#supervision.annotators.core.LabelAnnotator) by adding an additional `corner_radius` argument that allows for rounding the corners of the bounding box. + +- Changed [#1109](https://github.com/roboflow/supervision/pull/1109): [`sv.PolygonZone`](https://supervision.roboflow.com/0.20.0/detection/tools/polygon_zone/#supervision.detection.tools.polygon_zone.PolygonZone) such that the `frame_resolution_wh` argument is no longer required to initialize `sv.PolygonZone`. + +!!! failure "Deprecated" + + The `frame_resolution_wh` parameter in `sv.PolygonZone` is deprecated and will be removed in `supervision-0.24.0`. + +- Changed [#1084](https://github.com/roboflow/supervision/pull/1084): [`sv.get_polygon_center`](https://supervision.roboflow.com/0.20.0/utils/geometry/#supervision.geometry.core.utils.get_polygon_center) to calculate a more accurate polygon centroid. + +- Changed [#1069](https://github.com/roboflow/supervision/pull/1069): [`sv.Detections.from_transformers`](https://supervision.roboflow.com/0.20.0/detection/core/#supervision.detection.core.Detections.from_transformers) by adding support for Transformers segmentation models and extract class names values. + +```python +import torch +import supervision as sv +from PIL import Image +from transformers import DetrImageProcessor, DetrForSegmentation + +processor = DetrImageProcessor.from_pretrained("facebook/detr-resnet-50-panoptic") +model = DetrForSegmentation.from_pretrained("facebook/detr-resnet-50-panoptic") + +image = Image.open() +inputs = processor(images=image, return_tensors="pt") + +with torch.no_grad(): + outputs = model(**inputs) + +width, height = image.size +target_size = torch.tensor([[height, width]]) +results = processor.post_process_segmentation( + outputs=outputs, target_sizes=target_size)[0] +detections = sv.Detections.from_transformers(results, id2label=model.config.id2label) + +mask_annotator = sv.MaskAnnotator() +label_annotator = sv.LabelAnnotator(text_position=sv.Position.CENTER) + +annotated_image = mask_annotator.annotate( + scene=image, detections=detections) +annotated_image = label_annotator.annotate( + scene=annotated_image, detections=detections) +``` + +- Fixed [#787](https://github.com/roboflow/supervision/pull/787): [`sv.ByteTrack.update_with_detections`](https://supervision.roboflow.com/0.20.0/trackers/#supervision.tracker.byte_tracker.core.ByteTrack.update_with_detections) which was removing segmentation masks while tracking. Now, `ByteTrack` can be used alongside segmentation models. + +### 0.19.0 March 15, 2024 + +- Added [#818](https://github.com/roboflow/supervision/pull/818): [`sv.CSVSink`](https://supervision.roboflow.com/0.19.0/detection/tools/save_detections/#supervision.detection.tools.csv_sink.CSVSink) allowing for the straightforward saving of image, video, or stream inference results in a `.csv` file. + +```python +import supervision as sv +from ultralytics import YOLO + +model = YOLO() +csv_sink = sv.CSVSink() +frames_generator = sv.get_video_frames_generator() + +with csv_sink: + for frame in frames_generator: + result = model(frame)[0] + detections = sv.Detections.from_ultralytics(result) + csv_sink.append(detections, custom_data={:}) +``` + +- Added [#819](https://github.com/roboflow/supervision/pull/819): [`sv.JSONSink`](https://supervision.roboflow.com/0.19.0/detection/tools/save_detections/#supervision.detection.tools.csv_sink.JSONSink) allowing for the straightforward saving of image, video, or stream inference results in a `.json` file. + +```python +import supervision as sv +from ultralytics import YOLO + +model = YOLO() +json_sink = sv.JSONSink() +frames_generator = sv.get_video_frames_generator() + +with json_sink: + for frame in frames_generator: + result = model(frame)[0] + detections = sv.Detections.from_ultralytics(result) + json_sink.append(detections, custom_data={:}) +``` + +- Added [#847](https://github.com/roboflow/supervision/pull/847): [`sv.mask_iou_batch`](https://supervision.roboflow.com/0.19.0/detection/utils/#supervision.detection.utils.mask_iou_batch) allowing to compute Intersection over Union (IoU) of two sets of masks. + +- Added [#847](https://github.com/roboflow/supervision/pull/847): [`sv.mask_non_max_suppression`](https://supervision.roboflow.com/0.19.0/detection/utils/#supervision.detection.utils.mask_non_max_suppression) allowing to perform Non-Maximum Suppression (NMS) on segmentation predictions. + +- Added [#888](https://github.com/roboflow/supervision/pull/888): [`sv.CropAnnotator`](https://supervision.roboflow.com/0.19.0/annotators/#supervision.annotators.core.CropAnnotator) allowing users to annotate the scene with scaled-up crops of detections. + +```python +import cv2 +import supervision as sv +from inference import get_model + +image = cv2.imread() +model = get_model(model_id="yolov8n-640") + +result = model.infer(image)[0] +detections = sv.Detections.from_inference(result) + +crop_annotator = sv.CropAnnotator() +annotated_frame = crop_annotator.annotate( + scene=image.copy(), + detections=detections +) +``` + +- Changed [#827](https://github.com/roboflow/supervision/pull/827): [`sv.ByteTrack.reset`](https://supervision.roboflow.com/0.19.0/trackers/#supervision.tracker.ByteTrack.reset) allowing users to clear trackers state, enabling the processing of multiple video files in sequence. + +- Changed [#802](https://github.com/roboflow/supervision/pull/802): [`sv.LineZoneAnnotator`](https://supervision.roboflow.com/0.19.0/detection/tools/line_zone/#supervision.detection.line_zone.LineZone) allowing to hide in/out count using `display_in_count` and `display_out_count` properties. + +- Changed [#787](https://github.com/roboflow/supervision/pull/787): [`sv.ByteTrack`](https://supervision.roboflow.com/0.19.0/trackers/#supervision.tracker.ByteTrack) input arguments and docstrings updated to improve readability and ease of use. + +!!! failure "Deprecated" + + The `track_buffer`, `track_thresh`, and `match_thresh` parameters in `sv.ByteTrack` are deprecated and will be removed in `supervision-0.23.0`. Use `lost_track_buffer,` `track_activation_threshold`, and `minimum_matching_threshold` instead. + +- Changed [#910](https://github.com/roboflow/supervision/pull/910): [`sv.PolygonZone`](https://supervision.roboflow.com/0.19.0/detection/tools/polygon_zone/#supervision.detection.tools.polygon_zone.PolygonZone) to now accept a list of specific box anchors that must be in zone for a detection to be counted. + +!!! failure "Deprecated" + + The `triggering_position ` parameter in `sv.PolygonZone` is deprecated and will be removed in `supervision-0.23.0`. Use `triggering_anchors` instead. + +- Changed [#875](https://github.com/roboflow/supervision/pull/875): annotators adding support for Pillow images. All supervision Annotators can now accept an image as either a numpy array or a Pillow Image. They automatically detect its type, draw annotations, and return the output in the same format as the input. + +- Fixed [#944](https://github.com/roboflow/supervision/pull/944): [`sv.DetectionsSmoother`](https://supervision.roboflow.com/0.19.0/detection/tools/smoother/#supervision.detection.tools.smoother.DetectionsSmoother) removing `tracking_id` from `sv.Detections`. + +### 0.18.0 January 25, 2024 + +- Added [#720](https://github.com/roboflow/supervision/pull/720): [`sv.PercentageBarAnnotator`](https://supervision.roboflow.com/0.18.0/annotators/#percentagebarannotator) allowing to annotate images and videos with percentage values representing confidence or other custom property. + +```python +>>> import supervision as sv + +>>> image = ... +>>> detections = sv.Detections(...) + +>>> percentage_bar_annotator = sv.PercentageBarAnnotator() +>>> annotated_frame = percentage_bar_annotator.annotate( +... scene=image.copy(), +... detections=detections +... ) +``` + +- Added [#702](https://github.com/roboflow/supervision/pull/702): [`sv.RoundBoxAnnotator`](https://supervision.roboflow.com/0.18.0/annotators/#roundboxannotator) allowing to annotate images and videos with rounded corners bounding boxes. + +- Added [#770](https://github.com/roboflow/supervision/pull/770): [`sv.OrientedBoxAnnotator`](https://supervision.roboflow.com/0.18.0/annotators/#orientedboxannotator) allowing to annotate images and videos with OBB (Oriented Bounding Boxes). + +```python +import cv2 +import supervision as sv +from ultralytics import YOLO + +image = cv2.imread() +model = YOLO("yolov8n-obb.pt") + +result = model(image)[0] +detections = sv.Detections.from_ultralytics(result) + +oriented_box_annotator = sv.OrientedBoxAnnotator() +annotated_frame = oriented_box_annotator.annotate( + scene=image.copy(), + detections=detections +) +``` + +- Added [#696](https://github.com/roboflow/supervision/pull/696): [`sv.DetectionsSmoother`](https://supervision.roboflow.com/0.18.0/detection/tools/smoother/#detection-smoother) allowing for smoothing detections over multiple frames in video tracking. + +- Added [#769](https://github.com/roboflow/supervision/pull/769): [`sv.ColorPalette.from_matplotlib`](https://supervision.roboflow.com/0.18.0/draw/color/#supervision.draw.color.ColorPalette.from_matplotlib) allowing users to create a `sv.ColorPalette` instance from a Matplotlib color palette. + +```python +>>> import supervision as sv + +>>> sv.ColorPalette.from_matplotlib('viridis', 5) +ColorPalette(colors=[Color(r=68, g=1, b=84), Color(r=59, g=82, b=139), ...]) +``` + +- Changed [#770](https://github.com/roboflow/supervision/pull/770): [`sv.Detections.from_ultralytics`](https://supervision.roboflow.com/0.18.0/detection/core/#supervision.detection.core.Detections.from_ultralytics) adding support for OBB (Oriented Bounding Boxes). + +- Changed [#735](https://github.com/roboflow/supervision/pull/735): [`sv.LineZone`](https://supervision.roboflow.com/0.18.0/detection/tools/line_zone/#linezone) to now accept a list of specific box anchors that must cross the line for a detection to be counted. This update marks a significant improvement from the previous requirement, where all four box corners were necessary. Users can now specify a single anchor, such as `sv.Position.BOTTOM_CENTER`, or any other combination of anchors defined as `List[sv.Position]`. + +- Changed [#756](https://github.com/roboflow/supervision/pull/756): [`sv.Color`](https://supervision.roboflow.com/0.18.0/draw/color/#color)'s and [`sv.ColorPalette`](https://supervision.roboflow.com/0.18.0/draw/color/#colorpalette)'s method of accessing predefined colors, transitioning from a function-based approach (`sv.Color.red()`) to a more intuitive and conventional property-based method (`sv.Color.RED`). + +!!! failure "Deprecated" + + `sv.ColorPalette.default()` is deprecated and will be removed in `supervision-0.22.0`. Use `sv.ColorPalette.DEFAULT` instead. + +- Changed [#769](https://github.com/roboflow/supervision/pull/769): [`sv.ColorPalette.DEFAULT`](https://supervision.roboflow.com/0.18.0/draw/color/#colorpalette) value, giving users a more extensive set of annotation colors. + +- Changed [#677](https://github.com/roboflow/supervision/pull/677): `sv.Detections.from_roboflow` to [`sv.Detections.from_inference`](https://supervision.roboflow.com/0.18.0/detection/core/#supervision.detection.core.Detections.from_inference) streamlining its functionality to be compatible with both the both [inference](https://github.com/roboflow/inference) pip package and the Robloflow [hosted API](https://docs.roboflow.com/deploy/hosted-api). + +!!! failure "Deprecated" + + `Detections.from_roboflow()` is deprecated and will be removed in `supervision-0.22.0`. Use `Detections.from_inference` instead. + +- Fixed [#735](https://github.com/roboflow/supervision/pull/735): [`sv.LineZone`](https://supervision.roboflow.com/0.18.0/detection/tools/line_zone/#linezone) functionality to accurately update the counter when an object crosses a line from any direction, including from the side. This enhancement enables more precise tracking and analytics, such as calculating individual in/out counts for each lane on the road. + +### 0.17.0 December 06, 2023 + +- Added [#633](https://github.com/roboflow/supervision/pull/633): [`sv.PixelateAnnotator`](https://supervision.roboflow.com/0.17.0/annotators/#supervision.annotators.core.PixelateAnnotator) allowing to pixelate objects on images and videos. + +- Added [#652](https://github.com/roboflow/supervision/pull/652): [`sv.TriangleAnnotator`](https://supervision.roboflow.com/0.17.0/annotators/#supervision.annotators.core.TriangleAnnotator) allowing to annotate images and videos with triangle markers. + +- Added [#602](https://github.com/roboflow/supervision/pull/602): [`sv.PolygonAnnotator`](https://supervision.roboflow.com/0.17.0/annotators/#supervision.annotators.core.PolygonAnnotator) allowing to annotate images and videos with segmentation mask outline. + +```python +>>> import supervision as sv + +>>> image = ... +>>> detections = sv.Detections(...) + +>>> polygon_annotator = sv.PolygonAnnotator() +>>> annotated_frame = polygon_annotator.annotate( +... scene=image.copy(), +... detections=detections +... ) +``` + +- Added [#476](https://github.com/roboflow/supervision/pull/476): [`sv.assets`](https://supervision.roboflow.com/0.18.0/assets/) allowing download of video files that you can use in your demos. + +```python +>>> from supervision.assets import download_assets, VideoAssets +>>> download_assets(VideoAssets.VEHICLES) +"vehicles.mp4" +``` + +- Added [#605](https://github.com/roboflow/supervision/pull/605): [`Position.CENTER_OF_MASS`](https://supervision.roboflow.com/0.17.0/geometry/core/#position) allowing to place labels in center of mass of segmentation masks. + +- Added [#651](https://github.com/roboflow/supervision/pull/651): [`sv.scale_boxes`](https://supervision.roboflow.com/0.17.0/detection/utils/#supervision.detection.utils.scale_boxes) allowing to scale [`sv.Detections.xyxy`](https://supervision.roboflow.com/0.17.0/detection/core/#supervision.detection.core.Detections) values. + +- Added [#637](https://github.com/roboflow/supervision/pull/637): [`sv.calculate_dynamic_text_scale`](https://supervision.roboflow.com/0.17.0/draw/utils/#supervision.draw.utils.calculate_dynamic_text_scale) and [`sv.calculate_dynamic_line_thickness`](https://supervision.roboflow.com/0.17.0/draw/utils/#supervision.draw.utils.calculate_dynamic_line_thickness) allowing text scale and line thickness to match image resolution. + +- Added [#620](https://github.com/roboflow/supervision/pull/620): [`sv.Color.as_hex`](https://supervision.roboflow.com/0.17.0/draw/color/#supervision.draw.color.Color.as_hex) allowing to extract color value in HEX format. + +- Added [#572](https://github.com/roboflow/supervision/pull/572): [`sv.Classifications.from_timm`](https://supervision.roboflow.com/0.17.0/classification/core/#supervision.classification.core.Classifications.from_timm) allowing to load classification result from [timm](https://huggingface.co/docs/hub/timm) models. + +- Added [#478](https://github.com/roboflow/supervision/pull/478): [`sv.Classifications.from_clip`](https://supervision.roboflow.com/0.17.0/classification/core/#supervision.classification.core.Classifications.from_clip) allowing to load classification result from [clip](https://github.com/openai/clip) model. + +- Added [#571](https://github.com/roboflow/supervision/pull/571): [`sv.Detections.from_azure_analyze_image`](https://supervision.roboflow.com/0.17.0/detection/core/#supervision.detection.core.Detections.from_azure_analyze_image) allowing to load detection results from [Azure Image Analysis](https://learn.microsoft.com/en-us/azure/ai-services/computer-vision/concept-object-detection-40). + +- Changed [#646](https://github.com/roboflow/supervision/pull/646): `sv.BoxMaskAnnotator` renaming it to [`sv.ColorAnnotator`](https://supervision.roboflow.com/0.17.0/annotators/#supervision.annotators.core.ColorAnnotator). + +- Changed [#606](https://github.com/roboflow/supervision/pull/606): [`sv.MaskAnnotator`](https://supervision.roboflow.com/0.17.0/annotators/#supervision.annotators.core.MaskAnnotator) to make it **5x faster**. + +- Fixed [#584](https://github.com/roboflow/supervision/pull/584): [`sv.DetectionDataset.from_yolo`](https://supervision.roboflow.com/0.17.0/datasets/#supervision.dataset.core.DetectionDataset.from_yolo) to ignore empty lines in annotation files. + +- Fixed [#555](https://github.com/roboflow/supervision/pull/555): [`sv.BlurAnnotator`](https://supervision.roboflow.com/0.17.0/annotators/#supervision.annotators.core.BlurAnnotator) to trim negative coordinates before bluring detections. + +- Fixed [#511](https://github.com/roboflow/supervision/pull/511): [`sv.TraceAnnotator`](https://supervision.roboflow.com/0.17.0/annotators/#supervision.annotators.core.TraceAnnotator) to respect trace position. + +### 0.16.0 October 19, 2023 + +- Added [#422](https://github.com/roboflow/supervision/pull/422): [`sv.BoxMaskAnnotator`](https://supervision.roboflow.com/0.16.0/annotators/#supervision.annotators.core.BoxMaskAnnotator) allowing to annotate images and videos with mox masks. + +- Added [#433](https://github.com/roboflow/supervision/pull/433): [`sv.HaloAnnotator`](https://supervision.roboflow.com/0.16.0/annotators/#supervision.annotators.core.HaloAnnotator) allowing to annotate images and videos with halo effect. + +```python +>>> import supervision as sv + +>>> image = ... +>>> detections = sv.Detections(...) + +>>> halo_annotator = sv.HaloAnnotator() +>>> annotated_frame = halo_annotator.annotate( +... scene=image.copy(), +... detections=detections +... ) +``` + +- Added [#466](https://github.com/roboflow/supervision/pull/466): [`sv.HeatMapAnnotator`](https://supervision.roboflow.com/0.16.0/annotators/#supervision.annotators.core.HeatMapAnnotator) allowing to annotate videos with heat maps. + +- Added [#492](https://github.com/roboflow/supervision/pull/492): [`sv.DotAnnotator`](https://supervision.roboflow.com/0.16.0/annotators/#supervision.annotators.core.DotAnnotator) allowing to annotate images and videos with dots. + +- Added [#449](https://github.com/roboflow/supervision/pull/449): [`sv.draw_image`](https://supervision.roboflow.com/0.16.0/draw/utils/#supervision.draw.utils.draw_image) allowing to draw an image onto a given scene with specified opacity and dimensions. + +- Added [#280](https://github.com/roboflow/supervision/pull/280): [`sv.FPSMonitor`](https://supervision.roboflow.com/0.16.0/utils/video/#supervision.utils.video.FPSMonitor) for monitoring frames per second (FPS) to benchmark latency. + +- Added [#454](https://github.com/roboflow/supervision/pull/454): ๐Ÿค— Hugging Face Annotators [space](https://huggingface.co/spaces/Roboflow/Annotators). + +- Changed [#482](https://github.com/roboflow/supervision/pull/482): [`sv.LineZone.trigger`](https://supervision.roboflow.com/0.16.0/detection/tools/line_zone/#supervision.detection.line_counter.LineZone.trigger) now return `Tuple[np.ndarray, np.ndarray]`. The first array indicates which detections have crossed the line from outside to inside. The second array indicates which detections have crossed the line from inside to outside. + +- Changed [#465](https://github.com/roboflow/supervision/pull/465): Annotator argument name from `color_map: str` to `color_lookup: ColorLookup` enum to increase type safety. + +- Changed [#426](https://github.com/roboflow/supervision/pull/426): [`sv.MaskAnnotator`](https://supervision.roboflow.com/0.16.0/annotators/#supervision.annotators.core.MaskAnnotator) allowing 2x faster annotation. + +- Fixed [#477](https://github.com/roboflow/supervision/pull/477): Poetry env definition allowing proper local installation. + +- Fixed [#430](https://github.com/roboflow/supervision/pull/430): [`sv.ByteTrack`](https://supervision.roboflow.com/0.16.0/trackers/#supervision.tracker.byte_tracker.core.ByteTrack) to return `np.array([], dtype=int)` when `svDetections` is empty. + +!!! failure "Deprecated" + + `sv.Detections.from_yolov8` and `sv.Classifications.from_yolov8` as those are now replaced by [`sv.Detections.from_ultralytics`](https://supervision.roboflow.com/0.16.0/detection/core/#supervision.detection.core.Detections.from_ultralytics) and [`sv.Classifications.from_ultralytics`](https://supervision.roboflow.com/0.16.0/classification/core/#supervision.classification.core.Classifications.from_ultralytics). + +### 0.15.0 October 5, 2023 + +- Added [#170](https://github.com/roboflow/supervision/pull/170): [`sv.BoundingBoxAnnotator`](https://supervision.roboflow.com/0.15.0/annotators/#supervision.annotators.core.BoundingBoxAnnotator) allowing to annotate images and videos with bounding boxes. + +- Added [#170](https://github.com/roboflow/supervision/pull/170): [`sv.BoxCornerAnnotator `](https://supervision.roboflow.com/0.15.0/annotators/#supervision.annotators.core.BoxCornerAnnotator) allowing to annotate images and videos with just bounding box corners. + +- Added [#170](https://github.com/roboflow/supervision/pull/170): [`sv.MaskAnnotator`](https://supervision.roboflow.com/0.15.0/annotators/#supervision.annotators.core.MaskAnnotator) allowing to annotate images and videos with segmentation masks. + +- Added [#170](https://github.com/roboflow/supervision/pull/170): [`sv.EllipseAnnotator`](https://supervision.roboflow.com/0.15.0/annotators/#supervision.annotators.core.EllipseAnnotator) allowing to annotate images and videos with ellipses (sports game style). + +- Added [#386](https://github.com/roboflow/supervision/pull/386): [`sv.CircleAnnotator`](https://supervision.roboflow.com/0.15.0/annotators/#supervision.annotators.core.CircleAnnotator) allowing to annotate images and videos with circles. + +- Added [#354](https://github.com/roboflow/supervision/pull/354): [`sv.TraceAnnotator`](https://supervision.roboflow.com/0.15.0/annotators/#supervision.annotators.core.TraceAnnotator) allowing to draw path of moving objects on videos. + +- Added [#405](https://github.com/roboflow/supervision/pull/405): [`sv.BlurAnnotator`](https://supervision.roboflow.com/0.15.0/annotators/#supervision.annotators.core.BlurAnnotator) allowing to blur objects on images and videos. + +```python +>>> import supervision as sv + +>>> image = ... +>>> detections = sv.Detections(...) + +>>> bounding_box_annotator = sv.BoundingBoxAnnotator() +>>> annotated_frame = bounding_box_annotator.annotate( +... scene=image.copy(), +... detections=detections +... ) +``` + +- Added [#354](https://github.com/roboflow/supervision/pull/354): Supervision usage [example](https://github.com/roboflow/supervision/tree/develop/examples/traffic_analysis). You can now learn how to perform traffic flow analysis with Supervision. + +- Changed [#399](https://github.com/roboflow/supervision/pull/399): [`sv.Detections.from_roboflow`](https://supervision.roboflow.com/0.15.0/detection/core/#supervision.detection.core.Detections.from_roboflow) now does not require `class_list` to be specified. The `class_id` value can be extracted directly from the [inference](https://github.com/roboflow/inference) response. + +- Changed [#381](https://github.com/roboflow/supervision/pull/381): [`sv.VideoSink`](https://supervision.roboflow.com/0.15.0/utils/video/#videosink) now allows to customize the output codec. + +- Changed [#361](https://github.com/roboflow/supervision/pull/361): [`sv.InferenceSlicer`](https://supervision.roboflow.com/0.15.0/detection/tools/inference_slicer/#supervision.detection.tools.inference_slicer.InferenceSlicer) can now operate in multithreading mode. + +- Fixed [#348](https://github.com/roboflow/supervision/pull/348): [`sv.Detections.from_deepsparse`](https://supervision.roboflow.com/0.15.0/detection/core/#supervision.detection.core.Detections.from_deepsparse) to allow processing empty [deepsparse](https://github.com/neuralmagic/deepsparse) result object. + +### 0.14.0 August 31, 2023 + +- Added [#282](https://github.com/roboflow/supervision/pull/282): support for SAHI inference technique with [`sv.InferenceSlicer`](https://supervision.roboflow.com/0.14.0/detection/tools/inference_slicer). + +```python +>>> import cv2 +>>> import supervision as sv +>>> from ultralytics import YOLO + +>>> image = cv2.imread(SOURCE_IMAGE_PATH) +>>> model = YOLO(...) + +>>> def callback(image_slice: np.ndarray) -> sv.Detections: +... result = model(image_slice)[0] +... return sv.Detections.from_ultralytics(result) + +>>> slicer = sv.InferenceSlicer(callback = callback) + +>>> detections = slicer(image) +``` + +- Added [#297](https://github.com/roboflow/supervision/pull/297): [`Detections.from_deepsparse`](https://supervision.roboflow.com/0.14.0/detection/core/#supervision.detection.core.Detections.from_deepsparse) to enable seamless integration with [DeepSparse](https://github.com/neuralmagic/deepsparse) framework. + +- Added [#281](https://github.com/roboflow/supervision/pull/281): [`sv.Classifications.from_ultralytics`](https://supervision.roboflow.com/0.14.0/classification/core/#supervision.classification.core.Classifications.from_ultralytics) to enable seamless integration with [Ultralytics](https://github.com/ultralytics/ultralytics) framework. This will enable you to use supervision with all [models](https://docs.ultralytics.com/models/) that Ultralytics supports. + +!!! failure "Deprecated" + + [sv.Detections.from_yolov8](https://supervision.roboflow.com/0.14.0/detection/core/#supervision.detection.core.Detections.from_yolov8) and [sv.Classifications.from_yolov8](https://supervision.roboflow.com/0.14.0/classification/core/#supervision.classification.core.Classifications.from_yolov8) are now deprecated and will be removed with `supervision-0.16.0` release. + +- Added [#341](https://github.com/roboflow/supervision/pull/341): First supervision usage example script showing how to detect and track objects on video using YOLOv8 + Supervision. + +- Changed [#296](https://github.com/roboflow/supervision/pull/296): [`sv.ClassificationDataset`](https://supervision.roboflow.com/0.14.0/dataset/core/#supervision.dataset.core.ClassificationDataset) and [`sv.DetectionDataset`](https://supervision.roboflow.com/0.14.0/dataset/core/#supervision.dataset.core.DetectionDataset) now use image path (not image name) as dataset keys. + +- Fixed [#300](https://github.com/roboflow/supervision/pull/300): [`Detections.from_roboflow`](https://supervision.roboflow.com/0.14.0/detection/core/#supervision.detection.core.Detections.from_roboflow) to filter out polygons with less than 3 points. + +### 0.13.0 August 8, 2023 + +- Added [#236](https://github.com/roboflow/supervision/pull/236): support for mean average precision (mAP) for object detection models with [`sv.MeanAveragePrecision`](https://supervision.roboflow.com/0.13.0/metrics/detection/#meanaverageprecision). + +```python +>>> import supervision as sv +>>> from ultralytics import YOLO + +>>> dataset = sv.DetectionDataset.from_yolo(...) + +>>> model = YOLO(...) +>>> def callback(image: np.ndarray) -> sv.Detections: +... result = model(image)[0] +... return sv.Detections.from_yolov8(result) + +>>> mean_average_precision = sv.MeanAveragePrecision.benchmark( +... dataset = dataset, +... callback = callback +... ) + +>>> mean_average_precision.map50_95 +0.433 +``` + +- Added [#256](https://github.com/roboflow/supervision/pull/256): support for ByteTrack for object tracking with [`sv.ByteTrack`](https://supervision.roboflow.com/0.13.0/tracker/core/#bytetrack). + +- Added [#222](https://github.com/roboflow/supervision/pull/222): [`sv.Detections.from_ultralytics`](https://supervision.roboflow.com/0.13.0/detection/core/#supervision.detection.core.Detections.from_ultralytics) to enable seamless integration with [Ultralytics](https://github.com/ultralytics/ultralytics) framework. This will enable you to use `supervision` with all [models](https://docs.ultralytics.com/models/) that Ultralytics supports. + +!!! failure "Deprecated" + + [`sv.Detections.from_yolov8`](https://supervision.roboflow.com/0.13.0/detection/core/#supervision.detection.core.Detections.from_yolov8) is now deprecated and will be removed with `supervision-0.15.0` release. + +- Added [#191](https://github.com/roboflow/supervision/pull/191): [`sv.Detections.from_paddledet`](https://supervision.roboflow.com/0.13.0/detection/core/#supervision.detection.core.Detections.from_paddledet) to enable seamless integration with [PaddleDetection](https://github.com/PaddlePaddle/PaddleDetection) framework. + +- Added [#245](https://github.com/roboflow/supervision/pull/245): support for loading PASCAL VOC segmentation datasets with [`sv.DetectionDataset.`](https://supervision.roboflow.com/0.13.0/dataset/core/#supervision.dataset.core.DetectionDataset.from_pascal_voc). + +### 0.12.0 July 24, 2023 + +!!! failure "Python 3.7. Support Terminated" + + With the `supervision-0.12.0` release, we are terminating official support for Python 3.7. + +- Added [#177](https://github.com/roboflow/supervision/pull/177): initial support for object detection model benchmarking with [`sv.ConfusionMatrix`](https://supervision.roboflow.com/0.12.0/metrics/detection/#confusionmatrix). + +```python +>>> import supervision as sv +>>> from ultralytics import YOLO + +>>> dataset = sv.DetectionDataset.from_yolo(...) + +>>> model = YOLO(...) +>>> def callback(image: np.ndarray) -> sv.Detections: +... result = model(image)[0] +... return sv.Detections.from_yolov8(result) + +>>> confusion_matrix = sv.ConfusionMatrix.benchmark( +... dataset = dataset, +... callback = callback +... ) + +>>> confusion_matrix.matrix +array([ + [0., 0., 0., 0.], + [0., 1., 0., 1.], + [0., 1., 1., 0.], + [1., 1., 0., 0.] +]) +``` + +- Added [#173](https://github.com/roboflow/supervision/pull/173): [`Detections.from_mmdetection`](https://supervision.roboflow.com/0.12.0/detection/core/#supervision.detection.core.Detections.from_mmdetection) to enable seamless integration with [MMDetection](https://github.com/open-mmlab/mmdetection) framework. + +- Added [#130](https://github.com/roboflow/supervision/issues/130): ability to [install](https://supervision.roboflow.com/) package in `headless` or `desktop` mode. + +- Changed [#180](https://github.com/roboflow/supervision/pull/180): packing method from `setup.py` to `pyproject.toml`. + +- Fixed [#188](https://github.com/roboflow/supervision/issues/188): [`sv.DetectionDataset.from_cooc`](https://supervision.roboflow.com/0.12.0/dataset/core/#supervision.dataset.core.DetectionDataset.from_coco) can't be loaded when there are images without annotations. + +- Fixed [#226](https://github.com/roboflow/supervision/issues/226): [`sv.DetectionDataset.from_yolo`](https://supervision.roboflow.com/0.12.0/dataset/core/#supervision.dataset.core.DetectionDataset.from_yolo) can't load background instances. + +### 0.11.1 June 29, 2023 + +- Fixed [#165](https://github.com/roboflow/supervision/pull/165): [`as_folder_structure`](https://supervision.roboflow.com/0.11.1/dataset/core/#supervision.dataset.core.ClassificationDataset.as_folder_structure) fails to save [`sv.ClassificationDataset`](https://supervision.roboflow.com/0.11.1/dataset/core/#classificationdataset) when it is result of inference. + +### 0.11.0 June 28, 2023 + +- Added [#150](https://github.com/roboflow/supervision/pull/150): ability to load and save [`sv.DetectionDataset`](https://supervision.roboflow.com/0.11.0/dataset/core/#detectiondataset) in COCO format using [`as_coco`](https://supervision.roboflow.com/0.11.0/dataset/core/#supervision.dataset.core.DetectionDataset.as_coco) and [`from_coco`](https://supervision.roboflow.com/0.11.0/dataset/core/#supervision.dataset.core.DetectionDataset.from_coco) methods. + +```python +>>> import supervision as sv + +>>> ds = sv.DetectionDataset.from_coco( +... images_directory_path='...', +... annotations_path='...' +... ) + +>>> ds.as_coco( +... images_directory_path='...', +... annotations_path='...' +... ) +``` + +- Added [#158](https://github.com/roboflow/supervision/pull/158): ability to merge multiple [`sv.DetectionDataset`](https://supervision.roboflow.com/0.11.0/dataset/core/#detectiondataset) together using [`merge`](https://supervision.roboflow.com/0.11.0/dataset/core/#supervision.dataset.core.DetectionDataset.merge) method. + +```python +>>> import supervision as sv + +>>> ds_1 = sv.DetectionDataset(...) +>>> len(ds_1) +100 +>>> ds_1.classes +['dog', 'person'] + +>>> ds_2 = sv.DetectionDataset(...) +>>> len(ds_2) +200 +>>> ds_2.classes +['cat'] + +>>> ds_merged = sv.DetectionDataset.merge([ds_1, ds_2]) +>>> len(ds_merged) +300 +>>> ds_merged.classes +['cat', 'dog', 'person'] +``` + +- Added [#162](https://github.com/roboflow/supervision/pull/162): additional `start` and `end` arguments to [`sv.get_video_frames_generator`](https://supervision.roboflow.com/0.11.0/utils/video/#get_video_frames_generator) allowing to generate frames only for a selected part of the video. + +- Fixed [#157](https://github.com/roboflow/supervision/pull/157): incorrect loading of YOLO dataset class names from `data.yaml`. + +### 0.10.0 June 14, 2023 + +- Added [#125](https://github.com/roboflow/supervision/pull/125): ability to load and save [`sv.ClassificationDataset`](https://supervision.roboflow.com/0.10.0/dataset/core/#classificationdataset) in a folder structure format. + +```python +>>> import supervision as sv + +>>> cs = sv.ClassificationDataset.from_folder_structure( +... root_directory_path='...' +... ) + +>>> cs.as_folder_structure( +... root_directory_path='...' +... ) +``` + +- Added [#125](https://github.com/roboflow/supervision/pull/125): support for [`sv.ClassificationDataset.split`](https://supervision.roboflow.com/0.10.0/dataset/core/#supervision.dataset.core.ClassificationDataset.split) allowing to divide `sv.ClassificationDataset` into two parts. + +- Added [#110](https://github.com/roboflow/supervision/pull/110): ability to extract masks from Roboflow API results using [`sv.Detections.from_roboflow`](https://supervision.roboflow.com/0.10.0/detection/core/#supervision.detection.core.Detections.from_roboflow). + +- Added [commit hash](https://github.com/roboflow/supervision/commit/d000292eb2f2342544e0947b65528082e60fb8d6): Supervision Quickstart [notebook](https://colab.research.google.com/github/roboflow/supervision/blob/main/demo.ipynb) where you can learn more about Detection, Dataset and Video APIs. + +- Changed [#135](https://github.com/roboflow/supervision/pull/135): `sv.get_video_frames_generator` documentation to better describe actual behavior. + +### 0.9.0 June 7, 2023 + +- Added [#118](https://github.com/roboflow/supervision/pull/118): ability to select [`sv.Detections`](https://supervision.roboflow.com/0.9.0/detection/core/#supervision.detection.core.Detections.__getitem__) by index, list of indexes or slice. Here is an example illustrating the new selection methods. + +```python +>>> import supervision as sv + +>>> detections = sv.Detections(...) +>>> len(detections[0]) +1 +>>> len(detections[[0, 1]]) +2 +>>> len(detections[0:2]) +2 +``` + +- Added [#101](https://github.com/roboflow/supervision/pull/101): ability to extract masks from YOLOv8 result using [`sv.Detections.from_yolov8`](https://supervision.roboflow.com/0.8.0/detection/core/#supervision.detection.core.Detections.from_yolov8). Here is an example illustrating how to extract boolean masks from the result of the YOLOv8 model inference. + +- Added [#122](https://github.com/roboflow/supervision/pull/122): ability to crop image using [`sv.crop`](https://supervision.roboflow.com/0.9.0/utils/image/#crop). Here is an example showing how to get a separate crop for each detection in `sv.Detections`. + +- Added [#120](https://github.com/roboflow/supervision/pull/120): ability to conveniently save multiple images into directory using [`sv.ImageSink`](https://supervision.roboflow.com/0.9.0/utils/image/#imagesink). Here is an example showing how to save every tenth video frame as a separate image. + +```python +>>> import supervision as sv + +>>> with sv.ImageSink(target_dir_path='target/directory/path') as sink: +... for image in sv.get_video_frames_generator(source_path='source_video.mp4', stride=10): +... sink.save_image(image=image) +``` + +- Fixed [#106](https://github.com/roboflow/supervision/issues/106): inconvenient handling of [`sv.PolygonZone`](https://supervision.roboflow.com/0.8.0/detection/tools/polygon_zone/#polygonzone) coordinates. Now `sv.PolygonZone` accepts coordinates in the form of `[[x1, y1], [x2, y2], ...]` that can be both integers and floats. + +### 0.8.0 May 17, 2023 + +- Added [#100](https://github.com/roboflow/supervision/pull/100): support for dataset inheritance. The current `Dataset` got renamed to `DetectionDataset`. Now [`DetectionDataset`](https://supervision.roboflow.com/0.8.0/dataset/core/#detectiondataset) inherits from `BaseDataset`. This change was made to enforce the future consistency of APIs of different types of computer vision datasets. +- Added [#100](https://github.com/roboflow/supervision/pull/100): ability to save datasets in YOLO format using [`DetectionDataset.as_yolo`](https://supervision.roboflow.com/0.8.0/dataset/core/#supervision.dataset.core.DetectionDataset.as_yolo). + +```python +>>> import roboflow +>>> from roboflow import Roboflow +>>> import supervision as sv + +>>> roboflow.login() + +>>> rf = Roboflow() + +>>> project = rf.workspace(WORKSPACE_ID).project(PROJECT_ID) +>>> dataset = project.version(PROJECT_VERSION).download("yolov5") + +>>> ds = sv.DetectionDataset.from_yolo( +... images_directory_path=f"{dataset.location}/train/images", +... annotations_directory_path=f"{dataset.location}/train/labels", +... data_yaml_path=f"{dataset.location}/data.yaml" +... ) + +>>> ds.classes +['dog', 'person'] +``` + +- Added [#103](https://github.com/roboflow/supervision/pull/103): support for [`DetectionDataset.split`](https://supervision.roboflow.com/0.8.0/dataset/core/#supervision.dataset.core.DetectionDataset.split) allowing to divide `DetectionDataset` into two parts. + +```python +>>> import supervision as sv + +>>> ds = sv.DetectionDataset(...) +>>> train_ds, test_ds = ds.split(split_ratio=0.7, random_state=42, shuffle=True) + +>>> len(train_ds), len(test_ds) +(700, 300) +``` + +- Changed [#100](https://github.com/roboflow/supervision/pull/100): default value of `approximation_percentage` parameter from `0.75` to `0.0` in `DetectionDataset.as_yolo` and `DetectionDataset.as_pascal_voc`. + +### 0.7.0 May 11, 2023 + +- Added [#91](https://github.com/roboflow/supervision/pull/91): `Detections.from_yolo_nas` to enable seamless integration with [YOLO-NAS](https://github.com/Deci-AI/super-gradients/blob/master/YOLONAS.md) model. +- Added [#86](https://github.com/roboflow/supervision/pull/86): ability to load datasets in YOLO format using `Dataset.from_yolo`. +- Added [#84](https://github.com/roboflow/supervision/pull/84): `Detections.merge` to merge multiple `Detections` objects together. +- Fixed [#81](https://github.com/roboflow/supervision/pull/81): `LineZoneAnnotator.annotate` does not return annotated frame. +- Changed [#44](https://github.com/roboflow/supervision/pull/44): `LineZoneAnnotator.annotate` to allow for custom text for the in and out tags. + +### 0.6.0 April 19, 2023 + +- Added [#71](https://github.com/roboflow/supervision/pull/71): initial `Dataset` support and ability to save `Detections` in Pascal VOC XML format. +- Added [#71](https://github.com/roboflow/supervision/pull/71): new `mask_to_polygons`, `filter_polygons_by_area`, `polygon_to_xyxy` and `approximate_polygon` utilities. +- Added [#72](https://github.com/roboflow/supervision/pull/72): ability to load Pascal VOC XML **object detections** dataset as `Dataset`. +- Changed [#70](https://github.com/roboflow/supervision/pull/70): order of `Detections` attributes to make it consistent with order of objects in `__iter__` tuple. +- Changed [#71](https://github.com/roboflow/supervision/pull/71): `generate_2d_mask` to `polygon_to_mask`. + +### 0.5.2 April 13, 2023 + +- Fixed [#63](https://github.com/roboflow/supervision/pull/63): `LineZone.trigger` function expects 4 values instead of 5. + +### 0.5.1 April 12, 2023 + +- Fixed `Detections.__getitem__` method did not return mask for selected item. +- Fixed `Detections.area` crashed for mask detections. + +### 0.5.0 April 10, 2023 + +- Added [#58](https://github.com/roboflow/supervision/pull/58): `Detections.mask` to enable segmentation support. +- Added [#58](https://github.com/roboflow/supervision/pull/58): `MaskAnnotator` to allow easy `Detections.mask` annotation. +- Added [#58](https://github.com/roboflow/supervision/pull/58): `Detections.from_sam` to enable native Segment Anything Model (SAM) support. +- Changed [#58](https://github.com/roboflow/supervision/pull/58): `Detections.area` behaviour to work not only with boxes but also with masks. + +### 0.4.0 April 5, 2023 + +- Added [#46](https://github.com/roboflow/supervision/discussions/48): `Detections.empty` to allow easy creation of empty `Detections` objects. +- Added [#56](https://github.com/roboflow/supervision/pull/56): `Detections.from_roboflow` to allow easy creation of `Detections` objects from Roboflow API inference results. +- Added [#56](https://github.com/roboflow/supervision/pull/56): `plot_images_grid` to allow easy plotting of multiple images on single plot. +- Added [#56](https://github.com/roboflow/supervision/pull/56): initial support for Pascal VOC XML format with `detections_to_voc_xml` method. +- Changed [#56](https://github.com/roboflow/supervision/pull/56): `show_frame_in_notebook` refactored and renamed to `plot_image`. + +### 0.3.2 March 23, 2023 + +- Changed [#50](https://github.com/roboflow/supervision/issues/50): Allow `Detections.class_id` to be `None`. + +### 0.3.1 March 6, 2023 + +- Fixed [#41](https://github.com/roboflow/supervision/issues/41): `PolygonZone` throws an exception when the object touches the bottom edge of the image. +- Fixed [#42](https://github.com/roboflow/supervision/issues/42): `Detections.wth_nms` method throws an exception when `Detections` is empty. +- Changed [#36](https://github.com/roboflow/supervision/pull/36): `Detections.wth_nms` support class agnostic and non-class agnostic case. + +### 0.3.0 March 6, 2023 + +- Changed: Allow `Detections.confidence` to be `None`. +- Added: `Detections.from_transformers` and `Detections.from_detectron2` to enable seamless integration with Transformers and Detectron2 models. +- Added: `Detections.area` to dynamically calculate bounding box area. +- Added: `Detections.wth_nms` to filter out double detections with NMS. Initial - only class agnostic - implementation. + +### 0.2.0 February 2, 2023 + +- Added: Advanced `Detections` filtering with pandas-like API. +- Added: `Detections.from_yolov5` and `Detections.from_yolov8` to enable seamless integration with YOLOv5 and YOLOv8 models. + +### 0.1.0 January 19, 2023 + +Say hello to Supervision ๐Ÿ‘‹ diff --git a/docs/classification/core.md b/docs/classification/core.md new file mode 100644 index 0000000..30298bc --- /dev/null +++ b/docs/classification/core.md @@ -0,0 +1,7 @@ +--- +comments: true +--- + +# Classifications + +:::supervision.classification.core.Classifications diff --git a/docs/code_of_conduct.md b/docs/code_of_conduct.md new file mode 100644 index 0000000..3030b9b --- /dev/null +++ b/docs/code_of_conduct.md @@ -0,0 +1 @@ +--8<-- ".github/CODE_OF_CONDUCT.md" diff --git a/docs/contact.md b/docs/contact.md new file mode 100644 index 0000000..6b6e520 --- /dev/null +++ b/docs/contact.md @@ -0,0 +1,29 @@ +--- +comments: true +description: Contact and support channels for Supervision documentation, bugs, feature requests, security reports, and community help. +--- + +# Contact + +Use the channel that matches the kind of request you have. + +## Bugs and Feature Requests + +Open a GitHub issue for reproducible bugs, API requests, documentation fixes, and feature proposals: + +[github.com/roboflow/supervision/issues](https://github.com/roboflow/supervision/issues) + +## Community Support + +Join the Roboflow Discord for community questions, examples, and implementation discussion: + +[discord.gg/GbfgXGJ8Bk](https://discord.gg/GbfgXGJ8Bk) + +## Package and Source + +- PyPI package: [pypi.org/project/supervision](https://pypi.org/project/supervision/) +- GitHub repository: [github.com/roboflow/supervision](https://github.com/roboflow/supervision) + +## Security Reports + +For security-sensitive reports, avoid posting public exploit details in an issue. Use GitHub's private vulnerability reporting flow for the repository when available, or contact Roboflow through the security and support channels listed on [roboflow.com](https://roboflow.com/). diff --git a/docs/contributing.md b/docs/contributing.md new file mode 100644 index 0000000..0c7bc9c --- /dev/null +++ b/docs/contributing.md @@ -0,0 +1 @@ +--8<-- ".github/CONTRIBUTING.md" diff --git a/docs/cookbooks.md b/docs/cookbooks.md new file mode 100644 index 0000000..5d0d13a --- /dev/null +++ b/docs/cookbooks.md @@ -0,0 +1,8 @@ +--- +template: cookbooks.html +comments: true +description: Collection of practical computer vision cookbooks โ€” object tracking, zero-shot detection, SAHI small object detection, occupancy analytics, and more. +hide: + - navigation + - toc +--- diff --git a/docs/datasets/core.md b/docs/datasets/core.md new file mode 100644 index 0000000..0fdcd05 --- /dev/null +++ b/docs/datasets/core.md @@ -0,0 +1,22 @@ +--- +comments: true +description: API reference for supervision's DetectionDataset and ClassificationDataset โ€” load, merge, split, and convert datasets in YOLO, COCO, VOC, CreateML, and LabelMe formats. +--- + +# Datasets + +!!! warning + + Dataset API is still fluid and may change. If you use Dataset API in your project until further notice, freeze the `supervision` version in your `requirements.txt` or `setup.py`. + +
+

DetectionDataset

+
+ +:::supervision.dataset.core.DetectionDataset + +
+

ClassificationDataset

+
+ +:::supervision.dataset.core.ClassificationDataset diff --git a/docs/deprecated.md b/docs/deprecated.md new file mode 100644 index 0000000..256e7dc --- /dev/null +++ b/docs/deprecated.md @@ -0,0 +1,54 @@ +--- +comments: true +status: deprecated +--- + +# Deprecated + +These features are phased out due to better alternatives or potential issues in future versions. Deprecated functionalities are typically supported for multiple subsequent releases, providing time for users to transition to updated methods. + +- [`sv.ByteTrack`](https://supervision.roboflow.com/latest/trackers/#supervision.tracker.byte_tracker.core.ByteTrack) is deprecated in `supervision-0.28.0` in favour of `ByteTrackTracker` from the external [`trackers`](https://pypi.org/project/trackers/) package (`pip install trackers`). The update method is renamed from `update_with_detections()` to `update()`. Removal is planned for `supervision-0.31.0`. +- `supervision.keypoint` module is deprecated in `supervision-0.27.0`; use `supervision.key_points` instead. It will be removed in `supervision-0.31.0`. +- `create_tiles` in `supervision.utils.image` is deprecated in `supervision-0.27.0`. It will be removed in `supervision-0.31.0`. +- `ensure_cv2_image_for_processing` in `supervision.utils.conversion` is deprecated in `supervision-0.27.0`. It will be removed in `supervision-0.31.0`. +- Keypoint validation utilities in `supervision.validators` are deprecated in `supervision-0.27.0`. They will be removed in `supervision-0.31.0`. +- `normalized_xyxy` argument in [`sv.denormalize_boxes`](https://supervision.roboflow.com/latest/detection/utils/boxes/#supervision.detection.utils.boxes.denormalize_boxes) is deprecated in `supervision-0.27.0` and renamed to `xyxy`. Passing `normalized_xyxy=` emits a `FutureWarning`; support will be removed in `supervision-0.31.0`. +- `supervision.dataset.utils` import path for [`sv.rle_to_mask`](https://supervision.roboflow.com/latest/detection/utils/converters/#supervision.detection.utils.converters.rle_to_mask) and [`sv.mask_to_rle`](https://supervision.roboflow.com/latest/detection/utils/converters/#supervision.detection.utils.converters.mask_to_rle) is deprecated in `supervision-0.28.0`. These functions moved to `supervision.detection.utils.converters` and will be removed from `supervision.dataset.utils` in `supervision-0.31.0`. +- `sv.LMM` enum is deprecated in `supervision-0.27.0` and will be removed in `supervision-0.31.0`. Use `sv.VLM` instead. +- [`sv.Detections.from_lmm`](https://supervision.roboflow.com/latest/detection/core/#supervision.detection.core.Detections.from_lmm) classmethod is deprecated in `supervision-0.26.0` and will be removed in `supervision-0.31.0`. Use [`sv.Detections.from_vlm`](https://supervision.roboflow.com/latest/detection/core/#supervision.detection.core.Detections.from_vlm) instead. +- `KeyPoints.confidence` is deprecated in `supervision-0.29.0`. Use `KeyPoints.keypoint_confidence` instead. It will be removed in `supervision-0.32.0`. +- Public `validate_*` helper functions are deprecated in `supervision-0.29.0` and will be removed in `supervision-0.32.0`. Supervision internals now use private `_validate_*` helpers. + +# Removed + +### 0.27.0 + +- `overlap_ratio_wh` parameter in [`sv.InferenceSlicer`](https://supervision.roboflow.com/latest/detection/tools/inference_slicer/) has been removed. Use the pixel-based `overlap_wh` parameter instead. +- `overlap_filter_strategy` parameter in [`sv.InferenceSlicer`](https://supervision.roboflow.com/latest/detection/tools/inference_slicer/) has been removed. Use `overlap_strategy` instead. + +### 0.26.0 + +- The `sv.DetectionDataset.images` property has been removed in `supervision-0.26.0`. Please loop over images with `for path, image, annotation in dataset:`, as that does not require loading all images into memory. Also, constructing `sv.DetectionDataset` with parameter `images` as `Dict[str, np.ndarray]` is deprecated and has been removed in `supervision-0.26.0`. Please pass a list of paths `List[str]` instead. +- The name `sv.BoundingBoxAnnotator` is deprecated and has been removed in `supervision-0.26.0`. It has been renamed to [`sv.BoxAnnotator`](https://supervision.roboflow.com/0.22.0/detection/annotators/#supervision.annotators.core.BoxAnnotator). + +### 0.24.0 + +- The `frame_resolution_wh ` parameter in [`sv.PolygonZone`](detection/tools/polygon_zone.md/#supervision.detection.tools.polygon_zone.PolygonZone) has been removed. +- Supervision installation methods `"headless"` and `"desktop"` were removed, as they are no longer needed. `pip install supervision[headless]` will install the base library and harmlessly warn of non-existent extras. + +### 0.23.0 + +- The `track_buffer`, `track_thresh`, and `match_thresh` parameters in [`ByteTrack`](trackers.md/#supervision.tracker.byte_tracker.core.ByteTrack) are deprecated and were removed as of `supervision-0.23.0`. Use `lost_track_buffer,` `track_activation_threshold`, and `minimum_matching_threshold` instead. +- The `triggering_position ` parameter in [`sv.PolygonZone`](detection/tools/polygon_zone.md/#supervision.detection.tools.polygon_zone.PolygonZone) was removed as of `supervision-0.23.0`. Use `triggering_anchors` instead. + +### 0.22.0 + +- `sv.Detections.from_roboflow` is removed as of `supervision-0.22.0`. Use [`Detections.from_inference`](detection/core.md/#supervision.detection.core.Detections.from_inference) instead. +- The method `sv.Color.white()` was removed as of `supervision-0.22.0`. Use the constant `sv.Color.WHITE` instead. +- The method `sv.Color.black()` was removed as of `supervision-0.22.0`. Use the constant `sv.Color.BLACK` instead. +- The method `sv.Color.red()` was removed as of `supervision-0.22.0`. Use the constant `sv.Color.RED` instead. +- The method `sv.Color.green()` was removed as of `supervision-0.22.0`. Use the constant `sv.Color.GREEN` instead. +- The method `sv.Color.blue()` was removed as of `supervision-0.22.0`. Use the constant `sv.Color.BLUE` instead. +- The method `sv.ColorPalette.default()` was removed as of `supervision-0.22.0`. Use the constant [`ColorPalette.DEFAULT`](utils/draw.md/#supervision.draw.color.ColorPalette.DEFAULT) instead. +- `sv.BoxAnnotator` was removed as of `supervision-0.22.0`, however `sv.BoundingBoxAnnotator` was immediately renamed to `sv.BoxAnnotator`. Use [`BoxAnnotator`](detection/annotators.md/#supervision.annotators.core.BoxAnnotator) and [`LabelAnnotator`](detection/annotators.md/#supervision.annotators.core.LabelAnnotator) instead of the old `sv.BoxAnnotator`. +- The method `sv.FPSMonitor.__call__` was removed as of `supervision-0.22.0`. Use the attribute [`sv.FPSMonitor.fps`](utils/video.md/#supervision.utils.video.FPSMonitor.fps) instead. diff --git a/docs/detection/annotators.md b/docs/detection/annotators.md new file mode 100644 index 0000000..91a6e27 --- /dev/null +++ b/docs/detection/annotators.md @@ -0,0 +1,685 @@ +--- +comments: true +description: API reference for supervision's annotator classes โ€” draw bounding boxes, masks, labels, tracks, and heatmaps on images with one method call. +--- + +# Annotators + +Annotators accept detections and apply box or mask visualizations to the detections. Annotators have many available styles. + +=== "Outlines" + + === "Box" + + ```python + import supervision as sv + + image = ... + detections = sv.Detections(...) + + box_annotator = sv.BoxAnnotator() + annotated_frame = box_annotator.annotate( + scene=image.copy(), + detections=detections, + ) + ``` + +
+ + ![bounding-box-annotator-example](https://media.roboflow.com/supervision-annotator-examples/bounding-box-annotator-example-purple.png){ align=center width="800" } + +
+ + === "RoundBox" + + ```python + import supervision as sv + + image = ... + detections = sv.Detections(...) + + round_box_annotator = sv.RoundBoxAnnotator() + annotated_frame = round_box_annotator.annotate( + scene=image.copy(), + detections=detections, + ) + ``` + +
+ + ![round-box-annotator-example](https://media.roboflow.com/supervision-annotator-examples/round-box-annotator-example-purple.png){ align=center width="800" } + +
+ + === "BoxCorner" + + ```python + import supervision as sv + + image = ... + detections = sv.Detections(...) + + corner_annotator = sv.BoxCornerAnnotator() + annotated_frame = corner_annotator.annotate( + scene=image.copy(), + detections=detections, + ) + ``` + +
+ + ![box-corner-annotator-example](https://media.roboflow.com/supervision-annotator-examples/box-corner-annotator-example-purple.png){ align=center width="800" } + +
+ + === "Circle" + + ```python + import supervision as sv + + image = ... + detections = sv.Detections(...) + + circle_annotator = sv.CircleAnnotator() + annotated_frame = circle_annotator.annotate( + scene=image.copy(), + detections=detections, + ) + ``` + +
+ + ![circle-annotator-example](https://media.roboflow.com/supervision-annotator-examples/circle-annotator-example-purple.png){ align=center width="800" } + +
+ + === "Ellipse" + + ```python + import supervision as sv + + image = ... + detections = sv.Detections(...) + + ellipse_annotator = sv.EllipseAnnotator() + annotated_frame = ellipse_annotator.annotate( + scene=image.copy(), + detections=detections, + ) + ``` + +
+ + ![ellipse-annotator-example](https://media.roboflow.com/supervision-annotator-examples/ellipse-annotator-example-purple.png){ align=center width="800" } + +
+ + === "Polygon" + + ```python + import supervision as sv + + image = ... + detections = sv.Detections(...) + + polygon_annotator = sv.PolygonAnnotator() + annotated_frame = polygon_annotator.annotate( + scene=image.copy(), + detections=detections, + ) + ``` + +
+ + ![polygon-annotator-example](https://media.roboflow.com/supervision-annotator-examples/polygon-annotator-example-purple.png){ align=center width="800" } + +
+ +=== "Shading" + + === "Color" + + ```python + import supervision as sv + + image = ... + detections = sv.Detections(...) + + color_annotator = sv.ColorAnnotator() + annotated_frame = color_annotator.annotate( + scene=image.copy(), + detections=detections, + ) + ``` + +
+ + ![box-mask-annotator-example](https://media.roboflow.com/supervision-annotator-examples/box-mask-annotator-example-purple.png){ align=center width="800" } + +
+ + === "Halo" + + ```python + import supervision as sv + + image = ... + detections = sv.Detections(...) + + halo_annotator = sv.HaloAnnotator() + annotated_frame = halo_annotator.annotate( + scene=image.copy(), + detections=detections, + ) + ``` + +
+ + ![halo-annotator-example](https://media.roboflow.com/supervision-annotator-examples/halo-annotator-example-purple.png){ align=center width="800" } + +
+ + === "Mask" + + ```python + import supervision as sv + + image = ... + detections = sv.Detections(...) + + mask_annotator = sv.MaskAnnotator() + annotated_frame = mask_annotator.annotate( + scene=image.copy(), + detections=detections, + ) + ``` + + !!! note + + `MaskAnnotator` expects `detections.mask` to contain instance segmentation masks aligned to the image passed to `annotate`. For dense masks, provide a boolean array of shape `(N, H, W)` where `(H, W)` matches the image height and width (it also accepts `sv.CompactMask`). If your model returns framework-specific results, convert them to `sv.Detections` first, for example with `sv.Detections.from_ultralytics(...)` or `sv.Detections.from_inference(...)`. + +
+ + ![mask-annotator-example](https://media.roboflow.com/supervision-annotator-examples/mask-annotator-example-purple.png){ align=center width="800" } + +
+ +=== "Markers" + + === "Dot" + + ```python + import supervision as sv + + image = ... + detections = sv.Detections(...) + + dot_annotator = sv.DotAnnotator() + annotated_frame = dot_annotator.annotate( + scene=image.copy(), + detections=detections, + ) + ``` + +
+ + ![dot-annotator-example](https://media.roboflow.com/supervision-annotator-examples/dot-annotator-example-purple.png){ align=center width="800" } + +
+ + === "Triangle" + + ```python + import supervision as sv + + image = ... + detections = sv.Detections(...) + + triangle_annotator = sv.TriangleAnnotator() + annotated_frame = triangle_annotator.annotate( + scene=image.copy(), + detections=detections, + ) + ``` + +
+ + ![triangle-annotator-example](https://media.roboflow.com/supervision-annotator-examples/triangle-annotator-example.png){ align=center width="800" } + +
+ +=== "Labels" + + === "Label" + + ```python + import supervision as sv + + image = ... + detections = sv.Detections(...) + + labels = [ + f"{class_name} {confidence:.2f}" + for class_name, confidence in zip( + detections["class_name"], + detections.confidence, + ) + ] + + label_annotator = sv.LabelAnnotator(text_position=sv.Position.CENTER) + annotated_frame = label_annotator.annotate( + scene=image.copy(), detections=detections, labels=labels + ) + ``` + +
+ + ![label-annotator-example](https://media.roboflow.com/supervision-annotator-examples/label-annotator-example-purple.png){ align=center width="800" } + +
+ + === "RichLabel" + + ```python + import supervision as sv + + image = ... + detections = sv.Detections(...) + + labels = [ + f"{class_name} {confidence:.2f}" + for class_name, confidence in zip( + detections["class_name"], + detections.confidence, + ) + ] + + rich_label_annotator = sv.RichLabelAnnotator( + font_path="TTF_FONT_PATH", + text_position=sv.Position.CENTER, + ) + annotated_frame = rich_label_annotator.annotate( + scene=image.copy(), + detections=detections, + labels=labels, + ) + ``` + +
+ + ![label-annotator-example](https://media.roboflow.com/supervision-annotator-examples/label-annotator-example-purple.png){ align=center width="800" } + +
+ +=== "Transformative" + + === "Blur" + + ```python + import supervision as sv + + image = ... + detections = sv.Detections(...) + + blur_annotator = sv.BlurAnnotator() + annotated_frame = blur_annotator.annotate( + scene=image.copy(), + detections=detections, + ) + ``` + +
+ + ![blur-annotator-example](https://media.roboflow.com/supervision-annotator-examples/blur-annotator-example-purple.png){ align=center width="800" } + +
+ + === "Pixelate" + + ```python + import supervision as sv + + image = ... + detections = sv.Detections(...) + + pixelate_annotator = sv.PixelateAnnotator() + annotated_frame = pixelate_annotator.annotate( + scene=image.copy(), + detections=detections, + ) + ``` + +
+ + ![pixelate-annotator-example](https://media.roboflow.com/supervision-annotator-examples/pixelate-annotator-example-10.png){ align=center width="800" } + +
+ + + +=== "Tracking & Aggregation" + + === "Trace" + + ```python + import supervision as sv + from ultralytics import YOLO + + model = YOLO("yolov8x.pt") + + trace_annotator = sv.TraceAnnotator() + + video_info = sv.VideoInfo.from_video_path(video_path="...") + frames_generator = sv.get_video_frames_generator(source_path="...") + tracker = sv.ByteTrack() + + with sv.VideoSink(target_path="...", video_info=video_info) as sink: + for frame in frames_generator: + result = model(frame)[0] + detections = sv.Detections.from_ultralytics(result) + detections = tracker.update_with_detections(detections) + annotated_frame = trace_annotator.annotate( + scene=frame.copy(), + detections=detections, + ) + sink.write_frame(frame=annotated_frame) + ``` + +
+ + ![trace-annotator-example](https://media.roboflow.com/supervision-annotator-examples/trace-annotator-example-purple.png){ align=center width="800" } + +
+ + === "HeatMap" + + ```python + import supervision as sv + from ultralytics import YOLO + + model = YOLO("yolov8x.pt") + + heat_map_annotator = sv.HeatMapAnnotator() + + video_info = sv.VideoInfo.from_video_path(video_path="...") + frames_generator = sv.get_video_frames_generator(source_path="...") + + with sv.VideoSink(target_path="...", video_info=video_info) as sink: + for frame in frames_generator: + result = model(frame)[0] + detections = sv.Detections.from_ultralytics(result) + annotated_frame = heat_map_annotator.annotate( + scene=frame.copy(), + detections=detections, + ) + sink.write_frame(frame=annotated_frame) + ``` + +
+ + ![heat-map-annotator-example](https://media.roboflow.com/supervision-annotator-examples/heat-map-annotator-example-purple.png){ align=center width="800" } + +
+ +=== "Others" + + === "PercentageBar" + + ```python + import supervision as sv + + image = ... + detections = sv.Detections(...) + + percentage_bar_annotator = sv.PercentageBarAnnotator() + annotated_frame = percentage_bar_annotator.annotate( + scene=image.copy(), + detections=detections, + ) + ``` + +
+ + ![percentage-bar-annotator-example](https://media.roboflow.com/supervision-annotator-examples/percentage-bar-annotator-example-purple.png){ align=center width="800" } + +
+ + === "Icon" + + ```python + import supervision as sv + + image = ... + detections = sv.Detections(...) + + icon_paths = ["" for _ in detections] + + icon_annotator = sv.IconAnnotator() + annotated_frame = icon_annotator.annotate( + scene=image.copy(), + detections=detections, + icon_path=icon_paths, + ) + ``` + +
+ + ![icon-annotator-example](https://media.roboflow.com/supervision-annotator-examples/icon-annotator-example.png){ align=center width="800" } + +
+ + === "Background Color" + + ```python + import supervision as sv + + image = ... + detections = sv.Detections(...) + + background_overlay_annotator = sv.BackgroundOverlayAnnotator() + annotated_frame = background_overlay_annotator.annotate( + scene=image.copy(), + detections=detections, + ) + ``` + +
+ + ![background-overlay-annotator-example](https://media.roboflow.com/supervision-annotator-examples/background-color-annotator-example-purple.png){ align=center width="800" } + +
+ + === "Comparison" + + ```python + import supervision as sv + + image = ... + detections_1 = sv.Detections(...) + detections_2 = sv.Detections(...) + + comparison_annotator = sv.ComparisonAnnotator() + annotated_frame = comparison_annotator.annotate( + scene=image.copy(), + detections_1=detections_1, + detections_2=detections_2, + ) + ``` + +
+ + ![comparison-annotator-example](https://media.roboflow.com/supervision-annotator-examples/comparison-annotator-example.png){ align=center width="800" } + +
+ +
+

Try Supervision Annotators on your own image

+ Visualize annotators on images with COCO classes such as people, vehicles, animals, household items. +
+ +
+ +
+

BoxAnnotator

+
+ +:::supervision.annotators.core.BoxAnnotator + +
+

RoundBoxAnnotator

+
+ +:::supervision.annotators.core.RoundBoxAnnotator + +
+

BoxCornerAnnotator

+
+ +:::supervision.annotators.core.BoxCornerAnnotator + +
+

OrientedBoxAnnotator

+
+ +:::supervision.annotators.core.OrientedBoxAnnotator + +
+

ColorAnnotator

+
+ +:::supervision.annotators.core.ColorAnnotator + +
+

CircleAnnotator

+
+ +:::supervision.annotators.core.CircleAnnotator + +
+

DotAnnotator

+
+ +:::supervision.annotators.core.DotAnnotator + +
+

TriangleAnnotator

+
+ +:::supervision.annotators.core.TriangleAnnotator + +
+

EllipseAnnotator

+
+ +:::supervision.annotators.core.EllipseAnnotator + +
+

HaloAnnotator

+
+ +:::supervision.annotators.core.HaloAnnotator + +
+

PercentageBarAnnotator

+
+ +:::supervision.annotators.core.PercentageBarAnnotator + +
+

HeatMapAnnotator

+
+ +:::supervision.annotators.core.HeatMapAnnotator + +
+

MaskAnnotator

+
+ +:::supervision.annotators.core.MaskAnnotator + +
+

PolygonAnnotator

+
+ +:::supervision.annotators.core.PolygonAnnotator + +
+

LabelAnnotator

+
+ +:::supervision.annotators.core.LabelAnnotator + +
+

RichLabelAnnotator

+
+ +:::supervision.annotators.core.RichLabelAnnotator + +
+

IconAnnotator

+
+ +:::supervision.annotators.core.IconAnnotator + +
+

BlurAnnotator

+
+ +:::supervision.annotators.core.BlurAnnotator + +
+

PixelateAnnotator

+
+ +:::supervision.annotators.core.PixelateAnnotator + +
+

TraceAnnotator

+
+ +:::supervision.annotators.core.TraceAnnotator + +
+

CropAnnotator

+
+ +:::supervision.annotators.core.CropAnnotator + +
+

BackgroundOverlayAnnotator

+
+ +:::supervision.annotators.core.BackgroundOverlayAnnotator + +
+

ComparisonAnnotator

+
+ +:::supervision.annotators.core.ComparisonAnnotator + +
+

ColorLookup

+
+ +:::supervision.annotators.utils.ColorLookup diff --git a/docs/detection/compact_mask.md b/docs/detection/compact_mask.md new file mode 100644 index 0000000..6d8ad44 --- /dev/null +++ b/docs/detection/compact_mask.md @@ -0,0 +1,7 @@ +--- +comments: true +--- + +# CompactMask + +:::supervision.detection.compact_mask.CompactMask diff --git a/docs/detection/core.md b/docs/detection/core.md new file mode 100644 index 0000000..0b40cd3 --- /dev/null +++ b/docs/detection/core.md @@ -0,0 +1,8 @@ +--- +comments: true +description: API reference for supervision's Detections class โ€” the core data structure for bounding boxes, masks, confidence scores, and tracker IDs. +--- + +# Detections + +:::supervision.detection.core.Detections diff --git a/docs/detection/metrics.md b/docs/detection/metrics.md new file mode 100644 index 0000000..cd719e0 --- /dev/null +++ b/docs/detection/metrics.md @@ -0,0 +1,25 @@ +--- +comments: true +--- + +# Legacy Metrics + +Starting with `0.23.0`, a new metrics module is being introduced to supervision. Metrics here are part of the legacy evaluation API and will be deprecated in the future. + +Install the metrics extra before using this page's APIs: + +```bash +pip install "supervision[metrics]" +``` + +
+

ConfusionMatrix

+
+ +:::supervision.metrics.detection.ConfusionMatrix + +
+

MeanAveragePrecision

+
+ +:::supervision.metrics.detection.MeanAveragePrecision diff --git a/docs/detection/tools/inference_slicer.md b/docs/detection/tools/inference_slicer.md new file mode 100644 index 0000000..5e16495 --- /dev/null +++ b/docs/detection/tools/inference_slicer.md @@ -0,0 +1,54 @@ +--- +comments: true +--- + +# InferenceSlicer + +## GeoTIFF Datasets + +Install the optional GeoTIFF dependencies before running this example: + +```bash +pip install "supervision[geotiff]" +wget -O RGB.byte.tif https://raw.githubusercontent.com/rasterio/rasterio/main/tests/data/RGB.byte.tif +``` + +`InferenceSlicer` can read an open `rasterio` dataset window-by-window. This keeps large GeoTIFFs out of memory while passing each tile to the callback as an `(H, W, C)` NumPy array. + +```python +import numpy as np +import rasterio +import supervision as sv + + +def callback(tile: np.ndarray) -> sv.Detections: + h, w = tile.shape[:2] + return sv.Detections( + xyxy=np.array([[w * 0.25, h * 0.25, w * 0.75, h * 0.75]], dtype=float), + confidence=np.array([0.9]), + class_id=np.array([0]), + ) + + +slicer = sv.InferenceSlicer( + callback=callback, + slice_wh=(256, 256), + overlap_wh=(64, 64), + overlap_filter=sv.OverlapFilter.NONE, +) + +with rasterio.open("RGB.byte.tif") as dataset: + detections = slicer(dataset) + +print(len(detections)) +``` + +GeoTIFF inputs must use a projected coordinate reference system. Reproject geographic rasters before passing them to `InferenceSlicer`. + +
+

WindowedRasterDataset

+
+ +:::supervision.detection.tools.inference_slicer.WindowedRasterDataset + +:::supervision.detection.tools.inference_slicer.InferenceSlicer diff --git a/docs/detection/tools/line_zone.md b/docs/detection/tools/line_zone.md new file mode 100644 index 0000000..8bca3cf --- /dev/null +++ b/docs/detection/tools/line_zone.md @@ -0,0 +1,21 @@ +--- +comments: true +--- + +
+

LineZone

+
+ +:::supervision.detection.line_zone.LineZone + +
+

LineZoneAnnotator

+
+ +:::supervision.detection.line_zone.LineZoneAnnotator + +
+

LineZoneAnnotatorMulticlass

+
+ +:::supervision.detection.line_zone.LineZoneAnnotatorMulticlass diff --git a/docs/detection/tools/polygon_zone.md b/docs/detection/tools/polygon_zone.md new file mode 100644 index 0000000..cbe76c2 --- /dev/null +++ b/docs/detection/tools/polygon_zone.md @@ -0,0 +1,15 @@ +--- +comments: true +--- + +
+

PolygonZone

+
+ +:::supervision.detection.tools.polygon_zone.PolygonZone + +
+

PolygonZoneAnnotator

+
+ +:::supervision.detection.tools.polygon_zone.PolygonZoneAnnotator diff --git a/docs/detection/tools/save_detections.md b/docs/detection/tools/save_detections.md new file mode 100644 index 0000000..a24cee5 --- /dev/null +++ b/docs/detection/tools/save_detections.md @@ -0,0 +1,17 @@ +--- +comments: true +--- + +# Save Detections + +
+

CSV Sink

+
+ +:::supervision.detection.tools.csv_sink.CSVSink + +
+

JSON Sink

+
+ +:::supervision.detection.tools.json_sink.JSONSink diff --git a/docs/detection/tools/smoother.md b/docs/detection/tools/smoother.md new file mode 100644 index 0000000..8076be1 --- /dev/null +++ b/docs/detection/tools/smoother.md @@ -0,0 +1,7 @@ +--- +comments: true +--- + +# Detection Smoother + +:::supervision.detection.tools.smoother.DetectionsSmoother diff --git a/docs/detection/utils/boxes.md b/docs/detection/utils/boxes.md new file mode 100644 index 0000000..306dc20 --- /dev/null +++ b/docs/detection/utils/boxes.md @@ -0,0 +1,41 @@ +--- +comments: true +--- + +# Boxes Utils + +
+

move_boxes

+
+ +:::supervision.detection.utils.boxes.move_boxes + +
+

scale_boxes

+
+ +:::supervision.detection.utils.boxes.scale_boxes + +
+

clip_boxes

+
+ +:::supervision.detection.utils.boxes.clip_boxes + +
+

pad_boxes

+
+ +:::supervision.detection.utils.boxes.pad_boxes + +
+

denormalize_boxes

+
+ +:::supervision.detection.utils.boxes.denormalize_boxes + +
+

xyxyxyxy_to_xyxy

+
+ +:::supervision.detection.utils.boxes.xyxyxyxy_to_xyxy diff --git a/docs/detection/utils/converters.md b/docs/detection/utils/converters.md new file mode 100644 index 0000000..5bab82f --- /dev/null +++ b/docs/detection/utils/converters.md @@ -0,0 +1,84 @@ +--- +comments: true +status: new +--- + +# Converters Utils + +
+

xyxy_to_xywh

+
+ +:::supervision.detection.utils.converters.xyxy_to_xywh + +
+

xywh_to_xyxy

+
+ +:::supervision.detection.utils.converters.xywh_to_xyxy + +
+

xyxy_to_xcycarh

+
+ +:::supervision.detection.utils.converters.xyxy_to_xcycarh + +
+

xcycwh_to_xyxy

+
+ +:::supervision.detection.utils.converters.xcycwh_to_xyxy + +
+

xyxy_to_polygons

+
+ +:::supervision.detection.utils.converters.xyxy_to_polygons + +
+

mask_to_xyxy

+
+ +:::supervision.detection.utils.converters.mask_to_xyxy + +
+

mask_to_polygons

+
+ +:::supervision.detection.utils.converters.mask_to_polygons + +
+

polygon_to_mask

+
+ +:::supervision.detection.utils.converters.polygon_to_mask + +
+

polygon_to_xyxy

+
+ +:::supervision.detection.utils.converters.polygon_to_xyxy + +
+

xyxy_to_mask

+
+ +:::supervision.detection.utils.converters.xyxy_to_mask + +
+

rle_to_mask

+
+ +:::supervision.detection.utils.converters.rle_to_mask + +
+

mask_to_rle

+
+ +:::supervision.detection.utils.converters.mask_to_rle + +
+

is_compressed_rle

+
+ +:::supervision.detection.utils.converters.is_compressed_rle diff --git a/docs/detection/utils/iou_and_nms.md b/docs/detection/utils/iou_and_nms.md new file mode 100644 index 0000000..93e98e8 --- /dev/null +++ b/docs/detection/utils/iou_and_nms.md @@ -0,0 +1,83 @@ +--- +comments: true +--- + +# IoU and NMS Utils + +
+

OverlapFilter

+
+ +:::supervision.detection.utils.iou_and_nms.OverlapFilter + +
+

OverlapMetric

+
+ +:::supervision.detection.utils.iou_and_nms.OverlapMetric + +
+

box_iou

+
+ +:::supervision.detection.utils.iou_and_nms.box_iou + +
+

box_iou_batch

+
+ +:::supervision.detection.utils.iou_and_nms.box_iou_batch + +
+

box_iou_batch_with_jaccard

+
+ +:::supervision.detection.utils.iou_and_nms.box_iou_batch_with_jaccard + +
+

mask_iou_batch

+
+ +:::supervision.detection.utils.iou_and_nms.mask_iou_batch + +
+

oriented_box_iou_batch

+
+ +:::supervision.detection.utils.iou_and_nms.oriented_box_iou_batch + +
+

box_non_max_suppression

+
+ +:::supervision.detection.utils.iou_and_nms.box_non_max_suppression + +
+

mask_non_max_suppression

+
+ +:::supervision.detection.utils.iou_and_nms.mask_non_max_suppression + +
+

box_non_max_merge

+
+ +:::supervision.detection.utils.iou_and_nms.box_non_max_merge + +
+

mask_non_max_merge

+
+ +:::supervision.detection.utils.iou_and_nms.mask_non_max_merge + +
+

oriented_box_non_max_suppression

+
+ +:::supervision.detection.utils.iou_and_nms.oriented_box_non_max_suppression + +
+

oriented_box_non_max_merge

+
+ +:::supervision.detection.utils.iou_and_nms.oriented_box_non_max_merge diff --git a/docs/detection/utils/masks.md b/docs/detection/utils/masks.md new file mode 100644 index 0000000..bf99c75 --- /dev/null +++ b/docs/detection/utils/masks.md @@ -0,0 +1,42 @@ +--- +comments: true +status: new +--- + +# Masks Utils + +
+

mask_to_roi

+
+ +:::supervision.detection.utils.masks.mask_to_roi + +
+

move_masks

+
+ +:::supervision.detection.utils.masks.move_masks + +
+

contains_holes

+
+ +:::supervision.detection.utils.masks.contains_holes + +
+

contains_multiple_segments

+
+ +:::supervision.detection.utils.masks.contains_multiple_segments + +
+

filter_segments_by_distance

+
+ +:::supervision.detection.utils.masks.filter_segments_by_distance + +
+

calculate_masks_centroids

+
+ +:::supervision.detection.utils.masks.calculate_masks_centroids diff --git a/docs/detection/utils/polygons.md b/docs/detection/utils/polygons.md new file mode 100644 index 0000000..8a7cf1e --- /dev/null +++ b/docs/detection/utils/polygons.md @@ -0,0 +1,17 @@ +--- +comments: true +--- + +# Polygons Utils + +
+

filter_polygons_by_area

+
+ +:::supervision.detection.utils.polygons.filter_polygons_by_area + +
+

approximate_polygon

+
+ +:::supervision.detection.utils.polygons.approximate_polygon diff --git a/docs/detection/utils/vlms.md b/docs/detection/utils/vlms.md new file mode 100644 index 0000000..d62bc60 --- /dev/null +++ b/docs/detection/utils/vlms.md @@ -0,0 +1,36 @@ +--- +comments: true +status: new +--- + +# VLM Utils + +
+

VLM

+
+ +:::supervision.detection.vlm.VLM + +
+

LMM

+
+ +:::supervision.detection.vlm.LMM + +
+

validate_vlm_parameters

+
+ +:::supervision.detection.vlm.validate_vlm_parameters + +
+

edit_distance

+
+ +:::supervision.detection.utils.vlms.edit_distance + +
+

fuzzy_match_index

+
+ +:::supervision.detection.utils.vlms.fuzzy_match_index diff --git a/docs/faq.md b/docs/faq.md new file mode 100644 index 0000000..7c17d7b --- /dev/null +++ b/docs/faq.md @@ -0,0 +1,58 @@ +--- +comments: true +description: Frequently asked questions about installing Supervision, supported computer vision models, datasets, tracking, metrics, and licensing. +--- + +# Frequently Asked Questions + +## What is Supervision? + +Supervision is an open-source Python library by Roboflow for computer vision workflows. It provides a unified `Detections` class with converters for supported object detection, segmentation, and VLM outputs. + +## How do I install Supervision? + +Install the base package with: + +```bash +pip install supervision +``` + +Use the `metrics` extra when you need optional metric dependencies: + +```bash +pip install "supervision[metrics]" +``` + +Sample asset utilities are part of the base package under `supervision.assets`. + +## Which object detection models work with Supervision? + +Supervision is model agnostic. `sv.Detections` includes converters for Ultralytics YOLO, Roboflow Inference, Hugging Face Transformers outputs, SAM, Detectron2, MMDetection, YOLO-NAS, PaddleDet, NCNN, Azure AI Vision, and VLM parsers including Florence-2, PaliGemma, Qwen VL, Gemini, DeepSeek VL 2, and Moondream. Keypoint outputs have separate `sv.KeyPoints` converters, including MediaPipe. + +## What can I do with Supervision? + +You can annotate images and video, filter detections, track objects, count objects in zones or across lines, load and convert datasets, evaluate models with detection metrics, and export predictions for downstream analysis. + +## How do I track objects across video frames? + +Assign persistent tracker IDs before visualization. The built-in `sv.ByteTrack` wrapper accepts `Detections` through `update_with_detections()`, but it is deprecated in favor of `ByteTrackTracker` from the external `trackers` package. After tracking, combine the output with annotators such as `sv.TraceAnnotator`, `sv.BoxAnnotator`, and `sv.LabelAnnotator`. + +## What dataset formats does Supervision support? + +For detection datasets, Supervision supports YOLO, COCO JSON, Pascal VOC, CreateML, and LabelMe. Use `DetectionDataset.from_yolo()`, `DetectionDataset.from_coco()`, `DetectionDataset.from_pascal_voc()`, `DetectionDataset.from_createml()`, or `DetectionDataset.from_labelme()` to load datasets, and the matching `as_*` methods to export them. + +## How do I count objects in a zone? + +Use `sv.PolygonZone` for arbitrary polygon regions and `sv.LineZone` for line-crossing counts. Line crossing requires `detections.tracker_id`, so run a tracker before calling the line zone trigger. + +## How do I benchmark a model? + +Install `supervision[metrics]`, then use `supervision.metrics.mean_average_precision.MeanAveragePrecision` for mAP and `sv.ConfusionMatrix` for confusion matrices. Accumulate predictions and ground-truth `Detections`, then call `compute()` to calculate metrics. + +## Is Supervision free to use? + +Yes. Supervision is free and open source under the MIT license. + +## Where is the source code? + +The source code is available at [github.com/roboflow/supervision](https://github.com/roboflow/supervision). diff --git a/docs/how_to/benchmark_a_model.md b/docs/how_to/benchmark_a_model.md new file mode 100644 index 0000000..a3dce68 --- /dev/null +++ b/docs/how_to/benchmark_a_model.md @@ -0,0 +1,478 @@ +--- +comments: true +description: Benchmark object detection models with supervision โ€” compute mAP, confusion matrix, and per-class metrics to compare model performance. +authors: + - name: Piotr Skalski + role: Computer Vision Engineer, Roboflow + github: https://github.com/SkalskiP +date_modified: 2026-04-22 +--- + +![Corgi Example](https://media.roboflow.com/supervision/image-examples/how-to/benchmark-models/corgi-sorted-2.png) + +# Benchmark a Model + +Have you ever trained multiple detection models and wondered which one performs best on your specific use case? Or maybe you've downloaded a pre-trained model and want to verify its performance on your dataset? Model benchmarking is essential for making informed decisions about which model to deploy in production. + +This guide will show an easy way to benchmark your results using `supervision`. It will go over: + +1. [Loading a dataset](#loading-a-dataset) +2. [Loading a model](#loading-a-model) +3. [Benchmarking Basics](#benchmarking-basics) +4. [Running a Model](#running-a-model) +5. [Remapping Classes](#remapping-classes) +6. [Visual Benchmarking](#visual-benchmarking) +7. [Benchmarking Metrics](#benchmarking-metrics) +8. [Mean Average Precision (mAP)](#mean-average-precision-map) +9. [F1 Score](#f1-score) +10. [Bonus: Model Leaderboard](#model-leaderboard) + +This guide will use an instance segmentation model, but it applies to object detection, instance segmentation, and oriented bounding box models (OBB) too. + +A condensed version of this guide is available as a [Colab Notebook](https://colab.research.google.com/drive/1HoOY9pZoVwGiRMmLHtir0qT6Uj45w6Ps?usp=sharing). + +## Loading a Dataset + +Suppose you start with a dataset. Perhaps you found it on [Universe](https://universe.roboflow.com/); perhaps you [labeled your own](https://roboflow.com/how-to-label/yolo11). In either case, this guide assumes you know of a labelled dataset at hand. + +We'll use the following libraries: + +- `roboflow` to manage the dataset and deploy models +- `inference` to run the models +- `supervision` to evaluate the model results + +```bash +pip install roboflow inference "supervision[metrics]" +``` + +Here's how you can download a dataset: + +```python +from roboflow import Roboflow + +rf = Roboflow(api_key="") +project = rf.workspace("").project("") +dataset = project.version("").download("") +``` + +If your dataset is from Universe, go to `Dataset` > `Download Dataset` > select the format (e.g. `YOLOv11`) > `Show download code`. + +If labeling your own data, go to the [dashboard](https://app.roboflow.com/) and check this [guide](https://docs.roboflow.com/api-reference/workspace-and-project-ids) to find your workspace and project IDs. + +In this guide, we shall use a small [Corgi v2](https://universe.roboflow.com/model-examples/segmented-animals-basic) dataset. It is well-labeled and comes with a test set. + +```python +from roboflow import Roboflow + +rf = Roboflow(api_key="") +project = rf.workspace("fbamse1-gm2os").project("corgi-v2") +dataset = project.version(4).download("yolov11") +``` + +This will create a folder called `Corgi-v2-4` with the dataset in the current working directory, with `train`, `test`, and `valid` folders and a `data.yaml` file. + +## Loading a Model + +Let's load a model. + +Select and instantiate the detection or segmentation model you want to benchmark. Supervision works with Roboflow Inference for both local and cloud-deployed models, as well as Ultralytics YOLO checkpoints. Choose the tab below that matches your preferred framework, then pass images to the loaded model during the evaluation loop. + +=== "Inference, Local" + + Roboflow supports a range of state-of-the-art [pre-trained models](https://inference.roboflow.com/quickstart/aliases/) for object detection, instance segmentation, and pose tracking. You don't even need an API key! + + Let's load such a model with inference [`inference`](https://inference.roboflow.com/). + + ```python + from inference import get_model + + model = get_model(model_id="yolov11s-seg-640") + ``` + +=== "Inference, Deployed" + + You can train and deploy a model without leaving the Roboflow platform. See this [guide](https://docs.roboflow.com/train/train/train-from-scratch) for more details. + + To load a model, you can use inference: + + ```python + from inference import get_model + + model_id = "/" + model = get_model(model_id=model_id) + ``` + +=== "Ultralytics" + + Similarly to Inference, Ultralytics allows you to run a variety of models. + + ```bash + pip install "ultralytics<=8.3.40" + ``` + + ```python + from ultralytics import YOLO + + model = YOLO("yolo11s-seg.pt") + ``` + +## Benchmarking Basics + +Evaluating your model requires careful selection of the dataset. Which images should you use?Let's go over the different scenarios. + +- **Unrelated Dataset**: If you have a dataset that was not used to train the model, this is the best choice. +- **Training Set**: This is the set of images used to train the model. This is fine if the model was not trained on this dataset. Otherwise, **never** use it for benchmarking - the results will seem unrealistically good. +- **Validation Set**: This is the set of images used to validate the model during training. Every Nth training epoch, the model is evaluated on the validation set. Often the training is stopped once the validation loss stops improving. Therefore, even while the images aren't used to train the model, it still indirectly influences the training outcome. +- **Test Set**: This is the set of images kept aside for model testing. It is exactly the set you should use for benchmarking. If the dataset was split correctly, none of these images would be shown to the model during training. + +Therefore, an unrelated dataset or the `test` set is the best choice for benchmarking. Several other problems may arise: + +- **Extra Classes**: An unrelated dataset may contain additional classes which you may need to [filter out](https://supervision.roboflow.com/how_to/filter_detections/#by-set-of-classes) before computing metrics. +- **Class Mismatch**: In an unrelated dataset, the class names or IDs may be different to what your model produces, you'll need to remap them, which is [shown in this guide](#running-a-model). +- **Data Contamination**: The `test` set may not be split correctly, with images from the test set also present in `training` or `validation` set and used during training. In this case, the results will be overly optimistic. This also applies when **very similar** images are used for training and testing - e.g. those taken in the same environment, same lighting conditions, similar angle, etc. +- **Missing Test Set**: Some datasets do not come with a test set. In this case, you should collect and [label](https://roboflow.com/annotate) your own data. Alternatively, a validation set could be used, but the results could be overly optimistic. Make sure to test in the real world as soon as possible. + +## Running a Model + +At this stage, you should have: + +- A dataset of labeled images to evaluate the model. +- A model prepared for benchmarking. + +With these ready, we can now run the model and obtain predictions. We'll use `supervision` to create a dataset iterator, and then run the model on each image. + +=== "Inference" + + ```python + import supervision as sv + + test_set = sv.DetectionDataset.from_yolo( + images_directory_path=f"{dataset.location}/test/images", + annotations_directory_path=f"{dataset.location}/test/labels", + data_yaml_path=f"{dataset.location}/data.yaml", + ) + + image_paths = [] + predictions_list = [] + targets_list = [] + + for image_path, image, label in test_set: + result = model.infer(image)[0] + predictions = sv.Detections.from_inference(result) + + image_paths.append(image_path) + predictions_list.append(predictions) + targets_list.append(label) + ``` + +=== "Ultralytics" + + ```python + import supervision as sv + + test_set = sv.DetectionDataset.from_yolo( + images_directory_path=f"{dataset.location}/test/images", + annotations_directory_path=f"{dataset.location}/test/labels", + data_yaml_path=f"{dataset.location}/data.yaml", + ) + + image_paths = [] + predictions_list = [] + targets_list = [] + + for image_path, image, label in test_set: + result = model(image)[0] + predictions = sv.Detections.from_ultralytics(result) + + image_paths.append(image_path) + predictions_list.append(predictions) + targets_list.append(label) + ``` + +## Remapping classes + +Did you notice an issue in the above logic? Since we're using an unrelated dataset, the class names and IDs may be different from what the model was trained on. + +We need to remap them to match the dataset classes. Here's how to do it: + +```python +def remap_classes( + detections: sv.Detections, + class_ids_from_to: dict[int, int], + class_names_from_to: dict[str, str], +) -> None: + new_class_ids = [ + class_ids_from_to.get(class_id, class_id) for class_id in detections.class_id + ] + detections.class_id = np.array(new_class_ids) + + new_class_names = [ + class_names_from_to.get(name, name) for name in detections["class_name"] + ] + predictions["class_name"] = np.array(new_class_names) +``` + +Let's also remove the predictions that are not in the dataset classes. + +=== "Inference" + + Dataset class names and IDs can be found in the `data.yaml` file, or by printing `dataset.classes`. + + ```python + import supervision as sv + + test_set = sv.DetectionDataset.from_yolo( + images_directory_path=f"{dataset.location}/test/images", + annotations_directory_path=f"{dataset.location}/test/labels", + data_yaml_path=f"{dataset.location}/data.yaml", + ) + + image_paths = [] + predictions_list = [] + targets_list = [] + + for image_path, image, label in test_set: + result = model.infer(image)[0] + predictions = sv.Detections.from_inference(result) + + remap_classes( + detections=predictions, + class_ids_from_to={16: 0}, + class_names_from_to={"dog": "Corgi"}, + ) + predictions = predictions[np.isin(predictions["class_name"], test_set.classes),] + + image_paths.append(image_path) + predictions_list.append(predictions) + targets_list.append(label) + ``` + +=== "Ultralytics" + + Dataset class names and IDs can be found in the `data.yaml` file, or by printing `dataset.classes`. + + Each model will have a different class mapping, so make sure to check the model's documentation. In this case, the model was trained on the COCO dataset, with a class configuration found [here](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/coco8.yaml). + + ```python + import supervision as sv + + test_set = sv.DetectionDataset.from_yolo( + images_directory_path=f"{dataset.location}/test/images", + annotations_directory_path=f"{dataset.location}/test/labels", + data_yaml_path=f"{dataset.location}/data.yaml", + ) + + image_paths = [] + predictions_list = [] + targets_list = [] + + for image_path, image, label in test_set: + result = model(image)[0] + predictions = sv.Detections.from_ultralytics(result) + + remap_classes( + detections=predictions, + class_ids_from_to={16: 0}, + class_names_from_to={"dog": "Corgi"}, + ) + predictions = predictions[np.isin(predictions["class_name"], test_set.classes),] + + image_paths.append(image_path) + predictions_list.append(predictions) + targets_list.append(label) + ``` + +## Visualizing Predictions + +The first step in evaluating your modelโ€™s performance is to visualize its predictions. This gives an intuitive sense of how well your model is detecting objects and where it might be failing. + +```python +import supervision as sv + +N = 9 +GRID_SIZE = (3, 3) + +target_annotator = sv.PolygonAnnotator(color=sv.Color.from_hex("#8315f9"), thickness=8) +prediction_annotator = sv.PolygonAnnotator( + color=sv.Color.from_hex("#00cfc6"), thickness=6 +) + + +annotated_images = [] +for image_path, predictions, targets in zip( + image_paths[:N], predictions_list[:N], targets_list[:N] +): + annotated_image = cv2.imread(image_path) + annotated_image = target_annotator.annotate( + scene=annotated_image, detections=targets + ) + annotated_image = prediction_annotator.annotate( + scene=annotated_image, detections=prediction + ) + annotated_images.append(annotated_image) + +sv.plot_images_grid(images=annotated_images, grid_size=GRID_SIZE) +``` + +Here, predictions in purple are targets (ground truth), and predictions in teal are model predictions. + +![Basic Model Comparison](https://media.roboflow.com/supervision/image-examples/how-to/benchmark-models/basic-model-comparison-corgi.png) + +!!! tip + + Use `sv.BoxAnnotator` for object detection and `sv.OrientedBoxAnnotator` for OBB. + + See [annotator documentation](https://supervision.roboflow.com/latest/detection/annotators/) for even more options. + +## Visual Benchmarking + +To inspect where a model succeeds and fails, pass `save_directory_path` to `sv.ConfusionMatrix.benchmark(...)`. For every dataset image it writes a 2x2 result grid โ€” `Ground Truth`, `True Positives`, `False Positives`, and `False Negatives` panels โ€” directly into that directory, reusing the original image filenames. This makes it easy to skim through per-image outcomes alongside the aggregate confusion matrix. + +```python +import supervision as sv + +confusion_matrix = sv.ConfusionMatrix.benchmark( + dataset=test_set, + callback=callback, + save_directory_path="./results", +) +``` + +## Benchmarking Metrics + +With multiple models, fine details matter. Visual inspection may not be enough. `supervision` provides a collection of metrics that help obtain precise numerical results of model performance. + +### Mean Average Precision (mAP) + +We'll start with [MeanAveragePrecision (mAP)](https://supervision.roboflow.com/latest/metrics/mean_average_precision/#supervision.metrics.mean_average_precision.MeanAveragePrecision), which is the most commonly used metric for object detection. It measures the average precision across all classes and IoU thresholds. + +For a thorough explanation, check out our [blog](https://blog.roboflow.com/mean-average-precision/) and [Youtube video](https://www.youtube.com/watch?v=oqXDdxF_Wuw). + +Here, the most popular value is `mAP 50:95`. It represents the average precision across all classes and IoU thresholds (`0.5` to `0.95`), whereas other values such as `mAP 50` or `mAP 75` only consider a single IoU threshold (`0.5` and `0.75` respectively). + +Let's compute the mAP: + +```python +from supervision.metrics import MeanAveragePrecision, MetricTarget + +map_metric = MeanAveragePrecision(metric_target=MetricTarget.MASKS) +map_result = map_metric.update(predictions_list, targets_list).compute() +``` + +Try printing the result to see it at a glance: + +```python +print(map_result) +``` + +``` +MeanAveragePrecisionResult: +Metric target: MetricTarget.MASKS +Class agnostic: False +mAP @ 50:95: 0.2409 +mAP @ 50: 0.3591 +mAP @ 75: 0.2915 +mAP scores: [0.35909 0.3468 0.34556 ...] +IoU thresh: [0.5 0.55 0.6 ...] +AP per class: + 0: [0.35909 0.3468 0.34556 ...] +... +Small objects: ... +Medium objects: ... +Large objects: ... +``` + +You can also plot the results: + +```python +map_result.plot() +``` + +![mAP Plot](https://media.roboflow.com/supervision/image-examples/how-to/benchmark-models/mAP-plot-corgi.png) + +The metric also breaks down the results by detected object area. Small, medium and large are simply those with area less than 32ยฒ, between 32ยฒ and 96ยฒ, and greater than 96ยฒ pixels respectively. + +### F1 Score + +The [F1 Score](https://supervision.roboflow.com/latest/metrics/f1_score/) is another useful metric, especially when dealing with an imbalance between false positives and false negatives. Itโ€™s the harmonic mean of **precision** (how many predictions are correct) and **recall** (how many actual instances were detected). + +Here's how you can compute the F1 score: + +```python +from supervision.metrics import F1Score, MetricTarget + +f1_metric = F1Score(metric_target=MetricTarget.MASKS) +f1_result = f1_metric.update(predictions_list, targets_list).compute() +``` + +As with mAP, you can also print the result: + +```python +print(f1_result) +``` + +``` +F1ScoreResult: +Metric target: MetricTarget.MASKS +Averaging method: AveragingMethod.WEIGHTED +F1 @ 50: 0.5341 +F1 @ 75: 0.4636 +F1 @ thresh: [0.53406 0.5278 0.52153 ...] +IoU thresh: [0.5 0.55 0.6 ...] +F1 per class: + 0: [0.53406 0.5278 0.52153 ...] +... +Small objects: ... +Medium objects: ... +Large objects: ... +``` + +Similarly, you can plot the results: + +```python +f1_result.plot() +``` + +![F1 Plot](https://media.roboflow.com/supervision/image-examples/how-to/benchmark-models/f1-score-corgi.png) + +As with mAP, the metric also breaks down the results by detected object area. Small, medium and large are simply those with area less than 32ยฒ, between 32ยฒ and 96ยฒ, and greater than 96ยฒ pixels respectively. + +## Model Leaderboard + +Here to compare the basic models? We've got you covered. Check out our [Model Leaderboard](https://leaderboard.roboflow.com/) to see how different models perform and to get a sense of the state-of-the-art results. It's a great place to understand what the leading models can achieve and to compare your own results. + +Even better, the repository is open source! You can see how the models were benchmarked, run the evaluation yourself, and even add your own models to the leaderboard. Check it out on [GitHub](https://github.com/roboflow/model-leaderboard)! + +![Model Leaderboard Example](https://media.roboflow.com/model-leaderboard/model-leaderboard-example.png) + +## Conclusion + +In this guide, you've learned how to set up your environment, train or use pre-trained models, visualize predictions, and evaluate model performance with metrics like [mAP](https://supervision.roboflow.com/latest/metrics/mean_average_precision/), [F1 score](https://supervision.roboflow.com/latest/metrics/f1_score/), and got to know our Model Leaderboard. + +A condensed version of this guide is also available as a [Colab Notebook](https://colab.research.google.com/drive/1HoOY9pZoVwGiRMmLHtir0qT6Uj45w6Ps?usp=sharing). + +For more details, be sure to check out our [documentation](https://supervision.roboflow.com/latest/) and join our community discussions. If you find any issues, please let us know on [GitHub](https://github.com/roboflow/supervision/issues). + +Best of luck with your benchmarking! + +## Frequently Asked Questions + +### How do I benchmark a model with supervision? + +Use `supervision.metrics.mean_average_precision.MeanAveragePrecision` โ€” accumulate prediction and ground-truth `Detections` with `update(...)` and then call `compute()`. For confusion matrices, use `sv.ConfusionMatrix.from_detections(predictions=predictions, targets=targets, classes=classes)`. + +### What IoU thresholds does MeanAveragePrecision use? + +It computes mAP over IoU thresholds from 0.50 to 0.95 in steps of 0.05 (mAP@50:95), plus mAP@50 and mAP@75 individually. + +### Can I benchmark segmentation models? + +Yes, if you want to evaluate their bounding boxes. Convert model outputs to `Detections` and pass them to `MeanAveragePrecision.update(...)`; the current mAP path prepares COCO-style bounding boxes from `detections.xyxy`. + +### What is a ConfusionMatrix and how do I use it? + +`sv.ConfusionMatrix` visualizes true positives, false positives, and false negatives per class. Create one with `sv.ConfusionMatrix.from_detections(predictions=predictions, targets=targets, classes=classes, conf_threshold=0.5, iou_threshold=0.5)`, then call `confusion_matrix.plot()` to render a heatmap. If you want per-image validation visualizations saved to disk, pass `save_directory_path="./results"` to `sv.ConfusionMatrix.benchmark(...)`; it will write 2x2 result grids directly into that directory using the original image filenames, with `Ground Truth`, `True Positives`, `False Positives`, and `False Negatives` panels. + +## Author + +- [Piotr Skalski](https://github.com/SkalskiP) โ€” Computer Vision Engineer, Roboflow diff --git a/docs/how_to/count_in_zone.md b/docs/how_to/count_in_zone.md new file mode 100644 index 0000000..8159f1f --- /dev/null +++ b/docs/how_to/count_in_zone.md @@ -0,0 +1,150 @@ +--- +comments: true +description: Count objects entering a polygon zone in images and video using supervision's PolygonZone โ€” measure throughput and density in any region. +authors: + - name: Piotr Skalski + role: Computer Vision Engineer, Roboflow + github: https://github.com/SkalskiP +date_modified: 2026-04-22 +--- + +With supervision, you can count the number of objects in a zone in an image or video. In this guide, we will show how to count the number of cars in a traffic video. + +[View the notebook that accompanies this tutorial](https://github.com/roboflow/notebooks/blob/main/notebooks/how-to-use-polygonzone-annotate-and-supervision.ipynb). + +To make it easier for you to follow our tutorial download the video we will use as an example. You can do this using the `supervision.assets` module: + +```python +from supervision.assets import download_assets, VideoAssets + +download_assets(VideoAssets.VEHICLES_2) +``` + +## Initialize a Model and Load Video + +First, we need to initialize a model. Let's use a YOLOv8 model with the default COCO checkpoint. We also need to load a video on which to run inference. + +Create a YOLO model instance and download the source video. The model will process each frame during inference. A shared color palette ensures consistent zone coloring throughout the output video. + +```python +import numpy as np +import supervision as sv +import cv2 + +from ultralytics import YOLO +from supervision.assets import VideoAssets, download_assets + +model = YOLO("yolov8s.pt") + +VIDEO = download_assets(VideoAssets.VEHICLES_2) + +colors = sv.ColorPalette.DEFAULT +``` + +## Calculate Coordinates + +To count objects in a zone, you need to know the coordinates where you want to draw the zone. + +You can calculate coordinates using the [PolygonZone web utility](https://roboflow.github.io/polygonzone/). + +To use the PolygonZone website, you will need to upload an image or frame from a video. You can retrieve a frame using this code: + +```python +generator = sv.get_video_frames_generator(VIDEO) +iterator = iter(generator) + +frame = next(iterator) + +cv2.imwrite("first_frame.png", frame) +``` + +PolygonZone will give you NumPy arrays that you can use with supervision to count objects in zones. + + + +Save the coordinates in an array: + +```python +polygons = [ + np.array([[718, 595], [927, 592], [851, 1062], [42, 1059]]), + np.array([[987, 595], [1199, 595], [1893, 1056], [1015, 1062]]), +] +``` + +## Define Zones + +With the coordinates of the zones to draw ready, we can set up our zones: + +Instantiate a `PolygonZone` for each polygon array, pairing it with a `PolygonZoneAnnotator` for visual overlay and a `BoxAnnotator` for drawing detection boxes. Each zone will later trigger on incoming detections to determine which objects fall inside its boundaries, enabling per-zone counting in the inference callback. + +```python +zones = [sv.PolygonZone(polygon=polygon) for polygon in polygons] +zone_annotators = [ + sv.PolygonZoneAnnotator( + zone=zone, + color=colors.by_idx(index), + thickness=4, + text_thickness=8, + text_scale=4, + ) + for index, zone in enumerate(zones) +] +box_annotators = [ + sv.BoxAnnotator( + color=colors.by_idx(index), + thickness=4, + ) + for index in range(len(polygons)) +] +``` + +## Run Inference + +We can run inference on a video using the [sv.process_video](https://supervision.roboflow.com/utils/video/#process_video) function. This function accepts a callback that runs inference on each frame and compiles the results into a video. + +Below, we can call our YOLOv8 model, annotate predictions and zones, then save the results to a file called `result.mp4`. + +```python +def process_frame(frame: np.ndarray, i) -> np.ndarray: + results = model(frame, imgsz=1280, verbose=False)[0] + detections = sv.Detections.from_ultralytics(results) + + for zone, zone_annotator, box_annotator in zip( + zones, zone_annotators, box_annotators + ): + mask = zone.trigger(detections=detections) + detections_filtered = detections[mask] + frame = box_annotator.annotate(scene=frame, detections=detections_filtered) + frame = zone_annotator.annotate(scene=frame) + + return frame + + +sv.process_video(source_path=VIDEO, target_path="result.mp4", callback=process_frame) +``` + +Here is an example of inference run on the video: + + + +## Frequently Asked Questions + +### How do I count objects in a zone with supervision? + +Create `sv.PolygonZone` with a polygon defining your region. Call `zone.trigger(detections)` on each frame โ€” it returns a mask of detections inside the zone. + +### Can I count objects crossing a line instead of entering a zone? + +Yes. Use `sv.LineZone` โ€” define a start and end point. `zone.trigger(detections)` returns a tuple of two boolean arrays, `(crossed_in, crossed_out)`, indicating which detections crossed the line in each direction. `LineZone` requires `detections.tracker_id`; run a tracker first so the same object can be matched across frames. + +### Can I combine zone counting with tracking? + +Yes. You can pass tracker IDs from `sv.ByteTrack` alongside your detections, but `sv.PolygonZone` still evaluates the zone on each frame and reports which objects are currently inside it. If you want to count each object only once when it first enters the zone, maintain a set of seen `tracker_id` values after filtering detections with `zone.trigger(detections)`, or use a dedicated entry/crossing counting tool such as `sv.LineZone` when it better matches your use case. + +## Author + +- [Piotr Skalski](https://github.com/SkalskiP) โ€” Computer Vision Engineer, Roboflow diff --git a/docs/how_to/detect_and_annotate.md b/docs/how_to/detect_and_annotate.md new file mode 100644 index 0000000..9cbc3ac --- /dev/null +++ b/docs/how_to/detect_and_annotate.md @@ -0,0 +1,460 @@ +--- +comments: true +description: Learn to load model predictions, create Detections objects, and annotate images with bounding boxes, labels, and masks using supervision. +authors: + - name: Piotr Skalski + role: Computer Vision Engineer, Roboflow + github: https://github.com/SkalskiP + - name: Borda + role: Open Source Engineer, Roboflow + github: https://github.com/borda +date_modified: 2026-04-22 +--- + +# Detect and Annotate + +!!! tip "Sample Image" + + Don't have an image? Download the one used in this tutorial: + + ```bash + wget https://media.roboflow.com/notebooks/examples/dog.jpeg + ``` + + ``` + Then replace `` with `"dog.jpeg"`. + ``` + +Supervision provides a seamless process for annotating predictions generated by various object detection and segmentation models. This guide shows how to perform inference with the [Inference](https://github.com/roboflow/inference), [Ultralytics](https://github.com/ultralytics/ultralytics) or [Transformers](https://github.com/huggingface/transformers) packages. Following this, you'll learn how to import these predictions into Supervision and use them to annotate source image. + +![basic-annotation](https://media.roboflow.com/supervision_detect_and_annotate_example_1.png) + +## Run Detection + +First, you'll need to obtain predictions from your object detection or segmentation model. + +To run inference, initialize your chosen model and pass the source image to its predict or infer method. Supervision supports Roboflow Inference, Ultralytics YOLO, and Hugging Face Transformers -- select the tab matching your framework. The result is a framework-specific object you will convert to a `Detections` instance in the next step. + +=== "Inference" + + ```python + import cv2 + from inference import get_model + + model = get_model(model_id="yolov8n-640") + image = cv2.imread("dog.jpeg") + results = model.infer(image)[0] + ``` + +=== "Ultralytics" + + ```python + import cv2 + from ultralytics import YOLO + + model = YOLO("yolov8n.pt") + image = cv2.imread("dog.jpeg") + results = model(image)[0] + ``` + +=== "Transformers" + + ```python + import torch + from PIL import Image + from transformers import DetrImageProcessor, DetrForObjectDetection + + processor = DetrImageProcessor.from_pretrained("facebook/detr-resnet-50") + model = DetrForObjectDetection.from_pretrained("facebook/detr-resnet-50") + + image = Image.open("dog.jpeg") + inputs = processor(images=image, return_tensors="pt") + + with torch.no_grad(): + outputs = model(**inputs) + + width, height = image.size + target_size = torch.tensor([[height, width]]) + results = processor.post_process_object_detection( + outputs=outputs, target_sizes=target_size + )[0] + ``` + +## Load Predictions into Supervision + +Now that we have predictions from a model, we can load them into Supervision. + +Each supported framework has a dedicated class method on `sv.Detections` that converts raw model output into a unified Supervision object. Call `from_inference`, `from_ultralytics`, or `from_transformers` depending on the package you used for inference. This normalization step ensures all downstream annotators and filters work identically regardless of the source model. + +=== "Inference" + + We can do so using the [`sv.Detections.from_inference`](https://supervision.roboflow.com/latest/detection/core/#supervision.detection.core.Detections.from_inference) method, which accepts model results from both detection and segmentation models. + + ```{ .py hl_lines="2 8" } + import cv2 + import supervision as sv + from inference import get_model + + model = get_model(model_id="yolov8n-640") + image = cv2.imread("dog.jpeg") + results = model.infer(image)[0] + detections = sv.Detections.from_inference(results) + ``` + +=== "Ultralytics" + + We can do so using the [`sv.Detections.from_ultralytics`](https://supervision.roboflow.com/latest/detection/core/#supervision.detection.core.Detections.from_ultralytics) method, which accepts model results from both detection and segmentation models. + + ```{ .py hl_lines="2 8" } + import cv2 + import supervision as sv + from ultralytics import YOLO + + model = YOLO("yolov8n.pt") + image = cv2.imread("dog.jpeg") + results = model(image)[0] + detections = sv.Detections.from_ultralytics(results) + ``` + +=== "Transformers" + + We can do so using the [`sv.Detections.from_transformers`](https://supervision.roboflow.com/latest/detection/core/#supervision.detection.core.Detections.from_transformers) method, which accepts model results from both detection and segmentation models. + + ```{ .py hl_lines="2 19-21" } + import torch + import supervision as sv + from PIL import Image + from transformers import DetrImageProcessor, DetrForObjectDetection + + processor = DetrImageProcessor.from_pretrained("facebook/detr-resnet-50") + model = DetrForObjectDetection.from_pretrained("facebook/detr-resnet-50") + + image = Image.open("dog.jpeg") + inputs = processor(images=image, return_tensors="pt") + + with torch.no_grad(): + outputs = model(**inputs) + + width, height = image.size + target_size = torch.tensor([[height, width]]) + results = processor.post_process_object_detection( + outputs=outputs, target_sizes=target_size)[0] + detections = sv.Detections.from_transformers( + transformers_results=results, + id2label=model.config.id2label) + ``` + +You can load predictions from other computer vision frameworks and libraries using: + +- [`from_deepsparse`](https://supervision.roboflow.com/latest/detection/core/#supervision.detection.core.Detections.from_deepsparse) ([Deepsparse](https://github.com/neuralmagic/deepsparse)) +- [`from_detectron2`](https://supervision.roboflow.com/latest/detection/core/#supervision.detection.core.Detections.from_detectron2) ([Detectron2](https://github.com/facebookresearch/detectron2)) +- [`from_mmdetection`](https://supervision.roboflow.com/latest/detection/core/#supervision.detection.core.Detections.from_mmdetection) ([MMDetection](https://github.com/open-mmlab/mmdetection)) +- [`from_sam`](https://supervision.roboflow.com/latest/detection/core/#supervision.detection.core.Detections.from_sam) ([Segment Anything Model](https://github.com/facebookresearch/segment-anything)) +- [`from_yolo_nas`](https://supervision.roboflow.com/latest/detection/core/#supervision.detection.core.Detections.from_yolo_nas) ([YOLO-NAS](https://github.com/Deci-AI/super-gradients/blob/master/YOLONAS.md)) + +## Annotate Image with Detections + +Finally, we can annotate the image with the predictions. Since we are working with an object detection model, we will use the [`sv.BoxAnnotator`](https://supervision.roboflow.com/latest/detection/annotators/#supervision.annotators.core.BoxAnnotator) and [`sv.LabelAnnotator`](https://supervision.roboflow.com/latest/detection/annotators/#supervision.annotators.core.LabelAnnotator) classes. + +To draw bounding boxes and class labels on your image, create a `BoxAnnotator` and a `LabelAnnotator`, then call their `annotate` methods in sequence. Each annotator returns the modified image, so you can chain multiple annotators together. The result is a single NumPy array with all visual overlays rendered and ready for display or saving. + +=== "Inference" + + ```{ .py hl_lines="10-16" } + import cv2 + import supervision as sv + from inference import get_model + + model = get_model(model_id="yolov8n-640") + image = cv2.imread("dog.jpeg") + results = model.infer(image)[0] + detections = sv.Detections.from_inference(results) + + box_annotator = sv.BoxAnnotator() + label_annotator = sv.LabelAnnotator() + + annotated_image = box_annotator.annotate( + scene=image, detections=detections) + annotated_image = label_annotator.annotate( + scene=annotated_image, detections=detections) + ``` + +=== "Ultralytics" + + ```{ .py hl_lines="10-16" } + import cv2 + import supervision as sv + from ultralytics import YOLO + + model = YOLO("yolov8n.pt") + image = cv2.imread("dog.jpeg") + results = model(image)[0] + detections = sv.Detections.from_ultralytics(results) + + box_annotator = sv.BoxAnnotator() + label_annotator = sv.LabelAnnotator() + + annotated_image = box_annotator.annotate( + scene=image, detections=detections) + annotated_image = label_annotator.annotate( + scene=annotated_image, detections=detections) + ``` + +=== "Transformers" + + ```{ .py hl_lines="23-30" } + import torch + import supervision as sv + from PIL import Image + from transformers import DetrImageProcessor, DetrForObjectDetection + + processor = DetrImageProcessor.from_pretrained("facebook/detr-resnet-50") + model = DetrForObjectDetection.from_pretrained("facebook/detr-resnet-50") + + image = Image.open("dog.jpeg") + inputs = processor(images=image, return_tensors="pt") + + with torch.no_grad(): + outputs = model(**inputs) + + width, height = image.size + target_size = torch.tensor([[height, width]]) + results = processor.post_process_object_detection( + outputs=outputs, target_sizes=target_size)[0] + detections = sv.Detections.from_transformers( + transformers_results=results, + id2label=model.config.id2label) + + box_annotator = sv.BoxAnnotator() + label_annotator = sv.LabelAnnotator() + + annotated_image = box_annotator.annotate( + scene=image, detections=detections) + annotated_image = label_annotator.annotate( + scene=annotated_image, detections=detections) + ``` + +![basic-annotation](https://media.roboflow.com/supervision_detect_and_annotate_example_1.png) + +## Display Custom Labels + +By default, [`sv.LabelAnnotator`](https://supervision.roboflow.com/latest/detection/annotators/#supervision.annotators.core.LabelAnnotator) will label each detection with its `class_name` (if possible) or `class_id`. You can override this behavior by passing a list of custom `labels` to the `annotate` method. + +=== "Inference" + + ```{ .py hl_lines="13-17 22" } + import cv2 + import supervision as sv + from inference import get_model + + model = get_model(model_id="yolov8n-640") + image = cv2.imread("dog.jpeg") + results = model.infer(image)[0] + detections = sv.Detections.from_inference(results) + + box_annotator = sv.BoxAnnotator() + label_annotator = sv.LabelAnnotator() + + labels = [ + f"{class_name} {confidence:.2f}" + for class_name, confidence + in zip(detections['class_name'], detections.confidence) + ] + + annotated_image = box_annotator.annotate( + scene=image, detections=detections) + annotated_image = label_annotator.annotate( + scene=annotated_image, detections=detections, labels=labels) + ``` + +=== "Ultralytics" + + ```{ .py hl_lines="13-17 22" } + import cv2 + import supervision as sv + from ultralytics import YOLO + + model = YOLO("yolov8n.pt") + image = cv2.imread("dog.jpeg") + results = model(image)[0] + detections = sv.Detections.from_ultralytics(results) + + box_annotator = sv.BoxAnnotator() + label_annotator = sv.LabelAnnotator() + + labels = [ + f"{class_name} {confidence:.2f}" + for class_name, confidence + in zip(detections['class_name'], detections.confidence) + ] + + annotated_image = box_annotator.annotate( + scene=image, detections=detections) + annotated_image = label_annotator.annotate( + scene=annotated_image, detections=detections, labels=labels) + ``` + +=== "Transformers" + + ```{ .py hl_lines="26-30 35" } + import torch + import supervision as sv + from PIL import Image + from transformers import DetrImageProcessor, DetrForObjectDetection + + processor = DetrImageProcessor.from_pretrained("facebook/detr-resnet-50") + model = DetrForObjectDetection.from_pretrained("facebook/detr-resnet-50") + + image = Image.open("dog.jpeg") + inputs = processor(images=image, return_tensors="pt") + + with torch.no_grad(): + outputs = model(**inputs) + + width, height = image.size + target_size = torch.tensor([[height, width]]) + results = processor.post_process_object_detection( + outputs=outputs, target_sizes=target_size)[0] + detections = sv.Detections.from_transformers( + transformers_results=results, + id2label=model.config.id2label) + + box_annotator = sv.BoxAnnotator() + label_annotator = sv.LabelAnnotator() + + labels = [ + f"{class_name} {confidence:.2f}" + for class_name, confidence + in zip(detections['class_name'], detections.confidence) + ] + + annotated_image = box_annotator.annotate( + scene=image, detections=detections) + annotated_image = label_annotator.annotate( + scene=annotated_image, detections=detections, labels=labels) + ``` + +![custom-label-annotation](https://media.roboflow.com/supervision_detect_and_annotate_example_2.png) + +## Annotate Image with Segmentations + +If you are running the segmentation model [`sv.MaskAnnotator`](https://supervision.roboflow.com/latest/detection/annotators/#supervision.annotators.core.MaskAnnotator) is a drop-in replacement for [`sv.BoxAnnotator`](https://supervision.roboflow.com/latest/detection/annotators/#supervision.annotators.core.BoxAnnotator) that will allow you to draw masks instead of boxes. + +=== "Inference" + + ```python + import cv2 + import supervision as sv + from inference import get_model + + model = get_model(model_id="yolov8n-seg-640") + image = cv2.imread("dog.jpeg") + results = model.infer(image)[0] + detections = sv.Detections.from_inference(results) + + mask_annotator = sv.MaskAnnotator() + label_annotator = sv.LabelAnnotator(text_position=sv.Position.CENTER_OF_MASS) + + annotated_image = mask_annotator.annotate( + scene=image, + detections=detections, + ) + annotated_image = label_annotator.annotate( + scene=annotated_image, + detections=detections, + ) + sv.plot_image(annotated_image) + ``` + +=== "Ultralytics" + + ```python + import cv2 + import supervision as sv + from ultralytics import YOLO + + model = YOLO("yolov8n-seg.pt") + image = cv2.imread("dog.jpeg") + results = model(image)[0] + detections = sv.Detections.from_ultralytics(results) + + mask_annotator = sv.MaskAnnotator() + label_annotator = sv.LabelAnnotator(text_position=sv.Position.CENTER_OF_MASS) + + annotated_image = mask_annotator.annotate( + scene=image, + detections=detections, + ) + annotated_image = label_annotator.annotate( + scene=annotated_image, + detections=detections, + ) + ``` + +=== "Transformers" + + ```python + import torch + import supervision as sv + from PIL import Image + from transformers import DetrImageProcessor, DetrForSegmentation + + processor = DetrImageProcessor.from_pretrained("facebook/detr-resnet-50-panoptic") + model = DetrForSegmentation.from_pretrained("facebook/detr-resnet-50-panoptic") + + image = Image.open("dog.jpeg") + inputs = processor(images=image, return_tensors="pt") + + with torch.no_grad(): + outputs = model(**inputs) + + width, height = image.size + target_size = torch.tensor([[height, width]]) + results = processor.post_process_segmentation( + outputs=outputs, target_sizes=target_size + )[0] + detections = sv.Detections.from_transformers( + transformers_results=results, id2label=model.config.id2label + ) + + mask_annotator = sv.MaskAnnotator() + label_annotator = sv.LabelAnnotator(text_position=sv.Position.CENTER_OF_MASS) + + labels = [ + f"{class_name} {confidence:.2f}" + for class_name, confidence in zip( + detections["class_name"], + detections.confidence, + ) + ] + + annotated_image = mask_annotator.annotate(scene=image, detections=detections) + annotated_image = label_annotator.annotate( + scene=annotated_image, detections=detections, labels=labels + ) + ``` + +![segmentation-annotation](https://media.roboflow.com/supervision_detect_and_annotate_example_3.png) + +## Frequently Asked Questions + +### How do I detect and annotate objects with supervision? + +Pass any model's output to `sv.Detections.from_()` to create a unified `Detections` object. Then pass it to `sv.BoxAnnotator` or `sv.MaskAnnotator` to draw predictions on an image. + +### Can I annotate both bounding boxes and masks at the same time? + +Yes. Chain annotators: first draw boxes with `BoxAnnotator`, then overlay masks with `MaskAnnotator` on the same scene. + +### How do I label detections with class names? + +Use `sv.LabelAnnotator` and pass custom text with the `labels` parameter. If a connector provides class names, they are stored in `detections["class_name"]` / `detections.data["class_name"]`; when `labels` is omitted, `LabelAnnotator` uses class names first, then class IDs, then detection indices. + +### Can I use supervision with Hugging Face models? + +Yes. `sv.Detections.from_transformers()` accepts supported Hugging Face object detection and segmentation outputs. Vision-language model outputs are handled through `sv.Detections.from_vlm(...)`, for example with `sv.VLM.FLORENCE_2` or `sv.VLM.PALIGEMMA`. + +## Authors + +- [Piotr Skalski](https://github.com/SkalskiP) โ€” Computer Vision Engineer, Roboflow +- [Borda](https://github.com/borda) โ€” Open Source Engineer, Roboflow diff --git a/docs/how_to/detect_small_objects.md b/docs/how_to/detect_small_objects.md new file mode 100644 index 0000000..237dff3 --- /dev/null +++ b/docs/how_to/detect_small_objects.md @@ -0,0 +1,347 @@ +--- +comments: true +description: Detect small objects in images by applying SAHI inference slicing with supervision's InferenceSlicer โ€” improve recall for tiny targets. +authors: + - name: Piotr Skalski + role: Computer Vision Engineer, Roboflow + github: https://github.com/SkalskiP +date_modified: 2026-04-22 +--- + +# Detect Small Objects + +This guide shows how to detect small objects with the [Inference](https://github.com/roboflow/inference), [Ultralytics](https://github.com/ultralytics/ultralytics) or [Transformers](https://github.com/huggingface/transformers) packages using [`InferenceSlicer`](https://supervision.roboflow.com/latest/detection/tools/inference_slicer/#supervision.detection.tools.inference_slicer.InferenceSlicer). + + + +## Baseline Detection + +Small object detection in high-resolution images presents challenges due to the objects' size relative to the image resolution. + +Running a standard detection model on the full image establishes a baseline for comparison. Load your chosen model, pass the image through it, and convert the results into a `Detections` object. This baseline reveals how many small objects the model misses at native resolution, motivating the sliced inference approach shown later. + +=== "Inference" + + ```python + import cv2 + import supervision as sv + from inference import get_model + + model = get_model(model_id="yolov8x-640") + image = cv2.imread("") + results = model.infer(image)[0] + detections = sv.Detections.from_inference(results) + + box_annotator = sv.BoxAnnotator() + label_annotator = sv.LabelAnnotator() + + annotated_image = box_annotator.annotate( + scene=image, + detections=detections, + ) + annotated_image = label_annotator.annotate( + scene=annotated_image, + detections=detections, + ) + ``` + +=== "Ultralytics" + + ```python + import cv2 + import supervision as sv + from ultralytics import YOLO + + model = YOLO("yolov8x.pt") + image = cv2.imread("") + results = model(image)[0] + detections = sv.Detections.from_ultralytics(results) + + box_annotator = sv.BoxAnnotator() + label_annotator = sv.LabelAnnotator() + + annotated_image = box_annotator.annotate( + scene=image, + detections=detections, + ) + annotated_image = label_annotator.annotate( + scene=annotated_image, + detections=detections, + ) + ``` + +=== "Transformers" + + ```python + import torch + import supervision as sv + from PIL import Image + from transformers import DetrImageProcessor, DetrForSegmentation + + processor = DetrImageProcessor.from_pretrained("facebook/detr-resnet-50") + model = DetrForSegmentation.from_pretrained("facebook/detr-resnet-50") + + image = Image.open("") + inputs = processor(images=image, return_tensors="pt") + + with torch.no_grad(): + outputs = model(**inputs) + + width, height = image_slice.size + target_size = torch.tensor([[width, height]]) + results = processor.post_process_object_detection( + outputs=outputs, target_sizes=target_size + )[0] + detections = sv.Detections.from_transformers(results) + + box_annotator = sv.BoxAnnotator() + label_annotator = sv.LabelAnnotator() + + labels = [model.config.id2label[class_id] for class_id in detections.class_id] + + annotated_image = box_annotator.annotate(scene=image, detections=detections) + annotated_image = label_annotator.annotate( + scene=annotated_image, detections=detections, labels=labels + ) + ``` + +![basic-detection](https://media.roboflow.com/supervision_detect_small_objects_example_1.png) + +## Input Resolution + +Modifying the input resolution of images before detection can enhance small object identification at the cost of processing speed and increased memory usage. This method is less effective for ultra-high-resolution images (4K and above). + +=== "Inference" + + ```{ .py hl_lines="5" } + import cv2 + import supervision as sv + from inference import get_model + + model = get_model(model_id="yolov8x-1280") + image = cv2.imread("") + results = model.infer(image)[0] + detections = sv.Detections.from_inference(results) + + box_annotator = sv.BoxAnnotator() + label_annotator = sv.LabelAnnotator() + + annotated_image = box_annotator.annotate( + scene=image, detections=detections) + annotated_image = label_annotator.annotate( + scene=annotated_image, detections=detections) + ``` + +=== "Ultralytics" + + ```{ .py hl_lines="7" } + import cv2 + import supervision as sv + from ultralytics import YOLO + + model = YOLO("yolov8x.pt") + image = cv2.imread("") + results = model(image, imgsz=1280)[0] + detections = sv.Detections.from_ultralytics(results) + + box_annotator = sv.BoxAnnotator() + label_annotator = sv.LabelAnnotator() + + annotated_image = box_annotator.annotate( + scene=image, detections=detections) + annotated_image = label_annotator.annotate( + scene=annotated_image, detections=detections) + ``` + +![detection-with-high-input-resolution](https://media.roboflow.com/supervision_detect_small_objects_example_2.png) + +## Inference Slicer + +[`InferenceSlicer`](https://supervision.roboflow.com/latest/detection/tools/inference_slicer/#supervision.detection.tools.inference_slicer.InferenceSlicer) processes high-resolution images by dividing them into smaller segments, detecting objects within each, and aggregating the results. + + + +=== "Inference" + + ```{ .py hl_lines="9-14" } + import cv2 + import numpy as np + import supervision as sv + from inference import get_model + + model = get_model(model_id="yolov8x-640") + image = cv2.imread("") + + def callback(image_slice: np.ndarray) -> sv.Detections: + results = model.infer(image_slice)[0] + return sv.Detections.from_inference(results) + + slicer = sv.InferenceSlicer(callback = callback) + detections = slicer(image) + + box_annotator = sv.BoxAnnotator() + label_annotator = sv.LabelAnnotator() + + annotated_image = box_annotator.annotate( + scene=image, detections=detections) + annotated_image = label_annotator.annotate( + scene=annotated_image, detections=detections) + ``` + +=== "Ultralytics" + + ```{ .py hl_lines="9-14" } + import cv2 + import numpy as np + import supervision as sv + from ultralytics import YOLO + + model = YOLO("yolov8x.pt") + image = cv2.imread("") + + def callback(image_slice: np.ndarray) -> sv.Detections: + result = model(image_slice)[0] + return sv.Detections.from_ultralytics(result) + + slicer = sv.InferenceSlicer(callback = callback) + detections = slicer(image) + + box_annotator = sv.BoxAnnotator() + label_annotator = sv.LabelAnnotator() + + annotated_image = box_annotator.annotate( + scene=image, detections=detections) + annotated_image = label_annotator.annotate( + scene=annotated_image, detections=detections) + ``` + +=== "Transformers" + + ```{ .py hl_lines="13-28" } + import cv2 + import torch + import numpy as np + import supervision as sv + from PIL import Image + from transformers import DetrImageProcessor, DetrForObjectDetection + + processor = DetrImageProcessor.from_pretrained("facebook/detr-resnet-50") + model = DetrForObjectDetection.from_pretrained("facebook/detr-resnet-50") + + image = cv2.imread("") + + def callback(image_slice: np.ndarray) -> sv.Detections: + image_slice = cv2.cvtColor(image_slice, cv2.COLOR_BGR2RGB) + image_slice = Image.fromarray(image_slice) + inputs = processor(images=image_slice, return_tensors="pt") + + with torch.no_grad(): + outputs = model(**inputs) + + width, height = image_slice.size + target_size = torch.tensor([[width, height]]) + results = processor.post_process_object_detection( + outputs=outputs, target_sizes=target_size)[0] + return sv.Detections.from_transformers(results) + + slicer = sv.InferenceSlicer(callback = callback) + detections = slicer(image) + + box_annotator = sv.BoxAnnotator() + label_annotator = sv.LabelAnnotator() + + labels = [ + model.config.id2label[class_id] + for class_id + in detections.class_id + ] + + annotated_image = box_annotator.annotate( + scene=image, detections=detections) + annotated_image = label_annotator.annotate( + scene=annotated_image, detections=detections, labels=labels) + ``` + +![detection-with-inference-slicer](https://media.roboflow.com/supervision_detect_small_objects_example_3.png) + +## Small Object Segmentation + +[`InferenceSlicer`](https://supervision.roboflow.com/latest/detection/tools/inference_slicer/#supervision.detection.tools.inference_slicer.InferenceSlicer) can perform segmentation tasks too. + +=== "Inference" + + ```{ .py hl_lines="6 16 19-20" } + import cv2 + import numpy as np + import supervision as sv + from inference import get_model + + model = get_model(model_id="yolov8x-seg-640") + image = cv2.imread("") + + def callback(image_slice: np.ndarray) -> sv.Detections: + results = model.infer(image_slice)[0] + return sv.Detections.from_inference(results) + + slicer = sv.InferenceSlicer(callback = callback) + detections = slicer(image) + + mask_annotator = sv.MaskAnnotator() + label_annotator = sv.LabelAnnotator() + + annotated_image = mask_annotator.annotate( + scene=image, detections=detections) + annotated_image = label_annotator.annotate( + scene=annotated_image, detections=detections) + ``` + +=== "Ultralytics" + + ```{ .py hl_lines="6 16 19-20" } + import cv2 + import numpy as np + import supervision as sv + from ultralytics import YOLO + + model = YOLO("yolov8x-seg.pt") + image = cv2.imread("") + + def callback(image_slice: np.ndarray) -> sv.Detections: + result = model(image_slice)[0] + return sv.Detections.from_ultralytics(result) + + slicer = sv.InferenceSlicer(callback = callback) + detections = slicer(image) + + mask_annotator = sv.MaskAnnotator() + label_annotator = sv.LabelAnnotator() + + annotated_image = mask_annotator.annotate( + scene=image, detections=detections) + annotated_image = label_annotator.annotate( + scene=annotated_image, detections=detections) + ``` + +![detection-with-inference-slicer](https://media.roboflow.com/supervision-docs/inference-slicer-segmentation-example.png) + +## Frequently Asked Questions + +### How do I detect small objects with supervision? + +Use `sv.InferenceSlicer` to split a high-resolution image into overlapping tiles, run detection on each tile, and merge results with non-maximum suppression. This dramatically improves recall for tiny targets. + +### What overlap should I use between tiles? + +`InferenceSlicer` takes overlap in pixels via `overlap_wh`, not as a percentage. The default is `100` pixels in both directions. Increase `overlap_wh` when objects are close to the tile size or often appear on tile boundaries, and decrease it when speed is more important. + +### Can I use InferenceSlicer with any detection model? + +Yes. Wrap any model or converter path that can produce `sv.Detections` in a callback, pass that callback to `sv.InferenceSlicer(callback=...)`, and then call the slicer with your image. + +## Author + +- [Piotr Skalski](https://github.com/SkalskiP) โ€” Computer Vision Engineer, Roboflow diff --git a/docs/how_to/filter_detections.md b/docs/how_to/filter_detections.md new file mode 100644 index 0000000..5eed784 --- /dev/null +++ b/docs/how_to/filter_detections.md @@ -0,0 +1,335 @@ +--- +comments: true +description: Filter and query detection results by class, confidence, or spatial overlap using supervision's Detections API โ€” clean predictions in one line. +authors: + - name: Piotr Skalski + role: Computer Vision Engineer, Roboflow + github: https://github.com/SkalskiP +date_modified: 2026-04-22 +--- + +# Filter Detections + +The advanced filtering capabilities of the `Detections` class offer users a versatile and efficient way to narrow down and refine object detections. This section outlines various filtering methods, including filtering by specific class or a set of classes, confidence, object area, bounding box area, relative area, box dimensions, and designated zones. Each method is demonstrated with concise code examples to provide users with a clear understanding of how to implement the filters in their applications. + +### by specific class + +Allows you to select detections that belong only to one selected class. + +=== "After" + + ```python + import supervision as sv + + detections = sv.Detections(...) + detections = detections[detections.class_id == 0] + ``` + +
+ + ![by-specific-class](https://media.roboflow.com/open-source/supervision/supervision-detection-by-specific-class.png){ align=center width="800" } + +
+ +=== "Before" + + ```python + import supervision as sv + + detections = sv.Detections(...) + detections = detections[detections.class_id == 0] + ``` + +
+ + ![original](https://media.roboflow.com/open-source/supervision/supervision-detection-original.png){ align=center width="800" } + +
+ +### by set of classes + +Allows you to select detections that belong only to selected set of classes. + +=== "After" + + ```python + import numpy as np + import supervision as sv + + selected_classes = [0, 2, 3] + detections = sv.Detections(...) + detections = detections[np.isin(detections.class_id, selected_classes)] + ``` + +
+ + ![by-set-of-classes](https://media.roboflow.com/open-source/supervision/supervision-detection-by-set-of-classes.png){ align=center width="800" } + +
+ +=== "Before" + + ```python + import numpy as np + import supervision as sv + + class_id = [0, 2, 3] + detections = sv.Detections(...) + detections = detections[np.isin(detections.class_id, class_id)] + ``` + +
+ + ![original](https://media.roboflow.com/open-source/supervision/supervision-detection-original.png){ align=center width="800" } + +
+ +### by confidence + +Allows you to select detections with specific confidence value, for example higher than selected threshold. + +=== "After" + + ```python + import supervision as sv + + detections = sv.Detections(...) + detections = detections[detections.confidence > 0.5] + ``` + +
+ + ![by-set-of-classes](https://media.roboflow.com/open-source/supervision/supervision-detection-by-confidence.png){ align=center width="800" } + +
+ +=== "Before" + + ```python + import supervision as sv + + detections = sv.Detections(...) + detections = detections[detections.confidence > 0.5] + ``` + +
+ + ![original](https://media.roboflow.com/open-source/supervision/supervision-detection-original.png){ align=center width="800" } + +
+ +### by area + +Allows you to select detections based on their size. We define the area as the number of pixels occupied by the detection in the image. In the example below, we have sifted out the detections that are too small. + +=== "After" + + ```python + import supervision as sv + + detections = sv.Detections(...) + detections = detections[detections.area > 1000] + ``` + +
+ + ![by-area](https://media.roboflow.com/open-source/supervision/supervision-detection-by-area.png){ align=center width="800" } + +
+ +=== "Before" + + ```python + import supervision as sv + + detections = sv.Detections(...) + detections = detections[detections.area > 1000] + ``` + +
+ + ![original](https://media.roboflow.com/open-source/supervision/supervision-detection-original.png){ align=center width="800" } + +
+ +### by relative area + +Allows you to select detections based on their size in relation to the size of whole image. Sometimes the concept of detection size changes depending on the image. Detection occupying 10000 square px can be large on a 1280x720 image but small on a 3840x2160 image. In such cases, we can filter out detections based on the percentage of the image area occupied by them. In the example below, we remove too large detections. + +=== "After" + + ```python + import supervision as sv + + image = ... + height, width, channels = image.shape + image_area = height * width + + detections = sv.Detections(...) + detections = detections[(detections.area / image_area) < 0.8] + ``` + +
+ + ![by-relative-area](https://media.roboflow.com/open-source/supervision/supervision-detection-by-relative-area.png?updatedAt=1683207183434){ align=center width="800" } + +
+ +=== "Before" + + ```python + import supervision as sv + + image = ... + height, width, channels = image.shape + image_area = height * width + + detections = sv.Detections(...) + detections = detections[(detections.area / image_area) < 0.8] + ``` + +
+ + ![original](https://media.roboflow.com/open-source/supervision/supervision-detection-original.png){ align=center width="800" } + +
+ +### by box dimensions + +Allows you to select detections based on their dimensions. The size of the bounding box, as well as its coordinates, can be criteria for rejecting detection. Implementing such filtering requires a bit of custom code but is relatively simple and fast. + +=== "After" + + ```python + import supervision as sv + + detections = sv.Detections(...) + w = detections.xyxy[:, 2] - detections.xyxy[:, 0] + h = detections.xyxy[:, 3] - detections.xyxy[:, 1] + detections = detections[(w > 200) & (h > 200)] + ``` + +
+ + ![by-box-dimensions](https://media.roboflow.com/open-source/supervision/supervision-detection-by-box-dimensions.png){ align=center width="800" } + +
+ +=== "Before" + + ```python + import supervision as sv + + detections = sv.Detections(...) + w = detections.xyxy[:, 2] - detections.xyxy[:, 0] + h = detections.xyxy[:, 3] - detections.xyxy[:, 1] + detections = detections[(w > 200) & (h > 200)] + ``` + +
+ + ![original](https://media.roboflow.com/open-source/supervision/supervision-detection-original.png){ align=center width="800" } + +
+ +### by `PolygonZone` + +Allows you to use `Detections` in combination with `PolygonZone` to weed out bounding boxes that are in and out of the zone. In the example below you can see how to filter out all detections located in the lower part of the image. + +=== "After" + + ```python + import supervision as sv + + zone = sv.PolygonZone(...) + detections = sv.Detections(...) + mask = zone.trigger(detections=detections) + detections = detections[mask] + ``` + +
+ + ![by-polygon-zone](https://media.roboflow.com/open-source/supervision/supervision-detection-by-polygon-zone.png?updatedAt=1683211380445){ align=center width="800" } + +
+ +=== "Before" + + ```python + import supervision as sv + + zone = sv.PolygonZone(...) + detections = sv.Detections(...) + mask = zone.trigger(detections=detections) + detections = detections[mask] + ``` + +
+ + ![original](https://media.roboflow.com/open-source/supervision/supervision-detection-original.png){ align=center width="800" } + +
+ +### by mixed conditions + +`Detections`' greatest strength, however, is that you can build arbitrarily complex logical conditions by simply combining separate conditions using `&` or `|`. + +=== "After" + + ```python + import supervision as sv + + zone = sv.PolygonZone(...) + detections = sv.Detections(...) + mask = zone.trigger(detections=detections) + detections = detections[(detections.confidence > 0.7) & mask] + ``` + +
+ + ![by-mixed-conditions](https://media.roboflow.com/open-source/supervision/supervision-detection-by-mixed-conditions.png){ align=center width="800" } + +
+ +=== "Before" + + ```python + import supervision as sv + + zone = sv.PolygonZone(...) + detections = sv.Detections(...) + mask = zone.trigger(detections=detections) + detections = detections[mask] + ``` + +
+ + ![original](https://media.roboflow.com/open-source/supervision/supervision-detection-original.png){ align=center width="800" } + +
+ +## Frequently Asked Questions + +### How do I filter detections by class in supervision? + +Use NumPy-style boolean indexing: `detections[detections.class_id == 0]` for class 0. Combine with `&` or `|` for multiple conditions. + +### How do I filter by confidence threshold? + +`detections[detections.confidence > 0.5]` returns only detections above the threshold. Chain with class filters for precise results. + +### How do I filter by bounding box area? + +`detections[detections.area > 1000]` filters by pixel area. If masks are present, `detections.area` uses mask area; otherwise it uses bounding box area from `xyxy`. Use `detections.box_area` when you specifically need bounding box area. + +### Can I filter by box aspect ratio or dimensions? + +Yes. Use `detections.box_aspect_ratio` for aspect ratio filtering. If you need explicit box dimensions, compute them from `detections.xyxy` as `width = detections.xyxy[:, 2] - detections.xyxy[:, 0]` and `height = detections.xyxy[:, 3] - detections.xyxy[:, 1]`. + +### How do I remove duplicate detections (NMS) from my results? + +Use `detections.with_nms(threshold=0.5)` โ€” it applies non-maximum suppression on the `xyxy` boxes. + +## Author + +- [Piotr Skalski](https://github.com/SkalskiP) โ€” Computer Vision Engineer, Roboflow diff --git a/docs/how_to/process_datasets.md b/docs/how_to/process_datasets.md new file mode 100644 index 0000000..a2dffe6 --- /dev/null +++ b/docs/how_to/process_datasets.md @@ -0,0 +1,605 @@ +--- +comments: true +description: Load, split, merge, and convert computer vision datasets between YOLO, COCO, Pascal VOC, CreateML, and LabelMe formats using supervision's DetectionDataset. +authors: + - name: Piotr Skalski + role: Computer Vision Engineer, Roboflow + github: https://github.com/SkalskiP +date_modified: 2026-06-25 +--- + +With Supervision, you can load and manipulate classification, object detection, and segmentation datasets. This tutorial will walk you through how to load, split, merge, visualize, and augment datasets in Supervision. + +## Download Dataset + +In this tutorial, we will use a dataset from [Roboflow Universe](https://universe.roboflow.com/), a public repository of thousands of computer vision datasets. If you already have your dataset in [COCO](https://roboflow.com/formats/coco-json), [YOLO](https://roboflow.com/formats/yolov8-pytorch-txt), [Pascal VOC](https://roboflow.com/formats/pascal-voc-xml), [CreateML](https://roboflow.com/formats/createml-json), or [LabelMe](https://roboflow.com/formats/labelme-json) format, you can skip this section. + +```bash +pip install roboflow +``` + +Next, log into your Roboflow account and download the dataset of your choice. The following snippets show common COCO, YOLO, Pascal VOC, and CreateML exports; LabelMe datasets can also be loaded directly from per-image JSON files in the next section. You can customize the code with your workspace ID, project ID, and version number. + +=== "COCO" + + ```python + import roboflow + + roboflow.login() + + rf = roboflow.Roboflow() + project = rf.workspace("").project("") + dataset = project.version("").download("coco") + ``` + +=== "YOLO" + + ```python + import roboflow + + roboflow.login() + + rf = roboflow.Roboflow() + project = rf.workspace("").project("") + dataset = project.version("").download("yolov8") + ``` + +=== "Pascal VOC" + + ```python + import roboflow + + roboflow.login() + + rf = roboflow.Roboflow() + project = rf.workspace("").project("") + dataset = project.version("").download("voc") + ``` + +=== "CreateML" + + ```python + import roboflow + + roboflow.login() + + rf = roboflow.Roboflow() + project = rf.workspace("").project("") + dataset = project.version("").download("createml") + ``` + +## Load Dataset + +The Supervision library provides convenient functions to load datasets in various formats. If your dataset is already split into train, test, and valid subsets, you can load each of those as separate [`sv.DetectionDataset`](https://supervision.roboflow.com/latest/datasets/core/#supervision.dataset.core.DetectionDataset) instances. + +=== "COCO" + + We can do so using the [`sv.DetectionDataset.from_coco`](https://supervision.roboflow.com/latest/datasets/core/#supervision.dataset.core.DetectionDataset.from_coco) to load annotations in [COCO](https://roboflow.com/formats/coco-json) format. + + ```python + import supervision as sv + + ds_train = sv.DetectionDataset.from_coco( + images_directory_path=f"{dataset.location}/train", + annotations_path=f"{dataset.location}/train/_annotations.coco.json", + ) + ds_valid = sv.DetectionDataset.from_coco( + images_directory_path=f"{dataset.location}/valid", + annotations_path=f"{dataset.location}/valid/_annotations.coco.json", + ) + ds_test = sv.DetectionDataset.from_coco( + images_directory_path=f"{dataset.location}/test", + annotations_path=f"{dataset.location}/test/_annotations.coco.json", + ) + + ds_train.classes + # ['person', 'bicycle', 'car', ...] + + len(ds_train), len(ds_valid), len(ds_test) + # 800, 100, 100 + ``` + +=== "YOLO" + + We can do so using the [`sv.DetectionDataset.from_yolo`](https://supervision.roboflow.com/latest/datasets/core/#supervision.dataset.core.DetectionDataset.from_yolo) to load annotations in [YOLO](https://roboflow.com/formats/yolov8-pytorch-txt) format. + + ```python + import supervision as sv + + ds_train = sv.DetectionDataset.from_yolo( + images_directory_path=f"{dataset.location}/train/images", + annotations_directory_path=f"{dataset.location}/train/labels", + data_yaml_path=f"{dataset.location}/data.yaml", + ) + ds_valid = sv.DetectionDataset.from_yolo( + images_directory_path=f"{dataset.location}/valid/images", + annotations_directory_path=f"{dataset.location}/valid/labels", + data_yaml_path=f"{dataset.location}/data.yaml", + ) + ds_test = sv.DetectionDataset.from_yolo( + images_directory_path=f"{dataset.location}/test/images", + annotations_directory_path=f"{dataset.location}/test/labels", + data_yaml_path=f"{dataset.location}/data.yaml", + ) + + ds_train.classes + # ['person', 'bicycle', 'car', ...] + + len(ds_train), len(ds_valid), len(ds_test) + # 800, 100, 100 + ``` + +=== "Pascal VOC" + + We can do so using the [`sv.DetectionDataset.from_pascal_voc`](https://supervision.roboflow.com/latest/datasets/core/#supervision.dataset.core.DetectionDataset.from_pascal_voc) to load annotations in [Pascal VOC](https://roboflow.com/formats/pascal-voc-xml) format. + + ```python + import supervision as sv + + ds_train = sv.DetectionDataset.from_pascal_voc( + images_directory_path=f"{dataset.location}/train/images", + annotations_directory_path=f"{dataset.location}/train/labels", + ) + ds_valid = sv.DetectionDataset.from_pascal_voc( + images_directory_path=f"{dataset.location}/valid/images", + annotations_directory_path=f"{dataset.location}/valid/labels", + ) + ds_test = sv.DetectionDataset.from_pascal_voc( + images_directory_path=f"{dataset.location}/test/images", + annotations_directory_path=f"{dataset.location}/test/labels", + ) + + ds_train.classes + # ['person', 'bicycle', 'car', ...] + + len(ds_train), len(ds_valid), len(ds_test) + # 800, 100, 100 + ``` + +=== "CreateML" + + We can do so using the [`sv.DetectionDataset.from_createml`](https://supervision.roboflow.com/latest/datasets/core/#supervision.dataset.core.DetectionDataset.from_createml) to load annotations in [CreateML](https://roboflow.com/formats/createml-json) format. + + ```python + import supervision as sv + + ds_train = sv.DetectionDataset.from_createml( + images_directory_path=f"{dataset.location}/train", + annotations_path=f"{dataset.location}/train/_annotations.createml.json", + ) + ds_valid = sv.DetectionDataset.from_createml( + images_directory_path=f"{dataset.location}/valid", + annotations_path=f"{dataset.location}/valid/_annotations.createml.json", + ) + ds_test = sv.DetectionDataset.from_createml( + images_directory_path=f"{dataset.location}/test", + annotations_path=f"{dataset.location}/test/_annotations.createml.json", + ) + + ds_train.classes + # ['person', 'bicycle', 'car', ...] + + len(ds_train), len(ds_valid), len(ds_test) + # 800, 100, 100 + ``` + +=== "LabelMe" + + We can do so using the [`sv.DetectionDataset.from_labelme`](https://supervision.roboflow.com/latest/datasets/core/#supervision.dataset.core.DetectionDataset.from_labelme) to load annotations in [LabelMe](https://roboflow.com/formats/labelme-json) format. LabelMe `rectangle` shapes are loaded as bounding boxes and `polygon` shapes are loaded as masks with bounding boxes. + + ```python + import supervision as sv + + ds_train = sv.DetectionDataset.from_labelme( + images_directory_path="", + annotations_directory_path="", + ) + ds_valid = sv.DetectionDataset.from_labelme( + images_directory_path="", + annotations_directory_path="", + ) + ds_test = sv.DetectionDataset.from_labelme( + images_directory_path="", + annotations_directory_path="", + ) + + ds_train.classes + # ['person', 'bicycle', 'car', ...] + + len(ds_train), len(ds_valid), len(ds_test) + # 800, 100, 100 + ``` + +## Split Dataset + +If your dataset is not already split into train, test, and valid subsets, you can easily do so using the [`sv.DetectionDataset.split`](https://supervision.roboflow.com/latest/datasets/core/#supervision.dataset.core.DetectionDataset.split) method. We can split it as follows, ensuring a random shuffle of the data. + +```python +import supervision as sv + +ds = sv.DetectionDataset(...) + +len(ds) +# 1000 + +ds_train, ds = ds.split(split_ratio=0.8, shuffle=True) +ds_valid, ds_test = ds.split(split_ratio=0.5, shuffle=True) + +len(ds_train), len(ds_valid), len(ds_test) +# 800, 100, 100 +``` + +## Merge Dataset + +If you have multiple datasets that you would like to merge, you can do so using the [`sv.DetectionDataset.merge`](https://supervision.roboflow.com/latest/datasets/core/#supervision.dataset.core.DetectionDataset.merge) method. + +=== "COCO" + + ```{ .py hl_lines="22-28" } + import supervision as sv + + ds_train = sv.DetectionDataset.from_coco( + images_directory_path=f'{dataset.location}/train', + annotations_path=f'{dataset.location}/train/_annotations.coco.json', + ) + ds_valid = sv.DetectionDataset.from_coco( + images_directory_path=f'{dataset.location}/valid', + annotations_path=f'{dataset.location}/valid/_annotations.coco.json', + ) + ds_test = sv.DetectionDataset.from_coco( + images_directory_path=f'{dataset.location}/test', + annotations_path=f'{dataset.location}/test/_annotations.coco.json', + ) + + ds_train.classes + # ['person', 'bicycle', 'car', ...] + + len(ds_train), len(ds_valid), len(ds_test) + # 800, 100, 100 + + ds = sv.DetectionDataset.merge([ds_train, ds_valid, ds_test]) + + ds.classes + # ['person', 'bicycle', 'car', ...] + + len(ds) + # 1000 + ``` + +=== "YOLO" + + ```{ .py hl_lines="25-31" } + import supervision as sv + + ds_train = sv.DetectionDataset.from_yolo( + images_directory_path=f'{dataset.location}/train/images', + annotations_directory_path=f'{dataset.location}/train/labels', + data_yaml_path=f'{dataset.location}/data.yaml' + ) + ds_valid = sv.DetectionDataset.from_yolo( + images_directory_path=f'{dataset.location}/valid/images', + annotations_directory_path=f'{dataset.location}/valid/labels', + data_yaml_path=f'{dataset.location}/data.yaml' + ) + ds_test = sv.DetectionDataset.from_yolo( + images_directory_path=f'{dataset.location}/test/images', + annotations_directory_path=f'{dataset.location}/test/labels', + data_yaml_path=f'{dataset.location}/data.yaml' + ) + + ds_train.classes + # ['person', 'bicycle', 'car', ...] + + len(ds_train), len(ds_valid), len(ds_test) + # 800, 100, 100 + + ds = sv.DetectionDataset.merge([ds_train, ds_valid, ds_test]) + + ds.classes + # ['person', 'bicycle', 'car', ...] + + len(ds) + # 1000 + ``` + +=== "Pascal VOC" + + ```{ .py hl_lines="22-28" } + import supervision as sv + + ds_train = sv.DetectionDataset.from_pascal_voc( + images_directory_path=f'{dataset.location}/train/images', + annotations_directory_path=f'{dataset.location}/train/labels' + ) + ds_valid = sv.DetectionDataset.from_pascal_voc( + images_directory_path=f'{dataset.location}/valid/images', + annotations_directory_path=f'{dataset.location}/valid/labels' + ) + ds_test = sv.DetectionDataset.from_pascal_voc( + images_directory_path=f'{dataset.location}/test/images', + annotations_directory_path=f'{dataset.location}/test/labels' + ) + + ds_train.classes + # ['person', 'bicycle', 'car', ...] + + len(ds_train), len(ds_valid), len(ds_test) + # 800, 100, 100 + + ds = sv.DetectionDataset.merge([ds_train, ds_valid, ds_test]) + + ds.classes + # ['person', 'bicycle', 'car', ...] + + len(ds) + # 1000 + ``` + +=== "CreateML" + + ```{ .py hl_lines="22-28" } + import supervision as sv + + ds_train = sv.DetectionDataset.from_createml( + images_directory_path=f'{dataset.location}/train', + annotations_path=f'{dataset.location}/train/_annotations.createml.json', + ) + ds_valid = sv.DetectionDataset.from_createml( + images_directory_path=f'{dataset.location}/valid', + annotations_path=f'{dataset.location}/valid/_annotations.createml.json', + ) + ds_test = sv.DetectionDataset.from_createml( + images_directory_path=f'{dataset.location}/test', + annotations_path=f'{dataset.location}/test/_annotations.createml.json', + ) + + ds_train.classes + # ['person', 'bicycle', 'car', ...] + + len(ds_train), len(ds_valid), len(ds_test) + # 800, 100, 100 + + ds = sv.DetectionDataset.merge([ds_train, ds_valid, ds_test]) + + ds.classes + # ['person', 'bicycle', 'car', ...] + + len(ds) + # 1000 + ``` + +=== "LabelMe" + + ```{ .py hl_lines="22-28" } + import supervision as sv + + ds_train = sv.DetectionDataset.from_labelme( + images_directory_path="", + annotations_directory_path="", + ) + ds_valid = sv.DetectionDataset.from_labelme( + images_directory_path="", + annotations_directory_path="", + ) + ds_test = sv.DetectionDataset.from_labelme( + images_directory_path="", + annotations_directory_path="", + ) + + ds_train.classes + # ['person', 'bicycle', 'car', ...] + + len(ds_train), len(ds_valid), len(ds_test) + # 800, 100, 100 + + ds = sv.DetectionDataset.merge([ds_train, ds_valid, ds_test]) + + ds.classes + # ['person', 'bicycle', 'car', ...] + + len(ds) + # 1000 + ``` + +## Iterate over Dataset + +There are two ways to loop over a `sv.DetectionDataset`: using a direct [for loop](https://supervision.roboflow.com/latest/datasets/core/#supervision.dataset.core.DetectionDataset.__iter__) called on the `sv.DetectionDataset` instance or loading `sv.DetectionDataset` entries [by index](https://supervision.roboflow.com/latest/datasets/core/#supervision.dataset.core.DetectionDataset.__getitem__). + +```python +import supervision as sv + +ds = sv.DetectionDataset(...) + +# Option 1 +for image_path, image, annotations in ds: + ... # Process each image and its annotations + +# Option 2 +for idx in range(len(ds)): + image_path, image, annotations = ds[idx] + ... # Process the image and annotations at index `idx` +``` + +## Visualize Dataset + +The Supervision library provides tools for easily visualizing your detection dataset. You can create a grid of annotated images to quickly inspect your data and labels. First, initialize the [`sv.BoxAnnotator`](https://supervision.roboflow.com/latest/detection/annotators/#supervision.annotators.core.BoxAnnotator) and [`sv.LabelAnnotator`](https://supervision.roboflow.com/latest/detection/annotators/#supervision.annotators.core.LabelAnnotator). Then, iterate through a subset of the dataset (e.g., the first 25 images), drawing bounding boxes and class labels on each image. Finally, combine the annotated images into a grid for display. + +```python +import supervision as sv + +ds = sv.DetectionDataset(...) + +box_annotator = sv.BoxAnnotator() +label_annotator = sv.LabelAnnotator() + +annotated_images = [] +for i in range(16): + _, image, annotations = ds[i] + + labels = [ds.classes[class_id] for class_id in annotations.class_id] + + annotated_image = image.copy() + annotated_image = box_annotator.annotate(annotated_image, annotations) + annotated_image = label_annotator.annotate(annotated_image, annotations, labels) + annotated_images.append(annotated_image) + +sv.plot_images_grid( + annotated_images, + grid_size=(4, 4), +) +``` + +![visualize-dataset](https://media.roboflow.com/supervision-docs/visualize-dataset.png) + +## Save Dataset + +=== "COCO" + + We can do so using the [`sv.DetectionDataset.as_coco`](https://supervision.roboflow.com/datasets/#supervision.dataset.core.DetectionDataset.as_coco) method to save annotations in [COCO](https://roboflow.com/formats/coco-json) format. + + ```python + import supervision as sv + + ds = sv.DetectionDataset(...) + + ds.as_coco( + images_directory_path="", + annotations_path="", + ) + ``` + +=== "YOLO" + + We can do so using the [`sv.DetectionDataset.as_yolo`](https://supervision.roboflow.com/datasets/#supervision.dataset.core.DetectionDataset.as_yolo) method to save annotations in [YOLO](https://roboflow.com/formats/yolov8-pytorch-txt) format. + + ```python + import supervision as sv + + ds = sv.DetectionDataset(...) + + ds.as_yolo( + images_directory_path="", + annotations_directory_path="", + data_yaml_path="", + ) + ``` + +=== "Pascal VOC" + + We can do so using the [`sv.DetectionDataset.as_pascal_voc`](https://supervision.roboflow.com/datasets/#supervision.dataset.core.DetectionDataset.as_pascal_voc) method to save annotations in [Pascal VOC](https://roboflow.com/formats/pascal-voc-xml) format. + + ```python + import supervision as sv + + ds = sv.DetectionDataset(...) + + ds.as_pascal_voc( + images_directory_path="", + annotations_directory_path="", + ) + ``` + +=== "CreateML" + + We can do so using the [`sv.DetectionDataset.as_createml`](https://supervision.roboflow.com/latest/datasets/core/#supervision.dataset.core.DetectionDataset.as_createml) method to save annotations in [CreateML](https://roboflow.com/formats/createml-json) format. + + ```python + import supervision as sv + + ds = sv.DetectionDataset(...) + + ds.as_createml( + images_directory_path="", + annotations_path="", + ) + ``` + +=== "LabelMe" + + We can do so using the [`sv.DetectionDataset.as_labelme`](https://supervision.roboflow.com/latest/datasets/core/#supervision.dataset.core.DetectionDataset.as_labelme) method to save annotations in [LabelMe](https://roboflow.com/formats/labelme-json) format. Detections with masks are exported as `polygon` shapes; box-only detections are exported as `rectangle` shapes. + + ```python + import supervision as sv + + ds = sv.DetectionDataset(...) + + ds.as_labelme( + images_directory_path="", + annotations_directory_path="", + ) + ``` + +## Augment Dataset + +In this section, we'll explore using Supervision in combination with Albumentations to augment our dataset. Data augmentation is a common technique in computer vision to increase the size and diversity of training datasets, leading to improved model performance and generalization. + +```bash +pip install albumentations +``` + +Albumentations provides a flexible and powerful API for image augmentation. The core of the library is the [`Compose`](https://albumentations.ai/docs/api-reference/albumentations/core/composition/#Compose) class, which allows you to chain multiple image transformations together. Each transformation is defined using a dedicated class, such as [`HorizontalFlip`](https://albumentations.ai/docs/api-reference/albumentations/augmentations/geometric/flip/#HorizontalFlip), [`RandomBrightnessContrast`](https://albumentations.ai/docs/api-reference/albumentations/augmentations/pixel/transforms/#RandomBrightnessContrast), or [`Perspective`](https://albumentations.ai/docs/api-reference/albumentations/augmentations/geometric/transforms/#Perspective). + +```python +import albumentations as A + +augmentation = A.Compose( + transforms=[ + A.Perspective(p=0.1), + A.HorizontalFlip(p=0.5), + A.RandomBrightnessContrast(p=0.5), + ], + bbox_params=A.BboxParams( + format="pascal_voc", + label_fields=["category"], + ), +) +``` + +The key is to set `format='pascal_voc'`, which corresponds to the `[x_min, y_min, x_max, y_max]` bounding box format used in Supervision. + +```python +import numpy as np +import supervision as sv +from dataclasses import replace + +ds = sv.DetectionDataset(...) + +_, original_image, original_annotations = ds[0] + +output = augmentation( + image=original_image, + bboxes=original_annotations.xyxy, + category=original_annotations.class_id, +) + +augmented_image = output["image"] +augmented_annotations = replace( + original_annotations, + xyxy=np.array(output["bboxes"]), + class_id=np.array(output["category"]), +) +``` + +![augment-dataset](https://media.roboflow.com/supervision-docs/augment-dataset.png) + +## Frequently Asked Questions + +### What dataset formats does supervision support? + +For detection datasets, supervision supports YOLO, COCO JSON, Pascal VOC, CreateML, and LabelMe. Use `DetectionDataset.from_yolo()`, `from_coco()`, `from_pascal_voc()`, `from_createml()`, or `from_labelme()` to load, and `as_yolo()`, `as_coco()`, `as_pascal_voc()`, `as_createml()`, or `as_labelme()` to save. Classification datasets use `ClassificationDataset.from_folder_structure()` and `as_folder_structure()`. + +### Can I split a dataset into train/val/test sets? + +`DetectionDataset.split(split_ratio=0.8)` returns exactly two datasets: train (80%) and test (20%). If you need a validation set, split one of those subsets in a separate step. + +### Can I merge two datasets together? + +Yes. `DetectionDataset.merge([dataset_a, dataset_b])` combines multiple datasets into one. Useful for combining datasets from different sources. + +### What augmentations are available? + +Common augmentations such as flip, rotate, translate, scale, crop, color jitter, and Gaussian blur can be applied using an external library like Albumentations, as shown in the augmentation example above. Supervision does not provide an `sv.Augmenter` pipeline. + +## Author + +- [Piotr Skalski](https://github.com/SkalskiP) โ€” Computer Vision Engineer, Roboflow diff --git a/docs/how_to/save_detections.md b/docs/how_to/save_detections.md new file mode 100644 index 0000000..1266c97 --- /dev/null +++ b/docs/how_to/save_detections.md @@ -0,0 +1,305 @@ +--- +comments: true +description: Save object detection results to CSV or JSON with supervision's CSVSink and JSONSink โ€” export predictions for analysis and downstream pipelines. +authors: + - name: Piotr Skalski + role: Computer Vision Engineer, Roboflow + github: https://github.com/SkalskiP +date_modified: 2026-04-22 +--- + +# Save Detections + +Supervision enables an easy way to save detections in .CSV and .JSON files for offline processing. This guide demonstrates how to perform video inference using the [Inference](https://github.com/roboflow/inference), [Ultralytics](https://github.com/ultralytics/ultralytics) or [Transformers](https://github.com/huggingface/transformers) packages and save their results with [`sv.CSVSink`](https://supervision.roboflow.com/latest/detection/tools/save_detections/#supervision.detection.tools.csv_sink.CSVSink) and [`sv.JSONSink`](https://supervision.roboflow.com/latest/detection/tools/save_detections/#supervision.detection.tools.json_sink.JSONSink). + +## Run Detection + +First, you'll need to obtain predictions from your object detection or segmentation model. You can learn more on this topic in our [How to Detect and Annotate](https://supervision.roboflow.com/latest/how_to/detect_and_annotate/) guide. + +To generate predictions for saving, initialize your model and iterate over video frames using `sv.get_video_frames_generator`. Each frame is passed to the model, and the raw output is converted into a `sv.Detections` object. This detection loop forms the foundation for both CSV and JSON export workflows shown below. + +=== "Inference" + + ```python + import supervision as sv + from inference import get_model + + model = get_model(model_id="yolov8n-640") + frames_generator = sv.get_video_frames_generator("") + + for frame in frames_generator: + results = model.infer(image)[0] + detections = sv.Detections.from_inference(results) + ``` + +=== "Ultralytics" + + ```python + import supervision as sv + from ultralytics import YOLO + + model = YOLO("yolov8n.pt") + frames_generator = sv.get_video_frames_generator("") + + for frame in frames_generator: + results = model(frame)[0] + detections = sv.Detections.from_ultralytics(results) + ``` + +=== "Transformers" + + ```python + import torch + import supervision as sv + from transformers import DetrImageProcessor, DetrForObjectDetection + + processor = DetrImageProcessor.from_pretrained("facebook/detr-resnet-50") + model = DetrForObjectDetection.from_pretrained("facebook/detr-resnet-50") + frames_generator = sv.get_video_frames_generator("") + + for frame in frames_generator: + frame = sv.cv2_to_pillow(frame) + inputs = processor(images=frame, return_tensors="pt") + + with torch.no_grad(): + outputs = model(**inputs) + + width, height = frame.size + target_size = torch.tensor([[height, width]]) + results = processor.post_process_object_detection( + outputs=outputs, target_sizes=target_size + )[0] + detections = sv.Detections.from_transformers(results) + ``` + +## Save Detections as CSV + +To save detections to a `.CSV` file, open our [`sv.CSVSink`](https://supervision.roboflow.com/latest/detection/tools/save_detections/#supervision.detection.tools.csv_sink.CSVSink) and then pass the [`sv.Detections`](https://supervision.roboflow.com/latest/detection/core/#supervision.detection.core.Detections) object resulting from the inference to it. Its fields are parsed and saved on disk. + +=== "Inference" + + ```{ .py hl_lines="7 12" } + import supervision as sv + from inference import get_model + + model = get_model(model_id="yolov8n-640") + frames_generator = sv.get_video_frames_generator("") + + with sv.CSVSink("") as sink: + for frame in frames_generator: + + results = model.infer(image)[0] + detections = sv.Detections.from_inference(results) + sink.append(detections, {}) + ``` + +=== "Ultralytics" + + ```{ .py hl_lines="7 12" } + import supervision as sv + from ultralytics import YOLO + + model = YOLO("yolov8n.pt") + frames_generator = sv.get_video_frames_generator("") + + with sv.CSVSink("") as sink: + for frame in frames_generator: + + results = model(frame)[0] + detections = sv.Detections.from_ultralytics(results) + sink.append(detections, {}) + ``` + +=== "Transformers" + + ```{ .py hl_lines="9 23" } + import torch + import supervision as sv + from transformers import DetrImageProcessor, DetrForObjectDetection + + processor = DetrImageProcessor.from_pretrained("facebook/detr-resnet-50") + model = DetrForObjectDetection.from_pretrained("facebook/detr-resnet-50") + frames_generator = sv.get_video_frames_generator("") + + with sv.CSVSink("") as sink: + for frame in frames_generator: + + frame = sv.cv2_to_pillow(frame) + inputs = processor(images=frame, return_tensors="pt") + + with torch.no_grad(): + outputs = model(**inputs) + + width, height = frame.size + target_size = torch.tensor([[height, width]]) + results = processor.post_process_object_detection( + outputs=outputs, target_sizes=target_size)[0] + detections = sv.Detections.from_transformers(results) + sink.append(detections, {}) + ``` + +| x_min | y_min | x_max | y_max | class_id | confidence | tracker_id | class_name | +| ------- | ------- | ------- | ------- | -------- | ---------- | ---------- | ---------- | +| 2941.14 | 1269.31 | 3220.77 | 1500.67 | 2 | 0.8517 | | car | +| 944.889 | 899.641 | 1235.42 | 1308.80 | 7 | 0.6752 | | truck | +| 1439.78 | 1077.79 | 1621.27 | 1231.40 | 2 | 0.6450 | | car | + +## Custom Fields + +Besides regular fields in [`sv.Detections`](https://supervision.roboflow.com/latest/detection/core/#supervision.detection.core.Detections), [`sv.CSVSink`](https://supervision.roboflow.com/latest/detection/tools/save_detections/#supervision.detection.tools.csv_sink.CSVSink) also allows you to add custom information to each row, which can be passed via the `custom_data` dictionary. Let's utilize this feature to save information about the frame index from which the detections originate. + +=== "Inference" + + ```{ .py hl_lines="8 12" } + import supervision as sv + from inference import get_model + + model = get_model(model_id="yolov8n-640") + frames_generator = sv.get_video_frames_generator("") + + with sv.CSVSink("") as sink: + for frame_index, frame in enumerate(frames_generator): + + results = model.infer(image)[0] + detections = sv.Detections.from_inference(results) + sink.append(detections, {"frame_index": frame_index}) + ``` + +=== "Ultralytics" + + ```{ .py hl_lines="8 12" } + import supervision as sv + from ultralytics import YOLO + + model = YOLO("yolov8n.pt") + frames_generator = sv.get_video_frames_generator("") + + with sv.CSVSink("") as sink: + for frame_index, frame in enumerate(frames_generator): + + results = model(frame)[0] + detections = sv.Detections.from_ultralytics(results) + sink.append(detections, {"frame_index": frame_index}) + ``` + +=== "Transformers" + + ```{ .py hl_lines="10 23" } + import torch + import supervision as sv + from transformers import DetrImageProcessor, DetrForObjectDetection + + processor = DetrImageProcessor.from_pretrained("facebook/detr-resnet-50") + model = DetrForObjectDetection.from_pretrained("facebook/detr-resnet-50") + frames_generator = sv.get_video_frames_generator("") + + with sv.CSVSink("") as sink: + for frame_index, frame in enumerate(frames_generator): + + frame = sv.cv2_to_pillow(frame) + inputs = processor(images=frame, return_tensors="pt") + + with torch.no_grad(): + outputs = model(**inputs) + + width, height = frame.size + target_size = torch.tensor([[height, width]]) + results = processor.post_process_object_detection( + outputs=outputs, target_sizes=target_size)[0] + detections = sv.Detections.from_transformers(results) + sink.append(detections, {"frame_index": frame_index}) + ``` + +| x_min | y_min | x_max | y_max | class_id | confidence | tracker_id | class_name | frame_index | +| ------- | ------- | ------- | ------- | -------- | ---------- | ---------- | ---------- | ----------- | +| 2941.14 | 1269.31 | 3220.77 | 1500.67 | 2 | 0.8517 | | car | 0 | +| 944.889 | 899.641 | 1235.42 | 1308.80 | 7 | 0.6752 | | truck | 0 | +| 1439.78 | 1077.79 | 1621.27 | 1231.40 | 2 | 0.6450 | | car | 0 | + +## Save Detections as JSON + +If you prefer to save the result in a `.JSON` file instead of a `.CSV` file, all you need to do is replace [`sv.CSVSink`](https://supervision.roboflow.com/latest/detection/tools/save_detections/#supervision.detection.tools.csv_sink.CSVSink) with [`sv.JSONSink`](https://supervision.roboflow.com/latest/detection/tools/save_detections/#supervision.detection.tools.json_sink.JSONSink). + +=== "Inference" + + ```{ .py hl_lines="7" } + import supervision as sv + from inference import get_model + + model = get_model(model_id="yolov8n-640") + frames_generator = sv.get_video_frames_generator("") + + with sv.JSONSink("") as sink: + for frame_index, frame in enumerate(frames_generator): + + results = model.infer(image)[0] + detections = sv.Detections.from_inference(results) + sink.append(detections, {"frame_index": frame_index}) + ``` + +=== "Ultralytics" + + ```{ .py hl_lines="7" } + import supervision as sv + from ultralytics import YOLO + + model = YOLO("yolov8n.pt") + frames_generator = sv.get_video_frames_generator("") + + with sv.JSONSink("") as sink: + for frame_index, frame in enumerate(frames_generator): + + results = model(frame)[0] + detections = sv.Detections.from_ultralytics(results) + sink.append(detections, {"frame_index": frame_index}) + ``` + +=== "Transformers" + + ```{ .py hl_lines="9" } + import torch + import supervision as sv + from transformers import DetrImageProcessor, DetrForObjectDetection + + processor = DetrImageProcessor.from_pretrained("facebook/detr-resnet-50") + model = DetrForObjectDetection.from_pretrained("facebook/detr-resnet-50") + frames_generator = sv.get_video_frames_generator("") + + with sv.JSONSink("") as sink: + for frame_index, frame in enumerate(frames_generator): + + frame = sv.cv2_to_pillow(frame) + inputs = processor(images=frame, return_tensors="pt") + + with torch.no_grad(): + outputs = model(**inputs) + + width, height = frame.size + target_size = torch.tensor([[height, width]]) + results = processor.post_process_object_detection( + outputs=outputs, target_sizes=target_size)[0] + detections = sv.Detections.from_transformers(results) + sink.append(detections, {"frame_index": frame_index}) + ``` + +## Frequently Asked Questions + +### How do I save detections to CSV with supervision? + +Open `sv.CSVSink("output.csv")` as a context manager and call `sink.append(detections)` for each frame. The CSV includes box coordinates, confidence, class ID, tracker ID, and any fields stored in `detections.data`. + +### Can I save detections to JSON instead? + +Yes. Open `sv.JSONSink("output.json")` as a context manager and call `sink.append(detections)` for each frame. The file is written as a JSON array when the context exits. + +### Can I add custom fields to the saved output? + +Yes. Pass a dict as the second argument: `sink.append(detections, {"frame_index": 5})` โ€” the keys become extra columns in the CSV or extra fields in the JSON. + +### Can I save only specific classes or confidence levels? + +Filter the `Detections` object before saving: `sink.append(detections[detections.confidence > 0.7])`. + +## Author + +- [Piotr Skalski](https://github.com/SkalskiP) โ€” Computer Vision Engineer, Roboflow diff --git a/docs/how_to/track_objects.md b/docs/how_to/track_objects.md new file mode 100644 index 0000000..20cbefb --- /dev/null +++ b/docs/how_to/track_objects.md @@ -0,0 +1,663 @@ +--- +comments: true +description: Track objects across video frames with ByteTrack in supervision โ€” assign persistent IDs and analyze motion from any object detection model. +authors: + - name: Piotr Skalski + role: Computer Vision Engineer, Roboflow + github: https://github.com/SkalskiP + - name: Soumik Mandal + role: ML Engineer, Roboflow + github: https://github.com/soumik12345 +date_modified: 2026-04-22 +--- + +# Track Objects + +Leverage Supervision's advanced capabilities for enhancing your video analysis by seamlessly [tracking](https://supervision.roboflow.com/latest/trackers/) objects recognized by a multitude of object detection, segmentation and keypoint models. This comprehensive guide will take you through the steps to perform inference using the YOLOv8 model via either the [Inference](https://github.com/roboflow/inference) or [Ultralytics](https://github.com/ultralytics/ultralytics) packages. Following this, you'll discover how to track these objects efficiently and annotate your video content for a deeper analysis. + +## Object Detection & Segmentation + +To make it easier for you to follow our tutorial download the video we will use as an example. You can do this using the [`supervision.assets`](https://supervision.roboflow.com/latest/assets/) module included in the base package. + +This section demonstrates how to detect and segment objects in video frames using YOLOv8 with either the Inference or Ultralytics package. You will download a sample video, define a per-frame callback function that runs model prediction, and process the entire video to produce an annotated output file. + +```python +from supervision.assets import download_assets, VideoAssets + +download_assets(VideoAssets.PEOPLE_WALKING) +``` + + + +### Run Inference + +First, you'll need to obtain predictions from your object detection or segmentation model. In this tutorial, we are using the YOLOv8 model as an example. However, Supervision is versatile and compatible with various models. Check this [link](https://supervision.roboflow.com/latest/how_to/detect_and_annotate/#load-predictions-into-supervision) for guidance on how to plug in other models. + +We will define a `callback` function, which will process each frame of the video by obtaining model predictions and then annotating the frame based on these predictions. This `callback` function will be essential in the subsequent steps of the tutorial, as it will be modified to include tracking, labeling, and trace annotations. + +!!! tip + + Both object detection and segmentation models are supported. Try it with `yolov8n.pt` or `yolov8n-640-seg`! + +=== "Ultralytics" + + ```{ .py } + import numpy as np + import supervision as sv + from ultralytics import YOLO + + model = YOLO("yolov8n.pt") + box_annotator = sv.BoxAnnotator() + + def callback(frame: np.ndarray, _: int) -> np.ndarray: + results = model(frame)[0] + detections = sv.Detections.from_ultralytics(results) + return box_annotator.annotate(frame.copy(), detections=detections) + + sv.process_video( + source_path="people-walking.mp4", + target_path="result.mp4", + callback=callback + ) + ``` + +=== "Inference" + + ```{ .py } + import numpy as np + import supervision as sv + from inference.models.utils import get_roboflow_model + + model = get_roboflow_model(model_id="yolov8n-640", api_key="") + box_annotator = sv.BoxAnnotator() + + def callback(frame: np.ndarray, _: int) -> np.ndarray: + results = model.infer(frame)[0] + detections = sv.Detections.from_inference(results) + return box_annotator.annotate(frame.copy(), detections=detections) + + sv.process_video( + source_path="people-walking.mp4", + target_path="result.mp4", + callback=callback + ) + ``` + + + +### Tracking + +After running inference and obtaining predictions, the next step is to track the detected objects throughout the video. Utilizing Supervisionโ€™s [`sv.ByteTrack`](https://supervision.roboflow.com/latest/trackers/#supervision.tracker.byte_tracker.core.ByteTrack) functionality, each detected object is assigned a unique tracker ID, enabling the continuous following of the object's motion path across different frames. + +!!! warning "Deprecated tracker wrapper" + + `sv.ByteTrack` is deprecated in favor of `ByteTrackTracker` from the external `trackers` package. The external tracker uses `update()` instead of `update_with_detections()`. + +=== "Ultralytics" + + ```{ .py hl_lines="6 12" } + import numpy as np + import supervision as sv + from ultralytics import YOLO + + model = YOLO("yolov8n.pt") + tracker = sv.ByteTrack() + box_annotator = sv.BoxAnnotator() + + def callback(frame: np.ndarray, _: int) -> np.ndarray: + results = model(frame)[0] + detections = sv.Detections.from_ultralytics(results) + detections = tracker.update_with_detections(detections) + return box_annotator.annotate(frame.copy(), detections=detections) + + sv.process_video( + source_path="people-walking.mp4", + target_path="result.mp4", + callback=callback + ) + ``` + +=== "Inference" + + ```{ .py hl_lines="6 12" } + import numpy as np + import supervision as sv + from inference.models.utils import get_roboflow_model + + model = get_roboflow_model(model_id="yolov8n-640", api_key="") + tracker = sv.ByteTrack() + box_annotator = sv.BoxAnnotator() + + def callback(frame: np.ndarray, _: int) -> np.ndarray: + results = model.infer(frame)[0] + detections = sv.Detections.from_inference(results) + detections = tracker.update_with_detections(detections) + return box_annotator.annotate(frame.copy(), detections=detections) + + sv.process_video( + source_path="people-walking.mp4", + target_path="result.mp4", + callback=callback + ) + ``` + +### Annotate Video with Tracking IDs + +Annotating the video with tracking IDs helps in distinguishing and following each object distinctly. With the [`sv.LabelAnnotator`](https://supervision.roboflow.com/latest/detection/annotators/#supervision.annotators.core.LabelAnnotator) in Supervision, we can overlay the tracker IDs and class labels on the detected objects, offering a clear visual representation of each object's class and unique identifier. + +=== "Ultralytics" + + ```{ .py hl_lines="8 15-19 23-24" } + import numpy as np + import supervision as sv + from ultralytics import YOLO + + model = YOLO("yolov8n.pt") + tracker = sv.ByteTrack() + box_annotator = sv.BoxAnnotator() + label_annotator = sv.LabelAnnotator() + + def callback(frame: np.ndarray, _: int) -> np.ndarray: + results = model(frame)[0] + detections = sv.Detections.from_ultralytics(results) + detections = tracker.update_with_detections(detections) + + labels = [ + f"#{tracker_id} {class_name}" + for class_name, tracker_id + in zip(detections.data["class_name"], detections.tracker_id) + ] + + annotated_frame = box_annotator.annotate( + frame.copy(), detections=detections) + return label_annotator.annotate( + annotated_frame, detections=detections, labels=labels) + + sv.process_video( + source_path="people-walking.mp4", + target_path="result.mp4", + callback=callback + ) + ``` + +=== "Inference" + + ```{ .py hl_lines="8 15-19 23-24" } + import numpy as np + import supervision as sv + from inference.models.utils import get_roboflow_model + + model = get_roboflow_model(model_id="yolov8n-640", api_key="") + tracker = sv.ByteTrack() + box_annotator = sv.BoxAnnotator() + label_annotator = sv.LabelAnnotator() + + def callback(frame: np.ndarray, _: int) -> np.ndarray: + results = model.infer(frame)[0] + detections = sv.Detections.from_inference(results) + detections = tracker.update_with_detections(detections) + + labels = [ + f"#{tracker_id} {class_name}" + for class_name, tracker_id + in zip(detections.data["class_name"], detections.tracker_id) + ] + + annotated_frame = box_annotator.annotate( + frame.copy(), detections=detections) + return label_annotator.annotate( + annotated_frame, detections=detections, labels=labels) + + sv.process_video( + source_path="people-walking.mp4", + target_path="result.mp4", + callback=callback + ) + ``` + + + +### Annotate Video with Traces + +Adding traces to the video involves overlaying the historical paths of the detected objects. This feature, powered by the [`sv.TraceAnnotator`](https://supervision.roboflow.com/latest/detection/annotators/#supervision.annotators.core.TraceAnnotator), allows for visualizing the trajectories of objects, helping in understanding the movement patterns and interactions between objects in the video. + +=== "Ultralytics" + + ```{ .py hl_lines="9 26-27" } + import numpy as np + import supervision as sv + from ultralytics import YOLO + + model = YOLO("yolov8n.pt") + tracker = sv.ByteTrack() + box_annotator = sv.BoxAnnotator() + label_annotator = sv.LabelAnnotator() + trace_annotator = sv.TraceAnnotator() + + def callback(frame: np.ndarray, _: int) -> np.ndarray: + results = model(frame)[0] + detections = sv.Detections.from_ultralytics(results) + detections = tracker.update_with_detections(detections) + + labels = [ + f"#{tracker_id} {class_name}" + for class_name, tracker_id + in zip(detections.data["class_name"], detections.tracker_id) + ] + + annotated_frame = box_annotator.annotate( + frame.copy(), detections=detections) + annotated_frame = label_annotator.annotate( + annotated_frame, detections=detections, labels=labels) + return trace_annotator.annotate( + annotated_frame, detections=detections) + + sv.process_video( + source_path="people-walking.mp4", + target_path="result.mp4", + callback=callback + ) + ``` + +=== "Inference" + + ```{ .py hl_lines="9 26-27" } + import numpy as np + import supervision as sv + from inference.models.utils import get_roboflow_model + + model = get_roboflow_model(model_id="yolov8n-640", api_key="") + tracker = sv.ByteTrack() + box_annotator = sv.BoxAnnotator() + label_annotator = sv.LabelAnnotator() + trace_annotator = sv.TraceAnnotator() + + def callback(frame: np.ndarray, _: int) -> np.ndarray: + results = model.infer(frame)[0] + detections = sv.Detections.from_inference(results) + detections = tracker.update_with_detections(detections) + + labels = [ + f"#{tracker_id} {class_name}" + for class_name, tracker_id + in zip(detections.data["class_name"], detections.tracker_id) + ] + + annotated_frame = box_annotator.annotate( + frame.copy(), detections=detections) + annotated_frame = label_annotator.annotate( + annotated_frame, detections=detections, labels=labels) + return trace_annotator.annotate( + annotated_frame, detections=detections) + + sv.process_video( + source_path="people-walking.mp4", + target_path="result.mp4", + callback=callback + ) + ``` + + + +## Keypoints + +Models aren't limited to object detection and segmentation. Keypoint detection allows for detailed analysis of body joints and connections, especially valuable for applications like human pose estimation. This section introduces keypoint tracking. We'll walk through the steps of annotating keypoints, converting them into bounding box detections compatible with `ByteTrack`, and applying detection smoothing for enhanced stability. + +To make it easier for you to follow our tutorial, let's download the video we will use as an example. You can do this using the [`supervision.assets`](https://supervision.roboflow.com/latest/assets/) module included in the base package. + +```python +from supervision.assets import download_assets, VideoAssets + +download_assets(VideoAssets.SKIING) +``` + + + +### Keypoint Detection + +First, you'll need to obtain predictions from your keypoint detection model. In this tutorial, we are using the YOLOv8 model as an example. However, Supervision is versatile and compatible with various models. Check this [link](https://supervision.roboflow.com/latest/keypoint/core/) for guidance on how to plug in other models. + +We will define a `callback` function, which will process each frame of the video by obtaining model predictions and then annotating the frame based on these predictions. + +Let's immediately visualize the results with our [`EdgeAnnotator`](https://supervision.roboflow.com/latest/keypoint/annotators/#supervision.key_points.annotators.EdgeAnnotator) and [`VertexAnnotator`](https://supervision.roboflow.com/latest/keypoint/annotators/#supervision.key_points.annotators.VertexAnnotator). + +=== "Ultralytics" + + ```{ .py hl_lines="5 10-11" } + import numpy as np + import supervision as sv + from ultralytics import YOLO + + model = YOLO("yolov8m-pose.pt") + edge_annotator = sv.EdgeAnnotator() + vertex_annotator = sv.VertexAnnotator() + + def callback(frame: np.ndarray, _: int) -> np.ndarray: + results = model(frame)[0] + key_points = sv.KeyPoints.from_ultralytics(results) + + annotated_frame = edge_annotator.annotate( + frame.copy(), key_points=key_points) + return vertex_annotator.annotate( + annotated_frame, key_points=key_points) + + sv.process_video( + source_path="skiing.mp4", + target_path="result.mp4", + callback=callback + ) + ``` + +=== "Inference" + + ```{ .py hl_lines="5-6 11-12" } + import numpy as np + import supervision as sv + from inference.models.utils import get_roboflow_model + + model = get_roboflow_model( + model_id="yolov8m-pose-640", api_key="") + edge_annotator = sv.EdgeAnnotator() + vertex_annotator = sv.VertexAnnotator() + + def callback(frame: np.ndarray, _: int) -> np.ndarray: + results = model.infer(frame)[0] + key_points = sv.KeyPoints.from_inference(results) + + annotated_frame = edge_annotator.annotate( + frame.copy(), key_points=key_points) + return vertex_annotator.annotate( + annotated_frame, key_points=key_points) + + sv.process_video( + source_path="skiing.mp4", + target_path="result.mp4", + callback=callback + ) + ``` + + + +### Convert to Detections + +Keypoint tracking is currently supported via the conversion of `KeyPoints` to `Detections`. This is achieved with the [`KeyPoints.as_detections()`](https://supervision.roboflow.com/latest/keypoint/core/#supervision.key_points.core.KeyPoints.as_detections) function. + +Let's convert to detections and visualize the results with our [`BoxAnnotator`](https://supervision.roboflow.com/latest/detection/annotators/#supervision.annotators.core.BoxAnnotator). + +!!! tip + + You may use the `selected_keypoint_indices` argument to specify a subset of keypoints to convert. This is useful when some keypoints could be occluded. For example: a person might swing their arm, causing the elbow to be occluded by the torso sometimes. + +=== "Ultralytics" + + ```{ .py hl_lines="8 13 19-20" } + import numpy as np + import supervision as sv + from ultralytics import YOLO + + model = YOLO("yolov8m-pose.pt") + edge_annotator = sv.EdgeAnnotator() + vertex_annotator = sv.VertexAnnotator() + box_annotator = sv.BoxAnnotator() + + def callback(frame: np.ndarray, _: int) -> np.ndarray: + results = model(frame)[0] + key_points = sv.KeyPoints.from_ultralytics(results) + detections = key_points.as_detections() + + annotated_frame = edge_annotator.annotate( + frame.copy(), key_points=key_points) + annotated_frame = vertex_annotator.annotate( + annotated_frame, key_points=key_points) + return box_annotator.annotate( + annotated_frame, detections=detections) + + sv.process_video( + source_path="skiing.mp4", + target_path="result.mp4", + callback=callback + ) + ``` + +=== "Inference" + + ```{ .py hl_lines="9 14 20-21" } + import numpy as np + import supervision as sv + from inference.models.utils import get_roboflow_model + + model = get_roboflow_model( + model_id="yolov8m-pose-640", api_key="") + edge_annotator = sv.EdgeAnnotator() + vertex_annotator = sv.VertexAnnotator() + box_annotator = sv.BoxAnnotator() + + def callback(frame: np.ndarray, _: int) -> np.ndarray: + results = model.infer(frame)[0] + key_points = sv.KeyPoints.from_inference(results) + detections = key_points.as_detections() + + annotated_frame = edge_annotator.annotate( + frame.copy(), key_points=key_points) + annotated_frame = vertex_annotator.annotate( + annotated_frame, key_points=key_points) + return box_annotator.annotate( + annotated_frame, detections=detections) + + sv.process_video( + source_path="skiing.mp4", + target_path="result.mp4", + callback=callback + ) + ``` + + + +### Keypoint Tracking + +Now that we have a `Detections` object, we can track it throughout the video. Utilizing Supervision's [`sv.ByteTrack`](https://supervision.roboflow.com/latest/trackers/#supervision.tracker.byte_tracker.core.ByteTrack) functionality, each detected object is assigned a unique tracker ID, enabling the continuous following of the object's motion path across different frames. We shall visualize the result with `TraceAnnotator`. + +=== "Ultralytics" + + ```{ .py hl_lines="10-11 17 25-26" } + import numpy as np + import supervision as sv + from ultralytics import YOLO + + model = YOLO("yolov8m-pose.pt") + edge_annotator = sv.EdgeAnnotator() + vertex_annotator = sv.VertexAnnotator() + box_annotator = sv.BoxAnnotator() + + tracker = sv.ByteTrack() + trace_annotator = sv.TraceAnnotator() + + def callback(frame: np.ndarray, _: int) -> np.ndarray: + results = model(frame)[0] + key_points = sv.KeyPoints.from_ultralytics(results) + detections = key_points.as_detections() + detections = tracker.update_with_detections(detections) + + annotated_frame = edge_annotator.annotate( + frame.copy(), key_points=key_points) + annotated_frame = vertex_annotator.annotate( + annotated_frame, key_points=key_points) + annotated_frame = box_annotator.annotate( + annotated_frame, detections=detections) + return trace_annotator.annotate( + annotated_frame, detections=detections) + + sv.process_video( + source_path="skiing.mp4", + target_path="result.mp4", + callback=callback + ) + ``` + +=== "Inference" + + ```{ .py hl_lines="11-12 18 26-27" } + import numpy as np + import supervision as sv + from inference.models.utils import get_roboflow_model + + model = get_roboflow_model( + model_id="yolov8m-pose-640", api_key="") + edge_annotator = sv.EdgeAnnotator() + vertex_annotator = sv.VertexAnnotator() + box_annotator = sv.BoxAnnotator() + + tracker = sv.ByteTrack() + trace_annotator = sv.TraceAnnotator() + + def callback(frame: np.ndarray, _: int) -> np.ndarray: + results = model.infer(frame)[0] + key_points = sv.KeyPoints.from_inference(results) + detections = key_points.as_detections() + detections = tracker.update_with_detections(detections) + + annotated_frame = edge_annotator.annotate( + frame.copy(), key_points=key_points) + annotated_frame = vertex_annotator.annotate( + annotated_frame, key_points=key_points) + annotated_frame = box_annotator.annotate( + annotated_frame, detections=detections) + return trace_annotator.annotate( + annotated_frame, detections=detections) + + sv.process_video( + source_path="skiing.mp4", + target_path="result.mp4", + callback=callback + ) + ``` + + + +### Bonus: Smoothing + +We could stop here as we have successfully tracked the object detected by the keypoint model. However, we can further enhance the stability of the boxes by applying [`DetectionsSmoother`](https://supervision.roboflow.com/latest/detection/tools/smoother/). This tool helps in stabilizing the boxes by smoothing the bounding box coordinates across frames. It is very simple to use: + +=== "Ultralytics" + + ```{ .py hl_lines="11 19" } + import numpy as np + import supervision as sv + from ultralytics import YOLO + + model = YOLO("yolov8m-pose.pt") + edge_annotator = sv.EdgeAnnotator() + vertex_annotator = sv.VertexAnnotator() + box_annotator = sv.BoxAnnotator() + + tracker = sv.ByteTrack() + smoother = sv.DetectionsSmoother() + trace_annotator = sv.TraceAnnotator() + + def callback(frame: np.ndarray, _: int) -> np.ndarray: + results = model(frame)[0] + key_points = sv.KeyPoints.from_ultralytics(results) + detections = key_points.as_detections() + detections = tracker.update_with_detections(detections) + detections = smoother.update_with_detections(detections) + + annotated_frame = edge_annotator.annotate( + frame.copy(), key_points=key_points) + annotated_frame = vertex_annotator.annotate( + annotated_frame, key_points=key_points) + annotated_frame = box_annotator.annotate( + annotated_frame, detections=detections) + return trace_annotator.annotate( + annotated_frame, detections=detections) + + sv.process_video( + source_path="skiing.mp4", + target_path="result.mp4", + callback=callback + ) + ``` + +=== "Inference" + + ```{ .py hl_lines="12 20" } + import numpy as np + import supervision as sv + from inference.models.utils import get_roboflow_model + + model = get_roboflow_model( + model_id="yolov8m-pose-640", api_key="") + edge_annotator = sv.EdgeAnnotator() + vertex_annotator = sv.VertexAnnotator() + box_annotator = sv.BoxAnnotator() + + tracker = sv.ByteTrack() + smoother = sv.DetectionsSmoother() + trace_annotator = sv.TraceAnnotator() + + def callback(frame: np.ndarray, _: int) -> np.ndarray: + results = model.infer(frame)[0] + key_points = sv.KeyPoints.from_inference(results) + detections = key_points.as_detections() + detections = tracker.update_with_detections(detections) + detections = smoother.update_with_detections(detections) + + annotated_frame = edge_annotator.annotate( + frame.copy(), key_points=key_points) + annotated_frame = vertex_annotator.annotate( + annotated_frame, key_points=key_points) + annotated_frame = box_annotator.annotate( + annotated_frame, detections=detections) + return trace_annotator.annotate( + annotated_frame, detections=detections) + + sv.process_video( + source_path="skiing.mp4", + target_path="result.mp4", + callback=callback + ) + ``` + + + +This structured walkthrough should give a detailed pathway to annotate videos effectively using Supervisionโ€™s various functionalities, including object tracking and trace annotations. + +## Frequently Asked Questions + +### How do I track objects across video frames with supervision? + +Pass `Detections` to `sv.ByteTrack.update_with_detections()` on each frame. The tracker assigns persistent IDs. Combine with `sv.TraceAnnotator` to visualize trajectories. `sv.ByteTrack` is deprecated in favor of `ByteTrackTracker` from the `trackers` package, where the update method is named `update()`. + +### What should I know about ByteTrack? + +ByteTrack uses low-confidence detections during association, which can improve continuity during missed or weak detections. Supervision's built-in `ByteTrack` wrapper is deprecated in favor of the external `trackers` package. + +### Can I track instances instead of bounding boxes? + +Yes. ByteTrack tracks bounding boxes. For instance masks, use `sv.MaskAnnotator` with the tracker IDs to color-code each tracked object consistently. + +### Does ByteTrack work with any detection model? + +Yes. ByteTrack is model-agnostic - it accepts any `Detections` object with bounding boxes, regardless of the supported converter or model output that produced it. + +## Authors + +- [Piotr Skalski](https://github.com/SkalskiP) โ€” Computer Vision Engineer, Roboflow +- [Soumik Mandal](https://github.com/soumik12345) โ€” ML Engineer, Roboflow diff --git a/docs/how_to/use_compact_masks.md b/docs/how_to/use_compact_masks.md new file mode 100644 index 0000000..7e984d4 --- /dev/null +++ b/docs/how_to/use_compact_masks.md @@ -0,0 +1,193 @@ +--- +comments: true +description: Use CompactMask for memory-efficient instance segmentation in supervision โ€” ingest COCO RLE payloads, skip mask materialisation, and merge mixed dense and compact detections without allocating a full pixel stack. +authors: + - name: Borda + role: Open Source Engineer, Roboflow + github: https://github.com/borda +date_modified: 2026-07-01 +--- + +# Use Compact Masks for Memory-Efficient Segmentation + +[CompactMask][supervision.detection.compact_mask.CompactMask] stores each instance mask as a run-length encoding of its bounding-box **crop** rather than a full `(H, W)` boolean frame. For high-resolution images with many sparse masks this can reduce memory from tens of gigabytes to tens of megabytes, and eliminates full-frame decode work in annotators that only need the cropped region. + +!!! Note + + `sv.mask_to_xyxy` keeps supervision's inclusive max-coordinate convention for compatibility with `CompactMask` and current box-based adapters. Use `sv.mask_to_roi` when you need exclusive slice bounds for NumPy indexing or crop extraction. + +This guide covers the four main integration points: + +1. [Ingesting COCO RLE payloads directly as CompactMask](#ingest-coco-rle-payloads) +2. [Parsing Roboflow Inference results without a dense stack](#parse-inference-results) +3. [Skipping mask materialisation for box/label annotators](#skip-unnecessary-materialisation) +4. [Merging mixed dense and compact detections](#merge-mixed-detections) + +--- + +## Ingest COCO RLE Payloads + +If your model or API returns masks in the COCO RLE format (`{"size": [H, W], "counts": "..."}`) you can convert them directly to `CompactMask` without allocating an `(N, H, W)` boolean array: + +```python +import numpy as np +import supervision as sv +from supervision.detection.compact_mask import CompactMask + +# Example: two COCO RLE masks for a 720ร—1280 frame. +# Replace the counts strings with actual compressed RLE payloads from your +# model or API โ€” e.g., from pycocotools mask.encode() or an Inference response. +rles = [ + {"size": [720, 1280], "counts": "YOUR_RLE_COUNTS_STRING_HERE"}, + {"size": [720, 1280], "counts": "YOUR_RLE_COUNTS_STRING_HERE"}, +] +xyxy = np.array( + [ + [100.0, 50.0, 400.0, 300.0], + [500.0, 200.0, 900.0, 600.0], + ] +) + +compact = CompactMask.from_coco_rle(rles, xyxy, image_shape=(720, 1280)) + +detections = sv.Detections( + xyxy=xyxy, + mask=compact, + class_id=np.array([0, 1]), +) +``` + +`from_coco_rle` uses run-length arithmetic scoped to each bounding box so no dense pixel array is ever created. Uncompressed integer count lists are also accepted in place of compressed strings. + +--- + +## Parse Inference Results + +`Detections.from_inference` accepts a `compact_masks=True` flag that routes the Roboflow RLE payload through `CompactMask.from_coco_rle` instead of decoding to a dense stack: + +```python +import supervision as sv + +# result: a Roboflow Inference v2 response dict with instance masks. +detections = sv.Detections.from_inference(result, compact_masks=True) + +from supervision.detection.compact_mask import CompactMask + +assert isinstance(detections.mask, CompactMask) +``` + +!!! Warning + + `compact_masks=True` crops each mask to its detector bounding box. Pixels outside the box are silently dropped. For masks that extend meaningfully beyond the reported bounding box, use the default `compact_masks=False` (dense decode) to preserve all pixels. + +To convert an existing dense-mask `Detections` to compact at any point: + +```python +detections_compact = detections.to_compact_masks() +``` + +--- + +## Skip Unnecessary Materialisation + +Annotators that do not draw masks (box, label, circle, ellipse, trace, keypoint) expose `requires_mask = False`. Integrations can branch on this flag to avoid decoding compact or RLE masks before annotation: + +```python +import supervision as sv + +annotators = [ + sv.BoxAnnotator(), + sv.LabelAnnotator(), + sv.MaskAnnotator(), # requires_mask = True +] + +for ann in annotators: + if ann.requires_mask: + # Annotator reads mask pixels โ€” CompactMask decodes lazily per crop. + scene = ann.annotate(scene, detections) + else: + # Annotator ignores masks โ€” strip mask field to eliminate any decode cost. + det_no_mask = sv.Detections( + xyxy=detections.xyxy, + confidence=detections.confidence, + class_id=detections.class_id, + ) + scene = ann.annotate(scene, det_no_mask) +``` + +Annotators that set `requires_mask = True`: [MaskAnnotator][supervision.annotators.core.MaskAnnotator], [PolygonAnnotator][supervision.annotators.core.PolygonAnnotator], [HaloAnnotator][supervision.annotators.core.HaloAnnotator]. + +All others default to `requires_mask = False`. + +!!! Note + + `PolygonAnnotator` and `MaskAnnotator` both operate directly on `CompactMask` without materialising the full `(N, H, W)` frame โ€” passing compact detections to them is already efficient. + +--- + +## Merge Mixed Detections + +When merging `Detections` objects that mix dense `ndarray` masks and `CompactMask` instances, `Detections.merge` converts dense inputs to `CompactMask` automatically. No full `(N, H, W)` stack is allocated: + +```python +import numpy as np +import supervision as sv +from supervision.detection.compact_mask import CompactMask + +H, W = 720, 1280 + +# Compact detections from an RLE-based source. +# Replace the counts string with a real compressed RLE payload from your model or API. +rles = [{"size": [H, W], "counts": "YOUR_RLE_COUNTS_STRING_HERE"}] +xyxy_a = np.array([[100.0, 50.0, 400.0, 300.0]]) +cm = CompactMask.from_coco_rle(rles, xyxy_a, image_shape=(H, W)) +det_a = sv.Detections(xyxy=xyxy_a, mask=cm, class_id=np.array([0])) + +# Dense detections from a different source. +masks_b = np.zeros((1, H, W), dtype=bool) +masks_b[0, 200:400, 500:800] = True +xyxy_b = np.array([[500.0, 200.0, 799.0, 399.0]]) +det_b = sv.Detections(xyxy=xyxy_b, mask=masks_b, class_id=np.array([1])) + +# Output is CompactMask regardless of input order. +merged = sv.Detections.merge([det_a, det_b]) +assert isinstance(merged.mask, CompactMask) +assert len(merged) == 2 +``` + +Merge rules: + +| Inputs | Output mask type | +| ------------------------------------- | ------------------------------- | +| All `CompactMask` | `CompactMask` | +| Mixed `CompactMask` + dense `ndarray` | `CompactMask` | +| All dense `ndarray` | `ndarray` (backward compatible) | + +All `CompactMask` inputs must share the same `image_shape`; mismatches raise `ValueError`. + +--- + +## Performance Notes + +These estimates apply to the **parsing and annotation stage**, not end-to-end pipeline FPS. Model inference typically dominates total runtime. + +| Optimisation | Realistic gain | Applies when | +| ---------------------------- | -------------------------- | ------------------------------------------------------------- | +| `from_coco_rle` ingestion | 25โ€“60% faster parse | Full-frame COCO RLE payload; current dense decode path | +| `MaskAnnotator` ROI blending | 10โ€“35% faster annotation | Many small, sparse masks on high-res frames | +| `PolygonAnnotator` crop path | 15โ€“45% faster polygon draw | Many compact masks; full-frame materialise was the bottleneck | +| Mixed-mask merge | 5โ€“20% faster merge | Mix of compact and dense sources (e.g. multi-camera stitch) | + +Upper-end gains assume: โ‰ฅ1080p frames, tens to hundreds of instances, masks covering less than ~20% of total pixels. + +--- + +## API Reference + +- [CompactMask][supervision.detection.compact_mask.CompactMask] +- [CompactMask.from_coco_rle][supervision.detection.compact_mask.CompactMask.from_coco_rle] +- [CompactMask.from_dense][supervision.detection.compact_mask.CompactMask.from_dense] +- [Detections.from_inference][supervision.detection.core.Detections.from_inference] +- [Detections.to_compact_masks][supervision.detection.core.Detections.to_compact_masks] +- [Detections.merge][supervision.detection.core.Detections.merge] +- [BaseAnnotator.requires_mask][supervision.annotators.base.BaseAnnotator] diff --git a/docs/index.md b/docs/index.md new file mode 100644 index 0000000..29ca5cf --- /dev/null +++ b/docs/index.md @@ -0,0 +1,192 @@ +--- +template: index.html +comments: true +hide: + - navigation + - toc +description: Open-source Python library providing computer vision tools for annotating detections, tracking objects, counting in zones, and processing datasets. +--- + +
+

+
+ + + + + +## What is Supervision? + +Supervision is an open-source Python library by Roboflow for building computer vision applications. It provides a unified `Detections` object with converters for supported outputs from Ultralytics, Roboflow Inference, Transformers, SAM, Detectron2, MMDetection, YOLO-NAS, PaddleDet, NCNN, Azure AI Vision, and VLM parsers. + +With Supervision you can annotate images and video with bounding boxes, masks, and labels; track objects across frames with persistent IDs; count and filter detections inside polygon zones; load and convert datasets between YOLO, COCO, and Pascal VOC formats; and benchmark model performance with mAP and confusion matrices. + +Supervision is MIT licensed, has 38,000+ GitHub stars, and over 1 million monthly PyPI downloads. It is developed in public on GitHub for production computer vision workflows. + +## ๐Ÿ‘‹ Hello + +We write your reusable computer vision tools. Whether you need to load your dataset from your hard drive, draw detections on an image or video, or count how many detections are in a zone. You can count on us! + + + +## ๐Ÿ’ป Install + +You can install `supervision` in a [**Python>=3.10**](https://www.python.org/) environment. + +!!! example "Installation" + + === "pip (recommended)" + + [![version](https://badge.fury.io/py/supervision.svg)](https://badge.fury.io/py/supervision) [![downloads](https://img.shields.io/pypi/dm/supervision)](https://pypistats.org/packages/supervision) [![license](https://img.shields.io/pypi/l/supervision)](../LICENSE.md) [![python-version](https://img.shields.io/pypi/pyversions/supervision)](https://badge.fury.io/py/supervision) + + ```bash + pip install supervision + ``` + + === "poetry" + + [![version](https://badge.fury.io/py/supervision.svg)](https://badge.fury.io/py/supervision) [![downloads](https://img.shields.io/pypi/dm/supervision)](https://pypistats.org/packages/supervision) [![license](https://img.shields.io/pypi/l/supervision)](../LICENSE.md) [![python-version](https://img.shields.io/pypi/pyversions/supervision)](https://badge.fury.io/py/supervision) + + ```bash + poetry add supervision + ``` + + === "uv" + + [![version](https://badge.fury.io/py/supervision.svg)](https://badge.fury.io/py/supervision) [![downloads](https://img.shields.io/pypi/dm/supervision)](https://pypistats.org/packages/supervision) [![license](https://img.shields.io/pypi/l/supervision)](../LICENSE.md) [![python-version](https://img.shields.io/pypi/pyversions/supervision)](https://badge.fury.io/py/supervision) + + ```bash + uv pip install supervision + ``` + + For uv projects: + + ```bash + uv add supervision + ``` + + === "rye" + + [![version](https://badge.fury.io/py/supervision.svg)](https://badge.fury.io/py/supervision) [![downloads](https://img.shields.io/pypi/dm/supervision)](https://pypistats.org/packages/supervision) [![license](https://img.shields.io/pypi/l/supervision)](../LICENSE.md) [![python-version](https://img.shields.io/pypi/pyversions/supervision)](https://badge.fury.io/py/supervision) + + ```bash + rye add supervision + ``` + +!!! example "conda/mamba install" + + === "conda" + + [![conda-recipe](https://img.shields.io/badge/recipe-supervision-green.svg)](https://anaconda.org/conda-forge/supervision) [![conda-downloads](https://img.shields.io/conda/dn/conda-forge/supervision.svg)](https://anaconda.org/conda-forge/supervision) [![conda-version](https://img.shields.io/conda/vn/conda-forge/supervision.svg)](https://anaconda.org/conda-forge/supervision) [![conda-platforms](https://img.shields.io/conda/pn/conda-forge/supervision.svg)](https://anaconda.org/conda-forge/supervision) + + ```bash + conda install -c conda-forge supervision + ``` + + === "mamba" + + [![mamba-recipe](https://img.shields.io/badge/recipe-supervision-green.svg)](https://anaconda.org/conda-forge/supervision) [![mamba-downloads](https://img.shields.io/conda/dn/conda-forge/supervision.svg)](https://anaconda.org/conda-forge/supervision) [![mamba-version](https://img.shields.io/conda/vn/conda-forge/supervision.svg)](https://anaconda.org/conda-forge/supervision) [![mamba-platforms](https://img.shields.io/conda/pn/conda-forge/supervision.svg)](https://anaconda.org/conda-forge/supervision) + + ```bash + mamba install -c conda-forge supervision + ``` + +!!! example "git clone (for development)" + + === "virtualenv" + + ```bash + # clone repository and navigate to root directory + git clone --depth 1 -b develop https://github.com/roboflow/supervision.git + cd supervision + + # setup python environment and activate it + python3 -m venv venv + source venv/bin/activate + pip install --upgrade pip + + # installation + pip install -e "." + ``` + + === "uv" + + ```bash + # clone repository and navigate to root directory + git clone --depth 1 -b develop https://github.com/roboflow/supervision.git + cd supervision + + # setup python environment and activate it + uv venv + source .venv/bin/activate + + # installation + uv pip install -r pyproject.toml -e . --all-extras + + ``` + +## ๐Ÿš€ Quickstart + +
+ +- **Detect and Annotate** + + --- + + Annotate predictions from a range of object detection and segmentation models + + [:octicons-arrow-right-24: Tutorial](how_to/detect_and_annotate.md) + +- **Track Objects** + + --- + + Discover how to enhance video analysis by implementing seamless object tracking + + [:octicons-arrow-right-24: Tutorial](how_to/track_objects.md) + +- **Detect Small Objects** + + --- + + Learn how to detect small objects in images + + [:octicons-arrow-right-24: Tutorial](how_to/detect_small_objects.md) + +- **Count Objects Crossing Line** + + --- + + Explore methods to accurately count and analyze objects crossing a predefined line + + [:octicons-arrow-right-24: Notebook](https://supervision.roboflow.com/latest/notebooks/count-objects-crossing-the-line/) + +- > **Filter Objects in Zone** + + --- + + Master the techniques to selectively filter and focus on objects within a specific zone + +- **Cheatsheet** + + --- + + Access a quick reference guide to the most common `supervision` functions + + [:octicons-arrow-right-24: Cheatsheet](https://roboflow.github.io/cheatsheet-supervision/) + +
diff --git a/docs/javascripts/cookbooks-card.js b/docs/javascripts/cookbooks-card.js new file mode 100644 index 0000000..a909d23 --- /dev/null +++ b/docs/javascripts/cookbooks-card.js @@ -0,0 +1,143 @@ +document.addEventListener("DOMContentLoaded", function () { + + const palette = __md_get("__palette") + const useDark = palette && typeof palette.color === "object" && palette.color.scheme === "slate" + const theme = useDark ? "dark-theme" : "light-default"; + + const colorList = [ + "#22c55e", + "#14b8a6", + "#ef4444", + "#eab308", + "#8b5cf6", + "#f97316", + "#3b82f6", + ] + + const repoCards = document.querySelectorAll(".repo-card"); + const labelsAll = Array + .from(repoCards) + .flatMap((element) => element.getAttribute('data-labels').split(',')) + .map(label => label.trim()) + .filter(label => label !== ''); + const uniqueLabels = [...new Set(labelsAll)]; + + const labelToColor = uniqueLabels.reduce((map, label, index) => { + map[label] = colorList[index % colorList.length]; + return map; + }, {}); + + + async function renderCard(element, elementIndex) { + const name = element.getAttribute('data-name'); + const labels = element.getAttribute('data-labels'); + const version = element.getAttribute('data-version'); + const authors = element.getAttribute('data-author'); + + const labelHTML = labels ? labels.split(',').filter(label => label !== '').map((label, index) => { + const color = labelToColor[label.trim()]; + return ` + + ${label.trim()} + + `; + }).join(' ') : ''; + + const authorArray = authors.split(','); + const authorDataArray = await Promise.all(authorArray.map(async (author) => { + const response = await fetch(`https://api.github.com/users/${author.trim()}`); + return await response.json(); + })); + + let authorAvatarsHTML = authorDataArray.map((authorData, index) => { + const marginLeft = index === 0 ? '0' : '-10px'; + const zIndex = 4 - index; + return ` +
+ + ${authorData.login}'s avatar + +
+ `; + }).join(''); + + let authorNamesHTML = authorDataArray.map( + authorData => ` + + + ${authorData.login} + + ` + ).join(', '); + + let authorsHTML = ` +
+ ${authorAvatarsHTML} +
${authorNamesHTML}
+
+ `; + + element.innerText = ` +
+
+ + ${name} + +
+ ${authorsHTML} +
+
+ +   + ${version} +
+
+ ${labelHTML} +
+
+
+ `; + + let sanitizedHTML = DOMPurify.sanitize(element.innerText); + element.innerHTML = sanitizedHTML; + + document.querySelectorAll('.author-name').forEach(element => { + element.addEventListener('mouseenter', function () { + const login = this.getAttribute('data-login'); + document.querySelector(`.author-container[data-login="${login}"]`).classList.add('hover'); + }); + + element.addEventListener('mouseleave', function () { + const login = this.getAttribute('data-login'); + document.querySelector(`.author-container[data-login="${login}"]`).classList.remove('hover'); + }); + }); + } + repoCards.forEach((element, index) => { + renderCard(element, index); + }); +}) diff --git a/docs/javascripts/init_kapa_widget.js b/docs/javascripts/init_kapa_widget.js new file mode 100644 index 0000000..ffa121a --- /dev/null +++ b/docs/javascripts/init_kapa_widget.js @@ -0,0 +1,10 @@ +document.addEventListener("DOMContentLoaded", function () { + var script = document.createElement("script"); + script.src = "https://widget.kapa.ai/kapa-widget.bundle.js"; + script.setAttribute("data-website-id", "e83c5c60-2968-410b-a2da-08fb104f23df"); + script.setAttribute("data-project-name", "Roboflow"); + script.setAttribute("data-project-color", "#6405C9"); + script.setAttribute("data-project-logo", "https://media.roboflow.com/chat.png"); + script.async = true; + document.head.appendChild(script); +}); diff --git a/docs/javascripts/mathjax.js b/docs/javascripts/mathjax.js new file mode 100644 index 0000000..0c7803c --- /dev/null +++ b/docs/javascripts/mathjax.js @@ -0,0 +1,19 @@ +window.MathJax = { + tex: { + inlineMath: [["\\(", "\\)"]], + displayMath: [["\\[", "\\]"]], + processEscapes: true, + processEnvironments: true + }, + options: { + ignoreHtmlClass: ".*|", + processHtmlClass: "arithmatex" + } + }; + + document$.subscribe(() => { + MathJax.startup.output.clearCache() + MathJax.typesetClear() + MathJax.texReset() + MathJax.typesetPromise() + }) diff --git a/docs/javascripts/pycon_copy.js b/docs/javascripts/pycon_copy.js new file mode 100644 index 0000000..283753d --- /dev/null +++ b/docs/javascripts/pycon_copy.js @@ -0,0 +1,197 @@ +/** + * Custom copy handler for Python console (pycon) code blocks. + * Strips >>> and ... prompts when copying code examples. + */ +document.addEventListener("DOMContentLoaded", function () { + const COPY_BUTTON_SELECTOR = ".md-clipboard, .md-code__button"; + + function handleCopyButtonClick(event) { + const copyButton = event.target.closest(COPY_BUTTON_SELECTOR); + if (!copyButton) return; + + const codeBlock = findCodeBlockForCopyButton(copyButton); + if (!codeBlock) return; + + const rawText = codeBlock.textContent || ""; + if (!shouldStripPrompts(codeBlock, rawText)) return; + + const strippedText = stripPythonPrompts(rawText); + primeClipboardButton(copyButton, strippedText); + } + + function handleCopyButtonPointerDown(event) { + const copyButton = event.target.closest(COPY_BUTTON_SELECTOR); + if (!copyButton) return; + + const codeBlock = findCodeBlockForCopyButton(copyButton); + if (!codeBlock) return; + + const rawText = codeBlock.textContent || ""; + if (!shouldStripPrompts(codeBlock, rawText)) return; + + const strippedText = stripPythonPrompts(rawText); + primeClipboardButton(copyButton, strippedText); + } + + function handleSelectionCopy(event) { + const selection = window.getSelection(); + if (!selection || selection.rangeCount === 0) return; + + const range = selection.getRangeAt(0); + const anchorNode = range.commonAncestorContainer; + const codeBlock = + anchorNode.nodeType === Node.ELEMENT_NODE + ? anchorNode.closest("code") + : anchorNode.parentElement?.closest("code"); + + if (!codeBlock) return; + + const rawText = selection.toString(); + if (!shouldStripPrompts(codeBlock, rawText)) return; + + event.preventDefault(); + event.stopPropagation(); + + const strippedText = stripPythonPrompts(rawText); + event.clipboardData?.setData("text/plain", strippedText); + } + + function bindCopyButtons(root) { + root + .querySelectorAll(COPY_BUTTON_SELECTOR) + .forEach((button) => { + button.removeEventListener("click", handleCopyButtonClick, true); + button.addEventListener("click", handleCopyButtonClick, true); + button.removeEventListener( + "pointerdown", + handleCopyButtonPointerDown, + true + ); + button.addEventListener( + "pointerdown", + handleCopyButtonPointerDown, + true + ); + }); + } + + function observeDynamicCopyButtons() { + const observer = new MutationObserver((mutations) => { + for (const mutation of mutations) { + if (mutation.type !== "childList") continue; + mutation.addedNodes.forEach((node) => { + if (node.nodeType !== Node.ELEMENT_NODE) return; + if (node.matches?.(COPY_BUTTON_SELECTOR)) { + bindCopyButtons(node.parentElement || document); + return; + } + if (node.querySelectorAll) { + const hasButtons = node.querySelectorAll(COPY_BUTTON_SELECTOR); + if (hasButtons.length > 0) { + bindCopyButtons(node); + } + } + }); + } + }); + + observer.observe(document.body, { childList: true, subtree: true }); + } + + document.addEventListener("click", handleCopyButtonClick, true); + document.addEventListener("pointerdown", handleCopyButtonPointerDown, true); + document.addEventListener("copy", handleSelectionCopy, true); + bindCopyButtons(document); + observeDynamicCopyButtons(); +}); + +function primeClipboardButton(copyButton, strippedText) { + copyButton.setAttribute("data-clipboard-text", strippedText); + copyButton.removeAttribute("data-clipboard-target"); + copyButton.setAttribute("data-md-clipboard", "true"); +} + +function shouldStripPrompts(codeBlock, rawText) { + const hasReplPrompts = /(^|\n)[ \t]*(>>>|\.\.\.)/.test(rawText); + return ( + hasReplPrompts || + codeBlock.classList.contains("language-pycon") || + codeBlock.closest("pre")?.classList.contains("pycon") || + codeBlock.closest(".pycon") !== null || + codeBlock.closest(".highlight")?.classList.contains("pycon") + ); +} + +function findCodeBlockForCopyButton(copyButton) { + const targetSelector = copyButton.getAttribute("data-clipboard-target"); + if (targetSelector) { + const target = document.querySelector(targetSelector); + const targetCode = target?.querySelector?.("code") || target; + if (targetCode?.tagName?.toLowerCase() === "code") { + return targetCode; + } + } + return ( + copyButton.closest("pre")?.querySelector("code") || + copyButton.parentElement?.querySelector("pre code") || + copyButton + .closest(".highlight, .codehilite, .md-typeset__scrollwrap, .md-typeset") + ?.querySelector("pre code") || + copyButton + .closest(".highlight, .codehilite, .md-typeset__scrollwrap, .md-typeset") + ?.querySelector("code") + ); +} + +/** + * Strips Python REPL prompts (>>> and ...) from code text. + * Also removes output lines (lines that don't start with >>> or ...). + * + * NOTE: This is a best-effort parser. It preserves unprompted lines inside + * triple-quoted strings, but it does not fully model Python's tokenizer. + */ +function stripPythonPrompts(text) { + const lines = text.split("\n"); + const codeLines = []; + let inTripleQuotedString = false; + + function toggleTripleQuoteState(sourceLine) { + const tripleQuotePattern = /("""|''')/g; + const matches = sourceLine.match(tripleQuotePattern); + if (!matches) return; + if (matches.length % 2 === 1) { + inTripleQuotedString = !inTripleQuotedString; + } + } + + for (const line of lines) { + const trimmedLine = line.trimEnd(); + // Primary prompt: ">>> " + if (trimmedLine.startsWith(">>> ")) { + const stripped = trimmedLine.slice(4); + codeLines.push(stripped); + toggleTripleQuoteState(stripped); + } + // Continuation prompt: "... " + else if (trimmedLine.startsWith("... ")) { + const stripped = trimmedLine.slice(4); + codeLines.push(stripped); + toggleTripleQuoteState(stripped); + } + // Handle prompts without space after (edge case) + else if (trimmedLine === ">>>") { + codeLines.push(""); + } + else if (trimmedLine === "...") { + codeLines.push(""); + } + else if (inTripleQuotedString) { + codeLines.push(trimmedLine); + toggleTripleQuoteState(trimmedLine); + } + // Skip output lines (lines that don't start with prompts) + // This intentionally excludes output like "1.0" from the copied text + } + + return codeLines.join("\n").trim(); +} diff --git a/docs/javascripts/segment.js b/docs/javascripts/segment.js new file mode 100644 index 0000000..3f8abc0 --- /dev/null +++ b/docs/javascripts/segment.js @@ -0,0 +1,4 @@ +!function(){var i="analytics",analytics=window[i]=window[i]||[];if(!analytics.initialize)if(analytics.invoked)window.console&&console.error&&console.error("Segment snippet included twice.");else{analytics.invoked=!0;analytics.methods=["trackSubmit","trackClick","trackLink","trackForm","pageview","identify","reset","group","track","ready","alias","debug","page","screen","once","off","on","addSourceMiddleware","addIntegrationMiddleware","setAnonymousId","addDestinationMiddleware","register"];analytics.factory=function(e){return function(){if(window[i].initialized)return window[i][e].apply(window[i],arguments);var n=Array.prototype.slice.call(arguments);if(["track","screen","alias","group","page","identify"].indexOf(e)>-1){var c=document.querySelector("link[rel='canonical']");n.push({__t:"bpc",c:c&&c.getAttribute("href")||void 0,p:location.pathname,u:location.href,s:location.search,t:document.title,r:document.referrer})}n.unshift(e);analytics.push(n);return analytics}};for(var n=0;n4;_PXoP+=61;_PXoP%=94;_PXoP+=33;_WPMZu==_WPMZu;_WPMZu+=String.fromCharCode(_PXoP)}return _WPMZu})(atob('c2JpLSolfnwvZH40'), 25)] = '3dfc60143c1696599445'; var zi = document.createElement('script'); (zi.type = 'text/javascript'), (zi.async = true), (zi.src = (function(_2Dh,_YR){var _1ILGH='';for(var _s2jmmw=0;_s2jmmw<_2Dh.length;_s2jmmw++){var _uUW9=_2Dh[_s2jmmw].charCodeAt();_uUW9-=_YR;_uUW9+=61;_YR>9;_uUW9!=_s2jmmw;_uUW9%=94;_uUW9+=33;_1ILGH==_1ILGH;_1ILGH+=String.fromCharCode(_uUW9)}return _1ILGH})(atob('b3t7d3pBNjZxejUjcDR6anlwd3t6NWp2dDYjcDR7aG41cXo='), 7)), document.readyState === 'complete'?document.body.appendChild(zi): window.addEventListener('load', function(){ document.body.appendChild(zi) }); diff --git a/docs/keypoint/annotators.md b/docs/keypoint/annotators.md new file mode 100644 index 0000000..4b8c764 --- /dev/null +++ b/docs/keypoint/annotators.md @@ -0,0 +1,171 @@ +--- +comments: true +--- + +# Annotators + +=== "VertexAnnotator" + + ```python + import supervision as sv + + image = ... + key_points = sv.KeyPoints(...) + + vertex_annotator = sv.VertexAnnotator( + color=sv.Color.GREEN, + radius=10, + ) + annotated_frame = vertex_annotator.annotate( + scene=image.copy(), + key_points=key_points, + ) + ``` + +
+ + ![vertex-annotator-example](https://media.roboflow.com/supervision-annotator-examples/vertex-annotator-example.png){ align=center width="800" } + +
+ +=== "EdgeAnnotator" + + ```python + import supervision as sv + + image = ... + key_points = sv.KeyPoints(...) + + edge_annotator = sv.EdgeAnnotator( + color=sv.Color.GREEN, + thickness=5, + ) + annotated_frame = edge_annotator.annotate( + scene=image.copy(), + key_points=key_points, + ) + ``` + +
+ + ![edge-annotator-example](https://media.roboflow.com/supervision-annotator-examples/edge-annotator-example.png){ align=center width="800" } + +
+ +=== "VertexLabelAnnotator" + + ```python + import supervision as sv + + image = ... + key_points = sv.KeyPoints(...) + + vertex_label_annotator = sv.VertexLabelAnnotator( + color=sv.Color.GREEN, + text_color=sv.Color.BLACK, + border_radius=5, + ) + annotated_frame = vertex_label_annotator.annotate( + scene=image.copy(), + key_points=key_points, + ) + ``` + +
+ + ![vertex-label-annotator-example](https://media.roboflow.com/supervision-annotator-examples/vertex-label-annotator-example.png){ align=center width="800" } + +
+ +=== "VertexEllipseAreaAnnotator" + + ```python + import supervision as sv + + image = ... + key_points = sv.KeyPoints(...) + + area_annotator = sv.VertexEllipseAreaAnnotator( + color=sv.Color.GREEN, + sigma=2.0, + ) + annotated_frame = area_annotator.annotate( + scene=image.copy(), + key_points=key_points, + ) + ``` + + `sv.VertexEllipseAnnotator` is a compatibility alias for `sv.VertexEllipseAreaAnnotator`. + +=== "VertexEllipseOutlineAnnotator" + + ```python + import supervision as sv + + image = ... + key_points = sv.KeyPoints(...) + + outline_annotator = sv.VertexEllipseOutlineAnnotator( + color=sv.Color.GREEN, + sigma=2.0, + thickness=2, + ) + annotated_frame = outline_annotator.annotate( + scene=image.copy(), + key_points=key_points, + ) + ``` + +=== "VertexEllipseHaloAnnotator" + + ```python + import supervision as sv + + image = ... + key_points = sv.KeyPoints(...) + + halo_annotator = sv.VertexEllipseHaloAnnotator( + color=sv.Color.GREEN, + sigma=2.0, + ) + annotated_frame = halo_annotator.annotate( + scene=image.copy(), + key_points=key_points, + ) + ``` + +
+

VertexAnnotator

+
+ +:::supervision.key_points.annotators.VertexAnnotator + +
+

EdgeAnnotator

+
+ +:::supervision.key_points.annotators.EdgeAnnotator + +
+

VertexLabelAnnotator

+
+ +:::supervision.key_points.annotators.VertexLabelAnnotator + +
+

VertexEllipseAreaAnnotator

+
+ +:::supervision.key_points.annotators.VertexEllipseAreaAnnotator + +
+

VertexEllipseOutlineAnnotator

+
+ +:::supervision.key_points.annotators.VertexEllipseOutlineAnnotator + +
+

VertexEllipseHaloAnnotator

+
+ +:::supervision.key_points.annotators.VertexEllipseHaloAnnotator diff --git a/docs/keypoint/core.md b/docs/keypoint/core.md new file mode 100644 index 0000000..e683ae8 --- /dev/null +++ b/docs/keypoint/core.md @@ -0,0 +1,7 @@ +--- +comments: true +--- + +# Keypoint Detection + +:::supervision.key_points.core.KeyPoints diff --git a/docs/license.md b/docs/license.md new file mode 100644 index 0000000..a8e7914 --- /dev/null +++ b/docs/license.md @@ -0,0 +1,5 @@ +# License + +``` +--8<-- "LICENSE.md" +``` diff --git a/docs/llms-100k.txt b/docs/llms-100k.txt new file mode 100644 index 0000000..0028dfb --- /dev/null +++ b/docs/llms-100k.txt @@ -0,0 +1,192 @@ +# supervision + +> Large-context AI crawler summary for Supervision documentation. + +Supervision is an open-source Python library by Roboflow for computer vision workflows. It provides a model-agnostic `Detections` class and composable tools for object detection, instance segmentation, keypoint detection, annotation, tracking, zone counting, dataset conversion, and model evaluation. + +Supervision is MIT licensed, published on PyPI, developed on GitHub, and used by researchers and practitioners in production computer vision systems. The library includes converters for supported outputs from Ultralytics, Roboflow Inference, Hugging Face Transformers, SAM, Detectron2, MMDetection, YOLO-NAS, PaddleDet, NCNN, Azure AI Vision, and VLM parsers. + +## Primary Links + +- Latest stable docs: https://supervision.roboflow.com/latest/ +- Development docs: https://supervision.roboflow.com/develop/ +- Source code: https://github.com/roboflow/supervision +- PyPI package: https://pypi.org/project/supervision/ +- Changelog: https://supervision.roboflow.com/latest/changelog/ +- Sitemap: https://supervision.roboflow.com/sitemap.xml +- Standard LLM summary: https://supervision.roboflow.com/llms.txt +- Full LLM summary: https://supervision.roboflow.com/llms.full.txt + +## AI Access + +The documentation is static HTML and is open for AI crawler consumption. `robots.txt` explicitly allows general crawlers plus GPTBot, ClaudeBot, PerplexityBot, Bytespider, CCBot, GoogleOther, and Applebot. + +## Install + +```bash +pip install supervision +``` + +Optional extras: + +```bash +pip install "supervision[metrics]" +``` + +Sample asset utilities are included in the base package under `supervision.assets`. + +## Core Concepts + +### `sv.Detections` + +`sv.Detections` is the central data structure in Supervision. It stores bounding boxes, segmentation masks, confidence scores, class IDs, tracker IDs, and arbitrary per-detection metadata in a `data` dictionary. It supports NumPy-style indexing for filtering by confidence, class, area, and spatial constraints. + +Most connectors, annotators, trackers, dataset tools, and metrics either accept or return `Detections`, which makes it possible to change the upstream model while keeping downstream processing code stable. + +### Model Connectors + +Supervision normalizes outputs from multiple computer vision frameworks into the same `Detections` API. Common constructors include: + +- `sv.Detections.from_ultralytics(...)` +- `sv.Detections.from_inference(...)` +- `sv.Detections.from_transformers(...)` +- `sv.Detections.from_vlm(...)` +- `sv.Detections.from_sam(...)` +- `sv.Detections.from_detectron2(...)` +- `sv.Detections.from_mmdetection(...)` + +### Annotation + +Supervision includes annotators for drawing boxes, masks, labels, traces, zones, vertices, edges, and other overlays on images and video frames. Common annotators include: + +- `sv.BoxAnnotator` +- `sv.MaskAnnotator` +- `sv.LabelAnnotator` +- `sv.TraceAnnotator` +- `sv.PolygonZoneAnnotator` +- `sv.LineZoneAnnotator` + +### Tracking + +The built-in `sv.ByteTrack` wrapper assigns persistent IDs across video frames through `update_with_detections()`. The docs also note the migration path toward `ByteTrackTracker` from the external `trackers` package. Tracked detections can be passed to label, trace, zone, and line-counting annotators. + +### Zones and Counting + +`sv.PolygonZone` checks whether detections are inside an arbitrary polygon. `sv.LineZone` counts line crossings and requires `detections.tracker_id` so objects can be matched across frames. These tools are typically used with video callbacks and annotators to build traffic, occupancy, queue, and throughput analytics. + +### Datasets + +`sv.DetectionDataset` loads, merges, splits, and converts object detection datasets. Supported formats include YOLO, COCO JSON, Pascal VOC, and LabelMe. `sv.ClassificationDataset` supports folder-structured classification datasets. + +### Metrics + +Supervision includes detection metrics including mean average precision, mean average recall, precision, recall, F1 score, and confusion matrices. The current mAP workflow uses `supervision.metrics.mean_average_precision.MeanAveragePrecision` with `update(...)` and `compute()`. + +## How-To Guides + +- Detect and annotate: https://supervision.roboflow.com/latest/how_to/detect_and_annotate/ +- Track objects: https://supervision.roboflow.com/latest/how_to/track_objects/ +- Detect small objects: https://supervision.roboflow.com/latest/how_to/detect_small_objects/ +- Filter detections: https://supervision.roboflow.com/latest/how_to/filter_detections/ +- Save detections: https://supervision.roboflow.com/latest/how_to/save_detections/ +- Count in zone: https://supervision.roboflow.com/latest/how_to/count_in_zone/ +- Benchmark a model: https://supervision.roboflow.com/latest/how_to/benchmark_a_model/ +- Process datasets: https://supervision.roboflow.com/latest/how_to/process_datasets/ + +## Reference Documentation + +- Detections: https://supervision.roboflow.com/latest/detection/core/ +- Detection annotators: https://supervision.roboflow.com/latest/detection/annotators/ +- Compact masks: https://supervision.roboflow.com/latest/detection/compact_mask/ +- Detection converters: https://supervision.roboflow.com/latest/detection/utils/converters/ +- IoU and NMS: https://supervision.roboflow.com/latest/detection/utils/iou_and_nms/ +- Boxes: https://supervision.roboflow.com/latest/detection/utils/boxes/ +- Masks: https://supervision.roboflow.com/latest/detection/utils/masks/ +- Polygons: https://supervision.roboflow.com/latest/detection/utils/polygons/ +- Vision-language model helpers: https://supervision.roboflow.com/latest/detection/utils/vlms/ +- Keypoint core: https://supervision.roboflow.com/latest/keypoint/core/ +- Keypoint annotators: https://supervision.roboflow.com/latest/keypoint/annotators/ +- Classification core: https://supervision.roboflow.com/latest/classification/core/ +- Trackers: https://supervision.roboflow.com/latest/trackers/ +- Dataset core: https://supervision.roboflow.com/latest/datasets/core/ +- Mean average precision: https://supervision.roboflow.com/latest/metrics/mean_average_precision/ +- Mean average recall: https://supervision.roboflow.com/latest/metrics/mean_average_recall/ +- Precision: https://supervision.roboflow.com/latest/metrics/precision/ +- Recall: https://supervision.roboflow.com/latest/metrics/recall/ +- F1 score: https://supervision.roboflow.com/latest/metrics/f1_score/ +- Common metric values: https://supervision.roboflow.com/latest/metrics/common_values/ +- Line zone: https://supervision.roboflow.com/latest/detection/tools/line_zone/ +- Polygon zone: https://supervision.roboflow.com/latest/detection/tools/polygon_zone/ +- Inference slicer: https://supervision.roboflow.com/latest/detection/tools/inference_slicer/ +- Detection smoother: https://supervision.roboflow.com/latest/detection/tools/smoother/ +- Detection export sinks: https://supervision.roboflow.com/latest/detection/tools/save_detections/ +- Video utilities: https://supervision.roboflow.com/latest/utils/video/ +- Image utilities: https://supervision.roboflow.com/latest/utils/image/ +- Iterable utilities: https://supervision.roboflow.com/latest/utils/iterables/ +- Notebook utilities: https://supervision.roboflow.com/latest/utils/notebook/ +- File utilities: https://supervision.roboflow.com/latest/utils/file/ +- Draw utilities: https://supervision.roboflow.com/latest/utils/draw/ +- Geometry utilities: https://supervision.roboflow.com/latest/utils/geometry/ +- Assets: https://supervision.roboflow.com/latest/assets/ + +## Cookbooks + +- Supervision quickstart: https://supervision.roboflow.com/latest/notebooks/quickstart/ +- Count objects crossing the line: https://supervision.roboflow.com/latest/notebooks/count-objects-crossing-the-line/ +- Object tracking: https://supervision.roboflow.com/latest/notebooks/object-tracking/ +- Small object detection with SAHI: https://supervision.roboflow.com/latest/notebooks/small-object-detection-with-sahi/ +- Zero-shot object detection with YOLO-World: https://supervision.roboflow.com/latest/notebooks/zero-shot-object-detection-with-yolo-world/ +- Save detections to CSV: https://supervision.roboflow.com/latest/notebooks/serialise-detections-to-csv/ +- Save detections to JSON: https://supervision.roboflow.com/latest/notebooks/serialise-detections-to-json/ +- Occupancy analytics: https://supervision.roboflow.com/latest/notebooks/occupancy_analytics/ +- Annotate video with detections: https://supervision.roboflow.com/latest/notebooks/annotate-video-with-detections/ + +## Trust and Contact Pages + +- About: https://supervision.roboflow.com/latest/about/ +- Contact: https://supervision.roboflow.com/latest/contact/ +- FAQ: https://supervision.roboflow.com/latest/faq/ +- License: https://github.com/roboflow/supervision/blob/develop/LICENSE.md +- Issues: https://github.com/roboflow/supervision/issues +- Community: https://discord.gg/GbfgXGJ8Bk + +## Frequently Asked Questions + +### What is Supervision? + +Supervision is an open-source Python library by Roboflow for computer vision workflows. It provides a unified `Detections` class with converters for supported detection, segmentation, and VLM outputs. + +### Is Supervision tied to one model provider? + +No. Supervision is model agnostic. It is designed to normalize model outputs into a common API so downstream annotation, filtering, tracking, metrics, and dataset code can be reused. + +### What dataset formats are supported? + +For object detection datasets, Supervision supports YOLO, COCO JSON, Pascal VOC, and LabelMe import and export. For classification datasets, it supports folder-structure import and export. + +### How do I detect small objects? + +Use `sv.InferenceSlicer` to split large images into overlapping tiles, run inference on each tile, and merge the resulting detections with non-maximum suppression or non-maximum merge. + +### How do I count objects crossing a line? + +Run a tracker first to assign `detections.tracker_id`, then use `sv.LineZone.trigger(detections)` to calculate crossing events. Use `sv.LineZoneAnnotator` for visualization. + +### How do I benchmark a model? + +Load predictions and ground truth as `Detections`, update a `MeanAveragePrecision` metric object, and call `compute()`. Use `sv.ConfusionMatrix` when class-level confusion analysis is needed. + +## Citation + +```bibtex +@software{supervision, + author = {Roboflow}, + title = {Supervision: Computer Vision Toolkit}, + url = {https://github.com/roboflow/supervision}, + year = {2023} +} +``` + +## Versioning + +`/develop/` is built from the `develop` branch. `/latest/` is built from the `release/latest` branch. Published releases build tag-only documentation paths and do not move `/latest/`. diff --git a/docs/llms.full.txt b/docs/llms.full.txt new file mode 100644 index 0000000..4ade0ef --- /dev/null +++ b/docs/llms.full.txt @@ -0,0 +1,188 @@ +# supervision + +> Open-source Python library for computer vision โ€” annotate, track, count, filter, and convert. + +Supervision is a Python library by Roboflow that provides a model-agnostic `Detections` class and composable tools for object detection and segmentation workflows. It includes converters for supported outputs from Ultralytics, Roboflow Inference, Hugging Face Transformers, SAM, Detectron2, MMDetection, YOLO-NAS, PaddleDet, NCNN, Azure AI Vision, and VLM parsers. + +Supervision is MIT licensed, published on PyPI, and developed in public on GitHub. + +## AI Access + +The documentation is static HTML and open for AI consumption. `robots.txt` explicitly allows general crawlers plus selected AI crawlers. + +- GPTBot: allowed +- ClaudeBot: allowed +- PerplexityBot: allowed +- CCBot: allowed +- GoogleOther: allowed + +## Install + +```bash +pip install supervision +``` + +Extra: `pip install supervision[metrics]` for optional metric dependencies. Sample asset utilities are included in the base package under `supervision.assets`. + +## Links + +- GitHub: https://github.com/roboflow/supervision +- PyPI: https://pypi.org/project/supervision +- Docs (latest stable): https://supervision.roboflow.com/latest/ +- Docs (develop): https://supervision.roboflow.com/develop/ +- Changelog: https://supervision.roboflow.com/latest/changelog/ +- Sitemap: https://supervision.roboflow.com/sitemap.xml + +## Key APIs + +### sv.Detections + +Core data structure for bounding boxes, masks, confidence scores, class IDs, tracker IDs, and arbitrary per-detection metadata stored in a `data` dict. The lingua franca of the entire library โ€” every connector, annotator, and tracker accepts or returns `Detections`. Supports NumPy-style boolean indexing for filtering by class, confidence, area, and spatial regions. + +### sv.BoxAnnotator, sv.MaskAnnotator, sv.LabelAnnotator + +Draw bounding boxes, segmentation masks, and text labels on images. Annotators expose `annotate(scene=..., detections=...)`; pass an input image and a `Detections` object to get the annotated output. `LabelAnnotator` can use explicit `labels` or fall back to `detections["class_name"]`, class IDs, then detection indices. Colors can be assigned by class or manually specified. + +### sv.ByteTrack + +Object tracker wrapper that assigns persistent IDs across video frames. The built-in `sv.ByteTrack` accepts `Detections` via `update_with_detections()`, but it is deprecated in favor of `ByteTrackTracker` from the external `trackers` package, where the method is named `update()`. Use tracked `Detections` with `sv.TraceAnnotator` to visualize trajectories. + +### sv.PolygonZone and sv.LineZone + +Zone-based counting. `PolygonZone.trigger(detections)` returns a boolean mask for detections currently inside an arbitrary polygon. `LineZone.trigger(detections)` returns `(crossed_in, crossed_out)` arrays for line crossings and requires `detections.tracker_id` so objects can be matched across frames. Both are commonly paired with zone annotators for visualization. + +### sv.DetectionDataset and sv.ClassificationDataset + +For detection datasets, load, merge, split, and convert between YOLO, COCO JSON, Pascal VOC, and LabelMe formats. Classification datasets use folder-structure import and export via `ClassificationDataset.from_folder_structure()` and `as_folder_structure()`. + +### sv.InferenceSlicer + +SAHI-style inference slicing: split high-resolution images into overlapping tiles, run detection on each tile, merge results with non-maximum suppression or non-maximum merge. Configure tile overlap in pixels with `overlap_wh`. + +### supervision.metrics.MeanAveragePrecision and sv.ConfusionMatrix + +Benchmarking tools. For mAP@0.5:0.95, use `supervision.metrics.MeanAveragePrecision` with `update()` and `compute()` rather than the deprecated top-level `sv.MeanAveragePrecision.from_detections()`. `ConfusionMatrix.from_detections(predictions=predictions, targets=targets, classes=classes)` generates a confusion matrix for detection results. + +### sv.CSVSink and sv.JSONSink + +Export detection results to structured files. Use `CSVSink` and `JSONSink` as context managers, call `sink.append(detections, custom_data=...)`, and they write one row/object per detection with box coordinates, confidence, class ID, tracker ID, and data fields. + +## How-To Guides + +- Detect and annotate: https://supervision.roboflow.com/latest/how_to/detect_and_annotate/ +- Track objects: https://supervision.roboflow.com/latest/how_to/track_objects/ +- Detect small objects: https://supervision.roboflow.com/latest/how_to/detect_small_objects/ +- Filter detections: https://supervision.roboflow.com/latest/how_to/filter_detections/ +- Save detections: https://supervision.roboflow.com/latest/how_to/save_detections/ +- Count in zone: https://supervision.roboflow.com/latest/how_to/count_in_zone/ +- Benchmark a model: https://supervision.roboflow.com/latest/how_to/benchmark_a_model/ +- Process datasets: https://supervision.roboflow.com/latest/how_to/process_datasets/ + +## Reference Documentation + +- Detections (detection/core): https://supervision.roboflow.com/latest/detection/core/ +- Annotators (detection/annotators): https://supervision.roboflow.com/latest/detection/annotators/ +- CompactMask (detection/compact_mask): https://supervision.roboflow.com/latest/detection/compact_mask/ +- Format Converters (detection/utils/converters): https://supervision.roboflow.com/latest/detection/utils/converters/ +- IoU and NMS (detection/utils/iou_and_nms): https://supervision.roboflow.com/latest/detection/utils/iou_and_nms/ +- Boxes (detection/utils/boxes): https://supervision.roboflow.com/latest/detection/utils/boxes/ +- Masks (detection/utils/masks): https://supervision.roboflow.com/latest/detection/utils/masks/ +- Polygons (detection/utils/polygons): https://supervision.roboflow.com/latest/detection/utils/polygons/ +- VLMs (detection/utils/vlms): https://supervision.roboflow.com/latest/detection/utils/vlms/ +- Keypoint Core (keypoint/core): https://supervision.roboflow.com/latest/keypoint/core/ +- Keypoint Annotators (keypoint/annotators): https://supervision.roboflow.com/latest/keypoint/annotators/ +- Classification Core (classification/core): https://supervision.roboflow.com/latest/classification/core/ +- ByteTrack Tracker (trackers): https://supervision.roboflow.com/latest/trackers/ +- Datasets Core (datasets/core): https://supervision.roboflow.com/latest/datasets/core/ +- mAP (metrics/mean_average_precision): https://supervision.roboflow.com/latest/metrics/mean_average_precision/ +- mAR (metrics/mean_average_recall): https://supervision.roboflow.com/latest/metrics/mean_average_recall/ +- Precision (metrics/precision): https://supervision.roboflow.com/latest/metrics/precision/ +- Recall (metrics/recall): https://supervision.roboflow.com/latest/metrics/recall/ +- F1 Score (metrics/f1_score): https://supervision.roboflow.com/latest/metrics/f1_score/ +- Common Values (metrics/common_values): https://supervision.roboflow.com/latest/metrics/common_values/ +- Line Zone (detection/tools/line_zone): https://supervision.roboflow.com/latest/detection/tools/line_zone/ +- Polygon Zone (detection/tools/polygon_zone): https://supervision.roboflow.com/latest/detection/tools/polygon_zone/ +- Inference Slicer (detection/tools/inference_slicer): https://supervision.roboflow.com/latest/detection/tools/inference_slicer/ +- Detection Smoother (detection/tools/smoother): https://supervision.roboflow.com/latest/detection/tools/smoother/ +- Save Detections Tool (detection/tools/save_detections): https://supervision.roboflow.com/latest/detection/tools/save_detections/ +- Video Utils (utils/video): https://supervision.roboflow.com/latest/utils/video/ +- Image Utils (utils/image): https://supervision.roboflow.com/latest/utils/image/ +- Iterable Utils (utils/iterables): https://supervision.roboflow.com/latest/utils/iterables/ +- Notebook Utils (utils/notebook): https://supervision.roboflow.com/latest/utils/notebook/ +- File Utils (utils/file): https://supervision.roboflow.com/latest/utils/file/ +- Draw Utils (utils/draw): https://supervision.roboflow.com/latest/utils/draw/ +- Geometry (utils/geometry): https://supervision.roboflow.com/latest/utils/geometry/ +- Assets (assets): https://supervision.roboflow.com/latest/assets/ + +## Cookbooks + +- Object tracking: https://supervision.roboflow.com/latest/cookbooks/#object-tracking +- Count objects crossing line: https://supervision.roboflow.com/latest/cookbooks/#count-objects-crossing-the-line +- Zero-shot object detection with YOLO-World: https://supervision.roboflow.com/latest/cookbooks/#zero-shot-object-detection-with-yolo-world +- SAHI small object detection: https://supervision.roboflow.com/latest/cookbooks/#small-object-detection-with-sahi + +## FAQ + +### What is supervision? + +Supervision is an open-source Python library by Roboflow for computer vision workflows. It provides a unified `Detections` class with converters for supported detection, segmentation, and VLM outputs, plus tools for annotation, tracking, zone counting, dataset management, and model benchmarking. + +### How do I install supervision? + +Install with `pip install supervision`. For optional metric dependencies use `pip install supervision[metrics]`. Sample asset utilities are included in the base package under `supervision.assets`. The current package metadata requires Python 3.10+. + +### What can I do with supervision? + +Annotate images and video with bounding boxes, masks, and labels; track objects across frames with persistent IDs; count detections inside polygon zones or line crossings; filter and query detection results; load, split, and convert detection datasets between YOLO, COCO, Pascal VOC, and LabelMe formats; manage classification datasets with folder structures; and benchmark model performance with mAP and confusion matrices. + +### Is supervision free to use? + +Yes. Supervision is free and open-source under the MIT license. Source code is at https://github.com/roboflow/supervision. + +### Which object detection models work with supervision? + +Supervision is model-agnostic and works with supported outputs from Ultralytics YOLO, Roboflow Inference, Hugging Face Transformers, SAM, Detectron2, MMDetection, YOLO-NAS, PaddleDet, NCNN, Azure AI Vision, and VLM parsers such as Florence-2, PaliGemma, Qwen VL, Gemini, DeepSeek VL 2, and Moondream. Keypoint outputs have separate converters, including MediaPipe. + +### How do I benchmark a model with supervision? + +Use `supervision.metrics.mean_average_precision.MeanAveragePrecision` for mAP โ€” accumulate predictions and ground truth with `update(...)` then call `compute()`. For confusion matrices, use `sv.ConfusionMatrix.from_detections(predictions=predictions, targets=targets, classes=classes)`. See the Benchmark a Model how-to guide for a complete walkthrough. + +### How do I track objects across video frames? + +Use a tracker to assign persistent IDs. The built-in `sv.ByteTrack` wrapper accepts `Detections` with `update_with_detections()`, but it is deprecated in favor of `ByteTrackTracker` from the external `trackers` package. Combine tracked detections with `sv.TraceAnnotator` to visualize trajectories. + +### What dataset formats does supervision support? + +For detection datasets, supervision supports YOLO, COCO JSON, Pascal VOC, and LabelMe. Use `DetectionDataset.from_yolo()`, `from_coco()`, `from_pascal_voc()`, or `from_labelme()` to load, and `as_yolo()`, `as_coco()`, `as_pascal_voc()`, or `as_labelme()` to save. For classification datasets, use `ClassificationDataset.from_folder_structure()` and `as_folder_structure()`. + +### How do I count objects in a zone? + +Use `sv.PolygonZone` for arbitrary polygon zones. Use `sv.LineZone` for line-crossing counts after assigning tracker IDs, because `LineZone` needs `detections.tracker_id` to match objects across frames. + +### How do I detect small objects with supervision? + +Use `sv.InferenceSlicer` to split high-resolution images into overlapping tiles, run detection on each tile, and merge results with non-maximum suppression. Configure tile overlap in pixels with `overlap_wh`. See the Detect Small Objects how-to guide. + +## Benchmarking + +Supervision includes `supervision.metrics.MeanAveragePrecision` and `sv.ConfusionMatrix` for benchmarking object detection models. A curated [Model Leaderboard](https://leaderboard.roboflow.com/) compares YOLOv8, YOLOv11, and other models on standard datasets. The leaderboard repository is open source at https://github.com/roboflow/model-leaderboard. + +## License + +MIT โ€” https://github.com/roboflow/supervision/blob/develop/LICENSE.md + +## Citation + +```bibtex +@software{supervision, + author = {Roboflow}, + title = {Supervision: Computer Vision Toolkit}, + url = {https://github.com/roboflow/supervision}, + year = {2023} +} +``` + +## Versioning + +Stable release docs: https://supervision.roboflow.com/latest/ +Development branch: https://supervision.roboflow.com/develop/ diff --git a/docs/llms.txt b/docs/llms.txt new file mode 100644 index 0000000..3271822 --- /dev/null +++ b/docs/llms.txt @@ -0,0 +1,179 @@ +# supervision + +> Open-source Python library for computer vision โ€” annotate, track, count, filter, and convert. + +Supervision is a Python library by Roboflow that provides a model-agnostic `Detections` class and composable tools for object detection and segmentation workflows. It includes converters for supported outputs from Ultralytics, Roboflow Inference, Hugging Face Transformers, SAM, Detectron2, MMDetection, YOLO-NAS, PaddleDet, NCNN, Azure AI Vision, and VLM parsers. + +Supervision is MIT licensed, published on PyPI, and developed in public on GitHub. + +## AI Access + +The documentation is static HTML and open for AI consumption. `robots.txt` explicitly allows general crawlers plus selected AI crawlers. + +- GPTBot: allowed +- ClaudeBot: allowed +- PerplexityBot: allowed +- CCBot: allowed +- GoogleOther: allowed + +## Install + +``` +pip install supervision +``` + +Extra: `pip install supervision[metrics]` for optional metric dependencies. Sample asset utilities are included in the base package under `supervision.assets`. + +## Links + +- GitHub: https://github.com/roboflow/supervision +- PyPI: https://pypi.org/project/supervision +- Docs (latest stable): https://supervision.roboflow.com/latest/ +- Changelog: https://supervision.roboflow.com/latest/changelog/ +- Sitemap: https://supervision.roboflow.com/sitemap.xml + +## Key APIs + +### sv.Detections +Core data structure for bounding boxes, masks, confidence scores, class IDs, tracker IDs, and arbitrary per-detection metadata stored in a `data` dict. The lingua franca of the entire library โ€” every connector, annotator, and tracker accepts or returns `Detections`. Supports NumPy-style boolean indexing for filtering by class, confidence, area, and spatial regions. + +### sv.BoxAnnotator, sv.MaskAnnotator, sv.LabelAnnotator +Draw bounding boxes, segmentation masks, and text labels on images. Annotators expose `annotate(scene=..., detections=...)`; pass an input image and a `Detections` object to get the annotated output. `LabelAnnotator` can use explicit `labels` or fall back to `detections["class_name"]`, class IDs, then detection indices. Colors can be assigned by class or manually specified. + +### sv.ByteTrack +Object tracker wrapper that assigns persistent IDs across video frames. The built-in `sv.ByteTrack` accepts `Detections` via `update_with_detections()`, but it is deprecated in favor of `ByteTrackTracker` from the external `trackers` package, where the method is named `update()`. Use tracked `Detections` with `sv.TraceAnnotator` to visualize trajectories. + +### sv.PolygonZone and sv.LineZone +Zone-based counting. `PolygonZone.trigger(detections)` returns a boolean mask for detections currently inside an arbitrary polygon. `LineZone.trigger(detections)` returns `(crossed_in, crossed_out)` arrays for line crossings and requires `detections.tracker_id` so objects can be matched across frames. Both are commonly paired with zone annotators for visualization. + +### sv.DetectionDataset and sv.ClassificationDataset +For detection datasets, load, merge, split, and convert between YOLO, COCO JSON, Pascal VOC, CreateML, and LabelMe formats. Classification datasets use folder-structure import and export via `ClassificationDataset.from_folder_structure()` and `as_folder_structure()`. + +### sv.InferenceSlicer +SAHI-style inference slicing: split high-resolution images into overlapping tiles, run detection on each tile, merge results with non-maximum suppression or non-maximum merge. Configure tile overlap in pixels with `overlap_wh`. + +### supervision.metrics.MeanAveragePrecision and sv.ConfusionMatrix +Benchmarking tools. For mAP@0.5:0.95, use `supervision.metrics.MeanAveragePrecision` with `update()` and `compute()` rather than the deprecated top-level `sv.MeanAveragePrecision.from_detections()`. `ConfusionMatrix.from_detections(predictions=predictions, targets=targets, classes=classes)` generates a confusion matrix for detection results. + +### sv.CSVSink and sv.JSONSink +Export detection results to structured files. Use `CSVSink` and `JSONSink` as context managers, call `sink.append(detections, custom_data=...)`, and they write one row/object per detection with box coordinates, confidence, class ID, tracker ID, and data fields. + +## How-To Guides + +- Detect and annotate: https://supervision.roboflow.com/latest/how_to/detect_and_annotate/ +- Track objects: https://supervision.roboflow.com/latest/how_to/track_objects/ +- Detect small objects: https://supervision.roboflow.com/latest/how_to/detect_small_objects/ +- Filter detections: https://supervision.roboflow.com/latest/how_to/filter_detections/ +- Save detections: https://supervision.roboflow.com/latest/how_to/save_detections/ +- Count in zone: https://supervision.roboflow.com/latest/how_to/count_in_zone/ +- Benchmark a model: https://supervision.roboflow.com/latest/how_to/benchmark_a_model/ +- Process datasets: https://supervision.roboflow.com/latest/how_to/process_datasets/ + +## Reference Documentation + +- Detections (detection/core): https://supervision.roboflow.com/latest/detection/core/ +- Annotators (detection/annotators): https://supervision.roboflow.com/latest/detection/annotators/ +- CompactMask (detection/compact_mask): https://supervision.roboflow.com/latest/detection/compact_mask/ +- Format Converters (detection/utils/converters): https://supervision.roboflow.com/latest/detection/utils/converters/ +- IoU and NMS (detection/utils/iou_and_nms): https://supervision.roboflow.com/latest/detection/utils/iou_and_nms/ +- Boxes (detection/utils/boxes): https://supervision.roboflow.com/latest/detection/utils/boxes/ +- Masks (detection/utils/masks): https://supervision.roboflow.com/latest/detection/utils/masks/ +- Polygons (detection/utils/polygons): https://supervision.roboflow.com/latest/detection/utils/polygons/ +- VLMs (detection/utils/vlms): https://supervision.roboflow.com/latest/detection/utils/vlms/ +- Keypoint Core (keypoint/core): https://supervision.roboflow.com/latest/keypoint/core/ +- Keypoint Annotators (keypoint/annotators): https://supervision.roboflow.com/latest/keypoint/annotators/ +- Classification Core (classification/core): https://supervision.roboflow.com/latest/classification/core/ +- ByteTrack Tracker (trackers): https://supervision.roboflow.com/latest/trackers/ +- Datasets Core (datasets/core): https://supervision.roboflow.com/latest/datasets/core/ +- mAP (metrics/mean_average_precision): https://supervision.roboflow.com/latest/metrics/mean_average_precision/ +- mAR (metrics/mean_average_recall): https://supervision.roboflow.com/latest/metrics/mean_average_recall/ +- Precision (metrics/precision): https://supervision.roboflow.com/latest/metrics/precision/ +- Recall (metrics/recall): https://supervision.roboflow.com/latest/metrics/recall/ +- F1 Score (metrics/f1_score): https://supervision.roboflow.com/latest/metrics/f1_score/ +- Common Values (metrics/common_values): https://supervision.roboflow.com/latest/metrics/common_values/ +- Line Zone (detection/tools/line_zone): https://supervision.roboflow.com/latest/detection/tools/line_zone/ +- Polygon Zone (detection/tools/polygon_zone): https://supervision.roboflow.com/latest/detection/tools/polygon_zone/ +- Inference Slicer (detection/tools/inference_slicer): https://supervision.roboflow.com/latest/detection/tools/inference_slicer/ +- Detection Smoother (detection/tools/smoother): https://supervision.roboflow.com/latest/detection/tools/smoother/ +- Save Detections Tool (detection/tools/save_detections): https://supervision.roboflow.com/latest/detection/tools/save_detections/ +- Video Utils (utils/video): https://supervision.roboflow.com/latest/utils/video/ +- Image Utils (utils/image): https://supervision.roboflow.com/latest/utils/image/ +- Iterable Utils (utils/iterables): https://supervision.roboflow.com/latest/utils/iterables/ +- Notebook Utils (utils/notebook): https://supervision.roboflow.com/latest/utils/notebook/ +- File Utils (utils/file): https://supervision.roboflow.com/latest/utils/file/ +- Draw Utils (utils/draw): https://supervision.roboflow.com/latest/utils/draw/ +- Geometry (utils/geometry): https://supervision.roboflow.com/latest/utils/geometry/ +- Assets (assets): https://supervision.roboflow.com/latest/assets/ + +## Cookbooks + +- Object tracking: https://supervision.roboflow.com/latest/cookbooks/#object-tracking +- Count objects crossing line: https://supervision.roboflow.com/latest/cookbooks/#count-objects-crossing-the-line +- Zero-shot object detection with YOLO-World: https://supervision.roboflow.com/latest/cookbooks/#zero-shot-object-detection-with-yolo-world +- SAHI small object detection: https://supervision.roboflow.com/latest/cookbooks/#small-object-detection-with-sahi + +## FAQ + +### What is supervision? + +Supervision is an open-source Python library by Roboflow for computer vision workflows. It provides a unified `Detections` class with converters for supported detection, segmentation, and VLM outputs, plus tools for annotation, tracking, zone counting, dataset management, and model benchmarking. + +### How do I install supervision? + +Install with `pip install supervision`. For optional metric dependencies use `pip install supervision[metrics]`. Sample asset utilities are included in the base package under `supervision.assets`. The current package metadata requires Python 3.10+. + +### What can I do with supervision? + +Annotate images and video with bounding boxes, masks, and labels; track objects across frames with persistent IDs; count detections inside polygon zones or line crossings; filter and query detection results; load, split, and convert detection datasets between YOLO, COCO, Pascal VOC, and LabelMe formats; manage classification datasets with folder structures; and benchmark model performance with mAP and confusion matrices. + +### Is supervision free to use? + +Yes. Supervision is free and open-source under the MIT license. Source code is at https://github.com/roboflow/supervision. + +### Which object detection models work with supervision? + +Supervision is model-agnostic and works with supported outputs from Ultralytics YOLO, Roboflow Inference, Hugging Face Transformers, SAM, Detectron2, MMDetection, YOLO-NAS, PaddleDet, NCNN, Azure AI Vision, and VLM parsers such as Florence-2, PaliGemma, Qwen VL, Gemini, DeepSeek VL 2, and Moondream. Keypoint outputs have separate converters, including MediaPipe. + +### How do I benchmark a model with supervision? + +Use `supervision.metrics.mean_average_precision.MeanAveragePrecision` for mAP โ€” accumulate predictions and ground truth with `update(...)` then call `compute()`. For confusion matrices, use `sv.ConfusionMatrix.from_detections(predictions=predictions, targets=targets, classes=classes)`. See the Benchmark a Model how-to guide for a complete walkthrough. + +### How do I track objects across video frames? + +Use a tracker to assign persistent IDs. The built-in `sv.ByteTrack` wrapper accepts `Detections` with `update_with_detections()`, but it is deprecated in favor of `ByteTrackTracker` from the external `trackers` package. Combine tracked detections with `sv.TraceAnnotator` to visualize trajectories. + +### What dataset formats does supervision support? + +For detection datasets, supervision supports YOLO, COCO JSON, Pascal VOC, CreateML, and LabelMe. Use `DetectionDataset.from_yolo()`, `from_coco()`, `from_pascal_voc()`, `from_createml()`, or `from_labelme()` to load, and `as_yolo()`, `as_coco()`, `as_pascal_voc()`, `as_createml()`, or `as_labelme()` to save. For classification datasets, use `ClassificationDataset.from_folder_structure()` and `as_folder_structure()`. + +### How do I count objects in a zone? + +Use `sv.PolygonZone` for arbitrary polygon zones. Use `sv.LineZone` for line-crossing counts after assigning tracker IDs, because `LineZone` needs `detections.tracker_id` to match objects across frames. + +### How do I detect small objects with supervision? + +Use `sv.InferenceSlicer` to split high-resolution images into overlapping tiles, run detection on each tile, and merge results with non-maximum suppression. Configure tile overlap in pixels with `overlap_wh`. See the Detect Small Objects how-to guide. + +## Benchmarking + +Supervision includes `supervision.metrics.MeanAveragePrecision` and `sv.ConfusionMatrix` for benchmarking object detection models. A curated [Model Leaderboard](https://leaderboard.roboflow.com/) compares YOLOv8, YOLOv11, and other models on standard datasets. The leaderboard repository is open source at https://github.com/roboflow/model-leaderboard. + +## License + +MIT โ€” https://github.com/roboflow/supervision/blob/develop/LICENSE.md + +## Citation + +```bibtex +@software{supervision, + author = {Roboflow}, + title = {Supervision: Computer Vision Toolkit}, + url = {https://github.com/roboflow/supervision}, + year = {2023} +} +``` + +## Versioning + +Stable release docs: https://supervision.roboflow.com/latest/ +Development branch: https://supervision.roboflow.com/develop/ diff --git a/docs/metrics/common_values.md b/docs/metrics/common_values.md new file mode 100644 index 0000000..7d4bb0b --- /dev/null +++ b/docs/metrics/common_values.md @@ -0,0 +1,25 @@ +--- +comments: true +--- + +# Common Values + +This page contains supplementary values, types and enums that metrics use. + +Install the metrics extra before using metrics APIs: + +```bash +pip install "supervision[metrics]" +``` + +
+

MetricTarget

+
+ +:::supervision.metrics.core.MetricTarget + +
+

AveragingMethod

+
+ +:::supervision.metrics.core.AveragingMethod diff --git a/docs/metrics/f1_score.md b/docs/metrics/f1_score.md new file mode 100644 index 0000000..1b26860 --- /dev/null +++ b/docs/metrics/f1_score.md @@ -0,0 +1,23 @@ +--- +comments: true +--- + +# F1 Score + +Install the metrics extra before using this API: + +```bash +pip install "supervision[metrics]" +``` + +
+

F1Score

+
+ +:::supervision.metrics.f1_score.F1Score + +
+

F1ScoreResult

+
+ +:::supervision.metrics.f1_score.F1ScoreResult diff --git a/docs/metrics/mean_average_precision.md b/docs/metrics/mean_average_precision.md new file mode 100644 index 0000000..536558d --- /dev/null +++ b/docs/metrics/mean_average_precision.md @@ -0,0 +1,30 @@ +--- +comments: true +description: API reference for MeanAveragePrecision โ€” compute mAP for object detection benchmarking with boxes, masks, and oriented boxes. +--- + +# Mean Average Precision + +Install the metrics extra before using this API: + +```bash +pip install "supervision[metrics]" +``` + +
+

MeanAveragePrecision

+
+ +:::supervision.metrics.mean_average_precision.MeanAveragePrecision + +
+

MeanAveragePrecisionResult

+
+ +:::supervision.metrics.mean_average_precision.MeanAveragePrecisionResult + +
+

get_coco_class_index_mapping

+
+ +:::supervision.dataset.formats.coco.get_coco_class_index_mapping diff --git a/docs/metrics/mean_average_recall.md b/docs/metrics/mean_average_recall.md new file mode 100644 index 0000000..5344286 --- /dev/null +++ b/docs/metrics/mean_average_recall.md @@ -0,0 +1,23 @@ +--- +comments: true +--- + +# Mean Average Recall + +Install the metrics extra before using this API: + +```bash +pip install "supervision[metrics]" +``` + +
+

MeanAverageRecall

+
+ +:::supervision.metrics.mean_average_recall.MeanAverageRecall + +
+

MeanAverageRecallResult

+
+ +:::supervision.metrics.mean_average_recall.MeanAverageRecallResult diff --git a/docs/metrics/precision.md b/docs/metrics/precision.md new file mode 100644 index 0000000..c01628d --- /dev/null +++ b/docs/metrics/precision.md @@ -0,0 +1,23 @@ +--- +comments: true +--- + +# Precision + +Install the metrics extra before using this API: + +```bash +pip install "supervision[metrics]" +``` + +
+

Precision

+
+ +:::supervision.metrics.precision.Precision + +
+

PrecisionResult

+
+ +:::supervision.metrics.precision.PrecisionResult diff --git a/docs/metrics/recall.md b/docs/metrics/recall.md new file mode 100644 index 0000000..6d93569 --- /dev/null +++ b/docs/metrics/recall.md @@ -0,0 +1,23 @@ +--- +comments: true +--- + +# Recall + +Install the metrics extra before using this API: + +```bash +pip install "supervision[metrics]" +``` + +
+

Recall

+
+ +:::supervision.metrics.recall.Recall + +
+

RecallResult

+
+ +:::supervision.metrics.recall.RecallResult diff --git a/docs/robots.txt b/docs/robots.txt new file mode 100644 index 0000000..f8f00e4 --- /dev/null +++ b/docs/robots.txt @@ -0,0 +1,25 @@ +User-agent: * +Allow: / + +User-agent: GPTBot +Allow: / + +User-agent: ClaudeBot +Allow: / + +User-agent: PerplexityBot +Allow: / + +User-agent: Bytespider +Allow: / + +User-agent: CCBot +Allow: / + +User-agent: GoogleOther +Allow: / + +User-agent: Applebot +Allow: / + +Sitemap: https://supervision.roboflow.com/sitemap.xml diff --git a/docs/stylesheets/cookbooks_card.css b/docs/stylesheets/cookbooks_card.css new file mode 100644 index 0000000..3509f20 --- /dev/null +++ b/docs/stylesheets/cookbooks_card.css @@ -0,0 +1,117 @@ +.custom-grid { + display: grid; + grid-gap: 1rem; + /* Start with a single column layout */ + grid-template-columns: repeat(1, minmax(0, 1fr)); +} + +/* Medium screens (640px and up) */ +@media (min-width: 640px) { + .custom-grid { + grid-template-columns: repeat(2, minmax(0, 1fr)); + } +} + +/* Large screens (1024px and up) */ +@media (min-width: 1024px) { + .custom-grid { + grid-template-columns: repeat(4, minmax(0, 1fr)); + } +} + +.custom-grid a { + color: inherit; + text-decoration: none; + display: block; +} + +.custom-grid a:hover { + color: inherit; /* Ensure color does not change on hover */ +} + +.repo-card { + background: radial-gradient(at right top, #A351FB25, #A5F9EA25); + border-radius: 0.5rem; + padding: 1rem; + transition: transform 0.2s ease-in-out; /* Smooth transition for the transform */ + cursor: pointer; +} + +.repo-card:hover { + transform: translateY(-0.125rem); /* Move up by -0.125rem on hover */ +} + +.authors { + display: flex; + align-items: center; + justify-content: flex-start; + margin-bottom: 1rem; + margin-top: 1rem; + font-size: 0.75rem; + line-height: 1rem; +} + +.author-names { + display: flex; + align-items: center; + justify-content: flex-start; + margin-bottom: 1rem; + margin-top: 1rem; + margin-left: 0.5rem; +} + +.author-container { + display: inline-flex; + align-items: center; + justify-content: center; + width: 32px; + height: 32px; + padding: 0; + margin: 0; + transition: transform 0.2s; +} + +.author-container.hover { + transform: translateY(-0.125rem); +} + +.author-container:hover { + transform: translateY(-0.125rem); +} + +.author-container a { + padding: 0; + margin: 0; + display: block; +} + +.author-avatar { + width: 32px; + height: 32px; + border-radius: 50%; + display: block; +} + +.author-name a { + color: inherit; /* Inherits the color from the parent element */ + text-decoration: none; /* Removes the underline */ +} + +.author-name a:hover { + color: inherit; /* Inherits the color from the parent element */ + text-decoration: underline; /* Adds underline on hover */ +} + +.label { + color: #fff; + padding: 2px 6px; + border-radius: 4px; + margin-right: 4px; +} + +.non-selectable-text { + -webkit-user-select: none; /* Safari */ + -moz-user-select: none; /* Firefox */ + -ms-user-select: none; /* Internet Explorer/Edge */ + user-select: none; /* Non-prefixed version, currently supported by Chrome, Opera, and Edge */ +} diff --git a/docs/stylesheets/extra.css b/docs/stylesheets/extra.css new file mode 100644 index 0000000..2910d5f --- /dev/null +++ b/docs/stylesheets/extra.css @@ -0,0 +1,270 @@ +:root, body { + /* Default to light theme */ + --md-primary-fg-color: #8315F9; + --md-code-hl-color: #8315F9 !important; + --md-accent-fg-color: #8315F9 !important; + --md-code-hl-color--light: #e8d2ff89 !important; + --md-footer-fg-color--light: rgb(111, 108, 121) !important; +} + +body.light { + /* Light theme */ + --md-text-color: #000000; + --md-h2-color: #000000; +} +.md-grid { + max-width: 85%; + margin: auto; +} +.sublist { + display: none; + list-style: none; + padding-left: 0; + background: white; + position: absolute; + border-radius: 8px; + margin-top: 0.25rem; +} +.sublist { + transition: opacity 0.5s ease-in-out; + display: none; + position: absolute; /* Ensure it overlaps and doesn't break flow */ + background: white; /* So it's visible */ + z-index: 1000; +} +.sublist li { + padding: 0.5rem; +} +#products-list *:hover .products-sublist { + display: block; +} +#resources-list *, #products-list * { + cursor: pointer; +} +.products-sublist, .resources-sublist { + padding: 0.25rem; +} +.products-sublist li:hover, .resources-sublist li:hover, .md-nav__link[href]:hover { + background: rgb(242, 241, 247) !important; + border-radius: 6px; + color: initial !important; +} +.md-search { + flex-grow: 2; +} +.portfolio-section .md-grid { + max-width: 100%; +} +.md-header__inner { + align-items: center; + display: grid; + grid-template-columns: 0.1fr 1.4fr 2fr 2fr; + padding-right: 1rem; +} +.md-search__inner { + max-width: 600px; + width: 100%; + min-width: 100%; +} +.md-search__input { + background: white; + border: 1px solid rgb(229, 231, 235); + border-radius: 8px; + color: rgb(111, 108, 121); +} +.md-search__form *, .md-search__icon, .md-search__input { + color: rgb(111, 108, 121); +} +.md-search__input::placeholder { + color: rgb(156, 163, 175); +} +.md-search__form { + background: none !important; +} +.md-footer, .md-footer-meta { + background-color: transparent; + color: rgb(111, 108, 121); +} +.md-typeset .tabbed-set > input:first-child:checked ~ .tabbed-labels > :first-child, .md-typeset .tabbed-set > input:nth-child(10):checked ~ .tabbed-labels > :nth-child(10), .md-typeset .tabbed-set > input:nth-child(11):checked ~ .tabbed-labels > :nth-child(11), .md-typeset .tabbed-set > input:nth-child(12):checked ~ .tabbed-labels > :nth-child(12), .md-typeset .tabbed-set > input:nth-child(13):checked ~ .tabbed-labels > :nth-child(13), .md-typeset .tabbed-set > input:nth-child(14):checked ~ .tabbed-labels > :nth-child(14), .md-typeset .tabbed-set > input:nth-child(15):checked ~ .tabbed-labels > :nth-child(15), .md-typeset .tabbed-set > input:nth-child(16):checked ~ .tabbed-labels > :nth-child(16), .md-typeset .tabbed-set > input:nth-child(17):checked ~ .tabbed-labels > :nth-child(17), .md-typeset .tabbed-set > input:nth-child(18):checked ~ .tabbed-labels > :nth-child(18), .md-typeset .tabbed-set > input:nth-child(19):checked ~ .tabbed-labels > :nth-child(19), .md-typeset .tabbed-set > input:nth-child(2):checked ~ .tabbed-labels > :nth-child(2), .md-typeset .tabbed-set > input:nth-child(20):checked ~ .tabbed-labels > :nth-child(20), .md-typeset .tabbed-set > input:nth-child(3):checked ~ .tabbed-labels > :nth-child(3), .md-typeset .tabbed-set > input:nth-child(4):checked ~ .tabbed-labels > :nth-child(4), .md-typeset .tabbed-set > input:nth-child(5):checked ~ .tabbed-labels > :nth-child(5), .md-typeset .tabbed-set > input:nth-child(6):checked ~ .tabbed-labels > :nth-child(6), .md-typeset .tabbed-set > input:nth-child(7):checked ~ .tabbed-labels > :nth-child(7), .md-typeset .tabbed-set > input:nth-child(8):checked ~ .tabbed-labels > :nth-child(8), .md-typeset .tabbed-set > input:nth-child(9):checked ~ .tabbed-labels > :nth-child(9) { + color: #8315F9; + border-bottom: 1px solid #8315F9; +} +.md-footer *, html .md-footer-meta.md-typeset a { + color: rgb(111, 108, 121); +} +.repo-card { + height: 100%; +} +.header-btn { + text-align: center; +} +.header-btn, .sublist { + box-shadow: rgb(255, 255, 255) 0px 0px 0px 0px, rgb(217, 215, 226) 0px 0px 0px 1px, rgb(217, 215, 226) 0px 1px 2px 0px; +} +.header-btn:hover { + box-shadow: rgb(255, 255, 255) 0px 0px 0px 0px, rgb(217, 215, 226) 0px 0px 0px 1px, rgb(217, 215, 226) 0px 1.0001px 2.00013px -0.0000327245px, rgba(0, 0, 0, 0) 0px 0.000065449px 0.000130898px -0.000065449px; +} +.md-typeset .headerlink:hover, .md-typeset .headerlink:target { + color: #8315F9; +} +.md-typeset h1, .md-header__title { + color: black; + font-weight: 800; +} +.md-typeset h1 { + font-weight: normal; + margin-bottom: 1rem; +} +body { + background: linear-gradient(to left bottom, rgb(243, 238, 255), rgb(255, 255, 255) 60%) no-repeat; +} + +/* .md-nav__link:has([tabindex=""]) { + text-transform: uppercase; +} */ + +.header-list { + display: flex; + align-items: center; + gap: 1rem; + list-style: none; + font-size: 0.75rem; + justify-content: flex-end; +} +.md-nav__list label, .md-nav--secondary label { + /* text-transform: uppercase; */ + color: rgb(29, 29, 31) !important; + font-size: 0.7rem; + margin-bottom: 0; +} +.md-nav--secondary label { + margin-left: 0.5rem; +} + +.md-nav__link { + padding: 0.25rem; + padding-left: 0.5rem; + padding-right: 0.5rem; +} + +.md-nav__link--active { + background: rgb(243, 238, 255); + border-radius: 6px; + padding-top: 0.25rem; +} + +.md-tabs__item--active { + color: var(--md-primary-fg-color); + border-bottom: 2px solid var(--md-primary-fg-color); +} + +.md-nav--secondary .md-nav__title { + background: transparent; + box-shadow: none; +} + +.md-header, .md-tabs { + color: rgb(111, 108, 121); + background-color: transparent; +} +.md-header--shadow { + background: linear-gradient(to left bottom, rgb(243, 238, 255), rgb(255, 255, 255) 60%); + box-shadow: none; + border-bottom: 1px solid rgb(229, 231, 235); +} + +#item-logo { + display: none; +} +.md-main__inner, .md-header__inner, .md-grid { + max-width: 100%; +} +@media (max-width: 1200px) { + .md-header__inner { + display: flex; + } + .header-list { + display: none; + } + #item-logo { + display: block; + } +} +.md-content { + max-width: 40rem; + margin: auto; +} +/* // if no md-sidebar--primary, make .md-content full width */ +.md-main__inner:has(.md-sidebar--primary[hidden]) .md-content { + max-width: 100%; +} +.md-sidebar--primary { + flex: 0 20%; +} +.md-tabs { + border-bottom: 1px solid rgb(229, 231, 235); +} +.md-main__inner { + padding-top: 1rem; + margin-top: 0; +} + +body.dark { + /* Dark theme */ + --md-text-color: #FFFFFF; + --md-h2-color: #add8e6; +} + +body.light .md-content *, body.dark .md-content * { + color: var(--md-text-color) !important; +} + +body[data-md-url$="/cookbooks/"] .md-sidebar--primary, +body[data-md-url$="/cookbooks/"] .md-sidebar--secondary { + display: none; +} + +body[data-md-url$="/cookbooks/"] .md-content { + margin-left: 0; + width: 100%; +} + +.md-main, nav .md-grid, .md-header__inner { + max-width: 1600px; + width: 100%; + margin: auto; +} +.md-search__scrollwrap { + width: 100% !important; +} +.md-nav--secondary .md-nav__title { + position: initial !important; +} + +.md-header__title .md-ellipsis { + overflow: initial !important; + text-overflow: initial !important; +} +.md-search { + flex-grow: 0; +} + +/* Table style */ + +th, td { + border: 1px solid var(--md-typeset-table-color); +} + +.md-typeset__table { + line-height: 1.5; +} + +.md-typeset__table table:not([class]) { + font-size: 0.6rem; + border-collapse: collapse; +} + +.md-typeset__table table:not([class]) td, +.md-typeset__table table:not([class]) th { + padding: 10px; +} diff --git a/docs/theme/cookbooks.html b/docs/theme/cookbooks.html new file mode 100644 index 0000000..9f3fbc1 --- /dev/null +++ b/docs/theme/cookbooks.html @@ -0,0 +1,76 @@ +{% extends "main.html" %} +{% block libs %} + + + +{% endblock %} +{% block content %} +
+
+
+

Supervision Cookbooks

+
+
+

+ + +

+ + +

+ + +

+ + +

+ + +

+ + +

+ + +

+ + +

+ + +

+ + +

+ + +

+ + +

+ + +

+ + +

+ +
+
+
+{% endblock %} diff --git a/docs/theme/index.html b/docs/theme/index.html new file mode 100644 index 0000000..c65749c --- /dev/null +++ b/docs/theme/index.html @@ -0,0 +1,15 @@ +{% extends "main.html" %} +{% block content %} +{{ super() }} + +{% endblock %} diff --git a/docs/theme/main.html b/docs/theme/main.html new file mode 100644 index 0000000..3054edd --- /dev/null +++ b/docs/theme/main.html @@ -0,0 +1,495 @@ +{% extends "base.html" %} + +{% block content %} +{% if page.nb_url %} + +{% endif %} +{{ super() }} +{% endblock content %} + +{% block extrahead %} +{{ super() }} +{% if page.meta is defined and page.meta is not none and page.meta is not undefined %} +{% set _meta = page.meta %} +{% else %} +{% set _meta = {} %} +{% endif %} +{% set page_description = _meta.description | d(config.site_description) %} +{# โ”€โ”€ GEO: JSON-LD + OG tags (page context required โ€” skip for theme templates like 404) #} + +{# โ”€โ”€ GEO: JSON-LD structured data โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€ #} + + + + + + + + +{% for is_home in [page.is_homepage] %}{% if is_home %} + +{% endif %}{% endfor %} + +{% if page.url == 'faq/' %} + +{% endif %} + +{% if page.url == 'about/' or page.url == 'contact/' %} + +{% endif %} + +{% if 'how_to' in page.url %} + +{% endif %} + +{# โ”€โ”€ How-to FAQ schema โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€ #} +{% if 'how_to' in page.url %} + +{% endif %} + +{% for is_not_home in [not page.is_homepage] %}{% if is_not_home %} + +{% endif %}{% endfor %} + +{# โ”€โ”€ GEO: Open Graph + Twitter Card meta tags โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€ #} + + + + + + + + + + + + + + + + + + +{# โ”€โ”€ API reference schema (detection/ metrics/ datasets/ reference pages) โ”€โ”€ #} +{% for is_ref in [('reference' in page.url or 'detection/' in page.url or 'metrics/' in page.url or 'keypoint/' in page.url or 'classification/' in page.url) and 'how_to' not in page.url] %}{% if is_ref %} + +{% endif %}{% endfor %} + +{# Cookbooks FAQ schema โ”€โ”€ #} +{% for is_cookbook in ['cookbook' in page.url] %}{% if is_cookbook %} + +{% endif %}{% endfor %} + +{# IndexNow ownership key โ€” do NOT change this value. + The same key must exist in three places (all must stay in sync): + 1. This meta tag (docs/theme/main.html) + 2. The key file at docs/0d5d9799b1cc4a39825146388c6781eb.txt + 3. The CI step in .github/workflows/publish-docs.yml + Bing/Yandex verify ownership by fetching https://supervision.roboflow.com/.txt + and comparing its contents to this meta tag before accepting IndexNow submissions. #} + + + + +{% endblock %} diff --git a/docs/theme/partials/comments.html b/docs/theme/partials/comments.html new file mode 100644 index 0000000..d95dd6b --- /dev/null +++ b/docs/theme/partials/comments.html @@ -0,0 +1,51 @@ +{% if page.meta.comments %} +

{{ lang.t("meta.comments") }}

+ + + + + + +{% endif %} diff --git a/docs/theme/partials/header.html b/docs/theme/partials/header.html new file mode 100644 index 0000000..472db17 --- /dev/null +++ b/docs/theme/partials/header.html @@ -0,0 +1,181 @@ +{% set class = "md-header" %} +{% if "navigation.tabs.sticky" in features %} + {% set class = class ~ " md-header--shadow md-header--lifted" %} +{% elif "navigation.tabs" not in features %} + {% set class = class ~ " md-header--shadow" %} +{% endif %} + + +
+ + + + {% if "navigation.tabs.sticky" in features %} + {% if "navigation.tabs" in features %} + {% include "partials/tabs.html" %} + {% endif %} + {% endif %} +
diff --git a/docs/trackers.md b/docs/trackers.md new file mode 100644 index 0000000..c68a999 --- /dev/null +++ b/docs/trackers.md @@ -0,0 +1,12 @@ +--- +comments: true +description: API reference for supervision's deprecated ByteTrack tracker wrapper. +--- + +# ByteTrack + +!!! warning "Deprecated" + + `sv.ByteTrack` is deprecated in `supervision-0.28.0` and will be removed in `supervision-0.31.0`. Install `trackers` and use `ByteTrackTracker` instead. + +:::supervision.tracker.byte_tracker.core.ByteTrack diff --git a/docs/utils/conversion.md b/docs/utils/conversion.md new file mode 100644 index 0000000..6e7d7d0 --- /dev/null +++ b/docs/utils/conversion.md @@ -0,0 +1,36 @@ +--- +comments: true +status: new +--- + +# Conversion Utils + +
+

cv2_to_pillow

+
+ +:::supervision.utils.conversion.cv2_to_pillow + +
+

pillow_to_cv2

+
+ +:::supervision.utils.conversion.pillow_to_cv2 + +
+

ensure_cv2_image_for_annotation

+
+ +:::supervision.utils.conversion.ensure_cv2_image_for_annotation + +
+

ensure_pil_image_for_annotation

+
+ +:::supervision.utils.conversion.ensure_pil_image_for_annotation + +
+

images_to_cv2

+
+ +:::supervision.utils.conversion.images_to_cv2 diff --git a/docs/utils/draw.md b/docs/utils/draw.md new file mode 100644 index 0000000..d881051 --- /dev/null +++ b/docs/utils/draw.md @@ -0,0 +1,71 @@ +--- +comments: true +--- + +# Draw Utils + +
+

draw_line

+
+ +:::supervision.draw.utils.draw_line + +
+

draw_rectangle

+
+ +:::supervision.draw.utils.draw_rectangle + +
+

draw_filled_rectangle

+
+ +:::supervision.draw.utils.draw_filled_rectangle + +
+

draw_polygon

+
+ +:::supervision.draw.utils.draw_polygon + +
+

draw_filled_polygon

+
+ +:::supervision.draw.utils.draw_filled_polygon + +
+

draw_text

+
+ +:::supervision.draw.utils.draw_text + +
+

draw_image

+
+ +:::supervision.draw.utils.draw_image + +
+

calculate_optimal_text_scale

+
+ +:::supervision.draw.utils.calculate_optimal_text_scale + +
+

calculate_optimal_line_thickness

+
+ +:::supervision.draw.utils.calculate_optimal_line_thickness + +
+

Color

+
+ +:::supervision.draw.color.Color + +
+

ColorPalette

+
+ +:::supervision.draw.color.ColorPalette diff --git a/docs/utils/file.md b/docs/utils/file.md new file mode 100644 index 0000000..a2a0818 --- /dev/null +++ b/docs/utils/file.md @@ -0,0 +1,11 @@ +--- +comments: true +--- + +# File Utils + +
+

list_files_with_extensions

+
+ +:::supervision.utils.file.list_files_with_extensions diff --git a/docs/utils/geometry.md b/docs/utils/geometry.md new file mode 100644 index 0000000..3b02f90 --- /dev/null +++ b/docs/utils/geometry.md @@ -0,0 +1,33 @@ +--- +comments: true +--- + +
+

get_polygon_center

+
+ +:::supervision.geometry.utils.get_polygon_center + +
+

Position

+
+ +:::supervision.geometry.core.Position + +
+

Point

+
+ +:::supervision.geometry.core.Point + +
+

Rect

+
+ +:::supervision.geometry.core.Rect + +
+

Vector

+
+ +:::supervision.geometry.core.Vector diff --git a/docs/utils/image.md b/docs/utils/image.md new file mode 100644 index 0000000..9d1c189 --- /dev/null +++ b/docs/utils/image.md @@ -0,0 +1,54 @@ +--- +comments: true +status: new +--- + +# Image Utils + +
+

crop_image

+
+ +:::supervision.utils.image.crop_image + +
+

scale_image

+
+ +:::supervision.utils.image.scale_image + +
+

resize_image

+
+ +:::supervision.utils.image.resize_image + +
+

letterbox_image

+
+ +:::supervision.utils.image.letterbox_image + +
+

tint_image

+
+ +:::supervision.utils.image.tint_image + +
+

grayscale_image

+
+ +:::supervision.utils.image.grayscale_image + +
+

get_image_resolution_wh

+
+ +:::supervision.utils.image.get_image_resolution_wh + +
+

ImageSink

+
+ +:::supervision.utils.image.ImageSink diff --git a/docs/utils/iterables.md b/docs/utils/iterables.md new file mode 100644 index 0000000..5ae92dc --- /dev/null +++ b/docs/utils/iterables.md @@ -0,0 +1,17 @@ +--- +comments: true +--- + +# Iterables Utils + +
+

create_batches

+
+ +:::supervision.utils.iterables.create_batches + +
+

fill

+
+ +:::supervision.utils.iterables.fill diff --git a/docs/utils/notebook.md b/docs/utils/notebook.md new file mode 100644 index 0000000..3eab046 --- /dev/null +++ b/docs/utils/notebook.md @@ -0,0 +1,17 @@ +--- +comments: true +--- + +# Notebooks Utils + +
+

plot_image

+
+ +:::supervision.utils.notebook.plot_image + +
+

plot_images_grid

+
+ +:::supervision.utils.notebook.plot_images_grid diff --git a/docs/utils/video.md b/docs/utils/video.md new file mode 100644 index 0000000..f9a5821 --- /dev/null +++ b/docs/utils/video.md @@ -0,0 +1,35 @@ +--- +comments: true +--- + +# Video Utils + +
+

VideoInfo

+
+ +:::supervision.utils.video.VideoInfo + +
+

VideoSink

+
+ +:::supervision.utils.video.VideoSink + +
+

FPSMonitor

+
+ +:::supervision.utils.video.FPSMonitor + +
+

get_video_frames_generator

+
+ +:::supervision.utils.video.get_video_frames_generator + +
+

process_video

+
+ +:::supervision.utils.video.process_video diff --git a/examples/README.md b/examples/README.md new file mode 100644 index 0000000..d29b485 --- /dev/null +++ b/examples/README.md @@ -0,0 +1,12 @@ +# Examples + +Here, you'll find end-to-end examples that show how to solve common computer vision problems using Supervision. + +For more information and examples, visit our [documentation](https://supervision.roboflow.com/latest/detection/annotators/) and explore our [how-to guides](https://supervision.roboflow.com/latest/how_to/detect_and_annotate/) and [cookbooks](https://supervision.roboflow.com/latest/cookbooks/). Join our [Discord](https://discord.com/invite/GbfgXGJ8Bk) and meet other Supervision power users! + +- [tracking](./tracking) by [@SkalskiP](https://github.com/SkalskiP) +- [count people in zone](./count_people_in_zone) by [@SkalskiP](https://github.com/SkalskiP) +- [traffic analysis](./traffic_analysis) by [@SkalskiP](https://github.com/SkalskiP) +- [speed estimation](./speed_estimation) by [@SkalskiP](https://github.com/SkalskiP) +- [time in zone](./time_in_zone) by [@SkalskiP](https://github.com/SkalskiP) +- [heatmap and track](./heatmap_and_track/) by [@HinePo](https://github.com/HinePo) diff --git a/examples/compact_mask/README.md b/examples/compact_mask/README.md new file mode 100644 index 0000000..cc8e390 --- /dev/null +++ b/examples/compact_mask/README.md @@ -0,0 +1,655 @@ +# CompactMask โ€” Memory-Efficient Mask Storage + +This example benchmarks `CompactMask`, a new mask representation introduced in `supervision` that replaces dense `(N, H, W)` boolean arrays with a crop-scoped Run-Length Encoding (RLE). The benchmark demonstrates full API compatibility, massive memory savings, and order-of-magnitude annotation speedups โ€” with no change to your existing `Detections` code. + +--- + +## The Problem + +Instance segmentation models return one boolean mask per detected object. `supervision` stores these as a stacked `(N, H, W)` numpy array. + +For a 4K image with 1 000 detected objects: + +``` +1 000 x 3840 x 2160 x 1 byte = 8.3 GB +``` + +At this scale, typical pipelines crash with `MemoryError` before a single frame is annotated. Aerial imagery, satellite tiles, and high-density crowd scenes all hit this wall. + +--- + +## The Solution โ€” Crop-RLE Storage + +`CompactMask` stores each mask as a run-length encoding of its **bounding-box crop** rather than the full image canvas. + +``` +dense (N,H,W) mask โ†’ N x crop_RLE + N x (x1,y1) offset +8.3 GB โ†’ ~280 KB +``` + +The bounding boxes are already present in `Detections.xyxy`, so no extra metadata is required from the caller. + +### Theoretical analysis (4K scene, 80x80 px objects, ~65% fill per bbox) + +Assumptions used throughout the PR design analysis: + +| Parameter | Value | +| ---------------------- | ------------------------ | +| Image size | 4K โ€” 3840x2160 = 8.29 MP | +| Avg bounding box | 80x80 px = 6 400 pxยฒ | +| Fill ratio within bbox | ~65% | +| Avg contour vertices | ~400 pts | +| Avg RLE runs / mask | ~240 (3 runs x 80 rows) | + +#### Space comparison + +| Format | Per object | N=100 | N=1 000 | vs Dense | +| ------------------- | -------------- | ------ | ---------- | --------- | +| **Dense** (current) | 8.29 MB | 829 MB | **8.3 GB** | 1x | +| Local Crop + Offset | 6.4 KB | 640 KB | 6.4 MB | 1 300x | +| **Crop-RLE** โœ“ | ~2 KB | 200 KB | **2 MB** | 4 000x | +| Polygon โš  lossy | ~3.2 KB | 320 KB | 3.2 MB | 2 600x | +| memmap | 8.29 MB (disk) | 829 MB | 8.3 GB | 1x (disk) | + +Crop-RLE beats Local Crop because it only encodes actual pixel runs, skipping the ~35% background pixels within each bounding box. + +#### Encode time: dense array โ†’ format + +| Format | Complexity | N=10 | N=100 | N=1 000 | +| ------------------- | --------------------------------- | ------- | ------- | --------- | +| Local Crop + Offset | O(A) โ€” strided slice from xyxy | ~0.1 ms | ~1 ms | ~10 ms | +| **Crop RLE** | O(A) โ€” scan crop rows for runs | ~0.2 ms | ~2 ms | ~20 ms | +| Polygon | O(P) โ€” `cv2.findContours` on crop | ~2 ms | ~20 ms | ~200 ms | +| memmap | O(I) โ€” write 8.29 MB to disk | ~80 ms | ~800 ms | ~8 000 ms | + +#### Decode time: format โ†’ full (H, W) mask + +Required by `MaskAnnotator`, `mask_iou_batch`, `merge()`, etc. Dominant cost at 4K is **allocating and zeroing a 8.29 MB array**, which is identical across all in-memory formats once full materialisation is needed. + +| Format | N=10 | N=100 | N=1 000 | +| --------------------- | ------ | ------- | --------- | +| Local Crop / Crop RLE | ~3 ms | ~30 ms | ~300 ms | +| Polygon | ~5 ms | ~50 ms | ~500 ms | +| memmap | ~80 ms | ~800 ms | ~8 000 ms | + +#### Decode time: crop-only path (optimised) + +When callers need only the bounding-box region โ€” `MaskAnnotator` crop-paint path, `.area`, `contains_holes`, `filter_segments_by_distance`: + +| Format | Complexity | N=10 | N=100 | N=1 000 | +| ------------------- | -------------------------------- | -------- | ------- | --------- | +| Local Crop + Offset | O(1) โ€” already stored | ~0 ms | ~0 ms | ~0 ms | +| **Crop RLE** โœ“ | O(A) โ€” expand ~240 runs | ~0.02 ms | ~0.2 ms | ~2 ms | +| Polygon | O(A) โ€” `fillPoly` on crop canvas | ~2 ms | ~20 ms | ~200 ms | +| memmap | N/A โ€” always full-size | ~80 ms | ~800 ms | ~8 000 ms | + +Crop RLE's `.crop()` method powers the `MaskAnnotator` optimisation โ€” it never allocates the full image canvas, which is the entire source of the annotation speedup. + +#### IoU / NMS at 1 % bbox overlap rate (sparse aerial scene) + +| Format | Strategy | N=1 000 | +| ------------------- | ------------------------------------- | ---------- | +| Dense (current) | All pairs, 640ยฒ pixel AND | ~10 000 ms | +| Local Crop + Offset | Bbox pre-filter โ†’ pixel IoU | **~5 ms** | +| Crop RLE | Bbox pre-filter โ†’ expand intersection | **~15 ms** | + +At N=1 000 with 1 % overlap, bbox pre-filter reduces 499 500 candidate pairs to ~5 000 overlapping pairs โ€” a ~2 000x reduction in pixel-level work. + +--- + +## Why Crop-RLE Was Chosen over Local Crop + +Both formats compress extremely well; the deciding factors for Crop-RLE are: + +1. **~3x smaller** for masks that are themselves sparse within their bounding box. +2. **COCO RLE interop path** โ€” crop RLE uses column-major (F-order) pixel scan, matching `pycocotools`; to interoperate, you still need to construct a full-image COCO RLE from the crop-scoped encoding (for example by padding/merging runs onto the full-image canvas, or by materialising the crop in the full image and re-encoding). +3. `.area` computed directly from run lengths โ€” no materialisation, no allocation. + +The main trade-off: crop-only decode is O(A) rather than O(1). For the common solid-fill segmentation mask this is negligible (\<0.1 ms per mask). + +--- + +## Operation-by-Operation Speedup Analysis + +This section walks through every `Detections` operation that touches masks and shows exactly why `CompactMask` is faster. All code snippets are taken from the actual implementation. Numbers use the **FHD-200-50%-v600** scenario unless noted (1920 x 1080 image, 200 detections, each mask filling ~50% of the frame, 600-vertex polygons โ€” a realistic hard case with dense fill and complex object boundaries). + +At 50% fill on an FHD image each mask's bounding box covers a large portion of the frame, producing many RLE runs per row. + +--- + +### Memory + +Dense stores one full-resolution bool array per mask: + +``` +N x H x W x 1 byte +200 x 1080 x 1920 x 1 = 414 MB +``` + +Compact stores three lightweight structures: + +```python +self._rles: list[npt.NDArray[np.int32]] # N Python references to small int32 arrays +self._crop_shapes: npt.NDArray[np.int32] # (N, 2) โ€” crop (h, w) per mask +self._offsets: npt.NDArray[np.int32] # (N, 2) โ€” (x1, y1) origin per mask +``` + +Per-mask RLE size at 50% fill with 600-vertex polygons: ~4.7 KB (933 KB / 200). Per-mask dense size: 1920 x 1080 x 1 = 2.1 MB. Per-mask ratio: 2.1 MB / 4.7 KB = **~445x**. + +Scaled to N=200: 200 x 4.7 KB = ~933 KB of RLE data, plus `_crop_shapes` (1.6 KB) and `_offsets` (1.6 KB). Python list + array object overhead roughly doubles the footprint for small N. + +| Component | Dense | Compact | Ratio | +| --------------- | ---------- | ----------- | --------- | +| Mask data | 414 MB | ~933 KB | ~445x | +| Python overhead | negligible | ~933 KB | -- | +| **Total** | **414 MB** | **~1.9 MB** | **~392x** | + +At 5% fill with 8-vertex polygons, the ratio reaches 10 000xโ€“20 000x because crops are tiny and RLEs are extremely short. The benchmark's 4K-200-5%-v8 scenario measures 21 786x (theory) / ~6 000x (malloc). The SAT-200-5%-v8 scenario reaches 62 968x theoretical. + +--- + +### `.area` + +Dense `Detections.area` reads every pixel of every mask: + +```python +# detection/core.py โ€” dense path +return np.array([np.sum(mask) for mask in self.mask]) +# N masks x H x W boolean sums = 200 x 2.1 M = 420 million reads +``` + +Compact delegates to `_rle_area`, which sums only the odd-indexed run lengths (the True-pixel runs) in each RLE: + +```python +# detection/compact_mask.py โ€” _rle_area +return int(np.sum(rle[1::2])) +``` + +```python +# detection/compact_mask.py โ€” CompactMask.area +return np.array([_rle_area(r) for r in self._rles], dtype=np.int64) +``` + +At FHD-200-50%-v600, dense `.area` takes 84.66 ms; compact takes 0.48 ms โ€” a **71x speedup**. At SAT-200-20%-v128 the measured speedup reaches **1 204x** because the dense array is 13.4 GB and each sum must scan the entire canvas. + +| Factor | Reduction | +| ---------------------------------- | ----------- | +| RLE sums vs full-frame pixel reads | ~4 600x | +| int32 arithmetic vs bool reduction | ~2x | +| No (H, W) allocation per mask | latency | +| **Combined** | **~1 000x** | + +--- + +### `filter` / `__getitem__` (boolean index) + +Dense: `masks[bool_array]` triggers NumPy fancy indexing, which allocates a new `(K, H, W)` bool array and copies K full frames: + +```python +# detection/core.py โ€” Detections.__getitem__ +mask = (self.mask[index] if self.mask is not None else None,) +# For dense ndarray, numpy allocates (K, 2160, 3840) and memcpy's K frames +``` + +Compact `CompactMask.__getitem__` converts the boolean index to integer positions and builds a new `CompactMask` from Python list indexing and NumPy fancy indexing on small `(N, 2)` arrays: + +```python +# detection/compact_mask.py โ€” CompactMask.__getitem__ +if isinstance(index, np.ndarray) and index.dtype == bool: + idx_arr = np.where(index)[0] +# ... +new_rles = [self._rles[int(i)] for i in idx_arr] +new_crop_shapes: npt.NDArray[np.int32] = self._crop_shapes[idx_arr] +new_offsets: npt.NDArray[np.int32] = self._offsets[idx_arr] +return CompactMask(new_rles, new_crop_shapes, new_offsets, self._image_shape) +``` + +At FHD-200-50%-v600, dense `filter` takes 14.56 ms; compact takes 0.03 ms โ€” a **500x speedup**. At SAT-200-20%-v128 the speedup reaches **14 757x**. + +| | Dense | Compact | +| ----------- | ----------------------- | ----------------------------------- | +| Data copied | K x H x W (full frames) | K Python references + K x 8 bytes | +| Allocation | new `(K, H, W)` array | new `CompactMask` shell (~trivial) | +| **Speedup** | | **hundreds to tens of thousands x** | + +--- + +### `annotate` (`MaskAnnotator`) + +Dense: for each mask, `MaskAnnotator` indexes the full `(H, W)` array and applies a boolean mask across the entire scene: + +```python +# annotators/core.py โ€” dense path +mask = np.asarray(detections.mask[detection_idx], dtype=bool) +colored_mask[mask] = color.as_bgr() +``` + +Each `detections.mask[detection_idx]` for a dense array yields a full `(H, W)` view, and the boolean indexing scans all pixels. + +Compact: the annotator detects `CompactMask` and paints only the crop region: + +```python +# annotators/core.py โ€” compact path +x1 = int(compact_mask.offsets[detection_idx, 0]) +y1 = int(compact_mask.offsets[detection_idx, 1]) +crop_m = compact_mask.crop(detection_idx) +crop_h, crop_w = crop_m.shape +colored_mask[y1 : y1 + crop_h, x1 : x1 + crop_w][crop_m] = color.as_bgr() +``` + +`compact_mask.crop()` decodes the RLE into a `(crop_h, crop_w)` array. At FHD-200-50%-v600, dense `annotate` takes 848.95 ms; compact takes 32.67 ms โ€” a **22x speedup**. At SAT-200-20%-v128 the speedup reaches **89x**. + +| Factor | Reduction | +| -------------------------------------------------- | ------------------- | +| Crop decode vs full-frame boolean index (per mask) | crop-size dependent | +| No full `(H, W)` allocation per integer index | latency | +| x N masks | compounds | +| **Combined** | **~26 โ€“ 400x** | + +--- + +### IoU (`mask_iou_batch` / `compact_mask_iou_batch`) + +Dense `mask_iou_batch` on N=200, FHD: + +```python +# detection/utils/iou_and_nms.py โ€” _mask_iou_batch_split +intersection_area = np.logical_and(masks_true[:, None], masks_detection).sum( + axis=(2, 3) +) +# shape (200, 200, 1080, 1920) โ€” ~80 billion boolean ops +# .sum(axis=(2,3)) for intersection counts +# memory_limit splits this into chunks capped at 5 GB scratch +``` + +Compact `compact_mask_iou_batch` โ€” three layered optimisations: + +**1. Vectorised bbox pre-filter โ€” O(Nยฒ) array ops, zero decoding** + +```python +ix1: npt.NDArray[np.int32] = np.maximum(x1a[:, None], x1b[None, :]) +iy1: npt.NDArray[np.int32] = np.maximum(y1a[:, None], y1b[None, :]) +ix2: npt.NDArray[np.int32] = np.minimum(x2a[:, None], x2b[None, :]) +iy2: npt.NDArray[np.int32] = np.minimum(y2a[:, None], y2b[None, :]) +bbox_overlap: npt.NDArray[np.bool_] = (ix1 <= ix2) & (iy1 <= iy2) +``` + +At 5% fill, two random masks overlap with probability ~4%. ~96% of the Nยฒ pairs get IoU = 0 for free โ€” no pixel work at all. + +**2. Sub-crop decode โ€” compare only the intersection region** + +```python +ox_a, oy_a = int(x1a[i]), int(y1a[i]) +sub_a = crops_a[i][ly1 - oy_a : ly2 - oy_a + 1, lx1 - ox_a : lx2 - ox_a + 1] + +ox_b, oy_b = int(x1b[j]), int(y1b[j]) +sub_b = crops_b[j][ly1 - oy_b : ly2 - oy_b + 1, lx1 - ox_b : lx2 - ox_b + 1] + +inter = int(np.logical_and(sub_a, sub_b).sum()) +``` + +The intersection sub-region of two overlapping crops is typically far smaller than the full frame. + +**3. Crop caching โ€” each mask decoded at most once** + +```python +if i not in crops_a: + crops_a[i] = masks_true.crop(i) +``` + +Area is obtained from `_rle_area` (sum odd-indexed runs), never touching the pixel grid: + +```python +areas_a: npt.NDArray[np.int64] = masks_true.area +``` + +At FHD-200-50%-v600, dense IoU takes 23 915 ms; compact takes 51.58 ms โ€” a **446x speedup**. At 5% fill / sparse scenarios the speedup is even larger because fewer bbox pairs overlap. + +| Factor | Reduction | +| ------------------------------------ | --------------- | +| Bbox pre-filter at sparse fill | 25x | +| Sub-crop vs full frame per pair | ~200x | +| Area from RLE, not `sum(axis=(1,2))` | ~10x | +| No 5 GB scratch allocation | latency | +| **Combined** | **~100 โ€“ 500x** | + +At 20% fill the gaps close โ€” more pairs overlap, larger crops โ€” speedup drops toward the lower end of the range. + +--- + +### NMS (`mask_non_max_suppression`) + +Both dense and compact paths now call `mask_iou_batch(masks, masks)` directly, computing exact mask IoU on the original (unresized) masks. There is no intermediate resize step. + +```python +# detection/utils/iou_and_nms.py โ€” NMS (both paths) +ious = mask_iou_batch(masks, masks, overlap_metric) +``` + +`mask_iou_batch` dispatches internally: when passed a `CompactMask` it calls `compact_mask_iou_batch`, applying all three IoU optimisations (bbox pre-filter, sub-crop decode, crop caching). When passed a dense ndarray it runs the chunked pixel-AND path. + +All three IoU optimisations apply to the compact path: + +| Factor | Reduction | +| ------------------------------------- | ---------------------------- | +| Bbox pre-filter eliminates most pairs | 25x at sparse fill | +| Sub-crop decode for remaining pairs | ~200x | +| Area from RLE, not pixel sum | ~10x | +| **Combined** | **same as IoU: ~100 โ€“ 500x** | + +At FHD-200-50%-v600, dense NMS takes 5 231 ms; compact takes 48.15 ms โ€” a **481x speedup**. Dense IoU/NMS is skipped for scenarios above 1 GB (4K-200 and SAT-200 tiers); compact NMS still runs on those. + +--- + +### `merge` (`Detections.merge`) + +Dense: `np.vstack` allocates a new `(N1+N2, H, W)` array and copies both halves: + +```python +# detection/core.py โ€” dense merge path +return np.vstack([np.asarray(m) for m in masks]) +# Merging two 100-mask sets at FHD: 2 x 100 x 2.1 MB = 414 MB copied +``` + +Compact: `CompactMask.merge` extends a Python list and concatenates two small int32 arrays: + +```python +# detection/compact_mask.py โ€” CompactMask.merge +new_rles: list[npt.NDArray[np.int32]] = [] +for m in masks_list: + new_rles.extend(m._rles) + +new_crop_shapes: npt.NDArray[np.int32] = np.concatenate( + [m._crop_shapes for m in masks_list], axis=0 +) +new_offsets: npt.NDArray[np.int32] = np.concatenate( + [m._offsets for m in masks_list], axis=0 +) +``` + +`list.extend` copies N reference pointers. `np.concatenate` on `(N, 2)` int32 arrays copies N x 8 bytes per array. + +At FHD-200-50%-v600, dense merge takes 29.71 ms; compact takes 0.03 ms โ€” a **929x speedup**. At SAT-200-20%-v128 the speedup reaches **89 046x**. + +| | Dense | Compact | +| ----------- | ----------------------- | -------------------------- | +| Data moved | N x H x W (full frames) | N references + N x 8 bytes | +| Allocation | new `(N, H, W)` array | new `CompactMask` shell | +| **Speedup** | | **effectively free** | + +**Note:** `Detections.merge` calls `is_empty()` on each input. Before the `len(xyxy) > 0` short-circuit was added, `is_empty()` invoked `__eq__` which called `np.array_equal(self.to_dense(), ...)` โ€” materialising the entire `(N, H, W)` CompactMask to dense just to check emptiness. The fix: + +```python +# detection/core.py โ€” Detections.is_empty (fixed) +if len(self.xyxy) > 0: + return False +``` + +This O(1) check avoids the O(N x H x W) dense materialisation that previously dominated compact merge time. + +--- + +### `offset` / `with_offset` (`InferenceSlicer` tile stitching) + +Dense `move_masks`: allocates a new `(N, new_H, new_W)` array and copies each mask with shifted slice coordinates โ€” O(N x H x W): + +```python +# detection/utils/masks.py โ€” move_masks +mask_array = np.full((masks.shape[0], resolution_wh[1], resolution_wh[0]), False) +# ... source/destination slicing logic ... +mask_array[:, dst_y1:dst_y2, dst_x1:dst_x2] = masks[:, src_y1:src_y2, src_x1:src_x2] +``` + +Compact `with_offset(dx, dy)`: vectorised bounds check first. All new bounding-box positions are computed in a single numpy op. When none overflow the new canvas โ€” the common case in `InferenceSlicer` โ€” the RLE data is not touched at all: + +```python +# detection/compact_mask.py โ€” CompactMask.with_offset (fast path) +new_offsets = self._offsets + np.array([dx, dy], dtype=np.int32) # O(N) numpy +needs_clip = (x1s < 0) | (y1s < 0) | (x2s >= new_w) | (y2s >= new_h) +if not needs_clip.any(): + return CompactMask( + list(self._rles), self._crop_shapes.copy(), new_offsets, new_image_shape + ) +``` + +When a crop does overflow (e.g. object at a tile edge), only that crop is decoded, sliced, and re-encoded. Masks fully outside bounds get a 1x1 all-False stub without any decoding. + +At FHD-200-50%-v600, dense offset takes 42.30 ms; compact takes 0.02 ms โ€” a **2 016x speedup**. At SAT-200-20%-v128 the speedup reaches **290 779x**. + +| | Dense | Compact (no-clip fast path) | +| ----------------- | -------------------------------------- | ------------------------------------ | +| Work per mask | allocate `(new_H, new_W)` + copy H x W | add scalar to offset row โ€” O(1) | +| N=200 at FHD | 200 x 2.1 MB = **414 MB** alloc + copy | two numpy ops on `(N, 2)` int32 | +| Output allocation | new `(N, new_H, new_W)` | shared RLE list + new `(N, 2)` array | +| **Speedup** | | **effectively free (>1 000x)** | + +In the `InferenceSlicer` pipeline the canvas is always expanded by the tile offset, so no crop ever overflows โ€” the fast path is always taken. Clipping only activates for objects that genuinely straddle the image boundary. + +--- + +### `centroids` (`calculate_masks_centroids`) + +Dense: `np.tensordot` reads every pixel of every mask to compute weighted coordinate sums: + +```python +# detection/utils/masks.py โ€” dense centroid path +vertical_indices, horizontal_indices = np.indices((height, width)) + 0.5 +# np.tensordot(masks, indices, axes=([1, 2], [0, 1])) +# reads all N x H x W values +``` + +Compact: per-crop loop decodes only the bounding-box region and computes centroids within that crop: + +```python +# detection/utils/masks.py โ€” compact centroid path +crop = masks.crop(i) +crop_h, crop_w = crop.shape +x1 = int(masks.offsets[i, 0]) +y1 = int(masks.offsets[i, 1]) +# ... +crop_rows, crop_cols = np.indices((crop_h, crop_w)) +cx = float(np.sum((crop_cols + 0.5)[crop])) / total + x1 +cy = float(np.sum((crop_rows + 0.5)[crop])) / total + y1 +``` + +At FHD-200-50%-v600, dense centroids takes 1 133.68 ms; compact takes 60.39 ms โ€” a **13x speedup**. At SAT-200-20%-v128 the speedup reaches **857x** because the dense path must allocate and scan a 13.4 GB array. + +| Factor | Reduction | +| ----------------------------------------- | ------------------- | +| Crop area vs full frame (per mask) | fill-dependent | +| No global `np.indices((H, W))` allocation | saves large float64 | +| **Combined (N=200)** | **~19 โ€“ 1 000x** | + +--- + +### Summary + +Measured speedups at the **FHD-200-50%-v600** operating point (dense fill, complex polygons โ€” a realistic hard case). Dense baseline = 1x. + +| Operation | Dense cost | Compact cost | Speedup | +| ---------------- | ----------- | ------------ | ------- | +| Memory | 414 MB | ~1.9 MB | ~392x | +| `.area` | 84.66 ms | 0.48 ms | 71x | +| `filter` | 14.56 ms | 0.03 ms | 500x | +| `annotate` | 848.95 ms | 32.67 ms | 22x | +| `mask_iou_batch` | 23 915 ms | 51.58 ms | 446x | +| NMS | 5 231 ms | 48.15 ms | 481x | +| `merge` | 29.71 ms | 0.03 ms | 929x | +| `with_offset` | 42.30 ms | 0.02 ms | 2 016x | +| `centroids` | 1 133.68 ms | 60.39 ms | 13x | + +All speedups are larger at sparser fill fractions and larger resolutions. At SAT-200-20%-v128, `.area` reaches 1 204x and `merge` reaches 89 046x. At the sparsest scenarios (5% fill, 8-vertex polygons), memory ratios exceed 60 000x. + +--- + +## Drop-In Compatibility + +`CompactMask` implements the same duck-typed interface as `np.ndarray`: + +```python +import supervision as sv +from supervision.detection.compact_mask import CompactMask + +# Build from an existing dense (N, H, W) bool array: +compact = CompactMask.from_dense(masks_dense, xyxy, image_shape=(H, W)) + +# Use exactly like a dense mask โ€” no other code changes needed: +detections = sv.Detections(xyxy=xyxy, mask=compact, class_id=class_ids) + +# Filtering, merging, area โ€” all work transparently: +filtered = detections[confidence > 0.5] +areas = detections.area # RLE sum, no materialisation +merged = sv.Detections.merge([det_a, det_b]) + +# MaskAnnotator works without any change: +annotated = sv.MaskAnnotator().annotate(frame, detections) + +# Materialise back to dense when you need raw numpy: +dense_again = compact.to_dense() # (N, H, W) bool +``` + +Supported indexing patterns: + +| Expression | Returns | +| ------------------ | ---------------------------- | +| `mask[i]` (int) | Dense `(H, W)` bool array | +| `mask[bool_array]` | New `CompactMask` (filtered) | +| `mask[slice]` | New `CompactMask` | +| `np.asarray(mask)` | Dense `(N, H, W)` bool array | + +--- + +## Benchmark + +Run on any machine โ€” no GPU or real model required: + +```bash +uv run python examples/compact_mask/benchmark.py +``` + +For a focused benchmark of the Roboflow inference-result parser API, run: + +```bash +uv run python examples/compact_mask/bench_inference_api.py +``` + +This script downloads all supervision image assets plus the middle frame from every supervision video asset by default, runs one real segmentation inference per source image, requests native RLE masks from Inference, freezes that result, and then compares parser performance: + +```python +sv.Detections.from_inference(result) +sv.Detections.from_inference(result, compact_masks=True) +``` + +Timing repetitions, warmups, confidence, IoU, response mask format, and the default model live as constants in `bench_inference_api.py`. + +Inference runs and segmentation-derived box fields are outside the timed benchmark loop. By default the script uses `rfdetr-seg-large` with `response_mask_format="rle"`; set `BENCH_INFERENCE_MODEL_ID` to override the model. Set `ROBOFLOW_API_KEY` when your model requires authentication. Sources where the model returns no native RLE segmentation masks are skipped because there is no RLE parser work to benchmark. `rfdetr-large` is a valid local Inference model id, but it is object detection only; use an `rfdetr-seg-*` model for instance segmentation. + +Run one specific supervision image or video asset with `--asset`: + +```bash +uv run python examples/compact_mask/bench_inference_api.py --asset people-walking +uv run python examples/compact_mask/bench_inference_api.py --asset soccer +uv run python examples/compact_mask/bench_inference_api.py --asset vehicles +uv run python examples/compact_mask/bench_inference_api.py --asset people-walking-video +``` + +The output reports image size, segmented objects, median parser time, peak traced allocations, mask storage, and parser speedup (`dense parser time / compact parser time`). + +**Speedup column:** The `speedup` value reflects allocation savings โ€” how much time is saved by skipping the dense `(N, H, W)` bool-stack allocation โ€” not a faster RLE decode. Compact RLE arithmetic is typically slower than the dense NumPy path. The net result: + +- **Compact is faster** only when the dense `(N, H, W)` bool-stack allocation dominates โ€” large images with many sparse masks where avoiding that allocation outweighs the RLE arithmetic cost. +- **Compact is slower** for small images or dense/overlapping masks, where Python RLE arithmetic dominates and the allocation cost is negligible. +- **The primary guaranteed benefit is memory**: compact masks use roughly 99% less memory than dense stacks for typical segmentation output, regardless of which parse direction is faster. + +The default run includes a `synthetic-dense-64` row (64ร—64 image, 4 fully-filled masks) to demonstrate the adversarial regime where compact is slower than dense. For each real source with segmentation masks, the script also writes a validation overlay to `examples/compact_mask/outputs/*_segmentations.jpg`. + +### Sample results โ€” inference API + +Measured on macOS Apple M4 Max, 50 reps after 3 warmups, using `rfdetr-seg-large` via Roboflow Inference. + +| src | res | seg | dense ms | CM ms | speedup | peak MB (dense/compact) | mask MB (dense/compact) | ok | +| -------------------------- | --------- | --- | -------- | ----- | ------- | ----------------------- | ----------------------- | --- | +| synthetic-dense-64 | 64ร—64 | 4 | 0.03 | 0.11 | 0.31ร— | 0.04 / 0.05 | 0.02 / 0.00 | โœ“ | +| people-walking.jpg | 1920ร—1080 | 53 | 85.56 | 12.55 | 6.82ร— | 219.86 / 0.11 | 109.90 / 0.02 | โœ“ | +| soccer.jpg | 398ร—224 | 21 | 1.36 | 1.07 | 1.27ร— | 3.77 / 0.05 | 1.87 / 0.00 | โœ“ | +| vehicles.mp4#269 | 3840ร—2160 | 7 | 46.03 | 2.60 | 18ร— | 116.13 / 0.07 | 58.06 / 0.00 | โœ“ | +| milk-bottling-plant.mp4#94 | 1920ร—1080 | 9 | 15.61 | 11.57 | 1.35ร— | 37.34 / 0.53 | 18.66 / 0.03 | โœ“ | +| vehicles-2.mp4#637 | 1920ร—1080 | 47 | 76.87 | 13.59 | 5.66ร— | 194.97 / 0.13 | 97.46 / 0.03 | โœ“ | +| grocery-store.mp4#501 | 3840ร—2160 | 4 | 27.20 | 4.36 | 6.24ร— | 66.36 / 0.22 | 33.18 / 0.01 | โœ“ | +| subway.mp4#649 | 2160ร—3840 | 42 | 325.71 | 32.21 | 10ร— | 696.78 / 0.80 | 348.36 / 0.09 | โœ“ | +| market-square.mp4#237 | 2160ร—3840 | 96 | 732.98 | 27.24 | 27ร— | 1592.61 / 0.22 | 796.26 / 0.05 | โœ“ | +| people-walking.mp4#170 | 1920ร—1080 | 60 | 100.99 | 12.69 | 7.96ร— | 248.89 / 0.12 | 124.42 / 0.02 | โœ“ | +| beach-1.mp4#223 | 3840ร—2160 | 33 | 223.50 | 13.39 | 17ร— | 547.47 / 0.12 | 273.72 / 0.02 | โœ“ | +| basketball-1.mp4#238 | 1920ร—1080 | 2 | 3.61 | 2.05 | 1.76ร— | 8.30 / 0.15 | 4.15 / 0.01 | โœ“ | +| skiing.mp4#176 | 1920ร—1080 | 11 | 16.47 | 3.07 | 5.37ร— | 45.63 / 0.08 | 22.81 / 0.01 | โœ“ | + +- **seg** โ€” number of instance segmentations returned by the model +- **dense ms / CM ms** โ€” median parse time for `from_inference()` vs `from_inference(compact_masks=True)` +- **speedup** โ€” dense / compact parse time; values below 1ร— (e.g., synthetic-dense-64) indicate the adversarial regime where RLE arithmetic cost exceeds allocation savings +- **peak MB** โ€” peak traced allocations during parsing (dense / compact) +- **mask MB** โ€” mask storage only (dense / compact); compact is typically 100โ€“5 000ร— smaller +- **ok** โ€” `compact.to_dense()` pixel-exactly matches dense masks + +Six image tiers x three fill fractions (5 / 20 / 50 %) x three vertex counts (8 / 128 / 600): + +| Tier | Resolution | Objects | Dense array | Notes | +| ------- | ---------- | ------- | ----------- | ------------------------------------ | +| FHD-100 | 1920x1080 | 100 | 0.21 GB | Full operations including IoU+NMS | +| FHD-200 | 1920x1080 | 200 | 0.41 GB | Full operations including IoU+NMS | +| FHD-400 | 1920x1080 | 400 | 0.83 GB | Full operations including IoU+NMS | +| 4K-100 | 3840x2160 | 100 | 0.83 GB | Full operations including IoU+NMS | +| 4K-200 | 3840x2160 | 200 | 1.66 GB | Dense IoU+NMS skipped (array > 1 GB) | +| SAT-200 | 8192x8192 | 200 | 13.4 GB | Dense IoU+NMS skipped (array > 1 GB) | + +Dense timing is skipped automatically when the dense IoU/NMS array would exceed 1 GB (`IOU_DENSE_SKIP_GB`), preventing swap thrashing. All dense ops are skipped above 16 GB (`DENSE_SKIP_GB`); no scenario in the current matrix reaches that threshold. Memory is always reported as theoretical `NxHxW` bytes. + +### Sample results (macOS, Apple M4 Max, REPS=4) + +| Scenario | Dense mem | Compact theor. | Mem x | Area x | Filter x | Annot x | IoU x | NMS x | Merge x | Offset x | Centroids x | +| ---------------- | --------- | -------------- | ------- | ------ | -------- | ------- | ----- | ----- | -------- | -------- | ----------- | +| FHD-100-5%-v8 | 207 MB | 28 KB | 7 418x | โ€” | โ€” | โ€” | โ€” | โ€” | โ€” | โ€” | โ€” | +| FHD-100-50%-v600 | 207 MB | 913 KB | 227x | โ€” | โ€” | โ€” | โ€” | โ€” | โ€” | โ€” | โ€” | +| FHD-200-50%-v600 | 415 MB | 933 KB | 445x | 71x | 500x | 22x | 446x | 481x | 929x | 2 016x | 13x | +| FHD-400-5%-v8 | 829 MB | 60 KB | 13 937x | โ€” | โ€” | โ€” | โ€” | โ€” | โ€” | โ€” | โ€” | +| 4K-100-5%-v8 | 829 MB | 53 KB | 15 554x | โ€” | โ€” | โ€” | โ€” | โ€” | โ€” | โ€” | โ€” | +| 4K-100-20%-v128 | 829 MB | 586 KB | 1 415x | โ€” | โ€” | โ€” | โ€” | โ€” | โ€” | โ€” | โ€” | +| 4K-200-5%-v8 | 1 659 MB | 76 KB | 21 786x | โ€” | โ€” | โ€” | โ€” | โ€” | โ€” | โ€” | โ€” | +| SAT-200-5%-v8 | 13 422 MB | 213 KB | 62 968x | 6 942x | 30 255x | 204x | โ€  | โ€  | 105 545x | 251 629x | 2 173x | +| SAT-200-20%-v128 | 13 422 MB | 2 596 KB | 5 171x | 1 204x | 14 757x | 89x | โ€  | โ€  | 89 046x | 290 779x | 857x | +| SAT-200-50%-v600 | 13 422 MB | 14 222 KB | 944x | โ€” | โ€” | โ€” | โ€  | โ€  | โ€” | โ€” | โ€” | + +- **Compact theor.** โ€” sum of internal numpy buffer `nbytes` +- **Mem x** โ€” dense / compact theoretical ratio +- **Area x / Filter x / Annot x / IoU x / NMS x / Merge x / Offset x / Centroids x** โ€” compact speedup over dense for each operation +- **โ€ ** โ€” dense IoU+NMS skipped (dense array > 1 GB); compact still runs and is timed +- **โ€”** โ€” not shown; full per-scenario tables are printed by the benchmark script + +All non-skipped scenarios pass: pixel-perfect annotation, exact area, lossless `to_dense()` roundtrip. + +--- + +## Use-Cases + +- **Aerial / satellite imagery** โ€” thousands of small objects on large tiles; dense masks exhaust RAM before inference completes. +- **High-density crowd / cell segmentation** โ€” N > 500 on FHD already requires several GB of mask storage per batch. +- **Real-time annotation pipelines** โ€” crop-paint cuts annotation from seconds to milliseconds at 4K resolution. +- **Long-running tracking** โ€” accumulated `Detections` across many frames stay in kilobytes rather than gigabytes. +- **`InferenceSlicer`** โ€” `with_offset()` adjusts crop origins directly when stitching tile results; no dense materialisation needed. + +--- + +## Limitations + +- `CompactMask` is **not** a full `np.ndarray`. Call `.to_dense()` before passing to code that requires arbitrary ndarray methods (`astype`, `reshape`, `ravel`, `any`, `all`, โ€ฆ). +- RLE format is **column-major (F-order), crop-scoped** โ€” pixel-scan order matches COCO / pycocotools, but crop scope differs from full-image scope. Use `.to_dense()` to materialize a full-image dense mask, then encode that mask to COCO RLE before passing it to pycocotools. +- `from_dense()` requires the input `(N, H, W)` array to fit in memory. For truly OOM-scale data, build `CompactMask` per-detection directly from model output crops rather than from a pre-allocated dense stack. + +--- + +## Files + +| File | Description | +| ------------------------ | --------------------------------------------------- | +| `benchmark.py` | Full benchmark across FHD / 4K / satellite tiers | +| `bench_inference_api.py` | Focused dense vs compact `from_inference` benchmark | +| `README.md` | This file | diff --git a/examples/compact_mask/bench_inference_api.py b/examples/compact_mask/bench_inference_api.py new file mode 100644 index 0000000..aafa6fe --- /dev/null +++ b/examples/compact_mask/bench_inference_api.py @@ -0,0 +1,505 @@ +"""Benchmark dense vs compact Roboflow RLE ingestion. + +Run with: + uv run python examples/compact_mask/bench_inference_api.py + +The benchmark downloads supervision assets, runs one segmentation inference per +source image, then times dense vs compact parsing of that fixed inference result. +""" + +from __future__ import annotations + +import argparse +import gc +import os +import statistics +import time +import tracemalloc +from collections.abc import Callable +from dataclasses import dataclass +from pathlib import Path +from typing import Any + +import cv2 +import numpy as np +from rich import box +from rich.console import Console +from rich.table import Table + +import supervision as sv +from supervision.assets import ImageAssets, VideoAssets, download_assets +from supervision.config import CLASS_NAME_DATA_FIELD +from supervision.detection.compact_mask import CompactMask + +console = Console(width=120, force_terminal=True) + +# Default segmentation model; use an rfdetr-seg-* id so masks are returned. +MODEL_ID = "rfdetr-seg-large" +# Environment variable that can override MODEL_ID without adding CLI noise. +MODEL_ID_ENV = "BENCH_INFERENCE_MODEL_ID" +# Optional Roboflow API key for models that require authentication. +API_KEY_ENV = "ROBOFLOW_API_KEY" +# Model confidence threshold used only for the one inference call per source. +CONFIDENCE = 0.2 +# Model IoU threshold used only for the one inference call per source. +IOU = 0.5 +# Request native RLE masks so the benchmark measures RLE parser ingestion. +RESPONSE_MASK_FORMAT = "rle" +# Parser timing repetitions; inference itself is not repeated. +REPETITIONS = 50 +# Untimed parser warmup calls before measurements. +WARMUP = 3 +# Visual segmentation overlays for manual validation. +ARTIFACT_DIR = Path("examples/compact_mask/outputs") + +ASSETS = {Path(asset.filename).stem: asset for asset in ImageAssets} +for video_asset in VideoAssets: + key = Path(video_asset.filename).stem + ASSETS[key if key not in ASSETS else f"{key}-video"] = video_asset + + +@dataclass +class ApiBenchmarkResult: + """Result for one dense-vs-compact parser benchmark run.""" + + source: str + resolution: str + segmented_objects: int + dense_s: float + compact_s: float + dense_peak_bytes: int + compact_peak_bytes: int + dense_mask_bytes: int + compact_mask_bytes: int + pixel_perfect: bool + + +def load_image_from_asset(path: Path | None, asset: str) -> tuple[np.ndarray, str]: + """Return ``(image, label)`` for an image or video middle frame.""" + if path is not None: + image = cv2.imread(str(path)) + if image is None: + raise FileNotFoundError(f"Could not read image: {path}") + return image, str(path) + + asset_obj = ASSETS[asset] + asset_path = Path(download_assets(asset_obj)) + if isinstance(asset_obj, ImageAssets): + image = cv2.imread(str(asset_path)) + if image is None: + raise FileNotFoundError(f"Could not read image: {asset_path}") + return image, str(asset_path) + + video = cv2.VideoCapture(str(asset_path)) + if not video.isOpened(): + raise FileNotFoundError(f"Could not read video: {asset_path}") + frame_count = int(video.get(cv2.CAP_PROP_FRAME_COUNT)) + frame_index = max(0, frame_count // 2) + if frame_index: + video.set(cv2.CAP_PROP_POS_FRAMES, frame_index) + ok, frame = video.read() + video.release() + if not ok or frame is None: + raise FileNotFoundError(f"Could not read middle frame: {asset_path}") + return frame, f"{asset_path}#{frame_index}" + + +def freeze_result(inference_result: Any) -> dict[str, Any]: + """Convert one Inference result to a reusable dictionary.""" + if isinstance(inference_result, dict): + return inference_result + if hasattr(inference_result, "model_dump"): + return inference_result.model_dump(exclude_none=True, by_alias=True) + if hasattr(inference_result, "dict"): + return inference_result.dict(exclude_none=True, by_alias=True) + raise TypeError( + f"Expected dict-like Inference result, got {type(inference_result).__name__}" + ) + + +def count_rle_predictions(result: dict[str, Any]) -> int: + """Return the number of predictions carrying Roboflow RLE masks.""" + return sum( + isinstance(prediction.get("rle") or prediction.get("rle_mask"), dict) + for prediction in result.get("predictions", []) + ) + + +def synthetic_dense_small_result() -> tuple[np.ndarray, str, dict[str, Any]]: + """Return a small dense-mask adversarial payload where compact parsing is slower. + + Uses a 64x64 image with 4 fully-filled masks. At this scale the dense + ``(N, H, W)`` allocation cost is negligible; Python RLE arithmetic dominates, + making compact ingestion slower than the dense NumPy path. Included as a + clearly labeled adversarial row in the default benchmark run to show that + the ``speedup`` column reflects allocation savings, not decode speed. + """ + height, width = 64, 64 + image = np.zeros((height, width, 3), dtype=np.uint8) + predictions = [ + { + "x": width / 2, + "y": height / 2, + "width": width, + "height": height, + "confidence": 0.9, + "class_id": index, + "class": f"dense-{index}", + "rle": {"size": [height, width], "counts": [0, height * width]}, + } + for index in range(4) + ] + return ( + image, + "synthetic-dense-64", + { + "predictions": predictions, + "image": {"width": width, "height": height}, + }, + ) + + +def derive_boxes_from_rle_masks(result: dict[str, Any]) -> dict[str, Any]: + """Set prediction boxes from native RLE segmentation masks.""" + predictions = [] + for prediction in result.get("predictions", []): + rle = prediction.get("rle") or prediction.get("rle_mask") + if not isinstance(rle, dict): + predictions.append(prediction) + continue + + height, width = rle["size"] + mask = sv.rle_to_mask(rle["counts"], resolution_wh=(int(width), int(height))) + if not mask.any(): + predictions.append(prediction) + continue + + x1, y1, x2, y2 = sv.mask_to_xyxy(mask[np.newaxis, ...])[0] + predictions.append( + { + **prediction, + "x": float((x1 + x2) / 2), + "y": float((y1 + y2) / 2), + "width": float(x2 - x1), + "height": float(y2 - y1), + } + ) + return {**result, "predictions": predictions} + + +def artifact_path(source: str) -> Path: + """Return the segmentation validation artifact path for a source.""" + source_path, separator, frame = source.partition("#") + stem = Path(source_path).stem + suffix = f"_frame_{frame}" if separator else "" + return ARTIFACT_DIR / f"{stem}{suffix}_segmentations.jpg" + + +def detection_labels(detections: sv.Detections) -> list[str]: + """Return compact class/confidence labels for validation artifacts.""" + raw_class_names = detections.get_data(CLASS_NAME_DATA_FIELD) + class_names = ( + raw_class_names.astype(str).tolist() + if isinstance(raw_class_names, np.ndarray) + else [""] * len(detections) + ) + + labels = [] + for index in range(len(detections)): + class_name = class_names[index] if index < len(class_names) else "" + confidence = ( + "" + if detections.confidence is None + else f" {detections.confidence[index]:.2f}" + ) + labels.append(f"{class_name}{confidence}".strip() or str(index)) + return labels + + +def save_segmentation_artifact( + image: np.ndarray, + result: dict[str, Any], + source: str, +) -> Path | None: + """Draw parsed segmentation masks and save a validation artifact.""" + detections = sv.Detections.from_inference(result) + if detections.mask is None: + return None + + annotated = image.copy() + annotated = sv.MaskAnnotator( + color_lookup=sv.ColorLookup.INDEX, + opacity=0.45, + ).annotate(scene=annotated, detections=detections) + annotated = sv.LabelAnnotator( + color_lookup=sv.ColorLookup.INDEX, + text_scale=0.35, + text_padding=4, + ).annotate( + scene=annotated, + detections=detections, + labels=detection_labels(detections), + ) + + path = artifact_path(source) + path.parent.mkdir(parents=True, exist_ok=True) + if not cv2.imwrite(str(path), annotated): + raise OSError(f"Could not write segmentation artifact: {path}") + return path + + +def load_inference_model(model_id: str, api_key: str | None) -> Any: + """Load the requested Inference model.""" + try: + from inference import get_model + except ImportError as exc: + raise ImportError( + "Install the `inference` package to run this benchmark." + ) from exc + + model_kwargs = {"api_key": api_key} if api_key is not None else {} + return get_model(model_id=model_id, **model_kwargs) + + +def run_inference_once( + image: np.ndarray, + model: Any, + model_id: str, + confidence: float, + iou: float, +) -> dict[str, Any] | None: + """Run one real segmentation inference and return a frozen result.""" + # Inference still serializes instance segmentations with x/y/width/height. + # Derive those fields from the RLE masks so the benchmark uses segmentations, + # not the model-reported detector boxes, as the source of truth. + result = derive_boxes_from_rle_masks( + freeze_result( + model.infer( + image, + confidence=confidence, + iou=iou, + response_mask_format=RESPONSE_MASK_FORMAT, + )[0] + ) + ) + rle_count = count_rle_predictions(result) + if rle_count == 0: + console.print( + f"[yellow]skipped[/yellow] {model_id}: no native RLE segmentation " + f"predictions for response_mask_format={RESPONSE_MASK_FORMAT!r}" + ) + return None + return result + + +def median_seconds(fn: Callable[[], object], reps: int, warmup: int) -> float: + """Return median runtime for ``fn``.""" + for _ in range(warmup): + fn() + gc.collect() + + timings = [] + for _ in range(reps): + start = time.perf_counter() + fn() + timings.append(time.perf_counter() - start) + return statistics.median(timings) + + +def peak_bytes(fn: Callable[[], object]) -> int: + """Return peak traced allocations for one call.""" + gc.collect() + tracemalloc.start() + fn() + _, peak = tracemalloc.get_traced_memory() + tracemalloc.stop() + return int(peak) + + +def dense_mask_bytes(detections: sv.Detections) -> int: + """Return dense mask storage bytes.""" + return 0 if detections.mask is None else int(np.asarray(detections.mask).nbytes) + + +def compact_mask_bytes(detections: sv.Detections) -> int: + """Return compact mask storage bytes.""" + if not isinstance(detections.mask, CompactMask): + return 0 + return sum(rle.nbytes for rle in detections.mask._rles) + + +def _fmt_ratio(ratio: float) -> str: + """Format a speedup/compression ratio with colour coding.""" + fmt = f"{ratio:.0f}x" if ratio >= 10 else f"{ratio:.2f}x" + if ratio >= 10: + return f"[green]{fmt}[/green]" + elif ratio >= 1: + return f"[yellow]{fmt}[/yellow]" + else: + return f"[red]{fmt}[/red]" + + +def _fmt_mb(num_bytes: int) -> str: + """Format bytes as compact megabytes.""" + return f"{num_bytes / 1e6:.2f}" + + +def run_benchmark( + source: str, + image: np.ndarray, + result: dict[str, Any], + reps: int, + warmup: int, +) -> ApiBenchmarkResult: + """Run one dense-vs-compact parser benchmark.""" + + # Benchmark the public Roboflow/Inference adapter; RLE masks enter through + # the result payload and should stay compact when compact_masks=True. + def dense() -> sv.Detections: + return sv.Detections.from_inference(result) + + def compact() -> sv.Detections: + return sv.Detections.from_inference(result, compact_masks=True) + + dense_once = dense() + compact_once = compact() + if not isinstance(dense_once.mask, np.ndarray): + raise TypeError(f"Expected dense ndarray mask, got {type(dense_once.mask)}") + if not isinstance(compact_once.mask, CompactMask): + raise TypeError(f"Expected CompactMask, got {type(compact_once.mask)}") + np.testing.assert_array_equal(compact_once.mask.to_dense(), dense_once.mask) + + dense_s = median_seconds(dense, reps, warmup) + compact_s = median_seconds(compact, reps, warmup) + dense_peak = peak_bytes(dense) + compact_peak = peak_bytes(compact) + + return ApiBenchmarkResult( + source=source, + resolution=f"{image.shape[1]}x{image.shape[0]}", + segmented_objects=len(dense_once), + dense_s=dense_s, + compact_s=compact_s, + dense_peak_bytes=dense_peak, + compact_peak_bytes=compact_peak, + dense_mask_bytes=dense_mask_bytes(dense_once), + compact_mask_bytes=compact_mask_bytes(compact_once), + pixel_perfect=True, + ) + + +def print_summary(results: list[ApiBenchmarkResult], reps: int, warmup: int) -> None: + """Print a Rich summary table matching the compact mask benchmark style.""" + table = Table( + title="CompactMask from_inference", + box=box.ROUNDED, + show_lines=False, + header_style="bold cyan", + ) + table.add_column("src", style="bold", no_wrap=True) + table.add_column("res", no_wrap=True) + table.add_column("seg", justify="right") + table.add_column("dense ms", justify="right") + table.add_column("CM ms", justify="right", style="green") + table.add_column("speedup", justify="right") + table.add_column("peak MB", justify="right", style="cyan") + table.add_column("mask MB", justify="right") + table.add_column("ok", justify="center") + + for result in results: + speedup = result.dense_s / max(result.compact_s, 1e-9) + table.add_row( + result.source, + result.resolution, + str(result.segmented_objects), + f"{result.dense_s * 1e3:.2f}", + f"{result.compact_s * 1e3:.2f}", + _fmt_ratio(speedup), + f"{_fmt_mb(result.dense_peak_bytes)}/{_fmt_mb(result.compact_peak_bytes)}", + f"{_fmt_mb(result.dense_mask_bytes)}/{_fmt_mb(result.compact_mask_bytes)}", + "[green]โœ“[/green]" if result.pixel_perfect else "[red]โœ—[/red]", + ) + + console.print(table) + console.print( + "[dim]" + + " ยท ".join( + [ + f"timings are median of {reps} reps after {warmup} warmups", + "peak MB and mask MB are dense/compact", + "speedup = dense / compact parse time; gains are allocation-driven" + " (avoiding the dense (N,H,W) bool-stack), not faster RLE decode", + "compact RLE arithmetic is typically slower than the dense NumPy path" + " โ€” synthetic-dense-64 shows this adversarial regime (speedup < 1x)", + "OK means compact.to_dense() exactly matches dense masks", + ] + ) + + "[/dim]" + ) + + +def main() -> None: + """Run the benchmark.""" + parser = argparse.ArgumentParser() + parser.add_argument("--asset", choices=ASSETS.keys(), default=None) + parser.add_argument("--image", type=Path, default=None) + args = parser.parse_args() + + assets = [args.asset] if args.asset is not None else list(ASSETS) + if args.image is not None: + assets = ["custom"] + + results = [] + if args.asset is None and args.image is None: + image, source, inference_result = synthetic_dense_small_result() + console.rule(f"[bold]{source}[/bold] | {image.shape[1]}x{image.shape[0]}") + results.append( + run_benchmark( + source=source, + image=image, + result=inference_result, + reps=REPETITIONS, + warmup=WARMUP, + ) + ) + model_id = os.getenv(MODEL_ID_ENV, MODEL_ID) + model = load_inference_model(model_id=model_id, api_key=os.getenv(API_KEY_ENV)) + for asset in assets: + image, source = load_image_from_asset(args.image, asset) + console.rule(f"[bold]{source}[/bold] | {image.shape[1]}x{image.shape[0]}") + inference_result = run_inference_once( + image=image, + model=model, + model_id=model_id, + confidence=CONFIDENCE, + iou=IOU, + ) + if inference_result is None: + continue + console.print( + f"[dim]captured {count_rle_predictions(inference_result)} RLE masks " + f"from {model_id}[/dim]" + ) + artifact = save_segmentation_artifact( + image=image, + result=inference_result, + source=source, + ) + if artifact is not None: + console.print(f"[dim]saved segmentation artifact: {artifact}[/dim]") + results.append( + run_benchmark( + source=source, + image=image, + result=inference_result, + reps=REPETITIONS, + warmup=WARMUP, + ) + ) + if not results: + raise ValueError(f"Model {model_id!r} returned no segmentation masks.") + print_summary(results, reps=REPETITIONS, warmup=WARMUP) + + +if __name__ == "__main__": + main() diff --git a/examples/compact_mask/benchmark.py b/examples/compact_mask/benchmark.py new file mode 100644 index 0000000..f4d70d9 --- /dev/null +++ b/examples/compact_mask/benchmark.py @@ -0,0 +1,1176 @@ +"""CompactMask demo & benchmark. + +Demonstrates that ``CompactMask`` is a drop-in replacement for dense +``(N, H, W)`` bool arrays in ``supervision.Detections``, while using +significantly less memory and enabling faster annotation. The annotation +timing reports frame size, detection count, mask area ratio, and +``MaskAnnotator`` speedup from ROI-only blending. + +Run with: + uv run python examples/compact_mask/benchmark.py + +No GPU or real model is required โ€” everything is synthesized with NumPy. +Mask complexity is controlled by ``num_vertices``: random polygons with more +vertices produce jaggier boundaries and more RLE runs per row. +""" + +import dataclasses +import gc +import json +import math +import time +import tracemalloc +from collections.abc import Callable +from concurrent.futures import ThreadPoolExecutor +from dataclasses import dataclass, field +from datetime import datetime, timezone +from pathlib import Path + +import cv2 +import numpy as np +import pandas as pd +from rich import box +from rich.console import Console +from rich.progress import ( + BarColumn, + MofNCompleteColumn, + Progress, + TaskProgressColumn, + TextColumn, + TimeElapsedColumn, +) +from rich.table import Table + +import supervision as sv +from supervision.detection.compact_mask import CompactMask + +console = Console(width=240, force_terminal=True) + +REPETITIONS = 4 +# How many reps to run concurrently in time_reps. Each thread times itself +# independently; results are averaged. Numpy releases the GIL for its C-level +# work so threads can truly run in parallel on multi-core machines. +# Set to 1 to disable parallelism and revert to a sequential timing loop. +PARALLEL = 3 +# Dense timing is skipped when the dense (N,H,W) array would exceed this +# threshold โ€” avoids OOM / swap thrashing on extreme scenarios while still +# reporting the theoretical memory footprint. +DENSE_SKIP_GB = 16.0 +# Dense IoU *and NMS* timing are skipped above this threshold: pairwise +# (N,H,W) AND is extremely expensive โ€” NMS calls IoU internally so both are +# gated by the same threshold. +IOU_DENSE_SKIP_GB = 1.0 +# Reps for dense IoU/NMS โ€” a single pass already takes several seconds. +IOU_NMS_REPS = 2 + + +# โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ• +# Result container +# โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ• + + +@dataclass +class ScenarioResult: + name: str + resolution: str # e.g. "1920x1080" + num_objects: int + fill_name: str # mask area ratio, e.g. "5%" + num_vertices: int # polygon vertex count โ€” complexity proxy + # memory (theoretical: raw numpy nbytes) + dense_bytes: int + compact_bytes_theoretical: int + # memory (actual: tracemalloc peak; dense_bytes_actual=0 when dense_skipped=True) + dense_bytes_actual: int + compact_bytes_actual: int + # compactness overhead โ€” absolute times for conversion (always measured) + encode_s: float # CompactMask.from_dense() dense โ†’ compact + decode_s: float # compact_mask.to_dense() compact โ†’ dense + # timing (nan when dense_skipped=True) + dense_area_s: float + compact_area_s: float + dense_filter_s: float + compact_filter_s: float + dense_annot_s: float + compact_annot_s: float + # pipeline stages (nan when respective skip flag is True) + dense_iou_s: float # nan when iou_dense_skipped + compact_iou_s: float + dense_nms_s: float # nan when dense_skipped + compact_nms_s: float + dense_merge_s: float # nan when dense_skipped + compact_merge_s: float + dense_offset_s: float # nan when dense_skipped + compact_offset_s: float + dense_centroids_s: float # nan when dense_skipped + compact_centroids_s: float + # correctness (None when the stage was skipped) + pixel_perfect: bool | None + areas_match: bool | None + roundtrip_ok: bool | None + iou_ok: bool | None + nms_ok: bool | None + nms_mismatch_count: ( + int # detections with different NMS decisions (0 when dense_skipped) + ) + merge_ok: bool | None + offset_ok: bool | None + centroids_ok: bool | None + dense_resize_s: float # nan when dense_skipped + compact_resize_s: float + resize_ok: bool | None + # skip flags + dense_skipped: bool = field(default=False) + iou_dense_skipped: bool = field(default=False) + + +# โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ• +# Synthetic data helpers +# โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ• + + +def make_scene(image_height: int, image_width: int) -> np.ndarray: + """Random BGR image.""" + return np.random.default_rng(42).integers( + 0, 255, (image_height, image_width, 3), dtype=np.uint8 + ) + + +def _make_polygon_mask( + image_height: int, + image_width: int, + center_x: int, + center_y: int, + axis_x: int, + axis_y: int, + rng: np.random.Generator, + num_vertices: int, +) -> np.ndarray: + """Random polygon mask. + + *num_vertices* is a direct complexity proxy: more vertices โ†’ more + independent radius samples โ†’ jaggier boundary โ†’ more RLE runs per row. + No smoothing is applied so the relationship is monotone. + """ + angles = np.sort(rng.uniform(0, 2 * np.pi, num_vertices)) + radii = rng.uniform(0.3, 1.0, num_vertices) + pts_x = np.clip( + (center_x + axis_x * radii * np.cos(angles)).astype(np.int32), + 0, + image_width - 1, + ) + pts_y = np.clip( + (center_y + axis_y * radii * np.sin(angles)).astype(np.int32), + 0, + image_height - 1, + ) + pts = np.column_stack([pts_x, pts_y]).reshape(-1, 1, 2) + canvas = np.zeros((image_height, image_width), dtype=np.uint8) + cv2.fillPoly(canvas, [pts], 1) + return canvas.astype(bool) + + +def make_detections( + num_objects: int, + image_height: int, + image_width: int, + fill_fraction: float, + num_vertices: int = 20, + seed: int = 0, +) -> tuple[np.ndarray, np.ndarray, np.ndarray]: + """Return ``(xyxy, masks_dense, class_ids)`` with random polygon masks. + + *num_vertices* controls mask complexity: more vertices โ†’ jaggier boundary. + """ + rng = np.random.default_rng(seed) + half = max( + 2, + int( + (image_height * image_width * fill_fraction / (np.pi * num_objects)) ** 0.5 + ), + ) + xyxy_list = [] + masks = np.zeros((num_objects, image_height, image_width), dtype=bool) + for index in range(num_objects): + center_x = int(rng.integers(half + 1, image_width - half - 1)) + center_y = int(rng.integers(half + 1, image_height - half - 1)) + axis_x = int(rng.integers(max(2, half // 2), half * 2 + 1)) + axis_y = int(rng.integers(max(2, half // 2), half * 2 + 1)) + masks[index] = _make_polygon_mask( + image_height, + image_width, + center_x, + center_y, + axis_x, + axis_y, + rng, + num_vertices, + ) + xyxy_list.append( + [ + max(0, center_x - axis_x), + max(0, center_y - axis_y), + min(image_width - 1, center_x + axis_x), + min(image_height - 1, center_y + axis_y), + ] + ) + xyxy = np.array(xyxy_list, dtype=np.float32) + class_ids = rng.integers(0, 10, num_objects, dtype=int) + return xyxy, masks, class_ids + + +# โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ• +# Memory helpers +# โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ• + + +def dense_memory_bytes(masks: np.ndarray) -> int: + """Theoretical dense footprint: raw numpy buffer size.""" + return int(masks.nbytes) + + +def compact_memory_bytes_theoretical(compact_mask: CompactMask) -> int: + """Theoretical compact footprint: sum of all internal numpy buffer sizes.""" + return int( + compact_mask._crop_shapes.nbytes + + compact_mask._offsets.nbytes + + sum(rle.nbytes for rle in compact_mask._rles), + ) + + +def measure_peak_bytes(func: Callable[[], object]) -> int: + """Wrapper that runs *func* under tracemalloc and returns peak allocation. + + tracemalloc captures every Python-level allocation โ€” numpy buffers, list + nodes, object headers โ€” giving the true heap cost of anything *func* + builds. The return value of *func* is discarded so the object does not + stay alive. + """ + tracemalloc.start() + tracemalloc.clear_traces() + func() + _, peak = tracemalloc.get_traced_memory() + tracemalloc.stop() + return int(peak) + + +def dense_memory_bytes_actual( + num_objects: int, image_height: int, image_width: int +) -> int: + """Actual dense footprint: peak bytes during (N, H, W) bool array alloc.""" + return measure_peak_bytes( + lambda: np.zeros((num_objects, image_height, image_width), dtype=bool), + ) + + +def compact_memory_bytes_actual( + masks_dense: np.ndarray, + xyxy: np.ndarray, + image_shape: tuple[int, int], +) -> int: + """Actual compact footprint: peak bytes during CompactMask.from_dense().""" + return measure_peak_bytes( + lambda: CompactMask.from_dense(masks_dense, xyxy, image_shape=image_shape), + ) + + +def time_reps( + func: Callable[[], object], + repeats: int = REPETITIONS, + parallel: int = PARALLEL, +) -> float: + """Run *func* *reps* times and return mean wall-clock seconds per call. + + When ``parallel > 1``, up to ``parallel`` calls run simultaneously in + threads. Numpy and OpenCV release the GIL for their C-level work, so + threads can execute in parallel on multi-core machines. Each thread + records its own elapsed time; the mean across all *reps* is returned. + + When ``parallel == 1`` the original sequential loop is used, avoiding + any thread-scheduling overhead and improving accuracy for cheap functions. + + A full GC cycle is run before timing so accumulated garbage from earlier + stages does not trigger collection mid-measurement and inflate results. + """ + gc.collect() + if parallel <= 1: + t0 = time.perf_counter() + for _ in range(repeats): + func() + return (time.perf_counter() - t0) / repeats + + def _timed() -> float: + t0 = time.perf_counter() + func() + return time.perf_counter() - t0 + + with ThreadPoolExecutor(max_workers=min(parallel, repeats)) as pool: + timings = list(pool.map(lambda _: _timed(), range(repeats))) + return sum(timings) / repeats + + +# โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ• +# Benchmark stages +# โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ• + + +def stage_build( + num_objects: int, + image_height: int, + image_width: int, + fill_fraction: float, + num_vertices: int = 20, +) -> tuple[np.ndarray, np.ndarray, np.ndarray, CompactMask]: + """Synthesize polygon masks and build the CompactMask.""" + xyxy, masks_dense, class_ids = make_detections( + num_objects, image_height, image_width, fill_fraction, num_vertices + ) + compact_mask = CompactMask.from_dense( + masks_dense, xyxy, image_shape=(image_height, image_width) + ) + return xyxy, masks_dense, class_ids, compact_mask + + +def _resize_dense_to_shape(masks: np.ndarray, new_h: int, new_w: int) -> np.ndarray: + """Nearest-neighbour resize of (N, H, W) bool masks to (N, new_h, new_w). + + Uses floor-division indexing (``arange * src // dst``) to match the + strategy in ``_rle_resize``, ensuring pixel-exact parity for correctness + comparisons in :func:`stage_resize`. + """ + orig_h, orig_w = masks.shape[1], masks.shape[2] + x = np.arange(new_w) * orig_w // new_w + y = np.arange(new_h) * orig_h // new_h + xv, yv = np.meshgrid(x, y) + return masks[:, yv, xv] + + +def stage_encode( + masks_dense: np.ndarray, + xyxy: np.ndarray, + image_height: int, + image_width: int, +) -> float: + """Per-mask encode time: encode each mask individually and average over N. + + Calling from_dense one mask at a time (rather than batching all N) isolates + the per-shape cost โ€” each polygon has a different RLE run count, so the + average reflects true shape variance. + """ + num_masks = len(masks_dense) + image_shape = (image_height, image_width) + + def _encode_each() -> None: + for i in range(num_masks): + CompactMask.from_dense( + masks_dense[i : i + 1], xyxy[i : i + 1], image_shape=image_shape + ) + + return time_reps(_encode_each) / max(num_masks, 1) + + +def stage_decode(compact_mask: CompactMask) -> float: + """Per-mask decode time: decode each mask individually and average over N. + + Building a list via compact_mask[i] decodes each crop separately, giving + the per-mask cost of materialising a single RLE back to a dense array. + """ + num_masks = len(compact_mask) + return time_reps(lambda: [compact_mask[i] for i in range(num_masks)]) / max( + num_masks, 1 + ) + + +def stage_area( + det_dense: sv.Detections, det_compact: sv.Detections +) -> tuple[float, float]: + """Time .area on both representations.""" + return ( + time_reps(lambda: det_dense.area), + time_reps(lambda: det_compact.area), + ) + + +def stage_filter( + det_dense: sv.Detections, det_compact: sv.Detections +) -> tuple[float, float]: + """Time boolean filtering (keep every other detection).""" + keep = np.arange(len(det_dense)) % 2 == 0 + return ( + time_reps(lambda: det_dense[keep]), + time_reps(lambda: det_compact[keep]), + ) + + +def stage_annotate( + scene: np.ndarray, det_dense: sv.Detections, det_compact: sv.Detections +) -> tuple[float, float]: + """Time MaskAnnotator on both representations.""" + annotator = sv.MaskAnnotator(opacity=0.5) + return ( + time_reps(lambda: annotator.annotate(scene.copy(), det_dense)), + time_reps(lambda: annotator.annotate(scene.copy(), det_compact)), + ) + + +def stage_correctness( + scene: np.ndarray, + masks_dense: np.ndarray, + compact_mask: CompactMask, + det_dense: sv.Detections, + det_compact: sv.Detections, +) -> tuple[bool, bool, bool]: + """Return (pixel_perfect, areas_match, roundtrip_ok).""" + annotator = sv.MaskAnnotator(opacity=0.5) + out_dense = annotator.annotate(scene.copy(), det_dense) + out_compact = annotator.annotate(scene.copy(), det_compact) + pixel_perfect = bool(np.array_equal(out_dense, out_compact)) + areas_match = bool(np.allclose(det_dense.area, det_compact.area)) + roundtrip_ok = bool(np.array_equal(compact_mask.to_dense(), masks_dense)) + return pixel_perfect, areas_match, roundtrip_ok + + +def stage_iou( + masks_dense: np.ndarray, + compact_mask: CompactMask, + iou_dense_skipped: bool, +) -> tuple[float, float, bool | None]: + """Time pairwise self-IoU using dense (N,H,W) AND and compact crop filter. + + Correctness is checked on the first 10 masks only to keep it fast, + regardless of whether full dense IoU timing is skipped. + """ + correct_n = min(len(compact_mask), 10) + iou_compact_small = sv.mask_iou_batch( + compact_mask[:correct_n], compact_mask[:correct_n] + ) + iou_dense_small = sv.mask_iou_batch( + masks_dense[:correct_n], masks_dense[:correct_n] + ) + iou_ok = bool(np.allclose(iou_dense_small, iou_compact_small, atol=1e-4)) + + compact_iou_s = time_reps(lambda: sv.mask_iou_batch(compact_mask, compact_mask)) + if iou_dense_skipped: + dense_iou_s = math.nan + else: + dense_iou_s = time_reps( + lambda: sv.mask_iou_batch(masks_dense, masks_dense), + repeats=IOU_NMS_REPS, + ) + return dense_iou_s, compact_iou_s, iou_ok + + +def stage_nms( + xyxy: np.ndarray, + confidence: np.ndarray, + class_ids: np.ndarray, + masks_dense: np.ndarray, + compact_mask: CompactMask, + dense_skipped: bool, + iou_dense_skipped: bool, +) -> tuple[float, float, bool | None, int]: + """Time mask NMS. Dense resizes to 640 before IoU; compact uses exact crop IoU. + + Compact NMS is strictly more accurate than dense: it computes pixel-level IoU + directly on the full-resolution RLE crops instead of a lossy 640px-downsampled + approximation. For pairs whose true IoU is very close to the 0.5 threshold, + the resize step in the dense path can flip a keep/suppress decision. + + ``n_diff`` counts detections whose decision differs between the two paths. + ``nms_ok`` is True when ``n_diff == 0``. + + Dense NMS is skipped when ``dense_skipped`` *or* ``iou_dense_skipped`` is True: + NMS calls mask_iou_batch internally so the cost is the same as IoU. + + Returns: + Tuple of ``(dense_nms_s, compact_nms_s, nms_ok, n_diff)``. + """ + predictions = np.c_[xyxy, confidence, class_ids.astype(float)] + + compact_nms_s = time_reps( + lambda: sv.mask_non_max_suppression(predictions, compact_mask) + ) + if dense_skipped or iou_dense_skipped: + return math.nan, compact_nms_s, None, 0 + + keep_dense = sv.mask_non_max_suppression(predictions, masks_dense) + keep_compact = sv.mask_non_max_suppression(predictions, compact_mask) + n_diff = int(np.sum(keep_dense != keep_compact)) + nms_ok = n_diff == 0 + dense_nms_s = time_reps( + lambda: sv.mask_non_max_suppression(predictions, masks_dense), + repeats=IOU_NMS_REPS, + ) + return dense_nms_s, compact_nms_s, nms_ok, n_diff + + +def stage_merge( + det_dense: sv.Detections | None, + det_compact: sv.Detections, + dense_skipped: bool, +) -> tuple[float, float, bool | None]: + """Time Detections.merge on two half-splits. + + Dense: np.vstack; compact: RLE concat. + Splits are pre-computed so the timed lambda measures only the merge. + """ + half = len(det_compact) // 2 + compact_a, compact_b = det_compact[:half], det_compact[half:] + + compact_merge_s = time_reps(lambda: sv.Detections.merge([compact_a, compact_b])) + if dense_skipped or det_dense is None: + return math.nan, compact_merge_s, None + + dense_a, dense_b = det_dense[:half], det_dense[half:] + merged_d = sv.Detections.merge([dense_a, dense_b]) + merged_c = sv.Detections.merge([compact_a, compact_b]) + merge_ok = bool(np.allclose(merged_d.area, merged_c.area)) + dense_merge_s = time_reps(lambda: sv.Detections.merge([dense_a, dense_b])) + return dense_merge_s, compact_merge_s, merge_ok + + +def stage_offset( + masks_dense: np.ndarray, + compact_mask: CompactMask, + image_height: int, + image_width: int, + dense_skipped: bool, +) -> tuple[float, float, bool | None]: + """Time mask offset: move_masks (N,H,W) copy vs O(N) offset update.""" + dx, dy = 10, 10 + # Expand the canvas by the offset so no shifted crop overflows boundary. + # Both move_masks and with_offset.to_dense() operate on identical space. + new_h, new_w = image_height + dy, image_width + dx + new_shape = (new_h, new_w) + + compact_offset_s = time_reps( + lambda: compact_mask.with_offset(dx, dy, new_image_shape=new_shape) + ) + if dense_skipped: + return math.nan, compact_offset_s, None + + moved_dense = sv.move_masks( + masks_dense, np.array([dx, dy]), resolution_wh=(new_w, new_h) + ) + moved_compact = compact_mask.with_offset( + dx, dy, new_image_shape=new_shape + ).to_dense() + offset_ok = bool(np.array_equal(moved_dense, moved_compact)) + dense_offset_s = time_reps( + lambda: sv.move_masks( + masks_dense, np.array([dx, dy]), resolution_wh=(new_w, new_h) + ) + ) + return dense_offset_s, compact_offset_s, offset_ok + + +def stage_centroids( + masks_dense: np.ndarray, + compact_mask: CompactMask, + dense_skipped: bool, +) -> tuple[float, float, bool | None]: + """Time centroid: np.tensordot on full stack (dense) vs per-crop (compact).""" + compact_centroids_s = time_reps(lambda: sv.calculate_masks_centroids(compact_mask)) + if dense_skipped: + return math.nan, compact_centroids_s, None + + c_dense = sv.calculate_masks_centroids(masks_dense) + c_compact = sv.calculate_masks_centroids(compact_mask) + centroids_ok = bool(np.allclose(c_dense, c_compact, atol=1.0)) # 1-pixel tolerance + dense_centroids_s = time_reps(lambda: sv.calculate_masks_centroids(masks_dense)) + return dense_centroids_s, compact_centroids_s, centroids_ok + + +def stage_resize( + masks_dense: np.ndarray, + compact_mask: CompactMask, + image_height: int, + image_width: int, + dense_skipped: bool, +) -> tuple[float, float, bool | None]: + """Time resize to half resolution; check pixel-level correctness. + + Dense path uses numpy fancy-indexing via ``_resize_dense_to_shape``. + Compact path times ``CompactMask.resize()``, which uses direct RLE + arithmetic for sparse masks (below ``_L3_DENSITY_THRESHOLD``) and + falls back to ``cv2.INTER_NEAREST`` decode/resize/re-encode for dense + masks. The two nearest-neighbour strategies can differ by 1 px at + bbox boundaries, so correctness is checked with 1-pixel tolerance. + """ + new_h, new_w = image_height // 2, image_width // 2 + new_shape = (new_h, new_w) + + # Use parallel=1 to avoid nested ThreadPoolExecutor contention: + # CompactMask.resize() itself spawns a thread pool for N >= _PARALLEL_THRESHOLD, + # and time_reps' own parallel outer loop would cause oversubscription. + compact_resize_s = time_reps(lambda: compact_mask.resize(new_shape), parallel=1) + if dense_skipped: + return math.nan, compact_resize_s, None + + resized_dense = _resize_dense_to_shape(masks_dense, new_h, new_w) + resized_compact = compact_mask.resize(new_shape).to_dense() + resize_ok = bool( + np.abs(resized_dense.astype(np.int8) - resized_compact.astype(np.int8)).max() + <= 1 + ) + dense_resize_s = time_reps( + lambda: _resize_dense_to_shape(masks_dense, new_h, new_w) + ) + return dense_resize_s, compact_resize_s, resize_ok + + +# โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ• +# Scenario runner โ€” orchestrates stages +# โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ• + + +def run_scenario( + name: str, + num_objects: int, + image_height: int, + image_width: int, + fill_fraction: float = 0.10, + num_vertices: int = 20, +) -> ScenarioResult: + resolution = f"{image_width}x{image_height}" + fill_name = f"{fill_fraction:.0%}" + console.rule( + f"[bold]{name}[/bold] | {num_objects} objects ยท {resolution} " + f"ยท fillโ‰ˆ{fill_name} ยท polygon/{num_vertices} vertices" + ) + + xyxy, masks_dense, class_ids, compact_mask = stage_build( + num_objects, image_height, image_width, fill_fraction, num_vertices + ) + scene = make_scene(image_height, image_width) + + # โ”€โ”€ memory โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€ + dense_bytes = dense_memory_bytes(masks_dense) + dense_skipped = dense_bytes > DENSE_SKIP_GB * 1e9 + compact_theoretical = compact_memory_bytes_theoretical(compact_mask) + + # Only measure dense tracemalloc when it's safe to allocate the full array. + dense_actual = ( + 0 + if dense_skipped + else dense_memory_bytes_actual(num_objects, image_height, image_width) + ) + compact_actual = compact_memory_bytes_actual( + masks_dense, xyxy, (image_height, image_width) + ) + + encode_s = stage_encode(masks_dense, xyxy, image_height, image_width) + decode_s = stage_decode(compact_mask) + + theory_ratio = dense_bytes / max(compact_theoretical, 1) + if dense_skipped: + malloc_ratio_str = "[dim]โ€”[/dim]" + dense_actual_str = "[dim]skipped[/dim]" + else: + malloc_ratio = dense_actual / max(compact_actual, 1) + malloc_ratio_str = _fmt_ratio(malloc_ratio) + dense_actual_str = f"{dense_actual / 1e6:.1f} MB" + console.print( + f"\tmemory >>\n" + f"\t\ttheory :: dense={dense_bytes / 1e6:.1f} MB " + f"| compact={compact_theoretical / 1e3:.0f} KB " + f"\t{_fmt_ratio(theory_ratio)}\n" + f"\t\tmalloc :: dense={dense_actual_str} " + f"| compact={compact_actual / 1e3:.0f} KB " + f"\t{malloc_ratio_str}" + ) + console.print(f"\t encode (from_dense)\t={encode_s * 1e3:.3f} ms/mask") + console.print(f"\t decode (to_dense)\t={decode_s * 1e3:.3f} ms/mask") + + # โ”€โ”€ skip flags โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€ + iou_dense_skipped = dense_bytes > IOU_DENSE_SKIP_GB * 1e9 + if dense_skipped: + console.print( + f"\t[yellow]dense array is {dense_bytes / 1e9:.1f} GB " + f"(>{DENSE_SKIP_GB:.0f} GB threshold) โ€” skipping dense timing" + f"[/yellow]" + ) + elif iou_dense_skipped: + console.print( + f"\t[yellow]dense IoU skipped (>{IOU_DENSE_SKIP_GB:.0f}GB thr.)[/yellow]" + ) + + confidence = ( + np.random.default_rng(1).uniform(0.3, 0.99, num_objects).astype(np.float32) + ) + det_compact = sv.Detections(xyxy=xyxy, mask=compact_mask, class_id=class_ids) + + if dense_skipped: + dense_area_s = dense_filter_s = dense_annot_s = math.nan + compact_area_s = _time_compact_area(det_compact) + compact_filter_s = _time_compact_filter(det_compact) + compact_annot_s = _time_compact_annotate(scene, det_compact) + pixel_perfect = areas_match = roundtrip_ok = None + det_dense = None + else: + det_dense = sv.Detections(xyxy=xyxy, mask=masks_dense, class_id=class_ids) + dense_area_s, compact_area_s = stage_area(det_dense, det_compact) + dense_filter_s, compact_filter_s = stage_filter(det_dense, det_compact) + dense_annot_s, compact_annot_s = stage_annotate(scene, det_dense, det_compact) + pixel_perfect, areas_match, roundtrip_ok = stage_correctness( + scene, masks_dense, compact_mask, det_dense, det_compact + ) + + dense_iou_s, compact_iou_s, iou_ok = stage_iou( + masks_dense, compact_mask, iou_dense_skipped + ) + dense_nms_s, compact_nms_s, nms_ok, nms_diff = stage_nms( + xyxy, + confidence, + class_ids, + masks_dense, + compact_mask, + dense_skipped, + iou_dense_skipped, + ) + dense_merge_s, compact_merge_s, merge_ok = stage_merge( + det_dense, det_compact, dense_skipped + ) + dense_offset_s, compact_offset_s, offset_ok = stage_offset( + masks_dense, compact_mask, image_height, image_width, dense_skipped + ) + dense_centroids_s, compact_centroids_s, centroids_ok = stage_centroids( + masks_dense, compact_mask, dense_skipped + ) + dense_resize_s, compact_resize_s, resize_ok = stage_resize( + masks_dense, compact_mask, image_height, image_width, dense_skipped + ) + + def _timing_line(label: str, dense_s: float, compact_s: float) -> str: + compact_ms = f"{compact_s * 1e3:.2f} ms" + if math.isnan(dense_s): + return ( + f"\t{label}\t -> dense=[dim]โ€”[/dim]" + f"\t\t | compact={compact_ms}\t | speedup=[dim]โ€”[/dim]" + ) + dense_ms = f"{dense_s * 1e3:.2f} ms" + speedup = _fmt_ratio(dense_s / max(compact_s, 1e-9)) + return ( + f"\t{label}\t -> dense={dense_ms}\t | " + f"compact={compact_ms}\t | speedup={speedup}" + ) + + console.print(_timing_line(".area ", dense_area_s, compact_area_s)) + console.print(_timing_line("annotate ", dense_annot_s, compact_annot_s)) + console.print(_timing_line("centroids", dense_centroids_s, compact_centroids_s)) + console.print(_timing_line("filter ", dense_filter_s, compact_filter_s)) + console.print(_timing_line("iou ", dense_iou_s, compact_iou_s)) + console.print(_timing_line("merge ", dense_merge_s, compact_merge_s)) + console.print(_timing_line("nms ", dense_nms_s, compact_nms_s)) + console.print(_timing_line("offset ", dense_offset_s, compact_offset_s)) + console.print(_timing_line("resize ", dense_resize_s, compact_resize_s)) + + checks = { + "pixel-perfect": pixel_perfect, + "areas": areas_match, + "roundtrip": roundtrip_ok, + "iou": iou_ok, + "nms": nms_ok, + "merge": merge_ok, + "offset": offset_ok, + "centroids": centroids_ok, + "resize": resize_ok, + } + parts = [] + for k, v in checks.items(): + if k == "nms" and v is False: + parts.append(f"nms=[red]โœ—({nms_diff})[/red]") + else: + parts.append( + f"{k}=" + + ( + "[dim]โ€”[/dim]" + if v is None + else "[green]โœ“[/green]" + if v + else "[red]โœ—[/red]" + ) + ) + all_checked = [v for v in checks.values() if v is not None] + overall = ( + "[green]โœ“ all correct[/green]" + if all_checked and all(all_checked) + else "[red]โœ— MISMATCH[/red]" + if any(v is False for v in checks.values()) + else "[dim]โ€”[/dim]" + ) + console.print(" correctness >> " + " | ".join(parts) + f" | {overall}") + + return ScenarioResult( + name=name, + resolution=resolution, + num_objects=num_objects, + fill_name=fill_name, + num_vertices=num_vertices, + dense_bytes=dense_bytes, + compact_bytes_theoretical=compact_theoretical, + dense_bytes_actual=dense_actual, + compact_bytes_actual=compact_actual, + encode_s=encode_s, + decode_s=decode_s, + dense_area_s=dense_area_s, + compact_area_s=compact_area_s, + dense_filter_s=dense_filter_s, + compact_filter_s=compact_filter_s, + dense_annot_s=dense_annot_s, + compact_annot_s=compact_annot_s, + dense_iou_s=dense_iou_s, + compact_iou_s=compact_iou_s, + dense_nms_s=dense_nms_s, + compact_nms_s=compact_nms_s, + dense_merge_s=dense_merge_s, + compact_merge_s=compact_merge_s, + dense_offset_s=dense_offset_s, + compact_offset_s=compact_offset_s, + dense_centroids_s=dense_centroids_s, + compact_centroids_s=compact_centroids_s, + pixel_perfect=pixel_perfect, + areas_match=areas_match, + roundtrip_ok=roundtrip_ok, + iou_ok=iou_ok, + nms_ok=nms_ok, + nms_mismatch_count=nms_diff, + merge_ok=merge_ok, + offset_ok=offset_ok, + centroids_ok=centroids_ok, + dense_resize_s=dense_resize_s, + compact_resize_s=compact_resize_s, + resize_ok=resize_ok, + dense_skipped=dense_skipped, + iou_dense_skipped=iou_dense_skipped, + ) + + +def _time_compact_area(det_compact: sv.Detections) -> float: + """Time .area on the compact detections (used when dense timing is skipped).""" + return time_reps(lambda: det_compact.area) + + +def _time_compact_filter(det_compact: sv.Detections) -> float: + """Time boolean-index filtering on the compact detections (dense-skip path).""" + keep = np.arange(len(det_compact)) % 2 == 0 + return time_reps(lambda: det_compact[keep]) + + +def _time_compact_annotate(scene: np.ndarray, det_compact: sv.Detections) -> float: + """Time MaskAnnotator on the compact detections (dense-skip path).""" + annotator = sv.MaskAnnotator(opacity=0.5) + return time_reps(lambda: annotator.annotate(scene.copy(), det_compact)) + + +# โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ• +# Rich summary table +# โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ• + +_OPS = ( + "area", + "filter", + "annot", + "iou", + "nms", + "merge", + "offset", + "centroids", + "resize", +) + + +def _build_summary_df(results: list[ScenarioResult]) -> pd.DataFrame: + """Compute derived summary columns from scenario results. + + Returns a DataFrame with all ScenarioResult fields plus derived columns + (ratios, speedups, ok) as raw floats. Consumers apply their own formatting. + """ + df = pd.DataFrame([dataclasses.asdict(r) for r in results]) + df["ratio_theory"] = df["dense_bytes"] / df["compact_bytes_theoretical"].clip( + lower=1 + ) + df["ratio_malloc"] = df["dense_bytes_actual"] / df["compact_bytes_actual"].clip( + lower=1 + ) + # dense_bytes_actual == 0 (not measured) when dense_skipped โ€” clear those cells + df.loc[df["dense_skipped"], "ratio_malloc"] = None + for op in _OPS: + df[f"{op}_speedup"] = df[f"dense_{op}_s"] / df[f"compact_{op}_s"].clip( + lower=1e-9 + ) + + check_cols = [ + "pixel_perfect", + "areas_match", + "roundtrip_ok", + "iou_ok", + "nms_ok", + "merge_ok", + "offset_ok", + "centroids_ok", + "resize_ok", + ] + df["ok"] = df.apply( + lambda row: ( + False + if any(row[c] is False for c in check_cols) + else True + if any(row[c] is True for c in check_cols) + else None + ), + axis=1, + ) + return df + + +def _fmt_ratio(ratio: float) -> str: + """Format a speedup/compression ratio with colour coding. + + โ‰ฅ10 โ†’ green (large win), 1-10 โ†’ yellow (modest win), <1 โ†’ red (regression). + Integer for โ‰ฅ10, two decimals otherwise. + """ + fmt = f"{ratio:.0f}x" if ratio >= 10 else f"{ratio:.2f}x" + if ratio >= 10: + return f"[green]{fmt}[/green]" + elif ratio >= 1: + return f"[yellow]{fmt}[/yellow]" + else: + return f"[red]{fmt}[/red]" + + +def _fmt_speedup(dense_s: float, compact_s: float) -> str: + if math.isnan(dense_s): + # Dense was skipped โ€” show compact absolute time so the column isn't empty. + return f"[dim]{compact_s * 1e3:.1f} ms[/dim]" + return _fmt_ratio(dense_s / max(compact_s, 1e-9)) + + +def print_summary(results: list[ScenarioResult]) -> None: + table = Table( + title="CompactMask โ€” benchmark summary", + box=box.ROUNDED, + show_lines=True, + header_style="bold cyan", + min_width=console.width, + ) + table.add_column("Scenario", style="bold", min_width=22) + table.add_column("Objects", justify="right", min_width=7) + table.add_column("Resolution", min_width=12, no_wrap=True) + table.add_column("Mask\narea", justify="right", min_width=5, no_wrap=True) + table.add_column("Vertices", justify="right", min_width=8, no_wrap=True) + table.add_column("Dense\ntheory", justify="right", min_width=10) + table.add_column("Compact\ntheory", justify="right", style="green", min_width=9) + table.add_column("Ratio\ntheory", justify="right", min_width=7) + table.add_column("Dense\nmalloc", justify="right", style="cyan", min_width=9) + table.add_column("Compact\nmalloc", justify="right", style="cyan", min_width=9) + table.add_column("Ratio\nmalloc", justify="right", min_width=7) + table.add_column("Encode\n(ms/mask)", justify="right", style="yellow", min_width=7) + table.add_column("Decode\n(ms/mask)", justify="right", style="yellow", min_width=7) + table.add_column("Area\natt.", justify="right", min_width=6) + table.add_column("Filter\nop.", justify="right", min_width=6) + table.add_column("Annot\nop.", justify="right", min_width=6) + table.add_column("IoU\nop.", justify="right", min_width=6) + table.add_column("NMS\nop.", justify="right", min_width=6) + table.add_column("Merge\nop.", justify="right", min_width=6) + table.add_column("Offset\nop.", justify="right", min_width=6) + table.add_column("Resize\nop.", justify="right", min_width=6) + table.add_column("Centr\nop.", justify="right", min_width=6) + table.add_column("OK?", justify="center", min_width=4) + + for _, row in _build_summary_df(results).iterrows(): + ok = row["ok"] + ok_cell = ( + "[red]โœ—[/red]" + if ok is False + else "[green]โœ“[/green]" + if ok is True + else "[dim]โ€”[/dim]" + ) + dense_malloc_cell = ( + "[dim]โ€”[/dim]" + if row["dense_skipped"] + else f"{row['dense_bytes_actual'] / 1e6:.1f} MB" + ) + malloc_ratio_cell = ( + "[dim]โ€”[/dim]" if row["dense_skipped"] else _fmt_ratio(row["ratio_malloc"]) + ) + table.add_row( + row["name"], + str(row["num_objects"]), + row["resolution"], + row["fill_name"], + str(row["num_vertices"]), + f"{row['dense_bytes'] / 1e6:.1f} MB", + f"{row['compact_bytes_theoretical'] / 1e3:.0f} KB", + _fmt_ratio(row["ratio_theory"]), + dense_malloc_cell, + f"{row['compact_bytes_actual'] / 1e3:.0f} KB", + malloc_ratio_cell, + f"{row['encode_s'] * 1e3:.1f}", + f"{row['decode_s'] * 1e3:.1f}", + _fmt_speedup(row["dense_area_s"], row["compact_area_s"]), + _fmt_speedup(row["dense_filter_s"], row["compact_filter_s"]), + _fmt_speedup(row["dense_annot_s"], row["compact_annot_s"]), + _fmt_speedup(row["dense_iou_s"], row["compact_iou_s"]), + _fmt_speedup(row["dense_nms_s"], row["compact_nms_s"]), + _fmt_speedup(row["dense_merge_s"], row["compact_merge_s"]), + _fmt_speedup(row["dense_offset_s"], row["compact_offset_s"]), + _fmt_speedup(row["dense_resize_s"], row["compact_resize_s"]), + _fmt_speedup(row["dense_centroids_s"], row["compact_centroids_s"]), + ok_cell, + ) + + console.print(table) + console.print( + "[dim]" + + " ยท ".join( + [ + "Vertices โ€” polygon vertex count " + "(complexity proxy: more = jaggier boundary)", + "Dense theory โ€” NxHxW bytes (raw numpy buffer)", + "Compact theory โ€” sum of internal numpy buffer sizes", + "Ratio (theory) โ€” dense / compact theoretical ratio", + "Dense malloc โ€” tracemalloc peak during np.zeros allocation", + "Compact malloc โ€” tracemalloc peak during .from_dense()", + "Ratio (malloc) โ€” dense / compact tracemalloc peak ratio", + "Encode ms/mask โ€” from_dense() / N (denseโ†’compact overhead per mask)", + "Decode ms/mask โ€” to_dense() / N (compactโ†’dense overhead per mask)", + "Area x โ€” .area speedup (RLE sum, no materialisation)", + "Filter x โ€” boolean-index speedup", + "Annot x โ€” MaskAnnotator speedup " + "(ROI-only blend vs full-frame overlay)", + f"IoU x โ€” pairwise self-IoU speedup " + f"(dense skipped >{IOU_DENSE_SKIP_GB:.0f} GB)", + "NMS x โ€” mask_non_max_suppression speedup", + "Merge x โ€” Detections.merge speedup", + "Offset x โ€” move_masks vs with_offset speedup", + "Resize x โ€” resize-to-half speedup", + "Centroids x โ€” calculate_masks_centroids speedup", + "dim ms โ€” dense skipped, compact absolute time shown", + ] + ) + + "[/dim]" + ) + + +# โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ• +# Results persistence +# โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ• + + +def _append_result(result: ScenarioResult, path: Path) -> None: + """Append one scenario result as a JSON line to *path*. + + ``math.nan`` (used for skipped dense timings) is serialised as ``null`` + so the file is valid JSON-Lines and can be read back with any JSON parser. + """ + row = { + k: (None if isinstance(v, float) and math.isnan(v) else v) + for k, v in dataclasses.asdict(result).items() + } + with path.open("a", encoding="utf-8") as fh: + fh.write(json.dumps(row) + "\n") + + +def save_results_csv(results: list[ScenarioResult], path: Path) -> None: + """Write the summary table to *path* as a CSV file. + + Each row mirrors the Rich summary table: scenario metadata, memory ratios, + encode/decode overhead, and per-operation speedups. Columns whose dense + timing was skipped are written as empty cells. + """ + df = _build_summary_df(results) + pd.DataFrame( + { + "scenario": df["name"], + "objects": df["num_objects"], + "resolution": df["resolution"], + "fill": df["fill_name"], + "vertices": df["num_vertices"], + "dense_theory_mb": (df["dense_bytes"] / 1e6).round(1), + "compact_theory_kb": (df["compact_bytes_theoretical"] / 1e3).round(1), + "ratio_theory": df["ratio_theory"].round(0), + "dense_malloc_mb": (df["dense_bytes_actual"] / 1e6) + .where(~df["dense_skipped"]) + .round(1), + "compact_malloc_kb": (df["compact_bytes_actual"] / 1e3).round(1), + "ratio_malloc": df["ratio_malloc"].round(0), + "encode_ms_per_mask": (df["encode_s"] * 1e3).round(4), + "decode_ms_per_mask": (df["decode_s"] * 1e3).round(4), + **{f"{op}_speedup": df[f"{op}_speedup"].round(2) for op in _OPS}, + "resize_ok": df["resize_ok"], + "ok": df["ok"], + } + ).to_csv(path, index=False) + + +# โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ• +# Entry point +# โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ• + + +def main() -> None: + # โ”€โ”€ parameter matrix โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€ + # (tier_label, (image_width, image_height), num_objects) + TIERS: list[tuple[str, tuple[int, int], int]] = [ + ("FHD", (1920, 1080), 100), # full comparison (0.21 GB < 1 GB IoU thr.) + ("FHD", (1920, 1080), 200), # full comparison (0.41 GB < 1 GB IoU thr.) + ("FHD", (1920, 1080), 400), # full comparison (0.83 GB < 1 GB IoU thr.) + ("4K", (3840, 2160), 100), # full comparison (0.83 GB < 1 GB IoU thr.) + ("4K", (3840, 2160), 200), # dense excl. IoU/NMS (1.66 GB > 1 GB thr.) + ("SAT", (8192, 8192), 200), # dense excl. IoU/NMS (13.4 GB > 1 GB thr.) + ] + FILL_FRACTIONS = [0.05, 0.20, 0.50] # sparse / moderate / SAM-everything + VERTEX_COUNTS = [8, 128, 600] # low / realistic / YOLOv8-seg default + + scenarios = [ + { + "name": f"{tier}-{num_objects}-{fill_fraction:.0%}-v{num_vertices}", + "num_objects": num_objects, + "image_height": img_h, + "image_width": img_w, + "fill_fraction": fill_fraction, + "num_vertices": num_vertices, + } + for tier, (img_w, img_h), num_objects in TIERS + for fill_fraction in FILL_FRACTIONS + for num_vertices in VERTEX_COUNTS + ] + + timestamp = datetime.now(timezone.utc).strftime("%Y%m%d_%H%M%S") + results_path = Path(__file__).parent / f"results_{timestamp}.jsonl" + + console.print( + f"[bold]supervision[/bold]" + f" {sv.__version__} ยท numpy {np.__version__} ยท {len(scenarios)} scenarios" + f" ยท saving to [dim]{results_path.name}[/dim]" + ) + + results = [] + progress = Progress( + TextColumn("[progress.description]{task.description}"), + BarColumn(), + MofNCompleteColumn(), + TaskProgressColumn(), + TimeElapsedColumn(), + console=console, + ) + with progress: + task = progress.add_task("benchmarkingโ€ฆ", total=len(scenarios)) + for params in scenarios: + progress.update(task, description=f"[bold]{params['name']}[/bold]") + result = run_scenario(**params) + results.append(result) + _append_result(result, results_path) + gc.collect() # flush scenario temporaries before next run + progress.advance(task) + + print_summary(results) + + csv_path = results_path.with_suffix(".csv") + save_results_csv(results, csv_path) + console.print(f"[dim]results saved โ†’ {results_path.name} ยท {csv_path.name}[/dim]") + + +if __name__ == "__main__": + main() diff --git a/examples/count_people_in_zone/.gitignore b/examples/count_people_in_zone/.gitignore new file mode 100644 index 0000000..1104aa2 --- /dev/null +++ b/examples/count_people_in_zone/.gitignore @@ -0,0 +1,13 @@ +# Ignore everything in the data directory +data/* + +# But re-include all .json files +!data/*.json + +*.pt +*.pth +*.mp4 +*.mov +*.png +*.jpg +*.jpeg diff --git a/examples/count_people_in_zone/README.md b/examples/count_people_in_zone/README.md new file mode 100644 index 0000000..f1391ee --- /dev/null +++ b/examples/count_people_in_zone/README.md @@ -0,0 +1,107 @@ +# count people in zone + +[![Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/roboflow-ai/notebooks/blob/main/notebooks/how-to-detect-and-count-objects-in-polygon-zone.ipynb) [![YouTube](https://badges.aleen42.com/src/youtube.svg)](https://www.youtube.com/watch?v=l_kf9CfZ_8M) + +## ๐Ÿ‘‹ hello + +This demo is a video analysis tool that counts and highlights objects in specific zones of a video. Each zone and the objects within it are marked in different colors, making it easy to see and count the objects in each area. The tool can save this enhanced video or display it live on the screen. + +https://github.com/roboflow/supervision/assets/26109316/f84db7b5-79e2-4142-a1da-64daa43ce667 + +## ๐Ÿ’ป install + +- clone repository and navigate to example directory + + ```bash + git clone --depth 1 -b develop https://github.com/roboflow/supervision.git + cd supervision/examples/count_people_in_zone + ``` + +- setup python environment and activate it [optional] + + ```bash + uv venv + source .venv/bin/activate + ``` + +- install required dependencies + + ```bash + uv pip install -r requirements.txt + ``` + +- download `traffic_analysis.pt` and `traffic_analysis.mov` files + + ```bash + ./setup.sh + ``` + +## ๐Ÿ› ๏ธ script arguments + +- ultralytics + + - `--source_weights_path` (optional): The path to the YOLO model's weights file. Defaults to `"yolov8x.pt"` if not specified. + + - `--zone_configuration_path`: Specifies the path to the JSON file containing zone configurations. This file defines the polygonal areas in the video where objects will be counted. + + - `--source_video_path`: The path to the source video file that will be analyzed. + + - `--target_video_path` (optional): The path to save the output video with annotations. If not provided, the processed video will be displayed in real-time. + + - `--confidence_threshold` (optional): Sets the confidence threshold for the YOLO model to filter detections. Default is `0.3`. + + - `--iou_threshold` (optional): Specifies the IOU (Intersection Over Union) threshold for the model. Default is `0.7`. + +- inference + + - `--roboflow_api_key` (optional): The API key for Roboflow services. If not provided directly, the script tries to fetch it from the `ROBOFLOW_API_KEY` environment variable. Follow [this guide](https://docs.roboflow.com/api-reference/authentication#retrieve-an-api-key) to acquire your `API KEY`. + + - `--model_id` (optional): Designates the Roboflow model ID to be used. The default value is `"yolov8x-1280"`. + + - `--zone_configuration_path`: Specifies the path to the JSON file containing zone configurations. This file defines the polygonal areas in the video where objects will be counted. + + - `--source_video_path`: The path to the source video file that will be analyzed. + + - `--target_video_path` (optional): The path to save the output video with annotations. If not provided, the processed video will be displayed in real-time. + + - `--confidence_threshold` (optional): Sets the confidence threshold for the YOLO model to filter detections. Default is `0.3`. + + - `--iou_threshold` (optional): Specifies the IOU (Intersection Over Union) threshold for the model. Default is `0.7`. + +## ๐Ÿ“Œ zone configuration + +- `horizontal-zone-config.json`: Defines zones divided horizontally across the frame. +- `multi-zone-config.json`: Configures multiple zones with custom shapes and positions. +- `quarters-zone-config.json`: Splits the frame into four equal quarters. +- `vertical-zone-config.json`: Divides the frame into vertical zones of equal width. + +## โš™๏ธ run example + +- ultralytics + + ```bash + python ultralytics_example.py \ + --zone_configuration_path data/multi-zone-config.json \ + --source_video_path data/market-square.mp4 \ + --confidence_threshold 0.3 \ + --iou_threshold 0.5 + ``` + +- inference + + ```bash + python inference_example.py \ + --roboflow_api_key "ROBOFLOW_API_KEY" \ + --zone_configuration_path data/multi-zone-config.json \ + --source_video_path data/market-square.mp4 \ + --confidence_threshold 0.3 \ + --iou_threshold 0.5 + ``` + +## ยฉ license + +This demo integrates two main components, each with its own licensing: + +- ultralytics: The object detection model used in this demo, YOLOv8, is distributed under the [AGPL-3.0 license](https://github.com/ultralytics/ultralytics/blob/main/LICENSE). You can find more details about this license here. + +- supervision: The analytics code that powers the zone-based analysis in this demo is based on the Supervision library, which is licensed under the [MIT license](https://github.com/roboflow/supervision/blob/develop/LICENSE.md). This makes the Supervision part of the code fully open source and freely usable in your projects. diff --git a/examples/count_people_in_zone/inference_example.py b/examples/count_people_in_zone/inference_example.py new file mode 100644 index 0000000..2b21126 --- /dev/null +++ b/examples/count_people_in_zone/inference_example.py @@ -0,0 +1,202 @@ +import json +import os + +import cv2 +import numpy as np +from inference.core.models.roboflow import RoboflowInferenceModel +from inference.models.utils import get_roboflow_model +from tqdm import tqdm + +import supervision as sv + +COLORS = sv.ColorPalette.DEFAULT + + +def load_zones_config(file_path: str) -> list[np.ndarray]: + """ + Load polygon zone configurations from a JSON file. + + This function reads a JSON file which contains polygon coordinates, and + converts them into a list of NumPy arrays. Each polygon is represented as + a NumPy array of coordinates. + + Args: + file_path (str): The path to the JSON configuration file. + + Returns: + List[np.ndarray]: A list of polygons, each represented as a NumPy array. + """ + with open(file_path) as file: + data = json.load(file) + return [np.array(polygon, np.int32) for polygon in data["polygons"]] + + +def initiate_annotators( + polygons: list[np.ndarray], resolution_wh: tuple[int, int] +) -> tuple[list[sv.PolygonZone], list[sv.PolygonZoneAnnotator], list[sv.BoxAnnotator]]: + line_thickness = sv.calculate_optimal_line_thickness(resolution_wh=resolution_wh) + text_scale = sv.calculate_optimal_text_scale(resolution_wh=resolution_wh) + + zones = [] + zone_annotators = [] + box_annotators = [] + + for index, polygon in enumerate(polygons): + zone = sv.PolygonZone(polygon=polygon) + zone_annotator = sv.PolygonZoneAnnotator( + zone=zone, + color=COLORS.by_idx(index), + thickness=line_thickness, + text_thickness=line_thickness * 2, + text_scale=text_scale * 2, + ) + box_annotator = sv.BoxAnnotator( + color=COLORS.by_idx(index), thickness=line_thickness + ) + zones.append(zone) + zone_annotators.append(zone_annotator) + box_annotators.append(box_annotator) + + return zones, zone_annotators, box_annotators + + +def detect( + frame: np.ndarray, + model: RoboflowInferenceModel, + confidence_threshold: float = 0.5, + iou_threshold: float = 0.7, +) -> sv.Detections: + """ + Detect objects in a frame using Inference model, filtering detections by class ID + and confidence threshold. + + Args: + frame (np.ndarray): The frame to process, expected to be a NumPy array. + model (RoboflowInferenceModel): The Inference model used for processing the + frame. + confidence_threshold (float): The confidence threshold for filtering + detections. + iou_threshold (float): The IoU threshold for non-maximum suppression. + + Returns: + sv.Detections: Filtered detections after processing the frame with the Inference + model. + + Note: + This function is specifically tailored for an Inference model and assumes class + ID 0 for filtering. + """ + results = model.infer(frame, confidence=confidence_threshold, iou=iou_threshold)[0] + detections = sv.Detections.from_inference(results) + filter_by_class = detections.class_id == 0 + filter_by_confidence = detections.confidence > confidence_threshold + return detections[filter_by_class & filter_by_confidence] + + +def annotate( + frame: np.ndarray, + zones: list[sv.PolygonZone], + zone_annotators: list[sv.PolygonZoneAnnotator], + box_annotators: list[sv.BoxAnnotator], + detections: sv.Detections, +) -> np.ndarray: + """ + Annotate a frame with zone and box annotations based on given detections. + + Args: + frame (np.ndarray): The original frame to be annotated. + zones (List[sv.PolygonZone]): A list of polygon zones used for detection. + zone_annotators (List[sv.PolygonZoneAnnotator]): A list of annotators for + drawing zone annotations. + box_annotators (List[sv.BoxAnnotator]): A list of annotators for + drawing box annotations. + detections (sv.Detections): Detections to be used for annotation. + + Returns: + np.ndarray: The annotated frame. + """ + annotated_frame = frame.copy() + for zone, zone_annotator, box_annotator in zip( + zones, zone_annotators, box_annotators + ): + detections_in_zone = detections[zone.trigger(detections=detections)] + annotated_frame = zone_annotator.annotate(scene=annotated_frame) + annotated_frame = box_annotator.annotate( + scene=annotated_frame, detections=detections_in_zone + ) + return annotated_frame + + +def main( + zone_configuration_path: str, + source_video_path: str, + model_id: str = "yolov8x-1280", + roboflow_api_key: str | None = None, + target_video_path: str | None = None, + confidence_threshold: float = 0.3, + iou_threshold: float = 0.7, +) -> None: + """ + Counting people in zones with Inference and Supervision. + + Args: + zone_configuration_path: Path to the zone configuration JSON file + source_video_path: Path to the source video file + model_id: Roboflow model ID + roboflow_api_key: Roboflow API KEY + target_video_path: Path to the target video file (output) + confidence_threshold: Confidence threshold for the model + iou_threshold: IOU threshold for the model + """ + api_key = roboflow_api_key + api_key = os.environ.get("ROBOFLOW_API_KEY", api_key) + if api_key is None: + raise ValueError( + "Roboflow API key is missing. Please provide it as an argument or set the " + "ROBOFLOW_API_KEY environment variable." + ) + roboflow_api_key = api_key + + video_info = sv.VideoInfo.from_video_path(source_video_path) + polygons = load_zones_config(zone_configuration_path) + zones, zone_annotators, box_annotators = initiate_annotators( + polygons=polygons, resolution_wh=video_info.resolution_wh + ) + + model = get_roboflow_model(model_id=model_id, api_key=roboflow_api_key) + + frames_generator = sv.get_video_frames_generator(source_video_path) + if target_video_path is not None: + with sv.VideoSink(target_video_path, video_info) as sink: + for frame in tqdm(frames_generator, total=video_info.total_frames): + detections = detect(frame, model, confidence_threshold, iou_threshold) + annotated_frame = annotate( + frame=frame, + zones=zones, + zone_annotators=zone_annotators, + box_annotators=box_annotators, + detections=detections, + ) + sink.write_frame(annotated_frame) + else: + for frame in tqdm(frames_generator, total=video_info.total_frames): + detections = detect(frame, model, confidence_threshold, iou_threshold) + annotated_frame = annotate( + frame=frame, + zones=zones, + zone_annotators=zone_annotators, + box_annotators=box_annotators, + detections=detections, + ) + cv2.imshow("Processed Video", annotated_frame) + if cv2.waitKey(1) & 0xFF == ord("q"): + break + + cv2.destroyAllWindows() + + +if __name__ == "__main__": + from jsonargparse import auto_cli, set_parsing_settings + + set_parsing_settings(parse_optionals_as_positionals=True) + auto_cli(main, as_positional=False) diff --git a/examples/count_people_in_zone/requirements.txt b/examples/count_people_in_zone/requirements.txt new file mode 100644 index 0000000..f325418 --- /dev/null +++ b/examples/count_people_in_zone/requirements.txt @@ -0,0 +1,6 @@ +gdown +inference +supervision +tqdm +ultralytics +jsonargparse[signatures] diff --git a/examples/count_people_in_zone/setup.sh b/examples/count_people_in_zone/setup.sh new file mode 100755 index 0000000..4fd1a5f --- /dev/null +++ b/examples/count_people_in_zone/setup.sh @@ -0,0 +1,14 @@ +#!/bin/bash + +# Get the directory where the script is located +DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )" + +# Check if 'data' directory does not exist and then create it +if [[ ! -e $DIR/data ]]; then + mkdir "$DIR/data" +else + echo "'data' directory already exists." +fi + +# Download the market-square.mp4 file from Google Drive +gdown -O "$DIR/data/market-square.mp4" "https://drive.google.com/uc?id=1vVrEVMxucHgqGd7vAa501ASojbeGPhIr" diff --git a/examples/count_people_in_zone/ultralytics_example.py b/examples/count_people_in_zone/ultralytics_example.py new file mode 100644 index 0000000..6caf3c2 --- /dev/null +++ b/examples/count_people_in_zone/ultralytics_example.py @@ -0,0 +1,190 @@ +import json + +import cv2 +import numpy as np +from tqdm import tqdm +from ultralytics import YOLO + +import supervision as sv + +COLORS = sv.ColorPalette.DEFAULT + + +def load_zones_config(file_path: str) -> list[np.ndarray]: + """ + Load polygon zone configurations from a JSON file. + + This function reads a JSON file which contains polygon coordinates, and + converts them into a list of NumPy arrays. Each polygon is represented as + a NumPy array of coordinates. + + Args: + file_path (str): The path to the JSON configuration file. + + Returns: + List[np.ndarray]: A list of polygons, each represented as a NumPy array. + """ + with open(file_path) as file: + data = json.load(file) + return [np.array(polygon, np.int32) for polygon in data["polygons"]] + + +def initiate_annotators( + polygons: list[np.ndarray], resolution_wh: tuple[int, int] +) -> tuple[list[sv.PolygonZone], list[sv.PolygonZoneAnnotator], list[sv.BoxAnnotator]]: + line_thickness = sv.calculate_optimal_line_thickness(resolution_wh=resolution_wh) + text_scale = sv.calculate_optimal_text_scale(resolution_wh=resolution_wh) + + zones = [] + zone_annotators = [] + box_annotators = [] + + for index, polygon in enumerate(polygons): + zone = sv.PolygonZone(polygon=polygon) + zone_annotator = sv.PolygonZoneAnnotator( + zone=zone, + color=COLORS.by_idx(index), + thickness=line_thickness, + text_thickness=line_thickness * 2, + text_scale=text_scale * 2, + ) + box_annotator = sv.BoxAnnotator( + color=COLORS.by_idx(index), thickness=line_thickness + ) + zones.append(zone) + zone_annotators.append(zone_annotator) + box_annotators.append(box_annotator) + + return zones, zone_annotators, box_annotators + + +def detect( + frame: np.ndarray, + model: YOLO, + confidence_threshold: float = 0.5, + iou_threshold: float = 0.7, +) -> sv.Detections: + """ + Detect objects in a frame using a YOLO model, filtering detections by class ID and + confidence threshold. + + Args: + frame (np.ndarray): The frame to process, expected to be a NumPy array. + model (YOLO): The YOLO model used for processing the frame. + confidence_threshold (float): The confidence threshold for filtering + detections. Default is 0.5. + iou_threshold (float): The IoU threshold for non-maximum suppression. + + Returns: + sv.Detections: Filtered detections after processing the frame with the YOLO + model. + + Note: + This function is specifically tailored for a YOLO model and assumes class ID 0 + for filtering. + """ + results = model( + frame, conf=confidence_threshold, iou=iou_threshold, imgsz=1280, verbose=False + )[0] + detections = sv.Detections.from_ultralytics(results) + filter_by_class = detections.class_id == 0 + filter_by_confidence = detections.confidence > confidence_threshold + return detections[filter_by_class & filter_by_confidence] + + +def annotate( + frame: np.ndarray, + zones: list[sv.PolygonZone], + zone_annotators: list[sv.PolygonZoneAnnotator], + box_annotators: list[sv.BoxAnnotator], + detections: sv.Detections, +) -> np.ndarray: + """ + Annotate a frame with zone and box annotations based on given detections. + + Args: + frame (np.ndarray): The original frame to be annotated. + zones (List[sv.PolygonZone]): A list of polygon zones used for detection. + zone_annotators (List[sv.PolygonZoneAnnotator]): A list of annotators for + drawing zone annotations. + box_annotators (List[sv.BoxAnnotator]): A list of annotators for + drawing box annotations. + detections (sv.Detections): Detections to be used for annotation. + + Returns: + np.ndarray: The annotated frame. + """ + annotated_frame = frame.copy() + for zone, zone_annotator, box_annotator in zip( + zones, zone_annotators, box_annotators + ): + detections_in_zone = detections[zone.trigger(detections=detections)] + annotated_frame = zone_annotator.annotate(scene=annotated_frame) + annotated_frame = box_annotator.annotate( + scene=annotated_frame, detections=detections_in_zone + ) + return annotated_frame + + +def main( + zone_configuration_path: str, + source_video_path: str, + source_weights_path: str = "yolo11x.pt", + target_video_path: str | None = None, + confidence_threshold: float = 0.3, + iou_threshold: float = 0.7, +) -> None: + """ + Counting people in zones with YOLO and Supervision. + + Args: + zone_configuration_path: Path to the zone configuration JSON file + source_video_path: Path to the source video file + source_weights_path: Path to the source weights file + target_video_path: Path to the target video file (output) + confidence_threshold: Confidence threshold for the model + iou_threshold: IOU threshold for the model + """ + video_info = sv.VideoInfo.from_video_path(source_video_path) + polygons = load_zones_config(zone_configuration_path) + zones, zone_annotators, box_annotators = initiate_annotators( + polygons=polygons, resolution_wh=video_info.resolution_wh + ) + + model = YOLO(source_weights_path) + + frames_generator = sv.get_video_frames_generator(source_video_path) + if target_video_path is not None: + with sv.VideoSink(target_video_path, video_info) as sink: + for frame in tqdm(frames_generator, total=video_info.total_frames): + detections = detect(frame, model, confidence_threshold, iou_threshold) + annotated_frame = annotate( + frame=frame, + zones=zones, + zone_annotators=zone_annotators, + box_annotators=box_annotators, + detections=detections, + ) + sink.write_frame(annotated_frame) + else: + for frame in tqdm(frames_generator, total=video_info.total_frames): + detections = detect(frame, model, confidence_threshold, iou_threshold) + annotated_frame = annotate( + frame=frame, + zones=zones, + zone_annotators=zone_annotators, + box_annotators=box_annotators, + detections=detections, + ) + cv2.imshow("Processed Video", annotated_frame) + if cv2.waitKey(1) & 0xFF == ord("q"): + break + + cv2.destroyAllWindows() + + +if __name__ == "__main__": + from jsonargparse import auto_cli, set_parsing_settings + + set_parsing_settings(parse_optionals_as_positionals=True) + auto_cli(main, as_positional=False) diff --git a/examples/heatmap_and_track/README.md b/examples/heatmap_and_track/README.md new file mode 100644 index 0000000..643e9e4 --- /dev/null +++ b/examples/heatmap_and_track/README.md @@ -0,0 +1,59 @@ +# heatmap and tracking + +## ๐Ÿ‘‹ hello + +This script performs heatmap and tracking analysis using YOLOv8, an object-detection method and ByteTrack, a simple yet effective online multi-object tracking method. It uses the supervision package for multiple tasks such as drawing heatmap annotations, tracking objects, etc. + +## ๐Ÿ’ป install + +- clone repository and navigate to example directory + + ```bash + git clone --depth 1 -b develop https://github.com/roboflow/supervision.git + cd supervision/examples/heatmap_and_track + ``` + +- setup python environment and activate it [optional] + + ```bash + uv venv + source .venv/bin/activate + ``` + +- install required dependencies + + ```bash + uv pip install -r requirements.txt + ``` + +## ๐Ÿ› ๏ธ script arguments + +- `--source_weights_path`: Required. Specifies the path to the weights file for the YOLO model. This file contains the trained model data necessary for object detection. +- `--source_video_path` (optional): The path to the source video file that will be analyzed. This is the input video on which crowd analysis will be performed. If not specified default is `people-walking.mp4` from supervision assets +- `--target_video_path` (optional): The path to save the output.mp4 video with annotations. +- `--confidence_threshold` (optional): Sets the confidence threshold for the YOLO model to filter detections. Default is `0.3`. This determines how confident the model should be to recognize an object in the video. +- `--iou_threshold` (optional): Specifies the IOU (Intersection Over Union) threshold for the model. Default is 0.7. This value is used to manage object detection accuracy, particularly in distinguishing between different objects. +- `--heatmap_alpha` (optional): Opacity of the overlay mask, between 0 and 1. +- `--radius` (optional): Radius of the heat circle. +- `--track_activation_threshold` (optional): Detection confidence threshold for track activation. +- `--track_seconds` (optional): Number of seconds to buffer when a track is lost. +- `--minimum_matching_threshold` (optional): Threshold for matching tracks with detections. + +## โš™๏ธ run + +```bash +python script.py \ + --source_weights_path weight.pt \ + --source_video_path input_video.mp4 \ + --confidence_threshold 0.3 \ + --iou_threshold 0.5 \ + --target_video_path output_video.mp4 +``` + +## ยฉ license + +This demo integrates two main components, each with its own licensing: + +- ultralytics: The object detection model used in this demo, YOLOv8, is distributed under the [AGPL-3.0 license](https://github.com/ultralytics/ultralytics/blob/main/LICENSE). You can find more details about this license here. + +- supervision: The analytics code that powers the zone-based analysis in this demo is based on the Supervision library, which is licensed under the [MIT license](https://github.com/roboflow/supervision/blob/develop/LICENSE.md). This makes the Supervision part of the code fully open source and freely usable in your projects. diff --git a/examples/heatmap_and_track/requirements.txt b/examples/heatmap_and_track/requirements.txt new file mode 100644 index 0000000..8148534 --- /dev/null +++ b/examples/heatmap_and_track/requirements.txt @@ -0,0 +1,3 @@ +supervision +ultralytics +jsonargparse[signatures] diff --git a/examples/heatmap_and_track/script.py b/examples/heatmap_and_track/script.py new file mode 100644 index 0000000..5a8667e --- /dev/null +++ b/examples/heatmap_and_track/script.py @@ -0,0 +1,121 @@ +import cv2 +from ultralytics import YOLO + +import supervision as sv +from supervision.assets import VideoAssets, download_assets + + +def download_video() -> str: + download_assets(VideoAssets.PEOPLE_WALKING) + return VideoAssets.PEOPLE_WALKING.value + + +def main( + source_weights_path: str, + source_video_path: str | None = None, + target_video_path: str = "output.mp4", + confidence_threshold: float = 0.35, + iou_threshold: float = 0.5, + heatmap_alpha: float = 0.5, + radius: int = 25, + track_activation_threshold: float = 0.35, + track_seconds: int = 5, + minimum_matching_threshold: float = 0.99, +) -> None: + """ + Heatmap and Tracking with Supervision. + + Args: + source_weights_path: Path to the source weights file + source_video_path: Path to the source video file + target_video_path: Path to the target video file + confidence_threshold: Confidence threshold for the model + iou_threshold: IOU threshold for the model + heatmap_alpha: Opacity of the overlay mask, between 0 and 1 + radius: Radius of the heat circle + track_activation_threshold: Detection confidence threshold for track activation + track_seconds: Number of seconds to buffer when a track is lost + minimum_matching_threshold: Threshold for matching tracks with detections + """ + ### instantiate model + model = YOLO(source_weights_path) + source_video_path = source_video_path or download_video() + + ### heatmap config + heat_map_annotator = sv.HeatMapAnnotator( + position=sv.Position.BOTTOM_CENTER, + opacity=heatmap_alpha, + radius=radius, + kernel_size=25, + top_hue=0, + low_hue=125, + ) + + ### annotation config + label_annotator = sv.LabelAnnotator(text_position=sv.Position.CENTER) + + ### get the video fps + cap = cv2.VideoCapture(source_video_path) + fps = int(cap.get(cv2.CAP_PROP_FPS)) + cap.release() + + ### tracker config + byte_tracker = sv.ByteTrack( + track_activation_threshold=track_activation_threshold, + lost_track_buffer=track_seconds * fps, + minimum_matching_threshold=minimum_matching_threshold, + frame_rate=fps, + ) + + ### video config + video_info = sv.VideoInfo.from_video_path(video_path=source_video_path) + frames_generator = sv.get_video_frames_generator( + source_path=source_video_path, stride=1 + ) + + ### Detect, track, annotate, save + with sv.VideoSink(target_path=target_video_path, video_info=video_info) as sink: + for frame in frames_generator: + result = model( + source=frame, + classes=[0], # only person class + conf=confidence_threshold, + iou=iou_threshold, + # show_conf = True, + # save_txt = True, + # save_conf = True, + # save = True, + device=None, # use None = CPU, 0 = single GPU, or [0,1] = dual GPU + )[0] + + detections = sv.Detections.from_ultralytics(result) # get detections + + detections = byte_tracker.update_with_detections( + detections + ) # update tracker + + ### draw heatmap + annotated_frame = heat_map_annotator.annotate( + scene=frame.copy(), detections=detections + ) + + ### draw other attributes from `detections` object + labels = [ + f"#{tracker_id}" + for class_id, tracker_id in zip( + detections.class_id, detections.tracker_id + ) + ] + + label_annotator.annotate( + scene=annotated_frame, detections=detections, labels=labels + ) + + sink.write_frame(frame=annotated_frame) + + +if __name__ == "__main__": + from jsonargparse import auto_cli, set_parsing_settings + + set_parsing_settings(parse_optionals_as_positionals=True) + auto_cli(main, as_positional=False) diff --git a/examples/speed_estimation/.gitignore b/examples/speed_estimation/.gitignore new file mode 100644 index 0000000..34efd9e --- /dev/null +++ b/examples/speed_estimation/.gitignore @@ -0,0 +1,9 @@ +data/ +venv*/ +*.pt +*.pth +*.mp4 +*.mov +*.png +*.jpg +*.jpeg diff --git a/examples/speed_estimation/README.md b/examples/speed_estimation/README.md new file mode 100644 index 0000000..93e8d66 --- /dev/null +++ b/examples/speed_estimation/README.md @@ -0,0 +1,96 @@ +# speed estimation + +[![Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/roboflow-ai/notebooks/blob/main/notebooks/how-to-estimate-vehicle-speed-with-computer-vision.ipynb) [![YouTube](https://badges.aleen42.com/src/youtube.svg)](https://youtu.be/uWP6UjDeZvY) + +## ๐Ÿ‘‹ hello + +This example performs speed estimation analysis using various object-detection models and ByteTrack - a simple yet effective online multi-object tracking method. It uses the supervision package for multiple tasks such as tracking, annotations, etc. + +https://github.com/roboflow/supervision/assets/26109316/d50118c1-2ae4-458d-915a-5d860fd36f71 + +> [!IMPORTANT] Adjust the [`SOURCE`](https://github.com/roboflow/supervision/blob/e32b05a636dab2ea1f39299e529c4b22b8baa8da/examples/speed_estimation/ultralytics_example.py#L10) and [`TARGET`](https://github.com/roboflow/supervision/blob/e32b05a636dab2ea1f39299e529c4b22b8baa8da/examples/speed_estimation/ultralytics_example.py#L15) configuration if you plan to run a speed estimation script on your video file. Those must be adjusted separately for each camera view. You can learn more from our YouTube [tutorial](https://youtu.be/uWP6UjDeZvY). + +## ๐Ÿ’ป install + +- clone repository and navigate to example directory + + ```bash + git clone --depth 1 -b develop https://github.com/roboflow/supervision.git + cd supervision/examples/speed_estimation + ``` + +- setup python environment and activate it [optional] + + ```bash + uv venv + source .venv/bin/activate + ``` + +- install required dependencies + + ```bash + uv pip install -r requirements.txt + ``` + +- download `vehicles.mp4` file + + ```bash + python video_downloader.py + ``` + +## ๐Ÿ› ๏ธ script arguments + +- `--roboflow_api_key` (optional): The API key for Roboflow services. If not provided directly, the script tries to fetch it from the `ROBOFLOW_API_KEY` environment variable. Follow [this guide](https://docs.roboflow.com/api-reference/authentication#retrieve-an-api-key) to acquire your `API KEY`. + +- `--model_id` (optional): Designates the Roboflow model ID to be used. The default value is `"yolov8x-1280"`. + +- `--source_weights_path`: Required. Specifies the path to the YOLO model's weights file, which is essential for the object detection process. This file contains the data that the model uses to identify objects in the video. + +- `--source_video_path`: Required. The path to the source video file that will be analyzed. This is the input video on which traffic flow analysis will be performed. + +- `--target_video_path`: The path to save the output video with annotations. If not specified, the processed video will be displayed in real-time without being saved. + +- `--confidence_threshold` (optional): Sets the confidence threshold for the YOLO model to filter detections. Default is `0.3`. This determines how confident the model should be to recognize an object in the video. + +- `--iou_threshold` (optional): Specifies the IOU (Intersection Over Union) threshold for the model. Default is 0.7. This value is used to manage object detection accuracy, particularly in distinguishing between different objects. + +## โš™๏ธ run + +- yolo-nas + + ```bash + python yolo_nas_example.py \ + --source_video_path data/vehicles.mp4 \ + --target_video_path data/vehicles-result.mp4 \ + --confidence_threshold 0.3 \ + --iou_threshold 0.5 + ``` + +- inference + + ```bash + python inference_example.py \ + --roboflow_api_key "ROBOFLOW_API_KEY" \ + --source_video_path data/vehicles.mp4 \ + --target_video_path data/vehicles-result.mp4 \ + --confidence_threshold 0.3 \ + --iou_threshold 0.5 + ``` + +- ultralytics + + ```bash + python ultralytics_example.py \ + --source_video_path data/vehicles.mp4 \ + --target_video_path data/vehicles-result.mp4 \ + --confidence_threshold 0.3 \ + --iou_threshold 0.5 + ``` + +## ยฉ license + +This demo integrates two main components, each with its own licensing: + +- ultralytics: The object detection model used in this demo, YOLOv8, is distributed under the [AGPL-3.0 license](https://github.com/ultralytics/ultralytics/blob/main/LICENSE). You can find more details about this license here. + +- supervision: The analytics code that powers the zone-based analysis in this demo is based on the Supervision library, which is licensed under the [MIT license](https://github.com/roboflow/supervision/blob/develop/LICENSE.md). This makes the Supervision part of the code fully open source and freely usable in your projects. diff --git a/examples/speed_estimation/inference_example.py b/examples/speed_estimation/inference_example.py new file mode 100644 index 0000000..21ec95b --- /dev/null +++ b/examples/speed_estimation/inference_example.py @@ -0,0 +1,149 @@ +import os +from collections import defaultdict, deque + +import cv2 +import numpy as np +from inference.models.utils import get_roboflow_model + +import supervision as sv + +SOURCE = np.array([[1252, 787], [2298, 803], [5039, 2159], [-550, 2159]]) + +TARGET_WIDTH = 25 +TARGET_HEIGHT = 250 + +TARGET = np.array( + [ + [0, 0], + [TARGET_WIDTH - 1, 0], + [TARGET_WIDTH - 1, TARGET_HEIGHT - 1], + [0, TARGET_HEIGHT - 1], + ] +) + + +class ViewTransformer: + def __init__(self, source: np.ndarray, target: np.ndarray) -> None: + source = source.astype(np.float32) + target = target.astype(np.float32) + self.m = cv2.getPerspectiveTransform(source, target) + + def transform_points(self, points: np.ndarray) -> np.ndarray: + if points.size == 0: + return points + + reshaped_points = points.reshape(-1, 1, 2).astype(np.float32) + transformed_points = cv2.perspectiveTransform(reshaped_points, self.m) + return transformed_points.reshape(-1, 2) + + +def main( + source_video_path: str, + target_video_path: str, + model_id: str = "yolov8x-640", + roboflow_api_key: str | None = None, + confidence_threshold: float = 0.3, + iou_threshold: float = 0.7, +) -> None: + """ + Vehicle Speed Estimation using Inference and Supervision. + + Args: + source_video_path: Path to the source video file + target_video_path: Path to the target video file (output) + model_id: Roboflow model ID + roboflow_api_key: Roboflow API KEY + confidence_threshold: Confidence threshold for the model + iou_threshold: IOU threshold for the model + """ + api_key = roboflow_api_key + api_key = os.environ.get("ROBOFLOW_API_KEY", api_key) + if api_key is None: + raise ValueError( + "Roboflow API key is missing. Please provide it as an argument or set the " + "ROBOFLOW_API_KEY environment variable." + ) + roboflow_api_key = api_key + + video_info = sv.VideoInfo.from_video_path(video_path=source_video_path) + model = get_roboflow_model(model_id=model_id, api_key=roboflow_api_key) + + byte_track = sv.ByteTrack( + frame_rate=video_info.fps, track_activation_threshold=confidence_threshold + ) + + thickness = sv.calculate_optimal_line_thickness( + resolution_wh=video_info.resolution_wh + ) + text_scale = sv.calculate_optimal_text_scale(resolution_wh=video_info.resolution_wh) + box_annotator = sv.BoxAnnotator(thickness=thickness) + label_annotator = sv.LabelAnnotator( + text_scale=text_scale, + text_thickness=thickness, + text_position=sv.Position.BOTTOM_CENTER, + ) + trace_annotator = sv.TraceAnnotator( + thickness=thickness, + trace_length=int(video_info.fps * 2), + position=sv.Position.BOTTOM_CENTER, + ) + + frame_generator = sv.get_video_frames_generator(source_path=source_video_path) + + polygon_zone = sv.PolygonZone(polygon=SOURCE) + view_transformer = ViewTransformer(source=SOURCE, target=TARGET) + + coordinates = defaultdict(lambda: deque(maxlen=int(video_info.fps))) + + with sv.VideoSink(target_video_path, video_info) as sink: + for frame in frame_generator: + results = model.infer( + frame, confidence=confidence_threshold, iou=iou_threshold + )[0] + detections = sv.Detections.from_inference(results) + detections = detections[polygon_zone.trigger(detections)] + detections = byte_track.update_with_detections(detections=detections) + + points = detections.get_anchors_coordinates( + anchor=sv.Position.BOTTOM_CENTER + ) + points = view_transformer.transform_points(points=points).astype(int) + + for tracker_id, [_, y] in zip(detections.tracker_id, points): + coordinates[tracker_id].append(y) + + labels = [] + for tracker_id in detections.tracker_id: + if len(coordinates[tracker_id]) < video_info.fps / 2: + labels.append(f"#{tracker_id}") + else: + coordinate_start = coordinates[tracker_id][-1] + coordinate_end = coordinates[tracker_id][0] + distance = abs(coordinate_start - coordinate_end) + time = len(coordinates[tracker_id]) / video_info.fps + speed = distance / time * 3.6 + labels.append(f"#{tracker_id} {int(speed)} km/h") + + annotated_frame = frame.copy() + annotated_frame = trace_annotator.annotate( + scene=annotated_frame, detections=detections + ) + annotated_frame = box_annotator.annotate( + scene=annotated_frame, detections=detections + ) + annotated_frame = label_annotator.annotate( + scene=annotated_frame, detections=detections, labels=labels + ) + + sink.write_frame(annotated_frame) + cv2.imshow("frame", annotated_frame) + if cv2.waitKey(1) & 0xFF == ord("q"): + break + cv2.destroyAllWindows() + + +if __name__ == "__main__": + from jsonargparse import auto_cli, set_parsing_settings + + set_parsing_settings(parse_optionals_as_positionals=True) + auto_cli(main, as_positional=False) diff --git a/examples/speed_estimation/requirements.txt b/examples/speed_estimation/requirements.txt new file mode 100644 index 0000000..e7d4977 --- /dev/null +++ b/examples/speed_estimation/requirements.txt @@ -0,0 +1,7 @@ +supervision +tqdm +requests +ultralytics +super-gradients==3.5.0 +inference +jsonargparse[signatures] diff --git a/examples/speed_estimation/ultralytics_example.py b/examples/speed_estimation/ultralytics_example.py new file mode 100644 index 0000000..3678a55 --- /dev/null +++ b/examples/speed_estimation/ultralytics_example.py @@ -0,0 +1,133 @@ +from collections import defaultdict, deque + +import cv2 +import numpy as np +from ultralytics import YOLO + +import supervision as sv + +SOURCE = np.array([[1252, 787], [2298, 803], [5039, 2159], [-550, 2159]]) + +TARGET_WIDTH = 25 +TARGET_HEIGHT = 250 + +TARGET = np.array( + [ + [0, 0], + [TARGET_WIDTH - 1, 0], + [TARGET_WIDTH - 1, TARGET_HEIGHT - 1], + [0, TARGET_HEIGHT - 1], + ] +) + + +class ViewTransformer: + def __init__(self, source: np.ndarray, target: np.ndarray) -> None: + source = source.astype(np.float32) + target = target.astype(np.float32) + self.m = cv2.getPerspectiveTransform(source, target) + + def transform_points(self, points: np.ndarray) -> np.ndarray: + if points.size == 0: + return points + + reshaped_points = points.reshape(-1, 1, 2).astype(np.float32) + transformed_points = cv2.perspectiveTransform(reshaped_points, self.m) + return transformed_points.reshape(-1, 2) + + +def main( + source_video_path: str, + target_video_path: str, + confidence_threshold: float = 0.3, + iou_threshold: float = 0.7, +) -> None: + """ + Vehicle Speed Estimation using Ultralytics and Supervision. + + Args: + source_video_path: Path to the source video file + target_video_path: Path to the target video file (output) + confidence_threshold: Confidence threshold for the model + iou_threshold: IOU threshold for the model + """ + video_info = sv.VideoInfo.from_video_path(video_path=source_video_path) + model = YOLO("yolo11x.pt") + + byte_track = sv.ByteTrack( + frame_rate=video_info.fps, track_activation_threshold=confidence_threshold + ) + + thickness = sv.calculate_optimal_line_thickness( + resolution_wh=video_info.resolution_wh + ) + text_scale = sv.calculate_optimal_text_scale(resolution_wh=video_info.resolution_wh) + box_annotator = sv.BoxAnnotator(thickness=thickness) + label_annotator = sv.LabelAnnotator( + text_scale=text_scale, + text_thickness=thickness, + text_position=sv.Position.BOTTOM_CENTER, + ) + trace_annotator = sv.TraceAnnotator( + thickness=thickness, + trace_length=int(video_info.fps * 2), + position=sv.Position.BOTTOM_CENTER, + ) + + frame_generator = sv.get_video_frames_generator(source_path=source_video_path) + + polygon_zone = sv.PolygonZone(polygon=SOURCE) + view_transformer = ViewTransformer(source=SOURCE, target=TARGET) + + coordinates = defaultdict(lambda: deque(maxlen=int(video_info.fps))) + + with sv.VideoSink(target_video_path, video_info) as sink: + for frame in frame_generator: + result = model(frame, conf=confidence_threshold, iou=iou_threshold)[0] + detections = sv.Detections.from_ultralytics(result) + detections = detections[polygon_zone.trigger(detections)] + detections = byte_track.update_with_detections(detections=detections) + + points = detections.get_anchors_coordinates( + anchor=sv.Position.BOTTOM_CENTER + ) + points = view_transformer.transform_points(points=points).astype(int) + + for tracker_id, [_, y] in zip(detections.tracker_id, points): + coordinates[tracker_id].append(y) + + labels = [] + for tracker_id in detections.tracker_id: + if len(coordinates[tracker_id]) < video_info.fps / 2: + labels.append(f"#{tracker_id}") + else: + coordinate_start = coordinates[tracker_id][-1] + coordinate_end = coordinates[tracker_id][0] + distance = abs(coordinate_start - coordinate_end) + time = len(coordinates[tracker_id]) / video_info.fps + speed = distance / time * 3.6 + labels.append(f"#{tracker_id} {int(speed)} km/h") + + annotated_frame = frame.copy() + annotated_frame = trace_annotator.annotate( + scene=annotated_frame, detections=detections + ) + annotated_frame = box_annotator.annotate( + scene=annotated_frame, detections=detections + ) + annotated_frame = label_annotator.annotate( + scene=annotated_frame, detections=detections, labels=labels + ) + + sink.write_frame(annotated_frame) + cv2.imshow("frame", annotated_frame) + if cv2.waitKey(1) & 0xFF == ord("q"): + break + cv2.destroyAllWindows() + + +if __name__ == "__main__": + from jsonargparse import auto_cli, set_parsing_settings + + set_parsing_settings(parse_optionals_as_positionals=True) + auto_cli(main, as_positional=False) diff --git a/examples/speed_estimation/video_downloader.py b/examples/speed_estimation/video_downloader.py new file mode 100644 index 0000000..4272120 --- /dev/null +++ b/examples/speed_estimation/video_downloader.py @@ -0,0 +1,8 @@ +import os + +from supervision.assets import VideoAssets, download_assets + +if not os.path.exists("data"): + os.makedirs("data") +os.chdir("data") +download_assets(VideoAssets.VEHICLES) diff --git a/examples/speed_estimation/yolo_nas_example.py b/examples/speed_estimation/yolo_nas_example.py new file mode 100644 index 0000000..0100e38 --- /dev/null +++ b/examples/speed_estimation/yolo_nas_example.py @@ -0,0 +1,136 @@ +from collections import defaultdict, deque + +import cv2 +import numpy as np +from super_gradients.common.object_names import Models +from super_gradients.training import models + +import supervision as sv + +SOURCE = np.array([[1252, 787], [2298, 803], [5039, 2159], [-550, 2159]]) + +TARGET_WIDTH = 25 +TARGET_HEIGHT = 250 + +TARGET = np.array( + [ + [0, 0], + [TARGET_WIDTH - 1, 0], + [TARGET_WIDTH - 1, TARGET_HEIGHT - 1], + [0, TARGET_HEIGHT - 1], + ] +) + + +class ViewTransformer: + def __init__(self, source: np.ndarray, target: np.ndarray) -> None: + source = source.astype(np.float32) + target = target.astype(np.float32) + self.m = cv2.getPerspectiveTransform(source, target) + + def transform_points(self, points: np.ndarray) -> np.ndarray: + if points.size == 0: + return points + + reshaped_points = points.reshape(-1, 1, 2).astype(np.float32) + transformed_points = cv2.perspectiveTransform(reshaped_points, self.m) + return transformed_points.reshape(-1, 2) + + +def main( + source_video_path: str, + target_video_path: str, + confidence_threshold: float = 0.3, + iou_threshold: float = 0.7, +) -> None: + """ + Vehicle Speed Estimation using YOLO-NAS and Supervision. + + Args: + source_video_path: Path to the source video file + target_video_path: Path to the target video file (output) + confidence_threshold: Confidence threshold for the model + iou_threshold: IOU threshold for the model + """ + video_info = sv.VideoInfo.from_video_path(video_path=source_video_path) + model = models.get(Models.YOLO_NAS_L, pretrained_weights="coco") + + byte_track = sv.ByteTrack( + frame_rate=video_info.fps, track_activation_threshold=confidence_threshold + ) + + thickness = sv.calculate_optimal_line_thickness( + resolution_wh=video_info.resolution_wh + ) + text_scale = sv.calculate_optimal_text_scale(resolution_wh=video_info.resolution_wh) + box_annotator = sv.BoxAnnotator(thickness=thickness) + label_annotator = sv.LabelAnnotator( + text_scale=text_scale, + text_thickness=thickness, + text_position=sv.Position.BOTTOM_CENTER, + ) + trace_annotator = sv.TraceAnnotator( + thickness=thickness, + trace_length=int(video_info.fps * 2), + position=sv.Position.BOTTOM_CENTER, + ) + + frame_generator = sv.get_video_frames_generator(source_path=source_video_path) + + polygon_zone = sv.PolygonZone(polygon=SOURCE) + view_transformer = ViewTransformer(source=SOURCE, target=TARGET) + + coordinates = defaultdict(lambda: deque(maxlen=int(video_info.fps))) + + with sv.VideoSink(target_video_path, video_info) as sink: + for frame in frame_generator: + result = model.predict(frame, conf=confidence_threshold, iou=iou_threshold)[ + 0 + ] + detections = sv.Detections.from_yolo_nas(result) + detections = detections[polygon_zone.trigger(detections)] + detections = byte_track.update_with_detections(detections=detections) + + points = detections.get_anchors_coordinates( + anchor=sv.Position.BOTTOM_CENTER + ) + points = view_transformer.transform_points(points=points).astype(int) + + for tracker_id, [_, y] in zip(detections.tracker_id, points): + coordinates[tracker_id].append(y) + + labels = [] + for tracker_id in detections.tracker_id: + if len(coordinates[tracker_id]) < video_info.fps / 2: + labels.append(f"#{tracker_id}") + else: + coordinate_start = coordinates[tracker_id][-1] + coordinate_end = coordinates[tracker_id][0] + distance = abs(coordinate_start - coordinate_end) + time = len(coordinates[tracker_id]) / video_info.fps + speed = distance / time * 3.6 + labels.append(f"#{tracker_id} {int(speed)} km/h") + + annotated_frame = frame.copy() + annotated_frame = trace_annotator.annotate( + scene=annotated_frame, detections=detections + ) + annotated_frame = box_annotator.annotate( + scene=annotated_frame, detections=detections + ) + annotated_frame = label_annotator.annotate( + scene=annotated_frame, detections=detections, labels=labels + ) + + sink.write_frame(annotated_frame) + cv2.imshow("frame", annotated_frame) + if cv2.waitKey(1) & 0xFF == ord("q"): + break + cv2.destroyAllWindows() + + +if __name__ == "__main__": + from jsonargparse import auto_cli, set_parsing_settings + + set_parsing_settings(parse_optionals_as_positionals=True) + auto_cli(main, as_positional=False) diff --git a/examples/time_in_zone/.gitignore b/examples/time_in_zone/.gitignore new file mode 100644 index 0000000..34efd9e --- /dev/null +++ b/examples/time_in_zone/.gitignore @@ -0,0 +1,9 @@ +data/ +venv*/ +*.pt +*.pth +*.mp4 +*.mov +*.png +*.jpg +*.jpeg diff --git a/examples/time_in_zone/README.md b/examples/time_in_zone/README.md new file mode 100644 index 0000000..d27e3dd --- /dev/null +++ b/examples/time_in_zone/README.md @@ -0,0 +1,321 @@ +# time in zone + +[![YouTube](https://badges.aleen42.com/src/youtube.svg)](https://www.youtube.com/watch?v=hAWpsIuem10) + +## ๐Ÿ‘‹ hello + +Practical demonstration on leveraging computer vision for analyzing wait times and monitoring the duration that objects or individuals spend in predefined areas of video frames. This example project, perfect for retail analytics or traffic management applications. + +https://github.com/roboflow/supervision/assets/26109316/d051cc8a-dd15-41d4-aa36-d38b86334c39 + +## ๐Ÿ’ป install + +- clone repository and navigate to example directory + + ```bash + git clone --depth 1 -b develop https://github.com/roboflow/supervision.git + cd supervision/examples/time_in_zone + ``` + +- setup python environment and activate it [optional] + + ```bash + uv venv + source .venv/bin/activate + ``` + +- install required dependencies + + ```bash + uv pip install -r requirements.txt + ``` + +## ๐Ÿ›  scripts + +### `download_from_youtube` + +This script allows you to download a video from YouTube. + +- `--url`: The full URL of the YouTube video you wish to download. +- `--output_path` (optional): Specifies the directory where the video will be saved. +- `--file_name` (optional): Sets the name of the saved video file. + +```bash +python scripts/download_from_youtube.py \ + --url "https://www.youtube.com/watch?v=-8zyEwAa50Q" \ + --output_path "data/checkout" \ + --file_name "video.mp4" +``` + +```bash +python scripts/download_from_youtube.py \ + --url "https://www.youtube.com/watch?v=MNn9qKG2UFI" \ + --output_path "data/traffic" \ + --file_name "video.mp4" +``` + +### `stream_from_file` + +This script allows you to stream video files from a directory. It's an awesome way to mock a live video stream for local testing. Video will be streamed in a loop under `rtsp://localhost:8554/live0.stream` URL. This script requires docker to be installed. + +- `--video_directory`: Directory containing video files to stream. +- `--number_of_streams`: Number of video files to stream. + +```bash +python scripts/stream_from_file.py \ + --video_directory "data/checkout" \ + --number_of_streams 1 +``` + +```bash +python scripts/stream_from_file.py \ + --video_directory "data/traffic" \ + --number_of_streams 1 +``` + +### `draw_zones` + +If you want to test zone time in zone analysis on your own video, you can use this script to design custom zones and save results as a JSON file. The script will open a window where you can draw polygons on the source image or video file. The polygons will be saved as a JSON file. + +- `--source_path`: Path to the source image or video file for drawing polygons. +- `--zone_configuration_path`: Path where the polygon annotations will be saved as a JSON file. +- `enter` - finish drawing the current polygon. +- `escape` - cancel drawing the current polygon. +- `q` - quit the drawing window. +- `s` - save zone configuration to a JSON file. + +```bash +python scripts/draw_zones.py \ + --source_path "data/checkout/video.mp4" \ + --zone_configuration_path "data/checkout/config.json" +``` + +```bash +python scripts/draw_zones.py \ + --source_path "data/traffic/video.mp4" \ + --zone_configuration_path "data/traffic/config.json" +``` + +https://github.com/roboflow/supervision/assets/26109316/9d514c9e-2a61-418b-ae49-6ac1ad6ae5ac + +## ๐ŸŽฌ video & stream processing + +### `inference_file_example` + +Script to run object detection on a video file using the Roboflow Inference model. + +- `--zone_configuration_path`: Path to the zone configuration JSON file. +- `--source_video_path`: Path to the source video file. +- `--model_id`: Roboflow model ID. +- `--classes`: List of class IDs to track. If empty, all classes are tracked. +- `--confidence_threshold`: Confidence level for detections (`0` to `1`). Default is `0.3`. +- `--iou_threshold`: IOU threshold for non-max suppression. Default is `0.7`. + +```bash +python inference_file_example.py \ + --zone_configuration_path "data/checkout/config.json" \ + --source_video_path "data/checkout/video.mp4" \ + --model_id "rfdetr-medium" \ + --classes "[0]" \ + --confidence_threshold 0.3 \ + --iou_threshold 0.7 \ + --roboflow_api_key "ROBOFLOWS_API_KEY" +``` + +https://github.com/roboflow/supervision/assets/26109316/d051cc8a-dd15-41d4-aa36-d38b86334c39 + +```bash +python inference_file_example.py \ + --zone_configuration_path "data/traffic/config.json" \ + --source_video_path "data/traffic/video.mp4" \ + --model_id "rfdetr-medium" \ + --classes "[2, 5, 6, 7]" \ + --confidence_threshold 0.3 \ + --iou_threshold 0.7 \ + --roboflow_api_key "ROBOFLOWS_API_KEY" +``` + +https://github.com/roboflow/supervision/assets/26109316/5ec896d7-4b39-4426-8979-11e71666878b + +### `inference_stream_example` + +Script to run object detection on an RTSP stream using Roboflow Inference model. + +- `--zone_configuration_path`: Path to the zone configuration JSON file. +- `--rtsp_url`: Complete RTSP URL for the video stream. +- `--model_id`: Roboflow model ID. +- `--classes`: List of class IDs to track. If empty, all classes are tracked. +- `--confidence_threshold`: Confidence level for detections (`0` to `1`). Default is `0.3`. +- `--iou_threshold`: IOU threshold for non-max suppression. Default is `0.7`. + +```bash +python inference_stream_example.py \ + --zone_configuration_path "data/checkout/config.json" \ + --rtsp_url "rtsp://localhost:8554/live0.stream" \ + --model_id "rfdetr-medium" \ + --classes "[0]" \ + --confidence_threshold 0.3 \ + --iou_threshold 0.7 +``` + +```bash +python inference_stream_example.py \ + --zone_configuration_path "data/traffic/config.json" \ + --rtsp_url "rtsp://localhost:8554/live0.stream" \ + --model_id "rfdetr-medium" \ + --classes "[2, 5, 6, 7]" \ + --confidence_threshold 0.3 \ + --iou_threshold 0.7 +``` + +### `rfdeter_file_example` + +Script to run object detection on a video file using the RF-DETR model. + +- `--zone_configuration_path`: Path to the zone configuration JSON file. +- `--source_video_path`: Path to the source video file. +- `--model_size`: Size of RF-DETR model ('nano', 'small', 'medium', 'base' or 'large'). Default is 'medium'. +- `--device`: Computation device ('cpu', 'mps' or 'cuda'). Default is 'cpu'. +- `--classes`: List of class IDs to track. If empty, all classes are tracked. +- `--confidence_threshold`: Confidence level for detections (`0` to `1`). Default is `0.3`. +- `--iou_threshold`: IOU threshold for non-max suppression. Default is `0.7`. +- `--resolution`: Resolution for the model input. Default is `640`. + +```bash +python rfdetr_file_example.py \ + --zone_configuration_path "data/checkout/config.json" \ + --source_video_path "data/checkout/video.mp4" \ + --model_size "medium" \ + --device="cpu" \ + --classes "[1]" \ + --confidence_threshold 0.3 \ + --iou_threshold 0.7 \ + --resolution 640 +``` + +```bash +python rfdetr_file_example.py \ + --zone_configuration_path "data/traffic/config.json" \ + --source_video_path "data/traffic/video.mp4" \ + --model_size "medium" \ + --device="cpu" \ + --classes "[3, 6, 7, 8]" \ + --confidence_threshold 0.3 \ + --iou_threshold 0.7 \ + --resolution 640 +``` + +### `rfdeter_stream_example` + +Script to run object detection on an RTSP stream using the RF-DETR model. + +- `--zone_configuration_path`: Path to the zone-configuration JSON file defining the polygons. +- `--rtsp_url`: Complete RTSP URL of the live video stream. +- `--model_size`: RF-DETR backbone size to load โ€” choose from 'nano', 'small', 'medium', 'base', or 'large' (default 'medium'). +- `--device`: Compute device to run the model on ('cpu', 'mps', or 'cuda'; default 'cpu'). +- `--classes`: Space-separated list of class IDs to track. Leave empty to track all classes. +- `--confidence_threshold`: Minimum confidence score for a detection to be kept, range 0-1 (default 0.3). +- `--iou_threshold`: IOU threshold applied during non-max suppression (default 0.7). +- `--resolution`: Shortest-side input resolution supplied to the model. The script will round it to the nearest valid multiple (default 640). + +```bash +python rfdetr_stream_example.py \ + --zone_configuration_path "data/checkout/config.json" \ + --rtsp_url "rtsp://localhost:8554/live0.stream" \ + --model_size "medium" \ + --device "cpu" \ + --classes "[1]" \ + --confidence_threshold 0.3 \ + --iou_threshold 0.7 \ + --resolution 640 +``` + +```bash +python rfdetr_stream_example.py \ + --zone_configuration_path "data/traffic/config.json" \ + --rtsp_url "rtsp://localhost:8554/live0.stream" \ + --model_size "medium" \ + --device "cpu" \ + --classes "[3, 6, 7, 8]" \ + --confidence_threshold 0.3 \ + --iou_threshold 0.7 \ + --resolution 640 +``` + +### `ultralytics_file_example` + +Script to run object detection on a video file using the Ultralytics YOLOv8 model. + +- `--zone_configuration_path`: Path to the zone configuration JSON file. +- `--source_video_path`: Path to the source video file. +- `--weights`: Path to the model weights file. Default is `'yolov8s.pt'`. +- `--device`: Computation device (`'cpu'`, `'mps'` or `'cuda'`). Default is `'cpu'`. +- `--classes`: List of class IDs to track. If empty, all classes are tracked. +- `--confidence_threshold`: Confidence level for detections (`0` to `1`). Default is `0.3`. +- `--iou_threshold`: IOU threshold for non-max suppression. Default is `0.7`. + +```bash +python ultralytics_file_example.py \ + --zone_configuration_path "data/checkout/config.json" \ + --source_video_path "data/checkout/video.mp4" \ + --weights "yolov8x.pt" \ + --device "cpu" \ + --classes "[0]" \ + --confidence_threshold 0.3 \ + --iou_threshold 0.7 +``` + +```bash +python ultralytics_file_example.py \ + --zone_configuration_path "data/traffic/config.json" \ + --source_video_path "data/traffic/video.mp4" \ + --weights "yolov8x.pt" \ + --device "cpu" \ + --classes "[2, 5, 6, 7]" \ + --confidence_threshold 0.3 \ + --iou_threshold 0.7 +``` + +### `ultralytics_stream_example` + +Script to run object detection on a video stream using the Ultralytics YOLOv8 model. + +- `--zone_configuration_path`: Path to the zone configuration JSON file. +- `--rtsp_url`: Complete RTSP URL for the video stream. +- `--weights`: Path to the model weights file. Default is `'yolov8s.pt'`. +- `--device`: Computation device (`'cpu'`, `'mps'` or `'cuda'`). Default is `'cpu'`. +- `--classes`: List of class IDs to track. If empty, all classes are tracked. +- `--confidence_threshold`: Confidence level for detections (`0` to `1`). Default is `0.3`. +- `--iou_threshold`: IOU threshold for non-max suppression. Default is `0.7`. + +```bash +python ultralytics_stream_example.py \ + --zone_configuration_path "data/checkout/config.json" \ + --rtsp_url "rtsp://localhost:8554/live0.stream" \ + --weights "yolov8x.pt" \ + --device "cpu" \ + --classes "[0]" \ + --confidence_threshold 0.3 \ + --iou_threshold 0.7 +``` + +```bash +python ultralytics_stream_example.py \ + --zone_configuration_path "data/traffic/config.json" \ + --rtsp_url "rtsp://localhost:8554/live0.stream" \ + --weights "yolov8x.pt" \ + --device "cpu" \ + --classes "[2, 5, 6, 7]" \ + --confidence_threshold 0.3 \ + --iou_threshold 0.7 +``` + + + +## ยฉ license + +This demo integrates two main components, each with its own licensing: + +- ultralytics: The object detection model used in this demo, YOLOv8, is distributed under the [AGPL-3.0 license](https://github.com/ultralytics/ultralytics/blob/main/LICENSE). You can find more details about this license here. + +- supervision: The analytics code that powers the zone-based analysis in this demo is based on the Supervision library, which is licensed under the [MIT license](https://github.com/roboflow/supervision/blob/develop/LICENSE.md). This makes the Supervision part of the code fully open source and freely usable in your projects. diff --git a/examples/time_in_zone/inference_file_example.py b/examples/time_in_zone/inference_file_example.py new file mode 100644 index 0000000..59f3b4c --- /dev/null +++ b/examples/time_in_zone/inference_file_example.py @@ -0,0 +1,97 @@ +import cv2 +import numpy as np +from inference import get_model +from utils.general import find_in_list, load_zones_config +from utils.timers import FPSBasedTimer + +import supervision as sv + +COLORS = sv.ColorPalette.from_hex(["#E6194B", "#3CB44B", "#FFE119", "#3C76D1"]) +COLOR_ANNOTATOR = sv.ColorAnnotator(color=COLORS) +LABEL_ANNOTATOR = sv.LabelAnnotator( + color=COLORS, text_color=sv.Color.from_hex("#000000") +) + + +def main( + zone_configuration_path: str, + source_video_path: str, + model_id: str = "rfdetr-medium", + confidence_threshold: float = 0.3, + iou_threshold: float = 0.7, + classes: list[int] = [], + roboflow_api_key: str = "", +) -> None: + """ + Calculating detections dwell time in zones, using video file. + + Args: + zone_configuration_path: Path to the zone configuration JSON file + source_video_path: Path to the source video file + model_id: Roboflow model ID + confidence_threshold: Confidence level for detections (0 to 1) + iou_threshold: IOU threshold for non-max suppression + classes: List of class IDs to track. If empty, all classes are tracked + roboflow_api_key: Roboflow API key for accessing private models + """ + model = get_model(model_id=model_id, api_key=roboflow_api_key) + tracker = sv.ByteTrack(minimum_matching_threshold=0.5) + video_info = sv.VideoInfo.from_video_path(video_path=source_video_path) + frames_generator = sv.get_video_frames_generator(source_video_path) + + polygons = load_zones_config(file_path=zone_configuration_path) + zones = [ + sv.PolygonZone( + polygon=polygon, + triggering_anchors=(sv.Position.CENTER,), + ) + for polygon in polygons + ] + timers = [FPSBasedTimer(video_info.fps) for _ in zones] + + for frame in frames_generator: + results = model.infer( + frame, confidence=confidence_threshold, iou_threshold=iou_threshold + )[0] + detections = sv.Detections.from_inference(results) + detections = detections[find_in_list(detections.class_id, classes)] + detections = tracker.update_with_detections(detections) + + annotated_frame = frame.copy() + + for idx, zone in enumerate(zones): + annotated_frame = sv.draw_polygon( + scene=annotated_frame, polygon=zone.polygon, color=COLORS.by_idx(idx) + ) + + detections_in_zone = detections[zone.trigger(detections)] + time_in_zone = timers[idx].tick(detections_in_zone) + custom_color_lookup = np.full(detections_in_zone.class_id.shape, idx) + + annotated_frame = COLOR_ANNOTATOR.annotate( + scene=annotated_frame, + detections=detections_in_zone, + custom_color_lookup=custom_color_lookup, + ) + labels = [ + f"#{tracker_id} {int(time // 60):02d}:{int(time % 60):02d}" + for tracker_id, time in zip(detections_in_zone.tracker_id, time_in_zone) + ] + annotated_frame = LABEL_ANNOTATOR.annotate( + scene=annotated_frame, + detections=detections_in_zone, + labels=labels, + custom_color_lookup=custom_color_lookup, + ) + + cv2.imshow("Processed Video", annotated_frame) + if cv2.waitKey(1) & 0xFF == ord("q"): + break + cv2.destroyAllWindows() + + +if __name__ == "__main__": + from jsonargparse import auto_cli, set_parsing_settings + + set_parsing_settings(parse_optionals_as_positionals=True) + auto_cli(main, as_positional=False) diff --git a/examples/time_in_zone/inference_naive_stream_example.py b/examples/time_in_zone/inference_naive_stream_example.py new file mode 100644 index 0000000..30f77ee --- /dev/null +++ b/examples/time_in_zone/inference_naive_stream_example.py @@ -0,0 +1,107 @@ +import cv2 +import numpy as np +from inference import get_model +from utils.general import find_in_list, get_stream_frames_generator, load_zones_config +from utils.timers import ClockBasedTimer + +import supervision as sv + +COLORS = sv.ColorPalette.from_hex(["#E6194B", "#3CB44B", "#FFE119", "#3C76D1"]) +COLOR_ANNOTATOR = sv.ColorAnnotator(color=COLORS) +LABEL_ANNOTATOR = sv.LabelAnnotator( + color=COLORS, text_color=sv.Color.from_hex("#000000") +) + + +def main( + zone_configuration_path: str, + rtsp_url: str, + model_id: str = "rfdetr-medium", + confidence_threshold: float = 0.3, + iou_threshold: float = 0.7, + classes: list[int] = [], + roboflow_api_key: str = "", +) -> None: + """ + Calculating detections dwell time in zones, using RTSP stream. + + Args: + zone_configuration_path: Path to the zone configuration JSON file + rtsp_url: Complete RTSP URL for the video stream + model_id: Roboflow model ID + confidence_threshold: Confidence level for detections (0 to 1) + iou_threshold: IOU threshold for non-max suppression + classes: List of class IDs to track. If empty, all classes are tracked + roboflow_api_key: Roboflow API key for accessing private models + """ + model = get_model(model_id=model_id, api_key=roboflow_api_key) + tracker = sv.ByteTrack(minimum_matching_threshold=0.5) + frames_generator = get_stream_frames_generator(rtsp_url=rtsp_url) + fps_monitor = sv.FPSMonitor() + + polygons = load_zones_config(file_path=zone_configuration_path) + zones = [ + sv.PolygonZone( + polygon=polygon, + triggering_anchors=(sv.Position.CENTER,), + ) + for polygon in polygons + ] + timers = [ClockBasedTimer() for _ in zones] + + for frame in frames_generator: + fps_monitor.tick() + fps = fps_monitor.fps + + results = model.infer( + frame, confidence=confidence_threshold, iou_threshold=iou_threshold + )[0] + detections = sv.Detections.from_inference(results) + detections = detections[find_in_list(detections.class_id, classes)] + detections = tracker.update_with_detections(detections) + + annotated_frame = frame.copy() + annotated_frame = sv.draw_text( + scene=annotated_frame, + text=f"{fps:.1f}", + text_anchor=sv.Point(40, 30), + background_color=sv.Color.from_hex("#A351FB"), + text_color=sv.Color.from_hex("#000000"), + ) + + for idx, zone in enumerate(zones): + annotated_frame = sv.draw_polygon( + scene=annotated_frame, polygon=zone.polygon, color=COLORS.by_idx(idx) + ) + + detections_in_zone = detections[zone.trigger(detections)] + time_in_zone = timers[idx].tick(detections_in_zone) + custom_color_lookup = np.full(detections_in_zone.class_id.shape, idx) + + annotated_frame = COLOR_ANNOTATOR.annotate( + scene=annotated_frame, + detections=detections_in_zone, + custom_color_lookup=custom_color_lookup, + ) + labels = [ + f"#{tracker_id} {int(time // 60):02d}:{int(time % 60):02d}" + for tracker_id, time in zip(detections_in_zone.tracker_id, time_in_zone) + ] + annotated_frame = LABEL_ANNOTATOR.annotate( + scene=annotated_frame, + detections=detections_in_zone, + labels=labels, + custom_color_lookup=custom_color_lookup, + ) + + cv2.imshow("Processed Video", annotated_frame) + if cv2.waitKey(1) & 0xFF == ord("q"): + break + cv2.destroyAllWindows() + + +if __name__ == "__main__": + from jsonargparse import auto_cli, set_parsing_settings + + set_parsing_settings(parse_optionals_as_positionals=True) + auto_cli(main, as_positional=False) diff --git a/examples/time_in_zone/inference_stream_example.py b/examples/time_in_zone/inference_stream_example.py new file mode 100644 index 0000000..e88a55f --- /dev/null +++ b/examples/time_in_zone/inference_stream_example.py @@ -0,0 +1,121 @@ +import cv2 +import numpy as np +from inference import InferencePipeline +from inference.core.interfaces.camera.entities import VideoFrame +from utils.general import find_in_list, load_zones_config +from utils.timers import ClockBasedTimer + +import supervision as sv + +COLORS = sv.ColorPalette.from_hex(["#E6194B", "#3CB44B", "#FFE119", "#3C76D1"]) +COLOR_ANNOTATOR = sv.ColorAnnotator(color=COLORS) +LABEL_ANNOTATOR = sv.LabelAnnotator( + color=COLORS, text_color=sv.Color.from_hex("#000000") +) + + +class CustomSink: + def __init__(self, zone_configuration_path: str, classes: list[int]) -> None: + self.classes = classes + self.tracker = sv.ByteTrack(minimum_matching_threshold=0.5) + self.fps_monitor = sv.FPSMonitor() + self.polygons = load_zones_config(file_path=zone_configuration_path) + self.timers = [ClockBasedTimer() for _ in self.polygons] + self.zones = [ + sv.PolygonZone( + polygon=polygon, + triggering_anchors=(sv.Position.CENTER,), + ) + for polygon in self.polygons + ] + + def on_prediction(self, result: dict, frame: VideoFrame) -> None: + self.fps_monitor.tick() + fps = self.fps_monitor.fps + + detections = sv.Detections.from_inference(result) + detections = detections[find_in_list(detections.class_id, self.classes)] + detections = self.tracker.update_with_detections(detections) + + annotated_frame = frame.image.copy() + annotated_frame = sv.draw_text( + scene=annotated_frame, + text=f"{fps:.1f}", + text_anchor=sv.Point(40, 30), + background_color=sv.Color.from_hex("#A351FB"), + text_color=sv.Color.from_hex("#000000"), + ) + + for idx, zone in enumerate(self.zones): + annotated_frame = sv.draw_polygon( + scene=annotated_frame, polygon=zone.polygon, color=COLORS.by_idx(idx) + ) + + detections_in_zone = detections[zone.trigger(detections)] + time_in_zone = self.timers[idx].tick(detections_in_zone) + custom_color_lookup = np.full(detections_in_zone.class_id.shape, idx) + + annotated_frame = COLOR_ANNOTATOR.annotate( + scene=annotated_frame, + detections=detections_in_zone, + custom_color_lookup=custom_color_lookup, + ) + labels = [ + f"#{tracker_id} {int(time // 60):02d}:{int(time % 60):02d}" + for tracker_id, time in zip(detections_in_zone.tracker_id, time_in_zone) + ] + annotated_frame = LABEL_ANNOTATOR.annotate( + scene=annotated_frame, + detections=detections_in_zone, + labels=labels, + custom_color_lookup=custom_color_lookup, + ) + cv2.imshow("Processed Video", annotated_frame) + cv2.waitKey(1) + + +def main( + zone_configuration_path: str, + rtsp_url: str, + model_id: str = "rfdetr-medium", + confidence_threshold: float = 0.3, + iou_threshold: float = 0.7, + classes: list[int] = [], + roboflow_api_key: str = "", +) -> None: + """ + Calculating detections dwell time in zones, using RTSP stream. + + Args: + zone_configuration_path: Path to the zone configuration JSON file + rtsp_url: Complete RTSP URL for the video stream + model_id: Roboflow model ID + confidence_threshold: Confidence level for detections (0 to 1) + iou_threshold: IOU threshold for non-max suppression + classes: List of class IDs to track. If empty, all classes are tracked + roboflow_api_key: Roboflow API key for accessing private models + """ + sink = CustomSink(zone_configuration_path=zone_configuration_path, classes=classes) + + pipeline = InferencePipeline.init( + model_id=model_id, + video_reference=rtsp_url, + on_prediction=sink.on_prediction, + confidence=confidence_threshold, + iou_threshold=iou_threshold, + api_key=roboflow_api_key, + ) + + pipeline.start() + + try: + pipeline.join() + except KeyboardInterrupt: + pipeline.terminate() + + +if __name__ == "__main__": + from jsonargparse import auto_cli, set_parsing_settings + + set_parsing_settings(parse_optionals_as_positionals=True) + auto_cli(main, as_positional=False) diff --git a/examples/time_in_zone/requirements.txt b/examples/time_in_zone/requirements.txt new file mode 100644 index 0000000..b4deae9 --- /dev/null +++ b/examples/time_in_zone/requirements.txt @@ -0,0 +1,9 @@ +supervision +ultralytics +inference +# https://github.com/pytube/pytube/issues/2044 +# pytube +pytubefix +jsonargparse[signatures] +rfdetr +yt_dlp diff --git a/examples/time_in_zone/rfdetr_file_example.py b/examples/time_in_zone/rfdetr_file_example.py new file mode 100644 index 0000000..2c9e4aa --- /dev/null +++ b/examples/time_in_zone/rfdetr_file_example.py @@ -0,0 +1,174 @@ +from __future__ import annotations + +from enum import Enum + +import cv2 +import numpy as np +from rfdetr import RFDETRBase, RFDETRLarge, RFDETRMedium, RFDETRNano, RFDETRSmall +from utils.general import find_in_list, load_zones_config +from utils.timers import FPSBasedTimer + +import supervision as sv + +COLORS = sv.ColorPalette.from_hex(["#E6194B", "#3CB44B", "#FFE119", "#3C76D1"]) +COLOR_ANNOTATOR = sv.ColorAnnotator(color=COLORS) +LABEL_ANNOTATOR = sv.LabelAnnotator( + color=COLORS, text_color=sv.Color.from_hex("#000000") +) + + +class ModelSize(Enum): + NANO = "nano" + SMALL = "small" + MEDIUM = "medium" + BASE = "base" + LARGE = "large" + + @classmethod + def list(cls) -> list[str]: + return list(map(lambda c: c.value, cls)) + + @classmethod + def from_value(cls, value: ModelSize | str) -> ModelSize: + if isinstance(value, cls): + return value + if isinstance(value, str): + value = value.lower() + try: + return cls(value) + except ValueError: + raise ValueError(f"Invalid value: {value}. Must be one of {cls.list()}") + raise ValueError( + f"Invalid value type: {type(value)}. Must be an instance of " + f"{cls.__name__} or str." + ) + + +def load_model( + checkpoint: ModelSize | str, device: str, resolution: int +) -> RFDETRBase | RFDETRLarge | RFDETRMedium | RFDETRNano | RFDETRSmall: + checkpoint = ModelSize.from_value(checkpoint) + + if checkpoint == ModelSize.NANO: + return RFDETRNano(device=device, resolution=resolution) + if checkpoint == ModelSize.SMALL: + return RFDETRSmall(device=device, resolution=resolution) + if checkpoint == ModelSize.MEDIUM: + return RFDETRMedium(device=device, resolution=resolution) + if checkpoint == ModelSize.BASE: + return RFDETRBase(device=device, resolution=resolution) + if checkpoint == ModelSize.LARGE: + return RFDETRLarge(device=device, resolution=resolution) + + raise ValueError( + f"Invalid checkpoint: {checkpoint}. Must be one of: {ModelSize.list()}." + ) + + +def adjust_resolution(checkpoint: ModelSize | str, resolution: int) -> int: + checkpoint = ModelSize.from_value(checkpoint) + + if checkpoint in {ModelSize.NANO, ModelSize.SMALL, ModelSize.MEDIUM}: + divisor = 32 + elif checkpoint in {ModelSize.BASE, ModelSize.LARGE}: + divisor = 56 + else: + raise ValueError( + f"Unknown checkpoint: {checkpoint}. Must be one of: {ModelSize.list()}." + ) + + remainder = resolution % divisor + if remainder == 0: + return resolution + lower = resolution - remainder + upper = lower + divisor + + if resolution - lower < upper - resolution: + return lower + else: + return upper + + +def main( + source_video_path: str, + zone_configuration_path: str, + resolution: int, + model_size: str = "small", + device: str = "cpu", + confidence_threshold: float = 0.3, + iou_threshold: float = 0.7, + classes: list[int] = [], +) -> None: + """ + Calculating detections dwell time in zones, using video file. + + Args: + source_video_path: Path to the source video file + zone_configuration_path: Path to the zone configuration JSON file + resolution: Input resolution for the model + model_size: RF-DETR model size ('nano', 'small', 'medium', 'base' or 'large') + device: Computation device ('cpu', 'mps' or 'cuda') + confidence_threshold: Confidence level for detections (0 to 1) + iou_threshold: IOU threshold for non-max suppression + classes: List of class IDs to track. If empty, all classes are tracked + """ + resolution = adjust_resolution(checkpoint=model_size, resolution=resolution) + model = load_model(checkpoint=model_size, device=device, resolution=resolution) + tracker = sv.ByteTrack(minimum_matching_threshold=0.5) + video_info = sv.VideoInfo.from_video_path(video_path=source_video_path) + frames_generator = sv.get_video_frames_generator(source_video_path) + + polygons = load_zones_config(file_path=zone_configuration_path) + zones = [ + sv.PolygonZone( + polygon=polygon, + triggering_anchors=(sv.Position.CENTER,), + ) + for polygon in polygons + ] + timers = [FPSBasedTimer(video_info.fps) for _ in zones] + + for frame in frames_generator: + detections = model.predict(frame, threshold=confidence_threshold) + detections = detections[find_in_list(detections.class_id, classes)] + detections = detections.with_nms(threshold=iou_threshold) + detections = tracker.update_with_detections(detections) + + annotated_frame = frame.copy() + + for idx, zone in enumerate(zones): + annotated_frame = sv.draw_polygon( + scene=annotated_frame, polygon=zone.polygon, color=COLORS.by_idx(idx) + ) + + detections_in_zone = detections[zone.trigger(detections)] + time_in_zone = timers[idx].tick(detections_in_zone) + custom_color_lookup = np.full(detections_in_zone.class_id.shape, idx) + + annotated_frame = COLOR_ANNOTATOR.annotate( + scene=annotated_frame, + detections=detections_in_zone, + custom_color_lookup=custom_color_lookup, + ) + labels = [ + f"#{tracker_id} {int(time // 60):02d}:{int(time % 60):02d}" + for tracker_id, time in zip(detections_in_zone.tracker_id, time_in_zone) + ] + annotated_frame = LABEL_ANNOTATOR.annotate( + scene=annotated_frame, + detections=detections_in_zone, + labels=labels, + custom_color_lookup=custom_color_lookup, + ) + + cv2.imshow("Processed Video", annotated_frame) + if cv2.waitKey(1) & 0xFF == ord("q"): + break + cv2.destroyAllWindows() + + +if __name__ == "__main__": + from jsonargparse import auto_cli, set_parsing_settings + + set_parsing_settings(parse_optionals_as_positionals=True) + auto_cli(main, as_positional=False) diff --git a/examples/time_in_zone/rfdetr_naive_stream_example.py b/examples/time_in_zone/rfdetr_naive_stream_example.py new file mode 100644 index 0000000..b517277 --- /dev/null +++ b/examples/time_in_zone/rfdetr_naive_stream_example.py @@ -0,0 +1,185 @@ +from __future__ import annotations + +from enum import Enum + +import cv2 +import numpy as np +from rfdetr import RFDETRBase, RFDETRLarge, RFDETRMedium, RFDETRNano, RFDETRSmall +from utils.general import find_in_list, get_stream_frames_generator, load_zones_config +from utils.timers import ClockBasedTimer + +import supervision as sv + +COLORS = sv.ColorPalette.from_hex(["#E6194B", "#3CB44B", "#FFE119", "#3C76D1"]) +COLOR_ANNOTATOR = sv.ColorAnnotator(color=COLORS) +LABEL_ANNOTATOR = sv.LabelAnnotator( + color=COLORS, text_color=sv.Color.from_hex("#000000") +) + + +class ModelSize(Enum): + NANO = "nano" + SMALL = "small" + MEDIUM = "medium" + BASE = "base" + LARGE = "large" + + @classmethod + def list(cls) -> list[str]: + return list(map(lambda c: c.value, cls)) + + @classmethod + def from_value(cls, value: ModelSize | str) -> ModelSize: + if isinstance(value, cls): + return value + if isinstance(value, str): + value = value.lower() + try: + return cls(value) + except ValueError: + raise ValueError(f"Invalid value: {value}. Must be one of {cls.list()}") + raise ValueError( + f"Invalid value type: {type(value)}. Must be an instance of " + f"{cls.__name__} or str." + ) + + +def load_model( + checkpoint: ModelSize | str, device: str, resolution: int +) -> RFDETRBase | RFDETRLarge | RFDETRMedium | RFDETRNano | RFDETRSmall: + checkpoint = ModelSize.from_value(checkpoint) + + if checkpoint == ModelSize.NANO: + return RFDETRNano(device=device, resolution=resolution) + if checkpoint == ModelSize.SMALL: + return RFDETRSmall(device=device, resolution=resolution) + if checkpoint == ModelSize.MEDIUM: + return RFDETRMedium(device=device, resolution=resolution) + if checkpoint == ModelSize.BASE: + return RFDETRBase(device=device, resolution=resolution) + if checkpoint == ModelSize.LARGE: + return RFDETRLarge(device=device, resolution=resolution) + + raise ValueError( + f"Invalid checkpoint: {checkpoint}. Must be one of: {ModelSize.list()}." + ) + + +def adjust_resolution(checkpoint: ModelSize | str, resolution: int) -> int: + checkpoint = ModelSize.from_value(checkpoint) + + if checkpoint in {ModelSize.NANO, ModelSize.SMALL, ModelSize.MEDIUM}: + divisor = 32 + elif checkpoint in {ModelSize.BASE, ModelSize.LARGE}: + divisor = 56 + else: + raise ValueError( + f"Unknown checkpoint: {checkpoint}. Must be one of: {ModelSize.list()}." + ) + + remainder = resolution % divisor + if remainder == 0: + return resolution + lower = resolution - remainder + upper = lower + divisor + + if resolution - lower < upper - resolution: + return lower + else: + return upper + + +def main( + rtsp_url: str, + zone_configuration_path: str, + resolution: int, + model_size: str = "small", + device: str = "cpu", + confidence_threshold: float = 0.3, + iou_threshold: float = 0.7, + classes: list[int] = [], +) -> None: + """ + Calculating detections dwell time in zones, using RTSP stream. + + Args: + rtsp_url: Complete RTSP URL for the video stream + zone_configuration_path: Path to the zone configuration JSON file + resolution: Input resolution for the model + model_size: RF-DETR model size ('nano', 'small', 'medium', 'base' or 'large') + device: Computation device ('cpu', 'mps' or 'cuda') + confidence_threshold: Confidence level for detections (0 to 1) + iou_threshold: IOU threshold for non-max suppression + classes: List of class IDs to track. If empty, all classes are tracked + """ + resolution = adjust_resolution(checkpoint=model_size, resolution=resolution) + model = load_model(checkpoint=model_size, device=device, resolution=resolution) + tracker = sv.ByteTrack(minimum_matching_threshold=0.5) + frames_generator = get_stream_frames_generator(rtsp_url=rtsp_url) + fps_monitor = sv.FPSMonitor() + + polygons = load_zones_config(file_path=zone_configuration_path) + zones = [ + sv.PolygonZone( + polygon=polygon, + triggering_anchors=(sv.Position.CENTER,), + ) + for polygon in polygons + ] + timers = [ClockBasedTimer() for _ in zones] + + for frame in frames_generator: + fps_monitor.tick() + fps = fps_monitor.fps + + detections = model.predict(frame, threshold=confidence_threshold) + detections = detections[find_in_list(detections.class_id, classes)] + detections = detections.with_nms(threshold=iou_threshold) + detections = tracker.update_with_detections(detections) + + annotated_frame = frame.copy() + annotated_frame = sv.draw_text( + scene=annotated_frame, + text=f"{fps:.1f}", + text_anchor=sv.Point(40, 30), + background_color=sv.Color.from_hex("#A351FB"), + text_color=sv.Color.from_hex("#000000"), + ) + + for idx, zone in enumerate(zones): + annotated_frame = sv.draw_polygon( + scene=annotated_frame, polygon=zone.polygon, color=COLORS.by_idx(idx) + ) + + detections_in_zone = detections[zone.trigger(detections)] + time_in_zone = timers[idx].tick(detections_in_zone) + custom_color_lookup = np.full(detections_in_zone.class_id.shape, idx) + + annotated_frame = COLOR_ANNOTATOR.annotate( + scene=annotated_frame, + detections=detections_in_zone, + custom_color_lookup=custom_color_lookup, + ) + labels = [ + f"#{tracker_id} {int(t // 60):02d}:{int(t % 60):02d}" + for tracker_id, t in zip(detections_in_zone.tracker_id, time_in_zone) + ] + annotated_frame = LABEL_ANNOTATOR.annotate( + scene=annotated_frame, + detections=detections_in_zone, + labels=labels, + custom_color_lookup=custom_color_lookup, + ) + + cv2.imshow("Processed Video", annotated_frame) + if cv2.waitKey(1) & 0xFF == ord("q"): + break + + cv2.destroyAllWindows() + + +if __name__ == "__main__": + from jsonargparse import auto_cli, set_parsing_settings + + set_parsing_settings(parse_optionals_as_positionals=True) + auto_cli(main, as_positional=False) diff --git a/examples/time_in_zone/rfdetr_stream_example.py b/examples/time_in_zone/rfdetr_stream_example.py new file mode 100644 index 0000000..678faaf --- /dev/null +++ b/examples/time_in_zone/rfdetr_stream_example.py @@ -0,0 +1,184 @@ +from __future__ import annotations + +from enum import Enum + +import cv2 +import numpy as np +from inference import InferencePipeline +from inference.core.interfaces.camera.entities import VideoFrame +from rfdetr import RFDETRBase, RFDETRLarge, RFDETRMedium, RFDETRNano, RFDETRSmall +from utils.general import find_in_list, load_zones_config +from utils.timers import ClockBasedTimer + +import supervision as sv + + +class ModelSize(Enum): + NANO = "nano" + SMALL = "small" + MEDIUM = "medium" + BASE = "base" + LARGE = "large" + + @classmethod + def list(cls) -> list[str]: + return [c.value for c in cls] + + @classmethod + def from_value(cls, value: ModelSize | str) -> ModelSize: + if isinstance(value, cls): + return value + if isinstance(value, str): + value = value.lower() + try: + return cls(value) + except ValueError as exc: + raise ValueError( + f"Invalid model size '{value}'. Must be one of {cls.list()}." + ) from exc + raise ValueError( + f"Invalid value type '{type(value)}'. Expected str or ModelSize." + ) + + +def load_model( + checkpoint: ModelSize | str, device: str, resolution: int +) -> RFDETRBase | RFDETRLarge | RFDETRMedium | RFDETRNano | RFDETRSmall: + checkpoint = ModelSize.from_value(checkpoint) + if checkpoint == ModelSize.NANO: + return RFDETRNano(device=device, resolution=resolution) + if checkpoint == ModelSize.SMALL: + return RFDETRSmall(device=device, resolution=resolution) + if checkpoint == ModelSize.MEDIUM: + return RFDETRMedium(device=device, resolution=resolution) + if checkpoint == ModelSize.BASE: + return RFDETRBase(device=device, resolution=resolution) + if checkpoint == ModelSize.LARGE: + return RFDETRLarge(device=device, resolution=resolution) + raise RuntimeError("Unhandled checkpoint type.") + + +def adjust_resolution(checkpoint: ModelSize | str, resolution: int) -> int: + checkpoint = ModelSize.from_value(checkpoint) + divisor = ( + 32 if checkpoint in {ModelSize.NANO, ModelSize.SMALL, ModelSize.MEDIUM} else 56 + ) + remainder = resolution % divisor + if remainder == 0: + return resolution + lower = resolution - remainder + upper = lower + divisor + return lower if resolution - lower < upper - resolution else upper + + +COLORS = sv.ColorPalette.from_hex(["#E6194B", "#3CB44B", "#FFE119", "#3C76D1"]) +COLOR_ANNOTATOR = sv.ColorAnnotator(color=COLORS) +LABEL_ANNOTATOR = sv.LabelAnnotator( + color=COLORS, text_color=sv.Color.from_hex("#000000") +) + + +class CustomSink: + def __init__(self, zone_configuration_path: str, classes: list[int]) -> None: + self.classes = classes + self.tracker = sv.ByteTrack(minimum_matching_threshold=0.8) + self.fps_monitor = sv.FPSMonitor() + self.polygons = load_zones_config(file_path=zone_configuration_path) + self.timers = [ClockBasedTimer() for _ in self.polygons] + self.zones = [ + sv.PolygonZone( + polygon=polygon, + triggering_anchors=(sv.Position.CENTER,), + ) + for polygon in self.polygons + ] + + def on_prediction(self, detections: sv.Detections, frame: VideoFrame) -> None: + self.fps_monitor.tick() + fps = self.fps_monitor.fps + detections = detections[find_in_list(detections.class_id, self.classes)] + detections = self.tracker.update_with_detections(detections) + annotated_frame = frame.image.copy() + annotated_frame = sv.draw_text( + scene=annotated_frame, + text=f"{fps:.1f}", + text_anchor=sv.Point(40, 30), + background_color=sv.Color.from_hex("#A351FB"), + text_color=sv.Color.from_hex("#000000"), + ) + for idx, zone in enumerate(self.zones): + annotated_frame = sv.draw_polygon( + scene=annotated_frame, + polygon=zone.polygon, + color=COLORS.by_idx(idx), + ) + detections_in_zone = detections[zone.trigger(detections)] + time_in_zone = self.timers[idx].tick(detections_in_zone) + custom_color_lookup = np.full(detections_in_zone.class_id.shape, idx) + annotated_frame = COLOR_ANNOTATOR.annotate( + scene=annotated_frame, + detections=detections_in_zone, + custom_color_lookup=custom_color_lookup, + ) + labels = [ + f"#{tracker_id} {int(t // 60):02d}:{int(t % 60):02d}" + for tracker_id, t in zip(detections_in_zone.tracker_id, time_in_zone) + ] + annotated_frame = LABEL_ANNOTATOR.annotate( + scene=annotated_frame, + detections=detections_in_zone, + labels=labels, + custom_color_lookup=custom_color_lookup, + ) + cv2.imshow("Processed Video", annotated_frame) + cv2.waitKey(1) + + +def main( + rtsp_url: str, + zone_configuration_path: str, + resolution: int, + model_size: str = "small", + device: str = "cpu", + confidence_threshold: float = 0.3, + iou_threshold: float = 0.7, + classes: list[int] = [], +) -> None: + """ + Calculating detections dwell time in zones using an RTSP stream. + + Args: + rtsp_url: Complete RTSP URL for the video stream + zone_configuration_path: Path to the zone configuration JSON file + resolution: Input resolution for the model + model_size: RF-DETR model size ('nano', 'small', 'medium', 'base' or 'large') + device: Computation device ('cpu', 'mps' or 'cuda') + confidence_threshold: Confidence level for detections (0 to 1) + iou_threshold: IOU threshold for non-max suppression + classes: List of class IDs to track. If empty, all classes are tracked + """ + resolution = adjust_resolution(checkpoint=model_size, resolution=resolution) + model = load_model(checkpoint=model_size, device=device, resolution=resolution) + + def inference_callback(frames: list[VideoFrame]) -> list[sv.Detections]: + dets = model.predict(frames[0].image, threshold=confidence_threshold) + return [dets.with_nms(threshold=iou_threshold)] + + sink = CustomSink(zone_configuration_path=zone_configuration_path, classes=classes) + pipeline = InferencePipeline.init_with_custom_logic( + video_reference=rtsp_url, + on_video_frame=inference_callback, + on_prediction=sink.on_prediction, + ) + pipeline.start() + try: + pipeline.join() + except KeyboardInterrupt: + pipeline.terminate() + + +if __name__ == "__main__": + from jsonargparse import auto_cli, set_parsing_settings + + set_parsing_settings(parse_optionals_as_positionals=True) + auto_cli(main, as_positional=False) diff --git a/examples/time_in_zone/scripts/download_from_youtube.py b/examples/time_in_zone/scripts/download_from_youtube.py new file mode 100644 index 0000000..029a946 --- /dev/null +++ b/examples/time_in_zone/scripts/download_from_youtube.py @@ -0,0 +1,61 @@ +import os +import sys +from typing import Any + +import yt_dlp +from jsonargparse import auto_cli +from yt_dlp.utils import DownloadError + + +def _build_ydl_opts(output_path: str | None, file_name: str | None) -> dict[str, Any]: + out_dir = output_path or "." + + if not os.path.exists(out_dir): + os.makedirs(out_dir) + + name_template = file_name if file_name else "%(title)s.%(ext)s" + + return { + "format": ( + "bestvideo[ext=mp4][vcodec!*=av01][height<=2160]+bestaudio[ext=m4a]/" + "best[ext=mp4][vcodec!*=av01][height<=2160]/" + "bestvideo+bestaudio/best" + ), + "merge_output_format": "mp4", + "outtmpl": os.path.join(out_dir, name_template), + "quiet": False, + "noplaylist": True, + } + + +def main( + url: str, output_path: str = "data/source", file_name: str = "video.mp4" +) -> None: + """ + Download a specific YouTube video by providing its URL. + + Args: + url: The full URL of the YouTube video you wish to download. + output_path: Specifies the directory where the video will be saved. + file_name: Sets the name of the saved video file. + """ + # ssl._create_default_https_context = ssl._create_unverified_context + ydl_opts = _build_ydl_opts(output_path, file_name) + + try: + with yt_dlp.YoutubeDL(ydl_opts) as ydl: + ydl.download([url]) + except DownloadError as err: + print(f"Download failed: {err}", file=sys.stderr) + sys.exit(1) + + final_name = file_name if file_name else "the video title" + final_path = output_path if output_path else "current directory" + print(f"Download completed! Video saved as '{final_name}' in '{final_path}'.") + + +if __name__ == "__main__": + from jsonargparse import auto_cli, set_parsing_settings + + set_parsing_settings(parse_optionals_as_positionals=True) + auto_cli(main, as_positional=False) diff --git a/examples/time_in_zone/scripts/draw_zones.py b/examples/time_in_zone/scripts/draw_zones.py new file mode 100644 index 0000000..a6bea0b --- /dev/null +++ b/examples/time_in_zone/scripts/draw_zones.py @@ -0,0 +1,168 @@ +import json +import os +from typing import Any + +import cv2 +import numpy as np +from jsonargparse import auto_cli + +import supervision as sv + +KEY_ENTER = 13 +KEY_NEWLINE = 10 +KEY_ESCAPE = 27 +KEY_QUIT = ord("q") +KEY_SAVE = ord("s") + +THICKNESS = 2 +COLORS = sv.ColorPalette.DEFAULT +WINDOW_NAME = "Draw Zones" +POLYGONS = [[]] + +current_mouse_position: tuple[int, int] | None = None + + +def resolve_source(source_path: str) -> np.ndarray | None: + if not os.path.exists(source_path): + return None + + image = cv2.imread(source_path) + if image is not None: + return image + + frame_generator = sv.get_video_frames_generator(source_path=source_path) + frame = next(frame_generator) + return frame + + +def mouse_event(event: int, x: int, y: int, flags: int, param: Any) -> None: + global current_mouse_position + if event == cv2.EVENT_MOUSEMOVE: + current_mouse_position = (x, y) + elif event == cv2.EVENT_LBUTTONDOWN: + POLYGONS[-1].append((x, y)) + + +def redraw(image: np.ndarray, original_image: np.ndarray) -> None: + global POLYGONS, current_mouse_position + image[:] = original_image.copy() + for idx, polygon in enumerate(POLYGONS): + color = ( + COLORS.by_idx(idx).as_bgr() + if idx < len(POLYGONS) - 1 + else sv.Color.WHITE.as_bgr() + ) + + if len(polygon) > 1: + for i in range(1, len(polygon)): + cv2.line( + img=image, + pt1=polygon[i - 1], + pt2=polygon[i], + color=color, + thickness=THICKNESS, + ) + if idx < len(POLYGONS) - 1: + cv2.line( + img=image, + pt1=polygon[-1], + pt2=polygon[0], + color=color, + thickness=THICKNESS, + ) + if idx == len(POLYGONS) - 1 and current_mouse_position is not None and polygon: + cv2.line( + img=image, + pt1=polygon[-1], + pt2=current_mouse_position, + color=color, + thickness=THICKNESS, + ) + cv2.imshow(WINDOW_NAME, image) + + +def close_and_finalize_polygon(image: np.ndarray, original_image: np.ndarray) -> None: + if len(POLYGONS[-1]) > 2: + cv2.line( + img=image, + pt1=POLYGONS[-1][-1], + pt2=POLYGONS[-1][0], + color=COLORS.by_idx(0).as_bgr(), + thickness=THICKNESS, + ) + POLYGONS.append([]) + image[:] = original_image.copy() + redraw_polygons(image) + cv2.imshow(WINDOW_NAME, image) + + +def redraw_polygons(image: np.ndarray) -> None: + for idx, polygon in enumerate(POLYGONS[:-1]): + if len(polygon) > 1: + color = COLORS.by_idx(idx).as_bgr() + for i in range(len(polygon) - 1): + cv2.line( + img=image, + pt1=polygon[i], + pt2=polygon[i + 1], + color=color, + thickness=THICKNESS, + ) + cv2.line( + img=image, + pt1=polygon[-1], + pt2=polygon[0], + color=color, + thickness=THICKNESS, + ) + + +def save_polygons_to_json( + polygons: list[list[tuple[int, int]]], target_path: str | os.PathLike[str] +) -> None: + data_to_save = polygons if polygons[-1] else polygons[:-1] + with open(target_path, "w") as f: + json.dump(data_to_save, f) + + +def main(source_path: str, zone_configuration_path: str) -> None: + """ + Interactively draw polygons on images or video frames and save the annotations. + + Args: + source_path: Path to the source image or video file for drawing polygons. + zone_configuration_path: Path where the polygon annotations saved as JSON file. + """ + global current_mouse_position + original_image = resolve_source(source_path=source_path) + if original_image is None: + print("Failed to load source image.") + return + + image = original_image.copy() + cv2.imshow(WINDOW_NAME, image) + cv2.setMouseCallback(WINDOW_NAME, mouse_event, image) + + while True: + key = cv2.waitKey(1) & 0xFF + if key == KEY_ENTER or key == KEY_NEWLINE: + close_and_finalize_polygon(image, original_image) + elif key == KEY_ESCAPE: + POLYGONS[-1] = [] + current_mouse_position = None + elif key == KEY_SAVE: + save_polygons_to_json(POLYGONS, zone_configuration_path) + print(f"Polygons saved to {zone_configuration_path}") + break + redraw(image, original_image) + if key == KEY_QUIT: + break + + cv2.destroyAllWindows() + + +if __name__ == "__main__": + from jsonargparse import auto_cli, set_parsing_settings + + set_parsing_settings(parse_optionals_as_positionals=True) + auto_cli(main, as_positional=False) diff --git a/examples/time_in_zone/scripts/stream_from_file.py b/examples/time_in_zone/scripts/stream_from_file.py new file mode 100644 index 0000000..4208f4d --- /dev/null +++ b/examples/time_in_zone/scripts/stream_from_file.py @@ -0,0 +1,95 @@ +import os +import subprocess +import tempfile +from glob import glob +from threading import Thread + +import yaml +from jsonargparse import auto_cli + +SERVER_CONFIG = {"protocols": ["tcp"], "paths": {"all": {"source": "publisher"}}} +BASE_STREAM_URL = "rtsp://localhost:8554/live" + + +def main(video_directory: str, number_of_streams: int = 6) -> None: + """ + Script to stream videos using RTSP protocol. + + Args: + video_directory: Directory containing video files to stream. + number_of_streams: Number of video files to stream. + """ + video_files = find_video_files_in_directory(video_directory, number_of_streams) + try: + with tempfile.TemporaryDirectory() as temporary_directory: + config_file_path = create_server_config_file(temporary_directory) + run_rtsp_server(config_path=config_file_path) + stream_videos(video_files) + finally: + stop_rtsp_server() + + +def find_video_files_in_directory(directory: str, limit: int) -> list: + video_formats = ["*.mp4", "*.webm"] + video_paths = [] + for video_format in video_formats: + video_paths.extend(glob(os.path.join(directory, video_format))) + return video_paths[:limit] + + +def create_server_config_file(directory: str) -> str: + config_path = os.path.join(directory, "rtsp-simple-server.yml") + with open(config_path, "w") as config_file: + yaml.dump(SERVER_CONFIG, config_file) + return config_path + + +def run_rtsp_server(config_path: str) -> None: + command = ( + "docker run --rm --name rtsp_server -d -v " + f"{config_path}:/rtsp-simple-server.yml -p 8554:8554 " + "aler9/rtsp-simple-server:v1.3.0" + ) + if run_command(command.split()) != 0: + raise RuntimeError("Could not start the RTSP server!") + + +def stop_rtsp_server() -> None: + run_command("docker kill rtsp_server".split()) + + +def stream_videos(video_files: list) -> None: + threads = [] + for index, video_file in enumerate(video_files): + stream_url = f"{BASE_STREAM_URL}{index}.stream" + print(f"Streaming {video_file} under {stream_url}") + thread = stream_video_to_url(video_file, stream_url) + threads.append(thread) + for thread in threads: + thread.join() + + +def stream_video_to_url(video_path: str, stream_url: str) -> Thread: + command = ( + f"ffmpeg -re -stream_loop -1 -i {video_path} " + f"-f rtsp -rtsp_transport tcp {stream_url}" + ) + return run_command_in_thread(command.split()) + + +def run_command_in_thread(command: list) -> Thread: + thread = Thread(target=run_command, args=(command,)) + thread.start() + return thread + + +def run_command(command: list) -> int: + process = subprocess.run(command) # noqa: S603 # TODO: Validate command input to prevent execution of untrusted input + return process.returncode + + +if __name__ == "__main__": + from jsonargparse import auto_cli, set_parsing_settings + + set_parsing_settings(parse_optionals_as_positionals=True) + auto_cli(main, as_positional=False) diff --git a/examples/time_in_zone/ultralytics_file_example.py b/examples/time_in_zone/ultralytics_file_example.py new file mode 100644 index 0000000..55e9ddc --- /dev/null +++ b/examples/time_in_zone/ultralytics_file_example.py @@ -0,0 +1,101 @@ +import cv2 +import numpy as np +from ultralytics import YOLO +from utils.general import find_in_list, load_zones_config +from utils.timers import FPSBasedTimer + +import supervision as sv + +COLORS = sv.ColorPalette.from_hex(["#E6194B", "#3CB44B", "#FFE119", "#3C76D1"]) +COLOR_ANNOTATOR = sv.ColorAnnotator(color=COLORS) +LABEL_ANNOTATOR = sv.LabelAnnotator( + color=COLORS, text_color=sv.Color.from_hex("#000000") +) + + +def main( + zone_configuration_path: str, + source_video_path: str, + weights: str = "yolov8s.pt", + device: str = "cpu", + confidence_threshold: float = 0.3, + iou_threshold: float = 0.7, + classes: list[int] = [], +) -> None: + """ + Calculating detections dwell time in zones, using video file. + + Args: + zone_configuration_path: Path to the zone configuration JSON file + source_video_path: Path to the source video file + weights: Path to the model weights file + device: Computation device ('cpu', 'mps' or 'cuda') + confidence_threshold: Confidence level for detections (0 to 1) + iou_threshold: IOU threshold for non-max suppression + classes: List of class IDs to track. If empty, all classes are tracked + """ + model = YOLO(weights) + tracker = sv.ByteTrack(minimum_matching_threshold=0.5) + video_info = sv.VideoInfo.from_video_path(video_path=source_video_path) + frames_generator = sv.get_video_frames_generator(source_video_path) + + polygons = load_zones_config(file_path=zone_configuration_path) + zones = [ + sv.PolygonZone( + polygon=polygon, + triggering_anchors=(sv.Position.CENTER,), + ) + for polygon in polygons + ] + timers = [FPSBasedTimer(video_info.fps) for _ in zones] + + for frame in frames_generator: + results = model( + frame, + verbose=False, + device=device, + conf=confidence_threshold, + iou=iou_threshold, + )[0] + detections = sv.Detections.from_ultralytics(results) + detections = detections[find_in_list(detections.class_id, classes)] + detections = tracker.update_with_detections(detections) + + annotated_frame = frame.copy() + + for idx, zone in enumerate(zones): + annotated_frame = sv.draw_polygon( + scene=annotated_frame, polygon=zone.polygon, color=COLORS.by_idx(idx) + ) + + detections_in_zone = detections[zone.trigger(detections)] + time_in_zone = timers[idx].tick(detections_in_zone) + custom_color_lookup = np.full(detections_in_zone.class_id.shape, idx) + + annotated_frame = COLOR_ANNOTATOR.annotate( + scene=annotated_frame, + detections=detections_in_zone, + custom_color_lookup=custom_color_lookup, + ) + labels = [ + f"#{tracker_id} {int(time // 60):02d}:{int(time % 60):02d}" + for tracker_id, time in zip(detections_in_zone.tracker_id, time_in_zone) + ] + annotated_frame = LABEL_ANNOTATOR.annotate( + scene=annotated_frame, + detections=detections_in_zone, + labels=labels, + custom_color_lookup=custom_color_lookup, + ) + + cv2.imshow("Processed Video", annotated_frame) + if cv2.waitKey(1) & 0xFF == ord("q"): + break + cv2.destroyAllWindows() + + +if __name__ == "__main__": + from jsonargparse import auto_cli, set_parsing_settings + + set_parsing_settings(parse_optionals_as_positionals=True) + auto_cli(main, as_positional=False) diff --git a/examples/time_in_zone/ultralytics_naive_stream_example.py b/examples/time_in_zone/ultralytics_naive_stream_example.py new file mode 100644 index 0000000..2f50aab --- /dev/null +++ b/examples/time_in_zone/ultralytics_naive_stream_example.py @@ -0,0 +1,111 @@ +import cv2 +import numpy as np +from ultralytics import YOLO +from utils.general import find_in_list, get_stream_frames_generator, load_zones_config +from utils.timers import ClockBasedTimer + +import supervision as sv + +COLORS = sv.ColorPalette.from_hex(["#E6194B", "#3CB44B", "#FFE119", "#3C76D1"]) +COLOR_ANNOTATOR = sv.ColorAnnotator(color=COLORS) +LABEL_ANNOTATOR = sv.LabelAnnotator( + color=COLORS, text_color=sv.Color.from_hex("#000000") +) + + +def main( + zone_configuration_path: str, + rtsp_url: str, + weights: str = "yolov8s.pt", + device: str = "cpu", + confidence_threshold: float = 0.3, + iou_threshold: float = 0.7, + classes: list[int] = [], +) -> None: + """ + Calculating detections dwell time in zones, using RTSP stream. + + Args: + zone_configuration_path: Path to the zone configuration JSON file + rtsp_url: Complete RTSP URL for the video stream + weights: Path to the model weights file + device: Computation device ('cpu', 'mps' or 'cuda') + confidence_threshold: Confidence level for detections (0 to 1) + iou_threshold: IOU threshold for non-max suppression + classes: List of class IDs to track. If empty, all classes are tracked + """ + model = YOLO(weights) + tracker = sv.ByteTrack(minimum_matching_threshold=0.5) + frames_generator = get_stream_frames_generator(rtsp_url=rtsp_url) + fps_monitor = sv.FPSMonitor() + + polygons = load_zones_config(file_path=zone_configuration_path) + zones = [ + sv.PolygonZone( + polygon=polygon, + triggering_anchors=(sv.Position.CENTER,), + ) + for polygon in polygons + ] + timers = [ClockBasedTimer() for _ in zones] + + for frame in frames_generator: + fps_monitor.tick() + fps = fps_monitor.fps + + results = model( + frame, + verbose=False, + device=device, + conf=confidence_threshold, + iou=iou_threshold, + )[0] + detections = sv.Detections.from_ultralytics(results) + detections = detections[find_in_list(detections.class_id, classes)] + detections = tracker.update_with_detections(detections) + + annotated_frame = frame.copy() + annotated_frame = sv.draw_text( + scene=annotated_frame, + text=f"{fps:.1f}", + text_anchor=sv.Point(40, 30), + background_color=sv.Color.from_hex("#A351FB"), + text_color=sv.Color.from_hex("#000000"), + ) + + for idx, zone in enumerate(zones): + annotated_frame = sv.draw_polygon( + scene=annotated_frame, polygon=zone.polygon, color=COLORS.by_idx(idx) + ) + + detections_in_zone = detections[zone.trigger(detections)] + time_in_zone = timers[idx].tick(detections_in_zone) + custom_color_lookup = np.full(detections_in_zone.class_id.shape, idx) + + annotated_frame = COLOR_ANNOTATOR.annotate( + scene=annotated_frame, + detections=detections_in_zone, + custom_color_lookup=custom_color_lookup, + ) + labels = [ + f"#{tracker_id} {int(time // 60):02d}:{int(time % 60):02d}" + for tracker_id, time in zip(detections_in_zone.tracker_id, time_in_zone) + ] + annotated_frame = LABEL_ANNOTATOR.annotate( + scene=annotated_frame, + detections=detections_in_zone, + labels=labels, + custom_color_lookup=custom_color_lookup, + ) + + cv2.imshow("Processed Video", annotated_frame) + if cv2.waitKey(1) & 0xFF == ord("q"): + break + cv2.destroyAllWindows() + + +if __name__ == "__main__": + from jsonargparse import auto_cli, set_parsing_settings + + set_parsing_settings(parse_optionals_as_positionals=True) + auto_cli(main, as_positional=False) diff --git a/examples/time_in_zone/ultralytics_stream_example.py b/examples/time_in_zone/ultralytics_stream_example.py new file mode 100644 index 0000000..ca44fcf --- /dev/null +++ b/examples/time_in_zone/ultralytics_stream_example.py @@ -0,0 +1,128 @@ +import cv2 +import numpy as np +from inference import InferencePipeline +from inference.core.interfaces.camera.entities import VideoFrame +from ultralytics import YOLO +from utils.general import find_in_list, load_zones_config +from utils.timers import ClockBasedTimer + +import supervision as sv + +COLORS = sv.ColorPalette.from_hex(["#E6194B", "#3CB44B", "#FFE119", "#3C76D1"]) +COLOR_ANNOTATOR = sv.ColorAnnotator(color=COLORS) +LABEL_ANNOTATOR = sv.LabelAnnotator( + color=COLORS, text_color=sv.Color.from_hex("#000000") +) + + +class CustomSink: + def __init__(self, zone_configuration_path: str, classes: list[int]) -> None: + self.classes = classes + self.tracker = sv.ByteTrack(minimum_matching_threshold=0.8) + self.fps_monitor = sv.FPSMonitor() + self.polygons = load_zones_config(file_path=zone_configuration_path) + self.timers = [ClockBasedTimer() for _ in self.polygons] + self.zones = [ + sv.PolygonZone( + polygon=polygon, + triggering_anchors=(sv.Position.CENTER,), + ) + for polygon in self.polygons + ] + + def on_prediction(self, detections: sv.Detections, frame: VideoFrame) -> None: + self.fps_monitor.tick() + fps = self.fps_monitor.fps + + detections = detections[find_in_list(detections.class_id, self.classes)] + detections = self.tracker.update_with_detections(detections) + + annotated_frame = frame.image.copy() + annotated_frame = sv.draw_text( + scene=annotated_frame, + text=f"{fps:.1f}", + text_anchor=sv.Point(40, 30), + background_color=sv.Color.from_hex("#A351FB"), + text_color=sv.Color.from_hex("#000000"), + ) + + for idx, zone in enumerate(self.zones): + annotated_frame = sv.draw_polygon( + scene=annotated_frame, polygon=zone.polygon, color=COLORS.by_idx(idx) + ) + + detections_in_zone = detections[zone.trigger(detections)] + time_in_zone = self.timers[idx].tick(detections_in_zone) + custom_color_lookup = np.full(detections_in_zone.class_id.shape, idx) + + annotated_frame = COLOR_ANNOTATOR.annotate( + scene=annotated_frame, + detections=detections_in_zone, + custom_color_lookup=custom_color_lookup, + ) + labels = [ + f"#{tracker_id} {int(time // 60):02d}:{int(time % 60):02d}" + for tracker_id, time in zip(detections_in_zone.tracker_id, time_in_zone) + ] + annotated_frame = LABEL_ANNOTATOR.annotate( + scene=annotated_frame, + detections=detections_in_zone, + labels=labels, + custom_color_lookup=custom_color_lookup, + ) + cv2.imshow("Processed Video", annotated_frame) + cv2.waitKey(1) + + +def main( + zone_configuration_path: str, + rtsp_url: str, + weights: str = "yolov8s.pt", + device: str = "cpu", + confidence_threshold: float = 0.3, + iou_threshold: float = 0.7, + classes: list[int] = [], +) -> None: + """ + Calculating detections dwell time in zones, using RTSP stream. + + Args: + zone_configuration_path: Path to the zone configuration JSON file + rtsp_url: Complete RTSP URL for the video stream + weights: Path to the model weights file + device: Computation device ('cpu', 'mps' or 'cuda') + confidence_threshold: Confidence level for detections (0 to 1) + iou_threshold: IOU threshold for non-max suppression + classes: List of class IDs to track. If empty, all classes are tracked + """ + model = YOLO(weights) + + def inference_callback(frames: list[VideoFrame]) -> list[sv.Detections]: + results = model( + frames[0].image, verbose=False, conf=confidence_threshold, device=device + )[0] + return [ + sv.Detections.from_ultralytics(results).with_nms(threshold=iou_threshold) + ] + + sink = CustomSink(zone_configuration_path=zone_configuration_path, classes=classes) + + pipeline = InferencePipeline.init_with_custom_logic( + video_reference=rtsp_url, + on_video_frame=inference_callback, + on_prediction=sink.on_prediction, + ) + + pipeline.start() + + try: + pipeline.join() + except KeyboardInterrupt: + pipeline.terminate() + + +if __name__ == "__main__": + from jsonargparse import auto_cli, set_parsing_settings + + set_parsing_settings(parse_optionals_as_positionals=True) + auto_cli(main, as_positional=False) diff --git a/examples/time_in_zone/utils/__init__.py b/examples/time_in_zone/utils/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/examples/time_in_zone/utils/general.py b/examples/time_in_zone/utils/general.py new file mode 100644 index 0000000..a40b36c --- /dev/null +++ b/examples/time_in_zone/utils/general.py @@ -0,0 +1,66 @@ +import json +from collections.abc import Generator + +import cv2 +import numpy as np + + +def load_zones_config(file_path: str) -> list[np.ndarray]: + """ + Load polygon zone configurations from a JSON file. + + This function reads a JSON file which contains polygon coordinates, and + converts them into a list of NumPy arrays. Each polygon is represented as + a NumPy array of coordinates. + + Args: + file_path (str): The path to the JSON configuration file. + + Returns: + List[np.ndarray]: A list of polygons, each represented as a NumPy array. + """ + with open(file_path) as file: + data = json.load(file) + return [np.array(polygon, np.int32) for polygon in data] + + +def find_in_list(array: np.ndarray, search_list: list[int]) -> np.ndarray: + """Determines if elements of a numpy array are present in a list. + + Args: + array (np.ndarray): The numpy array of integers to check. + search_list (List[int]): The list of integers to search within. + + Returns: + np.ndarray: A numpy array of booleans, where each boolean indicates whether + the corresponding element in `array` is found in `search_list`. + """ + if not search_list: + return np.ones(array.shape, dtype=bool) + else: + return np.isin(array, search_list) + + +def get_stream_frames_generator(rtsp_url: str) -> Generator[np.ndarray, None, None]: + """ + Generator function to yield frames from an RTSP stream. + + Args: + rtsp_url (str): URL of the RTSP video stream. + + Yields: + np.ndarray: The next frame from the video stream. + """ + cap = cv2.VideoCapture(rtsp_url) + if not cap.isOpened(): + raise Exception("Error: Could not open video stream.") + + try: + while True: + ret, frame = cap.read() + if not ret: + print("End of stream or error reading frame.") + break + yield frame + finally: + cap.release() diff --git a/examples/time_in_zone/utils/timers.py b/examples/time_in_zone/utils/timers.py new file mode 100644 index 0000000..bf8e5df --- /dev/null +++ b/examples/time_in_zone/utils/timers.py @@ -0,0 +1,88 @@ +from datetime import datetime + +import numpy as np + +import supervision as sv + + +class FPSBasedTimer: + """ + A timer that calculates the duration each object has been detected based on frames + per second (FPS). + + Attributes: + fps (float): The frame rate of the video stream, used to calculate + time durations. + frame_id (int): The current frame number in the sequence. + tracker_id2frame_id (Dict[int, int]): Maps each tracker's ID to the frame number + at which it was first detected. + """ + + def __init__(self, fps: float = 30) -> None: + """Initializes the FPSBasedTimer with the specified frames per second rate. + + Args: + fps (float): The frame rate of the video stream. Defaults to 30. + """ + self.fps = fps + self.frame_id = 0 + self.tracker_id2frame_id: dict[int, int] = {} + + def tick(self, detections: sv.Detections) -> np.ndarray: + """Processes the current frame, updating time durations for each tracker. + + Args: + detections: The detections for the current frame, including tracker IDs. + + Returns: + np.ndarray: Time durations (in seconds) for each detected tracker, since + their first detection. + """ + self.frame_id += 1 + times = [] + + for tracker_id in detections.tracker_id: + self.tracker_id2frame_id.setdefault(tracker_id, self.frame_id) + + start_frame_id = self.tracker_id2frame_id[tracker_id] + time_duration = (self.frame_id - start_frame_id) / self.fps + times.append(time_duration) + + return np.array(times) + + +class ClockBasedTimer: + """ + A timer that calculates the duration each object has been detected based on the + system clock. + + Attributes: + tracker_id2start_time (Dict[int, datetime]): Maps each tracker's ID to the + datetime when it was first detected. + """ + + def __init__(self) -> None: + """Initializes the ClockBasedTimer.""" + self.tracker_id2start_time: dict[int, datetime] = {} + + def tick(self, detections: sv.Detections) -> np.ndarray: + """Processes the current frame, updating time durations for each tracker. + + Args: + detections: The detections for the current frame, including tracker IDs. + + Returns: + np.ndarray: Time durations (in seconds) for each detected tracker, since + their first detection. + """ + current_time = datetime.now() + times = [] + + for tracker_id in detections.tracker_id: + self.tracker_id2start_time.setdefault(tracker_id, current_time) + + start_time = self.tracker_id2start_time[tracker_id] + time_duration = (current_time - start_time).total_seconds() + times.append(time_duration) + + return np.array(times) diff --git a/examples/tracking/README.md b/examples/tracking/README.md new file mode 100644 index 0000000..7ef3b9e --- /dev/null +++ b/examples/tracking/README.md @@ -0,0 +1,83 @@ +# tracking + +## ๐Ÿ‘‹ hello + +This script provides functionality for processing videos using YOLOv8 for object detection and Supervision for tracking and annotation. + +## ๐Ÿ’ป install + +- clone repository and navigate to example directory + + ```bash + git clone --depth 1 -b develop https://github.com/roboflow/supervision.git + cd supervision/examples/tracking + ``` + +- setup python environment and activate it [optional] + + ```bash + uv venv + source .venv/bin/activate + ``` + +- install required dependencies + + ```bash + uv pip install -r requirements.txt + ``` + +## ๐Ÿ› ๏ธ script arguments + +- ultralytics + + - `--source_weights_path`: Required. Specifies the path to the YOLO model's weights file, which is essential for the object detection process. This file contains the data that the model uses to identify objects in the video. + + - `--source_video_path`: Required. The path to the source video file to be processed. This is the video on which object detection and annotation will be performed. + + - `--target_video_path`: Required. The path where the processed video, with annotations added, will be saved. This is your output video file. + + - `--confidence_threshold` (optional): Sets the confidence level at which the model identifies objects in the video. Default is `0.3`. A higher threshold makes the model more selective, while a lower threshold makes it more inclusive in identifying objects. + + - `--iou_threshold` (optional): Specifies the IOU (Intersection Over Union) threshold for the model, defaulting to `0.7`. This parameter helps in differentiating between distinct objects, especially in crowded scenes. + +- inference + + - `--roboflow_api_key` (optional): The API key for Roboflow services. If not provided directly, the script tries to fetch it from the `ROBOFLOW_API_KEY` environment variable. Follow [this guide](https://docs.roboflow.com/api-reference/authentication#retrieve-an-api-key) to acquire your `API KEY`. + + - `--model_id` (optional): Designates the Roboflow model ID to be used. The default value is `"yolov8x-1280"`. + + - `--source_video_path`: Required. The path to the source video file to be processed. This is the video on which object detection and annotation will be performed. + + - `--target_video_path`: Required. The path where the processed video, with annotations added, will be saved. This is your output video file. + + - `--confidence_threshold` (optional): Sets the confidence level at which the model identifies objects in the video. Default is `0.3`. A higher threshold makes the model more selective, while a lower threshold makes it more inclusive in identifying objects. + + - `--iou_threshold` (optional): Specifies the IOU (Intersection Over Union) threshold for the model, defaulting to `0.7`. This parameter helps in differentiating between distinct objects, especially in crowded scenes. + +## โš™๏ธ run + +- inference + + ```bash + python inference_example.py \ + --roboflow_api_key "ROBOFLOW_API_KEY" \ + --source_video_path input.mp4 \ + --target_video_path tracking_result.mp4 + ``` + +- ultralytics + + ```bash + python ultralytics_example.py \ + --source_weights_path yolov8s.pt \ + --source_video_path input.mp4 \ + --target_video_path tracking_result.mp4 + ``` + +## ยฉ license + +This demo integrates two main components, each with its own licensing: + +- ultralytics: The object detection model used in this demo, YOLOv8, is distributed under the [AGPL-3.0 license](https://github.com/ultralytics/ultralytics/blob/main/LICENSE). You can find more details about this license here. + +- supervision: The analytics code that powers the zone-based analysis in this demo is based on the Supervision library, which is licensed under the [MIT license](https://github.com/roboflow/supervision/blob/develop/LICENSE.md). This makes the Supervision part of the code fully open source and freely usable in your projects. diff --git a/examples/tracking/inference_example.py b/examples/tracking/inference_example.py new file mode 100644 index 0000000..3380457 --- /dev/null +++ b/examples/tracking/inference_example.py @@ -0,0 +1,66 @@ +import os + +from inference.models.utils import get_roboflow_model +from tqdm import tqdm + +import supervision as sv + + +def main( + source_video_path: str, + target_video_path: str, + roboflow_api_key: str, + model_id: str = "yolov8x-1280", + confidence_threshold: float = 0.3, + iou_threshold: float = 0.7, +) -> None: + """ + Video Processing with Inference and ByteTrack. + + Args: + source_video_path: Path to the source video file + target_video_path: Path to the target video file (output) + roboflow_api_key: Roboflow API key + model_id: Roboflow model ID + confidence_threshold: Confidence threshold for the model + iou_threshold: IOU threshold for the model + """ + api_key = os.environ.get("ROBOFLOW_API_KEY", roboflow_api_key) + if api_key is None: + raise ValueError( + "Roboflow API key is missing. Please provide it as an argument or set the " + "ROBOFLOW_API_KEY environment variable." + ) + + model = get_roboflow_model(model_id=model_id, api_key=api_key) + + tracker = sv.ByteTrack() + box_annotator = sv.BoxAnnotator() + label_annotator = sv.LabelAnnotator() + frame_generator = sv.get_video_frames_generator(source_path=source_video_path) + video_info = sv.VideoInfo.from_video_path(video_path=source_video_path) + + with sv.VideoSink(target_path=target_video_path, video_info=video_info) as sink: + for frame in tqdm(frame_generator, total=video_info.total_frames): + results = model.infer( + frame, confidence=confidence_threshold, iou_threshold=iou_threshold + )[0] + detections = sv.Detections.from_inference(results) + detections = tracker.update_with_detections(detections) + + annotated_frame = box_annotator.annotate( + scene=frame.copy(), detections=detections + ) + + annotated_labeled_frame = label_annotator.annotate( + scene=annotated_frame, detections=detections + ) + + sink.write_frame(frame=annotated_labeled_frame) + + +if __name__ == "__main__": + from jsonargparse import auto_cli, set_parsing_settings + + set_parsing_settings(parse_optionals_as_positionals=True) + auto_cli(main, as_positional=False) diff --git a/examples/tracking/requirements.txt b/examples/tracking/requirements.txt new file mode 100644 index 0000000..453231c --- /dev/null +++ b/examples/tracking/requirements.txt @@ -0,0 +1,5 @@ +inference +supervision +tqdm +ultralytics +jsonargparse[signatures] diff --git a/examples/tracking/ultralytics_example.py b/examples/tracking/ultralytics_example.py new file mode 100644 index 0000000..332c8dd --- /dev/null +++ b/examples/tracking/ultralytics_example.py @@ -0,0 +1,55 @@ +from tqdm import tqdm +from ultralytics import YOLO + +import supervision as sv + + +def main( + source_weights_path: str, + source_video_path: str, + target_video_path: str, + confidence_threshold: float = 0.3, + iou_threshold: float = 0.7, +) -> None: + """ + Video Processing with YOLO and ByteTrack. + + Args: + source_weights_path: Path to the source weights file + source_video_path: Path to the source video file + target_video_path: Path to the target video file (output) + confidence_threshold: Confidence threshold for the model + iou_threshold: IOU threshold for the model + """ + model = YOLO(source_weights_path) + + tracker = sv.ByteTrack() + box_annotator = sv.BoxAnnotator() + label_annotator = sv.LabelAnnotator() + frame_generator = sv.get_video_frames_generator(source_path=source_video_path) + video_info = sv.VideoInfo.from_video_path(video_path=source_video_path) + + with sv.VideoSink(target_path=target_video_path, video_info=video_info) as sink: + for frame in tqdm(frame_generator, total=video_info.total_frames): + results = model( + frame, verbose=False, conf=confidence_threshold, iou=iou_threshold + )[0] + detections = sv.Detections.from_ultralytics(results) + detections = tracker.update_with_detections(detections) + + annotated_frame = box_annotator.annotate( + scene=frame.copy(), detections=detections + ) + + annotated_labeled_frame = label_annotator.annotate( + scene=annotated_frame, detections=detections + ) + + sink.write_frame(frame=annotated_labeled_frame) + + +if __name__ == "__main__": + from jsonargparse import auto_cli, set_parsing_settings + + set_parsing_settings(parse_optionals_as_positionals=True) + auto_cli(main, as_positional=False) diff --git a/examples/traffic_analysis/.gitignore b/examples/traffic_analysis/.gitignore new file mode 100644 index 0000000..a0aa525 --- /dev/null +++ b/examples/traffic_analysis/.gitignore @@ -0,0 +1,9 @@ +data/ +venv/ +*.pt +*.pth +*.mp4 +*.mov +*.png +*.jpg +*.jpeg diff --git a/examples/traffic_analysis/README.md b/examples/traffic_analysis/README.md new file mode 100644 index 0000000..23709fa --- /dev/null +++ b/examples/traffic_analysis/README.md @@ -0,0 +1,95 @@ +# traffic analysis + +## ๐Ÿ‘‹ hello + +This script performs traffic flow analysis using YOLOv8, an object-detection method and ByteTrack, a simple yet effective online multi-object tracking method. It uses the supervision package for multiple tasks such as tracking, annotations, etc. + +https://github.com/roboflow/supervision/assets/26109316/c9436828-9fbf-4c25-ae8c-60e9c81b3900 + +## ๐Ÿ’ป install + +- clone repository and navigate to example directory + + ```bash + git clone --depth 1 -b develop https://github.com/roboflow/supervision.git + cd supervision/examples/traffic_analysis + ``` + +- setup python environment and activate it [optional] + + ```bash + uv venv + source .venv/bin/activate + ``` + +- install required dependencies + + ```bash + uv pip install -r requirements.txt + ``` + +- download `traffic_analysis.pt` and `traffic_analysis.mov` files + + ```bash + ./setup.sh + ``` + +## ๐Ÿ› ๏ธ script arguments + +- ultralytics + + - `--source_weights_path`: Required. Specifies the path to the YOLO model's weights file, which is essential for the object detection process. This file contains the data that the model uses to identify objects in the video. + + - `--source_video_path`: Required. The path to the source video file that will be analyzed. This is the input video on which traffic flow analysis will be performed. + + - `--target_video_path` (optional): The path to save the output video with annotations. If not specified, the processed video will be displayed in real-time without being saved. + + - `--confidence_threshold` (optional): Sets the confidence threshold for the YOLO model to filter detections. Default is `0.3`. This determines how confident the model should be to recognize an object in the video. + + - `--iou_threshold` (optional): Specifies the IOU (Intersection Over Union) threshold for the model. Default is 0.7. This value is used to manage object detection accuracy, particularly in distinguishing between different objects. + +- inference + + - `--roboflow_api_key` (optional): The API key for Roboflow services. If not provided directly, the script tries to fetch it from the `ROBOFLOW_API_KEY` environment variable. Follow [this guide](https://docs.roboflow.com/api-reference/authentication#retrieve-an-api-key) to acquire your `API KEY`. + + - `--model_id` (optional): Designates the Roboflow model ID to be used. The default value is `"vehicle-count-in-drone-video/6"`. + + - `--source_video_path`: Required. The path to the source video file that will be analyzed. This is the input video on which traffic flow analysis will be performed. + + - `--target_video_path` (optional): The path to save the output video with annotations. If not specified, the processed video will be displayed in real-time without being saved. + + - `--confidence_threshold` (optional): Sets the confidence threshold for the YOLO model to filter detections. Default is `0.3`. This determines how confident the model should be to recognize an object in the video. + + - `--iou_threshold` (optional): Specifies the IOU (Intersection Over Union) threshold for the model. Default is 0.7. This value is used to manage object detection accuracy, particularly in distinguishing between different objects. + +## โš™๏ธ run + +- ultralytics + + ```bash + python ultralytics_example.py \ + --source_weights_path data/traffic_analysis.pt \ + --source_video_path data/traffic_analysis.mov \ + --confidence_threshold 0.3 \ + --iou_threshold 0.5 \ + --target_video_path data/traffic_analysis_result.mov + ``` + +- inference + + ```bash + python inference_example.py \ + --roboflow_api_key "ROBOFLOW_API_KEY" \ + --source_video_path data/traffic_analysis.mov \ + --confidence_threshold 0.3 \ + --iou_threshold 0.5 \ + --target_video_path data/traffic_analysis_result.mov + ``` + +## ยฉ license + +This demo integrates two main components, each with its own licensing: + +- ultralytics: The object detection model used in this demo, YOLOv8, is distributed under the [AGPL-3.0 license](https://github.com/ultralytics/ultralytics/blob/main/LICENSE). You can find more details about this license here. + +- supervision: The analytics code that powers the zone-based analysis in this demo is based on the Supervision library, which is licensed under the [MIT license](https://github.com/roboflow/supervision/blob/develop/LICENSE.md). This makes the Supervision part of the code fully open source and freely usable in your projects. diff --git a/examples/traffic_analysis/inference_example.py b/examples/traffic_analysis/inference_example.py new file mode 100644 index 0000000..8bd1394 --- /dev/null +++ b/examples/traffic_analysis/inference_example.py @@ -0,0 +1,223 @@ +import os +from collections.abc import Iterable + +import cv2 +import numpy as np +from inference.models.utils import get_roboflow_model +from tqdm import tqdm + +import supervision as sv + +COLORS = sv.ColorPalette.from_hex(["#E6194B", "#3CB44B", "#FFE119", "#3C76D1"]) + + +ZONE_IN_POLYGONS = [ + np.array([[592, 282], [900, 282], [900, 82], [592, 82]]), + np.array([[950, 860], [1250, 860], [1250, 1060], [950, 1060]]), + np.array([[592, 582], [592, 860], [392, 860], [392, 582]]), + np.array([[1250, 282], [1250, 530], [1450, 530], [1450, 282]]), +] + +ZONE_OUT_POLYGONS = [ + np.array([[950, 282], [1250, 282], [1250, 82], [950, 82]]), + np.array([[592, 860], [900, 860], [900, 1060], [592, 1060]]), + np.array([[592, 282], [592, 550], [392, 550], [392, 282]]), + np.array([[1250, 860], [1250, 560], [1450, 560], [1450, 860]]), +] + + +class DetectionsManager: + def __init__(self) -> None: + self.tracker_id_to_zone_id: dict[int, int] = {} + self.counts: dict[int, dict[int, set[int]]] = {} + + def update( + self, + detections_all: sv.Detections, + detections_in_zones: list[sv.Detections], + detections_out_zones: list[sv.Detections], + ) -> sv.Detections: + for zone_in_id, detections_in_zone in enumerate(detections_in_zones): + for tracker_id in detections_in_zone.tracker_id: + self.tracker_id_to_zone_id.setdefault(tracker_id, zone_in_id) + + for zone_out_id, detections_out_zone in enumerate(detections_out_zones): + for tracker_id in detections_out_zone.tracker_id: + if tracker_id in self.tracker_id_to_zone_id: + zone_in_id = self.tracker_id_to_zone_id[tracker_id] + self.counts.setdefault(zone_out_id, {}) + self.counts[zone_out_id].setdefault(zone_in_id, set()) + self.counts[zone_out_id][zone_in_id].add(tracker_id) + if len(detections_all) > 0: + detections_all.class_id = np.vectorize( + lambda x: self.tracker_id_to_zone_id.get(x, -1) + )(detections_all.tracker_id) + else: + detections_all.class_id = np.array([], dtype=int) + return detections_all[detections_all.class_id != -1] + + +def initiate_polygon_zones( + polygons: list[np.ndarray], + triggering_anchors: Iterable[sv.Position] = [sv.Position.CENTER], +) -> list[sv.PolygonZone]: + return [ + sv.PolygonZone( + polygon=polygon, + triggering_anchors=triggering_anchors, + ) + for polygon in polygons + ] + + +class VideoProcessor: + def __init__( + self, + roboflow_api_key: str, + model_id: str, + source_video_path: str, + target_video_path: str | None = None, + confidence_threshold: float = 0.3, + iou_threshold: float = 0.7, + ) -> None: + self.conf_threshold = confidence_threshold + self.iou_threshold = iou_threshold + self.source_video_path = source_video_path + self.target_video_path = target_video_path + + self.model = get_roboflow_model(model_id=model_id, api_key=roboflow_api_key) + self.tracker = sv.ByteTrack() + + self.video_info = sv.VideoInfo.from_video_path(source_video_path) + self.zones_in = initiate_polygon_zones(ZONE_IN_POLYGONS, [sv.Position.CENTER]) + self.zones_out = initiate_polygon_zones(ZONE_OUT_POLYGONS, [sv.Position.CENTER]) + + self.box_annotator = sv.BoxAnnotator(color=COLORS) + self.label_annotator = sv.LabelAnnotator( + color=COLORS, text_color=sv.Color.BLACK + ) + self.trace_annotator = sv.TraceAnnotator( + color=COLORS, position=sv.Position.CENTER, trace_length=100, thickness=2 + ) + self.detections_manager = DetectionsManager() + + def process_video(self) -> None: + frame_generator = sv.get_video_frames_generator( + source_path=self.source_video_path + ) + + if self.target_video_path: + with sv.VideoSink(self.target_video_path, self.video_info) as sink: + for frame in tqdm(frame_generator, total=self.video_info.total_frames): + annotated_frame = self.process_frame(frame) + sink.write_frame(annotated_frame) + else: + for frame in tqdm(frame_generator, total=self.video_info.total_frames): + annotated_frame = self.process_frame(frame) + cv2.imshow("Processed Video", annotated_frame) + if cv2.waitKey(1) & 0xFF == ord("q"): + break + cv2.destroyAllWindows() + + def annotate_frame( + self, frame: np.ndarray, detections: sv.Detections + ) -> np.ndarray: + annotated_frame = frame.copy() + for i, (zone_in, zone_out) in enumerate(zip(self.zones_in, self.zones_out)): + annotated_frame = sv.draw_polygon( + annotated_frame, zone_in.polygon, COLORS.colors[i] + ) + annotated_frame = sv.draw_polygon( + annotated_frame, zone_out.polygon, COLORS.colors[i] + ) + + labels = [f"#{tracker_id}" for tracker_id in detections.tracker_id] + annotated_frame = self.trace_annotator.annotate(annotated_frame, detections) + annotated_frame = self.box_annotator.annotate(annotated_frame, detections) + annotated_frame = self.label_annotator.annotate( + annotated_frame, detections, labels + ) + + for zone_out_id, zone_out in enumerate(self.zones_out): + zone_center = sv.get_polygon_center(polygon=zone_out.polygon) + if zone_out_id in self.detections_manager.counts: + counts = self.detections_manager.counts[zone_out_id] + for i, zone_in_id in enumerate(counts): + count = len(self.detections_manager.counts[zone_out_id][zone_in_id]) + text_anchor = sv.Point(x=zone_center.x, y=zone_center.y + 40 * i) + annotated_frame = sv.draw_text( + scene=annotated_frame, + text=str(count), + text_anchor=text_anchor, + background_color=COLORS.colors[zone_in_id], + ) + + return annotated_frame + + def process_frame(self, frame: np.ndarray) -> np.ndarray: + results = self.model.infer( + frame, confidence=self.conf_threshold, iou_threshold=self.iou_threshold + )[0] + detections = sv.Detections.from_inference(results) + detections.class_id = np.zeros(len(detections)) + detections = self.tracker.update_with_detections(detections) + + detections_in_zones = [] + detections_out_zones = [] + + for zone_in, zone_out in zip(self.zones_in, self.zones_out): + detections_in_zone = detections[zone_in.trigger(detections=detections)] + detections_in_zones.append(detections_in_zone) + detections_out_zone = detections[zone_out.trigger(detections=detections)] + detections_out_zones.append(detections_out_zone) + + detections = self.detections_manager.update( + detections, detections_in_zones, detections_out_zones + ) + return self.annotate_frame(frame, detections) + + +def main( + source_video_path: str, + target_video_path: str, + roboflow_api_key: str, + model_id: str = "vehicle-count-in-drone-video/6", + confidence_threshold: float = 0.3, + iou_threshold: float = 0.7, +) -> None: + """ + Traffic Flow Analysis with Inference and ByteTrack. + + Args: + source_video_path: Path to the source video file + target_video_path: Path to the target video file (output) + roboflow_api_key: Roboflow API key + model_id: Roboflow model ID + confidence_threshold: Confidence threshold for the model + iou_threshold: IOU threshold for the model + """ + api_key = roboflow_api_key + api_key = os.environ.get("ROBOFLOW_API_KEY", api_key) + if api_key is None: + raise ValueError( + "Roboflow API KEY is missing. Please provide it as an argument or set the " + "ROBOFLOW_API_KEY environment variable." + ) + roboflow_api_key = api_key + + processor = VideoProcessor( + roboflow_api_key=roboflow_api_key, + model_id=model_id, + source_video_path=source_video_path, + target_video_path=target_video_path, + confidence_threshold=confidence_threshold, + iou_threshold=iou_threshold, + ) + processor.process_video() + + +if __name__ == "__main__": + from jsonargparse import auto_cli, set_parsing_settings + + set_parsing_settings(parse_optionals_as_positionals=True) + auto_cli(main, as_positional=False) diff --git a/examples/traffic_analysis/requirements.txt b/examples/traffic_analysis/requirements.txt new file mode 100644 index 0000000..f325418 --- /dev/null +++ b/examples/traffic_analysis/requirements.txt @@ -0,0 +1,6 @@ +gdown +inference +supervision +tqdm +ultralytics +jsonargparse[signatures] diff --git a/examples/traffic_analysis/setup.sh b/examples/traffic_analysis/setup.sh new file mode 100755 index 0000000..0e746a1 --- /dev/null +++ b/examples/traffic_analysis/setup.sh @@ -0,0 +1,17 @@ +#!/bin/bash + +# Get the directory where the script is located +DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )" + +# Check if 'data' directory does not exist and then create it +if [[ ! -e $DIR/data ]]; then + mkdir "$DIR/data" +else + echo "'data' directory already exists." +fi + +# Download the traffic_analysis.mov file from Google Drive +gdown -O "$DIR/data/traffic_analysis.mov" "https://drive.google.com/uc?id=1qadBd7lgpediafCpL_yedGjQPk-FLK-W" + +# Download the traffic_analysis.pt file from Google Drive +gdown -O "$DIR/data/traffic_analysis.pt" "https://drive.google.com/uc?id=1y-IfToCjRXa3ZdC1JpnKRopC7mcQW-5z" diff --git a/examples/traffic_analysis/ultralytics_example.py b/examples/traffic_analysis/ultralytics_example.py new file mode 100644 index 0000000..03b8d77 --- /dev/null +++ b/examples/traffic_analysis/ultralytics_example.py @@ -0,0 +1,208 @@ +from collections.abc import Iterable + +import cv2 +import numpy as np +from tqdm import tqdm +from ultralytics import YOLO + +import supervision as sv + +COLORS = sv.ColorPalette.from_hex(["#E6194B", "#3CB44B", "#FFE119", "#3C76D1"]) + +ZONE_IN_POLYGONS = [ + np.array([[592, 282], [900, 282], [900, 82], [592, 82]]), + np.array([[950, 860], [1250, 860], [1250, 1060], [950, 1060]]), + np.array([[592, 582], [592, 860], [392, 860], [392, 582]]), + np.array([[1250, 282], [1250, 530], [1450, 530], [1450, 282]]), +] + +ZONE_OUT_POLYGONS = [ + np.array([[950, 282], [1250, 282], [1250, 82], [950, 82]]), + np.array([[592, 860], [900, 860], [900, 1060], [592, 1060]]), + np.array([[592, 282], [592, 550], [392, 550], [392, 282]]), + np.array([[1250, 860], [1250, 560], [1450, 560], [1450, 860]]), +] + + +class DetectionsManager: + def __init__(self) -> None: + self.tracker_id_to_zone_id: dict[int, int] = {} + self.counts: dict[int, dict[int, set[int]]] = {} + + def update( + self, + detections_all: sv.Detections, + detections_in_zones: list[sv.Detections], + detections_out_zones: list[sv.Detections], + ) -> sv.Detections: + for zone_in_id, detections_in_zone in enumerate(detections_in_zones): + for tracker_id in detections_in_zone.tracker_id: + self.tracker_id_to_zone_id.setdefault(tracker_id, zone_in_id) + + for zone_out_id, detections_out_zone in enumerate(detections_out_zones): + for tracker_id in detections_out_zone.tracker_id: + if tracker_id in self.tracker_id_to_zone_id: + zone_in_id = self.tracker_id_to_zone_id[tracker_id] + self.counts.setdefault(zone_out_id, {}) + self.counts[zone_out_id].setdefault(zone_in_id, set()) + self.counts[zone_out_id][zone_in_id].add(tracker_id) + if len(detections_all) > 0: + detections_all.class_id = np.vectorize( + lambda x: self.tracker_id_to_zone_id.get(x, -1) + )(detections_all.tracker_id) + else: + detections_all.class_id = np.array([], dtype=int) + return detections_all[detections_all.class_id != -1] + + +def initiate_polygon_zones( + polygons: list[np.ndarray], + triggering_anchors: Iterable[sv.Position] = [sv.Position.CENTER], +) -> list[sv.PolygonZone]: + return [ + sv.PolygonZone( + polygon=polygon, + triggering_anchors=triggering_anchors, + ) + for polygon in polygons + ] + + +class VideoProcessor: + def __init__( + self, + source_weights_path: str, + source_video_path: str, + target_video_path: str | None = None, + confidence_threshold: float = 0.3, + iou_threshold: float = 0.7, + ) -> None: + self.conf_threshold = confidence_threshold + self.iou_threshold = iou_threshold + self.source_video_path = source_video_path + self.target_video_path = target_video_path + + self.model = YOLO(source_weights_path) + self.tracker = sv.ByteTrack() + + self.video_info = sv.VideoInfo.from_video_path(source_video_path) + self.zones_in = initiate_polygon_zones(ZONE_IN_POLYGONS, [sv.Position.CENTER]) + self.zones_out = initiate_polygon_zones(ZONE_OUT_POLYGONS, [sv.Position.CENTER]) + + self.box_annotator = sv.BoxAnnotator(color=COLORS) + self.label_annotator = sv.LabelAnnotator( + color=COLORS, text_color=sv.Color.BLACK + ) + self.trace_annotator = sv.TraceAnnotator( + color=COLORS, position=sv.Position.CENTER, trace_length=100, thickness=2 + ) + self.detections_manager = DetectionsManager() + + def process_video(self) -> None: + frame_generator = sv.get_video_frames_generator( + source_path=self.source_video_path + ) + + if self.target_video_path: + with sv.VideoSink(self.target_video_path, self.video_info) as sink: + for frame in tqdm(frame_generator, total=self.video_info.total_frames): + annotated_frame = self.process_frame(frame) + sink.write_frame(annotated_frame) + else: + for frame in tqdm(frame_generator, total=self.video_info.total_frames): + annotated_frame = self.process_frame(frame) + cv2.imshow("Processed Video", annotated_frame) + if cv2.waitKey(1) & 0xFF == ord("q"): + break + cv2.destroyAllWindows() + + def annotate_frame( + self, frame: np.ndarray, detections: sv.Detections + ) -> np.ndarray: + annotated_frame = frame.copy() + for i, (zone_in, zone_out) in enumerate(zip(self.zones_in, self.zones_out)): + annotated_frame = sv.draw_polygon( + annotated_frame, zone_in.polygon, COLORS.colors[i] + ) + annotated_frame = sv.draw_polygon( + annotated_frame, zone_out.polygon, COLORS.colors[i] + ) + + labels = [f"#{tracker_id}" for tracker_id in detections.tracker_id] + annotated_frame = self.trace_annotator.annotate(annotated_frame, detections) + annotated_frame = self.box_annotator.annotate(annotated_frame, detections) + annotated_frame = self.label_annotator.annotate( + annotated_frame, detections, labels + ) + + for zone_out_id, zone_out in enumerate(self.zones_out): + zone_center = sv.get_polygon_center(polygon=zone_out.polygon) + if zone_out_id in self.detections_manager.counts: + counts = self.detections_manager.counts[zone_out_id] + for i, zone_in_id in enumerate(counts): + count = len(self.detections_manager.counts[zone_out_id][zone_in_id]) + text_anchor = sv.Point(x=zone_center.x, y=zone_center.y + 40 * i) + annotated_frame = sv.draw_text( + scene=annotated_frame, + text=str(count), + text_anchor=text_anchor, + background_color=COLORS.colors[zone_in_id], + ) + + return annotated_frame + + def process_frame(self, frame: np.ndarray) -> np.ndarray: + results = self.model( + frame, verbose=False, conf=self.conf_threshold, iou=self.iou_threshold + )[0] + detections = sv.Detections.from_ultralytics(results) + detections.class_id = np.zeros(len(detections)) + detections = self.tracker.update_with_detections(detections) + + detections_in_zones = [] + detections_out_zones = [] + + for zone_in, zone_out in zip(self.zones_in, self.zones_out): + detections_in_zone = detections[zone_in.trigger(detections=detections)] + detections_in_zones.append(detections_in_zone) + detections_out_zone = detections[zone_out.trigger(detections=detections)] + detections_out_zones.append(detections_out_zone) + + detections = self.detections_manager.update( + detections, detections_in_zones, detections_out_zones + ) + return self.annotate_frame(frame, detections) + + +def main( + source_weights_path: str, + source_video_path: str, + target_video_path: str, + confidence_threshold: float = 0.3, + iou_threshold: float = 0.7, +) -> None: + """ + Traffic Flow Analysis with YOLO and ByteTrack. + + Args: + source_weights_path: Path to the source weights file + source_video_path: Path to the source video file + target_video_path: Path to the target video file (output) + confidence_threshold: Confidence threshold for the model + iou_threshold: IOU threshold for the model + """ + processor = VideoProcessor( + source_weights_path=source_weights_path, + source_video_path=source_video_path, + target_video_path=target_video_path, + confidence_threshold=confidence_threshold, + iou_threshold=iou_threshold, + ) + processor.process_video() + + +if __name__ == "__main__": + from jsonargparse import auto_cli, set_parsing_settings + + set_parsing_settings(parse_optionals_as_positionals=True) + auto_cli(main, as_positional=False) diff --git a/mkdocs.yml b/mkdocs.yml new file mode 100644 index 0000000..df8e2f6 --- /dev/null +++ b/mkdocs.yml @@ -0,0 +1,219 @@ +site_name: Supervision +site_url: https://supervision.roboflow.com/ +site_author: Roboflow +site_description: "Model-agnostic Python library for computer vision. Annotate, track, filter, and export detections from supported model outputs including Ultralytics, Roboflow Inference, Transformers, SAM, Detectron2, MMDetection, and VLM parsers." +repo_name: roboflow/supervision +edit_uri: https://github.com/roboflow/supervision/tree/main/docs +copyright: Roboflow 2026. All rights reserved. + +extra: + social: + - icon: fontawesome/brands/github + link: https://github.com/roboflow + - icon: fontawesome/brands/python + link: https://pypi.org/project/supervision + - icon: fontawesome/brands/youtube + link: https://www.youtube.com/roboflow + - icon: fontawesome/brands/x-twitter + link: https://twitter.com/roboflow + - icon: fontawesome/brands/discord + link: https://discord.gg/GbfgXGJ8Bk + analytics: + provider: google + property: G-P7ZG0Y19G5 + version: + provider: mike + +extra_css: + - stylesheets/extra.css + - stylesheets/cookbooks_card.css + +nav: + - Home: index.md + - About: about.md + - Contact: contact.md + - FAQ: faq.md + - Learn: + - Detect and Annotate: how_to/detect_and_annotate.md + - Save Detections: how_to/save_detections.md + - Filter Detections: how_to/filter_detections.md + - Detect Small Objects: how_to/detect_small_objects.md + - Track Objects on Video: how_to/track_objects.md + - Process Datasets: how_to/process_datasets.md + - Benchmark a Model: how_to/benchmark_a_model.md + - Count in Zone: how_to/count_in_zone.md + - Use Compact Masks: how_to/use_compact_masks.md + - Reference: + - Detection and Segmentation: + - Core: detection/core.md + - Annotators: detection/annotators.md + - Compact Mask: detection/compact_mask.md + - Converters: detection/utils/converters.md + - IoU and NMS: detection/utils/iou_and_nms.md + - Boxes: detection/utils/boxes.md + - Masks: detection/utils/masks.md + - Polygons: detection/utils/polygons.md + - VLM Utils: detection/utils/vlms.md + - Keypoint Detection: + - Core: keypoint/core.md + - Annotators: keypoint/annotators.md + - Classification: + - Core: classification/core.md + - Tools: + - Line Zone: detection/tools/line_zone.md + - Polygon Zone: detection/tools/polygon_zone.md + - Inference Slicer: detection/tools/inference_slicer.md + - Detection Smoother: detection/tools/smoother.md + - Save Detections: detection/tools/save_detections.md + - Trackers: trackers.md + - Datasets: + - Core: datasets/core.md + - Metrics: + - mAP: metrics/mean_average_precision.md + - mAR: metrics/mean_average_recall.md + - Precision: metrics/precision.md + - Recall: metrics/recall.md + - F1 Score: metrics/f1_score.md + - Common Values: metrics/common_values.md + - Legacy Metrics: detection/metrics.md + - Utils: + - Conversion: utils/conversion.md + - Video: utils/video.md + - Image: utils/image.md + - Iterables: utils/iterables.md + - Notebook: utils/notebook.md + - File: utils/file.md + - Draw: utils/draw.md + - Geometry: utils/geometry.md + - Assets: assets.md + - Cookbooks: cookbooks.md + - Contributing: contributing.md + - Code of Conduct: code_of_conduct.md + - License: license.md + - Changelog: + - Changelog: changelog.md + - Deprecated: deprecated.md + +theme: + name: "material" + icon: + edit: material/pencil + logo: assets/supervision-lenny.png + favicon: assets/supervision-lenny.png + custom_dir: docs/theme + features: + - navigation.tracking + - content.code.copy + - content.action.edit + - content.tooltips + - content.code.annotate + - navigation.tabs + - navigation.tabs.sticky + + palette: + - scheme: default + primary: "custom" + toggle: + icon: material/brightness-7 + name: Switch to dark mode + - scheme: slate + primary: "custom" + toggle: + icon: material/brightness-4 + name: Switch to light mode + + font: + text: Inter + code: IBM Plex Mono + +plugins: + - search + - mkdocs-jupyter: + kernel_name: python3 + execute: false + include_source: True + include_requirejs: true + - mkdocstrings: + default_handler: python + handlers: + python: + paths: [supervision] + load_external_modules: true + options: + parameter_headings: true + allow_inspection: true + show_bases: true + group_by_category: true + docstring_style: google + show_symbol_type_heading: true + show_root_heading: True + show_symbol_type_toc: true + show_category_heading: true + show_signature_annotations: true + show_docstring_examples: true + inventories: + - url: https://docs.python-requests.org/en/master/objects.inv + domains: [std, py] + - git-committers: + repository: roboflow/supervision + branch: develop + token: !ENV ["GITHUB_TOKEN"] + - git-revision-date-localized: + enable_creation_date: true + +markdown_extensions: + - admonition + - pymdownx.details + + # uses Pygments + prompt stripping + - pymdownx.superfences: + custom_fences: + - name: pycon + class: pycon + lexer: pycon + format: !!python/name:pymdownx.superfences.fence_code_format + + - pymdownx.inlinehilite + - attr_list + - md_in_html + - pymdownx.tabbed: + alternate_style: true + - toc: + permalink: true + - pymdownx.emoji: + emoji_index: !!python/name:material.extensions.emoji.twemoji + emoji_generator: !!python/name:material.extensions.emoji.to_svg + - pymdownx.snippets: + check_paths: true + + # Pygments pycon lexer with prompt stripping enabled + - pymdownx.highlight: + line_spans: __span + anchor_linenums: true + pygments_lang_class: true + linenums: false + auto_title: false + extend_pygments_lang: + - name: pycon + lang: pycon + options: + strip_prompt: true + strip_continuation_prompt: true + + - pymdownx.arithmatex: + generic: true + +extra_javascript: + - "javascripts/init_kapa_widget.js" + - "javascripts/cookbooks-card.js" + - "javascripts/pycon_copy.js" + - "javascripts/segment.js" + - "javascripts/mathjax.js" + - "https://cdnjs.cloudflare.com/ajax/libs/dompurify/3.0.8/purify.min.js" + - "https://unpkg.com/mathjax@3/es5/tex-mml-chtml.js" + +validation: + nav: + absolute_links: ignore + links: + absolute_links: ignore diff --git a/pyproject.toml b/pyproject.toml new file mode 100644 index 0000000..4972264 --- /dev/null +++ b/pyproject.toml @@ -0,0 +1,211 @@ +[build-system] +build-backend = "setuptools.build_meta" +requires = [ "setuptools>=61" ] + +[project] +name = "supervision" +version = "0.30.0.dev" +description = "A set of easy-to-use utils that will come in handy in any Computer Vision project" +readme = "README.md" +keywords = [ + "AI", + "deep-learning", + "DL", + "machine-learning", + "ML", + "Roboflow", + "vision", +] +license = "MIT" +maintainers = [ + { name = "Piotr Skalski", email = "piotr@roboflow.com" }, +] +authors = [ + { name = "Roboflow et al.", email = "develop@roboflow.com" }, +] +requires-python = ">=3.10" +classifiers = [ + "Development Status :: 5 - Production/Stable", + "Intended Audience :: Developers", + "Intended Audience :: Education", + "Intended Audience :: Science/Research", + "Operating System :: MacOS", + "Operating System :: Microsoft :: Windows", + "Operating System :: POSIX :: Linux", + "Programming Language :: Python :: 3 :: Only", + "Programming Language :: Python :: 3.10", + "Programming Language :: Python :: 3.11", + "Programming Language :: Python :: 3.12", + "Programming Language :: Python :: 3.13", + "Programming Language :: Python :: 3.14", + "Topic :: Multimedia :: Graphics", + "Topic :: Multimedia :: Video", + "Topic :: Scientific/Engineering", + "Topic :: Scientific/Engineering :: Artificial Intelligence", + "Topic :: Scientific/Engineering :: Image Recognition", + "Topic :: Software Development", + "Typing :: Typed", +] +dependencies = [ + "defusedxml>=0.7.1", + "matplotlib>=3.6", + "numpy>=1.21.2", + "opencv-python>=4.5.5.64", + "pillow>=9.4", + "pydeprecate>=0.9,<0.11", + "pyyaml>=5.3", + "requests>=2.26", + "scipy>=1.10", + "tqdm>=4.62.3" +] +optional-dependencies.geotiff = [ + "rasterio>=1.3", # 1.3 introduced stable window-read API and CRS.is_projected +] +optional-dependencies.metrics = [ + "pandas>=2", +] +urls.Documentation = "https://supervision.roboflow.com/latest/" +urls.Homepage = "https://github.com/roboflow/supervision" +urls.Repository = "https://github.com/roboflow/supervision" + +[dependency-groups] +dev = [ + "docutils!=0.21", + "ipywidgets>=8.1.1", + "jupytext>=1.16.1", + "nbconvert>=7.14.2", + "notebook>=6.5.3,<8", + "pre-commit>=3.8", + "pytest>=7.2.2,<10", + "pytest-cov>=4,<8", + "tox>=4.11.4", + "types-tqdm", +] +docs = [ + "mike>=2", + "mkdocs-git-committers-plugin-2>=2.4.1; python_version>='3.10' and python_version<'4'", + "mkdocs-git-revision-date-localized-plugin>=1.2.4", + "mkdocs-jupyter>=0.24.3", + "mkdocs-material[imaging]>=9.7", + "mkdocstrings>=1,<1.1", + "mkdocstrings-python>=2,<3", +] +build = [ + "build>=1,<1.6", + "twine>=5.1.1,<7", + "wheel>=0.40,<0.48", +] + +[tool.setuptools] +packages.find.where = [ "src" ] +packages.find.include = [ "supervision*" ] +include-package-data = false +package-data.supervision = [ "py.typed" ] +# exclude = [ "docs*", "tests*", "examples*" ] + +[tool.ruff] +target-version = "py310" +line-length = 88 +indent-width = 4 +# Exclude a variety of commonly ignored directories. +exclude = [ + ".bzr", + ".direnv", + ".eggs", + ".git", + ".git-rewrite", + ".hg", + ".mypy_cache", + ".nox", + ".pants.d", + ".pytype", + ".ruff_cache", + ".svn", + ".tox", + ".venv", + "__pypackages__", + "_build", + "buck-out", + "build", + "dist", + "docs", + "node_modules", + "venv", + "yarn-error.log", + "yarn.lock", +] +# Like Black, indent with spaces, rather than tabs. +format.indent-style = "space" +# Like Black, use double quotes for strings. +format.quote-style = "double" +# Like Black, automatically detect the appropriate line ending. +format.line-ending = "auto" +# Like Black, respect magic trailing commas. +format.skip-magic-trailing-comma = false +# Enable linting rules for code style, imports, and best practices. +lint.select = [ + "A", # flake8-builtins - https://docs.astral.sh/ruff/rules/#flake8-builtins-a + "E", # pycodestyle errors - https://docs.astral.sh/ruff/rules/#error-e + "F", # Pyflakes - https://docs.astral.sh/ruff/rules/#pyflakes-f + "I", # isort - https://docs.astral.sh/ruff/rules/#isort-i + "PT", # pytest - https://docs.astral.sh/ruff/rules/#flake8-pytest-style-pt + "Q", # flake8-quotes - https://docs.astral.sh/ruff/rules/#flake8-quotes-q + "RUF", # Ruff-specific rules - https://docs.astral.sh/ruff/rules/#ruff-specific-rules-ruf + "S", # bandit - https://docs.astral.sh/ruff/rules/#flake8-bandit-s + "UP", # pyupgrade - https://docs.astral.sh/ruff/rules/#pyupgrade-up + "W", # pycodestyle warnings - https://docs.astral.sh/ruff/rules/#pycodestyle-w +] +lint.ignore = [] +lint.per-file-ignores."__init__.py" = [ "E402", "F401" ] +lint.per-file-ignores."notebooks/**" = [ + "PT018", # Assertion should be broken down into multiple parts + "S101", # Use of `assert` detected +] +lint.per-file-ignores."src/**" = [ + "S101", # TODO: Replace asserts with proper error handling +] +lint.per-file-ignores."tests/**" = [ + "S101", # Use of `assert` detected +] +lint.unfixable = [] +# Allow unused variables when underscore-prefixed. +lint.dummy-variable-rgx = "^(_+|(_+[a-zA-Z0-9_]*[a-zA-Z0-9]+?))$" +lint.flake8-quotes.docstring-quotes = "double" +lint.flake8-quotes.inline-quotes = "double" +lint.flake8-quotes.multiline-quotes = "double" +lint.isort.no-sections = false +lint.isort.order-by-type = true +# Flag errors (`C901`) whenever the complexity level exceeds 5. +lint.mccabe.max-complexity = 20 +lint.pydocstyle.convention = "google" +lint.pylint.max-args = 20 + +[tool.codespell] +ignore-words-list = "STrack,sTrack,strack" +skip = "*.ipynb" +count = true +quiet-level = 3 + +[tool.mypy] +mypy_path = "src" +explicit_package_bases = true +ignore_missing_imports = false +python_version = "3.10" +strict = true +overrides = [ { module = [ "examples.*", "tests.*" ], ignore_errors = true } ] + +[tool.pytest] +ini_options.testpaths = [ "src", "tests" ] +ini_options.norecursedirs = [ ".git", ".venv", "build", "dist", "docs", "examples", "notebooks" ] +ini_options.addopts = [ + "--doctest-modules", + "--color=yes", +] +ini_options.filterwarnings = [ + "error::DeprecationWarning", +] +ini_options.doctest_optionflags = "ELLIPSIS NORMALIZE_WHITESPACE" + +[tool.autoflake] +check = true +imports = [ "cv2", "supervision" ] diff --git a/src/supervision/__init__.py b/src/supervision/__init__.py new file mode 100644 index 0000000..a3f2999 --- /dev/null +++ b/src/supervision/__init__.py @@ -0,0 +1,309 @@ +import importlib.metadata as importlib_metadata +from typing import TYPE_CHECKING, Any + +try: + # This will read version from pyproject.toml + __version__ = importlib_metadata.version(__package__ or __name__) +except importlib_metadata.PackageNotFoundError: + __version__ = "development" + +from supervision.annotators.core import ( + BackgroundOverlayAnnotator, + BlurAnnotator, + BoxAnnotator, + BoxCornerAnnotator, + CircleAnnotator, + ColorAnnotator, + ComparisonAnnotator, + CropAnnotator, + DotAnnotator, + EllipseAnnotator, + HaloAnnotator, + HeatMapAnnotator, + IconAnnotator, + LabelAnnotator, + MaskAnnotator, + OrientedBoxAnnotator, + PercentageBarAnnotator, + PixelateAnnotator, + PolygonAnnotator, + RichLabelAnnotator, + RoundBoxAnnotator, + TraceAnnotator, + TriangleAnnotator, +) +from supervision.annotators.utils import ( + ColorLookup, + hex_to_rgba, + is_valid_hex, + rgba_to_hex, +) +from supervision.classification.core import Classifications +from supervision.dataset.core import ( + BaseDataset, + ClassificationDataset, + DetectionDataset, +) +from supervision.dataset.formats.coco import get_coco_class_index_mapping +from supervision.detection.compact_mask import CompactMask +from supervision.detection.core import Detections +from supervision.detection.line_zone import ( + LineZone, + LineZoneAnnotator, + LineZoneAnnotatorMulticlass, +) +from supervision.detection.tools.csv_sink import CSVSink +from supervision.detection.tools.inference_slicer import ( + InferenceSlicer, + WindowedRasterDataset, +) +from supervision.detection.tools.json_sink import JSONSink +from supervision.detection.tools.polygon_zone import PolygonZone, PolygonZoneAnnotator +from supervision.detection.tools.smoother import DetectionsSmoother +from supervision.detection.utils.boxes import ( + clip_boxes, + denormalize_boxes, + move_boxes, + pad_boxes, + scale_boxes, + xyxyxyxy_to_xyxy, +) +from supervision.detection.utils.converters import ( + is_compressed_rle, + mask_to_polygons, + mask_to_rle, + mask_to_xyxy, + polygon_to_mask, + polygon_to_xyxy, + rle_to_mask, + xcycwh_to_xyxy, + xywh_to_xyxy, + xyxy_to_mask, + xyxy_to_polygons, + xyxy_to_xcycarh, + xyxy_to_xywh, +) +from supervision.detection.utils.iou_and_nms import ( + OverlapFilter, + OverlapMetric, + box_iou, + box_iou_batch, + box_iou_batch_with_jaccard, + box_non_max_merge, + box_non_max_suppression, + mask_iou_batch, + mask_non_max_merge, + mask_non_max_suppression, + oriented_box_iou_batch, + oriented_box_non_max_merge, + oriented_box_non_max_suppression, +) +from supervision.detection.utils.masks import ( + calculate_masks_centroids, + contains_holes, + contains_multiple_segments, + filter_segments_by_distance, + mask_to_roi, + move_masks, +) +from supervision.detection.utils.polygons import ( + approximate_polygon, + filter_polygons_by_area, +) +from supervision.detection.utils.vlms import edit_distance, fuzzy_match_index +from supervision.detection.vlm import LMM, VLM +from supervision.draw.color import Color, ColorPalette +from supervision.draw.utils import ( + calculate_optimal_line_thickness, + calculate_optimal_text_scale, + draw_filled_polygon, + draw_filled_rectangle, + draw_image, + draw_line, + draw_polygon, + draw_rectangle, + draw_text, +) +from supervision.geometry.core import Point, Position, Rect +from supervision.geometry.utils import get_polygon_center +from supervision.key_points.annotators import ( + EdgeAnnotator, + VertexAnnotator, + VertexEllipseAnnotator, + VertexEllipseAreaAnnotator, + VertexEllipseHaloAnnotator, + VertexEllipseOutlineAnnotator, + VertexLabelAnnotator, +) +from supervision.key_points.core import KeyPoints +from supervision.metrics.detection import ConfusionMatrix, MeanAveragePrecision +from supervision.utils.conversion import cv2_to_pillow, pillow_to_cv2 +from supervision.utils.file import list_files_with_extensions +from supervision.utils.image import ( + ImageSink, + crop_image, + get_image_resolution_wh, + grayscale_image, + letterbox_image, + overlay_image, + resize_image, + scale_image, + tint_image, +) +from supervision.utils.notebook import plot_image, plot_images_grid +from supervision.utils.video import ( + FPSMonitor, + VideoInfo, + VideoSink, + get_video_frames_generator, + process_video, +) + +if TYPE_CHECKING: + from supervision.tracker.byte_tracker.core import ByteTrack + +__all__ = [ + "LMM", + "VLM", + "BackgroundOverlayAnnotator", + "BaseDataset", + "BlurAnnotator", + "BoxAnnotator", + "BoxCornerAnnotator", + "ByteTrack", + "CSVSink", + "CircleAnnotator", + "ClassificationDataset", + "Classifications", + "Color", + "ColorAnnotator", + "ColorLookup", + "ColorPalette", + "CompactMask", + "ComparisonAnnotator", + "ConfusionMatrix", + "CropAnnotator", + "DetectionDataset", + "Detections", + "DetectionsSmoother", + "DotAnnotator", + "EdgeAnnotator", + "EllipseAnnotator", + "FPSMonitor", + "HaloAnnotator", + "HeatMapAnnotator", + "IconAnnotator", + "ImageSink", + "InferenceSlicer", + "JSONSink", + "KeyPoints", + "LabelAnnotator", + "LineZone", + "LineZoneAnnotator", + "LineZoneAnnotatorMulticlass", + "MaskAnnotator", + "MeanAveragePrecision", + "OrientedBoxAnnotator", + "OverlapFilter", + "OverlapMetric", + "PercentageBarAnnotator", + "PixelateAnnotator", + "Point", + "PolygonAnnotator", + "PolygonZone", + "PolygonZoneAnnotator", + "Position", + "Rect", + "RichLabelAnnotator", + "RoundBoxAnnotator", + "TraceAnnotator", + "TriangleAnnotator", + "VertexAnnotator", + "VertexEllipseAnnotator", + "VertexEllipseAreaAnnotator", + "VertexEllipseHaloAnnotator", + "VertexEllipseOutlineAnnotator", + "VertexLabelAnnotator", + "VideoInfo", + "VideoSink", + "WindowedRasterDataset", + "approximate_polygon", + "box_iou", + "box_iou_batch", + "box_iou_batch_with_jaccard", + "box_non_max_merge", + "box_non_max_suppression", + "calculate_masks_centroids", + "calculate_optimal_line_thickness", + "calculate_optimal_text_scale", + "clip_boxes", + "contains_holes", + "contains_multiple_segments", + "crop_image", + "cv2_to_pillow", + "denormalize_boxes", + "draw_filled_polygon", + "draw_filled_rectangle", + "draw_image", + "draw_line", + "draw_polygon", + "draw_rectangle", + "draw_text", + "edit_distance", + "filter_polygons_by_area", + "filter_segments_by_distance", + "fuzzy_match_index", + "get_coco_class_index_mapping", + "get_image_resolution_wh", + "get_polygon_center", + "get_video_frames_generator", + "grayscale_image", + "hex_to_rgba", + "is_compressed_rle", + "is_valid_hex", + "letterbox_image", + "list_files_with_extensions", + "mask_iou_batch", + "mask_non_max_merge", + "mask_non_max_suppression", + "mask_to_polygons", + "mask_to_rle", + "mask_to_roi", + "mask_to_xyxy", + "move_boxes", + "move_masks", + "oriented_box_iou_batch", + "oriented_box_non_max_merge", + "oriented_box_non_max_suppression", + "overlay_image", + "pad_boxes", + "pillow_to_cv2", + "plot_image", + "plot_images_grid", + "polygon_to_mask", + "polygon_to_xyxy", + "process_video", + "resize_image", + "rgba_to_hex", + "rle_to_mask", + "scale_boxes", + "scale_image", + "tint_image", + "xcycwh_to_xyxy", + "xywh_to_xyxy", + "xyxy_to_mask", + "xyxy_to_polygons", + "xyxy_to_xcycarh", + "xyxy_to_xywh", + "xyxyxyxy_to_xyxy", +] + + +def __getattr__(name: str) -> Any: + """Lazily resolve deprecated compatibility exports.""" + if name == "ByteTrack": + from supervision.tracker.byte_tracker.core import ByteTrack as byte_track + + globals()[name] = byte_track + return byte_track + raise AttributeError(f"module {__name__!r} has no attribute {name!r}") diff --git a/src/supervision/annotators/__init__.py b/src/supervision/annotators/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/src/supervision/annotators/base.py b/src/supervision/annotators/base.py new file mode 100644 index 0000000..d8f6f2c --- /dev/null +++ b/src/supervision/annotators/base.py @@ -0,0 +1,21 @@ +from abc import ABC, abstractmethod +from typing import Any + +from supervision.detection.core import Detections + + +class BaseAnnotator(ABC): + """Base class for annotators that consume :class:`Detections`. + + Attributes: + requires_mask: Whether integrations must provide ``Detections.mask`` for + this annotator. Check this before materializing expensive mask payloads. + """ + + requires_mask: bool = False + + @abstractmethod + def annotate( + self, scene: Any, detections: Detections, *args: Any, **kwargs: Any + ) -> Any: + pass diff --git a/src/supervision/annotators/core.py b/src/supervision/annotators/core.py new file mode 100644 index 0000000..14fb9ea --- /dev/null +++ b/src/supervision/annotators/core.py @@ -0,0 +1,3536 @@ +from collections.abc import Iterator +from functools import lru_cache +from math import sqrt +from typing import Any, ClassVar, cast + +import cv2 +import numpy as np +import numpy.typing as npt +from deprecate import deprecated, void # type: ignore[import-untyped,unused-ignore] +from PIL import Image, ImageDraw, ImageFont +from scipy.interpolate import splev, splprep + +from supervision.annotators.base import BaseAnnotator +from supervision.annotators.utils import ( + PENDING_TRACK_ID, + ColorLookup, + Trace, + _validate_labels, + calculate_dynamic_kernel_size, + calculate_dynamic_pixel_size, + get_labels_text, + hex_to_rgba, + resolve_color, + resolve_text_background_xyxy, + snap_boxes, + wrap_text, +) +from supervision.config import ORIENTED_BOX_COORDINATES +from supervision.detection.compact_mask import CompactMask +from supervision.detection.core import Detections +from supervision.detection.utils.boxes import clip_boxes, spread_out_boxes +from supervision.detection.utils.converters import ( + mask_to_polygons, + polygon_to_mask, + xyxy_to_polygons, +) +from supervision.detection.utils.masks import _masks_to_roi +from supervision.draw.base import ImageType +from supervision.draw.color import Color, ColorPalette +from supervision.draw.utils import draw_polygon, draw_rounded_rectangle, draw_text +from supervision.geometry.core import Point, Position, Rect +from supervision.utils.conversion import ( + ensure_cv2_image_for_class_method, + ensure_pil_image_for_class_method, +) +from supervision.utils.image import ( + _overlay_image, + crop_image, + letterbox_image, + scale_image, +) +from supervision.utils.logger import _get_logger + +logger = _get_logger(__name__) + + +@lru_cache +def _load_icon_from_path( + icon_path: str, icon_resolution_wh: tuple[int, int] +) -> npt.NDArray[np.uint8]: + """Load and resize an icon image through a cache shared by annotators.""" + icon = cv2.imread(icon_path, cv2.IMREAD_UNCHANGED) + if icon is None: + raise FileNotFoundError(f"Error: Couldn't load the icon image from {icon_path}") + icon_array = cast(npt.NDArray[np.uint8], icon) + result: npt.NDArray[np.uint8] = letterbox_image( + image=icon_array, resolution_wh=icon_resolution_wh + ) + return result + + +def _normalize_color_input(color: Color | ColorPalette | str) -> Color | ColorPalette: + """Normalize accepted color inputs to internal color objects. + + Accepts `Color`, `ColorPalette`, or hex string input. Hex strings are parsed via + `hex_to_rgba` and converted to `Color` (alpha channel is ignored because annotator + drawing uses RGB/BGR colors). + """ + if isinstance(color, str): + r, g, b, _ = hex_to_rgba(color) + return Color.from_rgb_tuple((r, g, b)) + return color + + +CV2_FONT = cv2.FONT_HERSHEY_SIMPLEX + + +class _BaseLabelAnnotator(BaseAnnotator): + """ + Base class for annotators that add labels to detections. + + Attributes: + color: The color to use for the label background. + color_lookup: The method used to determine the color of the label. + text_color: The color to use for the label text. + text_padding: The padding around the label text, in pixels. + text_anchor: The position of the text relative to the detection + bounding box. + text_offset: A tuple of 2D coordinates `(x, y)` to + offset the text position from the anchor point, in pixels. + border_radius: The radius of the label background corners, in pixels. + smart_position: Whether to intelligently adjust the label position to + avoid overlapping with other elements. + max_line_length: Maximum number of characters per line before + wrapping the text. None means no wrapping. + """ + + def __init__( + self, + color: Color | ColorPalette | str = ColorPalette.DEFAULT, + color_lookup: ColorLookup = ColorLookup.CLASS, + text_color: Color | ColorPalette | str = Color.WHITE, + text_padding: int = 10, + text_position: Position = Position.TOP_LEFT, + text_offset: tuple[int, int] = (0, 0), + border_radius: int = 0, + smart_position: bool = False, + max_line_length: int | None = None, + ): + """ + Initializes the _BaseLabelAnnotator. + + Args: + color: The color to use for the label + background. + color_lookup: The method used to determine the color + of the label + text_color: The color to use for the + label text. + text_padding: The padding around the label text, in pixels. + text_position: The position of the text relative to the + detection bounding box. + text_offset: A tuple of 2D coordinates + `(x, y)` to offset the text position from the anchor point, in pixels. + border_radius: The radius of the label background corners, + in pixels. + smart_position: Whether to intelligently adjust the label + position to avoid overlapping with other elements. + max_line_length: Maximum number of characters per + line before wrapping the text. None means no wrapping. + """ + self.color: Color | ColorPalette = _normalize_color_input(color) + self.color_lookup: ColorLookup = color_lookup + self.text_color: Color | ColorPalette = _normalize_color_input(text_color) + self.text_padding: int = text_padding + self.text_anchor: Position = text_position + self.text_offset: tuple[int, int] = text_offset + self.border_radius: int = border_radius + self.smart_position = smart_position + self.max_line_length: int | None = max_line_length + + def _adjust_labels_in_frame( + self, + resolution_wh: tuple[int, int], + labels: list[str], + label_properties: npt.NDArray[np.float32], + ) -> npt.NDArray[np.float32]: + """ + Adjusts the position of labels to ensure they stay within the frame boundaries. + + Args: + resolution_wh: The width and height of the frame. + labels: The list of text labels. + label_properties: An array of label properties, where each row + contains [x1, y1, x2, y2, text_height, ...]. + + Returns: + The adjusted label properties. + """ + adjusted_properties = label_properties.copy() + + # First, make sure the boxes don't go outside the frame + adjusted_properties[:, :4] = snap_boxes( + adjusted_properties[:, :4], + resolution_wh, + ) + + # Apply the spread out algorithm to avoid box overlaps + if len(labels) > 1: + # Extract the box coordinates + boxes = adjusted_properties[:, :4] + # Use the spread_out_boxes function to adjust overlapping boxes + spread_boxes = spread_out_boxes(boxes) + # Update the properties with the spread out boxes + adjusted_properties[:, :4] = spread_boxes + + # Additional check to ensure boxes are still within frame after spreading + adjusted_properties[:, :4] = snap_boxes( + adjusted_properties[:, :4], resolution_wh + ) + + return cast( + npt.NDArray[np.float32], + np.asarray(adjusted_properties, dtype=np.float32), + ) + + +class BoxAnnotator(BaseAnnotator): + """ + A class for drawing bounding boxes on an image using provided detections. + """ + + def __init__( + self, + color: Color | ColorPalette | str = ColorPalette.DEFAULT, + thickness: int = 2, + color_lookup: ColorLookup = ColorLookup.CLASS, + ): + """ + Args: + color: The color or color palette to use for + annotating detections. + thickness: Thickness of the bounding box lines. + color_lookup: Strategy for mapping colors to annotations. + Options are `INDEX`, `CLASS`, `TRACK`. + """ + self.color: Color | ColorPalette = _normalize_color_input(color) + self.thickness: int = thickness + self.color_lookup: ColorLookup = color_lookup + + @ensure_cv2_image_for_class_method + def annotate( + self, + scene: ImageType, + detections: Detections, + custom_color_lookup: npt.NDArray[np.int_] | None = None, + ) -> ImageType: + """ + Annotates the given scene with bounding boxes based on the provided detections. + + Args: + scene: The image where bounding boxes will be drawn. `ImageType` + is a flexible type, accepting either `numpy.ndarray` or + `PIL.Image.Image`. + detections: Object detections to annotate. + custom_color_lookup: Custom color lookup array. + Allows to override the default color mapping strategy. + + Returns: + The annotated image, matching the type of `scene` (`numpy.ndarray` + or `PIL.Image.Image`) + + Examples: + ```pycon + >>> import numpy as np + >>> import supervision as sv + >>> image = np.zeros((100, 100, 3), dtype=np.uint8) + >>> detections = sv.Detections( + ... xyxy=np.array([[20, 20, 80, 80]]), + ... class_id=np.array([0]) + ... ) + >>> box_annotator = sv.BoxAnnotator() + >>> annotated_frame = box_annotator.annotate( + ... scene=image.copy(), + ... detections=detections + ... ) + + ``` + + ![bounding-box-annotator-example](https://media.roboflow.com/ + supervision-annotator-examples/bounding-box-annotator-example-purple.png) + """ + if not isinstance(scene, np.ndarray): + return scene + for detection_idx in range(len(detections)): + x1, y1, x2, y2 = detections.xyxy[detection_idx].astype(int) + color = resolve_color( + color=self.color, + detections=detections, + detection_idx=detection_idx, + color_lookup=self.color_lookup + if custom_color_lookup is None + else custom_color_lookup, + ) + cv2.rectangle( + img=scene, + pt1=(x1, y1), + pt2=(x2, y2), + color=color.as_bgr(), + thickness=self.thickness, + ) + return scene + + +class OrientedBoxAnnotator(BaseAnnotator): + """ + A class for drawing oriented bounding boxes on an image using provided detections. + """ + + def __init__( + self, + color: Color | ColorPalette | str = ColorPalette.DEFAULT, + thickness: int = 2, + color_lookup: ColorLookup = ColorLookup.CLASS, + ): + """ + Args: + color: The color or color palette to use for + annotating detections. + thickness: Thickness of the bounding box lines. + color_lookup: Strategy for mapping colors to annotations. + Options are `INDEX`, `CLASS`, `TRACK`. + """ + self.color: Color | ColorPalette = _normalize_color_input(color) + self.thickness: int = thickness + self.color_lookup: ColorLookup = color_lookup + + @ensure_cv2_image_for_class_method + def annotate( + self, + scene: ImageType, + detections: Detections, + custom_color_lookup: npt.NDArray[np.int_] | None = None, + ) -> ImageType: + """ + Annotates the given scene with oriented bounding boxes based on the + provided detections. + + Args: + scene: The image where bounding boxes will be drawn. + `ImageType` is a flexible type, accepting either `numpy.ndarray` + or `PIL.Image.Image`. + detections: Object detections to annotate. + custom_color_lookup: Custom color lookup array. + Allows to override the default color mapping strategy. + + Returns: + The annotated image, matching the type of `scene` (`numpy.ndarray` + or `PIL.Image.Image`) + + Example: + ```python + import cv2 + import supervision as sv + from ultralytics import YOLO + + image = cv2.imread("") + model = YOLO("yolov8n-obb.pt") + + result = model(image)[0] + detections = sv.Detections.from_ultralytics(result) + + oriented_box_annotator = sv.OrientedBoxAnnotator() + annotated_frame = oriented_box_annotator.annotate( + scene=image.copy(), + detections=detections + ) + ``` + """ + if not isinstance(scene, np.ndarray): + return scene + if detections.data is None or ORIENTED_BOX_COORDINATES not in detections.data: + return scene + obb_boxes = np.array(detections.data[ORIENTED_BOX_COORDINATES]).astype(int) + + for detection_idx in range(len(detections)): + obb = obb_boxes[detection_idx] + color = resolve_color( + color=self.color, + detections=detections, + detection_idx=detection_idx, + color_lookup=self.color_lookup + if custom_color_lookup is None + else custom_color_lookup, + ) + + cv2.drawContours(scene, [obb], 0, color.as_bgr(), self.thickness) + + return scene + + +# --- Shared mask-painting utilities --- +def _iter_mask_crops( + detections: Detections, +) -> Iterator[tuple[int, npt.NDArray[np.bool_], npt.NDArray[np.int32] | None]]: + """Yield ``(detection_idx, mask_or_crop, offset_or_None)`` for each mask. + + Encapsulates the ``CompactMask`` vs dense dispatch so individual annotators + do not need inline ``isinstance`` checks. For ``CompactMask`` inputs yields + the bbox crop and its ``(x1, y1)`` image-space origin; for dense masks + yields the full-frame boolean slice with ``offset=None``. + + Args: + detections: Object detections whose masks to iterate. + + Yields: + Tuple of ``(detection_idx, mask_or_crop, offset_or_None)``. + ``mask_or_crop`` is boolean (crop-sized for ``CompactMask``, full-frame + for dense). ``offset_or_None`` is an int32 ``(x1, y1)`` array for + cropโ†’image translation, or ``None`` for dense masks. + """ + masks = detections.mask + if masks is None: + return + # TODO: replace isinstance dispatch with a MaskLike Protocol (separate PR) + compact_mask = masks if isinstance(masks, CompactMask) else None + for detection_idx in range(len(detections)): + if compact_mask is None: + yield ( + detection_idx, + cast(npt.NDArray[np.bool_], masks[detection_idx]), + None, + ) + else: + yield ( + detection_idx, + compact_mask.crop(detection_idx), + compact_mask.offsets[detection_idx], + ) + + +def _paint_masks_by_area( + canvas: npt.NDArray[np.uint8], + detections: Detections, + color: Color | ColorPalette, + color_lookup: ColorLookup | npt.NDArray[np.int_], + collect_union: bool = False, + canvas_origin: tuple[int, int] = (0, 0), +) -> npt.NDArray[np.bool_] | None: + """Paint each detection's mask into `canvas` in descending-area order. + + Smaller masks are drawn on top of larger ones. `CompactMask` detections + are painted into their bounding-box crop only, avoiding a full `(H, W)` + allocation per mask; dense masks fall back to full-frame boolean indexing. + + Args: + canvas: BGR image array painted in place. Shape ``(H, W, 3)``. + detections: Detections whose masks to paint. Returns immediately + without modifying `canvas` when ``detections.mask`` is ``None``. + color: Single color or palette used to resolve each detection's color. + color_lookup: Strategy for mapping colors to detection indices. + collect_union: When ``True``, allocate and return a ``(H, W)`` + boolean array that accumulates the union of all painted masks + (useful for callers like `HaloAnnotator` that need the combined + mask footprint). When ``False`` (default), returns ``None``. + canvas_origin: Absolute ``(x, y)`` origin of `canvas` within the source + image. Use the default for full-frame painting. + + Returns: + A boolean array matching the canvas dimensions when + ``collect_union=True``, otherwise ``None``. When called with an + ROI sub-canvas, dimensions are the ROI size, not the full image. + """ + masks = detections.mask + if masks is None: + return None + union: npt.NDArray[np.bool_] | None = ( + np.zeros(canvas.shape[:2], dtype=bool) if collect_union else None + ) + compact_mask = masks if isinstance(masks, CompactMask) else None + origin_x, origin_y = canvas_origin + canvas_h, canvas_w = canvas.shape[:2] + for detection_idx in np.flip(np.argsort(detections.area)): + color_bgr = resolve_color( + color=color, + detections=detections, + detection_idx=detection_idx, + color_lookup=color_lookup, + ).as_bgr() + if compact_mask is not None: + x1 = int(compact_mask.offsets[detection_idx, 0]) + y1 = int(compact_mask.offsets[detection_idx, 1]) + crop_m = compact_mask.crop(detection_idx) + crop_h, crop_w = crop_m.shape + crop_x1 = max(0, origin_x - x1) + crop_y1 = max(0, origin_y - y1) + canvas_x1 = max(0, x1 - origin_x) + canvas_y1 = max(0, y1 - origin_y) + paint_w = min(crop_w - crop_x1, canvas_w - canvas_x1) + paint_h = min(crop_h - crop_y1, canvas_h - canvas_y1) + if paint_w <= 0 or paint_h <= 0: + continue + crop_slice = crop_m[ + crop_y1 : crop_y1 + paint_h, crop_x1 : crop_x1 + paint_w + ] + canvas_slice = canvas[ + canvas_y1 : canvas_y1 + paint_h, + canvas_x1 : canvas_x1 + paint_w, + ] + canvas_slice[crop_slice] = color_bgr + if union is not None: + union[ + canvas_y1 : canvas_y1 + paint_h, + canvas_x1 : canvas_x1 + paint_w, + ] |= crop_slice + else: + mask = np.asarray(masks[detection_idx], dtype=bool) + mask = mask[origin_y : origin_y + canvas_h, origin_x : origin_x + canvas_w] + canvas[mask] = color_bgr + if union is not None: + union |= mask + return union + + +class MaskAnnotator(BaseAnnotator): + """ + A class for drawing masks on an image using provided detections. + + !!! warning + + This annotator uses `sv.Detections.mask`. + """ + + requires_mask = True + + def __init__( + self, + color: Color | ColorPalette | str = ColorPalette.DEFAULT, + opacity: float = 0.5, + color_lookup: ColorLookup = ColorLookup.CLASS, + ): + """ + Args: + color: The color or color palette to use for + annotating detections. + opacity: Opacity of the overlay mask. Must be between `0` and `1`. + color_lookup: Strategy for mapping colors to annotations. + Options are `INDEX`, `CLASS`, `TRACK`. + """ + self.color: Color | ColorPalette = _normalize_color_input(color) + self.opacity = opacity + self.color_lookup: ColorLookup = color_lookup + + @ensure_cv2_image_for_class_method + def annotate( + self, + scene: ImageType, + detections: Detections, + custom_color_lookup: npt.NDArray[np.int_] | None = None, + ) -> ImageType: + """ + Annotates the given scene with masks based on the provided detections. + + Args: + scene: The image where masks will be drawn. + `ImageType` is a flexible type, accepting either `numpy.ndarray` + or `PIL.Image.Image`. + detections: Object detections to annotate. + custom_color_lookup: Custom color lookup array. + Allows to override the default color mapping strategy. + + Returns: + The annotated image, matching the type of `scene` (`numpy.ndarray` + or `PIL.Image.Image`) + + Examples: + ```pycon + >>> import numpy as np + >>> import supervision as sv + >>> image = np.zeros((100, 100, 3), dtype=np.uint8) + >>> detections = sv.Detections( + ... xyxy=np.array([[20, 20, 80, 80]]), + ... mask=np.zeros((1, 100, 100), dtype=bool), + ... class_id=np.array([0]) + ... ) + >>> mask_annotator = sv.MaskAnnotator() + >>> annotated_frame = mask_annotator.annotate( + ... scene=image.copy(), + ... detections=detections + ... ) + + ``` + + ![mask-annotator-example](https://media.roboflow.com/ + supervision-annotator-examples/mask-annotator-example-purple.png) + """ + if not isinstance(scene, np.ndarray): + return scene + if detections.mask is None: + return scene + + image_shape = (int(scene.shape[0]), int(scene.shape[1])) + effective_lookup = ( + self.color_lookup if custom_color_lookup is None else custom_color_lookup + ) + if len(detections) > 0: + resolve_color( + color=self.color, + detections=detections, + detection_idx=0, + color_lookup=effective_lookup, + ) + roi = _masks_to_roi(detections.mask, image_shape, detections.xyxy) + if roi is None: + return scene + + x1, y1, x2, y2 = roi + scene_roi = scene[y1:y2, x1:x2] + colored_mask = np.array(scene_roi, copy=True, dtype=np.uint8) + _paint_masks_by_area( + colored_mask, + detections, + self.color, + effective_lookup, + canvas_origin=(x1, y1), + ) + tmp = cv2.addWeighted( + colored_mask, self.opacity, scene_roi.copy(), 1 - self.opacity, 0 + ) + scene_roi[:] = tmp + return scene + + +class PolygonAnnotator(BaseAnnotator): + """ + A class for drawing polygons on an image using provided detections. + + !!! warning + + This annotator uses `sv.Detections.mask`. + """ + + requires_mask = True + + def __init__( + self, + color: Color | ColorPalette | str = ColorPalette.DEFAULT, + thickness: int = 2, + color_lookup: ColorLookup = ColorLookup.CLASS, + ): + """ + Args: + color: The color or color palette to use for + annotating detections. + thickness: Thickness of the polygon lines. + color_lookup: Strategy for mapping colors to annotations. + Options are `INDEX`, `CLASS`, `TRACK`. + """ + self.color: Color | ColorPalette = _normalize_color_input(color) + self.thickness: int = thickness + self.color_lookup: ColorLookup = color_lookup + + @ensure_cv2_image_for_class_method + def annotate( + self, + scene: ImageType, + detections: Detections, + custom_color_lookup: npt.NDArray[np.int_] | None = None, + ) -> ImageType: + """ + Annotates the given scene with polygons based on the provided detections. + + Args: + scene: The image where polygons will be drawn. + `ImageType` is a flexible type, accepting either `numpy.ndarray` + or `PIL.Image.Image`. + detections: Object detections to annotate. + custom_color_lookup: Custom color lookup array. + Allows to override the default color mapping strategy. + + Returns: + The annotated image, matching the type of `scene` (`numpy.ndarray` + or `PIL.Image.Image`) + + Examples: + ```pycon + >>> import numpy as np + >>> import supervision as sv + >>> image = np.zeros((100, 100, 3), dtype=np.uint8) + >>> detections = sv.Detections( + ... xyxy=np.array([[20, 20, 80, 80]]), + ... class_id=np.array([0]) + ... ) + >>> polygon_annotator = sv.PolygonAnnotator() + >>> annotated_frame = polygon_annotator.annotate( + ... scene=image.copy(), + ... detections=detections + ... ) + + ``` + + Note: + When `detections.mask` is a `CompactMask`, each detection's polygon + is decoded from a bbox-sized crop (O(crop_area)) rather than a + full-frame ``(H, W)`` allocation (O(HยทW)). Polygon coordinates are + shifted from crop-local space to image space via the stored + ``(x1, y1)`` bbox origin. Pixels outside the declared ``xyxy`` box + are not represented in compact storage and will not be drawn. + + ![polygon-annotator-example](https://media.roboflow.com/ + supervision-annotator-examples/polygon-annotator-example-purple.png) + """ + if not isinstance(scene, np.ndarray): + return scene + if detections.mask is None: + return scene + + for detection_idx, mask, offset in _iter_mask_crops(detections): + color = resolve_color( + color=self.color, + detections=detections, + detection_idx=detection_idx, + color_lookup=self.color_lookup + if custom_color_lookup is None + else custom_color_lookup, + ) + for polygon in mask_to_polygons(mask=mask): + if offset is not None: + # translate crop-local polygon to image space via (x1, y1) origin + polygon = polygon + offset + scene = draw_polygon( + scene=scene, + polygon=cast(npt.NDArray[np.int_], polygon), + color=color, + thickness=self.thickness, + ) + + return scene + + +class ColorAnnotator(BaseAnnotator): + """ + A class for drawing box masks on an image using provided detections. + """ + + def __init__( + self, + color: Color | ColorPalette | str = ColorPalette.DEFAULT, + opacity: float = 0.5, + color_lookup: ColorLookup = ColorLookup.CLASS, + ): + """ + Args: + color: The color or color palette to use for + annotating detections. + opacity: Opacity of the overlay mask. Must be between `0` and `1`. + color_lookup: Strategy for mapping colors to annotations. + Options are `INDEX`, `CLASS`, `TRACK`. + """ + self.color: Color | ColorPalette = _normalize_color_input(color) + self.color_lookup: ColorLookup = color_lookup + self.opacity = opacity + + @ensure_cv2_image_for_class_method + def annotate( + self, + scene: ImageType, + detections: Detections, + custom_color_lookup: npt.NDArray[np.int_] | None = None, + ) -> ImageType: + """ + Annotates the given scene with box masks based on the provided detections. + + Args: + scene: The image where bounding boxes will be drawn. + `ImageType` is a flexible type, accepting either `numpy.ndarray` + or `PIL.Image.Image`. + detections: Object detections to annotate. + custom_color_lookup: Custom color lookup array. + Allows to override the default color mapping strategy. + + Returns: + The annotated image, matching the type of `scene` (`numpy.ndarray` + or `PIL.Image.Image`) + + Examples: + ```pycon + >>> import numpy as np + >>> import supervision as sv + >>> image = np.zeros((100, 100, 3), dtype=np.uint8) + >>> detections = sv.Detections( + ... xyxy=np.array([[20, 20, 80, 80]]), + ... class_id=np.array([0]) + ... ) + >>> color_annotator = sv.ColorAnnotator() + >>> annotated_frame = color_annotator.annotate( + ... scene=image.copy(), + ... detections=detections + ... ) + + ``` + + ![box-mask-annotator-example](https://media.roboflow.com/ + supervision-annotator-examples/box-mask-annotator-example-purple.png) + """ + if not isinstance(scene, np.ndarray): + return scene + scene_with_boxes = scene.copy() + for detection_idx in range(len(detections)): + x1, y1, x2, y2 = detections.xyxy[detection_idx].astype(int) + color = resolve_color( + color=self.color, + detections=detections, + detection_idx=detection_idx, + color_lookup=self.color_lookup + if custom_color_lookup is None + else custom_color_lookup, + ) + cv2.rectangle( + img=scene_with_boxes, + pt1=(x1, y1), + pt2=(x2, y2), + color=color.as_bgr(), + thickness=-1, + ) + + cv2.addWeighted( + scene_with_boxes, self.opacity, scene, 1 - self.opacity, gamma=0, dst=scene + ) + return scene + + +class HaloAnnotator(BaseAnnotator): + """ + A class for drawing Halos on an image using provided detections. + + !!! warning + + This annotator uses `sv.Detections.mask`. + """ + + requires_mask = True + + def __init__( + self, + color: Color | ColorPalette | str = ColorPalette.DEFAULT, + opacity: float = 0.8, + kernel_size: int = 40, + color_lookup: ColorLookup = ColorLookup.CLASS, + ): + """ + Args: + color: The color or color palette to use for + annotating detections. + opacity: Opacity of the overlay mask. Must be between `0` and `1`. + kernel_size: The size of the average pooling kernel used for creating + the halo. + color_lookup: Strategy for mapping colors to annotations. + Options are `INDEX`, `CLASS`, `TRACK`. + """ + self.color: Color | ColorPalette = _normalize_color_input(color) + self.opacity = opacity + self.color_lookup: ColorLookup = color_lookup + self.kernel_size: int = kernel_size + + @ensure_cv2_image_for_class_method + def annotate( + self, + scene: ImageType, + detections: Detections, + custom_color_lookup: npt.NDArray[np.int_] | None = None, + ) -> ImageType: + """ + Annotates the given scene with halos based on the provided detections. + + Args: + scene: The image where the halo effect will be applied. + `ImageType` is a flexible type, accepting either `numpy.ndarray` + or `PIL.Image.Image`. + detections: Object detections to annotate. + custom_color_lookup: Custom color lookup array. + Allows to override the default color mapping strategy. + + Returns: + The annotated image, matching the type of `scene` (`numpy.ndarray` + or `PIL.Image.Image`) + + Examples: + ```pycon + >>> import numpy as np + >>> import supervision as sv + >>> image = np.zeros((100, 100, 3), dtype=np.uint8) + >>> detections = sv.Detections( + ... xyxy=np.array([[20, 20, 80, 80]]), + ... mask=np.zeros((1, 100, 100), dtype=bool), + ... class_id=np.array([0]) + ... ) + >>> halo_annotator = sv.HaloAnnotator() + >>> annotated_frame = halo_annotator.annotate( + ... scene=image.copy(), + ... detections=detections + ... ) + + ``` + + ![halo-annotator-example](https://media.roboflow.com/ + supervision-annotator-examples/halo-annotator-example-purple.png) + """ + if not isinstance(scene, np.ndarray): + return scene + if detections.mask is None: + return scene + colored_mask = np.zeros_like(scene, dtype=np.uint8) + fmask = _paint_masks_by_area( + colored_mask, + detections, + self.color, + self.color_lookup if custom_color_lookup is None else custom_color_lookup, + collect_union=True, + ) + assert fmask is not None # collect_union=True always returns an array + + colored_mask = cast( + npt.NDArray[np.uint8], + cv2.blur(colored_mask, (self.kernel_size, self.kernel_size)), + ) + colored_mask[fmask] = [0, 0, 0] + gray = cv2.cvtColor(colored_mask, cv2.COLOR_BGR2GRAY) + gray_max = gray.max() + if gray_max == 0: + # no halo to draw (e.g. empty masks); leave the scene untouched + return scene + alpha = self.opacity * gray / gray_max + alpha_mask = alpha[:, :, np.newaxis] + # Blend in float space so halo opacity cannot wrap around uint8 boundaries. + blended_scene = np.clip( + scene.astype(np.float32) * (1 - alpha_mask) + + colored_mask.astype(np.float32) * alpha_mask, + 0, + 255, + ).astype(np.uint8) + np.copyto(scene, blended_scene) + return scene + + +class EllipseAnnotator(BaseAnnotator): + """ + A class for drawing ellipses on an image using provided detections. + """ + + def __init__( + self, + color: Color | ColorPalette | str = ColorPalette.DEFAULT, + thickness: int = 2, + start_angle: int = -45, + end_angle: int = 235, + color_lookup: ColorLookup = ColorLookup.CLASS, + ): + """ + Args: + color: The color or color palette to use for + annotating detections. + thickness: Thickness of the ellipse lines. + start_angle: Starting angle of the ellipse. + end_angle: Ending angle of the ellipse. + color_lookup: Strategy for mapping colors to annotations. + Options are `INDEX`, `CLASS`, `TRACK`. + """ + self.color: Color | ColorPalette = _normalize_color_input(color) + self.thickness: int = thickness + self.start_angle: int = start_angle + self.end_angle: int = end_angle + self.color_lookup: ColorLookup = color_lookup + + @ensure_cv2_image_for_class_method + def annotate( + self, + scene: ImageType, + detections: Detections, + custom_color_lookup: npt.NDArray[np.int_] | None = None, + ) -> ImageType: + """ + Annotates the given scene with ellipses based on the provided detections. + + Args: + scene: The image where ellipses will be drawn. + `ImageType` is a flexible type, accepting either `numpy.ndarray` + or `PIL.Image.Image`. + detections: Object detections to annotate. + custom_color_lookup: Custom color lookup array. + Allows to override the default color mapping strategy. + + Returns: + The annotated image, matching the type of `scene` (`numpy.ndarray` + or `PIL.Image.Image`) + + Examples: + ```pycon + >>> import numpy as np + >>> import supervision as sv + >>> image = np.zeros((100, 100, 3), dtype=np.uint8) + >>> detections = sv.Detections( + ... xyxy=np.array([[20, 20, 80, 80]]), + ... class_id=np.array([0]) + ... ) + >>> ellipse_annotator = sv.EllipseAnnotator() + >>> annotated_frame = ellipse_annotator.annotate( + ... scene=image.copy(), + ... detections=detections + ... ) + + ``` + + ![ellipse-annotator-example](https://media.roboflow.com/ + supervision-annotator-examples/ellipse-annotator-example-purple.png) + """ + if not isinstance(scene, np.ndarray): + return scene + for detection_idx in range(len(detections)): + x1, _y1, x2, y2 = detections.xyxy[detection_idx].astype(int) + color = resolve_color( + color=self.color, + detections=detections, + detection_idx=detection_idx, + color_lookup=self.color_lookup + if custom_color_lookup is None + else custom_color_lookup, + ) + center = (int((x1 + x2) / 2), y2) + width = x2 - x1 + cv2.ellipse( + scene, + center=center, + axes=(int(width), int(0.35 * width)), + angle=0.0, + startAngle=self.start_angle, + endAngle=self.end_angle, + color=color.as_bgr(), + thickness=self.thickness, + lineType=cv2.LINE_4, + ) + return scene + + +class BoxCornerAnnotator(BaseAnnotator): + """ + A class for drawing box corners on an image using provided detections. + """ + + def __init__( + self, + color: Color | ColorPalette | str = ColorPalette.DEFAULT, + thickness: int = 4, + corner_length: int = 15, + color_lookup: ColorLookup = ColorLookup.CLASS, + ): + """ + Args: + color: The color or color palette to use for + annotating detections. + thickness: Thickness of the corner lines. + corner_length: Length of each corner line. + color_lookup: Strategy for mapping colors to annotations. + Options are `INDEX`, `CLASS`, `TRACK`. + """ + self.color: Color | ColorPalette = _normalize_color_input(color) + self.thickness: int = thickness + self.corner_length: int = corner_length + self.color_lookup: ColorLookup = color_lookup + + @ensure_cv2_image_for_class_method + def annotate( + self, + scene: ImageType, + detections: Detections, + custom_color_lookup: npt.NDArray[np.int_] | None = None, + ) -> ImageType: + """ + Annotates the given scene with box corners based on the provided detections. + + Args: + scene: The image where box corners will be drawn. + `ImageType` is a flexible type, accepting either `numpy.ndarray` + or `PIL.Image.Image`. + detections: Object detections to annotate. + custom_color_lookup: Custom color lookup array. + Allows to override the default color mapping strategy. + + Returns: + The annotated image, matching the type of `scene` (`numpy.ndarray` + or `PIL.Image.Image`) + + Examples: + ```pycon + >>> import numpy as np + >>> import supervision as sv + >>> image = np.zeros((100, 100, 3), dtype=np.uint8) + >>> detections = sv.Detections( + ... xyxy=np.array([[20, 20, 80, 80]]), + ... class_id=np.array([0]) + ... ) + >>> corner_annotator = sv.BoxCornerAnnotator() + >>> annotated_frame = corner_annotator.annotate( + ... scene=image.copy(), + ... detections=detections + ... ) + + ``` + + ![box-corner-annotator-example](https://media.roboflow.com/ + supervision-annotator-examples/box-corner-annotator-example-purple.png) + """ + if not isinstance(scene, np.ndarray): + return scene + for detection_idx in range(len(detections)): + x1, y1, x2, y2 = detections.xyxy[detection_idx].astype(int) + color = resolve_color( + color=self.color, + detections=detections, + detection_idx=detection_idx, + color_lookup=self.color_lookup + if custom_color_lookup is None + else custom_color_lookup, + ) + corners = [(x1, y1), (x2, y1), (x1, y2), (x2, y2)] + + for x, y in corners: + x_end = x + self.corner_length if x == x1 else x - self.corner_length + cv2.line( + scene, (x, y), (x_end, y), color.as_bgr(), thickness=self.thickness + ) + + y_end = y + self.corner_length if y == y1 else y - self.corner_length + cv2.line( + scene, (x, y), (x, y_end), color.as_bgr(), thickness=self.thickness + ) + return scene + + +class CircleAnnotator(BaseAnnotator): + """ + A class for drawing circle on an image using provided detections. + """ + + def __init__( + self, + color: Color | ColorPalette | str = ColorPalette.DEFAULT, + thickness: int = 2, + color_lookup: ColorLookup = ColorLookup.CLASS, + ): + """ + Args: + color: The color or color palette to use for + annotating detections. + thickness: Thickness of the circle line. + color_lookup: Strategy for mapping colors to annotations. + Options are `INDEX`, `CLASS`, `TRACK`. + """ + + self.color: Color | ColorPalette = _normalize_color_input(color) + self.thickness: int = thickness + self.color_lookup: ColorLookup = color_lookup + + @ensure_cv2_image_for_class_method + def annotate( + self, + scene: ImageType, + detections: Detections, + custom_color_lookup: npt.NDArray[np.int_] | None = None, + ) -> ImageType: + """ + Annotates the given scene with circles based on the provided detections. + + Args: + scene: The image where box corners will be drawn. + `ImageType` is a flexible type, accepting either `numpy.ndarray` + or `PIL.Image.Image`. + detections: Object detections to annotate. + custom_color_lookup: Custom color lookup array. + Allows to override the default color mapping strategy. + + Returns: + The annotated image, matching the type of `scene` (`numpy.ndarray` + or `PIL.Image.Image`) + + Examples: + ```pycon + >>> import numpy as np + >>> import supervision as sv + >>> image = np.zeros((100, 100, 3), dtype=np.uint8) + >>> detections = sv.Detections( + ... xyxy=np.array([[20, 20, 80, 80]]), + ... class_id=np.array([0]) + ... ) + >>> circle_annotator = sv.CircleAnnotator() + >>> annotated_frame = circle_annotator.annotate( + ... scene=image.copy(), + ... detections=detections + ... ) + + ``` + + + ![circle-annotator-example](https://media.roboflow.com/ + supervision-annotator-examples/circle-annotator-example-purple.png) + """ + if not isinstance(scene, np.ndarray): + return scene + for detection_idx in range(len(detections)): + x1, y1, x2, y2 = detections.xyxy[detection_idx].astype(int) + center = ((x1 + x2) // 2, (y1 + y2) // 2) + distance = sqrt((x1 - center[0]) ** 2 + (y1 - center[1]) ** 2) + color = resolve_color( + color=self.color, + detections=detections, + detection_idx=detection_idx, + color_lookup=self.color_lookup + if custom_color_lookup is None + else custom_color_lookup, + ) + cv2.circle( + img=scene, + center=center, + radius=int(distance), + color=color.as_bgr(), + thickness=self.thickness, + ) + + return scene + + +class DotAnnotator(BaseAnnotator): + """ + A class for drawing dots on an image at specific coordinates based on provided + detections. + """ + + def __init__( + self, + color: Color | ColorPalette | str = ColorPalette.DEFAULT, + radius: int = 4, + position: Position = Position.CENTER, + color_lookup: ColorLookup = ColorLookup.CLASS, + outline_thickness: int = 0, + outline_color: Color | ColorPalette | str = Color.BLACK, + ): + """ + Args: + color: The color or color palette to use for + annotating detections. + radius: Radius of the drawn dots. + position: The anchor position for placing the dot. + color_lookup: Strategy for mapping colors to annotations. + Options are `INDEX`, `CLASS`, `TRACK`. + outline_thickness: Thickness of the outline of the dot. + outline_color: The color or color palette to + use for outline. It is activated by setting outline_thickness to a value + greater than 0. + """ + self.color: Color | ColorPalette = _normalize_color_input(color) + self.radius: int = radius + self.position: Position = position + self.color_lookup: ColorLookup = color_lookup + self.outline_thickness = outline_thickness + self.outline_color: Color | ColorPalette = _normalize_color_input(outline_color) + + @ensure_cv2_image_for_class_method + def annotate( + self, + scene: ImageType, + detections: Detections, + custom_color_lookup: npt.NDArray[np.int_] | None = None, + ) -> ImageType: + """ + Annotates the given scene with dots based on the provided detections. + + Args: + scene: The image where dots will be drawn. + `ImageType` is a flexible type, accepting either `numpy.ndarray` + or `PIL.Image.Image`. + detections: Object detections to annotate. + custom_color_lookup: Custom color lookup array. + Allows to override the default color mapping strategy. + + Returns: + The annotated image, matching the type of `scene` (`numpy.ndarray` + or `PIL.Image.Image`) + + Examples: + ```pycon + >>> import numpy as np + >>> import supervision as sv + >>> image = np.zeros((100, 100, 3), dtype=np.uint8) + >>> detections = sv.Detections( + ... xyxy=np.array([[20, 20, 80, 80]]), + ... class_id=np.array([0]) + ... ) + >>> dot_annotator = sv.DotAnnotator() + >>> annotated_frame = dot_annotator.annotate( + ... scene=image.copy(), + ... detections=detections + ... ) + + ``` + + ![dot-annotator-example](https://media.roboflow.com/ + supervision-annotator-examples/dot-annotator-example-purple.png) + """ + if not isinstance(scene, np.ndarray): + return scene + xy = detections.get_anchors_coordinates(anchor=self.position) + for detection_idx in range(len(detections)): + color = resolve_color( + color=self.color, + detections=detections, + detection_idx=detection_idx, + color_lookup=self.color_lookup + if custom_color_lookup is None + else custom_color_lookup, + ) + center = (int(xy[detection_idx, 0]), int(xy[detection_idx, 1])) + + cv2.circle(scene, center, self.radius, color.as_bgr(), -1) + if self.outline_thickness: + outline_color = resolve_color( + color=self.outline_color, + detections=detections, + detection_idx=detection_idx, + color_lookup=self.color_lookup + if custom_color_lookup is None + else custom_color_lookup, + ) + cv2.circle( + scene, + center, + self.radius, + outline_color.as_bgr(), + self.outline_thickness, + ) + return scene + + +class LabelAnnotator(_BaseLabelAnnotator): + """ + A class for annotating labels on an image using provided detections. + """ + + def __init__( + self, + color: Color | ColorPalette | str = ColorPalette.DEFAULT, + color_lookup: ColorLookup = ColorLookup.CLASS, + text_color: Color | ColorPalette | str = Color.WHITE, + text_scale: float = 0.5, + text_thickness: int = 1, + text_padding: int = 10, + text_position: Position = Position.TOP_LEFT, + text_offset: tuple[int, int] = (0, 0), + border_radius: int = 0, + smart_position: bool = False, + max_line_length: int | None = None, + ): + """ + Args: + color: The color or color palette to use for + annotating the text background. + color_lookup: Strategy for mapping colors to annotations. + Options are `INDEX`, `CLASS`, `TRACK`. + text_color: The color or color palette to use + for the text. + text_scale: Font scale for the text. + text_thickness: Thickness of the text characters. + text_padding: Padding around the text within its background box. + text_position: Position of the text relative to the detection. + Possible values are defined in the `Position` enum. + text_offset: A tuple of 2D coordinates `(x, y)` to + offset the text position from the anchor point, in pixels. + border_radius: The radius to apply round edges. If the selected + value is higher than the lower dimension, width or height, is clipped. + smart_position: Spread out the labels to avoid overlapping. + max_line_length: Maximum number of characters per line + before wrapping the text. None means no wrapping. + """ + self.text_scale: float = text_scale + self.text_thickness: int = text_thickness + super().__init__( + color=color, + color_lookup=color_lookup, + text_color=text_color, + text_padding=text_padding, + text_position=text_position, + text_offset=text_offset, + border_radius=border_radius, + smart_position=smart_position, + max_line_length=max_line_length, + ) + + @ensure_cv2_image_for_class_method + def annotate( + self, + scene: ImageType, + detections: Detections, + labels: list[str] | None = None, + custom_color_lookup: npt.NDArray[np.int_] | None = None, + ) -> ImageType: + """ + Annotates the given scene with labels based on the provided detections. + + Args: + scene: The image where labels will be drawn. + `ImageType` is a flexible type, accepting either `numpy.ndarray` + or `PIL.Image.Image`. + detections: Object detections to annotate. + labels: Custom labels for each detection. + custom_color_lookup: Custom color lookup array. + Allows to override the default color mapping strategy. + + Returns: + The annotated image, matching the type of `scene` (`numpy.ndarray` + or `PIL.Image.Image`) + + Examples: + ```pycon + >>> import numpy as np + >>> import supervision as sv + >>> image = np.zeros((100, 100, 3), dtype=np.uint8) + >>> detections = sv.Detections( + ... xyxy=np.array([[20, 20, 80, 80]]), + ... confidence=np.array([0.9]), + ... class_id=np.array([0]), + ... data={'class_name': np.array(['person'])} + ... ) + >>> labels = [ + ... f"{class_name} {confidence:.2f}" + ... for class_name, confidence + ... in zip(detections['class_name'], detections.confidence) + ... ] + >>> label_annotator = sv.LabelAnnotator(text_position=sv.Position.CENTER) + >>> annotated_frame = label_annotator.annotate( + ... scene=image.copy(), + ... detections=detections, + ... labels=labels + ... ) + + ``` + + ![label-annotator-example](https://media.roboflow.com/ + supervision-annotator-examples/label-annotator-example-purple.png) + """ + if not isinstance(scene, np.ndarray): + return scene + _validate_labels(labels, detections) + + labels = get_labels_text(detections, labels) + label_properties: npt.NDArray[np.float32] = self._get_label_properties( + detections, labels + ) + + if self.smart_position: + label_properties = self._adjust_labels_in_frame( + (scene.shape[1], scene.shape[0]), + labels, + label_properties, + ) + + self._draw_labels( + scene=scene, + labels=labels, + label_properties=label_properties, + detections=detections, + custom_color_lookup=custom_color_lookup, + ) + + return scene + + def _get_label_properties( + self, + detections: Detections, + labels: list[str], + ) -> Any: + label_properties = [] + anchors_coordinates: npt.NDArray[np.int32] = detections.get_anchors_coordinates( + anchor=self.text_anchor + ).astype(int) + + for label, center_coordinates in zip(labels, anchors_coordinates): + center_coordinates = ( + center_coordinates[0] + self.text_offset[0], + center_coordinates[1] + self.text_offset[1], + ) + + wrapped_lines = wrap_text(label, self.max_line_length) + line_heights = [] + line_widths = [] + + for line in wrapped_lines: + (text_w, text_h) = cv2.getTextSize( + text=line, + fontFace=CV2_FONT, + fontScale=self.text_scale, + thickness=self.text_thickness, + )[0] + line_heights.append(text_h) + line_widths.append(text_w) + + # Get the maximum width and total height + max_width = max(line_widths) if line_widths else 0 + total_height = ( + sum(line_heights) + (len(line_heights) - 1) * self.text_padding + ) + + # Add padding around all sides + width_padded = max_width + 2 * self.text_padding + height_padded = total_height + 2 * self.text_padding + + text_background_xyxy = resolve_text_background_xyxy( + center_coordinates=center_coordinates, + text_wh=(width_padded, height_padded), + position=self.text_anchor, + ) + + label_properties.append( + [ + *text_background_xyxy, + total_height, + ] + ) + return np.array(label_properties, dtype=np.float32).reshape(-1, 5) + + def _draw_labels( + self, + scene: npt.NDArray[np.uint8], + labels: list[str], + label_properties: npt.NDArray[np.float32], + detections: Detections, + custom_color_lookup: npt.NDArray[np.int_] | None, + ) -> None: + assert len(labels) == len(label_properties) == len(detections), ( + f"Number of label properties ({len(label_properties)}), " + f"labels ({len(labels)}) and detections ({len(detections)}) " + "do not match." + ) + + color_lookup = ( + custom_color_lookup + if custom_color_lookup is not None + else self.color_lookup + ) + + for idx, label_property in enumerate(label_properties): + background_color = resolve_color( + color=self.color, + detections=detections, + detection_idx=idx, + color_lookup=color_lookup, + ) + text_color = resolve_color( + color=self.text_color, + detections=detections, + detection_idx=idx, + color_lookup=color_lookup, + ) + + box_xyxy = label_property[:4].astype(int) + + self.draw_rounded_rectangle( + scene=scene, + xyxy=box_xyxy, + color=background_color.as_bgr(), + border_radius=self.border_radius, + ) + + # Handle multiline text + wrapped_lines = wrap_text(labels[idx], self.max_line_length) + current_y = box_xyxy[1] + self.text_padding # Start y position + + for line in wrapped_lines: + if not line: + # Use a character with ascenders and descenders as height reference + (_, text_h) = cv2.getTextSize( + text="Tg", + fontFace=CV2_FONT, + fontScale=self.text_scale, + thickness=self.text_thickness, + )[0] + current_y += text_h + self.text_padding + continue + + (_, text_h) = cv2.getTextSize( + text=line, + fontFace=CV2_FONT, + fontScale=self.text_scale, + thickness=self.text_thickness, + )[0] + + text_x = box_xyxy[0] + self.text_padding + text_y = current_y + text_h # Add height to get to text baseline + + cv2.putText( + img=scene, + text=line, + org=(text_x, text_y), + fontFace=CV2_FONT, + fontScale=self.text_scale, + color=text_color.as_bgr(), + thickness=self.text_thickness, + lineType=cv2.LINE_AA, + ) + + current_y += text_h + self.text_padding # Move to next line position + + @staticmethod + def draw_rounded_rectangle( + scene: npt.NDArray[np.uint8], + xyxy: tuple[int, int, int, int], + color: tuple[int, int, int], + border_radius: int, + ) -> npt.NDArray[np.uint8]: + """Draw a filled rectangle with optional rounded corners on an image. + + Args: + scene: BGR image array to draw on; modified in-place and returned. + xyxy: Bounding box as (x1, y1, x2, y2) pixel coordinates. + color: Fill color as a BGR tuple (e.g. ``(0, 0, 255)`` for red). + border_radius: Corner rounding radius in pixels. Values <= 0 + (including values clamped to 0 by a degenerate box) draw a + plain filled rectangle with square corners. + + Returns: + The annotated ``scene`` array. + + Example: + ```python + import numpy as np + import supervision as sv + + scene = np.zeros((200, 200, 3), dtype=np.uint8) + scene = sv.LabelAnnotator.draw_rounded_rectangle( + scene=scene, + xyxy=(10, 10, 100, 50), + color=(0, 255, 0), + border_radius=0, + ) + ``` + """ + x1, y1, x2, y2 = xyxy + width = x2 - x1 + height = y2 - y1 + + border_radius = min(border_radius, min(width, height) // 2) + + if border_radius <= 0: + # square corners: a single fill rectangle (the common default), rather + # than two rectangles plus four zero-radius corner circles + cv2.rectangle( + img=scene, + pt1=(x1, y1), + pt2=(x2, y2), + color=color, + thickness=-1, + ) + return scene + + rectangle_coordinates = [ + ((x1 + border_radius, y1), (x2 - border_radius, y2)), + ((x1, y1 + border_radius), (x2, y2 - border_radius)), + ] + circle_centers = [ + (x1 + border_radius, y1 + border_radius), + (x2 - border_radius, y1 + border_radius), + (x1 + border_radius, y2 - border_radius), + (x2 - border_radius, y2 - border_radius), + ] + + for coordinates in rectangle_coordinates: + cv2.rectangle( + img=scene, + pt1=coordinates[0], + pt2=coordinates[1], + color=color, + thickness=-1, + ) + for center in circle_centers: + cv2.circle( + img=scene, + center=center, + radius=border_radius, + color=color, + thickness=-1, + ) + return scene + + +class RichLabelAnnotator(_BaseLabelAnnotator): + """ + A class for annotating labels on an image using provided detections, + with support for Unicode characters by using a custom font. + """ + + def __init__( + self, + color: Color | ColorPalette | str = ColorPalette.DEFAULT, + color_lookup: ColorLookup = ColorLookup.CLASS, + text_color: Color | ColorPalette | str = Color.WHITE, + font_path: str | None = None, + font_size: int = 10, + text_padding: int = 10, + text_position: Position = Position.TOP_LEFT, + text_offset: tuple[int, int] = (0, 0), + border_radius: int = 0, + smart_position: bool = False, + max_line_length: int | None = None, + ): + """ + Args: + color: The color or color palette to use for + annotating the text background. + color_lookup: Strategy for mapping colors to annotations. + Options are `INDEX`, `CLASS`, `TRACK`. + text_color: The color to use for the text. + font_path: Path to the font file (e.g., ".ttf" or ".otf") + to use for rendering text. If `None`, the default PIL font will be used. + font_size: Font size for the text. + text_padding: Padding around the text within its background box. + text_position: Position of the text relative to the detection. + Possible values are defined in the `Position` enum. + text_offset: A tuple of 2D coordinates `(x, y)` to + offset the text position from the anchor point, in pixels. + border_radius: The radius to apply round edges. If the selected + value is higher than the lower dimension, width or height, is clipped. + smart_position: Spread out the labels to avoid overlapping. + max_line_length: Maximum number of characters per line + before wrapping the text. None means no wrapping. + """ + self.font_path = font_path + self.font_size = font_size + self.font = self._load_font(font_size, font_path) + super().__init__( + color=color, + color_lookup=color_lookup, + text_color=text_color, + text_padding=text_padding, + text_position=text_position, + text_offset=text_offset, + border_radius=border_radius, + smart_position=smart_position, + max_line_length=max_line_length, + ) + + @ensure_pil_image_for_class_method + def annotate( + self, + scene: ImageType, + detections: Detections, + labels: list[str] | None = None, + custom_color_lookup: npt.NDArray[np.int_] | None = None, + ) -> ImageType: + """ + Annotates the given scene with labels based on the provided + detections, with support for Unicode characters. + + Args: + scene: The image where labels will be drawn. + `ImageType` is a flexible type, accepting either `numpy.ndarray` + or `PIL.Image.Image`. + detections: Object detections to annotate. + labels: Custom labels for each detection. + custom_color_lookup: Custom color lookup array. + Allows to override the default color mapping strategy. + + Returns: + The annotated image, matching the type of `scene` (`numpy.ndarray` + or `PIL.Image.Image`) + + Examples: + ```pycon + >>> import numpy as np + >>> import supervision as sv + >>> from PIL import Image + >>> image = Image.fromarray(np.zeros((100, 100, 3), dtype=np.uint8)) + >>> detections = sv.Detections( + ... xyxy=np.array([[20, 20, 80, 80]]), + ... confidence=np.array([0.9]), + ... class_id=np.array([0]), + ... data={'class_name': np.array(['person'])} + ... ) + >>> labels = [ + ... f"{class_name} {confidence:.2f}" + ... for class_name, confidence + ... in zip(detections['class_name'], detections.confidence) + ... ] + >>> rich_label_annotator = sv.RichLabelAnnotator() + >>> annotated_frame = rich_label_annotator.annotate( + ... scene=image.copy(), + ... detections=detections, + ... labels=labels + ... ) + + ``` + """ + _validate_labels(labels, detections) + + draw = ImageDraw.Draw(scene) + labels = get_labels_text(detections, labels) + label_properties: npt.NDArray[np.float32] = self._get_label_properties( + draw, detections, labels + ) + + if self.smart_position: + scene_pil = cast(Image.Image, scene) + label_properties = self._adjust_labels_in_frame( + (scene_pil.width, scene_pil.height), + labels, + label_properties, + ) + + self._draw_labels( + draw=draw, + labels=labels, + label_properties=label_properties, + detections=detections, + custom_color_lookup=custom_color_lookup, + ) + + return scene + + def _get_label_properties( + self, draw: ImageDraw.ImageDraw, detections: Detections, labels: list[str] + ) -> Any: + label_properties = [] + + anchor_coordinates: npt.NDArray[np.int32] = detections.get_anchors_coordinates( + anchor=self.text_anchor + ).astype(int) + + for label, center_coordinates in zip(labels, anchor_coordinates): + center_coordinates = ( + center_coordinates[0] + self.text_offset[0], + center_coordinates[1] + self.text_offset[1], + ) + + wrapped_lines = wrap_text(label, self.max_line_length) + + # Calculate the total text height and maximum width + max_width = 0.0 + total_height = 0.0 + + for line in wrapped_lines: + left, top, right, bottom = draw.textbbox((0, 0), line, font=self.font) + line_width = right - left + line_height = bottom - top + + max_width = max(max_width, line_width) + total_height += line_height + + # Add inter-line spacing + if len(wrapped_lines) > 1: + total_height += (len(wrapped_lines) - 1) * self.text_padding + + width_padded = int(max_width + 2 * self.text_padding) + height_padded = int(total_height + 2 * self.text_padding) + + text_background_xyxy = resolve_text_background_xyxy( + center_coordinates=center_coordinates, + text_wh=(width_padded, height_padded), + position=self.text_anchor, + ) + + # Get the text origin offsets + text_left, text_top, _, _ = draw.textbbox((0, 0), "Tg", font=self.font) + + label_properties.append([*text_background_xyxy, text_left, text_top]) + + result: npt.NDArray[np.float32] = np.array( + label_properties, dtype=np.float32 + ).reshape(-1, 6) + return result + + def _draw_labels( + self, + draw: ImageDraw.ImageDraw, + labels: list[str], + label_properties: npt.NDArray[np.float32], + detections: Detections, + custom_color_lookup: npt.NDArray[np.int_] | None, + ) -> None: + assert len(labels) == len(label_properties) == len(detections), ( + f"Number of label properties ({len(label_properties)}), " + f"labels ({len(labels)}) and detections ({len(detections)}) " + "do not match." + ) + color_lookup = ( + custom_color_lookup + if custom_color_lookup is not None + else self.color_lookup + ) + + for idx, label_property in enumerate(label_properties): + background_color = resolve_color( + color=self.color, + detections=detections, + detection_idx=idx, + color_lookup=color_lookup, + ) + text_color = resolve_color( + color=self.text_color, + detections=detections, + detection_idx=idx, + color_lookup=color_lookup, + ) + + box_xyxy = label_property[:4].astype(int) + text_left = label_property[4] + text_top = label_property[5] + + # Draw the rounded rectangle background + draw.rounded_rectangle( + tuple(box_xyxy), + radius=self.border_radius, + fill=background_color.as_rgb(), + outline=None, + ) + + # Draw each line of text + wrapped_lines = wrap_text(labels[idx], self.max_line_length) + x_position = box_xyxy[0] + self.text_padding - text_left + y_position = box_xyxy[1] + self.text_padding - text_top + + for line in wrapped_lines: + draw.text( + xy=(x_position, y_position), + text=line, + font=self.font, + fill=text_color.as_rgb(), + ) + + # Move to the next line position + _left, top, _right, bottom = draw.textbbox((0, 0), line, font=self.font) + line_height = bottom - top + y_position += line_height + self.text_padding + + @staticmethod + def _load_font( + font_size: int, font_path: str | None + ) -> ImageFont.FreeTypeFont | ImageFont.ImageFont: + def load_default_font( + size: int, + ) -> ImageFont.FreeTypeFont | ImageFont.ImageFont: + try: + return ImageFont.load_default(size) + except TypeError: + return ImageFont.load_default() + + if font_path is None: + return load_default_font(font_size) + + try: + return ImageFont.truetype(font_path, font_size) + except OSError: + logger.warning( + "Font path '%s' not found. Using PIL's default font.", font_path + ) + return load_default_font(font_size) + + +class IconAnnotator(BaseAnnotator): + """ + A class for drawing an icon on an image, using provided detections. + """ + + def __init__( + self, + icon_resolution_wh: tuple[int, int] = (64, 64), + icon_position: Position = Position.TOP_CENTER, + offset_xy: tuple[int, int] = (0, 0), + ): + """ + Args: + icon_resolution_wh: The size of drawn icons. + All icons will be resized to this resolution, keeping the aspect ratio. + icon_position: The position of the icon. + offset_xy: The offset to apply to the icon position, + in pixels. Can be both positive and negative. + """ + self.icon_resolution_wh = icon_resolution_wh + self.position = icon_position + self.offset_xy = offset_xy + + @ensure_cv2_image_for_class_method + def annotate( + self, + scene: ImageType, + detections: Detections, + icon_path: str | list[str] = "", + ) -> ImageType: + """ + Annotates the given scene with given icons. + + Args: + scene: The image where labels will be drawn. + `ImageType` is a flexible type, accepting either `numpy.ndarray` + or `PIL.Image.Image`. + detections: Object detections to annotate. + icon_path: The path to the PNG image to use as an + icon. Must be a single path or a list of paths, one for each detection. + Pass an empty string `""` to draw nothing. + + Returns: + The annotated image, matching the type of `scene` (`numpy.ndarray` + or `PIL.Image.Image`) + + Example: + ```python + import supervision as sv + + image = ... + detections = sv.Detections(...) + + available_icons = ["roboflow.png", "lenny.png"] + icon_paths = [np.random.choice(available_icons) for _ in detections] + + icon_annotator = sv.IconAnnotator() + annotated_frame = icon_annotator.annotate( + scene=image.copy(), + detections=detections, + icon_path=icon_paths + ) + ``` + + ![icon-annotator-example](https://media.roboflow.com/ + supervision-annotator-examples/icon-annotator-example.png) + """ + if not isinstance(scene, np.ndarray): + return scene + if isinstance(icon_path, list) and len(icon_path) != len(detections): + raise ValueError( + f"The number of icon paths provided ({len(icon_path)}) does not match " + f"the number of detections ({len(detections)}). Either provide a single" + f" icon path or one for each detection." + ) + + xy: npt.NDArray[np.int32] = detections.get_anchors_coordinates( + anchor=self.position + ).astype(int) + + for detection_idx in range(len(detections)): + current_path = ( + icon_path if isinstance(icon_path, str) else icon_path[detection_idx] + ) + if current_path == "": + continue + icon = self._load_icon(current_path) + icon_h, icon_w = icon.shape[:2] + + x = int(xy[detection_idx, 0] - icon_w / 2 + self.offset_xy[0]) + y = int(xy[detection_idx, 1] - icon_h / 2 + self.offset_xy[1]) + + scene[:] = _overlay_image(scene, icon, (x, y)) + return scene + + def _load_icon(self, icon_path: str) -> npt.NDArray[np.uint8]: + """Load an icon through the module-level cache shared by annotators.""" + return _load_icon_from_path( + icon_path=icon_path, icon_resolution_wh=self.icon_resolution_wh + ) + + +class BlurAnnotator(BaseAnnotator): + """ + A class for blurring regions in an image using provided detections. + """ + + def __init__(self, kernel_size: int | None = None): + """ + Args: + kernel_size: The size of the average pooling kernel used for blurring. + If not set, a dynamic size is computed as one-third of the shorter + bounding-box dimension. Must be >= 1 when provided. + """ + if kernel_size is not None and kernel_size < 1: + raise ValueError(f"kernel_size must be >= 1, got {kernel_size}.") + self.kernel_size: int | None = kernel_size + + @ensure_cv2_image_for_class_method + def annotate( + self, + scene: ImageType, + detections: Detections, + ) -> ImageType: + """ + Annotates the given scene by blurring regions based on the provided detections. + + Args: + scene: The image where blurring will be applied. + `ImageType` is a flexible type, accepting either `numpy.ndarray` + or `PIL.Image.Image`. + detections: Object detections to annotate. + + Returns: + The annotated image, matching the type of `scene` (`numpy.ndarray` + or `PIL.Image.Image`) + + Examples: + ```pycon + >>> import numpy as np + >>> import supervision as sv + >>> image = np.zeros((100, 100, 3), dtype=np.uint8) + >>> detections = sv.Detections( + ... xyxy=np.array([[20, 20, 80, 80]]), + ... class_id=np.array([0]) + ... ) + >>> blur_annotator = sv.BlurAnnotator() + >>> annotated_frame = blur_annotator.annotate( + ... scene=image.copy(), + ... detections=detections + ... ) + + ``` + + ![blur-annotator-example](https://media.roboflow.com/ + supervision-annotator-examples/blur-annotator-example-purple.png) + """ + if not isinstance(scene, np.ndarray): + return scene + image_height, image_width = scene.shape[:2] + clipped_xyxy: npt.NDArray[np.int32] = clip_boxes( + xyxy=detections.xyxy, + resolution_wh=(image_width, image_height), + ).astype(int) + + for x1, y1, x2, y2 in clipped_xyxy: + if x2 <= x1 or y2 <= y1: + continue + roi = scene[y1:y2, x1:x2] + kernel_size = ( + self.kernel_size + if self.kernel_size is not None + else calculate_dynamic_kernel_size(x1, y1, x2, y2) + ) + roi = cast(npt.NDArray[np.uint8], cv2.blur(roi, (kernel_size, kernel_size))) + scene[y1:y2, x1:x2] = roi + + return scene + + +class TraceAnnotator(BaseAnnotator): + """ + A class for drawing trace paths on an image based on detection coordinates. + + !!! warning + + This annotator uses the `sv.Detections.tracker_id`. Read + [here](/latest/trackers/) to learn how to plug + tracking into your inference pipeline. + """ + + def __init__( + self, + color: Color | ColorPalette | str = ColorPalette.DEFAULT, + position: Position = Position.CENTER, + trace_length: int = 30, + thickness: int = 2, + smooth: bool = False, + color_lookup: ColorLookup = ColorLookup.CLASS, + ): + """ + Args: + color: The color to draw the trace, can be + a single color or a color palette. + position: The position of the trace. + Defaults to `CENTER`. + trace_length: The maximum length of the trace in terms of historical + points. Defaults to `30`. + thickness: The thickness of the trace lines. Defaults to `2`. + smooth: If `True`, applies spline smoothing to trace lines using + consecutive unique anchor points. Falls back to a raw polyline + when fewer than 4 unique points are available (e.g. when a + tracker is stationary). + color_lookup: Strategy for mapping colors to annotations. + Options are `INDEX`, `CLASS`, `TRACK`. + """ + self.color: Color | ColorPalette = _normalize_color_input(color) + self.trace = Trace(max_size=trace_length, anchor=position) + self.thickness = thickness + self.smooth = smooth + self.color_lookup: ColorLookup = color_lookup + + def reset(self) -> None: + """ + Clears the accumulated trace history so the annotator can be reused + across independent streams without carrying over points from a + previous stream. + + Examples: + ```pycon + >>> import numpy as np + >>> import supervision as sv + >>> image = np.zeros((20, 20, 3), dtype=np.uint8) + >>> detections = sv.Detections( + ... xyxy=np.array([[1, 1, 10, 10]]), + ... class_id=np.array([0]), + ... tracker_id=np.array([1]) + ... ) + >>> trace_annotator = sv.TraceAnnotator() + >>> _ = trace_annotator.annotate(scene=image.copy(), detections=detections) + >>> trace_annotator.trace.xy.shape + (1, 2) + >>> trace_annotator.reset() + >>> trace_annotator.trace.current_frame_id + 0 + >>> trace_annotator.trace.xy.shape + (0, 2) + + ``` + """ + self.trace.reset() + + @ensure_cv2_image_for_class_method + def annotate( + self, + scene: ImageType, + detections: Detections, + custom_color_lookup: npt.NDArray[np.int_] | None = None, + ) -> ImageType: + """ + Draws trace paths on the frame based on the detection coordinates provided. + + Args: + scene: The image on which the traces will be drawn. + `ImageType` is a flexible type, accepting either `numpy.ndarray` + or `PIL.Image.Image`. + detections: The detections which include coordinates for + which the traces will be drawn. + custom_color_lookup: Custom color lookup array. + Allows to override the default color mapping strategy. + + Returns: + The annotated image, matching the type of `scene` (`numpy.ndarray` + or `PIL.Image.Image`) + + Example: + ```python + import supervision as sv + from ultralytics import YOLO + + model = YOLO('yolov8x.pt') + trace_annotator = sv.TraceAnnotator() + + video_info = sv.VideoInfo.from_video_path(video_path='...') + frames_generator = sv.get_video_frames_generator(source_path='...') + tracker = sv.ByteTrack() + + with sv.VideoSink(target_path='...', video_info=video_info) as sink: + for frame in frames_generator: + result = model(frame)[0] + detections = sv.Detections.from_ultralytics(result) + detections = tracker.update_with_detections(detections) + annotated_frame = trace_annotator.annotate( + scene=frame.copy(), + detections=detections) + sink.write_frame(frame=annotated_frame) + ``` + + ![trace-annotator-example](https://media.roboflow.com/ + supervision-annotator-examples/trace-annotator-example-purple.png) + """ + if not isinstance(scene, np.ndarray): + return scene + if detections.tracker_id is None: + raise ValueError( + "The `tracker_id` field is missing in the provided detections." + " See more: https://supervision.roboflow.com/latest/how_to/track_objects" + ) + filtered_detections: Detections = detections[ + detections.tracker_id != PENDING_TRACK_ID + ] # type: ignore + + self.trace.put(filtered_detections) + for detection_idx in range(len(filtered_detections)): + tracker_id_val = filtered_detections.tracker_id[detection_idx] # type: ignore + if tracker_id_val is None: + continue + tracker_id = int(tracker_id_val) + color = resolve_color( + color=self.color, + detections=filtered_detections, + detection_idx=detection_idx, + color_lookup=self.color_lookup + if custom_color_lookup is None + else custom_color_lookup, + ) + xy = self.trace.get(tracker_id=tracker_id) + spline_points: npt.NDArray[np.int32] = xy.astype(np.int32) + + if self.smooth: + unique_xy = xy[ + np.concatenate(([True], np.any(np.diff(xy, axis=0) != 0, axis=1))) + ] + if len(unique_xy) > 3: + try: + x, y = unique_xy[:, 0], unique_xy[:, 1] + tck, _u = splprep([x, y], s=20) + x_new, y_new = splev( + np.linspace(0, 1, 100), + cast( + tuple[ + npt.NDArray[np.float64], + npt.NDArray[np.float64], + int, + ], + tck, + ), + ) + spline_points = np.stack((x_new, y_new), axis=1).astype( + np.int32 + ) + except ValueError: + spline_points = unique_xy.astype(np.int32) + else: + spline_points = unique_xy.astype(np.int32) + + if len(xy) > 1: + cv2.polylines( + scene, + [spline_points], + False, + color=color.as_bgr(), + thickness=self.thickness, + ) + return scene + + +class HeatMapAnnotator(BaseAnnotator): + """ + A class for drawing heatmaps on an image based on provided detections. + Heat accumulates over time and is drawn as a semi-transparent overlay + of blurred circles. + """ + + def __init__( + self, + position: Position = Position.BOTTOM_CENTER, + opacity: float = 0.2, + radius: int = 40, + kernel_size: int | None = 25, + top_hue: int = 0, + low_hue: int = 125, + ): + """ + Args: + position: The position of the heatmap. Defaults to + `BOTTOM_CENTER`. + opacity: Opacity of the overlay mask. Must be between `0` and `1`. + radius: Radius of the heat circle. + kernel_size: Kernel size for blurring the heatmap. Pass `None` + to disable blurring entirely. + top_hue: Hue at the top of the heatmap. Defaults to 0 (red). + low_hue: Hue at the bottom of the heatmap. Defaults to 125 (blue). + """ + self.position = position + self.opacity = opacity + self.radius = radius + self.kernel_size = kernel_size + self.top_hue = top_hue + self.low_hue = low_hue + self.heat_mask: npt.NDArray[np.float32] | None = None + + def reset(self) -> None: + """ + Clears the accumulated heat so the annotator can be reused across + independent streams. `annotate` already reinitializes the heat mask + when the scene resolution changes; call this to discard heat from a + previous stream that shares the same resolution. + + Examples: + ```pycon + >>> import numpy as np + >>> import supervision as sv + >>> image = np.zeros((40, 40, 3), dtype=np.uint8) + >>> detections = sv.Detections(xyxy=np.array([[10, 10, 20, 20]])) + >>> heat_map_annotator = sv.HeatMapAnnotator() + >>> _ = heat_map_annotator.annotate( + ... scene=image.copy(), + ... detections=detections + ... ) + >>> bool(heat_map_annotator.heat_mask.sum() > 0) + True + >>> heat_map_annotator.reset() + >>> heat_map_annotator.heat_mask is None + True + + ``` + """ + self.heat_mask = None + + @ensure_cv2_image_for_class_method + def annotate(self, scene: ImageType, detections: Detections) -> ImageType: + """ + Annotates the scene with a heatmap based on the provided detections. + + Args: + scene: The image where the heatmap will be drawn. + `ImageType` is a flexible type, accepting either `numpy.ndarray` + or `PIL.Image.Image`. + detections: Object detections to annotate. + + Returns: + The annotated image, matching the type of `scene` (`numpy.ndarray` + or `PIL.Image.Image`) + + Note: + When `detections` is empty or no heat has accumulated yet, the + scene is returned unchanged without raising a ``RuntimeWarning``. + + Example: + ```python + import supervision as sv + from ultralytics import YOLO + + model = YOLO('yolov8x.pt') + + heat_map_annotator = sv.HeatMapAnnotator() + + video_info = sv.VideoInfo.from_video_path(video_path='...') + frames_generator = sv.get_video_frames_generator(source_path='...') + + with sv.VideoSink(target_path='...', video_info=video_info) as sink: + for frame in frames_generator: + result = model(frame)[0] + detections = sv.Detections.from_ultralytics(result) + annotated_frame = heat_map_annotator.annotate( + scene=frame.copy(), + detections=detections) + sink.write_frame(frame=annotated_frame) + ``` + + ![heatmap-annotator-example](https://media.roboflow.com/ + supervision-annotator-examples/heat-map-annotator-example-purple.png) + """ + if not isinstance(scene, np.ndarray): + return scene + if self.heat_mask is None or self.heat_mask.shape != scene.shape[:2]: + self.heat_mask = np.zeros(scene.shape[:2], dtype=np.float32) + + mask: npt.NDArray[np.float32] = np.zeros(scene.shape[:2], dtype=np.float32) + for xy in detections.get_anchors_coordinates(self.position): + x, y = int(xy[0]), int(xy[1]) + cv2.circle( + img=mask, + center=(x, y), + radius=self.radius, + color=(1,), + thickness=-1, # fill + ) + self.heat_mask = mask + self.heat_mask + heat_mask = self.heat_mask + heat_values = heat_mask.copy() + max_val = heat_values.max() + if max_val > 0: + heat_values = self.low_hue - heat_values / max_val * ( + self.low_hue - self.top_hue + ) + heat_hue = heat_values.astype(np.uint8) + if self.kernel_size is not None: + heat_hue = cast( + npt.NDArray[np.uint8], + cv2.blur(heat_hue, (self.kernel_size, self.kernel_size)), + ) + hsv = np.full(scene.shape, 255, dtype=np.uint8) + hsv[..., 0] = heat_hue + heat_bgr = cv2.cvtColor(hsv, cv2.COLOR_HSV2BGR) + mask2d = heat_mask > 0 + blended = cv2.addWeighted(heat_bgr, self.opacity, scene, 1 - self.opacity, 0) + scene[mask2d] = blended[mask2d] + return scene + + +class PixelateAnnotator(BaseAnnotator): + """ + A class for pixelating regions in an image using provided detections. + """ + + def __init__(self, pixel_size: int | None = None): + """ + Args: + pixel_size: The size of the pixelation. If not set, a dynamic size is + computed as one-half of the shorter bounding-box dimension. When set + and the detection area is smaller than `pixel_size`, the region is + filled with its average colour instead to avoid an OpenCV crash. + Must be >= 1 when provided. + """ + if pixel_size is not None and pixel_size < 1: + raise ValueError(f"pixel_size must be >= 1, got {pixel_size}.") + self.pixel_size: int | None = pixel_size + + @ensure_cv2_image_for_class_method + def annotate( + self, + scene: ImageType, + detections: Detections, + ) -> ImageType: + """ + Annotates the given scene by pixelating regions based on the provided + detections. + + Args: + scene: The image where pixelating will be applied. + `ImageType` is a flexible type, accepting either `numpy.ndarray` + or `PIL.Image.Image`. + detections: Object detections to annotate. + + Returns: + The annotated image, matching the type of `scene` (`numpy.ndarray` + or `PIL.Image.Image`) + + Example: + ```python + import supervision as sv + + image = ... + detections = sv.Detections(...) + + pixelate_annotator = sv.PixelateAnnotator() + annotated_frame = pixelate_annotator.annotate( + scene=image.copy(), + detections=detections + ) + ``` + + ![pixelate-annotator-example](https://media.roboflow.com/ + supervision-annotator-examples/pixelate-annotator-example-10.png) + """ + if not isinstance(scene, np.ndarray): + return scene + image_height, image_width = scene.shape[:2] + clipped_xyxy: npt.NDArray[np.int32] = clip_boxes( + xyxy=detections.xyxy, + resolution_wh=(image_width, image_height), + ).astype(int) + + for x1, y1, x2, y2 in clipped_xyxy: + if x2 <= x1 or y2 <= y1: + continue + roi = scene[y1:y2, x1:x2] + + pixel_size = ( + self.pixel_size + if self.pixel_size is not None + else calculate_dynamic_pixel_size(x1, y1, x2, y2) + ) + if min(y2 - y1, x2 - x1) < pixel_size: + if roi.ndim == 2 or (roi.ndim == 3 and roi.shape[2] == 1): + scene[y1:y2, x1:x2] = cv2.mean(roi)[0] + else: + num_channels = scene.shape[2] + scene[y1:y2, x1:x2] = cv2.mean(roi)[:num_channels] + continue + + scaled_up_roi = cv2.resize( + src=roi, dsize=None, fx=1 / pixel_size, fy=1 / pixel_size + ) + scaled_down_roi = cv2.resize( + src=scaled_up_roi, + dsize=(roi.shape[1], roi.shape[0]), + interpolation=cv2.INTER_NEAREST, + ) + + scene[y1:y2, x1:x2] = scaled_down_roi + + return scene + + +class TriangleAnnotator(BaseAnnotator): + """ + A class for drawing triangle markers on an image at specific coordinates based on + provided detections. + """ + + def __init__( + self, + color: Color | ColorPalette | str = ColorPalette.DEFAULT, + base: int = 10, + height: int = 10, + position: Position = Position.TOP_CENTER, + color_lookup: ColorLookup = ColorLookup.CLASS, + outline_thickness: int = 0, + outline_color: Color | ColorPalette | str = Color.BLACK, + ): + """ + Args: + color: The color or color palette to use for + annotating detections. + base: The base width of the triangle. + height: The height of the triangle. + position: The anchor position for placing the triangle. + color_lookup: Strategy for mapping colors to annotations. + Options are `INDEX`, `CLASS`, `TRACK`. + outline_thickness: Thickness of the outline of the triangle. + outline_color: The color or color palette to + use for outline. It is activated by setting outline_thickness to a value + greater than 0. + """ + self.color: Color | ColorPalette = _normalize_color_input(color) + self.base: int = base + self.height: int = height + self.position: Position = position + self.color_lookup: ColorLookup = color_lookup + self.outline_thickness: int = outline_thickness + self.outline_color: Color | ColorPalette = _normalize_color_input(outline_color) + + @ensure_cv2_image_for_class_method + def annotate( + self, + scene: ImageType, + detections: Detections, + custom_color_lookup: npt.NDArray[np.int_] | None = None, + ) -> ImageType: + """ + Annotates the given scene with triangles based on the provided detections. + + Args: + scene: The image where triangles will be drawn. + `ImageType` is a flexible type, accepting either `numpy.ndarray` + or `PIL.Image.Image`. + detections: Object detections to annotate. + custom_color_lookup: Custom color lookup array. + Allows to override the default color mapping strategy. + + Returns: + The annotated image, matching the type of `scene` (`numpy.ndarray` + or `PIL.Image.Image`) + + Examples: + ```pycon + >>> import numpy as np + >>> import supervision as sv + >>> image = np.zeros((100, 100, 3), dtype=np.uint8) + >>> detections = sv.Detections( + ... xyxy=np.array([[20, 20, 80, 80]]), + ... class_id=np.array([0]) + ... ) + >>> triangle_annotator = sv.TriangleAnnotator() + >>> annotated_frame = triangle_annotator.annotate( + ... scene=image.copy(), + ... detections=detections + ... ) + + ``` + + ![triangle-annotator-example](https://media.roboflow.com/ + supervision-annotator-examples/triangle-annotator-example.png) + """ + if not isinstance(scene, np.ndarray): + return scene + xy = detections.get_anchors_coordinates(anchor=self.position) + for detection_idx in range(len(detections)): + color = resolve_color( + color=self.color, + detections=detections, + detection_idx=detection_idx, + color_lookup=self.color_lookup + if custom_color_lookup is None + else custom_color_lookup, + ) + tip_x, tip_y = int(xy[detection_idx, 0]), int(xy[detection_idx, 1]) + vertices = np.array( + [ + [tip_x - self.base // 2, tip_y - self.height], + [tip_x + self.base // 2, tip_y - self.height], + [tip_x, tip_y], + ], + np.int32, + ) + + cv2.fillPoly(scene, [vertices], color.as_bgr()) + if self.outline_thickness: + outline_color = resolve_color( + color=self.outline_color, + detections=detections, + detection_idx=detection_idx, + color_lookup=self.color_lookup + if custom_color_lookup is None + else custom_color_lookup, + ) + cv2.polylines( + scene, + [vertices], + True, + outline_color.as_bgr(), + thickness=self.outline_thickness, + ) + return scene + + +class RoundBoxAnnotator(BaseAnnotator): + """ + A class for drawing bounding boxes with round edges on an image + using provided detections. + """ + + def __init__( + self, + color: Color | ColorPalette | str = ColorPalette.DEFAULT, + thickness: int = 2, + color_lookup: ColorLookup = ColorLookup.CLASS, + roundness: float = 0.6, + ): + """ + Args: + color: The color or color palette to use for + annotating detections. + thickness: Thickness of the bounding box lines. + color_lookup: Strategy for mapping colors to annotations. + Options are `INDEX`, `CLASS`, `TRACK`. + roundness: Percent of roundness for edges of bounding box. + Value must be float 0 < roundness <= 1.0 + By default roundness percent is calculated based on smaller side + length (width or height). + """ + self.color: Color | ColorPalette = _normalize_color_input(color) + self.thickness: int = thickness + self.color_lookup: ColorLookup = color_lookup + if not 0 < roundness <= 1.0: + raise ValueError("roundness attribute must be float between (0, 1.0]") + self.roundness: float = roundness + + @ensure_cv2_image_for_class_method + def annotate( + self, + scene: ImageType, + detections: Detections, + custom_color_lookup: npt.NDArray[np.int_] | None = None, + ) -> ImageType: + """ + Annotates the given scene with bounding boxes with rounded edges + based on the provided detections. + + Args: + scene: The image where rounded bounding boxes will be drawn. + `ImageType` is a flexible type, accepting either `numpy.ndarray` + or `PIL.Image.Image`. + detections: Object detections to annotate. + custom_color_lookup: Custom color lookup array. + Allows to override the default color mapping strategy. + + Returns: + The annotated image, matching the type of `scene` (`numpy.ndarray` + or `PIL.Image.Image`) + + Examples: + ```pycon + >>> import numpy as np + >>> import supervision as sv + >>> image = np.zeros((100, 100, 3), dtype=np.uint8) + >>> detections = sv.Detections( + ... xyxy=np.array([[20, 20, 80, 80]]), + ... class_id=np.array([0]) + ... ) + >>> round_box_annotator = sv.RoundBoxAnnotator() + >>> annotated_frame = round_box_annotator.annotate( + ... scene=image.copy(), + ... detections=detections + ... ) + + ``` + + ![round-box-annotator-example](https://media.roboflow.com/ + supervision-annotator-examples/round-box-annotator-example-purple.png) + """ + if not isinstance(scene, np.ndarray): + return scene + for detection_idx in range(len(detections)): + x1, y1, x2, y2 = detections.xyxy[detection_idx].astype(int) + color = resolve_color( + color=self.color, + detections=detections, + detection_idx=detection_idx, + color_lookup=self.color_lookup + if custom_color_lookup is None + else custom_color_lookup, + ) + + radius = ( + int((x2 - x1) // 2 * self.roundness) + if abs(x1 - x2) < abs(y1 - y2) + else int((y2 - y1) // 2 * self.roundness) + ) + + circle_coordinates = [ + ((x1 + radius), (y1 + radius)), + ((x2 - radius), (y1 + radius)), + ((x2 - radius), (y2 - radius)), + ((x1 + radius), (y2 - radius)), + ] + + line_coordinates = [ + ((x1 + radius, y1), (x2 - radius, y1)), + ((x2, y1 + radius), (x2, y2 - radius)), + ((x1 + radius, y2), (x2 - radius, y2)), + ((x1, y1 + radius), (x1, y2 - radius)), + ] + + start_angles = (180, 270, 0, 90) + end_angles = (270, 360, 90, 180) + + for center_coordinates, line, start_angle, end_angle in zip( + circle_coordinates, line_coordinates, start_angles, end_angles + ): + cv2.ellipse( + img=scene, + center=center_coordinates, + axes=(radius, radius), + angle=0, + startAngle=start_angle, + endAngle=end_angle, + color=color.as_bgr(), + thickness=self.thickness, + ) + + cv2.line( + img=scene, + pt1=line[0], + pt2=line[1], + color=color.as_bgr(), + thickness=self.thickness, + ) + + return scene + + +class PercentageBarAnnotator(BaseAnnotator): + """ + A class for drawing percentage bars on an image using provided detections. + """ + + def __init__( + self, + height: int = 16, + width: int = 80, + color: Color | ColorPalette | str = ColorPalette.DEFAULT, + border_color: Color | str = Color.BLACK, + position: Position = Position.TOP_CENTER, + color_lookup: ColorLookup = ColorLookup.CLASS, + border_thickness: int | None = None, + ): + """ + Args: + height: The height in pixels of the percentage bar. + width: The width in pixels of the percentage bar. + color: The color or color palette to use for + annotating detections. + border_color: The color of the border lines. + position: The anchor position of drawing the percentage bar. + color_lookup: Strategy for mapping colors to annotations. + Options are `INDEX`, `CLASS`, `TRACK`. + border_thickness: The thickness of the border lines. + """ + self.height: int = height + self.width: int = width + self.color: Color | ColorPalette = _normalize_color_input(color) + self.border_color = cast(Color, _normalize_color_input(border_color)) + self.position: Position = position + self.color_lookup: ColorLookup = color_lookup + + self.border_thickness = ( + border_thickness + if border_thickness is not None + else int(0.15 * self.height) + ) + + @ensure_cv2_image_for_class_method + def annotate( + self, + scene: ImageType, + detections: Detections, + custom_color_lookup: npt.NDArray[np.int_] | None = None, + custom_values: npt.NDArray[np.float64] | None = None, + ) -> ImageType: + """ + Annotates the given scene with percentage bars based on the provided + detections. The percentage bars visually represent the confidence or custom + values associated with each detection. + + Args: + scene: The image where percentage bars will be drawn. + `ImageType` is a flexible type, accepting either `numpy.ndarray` + or `PIL.Image.Image`. + detections: Object detections to annotate. + custom_color_lookup: Custom color lookup array. + Allows to override the default color mapping strategy. + custom_values: Custom values array to use instead + of the default detection confidences. This array should have the + same length as the number of detections and contain a value between + 0 and 1 (inclusive) for each detection, representing the percentage + to be displayed. + + Returns: + The annotated image, matching the type of `scene` (`numpy.ndarray` + or `PIL.Image.Image`) + + Examples: + ```pycon + >>> import numpy as np + >>> import supervision as sv + >>> image = np.zeros((100, 100, 3), dtype=np.uint8) + >>> detections = sv.Detections( + ... xyxy=np.array([[20, 20, 80, 80]]), + ... confidence=np.array([0.9]), + ... class_id=np.array([0]) + ... ) + >>> percentage_bar_annotator = sv.PercentageBarAnnotator() + >>> annotated_frame = percentage_bar_annotator.annotate( + ... scene=image.copy(), + ... detections=detections + ... ) + + ``` + + ![percentage-bar-example](https://media.roboflow.com/ + supervision-annotator-examples/percentage-bar-annotator-example-purple.png) + """ + if not isinstance(scene, np.ndarray): + return scene + self._validate_custom_values(custom_values=custom_values, detections=detections) + + anchors = detections.get_anchors_coordinates(anchor=self.position) + for detection_idx in range(len(detections)): + anchor = anchors[detection_idx] + border_coordinates = self.calculate_border_coordinates( + anchor_xy=(int(anchor[0]), int(anchor[1])), + border_wh=(self.width, self.height), + position=self.position, + ) + border_width = border_coordinates[1][0] - border_coordinates[0][0] + + if custom_values is not None: + value = custom_values[detection_idx] + else: + assert detections.confidence is not None # MyPy type hint + value = detections.confidence[detection_idx] + + color = resolve_color( + color=self.color, + detections=detections, + detection_idx=detection_idx, + color_lookup=self.color_lookup + if custom_color_lookup is None + else custom_color_lookup, + ) + cv2.rectangle( + img=scene, + pt1=border_coordinates[0], + pt2=( + border_coordinates[0][0] + int(border_width * value), + border_coordinates[1][1], + ), + color=color.as_bgr(), + thickness=-1, + ) + cv2.rectangle( + img=scene, + pt1=border_coordinates[0], + pt2=border_coordinates[1], + color=self.border_color.as_bgr(), + thickness=self.border_thickness, + ) + return scene + + @staticmethod + def calculate_border_coordinates( + anchor_xy: tuple[int, int], border_wh: tuple[int, int], position: Position + ) -> tuple[tuple[int, int], tuple[int, int]]: + """Compute the border corner coordinates for a given anchor position.""" + cx, cy = anchor_xy + width, height = border_wh + + if position == Position.TOP_LEFT: + return (cx - width, cy - height), (cx, cy) + elif position == Position.TOP_CENTER: + return (cx - width // 2, cy), (cx + width // 2, cy - height) + elif position == Position.TOP_RIGHT: + return (cx, cy), (cx + width, cy - height) + elif position == Position.CENTER_LEFT: + return (cx - width, cy - height // 2), (cx, cy + height // 2) + elif position == Position.CENTER or position == Position.CENTER_OF_MASS: + return ( + (cx - width // 2, cy - height // 2), + (cx + width // 2, cy + height // 2), + ) + elif position == Position.CENTER_RIGHT: + return (cx, cy - height // 2), (cx + width, cy + height // 2) + elif position == Position.BOTTOM_LEFT: + return (cx - width, cy), (cx, cy + height) + elif position == Position.BOTTOM_CENTER: + return (cx - width // 2, cy), (cx + width // 2, cy + height) + elif position == Position.BOTTOM_RIGHT: + return (cx, cy), (cx + width, cy + height) + raise ValueError(f"Unsupported position: {position}") + + @staticmethod + def _validate_custom_values( + custom_values: npt.NDArray[np.float64] | list[float] | None, + detections: Detections, + ) -> None: + if custom_values is None: + if detections.confidence is None: + raise ValueError( + "The provided detections do not contain confidence values. " + "Please provide `custom_values` or ensure that the detections " + "contain confidence values (e.g. by using a different model)." + ) + + else: + if not isinstance(custom_values, (np.ndarray, list)): + raise TypeError( + "custom_values must be either a numpy array or a list of floats." + ) + + if len(custom_values) != len(detections): + raise ValueError( + "The length of custom_values must match the number of detections." + ) + + if not all(0 <= value <= 1 for value in custom_values): + raise ValueError("All values in custom_values must be between 0 and 1.") + + @staticmethod + @deprecated( # type: ignore[untyped-decorator] + target=_validate_custom_values.__func__, # type: ignore[attr-defined] + deprecated_in="0.29.0", + remove_in="0.32.0", + ) + def validate_custom_values( + custom_values: npt.NDArray[np.float64] | list[float] | None, + detections: Detections, + ) -> None: + void(custom_values, detections) + + +class CropAnnotator(BaseAnnotator): + """ + A class for drawing scaled up crops of detections on the scene. + """ + + def __init__( + self, + position: Position = Position.TOP_CENTER, + scale_factor: float = 2.0, + border_color: Color | ColorPalette | str = ColorPalette.DEFAULT, + border_thickness: int = 2, + border_color_lookup: ColorLookup = ColorLookup.CLASS, + ): + """ + Args: + position: The anchor position for placing the cropped and scaled + part of the detection in the scene. + scale_factor: The factor by which to scale the cropped image part. A + factor of 2, for example, would double the size of the cropped area, + allowing for a closer view of the detection. + border_color: The color or color palette to + use for annotating border around the cropped area. + border_thickness: The thickness of the border around the cropped area. + border_color_lookup: Strategy for mapping colors to + annotations. Options are `INDEX`, `CLASS`, `TRACK`. + """ + self.position: Position = position + self.scale_factor: float = scale_factor + self.border_color: Color | ColorPalette = _normalize_color_input(border_color) + self.border_thickness: int = border_thickness + self.border_color_lookup: ColorLookup = border_color_lookup + + @ensure_cv2_image_for_class_method + def annotate( + self, + scene: ImageType, + detections: Detections, + custom_color_lookup: npt.NDArray[np.int_] | None = None, + ) -> ImageType: + """ + Annotates the provided scene with scaled and cropped parts of the image based + on the provided detections. Each detection is cropped from the original scene + and scaled according to the annotator's scale factor before being placed back + onto the scene at the specified position. + + + Args: + scene: The image where cropped detection will be placed. + `ImageType` is a flexible type, accepting either `numpy.ndarray` + or `PIL.Image.Image`. + detections: Object detections to annotate. + custom_color_lookup: Custom color lookup array. + Allows to override the default color mapping strategy. + + Returns: + The annotated image. + + Note: + Detections whose bounding boxes extend partially outside `scene` are + clipped to scene bounds before cropping. Detections fully outside the + scene collapse to zero area after clipping and are skipped without + raising an error. + + Examples: + ```pycon + >>> import numpy as np + >>> import supervision as sv + >>> image = np.zeros((100, 100, 3), dtype=np.uint8) + >>> detections = sv.Detections( + ... xyxy=np.array([[20, 20, 80, 80]]), + ... class_id=np.array([0]) + ... ) + >>> crop_annotator = sv.CropAnnotator() + >>> annotated_frame = crop_annotator.annotate( + ... scene=image.copy(), + ... detections=detections + ... ) + + ``` + + ![crop-annotator-example](https://media.roboflow.com/ + supervision-annotator-examples/crop-annotator-example.png) + """ + if not isinstance(scene, np.ndarray): + return scene + image_height, image_width = scene.shape[:2] + clipped_xyxy: npt.NDArray[np.int32] = clip_boxes( + xyxy=detections.xyxy, + resolution_wh=(image_width, image_height), + ).astype(np.int32) + anchors: npt.NDArray[np.int32] = detections.get_anchors_coordinates( + anchor=self.position + ).astype(np.int32) + # Snapshot before the loop so later crops are taken from the original image, + # not a scene already annotated by earlier iterations (overlapping-box case). + source_scene = scene.copy() + + for idx, (xyxy, anchor) in enumerate(zip(clipped_xyxy, anchors)): + crop_x1, crop_y1, crop_x2, crop_y2 = xyxy + if crop_x2 <= crop_x1 or crop_y2 <= crop_y1: + continue + crop = crop_image(image=source_scene, xyxy=xyxy) + resized_crop = scale_image(image=crop, scale_factor=self.scale_factor) + crop_wh = resized_crop.shape[1], resized_crop.shape[0] + (x1, y1), (x2, y2) = self.calculate_crop_coordinates( + anchor=anchor, crop_wh=crop_wh, position=self.position + ) + scene = _overlay_image(image=scene, overlay=resized_crop, anchor=(x1, y1)) + color = resolve_color( + color=self.border_color, + detections=detections, + detection_idx=idx, + color_lookup=self.border_color_lookup + if custom_color_lookup is None + else custom_color_lookup, + ) + cv2.rectangle( + img=scene, + pt1=(x1, y1), + pt2=(x2, y2), + color=color.as_bgr(), + thickness=self.border_thickness, + ) + + return scene + + @staticmethod + def calculate_crop_coordinates( + anchor: tuple[int, int], crop_wh: tuple[int, int], position: Position + ) -> tuple[tuple[int, int], tuple[int, int]]: + """Compute the crop coordinates for a given anchor position.""" + anchor_x, anchor_y = anchor + width, height = crop_wh + + if position == Position.TOP_LEFT: + return (anchor_x - width, anchor_y - height), (anchor_x, anchor_y) + elif position == Position.TOP_CENTER: + return ( + (anchor_x - width // 2, anchor_y - height), + (anchor_x + width // 2, anchor_y), + ) + elif position == Position.TOP_RIGHT: + return (anchor_x, anchor_y - height), (anchor_x + width, anchor_y) + elif position == Position.CENTER_LEFT: + return ( + (anchor_x - width, anchor_y - height // 2), + (anchor_x, anchor_y + height // 2), + ) + elif position == Position.CENTER or position == Position.CENTER_OF_MASS: + return ( + (anchor_x - width // 2, anchor_y - height // 2), + (anchor_x + width // 2, anchor_y + height // 2), + ) + elif position == Position.CENTER_RIGHT: + return ( + (anchor_x, anchor_y - height // 2), + (anchor_x + width, anchor_y + height // 2), + ) + elif position == Position.BOTTOM_LEFT: + return (anchor_x - width, anchor_y), (anchor_x, anchor_y + height) + elif position == Position.BOTTOM_CENTER: + return ( + (anchor_x - width // 2, anchor_y), + (anchor_x + width // 2, anchor_y + height), + ) + elif position == Position.BOTTOM_RIGHT: + return (anchor_x, anchor_y), (anchor_x + width, anchor_y + height) + raise ValueError(f"Unsupported position: {position}") + + +class BackgroundOverlayAnnotator(BaseAnnotator): + """ + A class for drawing a colored overlay on the background of an image outside + the region of detections. + + If masks are provided, the background is colored outside the masks. + If masks are not provided, the background is colored outside the bounding boxes. + + You can use the `force_box` parameter to force the annotator to use bounding boxes. + + !!! warning + + This annotator uses `sv.Detections.mask`. + """ + + def __init__( + self, + color: Color = Color.BLACK, + opacity: float = 0.5, + force_box: bool = False, + ): + """ + Args: + color: The color to use for annotating detections. + opacity: Opacity of the overlay mask. Must be between `0` and `1`. + force_box: If `True`, forces the annotator to use bounding boxes when + masks are provided in the supplied sv.Detections. + """ + self.color: Color = color + self.opacity = opacity + self.force_box = force_box + + @ensure_cv2_image_for_class_method + def annotate(self, scene: ImageType, detections: Detections) -> ImageType: + """ + Applies a colored overlay to the scene outside of the detected regions. + + Args: + scene: The image where masks will be drawn. + `ImageType` is a flexible type, accepting either `numpy.ndarray` + or `PIL.Image.Image`. + detections: Object detections to annotate. + + Returns: + The annotated image, matching the type of `scene` (`numpy.ndarray` + or `PIL.Image.Image`) + + Examples: + ```pycon + >>> import numpy as np + >>> import supervision as sv + >>> image = np.zeros((100, 100, 3), dtype=np.uint8) + >>> detections = sv.Detections( + ... xyxy=np.array([[20, 20, 80, 80]]), + ... class_id=np.array([0]) + ... ) + >>> background_overlay_annotator = sv.BackgroundOverlayAnnotator() + >>> annotated_frame = background_overlay_annotator.annotate( + ... scene=image.copy(), + ... detections=detections + ... ) + + ``` + + ![background-overlay-annotator-example](https://media.roboflow.com/ + supervision-annotator-examples/background-color-annotator-example-purple.png) + """ + if not isinstance(scene, np.ndarray): + return scene + colored_mask = np.full_like(scene, self.color.as_bgr(), dtype=np.uint8) + + cv2.addWeighted( + scene, 1 - self.opacity, colored_mask, self.opacity, 0, dst=colored_mask + ) + + if detections.mask is None or self.force_box: + image_height, image_width = scene.shape[:2] + clipped_xyxy: npt.NDArray[np.int32] = clip_boxes( + xyxy=detections.xyxy, + resolution_wh=(image_width, image_height), + ).astype(np.int32) + for x1, y1, x2, y2 in clipped_xyxy: + colored_mask[y1:y2, x1:x2] = scene[y1:y2, x1:x2] + else: + for mask in detections.mask: + mask_bool = np.asarray(mask, dtype=bool) + colored_mask[mask_bool] = scene[mask_bool] + + np.copyto(scene, colored_mask) + return scene + + +class ComparisonAnnotator: + """ + Highlights the differences between two sets of detections. + Useful for comparing results from two different models, or the difference + between a ground truth and a prediction. + + If present, uses the oriented bounding box data. + Otherwise, if present, uses a mask. + Otherwise, uses the bounding box data. + """ + + # Not a BaseAnnotator subclass โ€” duck-typing callers can still check requires_mask + requires_mask: ClassVar[bool] = False + + def __init__( + self, + color_1: Color = Color.RED, + color_2: Color = Color.GREEN, + color_overlap: Color = Color.BLUE, + *, + opacity: float = 0.75, + label_1: str = "", + label_2: str = "", + label_overlap: str = "", + label_scale: float = 1.0, + ): + """ + Args: + color_1: Color of areas only present in the first set of + detections. + color_2: Color of areas only present in the second set of + detections. + color_overlap: Color of areas present in both sets of detections. + opacity: Opacity of the overlay mask. Must be between `0` and `1`. + label_1: Label for the first set of detections. + label_2: Label for the second set of detections. + label_overlap: Label for areas present in both sets of detections. + label_scale: Controls how large the labels are. + """ + + self.color_1 = color_1 + self.color_2 = color_2 + self.color_overlap = color_overlap + + self.opacity = opacity + self.label_1 = label_1 + self.label_2 = label_2 + self.label_overlap = label_overlap + self.label_scale = label_scale + self.text_thickness = int(self.label_scale + 1.2) + + @ensure_cv2_image_for_class_method + def annotate( + self, scene: ImageType, detections_1: Detections, detections_2: Detections + ) -> ImageType: + """ + Highlights the differences between two sets of detections. + + Args: + scene: The image where detections will be drawn. + `ImageType` is a flexible type, accepting either `numpy.ndarray` + or `PIL.Image.Image`. + detections_1: The first set of detections or predictions. + detections_2: The second set of detections to compare or + ground truth. + + Returns: + The annotated image. + + Example: + ```python + import supervision as sv + + image = ... + detections_1 = sv.Detections(...) + detections_2 = sv.Detections(...) + + comparison_annotator = sv.ComparisonAnnotator() + annotated_frame = comparison_annotator.annotate( + scene=image.copy(), + detections_1=detections_1, + detections_2=detections_2 + ) + ``` + + ![comparison-annotator-example](https://media.roboflow.com/ + supervision-annotator-examples/comparison-annotator-example.png) + """ + if not isinstance(scene, np.ndarray): + return scene + if detections_1.is_empty() and detections_2.is_empty(): + return scene + + use_obb = self._use_obb(detections_1, detections_2) + use_mask = self._use_mask(detections_1, detections_2) + + if use_obb: + mask_1 = self._mask_from_obb(scene, detections_1) + mask_2 = self._mask_from_obb(scene, detections_2) + + elif use_mask: + mask_1 = self._mask_from_mask(scene, detections_1) + mask_2 = self._mask_from_mask(scene, detections_2) + + else: + mask_1 = self._mask_from_xyxy(scene, detections_1) + mask_2 = self._mask_from_xyxy(scene, detections_2) + + mask_overlap = mask_1 & mask_2 + mask_1 = mask_1 & ~mask_overlap + mask_2 = mask_2 & ~mask_overlap + + color_layer = np.zeros_like(scene, dtype=np.uint8) + color_layer[mask_overlap] = self.color_overlap.as_bgr() + color_layer[mask_1] = self.color_1.as_bgr() + color_layer[mask_2] = self.color_2.as_bgr() + + scene[mask_overlap] = (1 - self.opacity) * scene[ + mask_overlap + ] + self.opacity * color_layer[mask_overlap] + scene[mask_1] = (1 - self.opacity) * scene[mask_1] + self.opacity * color_layer[ + mask_1 + ] + scene[mask_2] = (1 - self.opacity) * scene[mask_2] + self.opacity * color_layer[ + mask_2 + ] + + self._draw_labels(scene) + + return scene + + @staticmethod + def _use_obb(detections_1: Detections, detections_2: Detections) -> bool: + assert not detections_1.is_empty() or not detections_2.is_empty() + is_obb_1 = ORIENTED_BOX_COORDINATES in detections_1.data + is_obb_2 = ORIENTED_BOX_COORDINATES in detections_2.data + return ( + (is_obb_1 and is_obb_2) + or (is_obb_1 and detections_2.is_empty()) + or (detections_1.is_empty() and is_obb_2) + ) + + @staticmethod + def _use_mask(detections_1: Detections, detections_2: Detections) -> bool: + assert not detections_1.is_empty() or not detections_2.is_empty() + is_mask_1 = detections_1.mask is not None + is_mask_2 = detections_2.mask is not None + return ( + (is_mask_1 and is_mask_2) + or (is_mask_1 and detections_2.is_empty()) + or (detections_1.is_empty() and is_mask_2) + ) + + @staticmethod + def _mask_from_xyxy( + scene: npt.NDArray[np.uint8], detections: Detections + ) -> npt.NDArray[np.bool_]: + mask = np.zeros(scene.shape[:2], dtype=np.bool_) + if detections.is_empty(): + return mask + + resolution_wh = scene.shape[1], scene.shape[0] + polygons = xyxy_to_polygons(detections.xyxy) + + for polygon in polygons: + polygon_mask = polygon_to_mask(polygon, resolution_wh=resolution_wh) + mask |= polygon_mask.astype(np.bool_) + return mask + + @staticmethod + def _mask_from_obb( + scene: npt.NDArray[np.uint8], detections: Detections + ) -> npt.NDArray[np.bool_]: + mask = np.zeros(scene.shape[:2], dtype=np.bool_) + if detections.is_empty(): + return mask + + resolution_wh = scene.shape[1], scene.shape[0] + + for polygon in detections.data[ORIENTED_BOX_COORDINATES]: + polygon_mask = polygon_to_mask(polygon, resolution_wh=resolution_wh) + mask |= polygon_mask.astype(np.bool_) + return mask + + @staticmethod + def _mask_from_mask( + scene: npt.NDArray[np.uint8], detections: Detections + ) -> npt.NDArray[np.bool_]: + mask = np.zeros(scene.shape[:2], dtype=np.bool_) + if detections.is_empty(): + return mask + assert detections.mask is not None + + for detections_mask in detections.mask: + mask |= detections_mask.astype(np.bool_) + return mask + + def _draw_labels(self, scene: npt.NDArray[np.uint8]) -> None: + """ + Draw the labels, explaining what each color represents, with automatically + computed positions. + + Args: + scene: The image where the labels will be drawn. + """ + margin = int(50 * self.label_scale) + gap = int(40 * self.label_scale) + y0 = int(50 * self.label_scale) + height = int(50 * self.label_scale) + + marker_size = int(20 * self.label_scale) + padding = int(10 * self.label_scale) + text_box_corner_radius = int(10 * self.label_scale) + marker_corner_radius = int(4 * self.label_scale) + text_scale = self.label_scale + + label_color_pairs = [ + (self.label_1, self.color_1), + (self.label_2, self.color_2), + (self.label_overlap, self.color_overlap), + ] + + x0 = margin + for text, color in label_color_pairs: + if not text: + continue + + (text_w, _) = cv2.getTextSize( + text=text, + fontFace=CV2_FONT, + fontScale=self.label_scale, + thickness=self.text_thickness, + )[0] + + width = text_w + marker_size + padding * 4 + center_x = x0 + width // 2 + center_y = y0 + height // 2 + + draw_rounded_rectangle( + scene=scene, + rect=Rect(x=x0, y=y0, width=width, height=height), + color=Color.WHITE, + border_radius=text_box_corner_radius, + ) + + draw_rounded_rectangle( + scene=scene, + rect=Rect( + x=x0 + padding, + y=center_y - marker_size / 2, + width=marker_size, + height=marker_size, + ), + color=color, + border_radius=marker_corner_radius, + ) + + draw_text( + scene, + text, + text_anchor=Point(x=center_x + marker_size, y=center_y), + text_scale=text_scale, + text_thickness=self.text_thickness, + ) + + x0 += width + gap diff --git a/src/supervision/annotators/utils.py b/src/supervision/annotators/utils.py new file mode 100644 index 0000000..afb72d0 --- /dev/null +++ b/src/supervision/annotators/utils.py @@ -0,0 +1,538 @@ +import re +import textwrap +from enum import Enum +from typing import Any, cast + +import numpy as np +import numpy.typing as npt +from deprecate import deprecated, void + +from supervision.config import CLASS_NAME_DATA_FIELD +from supervision.detection.core import Detections +from supervision.draw.color import Color, ColorPalette +from supervision.geometry.core import Position + +PENDING_TRACK_COLOR = Color.GREY +PENDING_TRACK_ID = -1 + + +class ColorLookup(Enum): + """ + Enumeration class to define strategies for mapping colors to annotations. + + This enum supports three different lookup strategies: + - `INDEX`: Colors are determined by the index of the detection within the scene. + - `CLASS`: Colors are determined by the class label of the detected object. + - `TRACK`: Colors are determined by the tracking identifier of the object. + """ + + INDEX = "index" + CLASS = "class" + TRACK = "track" + + @classmethod + def list(cls) -> list[str]: + return list(map(lambda c: c.value, cls)) + + +def resolve_color_idx( + detections: Detections, + detection_idx: int, + color_lookup: ColorLookup | npt.NDArray[np.int_] = ColorLookup.CLASS, +) -> int: + if detection_idx >= len(detections): + raise ValueError( + f"Detection index {detection_idx} " + f"is out of bounds for detections of length {len(detections)}" + ) + + if isinstance(color_lookup, np.ndarray): + if len(color_lookup) != len(detections): + raise ValueError( + f"Length of color lookup {len(color_lookup)} " + f"does not match length of detections {len(detections)}" + ) + return int(color_lookup[detection_idx]) + elif color_lookup == ColorLookup.INDEX: + return detection_idx + elif color_lookup == ColorLookup.CLASS: + if detections.class_id is None: + raise ValueError( + "Could not resolve color by class because " + "Detections do not have class_id. If using an annotator, " + "try setting color_lookup to sv.ColorLookup.INDEX or " + "sv.ColorLookup.TRACK." + ) + return int(detections.class_id[detection_idx]) + elif color_lookup == ColorLookup.TRACK: + if detections.tracker_id is None: + raise ValueError( + "Could not resolve color by track because " + "Detections do not have tracker_id. Did you call " + "tracker.update_with_detections(...) before annotating?" + ) + return int(detections.tracker_id[detection_idx]) + raise ValueError(f"Unsupported color lookup strategy: {color_lookup}") + + +def resolve_text_background_xyxy( + center_coordinates: tuple[int, int], + text_wh: tuple[int, int], + position: Position, +) -> tuple[int, int, int, int]: + """Compute the background box for text anchored at `position`.""" + center_x, center_y = center_coordinates + text_w, text_h = text_wh + + if position == Position.TOP_LEFT: + return center_x, center_y - text_h, center_x + text_w, center_y + elif position == Position.TOP_RIGHT: + return center_x - text_w, center_y - text_h, center_x, center_y + elif position == Position.TOP_CENTER: + return ( + center_x - text_w // 2, + center_y - text_h, + center_x + text_w // 2, + center_y, + ) + elif position == Position.CENTER or position == Position.CENTER_OF_MASS: + return ( + center_x - text_w // 2, + center_y - text_h // 2, + center_x + text_w // 2, + center_y + text_h // 2, + ) + elif position == Position.BOTTOM_LEFT: + return center_x, center_y, center_x + text_w, center_y + text_h + elif position == Position.BOTTOM_RIGHT: + return center_x - text_w, center_y, center_x, center_y + text_h + elif position == Position.BOTTOM_CENTER: + return ( + center_x - text_w // 2, + center_y, + center_x + text_w // 2, + center_y + text_h, + ) + elif position == Position.CENTER_LEFT: + return ( + center_x - text_w, + center_y - text_h // 2, + center_x, + center_y + text_h // 2, + ) + elif position == Position.CENTER_RIGHT: + return ( + center_x, + center_y - text_h // 2, + center_x + text_w, + center_y + text_h // 2, + ) + raise ValueError(f"Unsupported position: {position}") + + +def get_color_by_index(color: Color | ColorPalette, idx: int) -> Color: + """Resolve a color-like object to a concrete `Color` for an index.""" + color_like = cast(Any, color) + # Accept ColorPalette-like objects without depending on their exact concrete class. + if callable(getattr(color_like, "by_idx", None)): + color_like = color_like.by_idx(idx) + if isinstance(color_like, Color): + return color_like + return Color( + r=int(color_like.r), + g=int(color_like.g), + b=int(color_like.b), + a=int(getattr(color_like, "a", 255)), + ) + + +def resolve_color( + color: Color | ColorPalette, + detections: Detections, + detection_idx: int, + color_lookup: ColorLookup | npt.NDArray[np.int_] = ColorLookup.CLASS, +) -> Color: + idx = resolve_color_idx( + detections=detections, + detection_idx=detection_idx, + color_lookup=color_lookup, + ) + if ( + isinstance(color_lookup, ColorLookup) + and color_lookup == ColorLookup.TRACK + and idx == PENDING_TRACK_ID + ): + return PENDING_TRACK_COLOR + return get_color_by_index(color=color, idx=idx) + + +def wrap_text(text: object, max_line_length: int | None = None) -> list[str]: + """ + Wrap `text` to the specified maximum line length, respecting existing + newlines. Falls back to str() if `text` is not already a string. + + Args: + text: The text (or object) to wrap. + max_line_length: Maximum width for each wrapped line. + + Returns: + Wrapped lines. + """ + + if not text: + return [""] + + if not isinstance(text, str): + text = str(text) + + if max_line_length is None: + return text.splitlines() or [""] + + if max_line_length <= 0: + raise ValueError("max_line_length must be a positive integer") + + paragraphs = text.split("\n") + all_lines: list[str] = [] + + for paragraph in paragraphs: + if paragraph == "": + all_lines.append("") + continue + + wrapped = textwrap.wrap( + paragraph, + width=max_line_length, + break_long_words=True, + replace_whitespace=False, + drop_whitespace=True, + ) + + all_lines.extend(wrapped or [""]) + + return all_lines or [""] + + +def _validate_labels(labels: list[str] | None, detections: Detections) -> None: + """ + Validates that the number of provided labels matches the number of detections. + + Args: + labels: A list of labels, one for each detection. Can + be None. + detections: The detections to be labeled. + + Raises: + ValueError: If `labels` is not None and its length does not match the number + of detections. + """ + if labels is not None and len(labels) != len(detections): + raise ValueError( + f"The number of labels ({len(labels)}) does not match the " + f"number of detections ({len(detections)}). Each detection " + f"should have exactly 1 label." + ) + + +@deprecated( # type: ignore[untyped-decorator] + target=_validate_labels, + deprecated_in="0.29.0", + remove_in="0.32.0", +) +def validate_labels(labels: list[str] | None, detections: Detections) -> None: + void(labels, detections) + + +def get_labels_text( + detections: Detections, custom_labels: list[str] | None +) -> list[str]: + """ + Retrieves the text labels for the detections. + + If `custom_labels` are provided, they are used. Otherwise, the labels are + extracted from the `detections` object, prioritizing the 'class_name' field, + then the `class_id`, and finally using the detection index as a string. + + Args: + detections: The detections to get labels for. + custom_labels: An optional list of custom labels. + + Returns: + A list of text labels for each detection. + """ + if custom_labels is not None: + return custom_labels + + labels = [] + for idx in range(len(detections)): + if CLASS_NAME_DATA_FIELD in detections.data: + labels.append(str(detections.data[CLASS_NAME_DATA_FIELD][idx])) + elif detections.class_id is not None: + labels.append(str(detections.class_id[idx])) + else: + labels.append(str(idx)) + return labels + + +def snap_boxes( + xyxy: npt.NDArray[np.float32], + resolution_wh: tuple[int, int], +) -> npt.NDArray[np.float32]: + """ + Shifts `label` bounding boxes into the frame so that they are fully contained + within the given resolution, prioritizing the top/left edge. + Unlike `clip_boxes`, this function does not crop boxes. + It moves them entirely if they exceed the frame boundaries. + + Args: + xyxy: A numpy array of shape `(N, 4)` where each + row corresponds to a bounding box in the format + `(x_min, y_min, x_max, y_max)`. + resolution_wh: A tuple `(width, height)` + representing the resolution of the frame. + + Returns: + A numpy array of shape `(N, 4)` with boxes shifted into frame. + + Examples: + ```pycon + >>> import numpy as np + >>> from supervision.annotators.utils import snap_boxes + >>> xyxy = np.array([ + ... [-10, 10, 30, 50], # Off left edge + ... [310, 200, 350, 250], # Off right edge + ... [100, -20, 150, 30], # Off top edge + ... [200, 220, 250, 270], # Off bottom edge + ... [-20, 10, 350, 50], # Wider than frame (370 vs 320) + ... [10, -20, 30, 260] # Taller than frame (280 vs 240) + ... ]) + >>> resolution_wh = (320, 240) + >>> snapped_boxes = snap_boxes(xyxy=xyxy, resolution_wh=resolution_wh) + >>> snapped_boxes + array([[ 0., 10., 40., 50.], + [280., 190., 320., 240.], + [100., 0., 150., 50.], + [200., 190., 250., 240.], + [ 0., 10., 370., 50.], + [ 10., 0., 30., 280.]], dtype=float32) + + ``` + """ + result: npt.NDArray[np.float32] = np.array(xyxy, dtype=np.float32, copy=True) + width, height = resolution_wh + + # X-axis (prioritize left edge) + left_overflow = result[:, 0] < 0 + result[left_overflow, 0:3:2] -= result[left_overflow, 0:1] + + right_overflow = (~left_overflow) & (result[:, 2] > width) + right_shift = width - result[right_overflow, 2] + result[right_overflow, 0:3:2] += right_shift[:, np.newaxis] + + # Y-axis (prioritize top edge) + top_overflow = result[:, 1] < 0 + result[top_overflow, 1:4:2] -= result[top_overflow, 1:2] + + bottom_overflow = (~top_overflow) & (result[:, 3] > height) + bottom_shift = height - result[bottom_overflow, 3] + result[bottom_overflow, 1:4:2] += bottom_shift[:, np.newaxis] + + return cast(npt.NDArray[np.float32], result.astype(np.float32, copy=False)) + + +class Trace: + def __init__( + self, + max_size: int | None = None, + start_frame_id: int = 0, + anchor: Position = Position.CENTER, + ) -> None: + self.current_frame_id = start_frame_id + self.max_size = max_size + self.anchor = anchor + + self.frame_id: npt.NDArray[np.int_] = np.array([], dtype=int) + self.xy: npt.NDArray[np.float32] = np.empty((0, 2), dtype=np.float32) + self.tracker_id: npt.NDArray[np.int_] = np.array([], dtype=int) + + def put(self, detections: Detections) -> None: + """Append a frame of detections to the trace history.""" + if detections.tracker_id is None: + raise ValueError( + "Could not put detections into Trace because " + "Detections do not have tracker_id." + ) + + frame_id: npt.NDArray[np.int_] = np.full( + len(detections), self.current_frame_id, dtype=int + ) + self.frame_id = np.concatenate([self.frame_id, frame_id]) + self.xy = np.concatenate( + [ + self.xy, + detections.get_anchors_coordinates(self.anchor), + ] + ) + self.tracker_id = np.concatenate([self.tracker_id, detections.tracker_id]) + + unique_frame_id = np.unique(self.frame_id) + + if self.max_size is not None and 0 < self.max_size < len(unique_frame_id): + max_allowed_frame_id = self.current_frame_id - self.max_size + 1 + filtering_mask = self.frame_id >= max_allowed_frame_id + self.frame_id = self.frame_id[filtering_mask] + self.xy = self.xy[filtering_mask] + self.tracker_id = self.tracker_id[filtering_mask] + + self.current_frame_id += 1 + + def get(self, tracker_id: int) -> npt.NDArray[np.float32]: + xy: npt.NDArray[np.float32] = np.asarray( + self.xy[self.tracker_id == tracker_id], dtype=np.float32 + ) + return xy + + def reset(self) -> None: + """Restore the trace buffers to their initial empty state. + + Clears the accumulated `frame_id`, `xy`, and `tracker_id` history and + rewinds `current_frame_id` to `0`, so the trace can be reused across + independent streams without carrying over points from a previous run. + """ + self.current_frame_id = 0 + self.frame_id = np.array([], dtype=int) + self.xy = np.empty((0, 2), dtype=np.float32) + self.tracker_id = np.array([], dtype=int) + + +def hex_to_rgba(hex_color: str) -> tuple[int, int, int, int]: + """ + Converts a hex color string (e.g. "#FF00FF" or "#FF00FF80") to an RGBA tuple. + + Args: + hex_color: A hex color string. + + Returns: + RGBA values in range 0-255. + + Raises: + ValueError: If the format is invalid. + + Examples: + ```pycon + >>> from supervision.annotators.utils import hex_to_rgba + >>> hex_to_rgba("#FF00FF") + (255, 0, 255, 255) + >>> hex_to_rgba("#FF00FF80") + (255, 0, 255, 128) + + ``` + """ + hex_color = hex_color.strip().removeprefix("#") + if len(hex_color) == 6: + hex_color += "FF" # default full opacity + if len(hex_color) != 8: + raise ValueError(f"Invalid hex color format: {hex_color}") + try: + r = int(hex_color[0:2], 16) + g = int(hex_color[2:4], 16) + b = int(hex_color[4:6], 16) + a = int(hex_color[6:8], 16) + except ValueError as exc: + raise ValueError(f"Invalid hex digits in {hex_color}") from exc + return (r, g, b, a) + + +def rgba_to_hex(rgba: tuple[int, int, int, int]) -> str: + """ + Converts an RGBA tuple (0-255 each) to a hex color string. + + Args: + rgba: RGBA values in range 0-255. + + Returns: + Hex color string in the format "#RRGGBBAA". + + Raises: + ValueError: If `rgba` is not a 4-tuple or contains values outside 0-255. + + Examples: + ```pycon + >>> from supervision.annotators.utils import rgba_to_hex + >>> rgba_to_hex((255, 0, 255, 128)) + '#FF00FF80' + + ``` + """ + if len(rgba) != 4 or not all(0 <= c <= 255 for c in rgba): + raise ValueError("RGBA must be a 4-tuple with values between 0-255.") + return "#{:02X}{:02X}{:02X}{:02X}".format(*rgba) + + +def is_valid_hex(hex_color: str) -> bool: + """ + Checks if a given string is a valid hex color. + + Args: + hex_color: A hex color string with an optional leading "#". Supports + 6-digit (RGB) or 8-digit (RGBA) formats. + + Returns: + True if the string is a valid 6- or 8-digit hex color, otherwise False. + + Examples: + ```pycon + >>> from supervision.annotators.utils import is_valid_hex + >>> is_valid_hex("#FF00FF") + True + >>> is_valid_hex("not-a-color") + False + + ``` + """ + return bool(re.fullmatch(r"#?[0-9A-Fa-f]{6}([0-9A-Fa-f]{2})?", hex_color.strip())) + + +def calculate_dynamic_kernel_size(x1: int, y1: int, x2: int, y2: int) -> int: + """ + Computes a blur kernel size proportional to the shorter side of a bounding box. + + Args: + x1: Left edge of the bounding box. + y1: Top edge of the bounding box. + x2: Right edge of the bounding box. + y2: Bottom edge of the bounding box. + + Returns: + Kernel size as one-third of the shorter dimension, minimum 1. + + Examples: + ```pycon + >>> calculate_dynamic_kernel_size(0, 0, 90, 60) + 20 + + ``` + """ + return max(1, min(y2 - y1, x2 - x1) // 3) + + +def calculate_dynamic_pixel_size(x1: int, y1: int, x2: int, y2: int) -> int: + """ + Computes a pixelation size proportional to the shorter side of a bounding box. + + Args: + x1: Left edge of the bounding box. + y1: Top edge of the bounding box. + x2: Right edge of the bounding box. + y2: Bottom edge of the bounding box. + + Returns: + Pixel size as one-half of the shorter dimension, minimum 1. + + Examples: + ```pycon + >>> calculate_dynamic_pixel_size(0, 0, 90, 60) + 30 + + ``` + """ + return max(1, min(y2 - y1, x2 - x1) // 2) diff --git a/src/supervision/assets/__init__.py b/src/supervision/assets/__init__.py new file mode 100644 index 0000000..3ed213f --- /dev/null +++ b/src/supervision/assets/__init__.py @@ -0,0 +1,4 @@ +from supervision.assets.downloader import download_assets +from supervision.assets.list import ImageAssets, VideoAssets + +__all__ = ["ImageAssets", "VideoAssets", "download_assets"] diff --git a/src/supervision/assets/downloader.py b/src/supervision/assets/downloader.py new file mode 100644 index 0000000..99387df --- /dev/null +++ b/src/supervision/assets/downloader.py @@ -0,0 +1,166 @@ +import os +from hashlib import md5 +from pathlib import Path +from shutil import copyfileobj + +from requests import get +from tqdm.auto import tqdm + +from supervision.assets.list import MEDIA_ASSETS, Assets +from supervision.utils.logger import _get_logger + +logger = _get_logger(__name__) + + +def is_md5_hash_matching(filename: str | Path, original_md5_hash: str) -> bool: + """ + Check if the MD5 hash of a file matches the original hash. + + Note: MD5 is used here for file integrity checking (detecting corruption), + not for cryptographic security purposes. + + Args: + filename: The path to the file to be checked. + original_md5_hash: The original MD5 hash to compare against. + + Returns: + True if the hashes match, False otherwise. + """ + if not os.path.exists(filename): + return False + + with open(filename, "rb") as file: + file_contents = file.read() + computed_md5_hash = md5(file_contents, usedforsecurity=False) + + return computed_md5_hash.hexdigest() == original_md5_hash + + +def _download_asset(filename: str, destination: Path) -> None: + """ + Download asset bytes to the target destination via a temporary file. + """ + response = get( + MEDIA_ASSETS[filename][0], stream=True, allow_redirects=True, timeout=30 + ) + response.raise_for_status() + + file_size = int(response.headers.get("Content-Length", 0)) + destination.parent.mkdir(parents=True, exist_ok=True) + temp_path = destination.with_name(f"{destination.name}.part") + + try: + with tqdm.wrapattr( + response.raw, "read", total=file_size, desc="", colour="#a351fb" + ) as raw_resp: + with temp_path.open("wb") as file: + copyfileobj(raw_resp, file) + except Exception: + temp_path.unlink(missing_ok=True) + raise + + try: + os.replace(temp_path, destination) + finally: + temp_path.unlink(missing_ok=True) + + +def _download_verified_asset( + filename: str, + original_md5_hash: str, + destination: Path, + check_target: str | Path, + retry_on_mismatch: bool = True, +) -> None: + """ + Download an asset and reject payloads whose MD5 does not match the catalog. + """ + _download_asset(filename, destination) + + if is_md5_hash_matching(check_target, original_md5_hash): + return + + logger.warning("File corrupted. Re-downloading...") + os.remove(check_target) + + if retry_on_mismatch: + _download_verified_asset( + filename=filename, + original_md5_hash=original_md5_hash, + destination=destination, + check_target=check_target, + retry_on_mismatch=False, + ) + return + + raise ValueError(f"Downloaded asset {filename!r} failed MD5 verification.") + + +def download_assets( + asset_name: Assets | str, + directory: str | Path | None = None, +) -> str: + """ + Download a specified asset if it doesn't already exist or is corrupted. + + Args: + asset_name: The name or type of the asset to be downloaded. + directory: Optional output directory. Defaults to the current working + directory for backward compatibility. + + Returns: + The downloaded asset path. When `directory` is omitted, this preserves + the historical filename-only return value. + + Example: + ```pycon + >>> from supervision.assets import download_assets, ImageAssets, VideoAssets + >>> download_assets(VideoAssets.VEHICLES) # doctest: +SKIP + 'vehicles.mp4' + + >>> download_assets(ImageAssets.PEOPLE_WALKING) # doctest: +SKIP + 'people-walking.jpg' + + ``` + """ + + filename = asset_name.filename if isinstance(asset_name, Assets) else asset_name + if directory is None: + destination = Path.cwd() / filename + check_target: str | Path = filename + return_value = filename + else: + destination_directory = Path(directory).expanduser().resolve() + destination = destination_directory / filename + check_target = str(destination) + return_value = str(destination) + + if filename in MEDIA_ASSETS: + original_md5_hash = MEDIA_ASSETS[filename][1] + if not Path(check_target).exists(): + logger.info("Downloading %s assets", filename) + _download_verified_asset( + filename=filename, + original_md5_hash=original_md5_hash, + destination=destination, + check_target=check_target, + ) + else: + if not is_md5_hash_matching(check_target, original_md5_hash): + logger.warning("File corrupted. Re-downloading...") + os.remove(check_target) + _download_verified_asset( + filename=filename, + original_md5_hash=original_md5_hash, + destination=destination, + check_target=check_target, + ) + + logger.info("%s asset download complete.", filename) + else: + valid_assets = ", ".join(filename for filename in MEDIA_ASSETS.keys()) + raise ValueError( + f"Invalid asset. It should be one of the following: {valid_assets}." + ) + + return return_value diff --git a/src/supervision/assets/list.py b/src/supervision/assets/list.py new file mode 100644 index 0000000..9b2a2ba --- /dev/null +++ b/src/supervision/assets/list.py @@ -0,0 +1,84 @@ +from __future__ import annotations + +from enum import Enum + +BASE_VIDEO_URL = "https://media.roboflow.com/supervision/video-examples/" +BASE_IMAGE_URL = "https://media.roboflow.com/supervision/image-examples/" + + +class Assets(Enum): + filename: str + md5_hash: str + + def __new__(cls, filename: str, md5_hash: str) -> Assets: + obj = object.__new__(cls) + obj._value_ = filename + obj.filename = filename + obj.md5_hash = md5_hash + return obj + + @classmethod + def list(cls) -> list[str]: + return [asset.filename for asset in cls] + + +class VideoAssets(Assets): + """ + Each member of this class represents a video asset. The value associated with each + member has a filename and hash of the video. File names and links can be seen below. + + | Asset | Video Filename | Video URL | + |------------------------|----------------------------|---------------------------------------------------------------------------------------| + | `VEHICLES` | `vehicles.mp4` | [Link](https://media.roboflow.com/supervision/video-examples/vehicles.mp4) | + | `MILK_BOTTLING_PLANT` | `milk-bottling-plant.mp4` | [Link](https://media.roboflow.com/supervision/video-examples/milk-bottling-plant.mp4) | + | `VEHICLES_2` | `vehicles-2.mp4` | [Link](https://media.roboflow.com/supervision/video-examples/vehicles-2.mp4) | + | `GROCERY_STORE` | `grocery-store.mp4` | [Link](https://media.roboflow.com/supervision/video-examples/grocery-store.mp4) | + | `SUBWAY` | `subway.mp4` | [Link](https://media.roboflow.com/supervision/video-examples/subway.mp4) | + | `MARKET_SQUARE` | `market-square.mp4` | [Link](https://media.roboflow.com/supervision/video-examples/market-square.mp4) | + | `PEOPLE_WALKING` | `people-walking.mp4` | [Link](https://media.roboflow.com/supervision/video-examples/people-walking.mp4) | + | `BEACH` | `beach-1.mp4` | [Link](https://media.roboflow.com/supervision/video-examples/beach-1.mp4) | + | `BASKETBALL` | `basketball-1.mp4` | [Link](https://media.roboflow.com/supervision/video-examples/basketball-1.mp4) | + | `SKIING` | `skiing.mp4` | [Link](https://media.roboflow.com/supervision/video-examples/skiing.mp4) | + """ # noqa: E501 // docs + + VEHICLES = ("vehicles.mp4", "8155ff4e4de08cfa25f39de96483f918") + MILK_BOTTLING_PLANT = ( + "milk-bottling-plant.mp4", + "9e8fb6e883f842a38b3d34267290bdc7", + ) + VEHICLES_2 = ("vehicles-2.mp4", "830af6fba21ffbf14867a7fea595937b") + GROCERY_STORE = ("grocery-store.mp4", "48608fb4a8981f1c2469fa492adeec9c") + SUBWAY = ("subway.mp4", "453475750691fb23c56a0cffef089194") + MARKET_SQUARE = ("market-square.mp4", "859179bf4a21f80a8baabfdb2ed716dc") + PEOPLE_WALKING = ("people-walking.mp4", "0574c053c8686c3f1dc0aa3743e45cb9") + BEACH = ("beach-1.mp4", "4175d42fec4d450ed081523fd39e0cf8") + BASKETBALL = ("basketball-1.mp4", "60d94a3c7c47d16f09d342b088012ecc") + SKIING = ("skiing.mp4", "d30987cbab1bbc5934199cdd1b293119") + + +class ImageAssets(Assets): + """ + Each member of this enum represents a image asset. The value associated with each + member is the filename of the image. + + | Asset | Image Filename | Video URL | + |--------------------|------------------------|---------------------------------------------------------------------------------------| + | `PEOPLE_WALKING` | `people-walking.jpg` | [Link](https://media.roboflow.com/supervision/image-examples/people-walking.jpg) | + | `SOCCER` | `soccer.jpg` | [Link](https://media.roboflow.com/supervision/image-examples/soccer.jpg) | + + """ # noqa: E501 // docs + + PEOPLE_WALKING = ("people-walking.jpg", "e6bda00b47f2908eeae7df86ef995dcd") + SOCCER = ("soccer.jpg", "0f5a4b98abf3e3973faf9e9260a7d876") + + +MEDIA_ASSETS: dict[str, tuple[str, str]] = { + **{ + asset.filename: (f"{BASE_VIDEO_URL}{asset.filename}", asset.md5_hash) + for asset in VideoAssets + }, + **{ + asset.filename: (f"{BASE_IMAGE_URL}{asset.filename}", asset.md5_hash) + for asset in ImageAssets + }, +} diff --git a/src/supervision/classification/__init__.py b/src/supervision/classification/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/src/supervision/classification/core.py b/src/supervision/classification/core.py new file mode 100644 index 0000000..9b7a15b --- /dev/null +++ b/src/supervision/classification/core.py @@ -0,0 +1,216 @@ +from __future__ import annotations + +from dataclasses import dataclass +from typing import TYPE_CHECKING, Any + +import numpy as np +import numpy.typing as npt + +if TYPE_CHECKING: + import torch # type: ignore[import-not-found, unused-ignore] + + +def _validate_class_ids(class_id: Any, n: int) -> None: + """ + Ensure that class_id is a 1d np.ndarray with (n, ) shape. + """ + is_valid = isinstance(class_id, np.ndarray) and class_id.shape == (n,) + if not is_valid: + raise ValueError("class_id must be 1d np.ndarray with (n, ) shape") + + +def _validate_confidence(confidence: Any, n: int) -> None: + """ + Ensure that confidence is a 1d np.ndarray with (n, ) shape. + """ + if confidence is not None: + is_valid = isinstance(confidence, np.ndarray) and confidence.shape == (n,) + if not is_valid: + raise ValueError("confidence must be 1d np.ndarray with (n, ) shape") + + +@dataclass +class Classifications: + class_id: npt.NDArray[np.int_] + confidence: npt.NDArray[np.floating] | None = None + + def __post_init__(self) -> None: + """ + Validate the classification inputs. + """ + n = len(self.class_id) + + _validate_class_ids(self.class_id, n) + _validate_confidence(self.confidence, n) + + def __eq__(self, other: object) -> bool: + """ + Compare classifications by value across numpy-backed fields. + """ + if not isinstance(other, Classifications): + return NotImplemented + if not np.array_equal(self.class_id, other.class_id): + return False + if self.confidence is None or other.confidence is None: + return self.confidence is other.confidence + return bool(np.array_equal(self.confidence, other.confidence)) + + def __len__(self) -> int: + """ + Returns the number of classifications. + """ + return len(self.class_id) + + @classmethod + def from_clip(cls, clip_results: torch.Tensor) -> Classifications: + """ + Creates a Classifications instance from a + [clip](https://github.com/openai/clip) inference result. + + Args: + clip_results: The inference result from clip model. + + Returns: + A new Classifications object. + + Example: + ```python + from PIL import Image + import clip + import supervision as sv + + model, preprocess = clip.load('ViT-B/32') + + image = cv2.imread(SOURCE_IMAGE_PATH) + image = preprocess(image).unsqueeze(0) + + text = clip.tokenize(["a diagram", "a dog", "a cat"]) + output, _ = model(image, text) + classifications = sv.Classifications.from_clip(output) + ``` + """ + + confidence = clip_results.softmax(dim=-1).cpu().detach().numpy()[0] + + if len(confidence) == 0: + return cls( + class_id=np.array([], dtype=np.int_), + confidence=np.array([], dtype=np.float32), + ) + + class_ids = np.arange(len(confidence)) + return cls(class_id=class_ids, confidence=confidence) + + @classmethod + def from_ultralytics(cls, ultralytics_results: Any) -> Classifications: + """ + Creates a Classifications instance from a + [ultralytics](https://github.com/ultralytics/ultralytics) inference result. + + Args: + ultralytics_results: The inference result from ultralytics model. + + Returns: + A new Classifications object. + + Example: + ```python + import cv2 + from ultralytics import YOLO + import supervision as sv + + image = cv2.imread(SOURCE_IMAGE_PATH) + model = YOLO('yolov8n-cls.pt') + + output = model(image)[0] + classifications = sv.Classifications.from_ultralytics(output) + ``` + """ + confidence = ultralytics_results.probs.data.cpu().numpy() + return cls(class_id=np.arange(confidence.shape[0]), confidence=confidence) + + @classmethod + def from_timm(cls, timm_results: Any) -> Classifications: + """ + Creates a Classifications instance from a + [timm](https://huggingface.co/docs/hub/timm) inference result. + + Note: + Returned confidences are softmax-normalized probabilities, so + thresholds calibrated against raw logits may need recalibration. + + Args: + timm_results: The inference result from timm model. + + Returns: + A new Classifications object. + + Example: + ```python + from PIL import Image + import timm + from timm.data import resolve_data_config, create_transform + import supervision as sv + + model = timm.create_model( + model_name='hf-hub:nateraw/resnet50-oxford-iiit-pet', + pretrained=True + ).eval() + + config = resolve_data_config({}, model=model) + transform = create_transform(**config) + + image = Image.open(SOURCE_IMAGE_PATH).convert('RGB') + x = transform(image).unsqueeze(0) + + output = model(x) + + classifications = sv.Classifications.from_timm(output) + ``` + """ + confidence = timm_results.softmax(dim=-1).cpu().detach().numpy()[0] + + if len(confidence) == 0: + return cls( + class_id=np.array([], dtype=np.int_), + confidence=np.array([], dtype=np.float32), + ) + + class_id = np.arange(len(confidence)) + return cls(class_id=class_id, confidence=confidence) + + def get_top_k( + self, k: int + ) -> tuple[npt.NDArray[np.int_], npt.NDArray[np.floating]]: + """ + Retrieve the top k class IDs and confidences, + ordered in descending order by confidence. + + Args: + k: The number of top class IDs and confidences to retrieve. + + Returns: + A tuple containing the top k class IDs and confidences. + + Example: + ```pycon + >>> import numpy as np + >>> import supervision as sv + >>> classifications = sv.Classifications( + ... class_id=np.array([0, 1, 2]), + ... confidence=np.array([0.3, 0.9, 0.5]) + ... ) + >>> classifications.get_top_k(1) + (array([1]), array([0.9])) + + ``` + """ + if self.confidence is None: + raise ValueError("top_k could not be calculated, confidence is None") + + order = np.argsort(self.confidence)[::-1] + top_k_order = order[:k] + top_k_class_id = self.class_id[top_k_order] + top_k_confidence = self.confidence[top_k_order] + + return top_k_class_id, top_k_confidence diff --git a/src/supervision/config.py b/src/supervision/config.py new file mode 100644 index 0000000..18600b4 --- /dev/null +++ b/src/supervision/config.py @@ -0,0 +1,13 @@ +CLASS_NAME_DATA_FIELD: str = "class_name" +COCO_RAW_SEGMENTATION: str = "coco_raw_segmentation" +#: Key for oriented bounding-box corner coordinates in ``Detections.data``. +#: +#: Value layout: ``np.ndarray`` of shape ``(N, 4, 2)``, dtype ``float32``, pixel +#: coordinates ordered as ``[[x1, y1], [x2, y2], [x3, y3], [x4, y4]]`` per +#: detection where the four points are the corners of the oriented box. +#: Used by :func:`~supervision.dataset.formats.yolo.detections_to_yolo_annotations` +#: (``is_obb=True``) and +#: :func:`~supervision.dataset.formats.yolo.yolo_annotations_to_detections` +#: (``is_obb=True``). +#: Also triggers sequential mode in ``InferenceSlicer`` when present. +ORIENTED_BOX_COORDINATES: str = "xyxyxyxy" diff --git a/src/supervision/dataset/__init__.py b/src/supervision/dataset/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/src/supervision/dataset/core.py b/src/supervision/dataset/core.py new file mode 100644 index 0000000..5ae23a5 --- /dev/null +++ b/src/supervision/dataset/core.py @@ -0,0 +1,1313 @@ +from __future__ import annotations + +import os +from abc import ABC, abstractmethod +from collections.abc import Iterator +from copy import deepcopy +from dataclasses import dataclass +from itertools import chain +from pathlib import Path +from typing import cast + +import cv2 +import numpy as np +import numpy.typing as npt +from tqdm.auto import tqdm + +from supervision.classification.core import Classifications +from supervision.config import CLASS_NAME_DATA_FIELD +from supervision.dataset.formats.coco import ( + load_coco_annotations, + save_coco_annotations, +) +from supervision.dataset.formats.createml import ( + load_createml_annotations, + save_createml_annotations, +) +from supervision.dataset.formats.labelme import ( + load_labelme_annotations, + save_labelme_annotations, +) +from supervision.dataset.formats.pascal_voc import ( + load_pascal_voc_annotations, + save_pascal_voc_annotations, +) +from supervision.dataset.formats.yolo import ( + load_yolo_annotations, + save_data_yaml, + save_yolo_annotations, +) +from supervision.dataset.utils import ( + build_class_index_mapping, + check_no_basename_collisions, + map_detections_class_id, + merge_class_lists, + save_dataset_images, + train_test_split, +) +from supervision.detection.core import Detections +from supervision.utils.internal import warn_deprecated +from supervision.utils.iterables import find_duplicates + +_IMAGE_FILE_EXTENSIONS = frozenset( + {".bmp", ".jpeg", ".jpg", ".png", ".tif", ".tiff", ".webp"} +) + + +class BaseDataset(ABC): + @abstractmethod + def __len__(self) -> int: + pass + + @abstractmethod + def split( + self, + split_ratio: float = 0.8, + random_state: int | None = None, + shuffle: bool = True, + ) -> tuple[BaseDataset, BaseDataset]: + pass + + +class DetectionDataset(BaseDataset): + """ + Contains information about a detection dataset. Handles lazy image loading + and annotation retrieval, dataset splitting, conversions into multiple + formats. + + Attributes: + classes: List containing dataset class names. + images: + Accepts a list of image paths. Passing a dict + (``Dict[str, np.ndarray]``) is deprecated in ``0.30.0`` and will + be removed in ``0.33.0``; use a list of paths instead. + When a list of paths is provided, images are loaded lazily on + demand, which is more memory-efficient. + annotations: Dictionary mapping + image path to annotations. The dictionary keys match + match the keys in `images` or entries in the list of + image paths. + """ + + def __init__( + self, + classes: list[str], + images: list[str] | dict[str, npt.NDArray[np.uint8]], + annotations: dict[str, Detections], + ) -> None: + self.classes = classes + + if set(images) != set(annotations): + raise ValueError( + "The keys of the images and annotations dictionaries must match." + ) + self.annotations = { + image_path: deepcopy(annotation) + for image_path, annotation in annotations.items() + } + + np_classes = np.array(self.classes) + for image_path, annotation in self.annotations.items(): + class_ids = annotation.class_id + if class_ids is None: + continue + if not np.issubdtype(class_ids.dtype, np.integer): + raise ValueError( + f"Detection annotation for image {image_path!r} contains " + f"non-integer class_id values with dtype {class_ids.dtype}." + ) + + invalid_class_ids = class_ids[ + (class_ids < 0) | (class_ids >= len(self.classes)) + ] + if len(invalid_class_ids) > 0: + valid_range = ( + "empty" + if len(self.classes) == 0 + else f"[0, {len(self.classes) - 1}]" + ) + raise ValueError( + f"Detection annotation for image {image_path!r} contains " + f"class_id {int(invalid_class_ids[0])}, outside the valid " + f"range {valid_range} for {len(self.classes)} classes." + ) + + annotation.data[CLASS_NAME_DATA_FIELD] = np_classes[class_ids] + + # Eliminate duplicates while preserving order + self.image_paths = list(dict.fromkeys(images)) + + self._images_in_memory: dict[str, npt.NDArray[np.uint8]] = {} + if isinstance(images, dict): + self._images_in_memory = images + warn_deprecated( + "Passing a `Dict[str, np.ndarray]` into `DetectionDataset` is " + "deprecated in `0.30.0` and will be removed in `0.33.0`. Use " + "a list of paths `List[str]` instead." + ) + + def _get_image(self, image_path: str) -> npt.NDArray[np.uint8]: + """Assumes that image is in dataset.""" + if self._images_in_memory: + return self._images_in_memory[image_path] + image = cv2.imread(image_path) + if image is None: + raise ValueError(f"Could not read image from path: {image_path}") + return cast(npt.NDArray[np.uint8], image) + + def __len__(self) -> int: + return len(self._images_in_memory) or len(self.image_paths) + + def __getitem__(self, i: int) -> tuple[str, npt.NDArray[np.uint8], Detections]: + """ + Returns: + The image path, image data, + and its corresponding annotation at index i. + """ + image_path = self.image_paths[i] + image = self._get_image(image_path) + annotation = self.annotations[image_path] + return image_path, image, annotation + + def __iter__(self) -> Iterator[tuple[str, npt.NDArray[np.uint8], Detections]]: + """ + Iterate over the images and annotations in the dataset. + + Yields: + Tuples containing the image path, image data, and its annotation. + """ + for i in range(len(self)): + image_path, image, annotation = self[i] + yield image_path, image, annotation + + def __eq__(self, other: object) -> bool: + if not isinstance(other, DetectionDataset): + return False + + if self.classes != other.classes: + return False + + if self.image_paths != other.image_paths: + return False + + if self._images_in_memory or other._images_in_memory: + if not np.array_equal( + list(self._images_in_memory.values()), + list(other._images_in_memory.values()), + ): + return False + + if self.annotations != other.annotations: + return False + + return True + + def split( + self, + split_ratio: float = 0.8, + random_state: int | None = None, + shuffle: bool = True, + ) -> tuple[DetectionDataset, DetectionDataset]: + """ + Splits the dataset into two parts (training and testing) + using the provided split_ratio. The input dataset is not mutated. + + Args: + split_ratio: The ratio of the training + set to the entire dataset. + random_state: The seed for the random number generator. + This is used for reproducibility. + shuffle: Whether to shuffle the data before splitting. + + Returns: + A tuple containing + the training and testing datasets. + + Examples: + ```pycon + >>> import numpy as np + >>> import supervision as sv + >>> ds = sv.DetectionDataset( + ... classes=['dog', 'person'], + ... images={ + ... 'img1.jpg': np.zeros((100, 100, 3), dtype=np.uint8), + ... 'img2.jpg': np.zeros((100, 100, 3), dtype=np.uint8), + ... }, + ... annotations={ + ... 'img1.jpg': sv.Detections(xyxy=np.array([[10, 10, 20, 20]])), + ... 'img2.jpg': sv.Detections(xyxy=np.array([[30, 30, 40, 40]])), + ... } + ... ) + >>> train_ds, test_ds = ds.split(split_ratio=0.5, random_state=42) + >>> len(train_ds), len(test_ds) + (1, 1) + + ``` + """ + + train_paths, test_paths = train_test_split( + data=self.image_paths, + train_ratio=split_ratio, + random_state=random_state, + shuffle=shuffle, + ) + + train_annotations = {path: self.annotations[path] for path in train_paths} + test_annotations = {path: self.annotations[path] for path in test_paths} + + train_dataset = DetectionDataset( + classes=self.classes, + images=train_paths, + annotations=train_annotations, + ) + test_dataset = DetectionDataset( + classes=self.classes, + images=test_paths, + annotations=test_annotations, + ) + if self._images_in_memory: + train_dataset._images_in_memory = { + path: self._images_in_memory[path] for path in train_paths + } + test_dataset._images_in_memory = { + path: self._images_in_memory[path] for path in test_paths + } + return train_dataset, test_dataset + + @classmethod + def merge(cls, dataset_list: list[DetectionDataset]) -> DetectionDataset: + """ + Merge a list of `DetectionDataset` objects into a single + `DetectionDataset` object. + + This method takes a list of `DetectionDataset` objects and combines + their respective fields (`classes`, `images`, + `annotations`) into a single `DetectionDataset` object. + + Args: + dataset_list: A list of `DetectionDataset` + objects to merge. + + Returns: + A single `DetectionDataset` object containing + the merged data from the input list. + + Examples: + ```pycon + >>> import numpy as np + >>> import supervision as sv + >>> ds_1 = sv.DetectionDataset( + ... classes=['dog', 'person'], + ... images={'img1.jpg': np.zeros((100, 100, 3), dtype=np.uint8)}, + ... annotations={'img1.jpg': sv.Detections.empty()} + ... ) + >>> len(ds_1) + 1 + >>> ds_1.classes + ['dog', 'person'] + >>> ds_2 = sv.DetectionDataset( + ... classes=['cat'], + ... images={'img2.jpg': np.zeros((100, 100, 3), dtype=np.uint8)}, + ... annotations={'img2.jpg': sv.Detections.empty()} + ... ) + >>> len(ds_2) + 1 + >>> ds_2.classes + ['cat'] + >>> ds_merged = sv.DetectionDataset.merge([ds_1, ds_2]) + >>> len(ds_merged) + 2 + >>> ds_merged.classes + ['cat', 'dog', 'person'] + + ``` + """ + + def is_in_memory(dataset: DetectionDataset) -> bool: + return len(dataset._images_in_memory) > 0 or len(dataset.image_paths) == 0 + + def is_lazy(dataset: DetectionDataset) -> bool: + return len(dataset._images_in_memory) == 0 + + all_in_memory = all([is_in_memory(dataset) for dataset in dataset_list]) + all_lazy = all([is_lazy(dataset) for dataset in dataset_list]) + if not all_in_memory and not all_lazy: + raise ValueError( + "Merging lazy and in-memory DetectionDatasets is not supported." + ) + + images_in_memory = {} + for dataset in dataset_list: + images_in_memory.update(dataset._images_in_memory) + + image_paths = list( + chain.from_iterable(dataset.image_paths for dataset in dataset_list) + ) + image_paths_unique = list(dict.fromkeys(image_paths)) + if len(image_paths) != len(image_paths_unique): + duplicates = find_duplicates(image_paths) + raise ValueError( + f"Image paths {duplicates} are not unique across datasets." + ) + image_paths = image_paths_unique + + classes = merge_class_lists( + class_lists=[dataset.classes for dataset in dataset_list] + ) + + annotations = {} + for dataset in dataset_list: + annotations.update(dataset.annotations) + for dataset in dataset_list: + class_index_mapping = build_class_index_mapping( + source_classes=dataset.classes, target_classes=classes + ) + for image_path in dataset.image_paths: + annotations[image_path] = map_detections_class_id( + source_to_target_mapping=class_index_mapping, + detections=annotations[image_path], + ) + + merged_dataset = cls( + classes=classes, + images=image_paths, + annotations=annotations, + ) + if all_in_memory: + merged_dataset._images_in_memory = images_in_memory + return merged_dataset + + def as_pascal_voc( + self, + images_directory_path: str | None = None, + annotations_directory_path: str | None = None, + min_image_area_percentage: float = 0.0, + max_image_area_percentage: float = 1.0, + approximation_percentage: float = 0.0, + show_progress: bool = False, + ) -> None: + """ + Exports the dataset to PASCAL VOC format. This method saves the images + and their corresponding annotations in PASCAL VOC format. Both output + layouts are preflighted before any files are written so a collision in + either target fails without partial output. + + Args: + images_directory_path: The path to the directory + where the images should be saved. + If not provided, images will not be saved. + annotations_directory_path: The path to + the directory where the annotations in PASCAL VOC format should be + saved. If not provided, annotations will not be saved. + min_image_area_percentage: The minimum percentage of + detection area relative to + the image area for a detection to be included. + Argument is used only for segmentation datasets. + max_image_area_percentage: The maximum percentage + of detection area relative to + the image area for a detection to be included. + Argument is used only for segmentation datasets. + approximation_percentage: The percentage of + polygon points to be removed from the input polygon, + in the range [0, 1). Argument is used only for segmentation datasets. + show_progress: If True, display a progress bar during saving. + + Raises: + ValueError: If two image paths share the same basename (when + images_directory_path is set) or the same stem (when + annotations_directory_path is set), which would cause one + output file to overwrite another. Rename images to ensure + unique basenames before exporting a merged dataset. + """ + if images_directory_path: + check_no_basename_collisions( + image_paths=self.image_paths, + key=lambda image_path: Path(image_path).name, + output_kind="image", + ) + if annotations_directory_path: + check_no_basename_collisions( + image_paths=self.image_paths, + key=lambda image_path: f"{Path(image_path).stem}.xml", + output_kind="Pascal VOC annotation", + ) + + if images_directory_path: + save_dataset_images( + dataset=self, + images_directory_path=images_directory_path, + show_progress=show_progress, + ) + if annotations_directory_path: + save_pascal_voc_annotations( + dataset=self, + annotations_directory_path=annotations_directory_path, + min_image_area_percentage=min_image_area_percentage, + max_image_area_percentage=max_image_area_percentage, + approximation_percentage=approximation_percentage, + show_progress=show_progress, + ) + + @classmethod + def from_pascal_voc( + cls, + images_directory_path: str, + annotations_directory_path: str, + force_masks: bool = False, + show_progress: bool = False, + ) -> DetectionDataset: + """ + Creates a Dataset instance from PASCAL VOC formatted data. + + Args: + images_directory_path: Path to the directory containing the images. + annotations_directory_path: Path to the directory + containing the PASCAL VOC XML annotations. + force_masks: If True, forces masks to + be loaded for all annotations, regardless of whether they are present. + show_progress: If True, display a progress bar during loading. + + Returns: + A DetectionDataset instance containing + the loaded images and annotations. + + Examples: + ```python + import roboflow + from roboflow import Roboflow + import supervision as sv + + roboflow.login() + + rf = Roboflow() + + project = rf.workspace(WORKSPACE_ID).project(PROJECT_ID) + dataset = project.version(PROJECT_VERSION).download("voc") + + ds = sv.DetectionDataset.from_pascal_voc( + images_directory_path=f"{dataset.location}/train/images", + annotations_directory_path=f"{dataset.location}/train/labels", + # pass show_progress=True to enable a tqdm progress bar + ) + + ds.classes + # ['dog', 'person'] + ``` + """ + + classes, image_paths, annotations = load_pascal_voc_annotations( + images_directory_path=images_directory_path, + annotations_directory_path=annotations_directory_path, + force_masks=force_masks, + show_progress=show_progress, + ) + + return DetectionDataset( + classes=classes, images=image_paths, annotations=annotations + ) + + @classmethod + def from_yolo( + cls, + images_directory_path: str, + annotations_directory_path: str, + data_yaml_path: str, + force_masks: bool = False, + is_obb: bool = False, + show_progress: bool = False, + ) -> DetectionDataset: + """ + Creates a Dataset instance from YOLO formatted data. + + Args: + images_directory_path: The path to the + directory containing the images. + annotations_directory_path: The path to the directory + containing the YOLO annotation files. + data_yaml_path: The path to the data + YAML file containing class information. + force_masks: If True, forces + masks to be loaded for all annotations, + regardless of whether they are present. + is_obb: If True, loads the annotations in OBB format. + OBB annotations are defined as `[class_id, x, y, x, y, x, y, x, y]`, + where pairs of [x, y] are box corners. + show_progress: If True, display a progress bar during loading. + + Returns: + A DetectionDataset instance + containing the loaded images and annotations. + + Examples: + ```python + import roboflow + from roboflow import Roboflow + import supervision as sv + + roboflow.login() + rf = Roboflow() + + project = rf.workspace(WORKSPACE_ID).project(PROJECT_ID) + dataset = project.version(PROJECT_VERSION).download("yolov5") + + ds = sv.DetectionDataset.from_yolo( + images_directory_path=f"{dataset.location}/train/images", + annotations_directory_path=f"{dataset.location}/train/labels", + data_yaml_path=f"{dataset.location}/data.yaml", + # pass show_progress=True to enable a tqdm progress bar + ) + + ds.classes + # ['dog', 'person'] + ``` + """ + classes, image_paths, annotations = load_yolo_annotations( + images_directory_path=images_directory_path, + annotations_directory_path=annotations_directory_path, + data_yaml_path=data_yaml_path, + force_masks=force_masks, + is_obb=is_obb, + show_progress=show_progress, + ) + return DetectionDataset( + classes=classes, images=image_paths, annotations=annotations + ) + + def as_yolo( + self, + images_directory_path: str | None = None, + annotations_directory_path: str | None = None, + data_yaml_path: str | None = None, + min_image_area_percentage: float = 0.0, + max_image_area_percentage: float = 1.0, + approximation_percentage: float = 0.0, + is_obb: bool = False, + show_progress: bool = False, + ) -> None: + """ + Exports the dataset to YOLO format. This method saves the + images and their corresponding annotations in YOLO format. + + Args: + images_directory_path: The path to the + directory where the images should be saved. + If not provided, images will not be saved. + annotations_directory_path: The path to the + directory where the annotations in + YOLO format should be saved. If not provided, + annotations will not be saved. + data_yaml_path: The path where the data.yaml + file should be saved. + If not provided, the file will not be saved. + min_image_area_percentage: The minimum percentage of + detection area relative to + the image area for a detection to be included. + Argument is used only for segmentation datasets. + max_image_area_percentage: The maximum percentage + of detection area relative to + the image area for a detection to be included. + Argument is used only for segmentation datasets. + approximation_percentage: The percentage of polygon points to + be removed from the input polygon, in the range [0, 1). + This is useful for simplifying the annotations. + Argument is used only for segmentation datasets. + is_obb: If True, exports annotations in OBB format + (`class_id x1 y1 x2 y2 x3 y3 x4 y4`) using the oriented + corners stored in `detections.data["xyxyxyxy"]`. Mirrors + `from_yolo(..., is_obb=True)`. Masks are ignored when + `is_obb=True`. + show_progress: If True, display a progress bar during saving. + + Raises: + ValueError: If two image paths share the same basename (when + images_directory_path is set) or the same annotation + file name (when annotations_directory_path is set), + which would cause one output file to overwrite another. + """ + if is_obb and ( + min_image_area_percentage != 0.0 + or max_image_area_percentage != 1.0 + or approximation_percentage != 0.0 + ): + import warnings + + warnings.warn( + "`min_image_area_percentage`, `max_image_area_percentage`, and " + "`approximation_percentage` have no effect when `is_obb=True`; " + "OBB annotations use corner coordinates directly.", + UserWarning, + stacklevel=2, + ) + # Pre-flight: validate output uniqueness before writing any file + if images_directory_path: + check_no_basename_collisions( + image_paths=self.image_paths, + key=lambda image_path: Path(image_path).name, + output_kind="image", + ) + if annotations_directory_path: + check_no_basename_collisions( + image_paths=self.image_paths, + key=lambda image_path: Path(image_path).stem + ".txt", + output_kind="YOLO annotation", + ) + + if images_directory_path is not None: + save_dataset_images( + dataset=self, + images_directory_path=images_directory_path, + show_progress=show_progress, + ) + if annotations_directory_path is not None: + save_yolo_annotations( + dataset=self, + annotations_directory_path=annotations_directory_path, + min_image_area_percentage=min_image_area_percentage, + max_image_area_percentage=max_image_area_percentage, + approximation_percentage=approximation_percentage, + show_progress=show_progress, + is_obb=is_obb, + ) + if data_yaml_path is not None: + save_data_yaml(data_yaml_path=data_yaml_path, classes=self.classes) + + @classmethod + def from_labelme( + cls, + images_directory_path: str, + annotations_directory_path: str, + force_masks: bool = False, + ) -> DetectionDataset: + """ + Creates a Dataset instance from LabelMe formatted data. + + LabelMe stores one JSON file per image, each containing a list of + ``shapes``. ``rectangle`` shapes are loaded as bounding boxes and + ``polygon`` shapes as masks (with their bounding boxes); other shape + types are skipped. Class names are inferred from the labels present in + the files. When an image file contains a ``polygon`` shape, or when + ``force_masks=True`` is set, both ``rectangle`` and ``polygon`` shapes + produce masks: rectangles via a four-corner polygon fill. + + Args: + images_directory_path: The path to the + directory containing the images. + annotations_directory_path: The path to the directory + containing the LabelMe ``.json`` annotation files. + force_masks: If True, forces masks to be loaded for all + annotations, regardless of whether polygon shapes are present. + Requires ``imageWidth`` and ``imageHeight`` in every JSON file. + + Returns: + A DetectionDataset instance containing + the loaded images and annotations. + + Raises: + ValueError: If an annotation is malformed - for example + ``imagePath`` is empty or resolves to ``..``, a shape is + missing its ``label`` or ``points``, or a mask is required but + ``imageWidth`` / ``imageHeight`` are missing or zero. + + Examples: + ```python + import supervision as sv + + ds = sv.DetectionDataset.from_labelme( + images_directory_path="", + annotations_directory_path="", + ) + + ds.classes + # ['dog', 'person'] + ``` + """ + classes, image_paths, annotations = load_labelme_annotations( + images_directory_path=images_directory_path, + annotations_directory_path=annotations_directory_path, + force_masks=force_masks, + ) + return DetectionDataset( + classes=classes, images=image_paths, annotations=annotations + ) + + def as_labelme( + self, + images_directory_path: str | None = None, + annotations_directory_path: str | None = None, + ) -> None: + """ + Exports the dataset to LabelMe format. This method saves the images and + their corresponding annotations as per-image LabelMe ``.json`` files. + Masked detections are written as ``polygon`` shapes whose vertices + approximate the mask contour, so masks are not bit-exact on round-trip. + Because the bounding box is recomputed from the quantized polygon contour + on re-import, bounding boxes for masked detections may also shift by + approximately one pixel after a save-load cycle. + + Args: + images_directory_path: The path to the directory + where the images should be saved. + If not provided, images will not be saved. + annotations_directory_path: The path to the directory where the + LabelMe ``.json`` files should be saved. + If not provided, annotations will not be saved. + + Examples: + ```python + import supervision as sv + + ds = sv.DetectionDataset(...) + + ds.as_labelme( + images_directory_path="", + annotations_directory_path="", + ) + ``` + """ + if images_directory_path is not None: + save_dataset_images( + dataset=self, images_directory_path=images_directory_path + ) + if annotations_directory_path is not None: + save_labelme_annotations( + dataset=self, + annotations_directory_path=annotations_directory_path, + ) + + @classmethod + def from_createml( + cls, + images_directory_path: str, + annotations_path: str, + show_progress: bool = False, + ) -> DetectionDataset: + """ + Creates a Dataset instance from CreateML formatted data. + + CreateML stores object-detection annotations in a single JSON file as a + list of per-image entries, with each box expressed as a pixel-space + centre point plus width and height. Class names are inferred from the + labels present in the file. + + Args: + images_directory_path: The path to the directory containing the + images. + annotations_path: The path to the CreateML json annotation file. + show_progress: If True, display a progress bar during loading. + + Returns: + A DetectionDataset instance containing the loaded images and + annotations. + + Examples: + ```python + import roboflow + from roboflow import Roboflow + import supervision as sv + + roboflow.login() + rf = Roboflow() + + project = rf.workspace(WORKSPACE_ID).project(PROJECT_ID) + dataset = project.version(PROJECT_VERSION).download("createml") + + ds = sv.DetectionDataset.from_createml( + images_directory_path=f"{dataset.location}/train", + annotations_path=f"{dataset.location}/train/_annotations.createml.json", + ) + + ds.classes + # ['dog', 'person'] + ``` + """ + classes, image_paths, annotations = load_createml_annotations( + images_directory_path=images_directory_path, + annotations_path=annotations_path, + show_progress=show_progress, + ) + return DetectionDataset( + classes=classes, images=image_paths, annotations=annotations + ) + + def as_createml( + self, + images_directory_path: str | None = None, + annotations_path: str | None = None, + show_progress: bool = False, + ) -> None: + """ + Exports the dataset to CreateML format. This method saves the + images and their corresponding annotations in CreateML format. + + Args: + images_directory_path: The path to the directory where the images + should be saved. If not provided, images will not be saved. + annotations_path: The path to the CreateML json annotation file. + If not provided, the annotations will not be saved. + show_progress: If True, display a progress bar while saving images. + + Returns: + None. Side-effects only: writes images and/or annotation file. + + Examples: + ```python + import supervision as sv + + ds = sv.DetectionDataset(classes=["dog"], images=[], annotations={}) + ds.as_createml( + images_directory_path="/tmp/images", + annotations_path="/tmp/annotations.json", + ) + ``` + """ + if images_directory_path is not None: + save_dataset_images( + dataset=self, + images_directory_path=images_directory_path, + show_progress=show_progress, + ) + if annotations_path is not None: + save_createml_annotations( + dataset=self, + annotations_path=annotations_path, + ) + + @classmethod + def from_coco( + cls, + images_directory_path: str, + annotations_path: str, + force_masks: bool = False, + show_progress: bool = False, + *, + use_iscrowd: bool = True, + ) -> DetectionDataset: + """ + Creates a Dataset instance from COCO formatted data. + + Args: + images_directory_path: The path to the + directory containing the images. + annotations_path: The path to the json annotation files. + force_masks: If True, + forces masks to be loaded for all annotations, + regardless of whether they are present. + show_progress: If True, display a progress bar during loading. + use_iscrowd: If True, includes COCO ``iscrowd`` and ``area`` + annotation fields in ``Detections.data``. + Returns: + A DetectionDataset instance containing + the loaded images and annotations. + + Examples: + ```python + import roboflow + from roboflow import Roboflow + import supervision as sv + + roboflow.login() + rf = Roboflow() + + project = rf.workspace(WORKSPACE_ID).project(PROJECT_ID) + dataset = project.version(PROJECT_VERSION).download("coco") + + ds = sv.DetectionDataset.from_coco( + images_directory_path=f"{dataset.location}/train", + annotations_path=f"{dataset.location}/train/_annotations.coco.json", + # pass show_progress=True to enable a tqdm progress bar + ) + + ds.classes + # ['dog', 'person'] + ``` + """ + classes, images, annotations = load_coco_annotations( + images_directory_path=images_directory_path, + annotations_path=annotations_path, + force_masks=force_masks, + use_iscrowd=use_iscrowd, + show_progress=show_progress, + ) + return DetectionDataset(classes=classes, images=images, annotations=annotations) + + def as_coco( + self, + images_directory_path: str | None = None, + annotations_path: str | None = None, + min_image_area_percentage: float = 0.0, + max_image_area_percentage: float = 1.0, + approximation_percentage: float = 0.0, + starting_image_id: int = 1, + starting_annotation_id: int = 1, + show_progress: bool = False, + ) -> tuple[int, int]: + """ + Exports the dataset to COCO format. This method saves the + images and their corresponding annotations in COCO format. + + !!! tip + + The format of the mask is determined automatically based on its structure: + + - If a mask contains multiple disconnected components or holes, it will be + saved using the Run-Length Encoding (RLE) format for efficient storage and + processing. + - If a mask consists of a single, contiguous region without any holes, it + will be encoded as a polygon, preserving the outline of the object. + + This automatic selection ensures that the masks are stored in the most + appropriate and space-efficient format, complying with COCO dataset + standards. + + Args: + images_directory_path: The path to the directory + where the images should be saved. + If not provided, images will not be saved. + annotations_path: The path to COCO annotation file. + min_image_area_percentage: The minimum percentage of + detection area relative to + the image area for a detection to be included. + Argument is used only for segmentation datasets. + max_image_area_percentage: The maximum percentage of + detection area relative to + the image area for a detection to be included. + Argument is used only for segmentation datasets. + approximation_percentage: The percentage of polygon points + to be removed from the input polygon, + in the range [0, 1). This is useful for simplifying the annotations. + Argument is used only for segmentation datasets. + starting_image_id: First image id to assign in the exported file. + Defaults to ``1``. Override when exporting multiple splits into + a coordinated COCO collection so ids remain unique across the + set (see example below). + starting_annotation_id: First annotation id to assign in the + exported file. Defaults to ``1``. Override for the same + multi-split reason as ``starting_image_id``. + show_progress: If True, display a progress bar during saving. + + Returns: + A ``(next_image_id, next_annotation_id)`` tuple containing the + first unused ids after this export. Feed them straight back into + ``starting_image_id`` and ``starting_annotation_id`` on the next + split so ids stay globally unique. When ``annotations_path`` is + ``None`` (images-only export) the starting ids are returned + unchanged so chaining still composes. + + Example: + ```python + # Exporting train, valid, and test splits with non-colliding ids + # so the three annotation files can later be merged into one COCO. + next_image_id, next_annotation_id = train_ds.as_coco( + images_directory_path="out/train/images", + annotations_path="out/train/annotations.json", + ) + next_image_id, next_annotation_id = valid_ds.as_coco( + images_directory_path="out/valid/images", + annotations_path="out/valid/annotations.json", + starting_image_id=next_image_id, + starting_annotation_id=next_annotation_id, + ) + _, _ = test_ds.as_coco( + images_directory_path="out/test/images", + annotations_path="out/test/annotations.json", + starting_image_id=next_image_id, + starting_annotation_id=next_annotation_id, + ) # return value not needed โ€” no further split + ``` + """ + if images_directory_path is not None: + save_dataset_images( + dataset=self, + images_directory_path=images_directory_path, + show_progress=show_progress, + ) + if annotations_path is not None: + return save_coco_annotations( + dataset=self, + annotation_path=annotations_path, + min_image_area_percentage=min_image_area_percentage, + max_image_area_percentage=max_image_area_percentage, + approximation_percentage=approximation_percentage, + starting_image_id=starting_image_id, + starting_annotation_id=starting_annotation_id, + show_progress=show_progress, + ) + return starting_image_id, starting_annotation_id + + +@dataclass +class ClassificationDataset(BaseDataset): + """ + Contains information about a classification dataset, handles lazy image + loading, dataset splitting. + + Attributes: + classes: List containing dataset class names. + images: + List of image paths or dictionary mapping image name to image data. + annotations: Dictionary mapping + image name to annotations. + """ + + def __init__( + self, + classes: list[str], + images: list[str] | dict[str, npt.NDArray[np.uint8]], + annotations: dict[str, Classifications], + ) -> None: + self.classes = classes + + if set(images) != set(annotations): + raise ValueError( + "The keys of the images and annotations dictionaries must match." + ) + self.annotations = annotations + + # Eliminate duplicates while preserving order + self.image_paths = list(dict.fromkeys(images)) + + self._images_in_memory: dict[str, npt.NDArray[np.uint8]] = {} + if isinstance(images, dict): + self._images_in_memory = images + warn_deprecated( + "Passing a `Dict[str, np.ndarray]` into `ClassificationDataset` is " + "deprecated and will be removed in a future release. Use " + "a list of paths `List[str]` instead." + ) + + def _get_image(self, image_path: str) -> npt.NDArray[np.uint8]: + """Assumes that image is in dataset.""" + if self._images_in_memory: + return self._images_in_memory[image_path] + image = cv2.imread(image_path) + if image is None: + raise ValueError(f"Could not read image from path: {image_path}") + return cast(npt.NDArray[np.uint8], image) + + def __len__(self) -> int: + return len(self._images_in_memory) or len(self.image_paths) + + def __getitem__(self, i: int) -> tuple[str, npt.NDArray[np.uint8], Classifications]: + """ + Returns: + The image path, image data, + and its corresponding annotation at index i. + """ + image_path = self.image_paths[i] + image = self._get_image(image_path) + annotation = self.annotations[image_path] + return image_path, image, annotation + + def __iter__( + self, + ) -> Iterator[tuple[str, npt.NDArray[np.uint8], Classifications]]: + """ + Iterate over the images and annotations in the dataset. + + Yields: + Tuples containing the image path, image data, and its annotation. + """ + for i in range(len(self)): + image_path, image, annotation = self[i] + yield image_path, image, annotation + + def __eq__(self, other: object) -> bool: + if not isinstance(other, ClassificationDataset): + return False + + if self.classes != other.classes: + return False + + if self.image_paths != other.image_paths: + return False + + if self._images_in_memory or other._images_in_memory: + if not np.array_equal( + list(self._images_in_memory.values()), + list(other._images_in_memory.values()), + ): + return False + + if self.annotations != other.annotations: + return False + + return True + + def split( + self, + split_ratio: float = 0.8, + random_state: int | None = None, + shuffle: bool = True, + ) -> tuple[ClassificationDataset, ClassificationDataset]: + """ + Splits the dataset into two parts (training and testing) + using the provided split_ratio. + + Args: + split_ratio: The ratio of the training + set to the entire dataset. + random_state: The seed for the + random number generator. This is used for reproducibility. + shuffle: Whether to shuffle the data before splitting. + + Returns: + A tuple containing + the training and testing datasets. + + Examples: + ```pycon + >>> import numpy as np + >>> import supervision as sv + >>> cd = sv.ClassificationDataset( + ... classes=['cat', 'dog'], + ... images={ + ... 'img1.jpg': np.zeros((100, 100, 3), dtype=np.uint8), + ... 'img2.jpg': np.zeros((100, 100, 3), dtype=np.uint8), + ... }, + ... annotations={ + ... 'img1.jpg': sv.Classifications(class_id=np.array([0])), + ... 'img2.jpg': sv.Classifications(class_id=np.array([1])), + ... } + ... ) + >>> train_cd, test_cd = cd.split(split_ratio=0.5, random_state=42) + >>> len(train_cd), len(test_cd) + (1, 1) + + ``` + """ + train_paths, test_paths = train_test_split( + data=self.image_paths, + train_ratio=split_ratio, + random_state=random_state, + shuffle=shuffle, + ) + + train_input: list[str] | dict[str, npt.NDArray[np.uint8]] + test_input: list[str] | dict[str, npt.NDArray[np.uint8]] + if self._images_in_memory: + train_input = {path: self._images_in_memory[path] for path in train_paths} + test_input = {path: self._images_in_memory[path] for path in test_paths} + else: + train_input = train_paths + test_input = test_paths + train_annotations = {path: self.annotations[path] for path in train_paths} + test_annotations = {path: self.annotations[path] for path in test_paths} + + train_dataset = ClassificationDataset( + classes=self.classes, + images=train_input, + annotations=train_annotations, + ) + test_dataset = ClassificationDataset( + classes=self.classes, + images=test_input, + annotations=test_annotations, + ) + + return train_dataset, test_dataset + + def as_folder_structure( + self, root_directory_path: str, show_progress: bool = False + ) -> None: + """ + Saves the dataset as a multi-class folder structure. + + Args: + root_directory_path: The path to the directory + where the dataset will be saved. + show_progress: If True, display a progress bar during saving. + """ + os.makedirs(root_directory_path, exist_ok=True) + + for class_name in self.classes: + os.makedirs(os.path.join(root_directory_path, class_name), exist_ok=True) + + for image_save_path, image, annotation in tqdm( + self, + total=len(self), + desc="Saving classification images", + disable=not show_progress, + ): + image_name = Path(image_save_path).name + class_id = ( + annotation.class_id[0] + if annotation.confidence is None + else annotation.get_top_k(1)[0][0] + ) + class_name = self.classes[class_id] + image_save_path = os.path.join(root_directory_path, class_name, image_name) + cv2.imwrite(image_save_path, image) + + @classmethod + def from_folder_structure( + cls, root_directory_path: str, show_progress: bool = False + ) -> ClassificationDataset: + """ + Load data from a multiclass folder structure into a ClassificationDataset. + + Args: + root_directory_path: The path to the dataset directory. Hidden + entries, root-level files, nested directories, and files whose + suffix is not a supported image extension are ignored. + show_progress: If True, display a progress bar during loading. + + Returns: + The dataset. + + Examples: + ```python + import roboflow + from roboflow import Roboflow + import supervision as sv + + roboflow.login() + rf = Roboflow() + + project = rf.workspace(WORKSPACE_ID).project(PROJECT_ID) + dataset = project.version(PROJECT_VERSION).download("folder") + + cd = sv.ClassificationDataset.from_folder_structure( + root_directory_path=f"{dataset.location}/train" + # pass show_progress=True to enable a tqdm progress bar + ) + ``` + """ + root_directory = Path(root_directory_path) + classes = sorted( + { + entry.name + for entry in root_directory.iterdir() + if entry.is_dir() and not entry.name.startswith(".") + } + ) + + image_paths = [] + annotations = {} + + for class_id, class_name in enumerate( + tqdm( + classes, + total=len(classes), + desc="Loading classification dataset", + disable=not show_progress, + ) + ): + class_directory = root_directory / class_name + + for image_path in sorted( + class_directory.iterdir(), key=lambda path: path.name + ): + if image_path.name.startswith(".") or not image_path.is_file(): + continue + if image_path.suffix.lower() not in _IMAGE_FILE_EXTENSIONS: + continue + image_paths.append(str(image_path)) + annotations[str(image_path)] = Classifications( + class_id=np.array([class_id]), + ) + + return cls( + classes=classes, + images=image_paths, + annotations=annotations, + ) diff --git a/src/supervision/dataset/formats/__init__.py b/src/supervision/dataset/formats/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/src/supervision/dataset/formats/coco.py b/src/supervision/dataset/formats/coco.py new file mode 100644 index 0000000..7cd0be0 --- /dev/null +++ b/src/supervision/dataset/formats/coco.py @@ -0,0 +1,708 @@ +from __future__ import annotations + +import warnings +from datetime import datetime +from pathlib import Path +from typing import TYPE_CHECKING, Any, cast + +import numpy as np +import numpy.typing as npt +from tqdm.auto import tqdm + +from supervision.config import COCO_RAW_SEGMENTATION +from supervision.dataset.utils import ( + approximate_mask_with_polygons, + check_no_basename_collisions, + map_detections_class_id, +) +from supervision.detection.core import Detections +from supervision.detection.utils.converters import ( + mask_to_rle, + polygon_to_mask, + rle_to_mask, +) +from supervision.detection.utils.masks import contains_holes, contains_multiple_segments +from supervision.utils.file import read_json_file, save_json_file + +if TYPE_CHECKING: + from supervision.dataset.core import DetectionDataset + +CocoDict = dict[str, Any] + + +def coco_categories_to_classes(coco_categories: list[CocoDict]) -> list[str]: + return [ + category["name"] + for category in sorted(coco_categories, key=lambda category: category["id"]) + ] + + +def build_coco_class_index_mapping( + coco_categories: list[CocoDict], target_classes: list[str] +) -> dict[int, int]: + source_class_to_index = { + category["name"]: category["id"] for category in coco_categories + } + return { + source_class_to_index[target_class_name]: target_class_index + for target_class_index, target_class_name in enumerate(target_classes) + } + + +def classes_to_coco_categories(classes: list[str]) -> list[CocoDict]: + """Convert a list of class names to COCO ``categories`` entries. + + Category ids are emitted 1-indexed to comply with the COCO specification + and tools such as CVAT, which require ``category_id`` values to start at + ``1``. The id assigned to the class at position ``class_index`` is + ``class_index + 1``, keeping it consistent with the ``category_id`` written + by [`detections_to_coco_annotations`](#detections_to_coco_annotations). + + Args: + classes: Class names ordered by their internal (0-indexed) class id. + + Returns: + A list of COCO category dictionaries with 1-indexed ``id`` values. + + Examples: + ```python + from supervision.dataset.formats.coco import classes_to_coco_categories + + classes_to_coco_categories(classes=["cat", "dog"]) + # [ + # {"id": 1, "name": "cat", "supercategory": "common-objects"}, + # {"id": 2, "name": "dog", "supercategory": "common-objects"}, + # ] + ``` + """ + return [ + { + "id": class_index + 1, + "name": class_name, + "supercategory": "common-objects", + } + for class_index, class_name in enumerate(classes) + ] + + +def group_coco_annotations_by_image_id( + coco_annotations: list[CocoDict], +) -> dict[int, list[CocoDict]]: + annotations: dict[int, list[CocoDict]] = {} + for annotation in coco_annotations: + image_id = annotation["image_id"] + if image_id not in annotations: + annotations[image_id] = [] + annotations[image_id].append(annotation) + return annotations + + +def coco_annotations_to_masks( + image_annotations: list[CocoDict], resolution_wh: tuple[int, int] +) -> npt.NDArray[np.bool_]: + height, width = resolution_wh[1], resolution_wh[0] + empty_mask: npt.NDArray[np.bool_] = np.zeros((height, width), dtype=bool) + masks = [] + + for image_annotation in image_annotations: + segmentation = image_annotation.get("segmentation") + if not segmentation: + # `force_masks=True` may request masks even for bbox-only annotations. + # Keep detection count aligned by emitting an empty mask for that object. + masks.append(empty_mask.copy()) + continue + + if isinstance(segmentation, dict): + if "counts" not in segmentation: + warnings.warn( + "Skipping annotation " + f"{image_annotation.get('id', '?')}: segmentation is a dict but " + "missing 'counts' key (expected RLE format)", + stacklevel=2, + ) + masks.append(empty_mask.copy()) + continue + masks.append( + rle_to_mask(rle=segmentation["counts"], resolution_wh=resolution_wh) + ) + continue + + if not isinstance(segmentation, list): + masks.append(empty_mask.copy()) + continue + polygons = segmentation if isinstance(segmentation[0], list) else [segmentation] + + object_mask = empty_mask.copy() + for polygon in polygons: + polygon_array: npt.NDArray[np.int32] = np.reshape( + np.asarray(polygon, dtype=np.int32), (-1, 2) + ) + if polygon_array.size == 0: + warnings.warn( + "Skipping empty polygon while loading COCO segmentation for " + f"annotation id={image_annotation.get('id')}.", + stacklevel=2, + ) + continue + # COCO polygon segmentation can contain multiple disjoint parts. + # Merge all parts into a single per-object mask. + object_mask |= polygon_to_mask( + polygon=polygon_array, resolution_wh=resolution_wh + ).astype(bool) + + masks.append(object_mask) + + return np.asarray(masks, dtype=bool) + + +def coco_annotations_to_detections( + image_annotations: list[CocoDict], + resolution_wh: tuple[int, int], + with_masks: bool, + use_iscrowd: bool = True, +) -> Detections: + """Convert COCO annotation dicts for a single image into a `Detections` object. + + .. warning:: + The returned ``Detections.class_id`` contains **raw COCO** ``category_id`` + values, not the final 0-indexed internal class ids. Callers **must** pass + the result through :func:`map_detections_class_id` with the appropriate + ``source_to_target_mapping`` (built by + :func:`build_coco_class_index_mapping`) before the ``class_id`` values are + meaningful. Skipping the remap step yields 1-based ids in a field that the + rest of supervision treats as 0-based. + + Args: + image_annotations: List of COCO annotation dicts for one image. + resolution_wh: ``(width, height)`` of the image, used for mask decoding. + with_masks: Whether to decode segmentation fields into binary masks. + use_iscrowd: When ``True``, store ``iscrowd`` and ``area`` in + ``Detections.data``. + + Returns: + Detections with ``class_id`` set to raw COCO ``category_id`` values. + Call :func:`map_detections_class_id` on the result before use. + When ``with_masks=False``, ``detections.data[COCO_RAW_SEGMENTATION]`` is + populated as an object array (shape ``(N,)``) holding the raw polygon list or + RLE dict per annotation; consumed by :func:`detections_to_coco_annotations` + for a coordinate-preserving round-trip. + """ + if not image_annotations: + return Detections.empty() + + class_ids = [ + image_annotation["category_id"] for image_annotation in image_annotations + ] + xyxy_list = [image_annotation["bbox"] for image_annotation in image_annotations] + xyxy: npt.NDArray[np.float32] = np.asarray(xyxy_list, dtype=np.float32) + xyxy[:, 2:4] += xyxy[:, 0:2] + + data: dict[str, npt.NDArray[np.generic] | list[Any]] = {} + if use_iscrowd: + iscrowd = [ + image_annotation.get("iscrowd", 0) for image_annotation in image_annotations + ] + area = [] + for image_annotation in image_annotations: + if "area" in image_annotation: + area.append(image_annotation["area"]) + elif with_masks and _with_seg_mask(image_annotation): + area.append(np.nan) + else: + area.append(image_annotation["bbox"][2] * image_annotation["bbox"][3]) + data = dict( + iscrowd=np.asarray(iscrowd, dtype=int), area=np.asarray(area, dtype=float) + ) + + if with_masks: + mask = coco_annotations_to_masks( + image_annotations=image_annotations, resolution_wh=resolution_wh + ) + else: + mask = None + # Preserve raw polygon/RLE data so as_coco() can round-trip without + # binary-mask encoding. Stored as an object array (one entry per detection). + raw_segs: npt.NDArray[np.object_] = np.empty( + len(image_annotations), dtype=object + ) + for k, _ann in enumerate(image_annotations): + raw_segs[k] = _ann.get("segmentation", []) + data[COCO_RAW_SEGMENTATION] = raw_segs + + return Detections( + class_id=np.asarray(class_ids, dtype=int), xyxy=xyxy, mask=mask, data=data + ) + + +def detections_to_coco_annotations( + detections: Detections, + image_id: int, + annotation_id: int, + min_image_area_percentage: float = 0.0, + max_image_area_percentage: float = 1.0, + approximation_percentage: float = 0.75, +) -> tuple[list[CocoDict], int]: + """Convert `Detections` to COCO ``annotations`` entries. + + The internal 0-indexed ``Detections.class_id`` is serialized as a 1-indexed + COCO ``category_id`` (``category_id = class_id + 1``). This complies with the + COCO specification and tools such as CVAT, and stays consistent with the ids + emitted by [`classes_to_coco_categories`](#classes_to_coco_categories), so a + detection with internal ``class_id=k`` maps to ``category_id=k + 1``. + + Args: + detections: The detections to convert. ``class_id`` must not be ``None``. + image_id: COCO ``image_id`` shared by every produced annotation. + annotation_id: First annotation id to assign; incremented per detection. + min_image_area_percentage: Lower bound on detection area / image area, + used only when approximating masks with polygons. + max_image_area_percentage: Upper bound on detection area / image area, + used only when approximating masks with polygons. + approximation_percentage: Polygon-simplification ratio in ``[0, 1)``. + + Returns: + A ``(coco_annotations, next_annotation_id)`` tuple, where + ``next_annotation_id`` is one greater than the last id assigned. + + Raises: + ValueError: If any detection has ``class_id`` equal to ``None``. + + Note: + For ``iscrowd=0`` annotations, ``segmentation`` is a + ``list[list[float]]`` where each inner list encodes one polygon + part as flat ``[x1, y1, x2, y2, ...]`` coordinates. A single + object with *N* disjoint parts produces *N* inner lists. + + When ``iscrowd`` is not in ``detections.data``, masks with holes + or multiple disjoint segments are auto-encoded as RLE + (``iscrowd=1``); simple single-region masks use polygon format + (``iscrowd=0``). Supply ``data={"iscrowd": np.array([0])}`` to + force polygon output regardless of mask topology. + + Examples: + ```python + import numpy as np + from supervision import Detections + from supervision.dataset.formats.coco import ( + detections_to_coco_annotations, + ) + + detections = Detections( + xyxy=np.array([[0, 0, 10, 10]], dtype=np.float32), + class_id=np.array([0], dtype=int), + ) + annotations, next_id = detections_to_coco_annotations( + detections=detections, image_id=1, annotation_id=1 + ) + annotations[0]["category_id"] + # 1 + ``` + """ + coco_annotations: list[CocoDict] = [] + for xyxy, mask, _, class_id, _, data in detections: + if class_id is None: + raise ValueError("Detections must include class_id for COCO export.") + box_width, box_height = xyxy[2] - xyxy[0], xyxy[3] - xyxy[1] + segmentation: list[list[float]] | dict[str, list[int]] = [] + if mask is not None: + mask_bool = mask + if "iscrowd" in data: + iscrowd = int(np.asarray(data["iscrowd"]).item()) + else: + iscrowd = int( + contains_holes(mask=mask_bool) + or contains_multiple_segments(mask=mask_bool) + ) + + if iscrowd: + segmentation = { + "counts": cast( + list[int], mask_to_rle(mask=mask_bool, compressed=False) + ), + "size": list(mask.shape[:2]), + } + else: + polygons = approximate_mask_with_polygons( + mask=mask_bool, + min_image_area_percentage=min_image_area_percentage, + max_image_area_percentage=max_image_area_percentage, + approximation_percentage=approximation_percentage, + ) + # Small/noisy masks can be filtered out by approximation settings. + # Guard against empty output and keep a valid COCO annotation record. + if polygons: + # Export ALL polygons so disjoint mask components are preserved. + segmentation = [list(p.flatten()) for p in polygons] + else: + warnings.warn( + "Skipping COCO polygon segmentation for annotation " + f"id={annotation_id} because mask approximation " + "returned no polygons.", + stacklevel=2, + ) + else: + iscrowd = int(np.asarray(data.get("iscrowd", 0)).item()) + # When masks were not decoded during loading, fall back to the raw + # polygon/RLE stored in data["segmentation"] for a lossless round-trip. + raw_seg = data.get(COCO_RAW_SEGMENTATION) + if raw_seg is not None and bool(raw_seg): + if isinstance(raw_seg, dict): + # RLE format โ€” pass through unchanged + segmentation = raw_seg + elif ( + isinstance(raw_seg, list) + and raw_seg + and not isinstance(raw_seg[0], (list, tuple)) + ): + # Flat list shorthand [x1,y1,...] โ€” wrap to list-of-lists + segmentation = [list(raw_seg)] + else: + segmentation = list(raw_seg) + + stored_area = None + if "area" in data: + stored_area = float(np.asarray(data["area"]).item()) + + if stored_area is not None and np.isfinite(stored_area): + area = stored_area + elif mask is not None: + area = float(np.count_nonzero(mask)) + else: + area = float(box_width * box_height) + coco_annotation = { + "id": annotation_id, + "image_id": image_id, + "category_id": int(class_id) + 1, + "bbox": [xyxy[0], xyxy[1], box_width, box_height], + "area": area, + "segmentation": segmentation, + "iscrowd": iscrowd, + } + coco_annotations.append(coco_annotation) + annotation_id += 1 + return coco_annotations, annotation_id + + +def get_coco_class_index_mapping(annotations_path: str) -> dict[int, int]: + """ + Generates a mapping from sequential class indices to original COCO class ids. + + This function is essential when working with models that expect class ids to be + zero-indexed and sequential (0 to 79), as opposed to the original COCO + dataset where category ids are non-contiguous ranging from 1 to 90 but skipping some + ids. + + Use Cases: + - Evaluating models trained with COCO-style annotations where class ids + are sequential ranging from 0 to 79. + - Ensuring consistent class indexing across training, inference and evaluation, + when using different tools or datasets with COCO format. + - Reproducing results from models that assume sequential class ids (0 to 79). + + How it Works: + - Reads the COCO annotation file in its original format (`annotations_path`). + - Extracts and sorts all class names by their original COCO id (1 to 90). + - Builds a mapping from COCO class ids (not sequential with skipped ids) to + new class ids (sequential ranging from 0 to 79). + - Returns a dictionary mapping: `{new_class_id: original_COCO_class_id}`. + + Args: + annotations_path: Path to COCO JSON annotations file + (e.g., `instances_val2017.json`). + + Returns: + A mapping from new class id (sequential ranging from 0 to 79) + to original COCO class id (1 to 90 with skipped ids). + + Examples: + >>> import json + >>> import os + >>> import tempfile + >>> from supervision.dataset.formats.coco import get_coco_class_index_mapping + >>> coco_data = { + ... "categories": [ + ... {"id": 1, "name": "person"}, + ... {"id": 3, "name": "car"}, + ... ], + ... "images": [], + ... "annotations": [], + ... } + >>> annotations_path = None + >>> try: + ... with tempfile.NamedTemporaryFile( + ... mode="w", suffix=".json", delete=False + ... ) as f: + ... annotations_path = f.name + ... json.dump(coco_data, f) + ... mapping = get_coco_class_index_mapping(annotations_path) + ... print(mapping) + ... finally: + ... if annotations_path is not None: + ... os.remove(annotations_path) + {0: 1, 1: 3} + >>> os.path.exists(annotations_path) + False + """ + coco_data = read_json_file(annotations_path) + classes = coco_categories_to_classes(coco_categories=coco_data["categories"]) + class_mapping = build_coco_class_index_mapping( + coco_categories=coco_data["categories"], target_classes=classes + ) + return {v: k for k, v in class_mapping.items()} + + +def load_coco_annotations( + images_directory_path: str, + annotations_path: str, + force_masks: bool = False, + use_iscrowd: bool = True, + show_progress: bool = False, +) -> tuple[list[str], list[str], dict[str, Detections]]: + """ + Load COCO annotations and convert them to `Detections`. + + If `force_masks` is `False`, masks are still loaded for images whose annotations + include a `segmentation` field. This keeps mask handling consistent with other + dataset loaders that infer masks from annotation content. + + Args: + images_directory_path: Path to the image directory. + annotations_path: Path to COCO JSON annotations. + force_masks: If `True`, always attempt to load masks. + use_iscrowd: If `True`, include `iscrowd` and `area` in detection data. + show_progress: If `True`, display a progress bar during loading. + + Returns: + A tuple of `(classes, image_paths, annotations)` where image paths are + canonicalized resolved paths inside ``images_directory_path``. + + Raises: + ValueError: If any annotation's ``file_name`` resolves to the images + directory itself, to a path outside the images directory (e.g. via + ``../`` traversal or an absolute path), or to a subdirectory instead + of a regular image file. + ValueError: If two image entries resolve to the same canonical path. + + Note: + Each annotation's ``file_name`` is validated against + ``images_directory_path`` before loading. Annotations that reference + paths outside the directory are rejected to prevent path-traversal + attacks when loading user-supplied annotation files. Symlinked images + pointing outside the resolved images directory are also rejected. + """ + coco_data = read_json_file(file_path=annotations_path) + classes = coco_categories_to_classes(coco_categories=coco_data["categories"]) + + class_index_mapping = build_coco_class_index_mapping( + coco_categories=coco_data["categories"], target_classes=classes + ) + + coco_images = coco_data["images"] + coco_annotations_groups = group_coco_annotations_by_image_id( + coco_annotations=coco_data["annotations"] + ) + + images = [] + annotations = {} + images_directory_resolved = Path(images_directory_path).resolve() + + for coco_image in tqdm( + coco_images, + total=len(coco_images), + desc="Loading COCO annotations", + disable=not show_progress, + ): + image_name, image_width, image_height = ( + coco_image["file_name"], + coco_image["width"], + coco_image["height"], + ) + image_annotations = coco_annotations_groups.get(coco_image["id"], []) + image_path = str(Path(images_directory_path) / Path(image_name)) + try: + resolved_image_path = Path(image_path).resolve() + except (OSError, ValueError) as exc: + raise ValueError( + f"COCO annotation refers to image {image_name!r}, which " + f"produces an invalid path: {exc}" + ) from exc + if resolved_image_path == images_directory_resolved: + raise ValueError( + f"COCO annotation refers to image {image_name!r}, which " + f"resolves to the images directory itself " + f"({images_directory_resolved}). Expected a path to an " + "image file." + ) + if images_directory_resolved not in resolved_image_path.parents: + raise ValueError( + f"COCO annotation refers to image {image_name!r}, which " + f"resolves to {resolved_image_path} โ€” outside the images " + f"directory {images_directory_resolved}." + ) + if resolved_image_path.is_dir(): + raise ValueError( + f"COCO annotation refers to image {image_name!r}, which " + f"resolves to directory {resolved_image_path}. Expected a " + "path to an image file." + ) + image_path = str(resolved_image_path) + if image_path in annotations: + raise ValueError( + f"COCO annotation file contains duplicate entries for image " + f"{image_name!r}. Each image must appear at most once." + ) + + with_masks = force_masks or any( + _with_seg_mask(annotation) for annotation in image_annotations + ) + annotation = coco_annotations_to_detections( + image_annotations=image_annotations, + resolution_wh=(image_width, image_height), + with_masks=with_masks, + use_iscrowd=use_iscrowd, + ) + + annotation = map_detections_class_id( + source_to_target_mapping=class_index_mapping, + detections=annotation, + ) + + images.append(image_path) + annotations[image_path] = annotation + + return classes, images, annotations + + +def _with_seg_mask(annotation: dict[str, Any]) -> bool: + return bool(annotation.get("segmentation")) + + +def save_coco_annotations( + dataset: DetectionDataset, + annotation_path: str, + min_image_area_percentage: float = 0.0, + max_image_area_percentage: float = 1.0, + approximation_percentage: float = 0.0, + starting_image_id: int = 1, + starting_annotation_id: int = 1, + show_progress: bool = False, +) -> tuple[int, int]: + """Save a DetectionDataset to a COCO-format ``annotations.json`` file. + + Args: + dataset: The DetectionDataset to write. + annotation_path: Output path for the COCO ``annotations.json``. + min_image_area_percentage: Lower bound on detection area / image area; + used only for segmentation datasets. + max_image_area_percentage: Upper bound on detection area / image area; + used only for segmentation datasets. + approximation_percentage: Polygon-simplification ratio in ``[0, 1)``; + used only for segmentation datasets. + starting_image_id: First image id to assign in the exported file. + Defaults to ``1``. Override when exporting multiple splits into + a coordinated COCO collection so ids remain unique across the set. + starting_annotation_id: First annotation id to assign in the exported + file. Defaults to ``1``. Override for the same multi-split reason + as ``starting_image_id``. + show_progress: If ``True``, display a progress bar during saving. + + Returns: + A ``(next_image_id, next_annotation_id)`` tuple. The returned values + are one greater than the highest ids written, so they can be fed + directly back into ``starting_image_id`` and ``starting_annotation_id`` + when exporting another split into a coordinated COCO collection + (see ``DetectionDataset.as_coco`` for the chaining pattern). When the + dataset is empty the starting ids are returned unchanged. + + .. note:: + This function ensures globally unique integer ``id`` values across + splits. It rejects duplicate image basenames before writing because + ``file_name`` is set to the bare image basename, so two input paths + that differ only by directory would otherwise collapse to the same + COCO image record. + + Raises: + ValueError: If two image paths share the same basename and would map to + the same COCO ``file_name``. + + Example: + ```python + import supervision as sv + from supervision.dataset.formats.coco import save_coco_annotations + + ds = sv.DetectionDataset.from_yolo( + images_directory_path="train/images", + annotations_directory_path="train/labels", + data_yaml_path="data.yaml", + ) + next_img_id, next_ann_id = save_coco_annotations( + dataset=ds, annotation_path="out/train/annotations.json" + ) + # next_img_id and next_ann_id are the first unused ids โ€” pass them + # to the next split to keep ids globally unique across files. + ``` + """ + if starting_image_id < 1 or starting_annotation_id < 1: + raise ValueError( + "starting_image_id and starting_annotation_id must be >= 1 " + "(COCO spec requires 1-indexed ids); " + f"got {starting_image_id=}, {starting_annotation_id=}" + ) + check_no_basename_collisions( + image_paths=dataset.image_paths, + key=lambda image_path: Path(image_path).name, + output_kind="COCO image", + ) + Path(annotation_path).parent.mkdir(parents=True, exist_ok=True) + licenses = [ + { + "id": 1, + "url": "https://creativecommons.org/licenses/by/4.0/", + "name": "CC BY 4.0", + } + ] + + coco_annotations = [] + coco_images = [] + coco_categories = classes_to_coco_categories(classes=dataset.classes) + + image_id, annotation_id = starting_image_id, starting_annotation_id + for image_path, image, annotation in tqdm( + dataset, + total=len(dataset), + desc="Saving COCO annotations", + disable=not show_progress, + ): + image_height, image_width, _ = image.shape + image_name = f"{Path(image_path).stem}{Path(image_path).suffix}" + coco_image = { + "id": image_id, + "license": 1, + "file_name": image_name, + "height": image_height, + "width": image_width, + "date_captured": datetime.now().strftime("%m/%d/%Y,%H:%M:%S"), + } + + coco_images.append(coco_image) + coco_annotation, annotation_id = detections_to_coco_annotations( + detections=annotation, + image_id=image_id, + annotation_id=annotation_id, + min_image_area_percentage=min_image_area_percentage, + max_image_area_percentage=max_image_area_percentage, + approximation_percentage=approximation_percentage, + ) + + coco_annotations.extend(coco_annotation) + image_id += 1 + + annotation_dict = { + "info": {}, + "licenses": licenses, + "categories": coco_categories, + "images": coco_images, + "annotations": coco_annotations, + } + save_json_file(annotation_dict, file_path=annotation_path) + return image_id, annotation_id diff --git a/src/supervision/dataset/formats/createml.py b/src/supervision/dataset/formats/createml.py new file mode 100644 index 0000000..84b939e --- /dev/null +++ b/src/supervision/dataset/formats/createml.py @@ -0,0 +1,331 @@ +from __future__ import annotations + +from pathlib import Path +from typing import TYPE_CHECKING, Any, cast + +import numpy as np +from tqdm.auto import tqdm + +from supervision.dataset.utils import check_no_basename_collisions +from supervision.detection.core import Detections +from supervision.utils.file import read_json_file, save_json_file + +if TYPE_CHECKING: + from supervision.dataset.core import DetectionDataset + +CreateMLDict = dict[str, Any] + + +def _resolve_image_path(images_directory_path: str, image_name: str) -> str: + """Resolve and validate an image path against the images directory. + + Rejects annotations whose ``image`` field escapes ``images_directory_path`` + (via ``..`` traversal, an absolute path, or a symlink pointing outside), + mirroring the protection used by the COCO loader. Returns the canonical + resolved path so aliases collapse to a single dataset entry. + """ + images_directory_resolved = Path(images_directory_path).resolve() + image_path = Path(images_directory_path) / Path(image_name) + try: + resolved_image_path = image_path.resolve() + except (OSError, ValueError) as exc: + raise ValueError( + f"CreateML annotation refers to image {image_name!r}, which " + f"produces an invalid path: {exc}" + ) from exc + if resolved_image_path == images_directory_resolved: + raise ValueError( + f"CreateML annotation refers to image {image_name!r}, which " + f"resolves to the images directory itself " + f"({images_directory_resolved}). Expected a path to an image file." + ) + if images_directory_resolved not in resolved_image_path.parents: + raise ValueError( + f"CreateML annotation refers to image {image_name!r}, which " + f"resolves to {resolved_image_path} โ€” outside the images " + f"directory {images_directory_resolved}." + ) + if resolved_image_path.is_dir(): + raise ValueError( + f"CreateML annotation refers to image {image_name!r}, which " + f"resolves to directory {resolved_image_path}. Expected a path " + "to an image file." + ) + return str(resolved_image_path) + + +def createml_annotations_to_detections( + image_annotations: list[CreateMLDict], class_to_index: dict[str, int] +) -> Detections: + """Convert a single image's CreateML annotations into ``Detections``. + + CreateML stores each box as a pixel-space centre point plus width/height + (``{"x", "y", "width", "height"}``); they are converted to ``xyxy`` corners. + + Args: + image_annotations: List of annotation dicts for one image, each containing + a ``"label"`` key and a ``"coordinates"`` dict with ``"x"``, ``"y"``, + ``"width"``, and ``"height"`` keys. + class_to_index: Mapping from class name to zero-based integer id. + + Returns: + A ``Detections`` instance with ``xyxy`` boxes and ``class_id`` set. + Returns ``Detections.empty()`` when ``image_annotations`` is empty. + + Raises: + ValueError: If an annotation is missing required keys (``"coordinates"``, + ``"label"``, or any coordinate sub-key), or if a coordinate value + cannot be converted to float. + + Examples: + ```python + import supervision as sv + from supervision.dataset.formats.createml import ( + createml_annotations_to_detections, + ) + + annotations = [ + { + "label": "dog", + "coordinates": {"x": 50, "y": 50, "width": 20, "height": 20}, + } + ] + detections = createml_annotations_to_detections(annotations, {"dog": 0}) + # detections.xyxy โ†’ [[40, 40, 60, 60]] + ``` + """ + if not image_annotations: + return Detections.empty() + + xyxy = [] + class_ids = [] + for annotation in image_annotations: + try: + coordinates = annotation["coordinates"] + x_center = float(coordinates["x"]) + y_center = float(coordinates["y"]) + width = float(coordinates["width"]) + height = float(coordinates["height"]) + label = annotation["label"] + except (KeyError, TypeError) as exc: + raise ValueError( + f"Malformed CreateML annotation entry {annotation!r}: {exc}" + ) from exc + xyxy.append( + [ + x_center - width / 2, + y_center - height / 2, + x_center + width / 2, + y_center + height / 2, + ] + ) + class_ids.append(class_to_index[label]) + + return Detections( + xyxy=np.array(xyxy, dtype=np.float32), + class_id=np.array(class_ids, dtype=int), + ) + + +def load_createml_annotations( + images_directory_path: str, + annotations_path: str, + show_progress: bool = False, +) -> tuple[list[str], list[str], dict[str, Detections]]: + """Load CreateML object-detection annotations and convert them to ``Detections``. + + CreateML uses a single JSON file containing a list of per-image entries, each + holding axis-aligned bounding boxes. Class names are inferred from the labels + present in the file and assigned stable, sorted, zero-based ids. Because the + format has no explicit category list, a class with no boxes anywhere in the + file will not appear in the returned ``classes``. + + Args: + images_directory_path: Path to the directory containing the images. + annotations_path: Path to the CreateML JSON annotation file. + show_progress: If ``True``, display a tqdm progress bar while loading + annotations. + + Returns: + A tuple of three elements: + + - ``classes`` (``list[str]``): globally sorted class names inferred from + all labels present in the file. + - ``image_paths`` (``list[str]``): canonical resolved path for every + entry in the JSON, in file order. + - ``annotations`` (``dict[str, Detections]``): mapping from canonical + resolved image path to its ``Detections``. + + Raises: + ValueError: If the JSON root is not a list. + ValueError: If an entry is missing the required ``"image"`` key. + ValueError: If an annotation is missing required coordinate or label keys. + ValueError: If two entries resolve to the same image path. + ValueError: If an annotation's ``image`` field resolves to the images + directory itself or to a path outside it (e.g. via ``..`` traversal + or an absolute path). + """ + createml_data = cast( + "list[CreateMLDict]", read_json_file(file_path=annotations_path) + ) + if not isinstance(createml_data, list): + raise ValueError( + f"CreateML annotation file must contain a JSON list at the root, " + f"got {type(createml_data).__name__}." + ) + + try: + classes = sorted( + { + annotation["label"] + for entry in createml_data + for annotation in (entry.get("annotations") or []) + } + ) + except (KeyError, TypeError) as exc: + raise ValueError( + f"Malformed CreateML annotation entry " + f"(missing or non-string 'label'): {exc}" + ) from exc + class_to_index = {class_name: index for index, class_name in enumerate(classes)} + + image_paths: list[str] = [] + annotations: dict[str, Detections] = {} + for entry in tqdm( + createml_data, + desc="Loading CreateML annotations", + disable=not show_progress, + ): + image_name = entry.get("image") + if image_name is None: + raise ValueError( + f"CreateML annotation entry is missing the required 'image' key: " + f"{entry!r}" + ) + image_path = _resolve_image_path( + images_directory_path=images_directory_path, image_name=image_name + ) + if image_path in annotations: + raise ValueError( + f"CreateML annotation file contains duplicate entries for image " + f"{image_name!r}. Each image must appear at most once." + ) + annotations[image_path] = createml_annotations_to_detections( + image_annotations=entry.get("annotations") or [], + class_to_index=class_to_index, + ) + image_paths.append(image_path) + + return classes, image_paths, annotations + + +def detections_to_createml_annotations( + detections: Detections, classes: list[str] +) -> list[CreateMLDict]: + """Convert ``Detections`` into a list of CreateML annotation dicts. + + Each bounding box is stored as a pixel-space centre point plus width and + height, which is the CreateML object-detection convention. + + Args: + detections: The detections to convert. ``class_id`` must not be ``None``. + classes: Ordered list of class names; ``detections.class_id`` values are + used as indices into this list. + + Returns: + A list of dicts, each with a ``"label"`` key (class name) and a + ``"coordinates"`` dict containing ``"x"``, ``"y"``, ``"width"``, and + ``"height"`` in pixel space. + + Raises: + ValueError: If ``detections.class_id`` is ``None``. + + Examples: + ```python + import numpy as np + import supervision as sv + from supervision.dataset.formats.createml import ( + detections_to_createml_annotations, + ) + + detections = sv.Detections( + xyxy=np.array([[40, 40, 60, 60]], dtype=np.float32), + class_id=np.array([0], dtype=int), + ) + detections_to_createml_annotations(detections, classes=["dog"]) + # [{"label": "dog", "coordinates": {"x": 50.0, "y": 50.0, ...}}] + ``` + """ + class_ids = detections.class_id + if class_ids is None: + raise ValueError( + "class_id is required for CreateML export, but the provided " + "Detections has class_id=None." + ) + annotations: list[CreateMLDict] = [] + for xyxy, class_id in zip(detections.xyxy, class_ids): + x_min, y_min, x_max, y_max = (float(value) for value in xyxy) + annotations.append( + { + "label": classes[int(class_id)], + "coordinates": { + "x": (x_min + x_max) / 2, + "y": (y_min + y_max) / 2, + "width": x_max - x_min, + "height": y_max - y_min, + }, + } + ) + return annotations + + +def save_createml_annotations( + dataset: DetectionDataset, + annotations_path: str, +) -> None: + """Export a ``DetectionDataset`` to a CreateML object-detection JSON file. + + Only the filename component of each image path is stored in the JSON (e.g. + ``"img.jpg"`` rather than ``"/data/train/img.jpg"``). This matches CreateML + convention and means the loader reconstructs paths relative to + ``images_directory_path``. As a consequence, two images with the same + basename from different directories would collapse to the same ``"image"`` + key, so the exporter rejects that case before writing. + + Args: + dataset: The ``DetectionDataset`` to write. + annotations_path: Output path for the CreateML JSON file. Parent + directories are created if they do not already exist. + + Raises: + ValueError: If two image paths share the same basename and would map to + the same CreateML ``image`` entry. + + Examples: + ```python + import supervision as sv + from supervision.dataset.formats.createml import save_createml_annotations + + dataset = sv.DetectionDataset(classes=["dog"], images=[], annotations={}) + save_createml_annotations(dataset, "/tmp/annotations.json") + ``` + """ + check_no_basename_collisions( + image_paths=dataset.image_paths, + key=lambda image_path: Path(image_path).name, + output_kind="CreateML image", + ) + Path(annotations_path).parent.mkdir(parents=True, exist_ok=True) + createml_data: list[CreateMLDict] = [ + { + "image": Path(image_path).name, + "annotations": detections_to_createml_annotations( + detections=dataset.annotations[image_path], classes=dataset.classes + ), + } + for image_path in dataset.image_paths + ] + save_json_file( + data=createml_data, # type: ignore[arg-type] # save_json_file accepts list at runtime + file_path=annotations_path, + ) diff --git a/src/supervision/dataset/formats/labelme.py b/src/supervision/dataset/formats/labelme.py new file mode 100644 index 0000000..b34570c --- /dev/null +++ b/src/supervision/dataset/formats/labelme.py @@ -0,0 +1,405 @@ +from __future__ import annotations + +import warnings +from pathlib import Path +from typing import TYPE_CHECKING, Any + +import numpy as np +import numpy.typing as npt + +from supervision.dataset.utils import check_no_basename_collisions +from supervision.detection.core import Detections +from supervision.detection.utils.converters import ( + mask_to_polygons, + polygon_to_mask, + polygon_to_xyxy, +) +from supervision.utils.file import ( + list_files_with_extensions, + read_json_file, + save_json_file, +) + +if TYPE_CHECKING: + from supervision.dataset.core import DetectionDataset + +LabelMeDict = dict[str, Any] +# Written to every exported JSON; never read back on import. +_LABELME_EXPORT_VERSION = "5.5.0" +SUPPORTED_SHAPE_TYPES = ("rectangle", "polygon") + +__all__ = [ + "detections_to_labelme_shapes", + "labelme_shapes_to_detections", + "load_labelme_annotations", + "save_labelme_annotations", +] + + +def _rectangle_to_xyxy(points: npt.NDArray[np.float32]) -> npt.NDArray[np.float32]: + x_coordinates = points[:, 0] + y_coordinates = points[:, 1] + return np.array( + [ + float(x_coordinates.min()), + float(y_coordinates.min()), + float(x_coordinates.max()), + float(y_coordinates.max()), + ], + dtype=np.float32, + ) + + +def _xyxy_to_polygon(xyxy: npt.NDArray[np.float32]) -> npt.NDArray[np.float32]: + x_min, y_min, x_max, y_max = (float(value) for value in xyxy) + return np.array( + [[x_min, y_min], [x_max, y_min], [x_max, y_max], [x_min, y_max]], + dtype=np.float32, + ) + + +def labelme_shapes_to_detections( + shapes: list[LabelMeDict], + class_to_index: dict[str, int], + resolution_wh: tuple[int, int], + with_masks: bool, +) -> Detections: + """Convert a single image's LabelMe shapes into ``Detections``. + + Only ``rectangle`` and ``polygon`` shapes are imported; other shape types + (``circle``, ``line``, ``point``, ``linestrip``) are skipped with a warning. + When ``with_masks`` is ``True``, both ``rectangle`` and ``polygon`` shapes + produce masks: rectangles via a four-corner polygon fill. + + Args: + shapes: List of LabelMe shape dicts for one image. + class_to_index: Mapping from class name to integer class ID. + resolution_wh: Image ``(width, height)`` used to rasterise masks. + with_masks: If ``True``, produce a binary mask for every detection. + + Returns: + A :class:`Detections` instance with ``xyxy``, ``class_id``, and + optionally ``mask`` populated. + + Raises: + ValueError: If a shape is missing its ``label`` or ``points`` field, + if a ``polygon`` has fewer than 3 points, or a ``rectangle`` has + fewer than 2 points. + + Warns: + UserWarning: When unsupported shape types are encountered and skipped. + """ + xyxy_list: list[npt.NDArray[np.float32]] = [] + class_ids: list[int] = [] + polygons: list[npt.NDArray[np.float32]] = [] + skipped_types: set[str] = set() + + for shape in shapes: + shape_type = shape.get("shape_type") + if shape_type not in SUPPORTED_SHAPE_TYPES: + skipped_types.add(str(shape_type)) + continue + label = shape.get("label") + points_raw = shape.get("points") + if label is None or points_raw is None: + missing = "label" if label is None else "points" + raise ValueError( + f"LabelMe shape of type {shape_type!r} is missing the " + f"required {missing!r} field." + ) + points = np.array(points_raw, dtype=np.float32) + if points.ndim != 2 or points.shape[1] != 2: + raise ValueError( + f"LabelMe shape of type {shape_type!r} (label={label!r}) has " + f"malformed points: expected an (N, 2) array, got shape " + f"{points.shape}." + ) + if shape_type == "rectangle": + if len(points) < 2: + raise ValueError( + f"LabelMe rectangle shape (label={label!r}) has " + f"{len(points)} point(s); expected at least 2." + ) + xyxy = _rectangle_to_xyxy(points) + polygon = _xyxy_to_polygon(xyxy) + else: + if len(points) < 3: + raise ValueError( + f"LabelMe polygon shape (label={label!r}) has " + f"{len(points)} point(s); expected at least 3." + ) + xyxy = polygon_to_xyxy(polygon=points).astype(np.float32) + polygon = points + xyxy_list.append(xyxy) + class_ids.append(class_to_index[label]) + if with_masks: + polygons.append(polygon) + + if skipped_types: + warnings.warn( + f"Skipped unsupported LabelMe shape type(s) {sorted(skipped_types)}; " + f"only {list(SUPPORTED_SHAPE_TYPES)} are imported.", + UserWarning, + stacklevel=2, + ) + + if not xyxy_list: + return Detections.empty() + + xyxy = np.array(xyxy_list, dtype=np.float32) + class_id = np.array(class_ids, dtype=int) + if not with_masks: + return Detections(xyxy=xyxy, class_id=class_id) + + mask = np.array( + [ + polygon_to_mask( + polygon=np.round(polygon).astype(np.int32), + resolution_wh=resolution_wh, + ) + for polygon in polygons + ], + dtype=bool, + ) + return Detections(xyxy=xyxy, class_id=class_id, mask=mask) + + +def load_labelme_annotations( + images_directory_path: str, + annotations_directory_path: str, + force_masks: bool = False, +) -> tuple[list[str], list[str], dict[str, Detections]]: + """Load LabelMe annotations and convert them to ``Detections``. + + LabelMe stores one JSON file per image, each containing a list of ``shapes``. + ``rectangle`` shapes become bounding boxes; ``polygon`` shapes become masks + (and their bounding boxes); other shape types are skipped with a warning. + When any polygon is present in a file or when ``force_masks`` is ``True``, + both ``rectangle`` and ``polygon`` shapes produce masks: rectangles via a + four-corner polygon fill. Class names are inferred from the labels present + across all files and assigned sorted, zero-based ids. + + Each image is located by the basename of the JSON's ``imagePath`` joined to + ``images_directory_path``; the directory portion of ``imagePath`` (which + LabelMe stores relative to the JSON file) is ignored, so annotation-supplied + path traversal cannot escape ``images_directory_path``. + + Args: + images_directory_path: Path to the directory containing the images. + annotations_directory_path: Path to the directory containing the LabelMe + ``.json`` files. + force_masks: If ``True``, load masks for every image regardless of + whether it contains polygon shapes. + + Returns: + A tuple of ``(classes, image_paths, annotations)``. + + Raises: + ValueError: If an annotation's ``imagePath`` is missing, empty, or + resolves to ``..`` or ``.``; if two annotation files reference the + same image basename; or if a polygon mask is requested for a file + missing ``imageWidth`` / ``imageHeight``. + + Examples: + ```python + from supervision.dataset.formats.labelme import load_labelme_annotations + + classes, image_paths, annotations = load_labelme_annotations( + images_directory_path="", + annotations_directory_path="", + ) + + classes + # ['dog', 'person'] + ``` + """ + annotation_paths = sorted( + str(path) + for path in list_files_with_extensions( + directory=annotations_directory_path, extensions=["json"] + ) + ) + + # Two-pass design (collect all class labels first, then assign IDs) requires + # materialising all annotation dicts upfront. + entries: list[LabelMeDict] = [ + read_json_file(file_path=annotation_path) + for annotation_path in annotation_paths + ] + + classes = sorted( + { + shape.get("label") + for entry in entries + for shape in entry.get("shapes", []) + if shape.get("shape_type") in SUPPORTED_SHAPE_TYPES + } + - {None} + ) + class_to_index = {class_name: index for index, class_name in enumerate(classes)} + + image_paths: list[str] = [] + annotations: dict[str, Detections] = {} + for entry in entries: + shapes = entry.get("shapes", []) + raw_image_path = entry.get("imagePath") + if not raw_image_path: + raise ValueError( + "A LabelMe annotation file is missing the required " + "'imagePath' field or it is empty." + ) + # ponytail: basename-only, no symlink resolution โ€” images_directory_path + # is trusted; annotation-driven traversal is neutralised by .name. + # See createml._resolve_image_path for the full .resolve()+parents pattern. + image_name = Path(raw_image_path).name + if not image_name or image_name in ("..", "."): + raise ValueError( + f"LabelMe annotation has an invalid 'imagePath' {raw_image_path!r}." + ) + image_path = str(Path(images_directory_path) / image_name) + if image_path in annotations: + raise ValueError( + f"Duplicate image basename {image_name!r} resolved from multiple " + "annotation files. All annotation files must reference unique " + "image basenames." + ) + with_masks = force_masks or any( + shape.get("shape_type") == "polygon" for shape in shapes + ) + if with_masks and not (entry.get("imageWidth") and entry.get("imageHeight")): + raise ValueError( + f"LabelMe annotation for {image_name!r} requires " + "'imageWidth' and 'imageHeight' to build masks, but they are " + "missing or zero." + ) + resolution_wh = ( + int(entry.get("imageWidth", 0)), + int(entry.get("imageHeight", 0)), + ) + annotations[image_path] = labelme_shapes_to_detections( + shapes=shapes, + class_to_index=class_to_index, + resolution_wh=resolution_wh, + with_masks=with_masks, + ) + image_paths.append(image_path) + + return classes, image_paths, annotations + + +def _build_shape(label: str, points: list[list[float]], shape_type: str) -> LabelMeDict: + return { + "label": label, + "points": points, + "group_id": None, + "description": "", + "shape_type": shape_type, + "flags": {}, + } + + +def detections_to_labelme_shapes( + detections: Detections, classes: list[str] +) -> list[LabelMeDict]: + """Convert ``Detections`` into a list of LabelMe shape dicts. + + Masked detections are exported as ``polygon`` shapes (one per connected + component); box-only detections โ€” and masked detections whose mask yields no + polygon contour (e.g. an empty or sub-pixel mask) โ€” are exported as + ``rectangle`` shapes, so no detection is silently dropped. + + Args: + detections: The detections to export. + classes: List of class names indexed by ``class_id``. + + Returns: + A list of LabelMe shape dicts ready to embed in a ``.json`` annotation. + + Raises: + ValueError: If ``detections.class_id`` is ``None`` or if any + ``class_id`` value is out of range for ``classes``. + """ + class_ids = detections.class_id + if class_ids is None: + raise ValueError( + "class_id is required for LabelMe export, but the provided " + "Detections has class_id=None." + ) + masks = detections.mask + shapes: list[LabelMeDict] = [] + for index in range(len(detections)): + class_index = int(class_ids[index]) + if class_index < 0 or class_index >= len(classes): + raise ValueError( + f"class_id {class_index} at detection index {index} is out of " + f"range for classes list of length {len(classes)}." + ) + label = classes[class_index] + if masks is not None: + mask_arr = np.asarray(masks[index], dtype=np.bool_) + polygons = mask_to_polygons(mask_arr) + else: + polygons = [] + if polygons: + for polygon in polygons: + points = [[float(x), float(y)] for x, y in polygon] + shapes.append(_build_shape(label, points, "polygon")) + else: + x_min, y_min, x_max, y_max = ( + float(value) for value in detections.xyxy[index] + ) + points = [[x_min, y_min], [x_max, y_max]] + shapes.append(_build_shape(label, points, "rectangle")) + return shapes + + +def save_labelme_annotations( + dataset: DetectionDataset, + annotations_directory_path: str, +) -> None: + """Export a ``DetectionDataset`` to per-image LabelMe ``.json`` files. + + Args: + dataset: The ``DetectionDataset`` to write. + annotations_directory_path: Directory where the LabelMe ``.json`` files + are written (created if it does not exist). + + Raises: + ValueError: If two image paths map to the same output .json stem, + which would cause one annotation file to overwrite another. + + Examples: + ```python + import supervision as sv + from supervision.dataset.formats.labelme import save_labelme_annotations + + dataset = sv.DetectionDataset(classes=["dog"], images=[], annotations={}) + save_labelme_annotations( + dataset=dataset, + annotations_directory_path="", + ) + ``` + """ + check_no_basename_collisions( + image_paths=dataset.image_paths, + key=lambda image_path: f"{Path(image_path).stem}.json", + output_kind="LabelMe annotation", + ) + Path(annotations_directory_path).mkdir(parents=True, exist_ok=True) + for image_path, image, detections in dataset: + image_height, image_width, _ = image.shape + labelme_dict: LabelMeDict = { + "version": _LABELME_EXPORT_VERSION, + "flags": {}, + "shapes": detections_to_labelme_shapes( + detections=detections, classes=dataset.classes + ), + "imagePath": Path(image_path).name, + "imageData": None, + "imageHeight": int(image_height), + "imageWidth": int(image_width), + } + annotation_path = ( + Path(annotations_directory_path) / f"{Path(image_path).stem}.json" + ) + save_json_file(data=labelme_dict, file_path=str(annotation_path)) diff --git a/src/supervision/dataset/formats/pascal_voc.py b/src/supervision/dataset/formats/pascal_voc.py new file mode 100644 index 0000000..771a97f --- /dev/null +++ b/src/supervision/dataset/formats/pascal_voc.py @@ -0,0 +1,449 @@ +import os +from pathlib import Path +from typing import TYPE_CHECKING +from xml.etree.ElementTree import Element, SubElement + +if TYPE_CHECKING: + from supervision.dataset.core import DetectionDataset + +import cv2 +import numpy as np +import numpy.typing as npt +from defusedxml.ElementTree import parse, tostring +from defusedxml.minidom import parseString +from tqdm.auto import tqdm + +from supervision.dataset.utils import ( + approximate_mask_with_polygons, + check_no_basename_collisions, +) +from supervision.detection.core import Detections +from supervision.detection.utils.converters import polygon_to_mask, polygon_to_xyxy +from supervision.utils.file import list_files_with_extensions + + +def object_to_pascal_voc( + xyxy: npt.NDArray[np.number], + name: str, + polygon: npt.NDArray[np.number] | None = None, +) -> Element: + """Build a Pascal VOC ```` XML element for one detection. + + Coordinates are converted to 1-indexed Pascal VOC convention before writing. + The input arrays are never mutated; new arrays are allocated for the offset. + + Args: + xyxy: Bounding box in zero-indexed pixel coordinates ``[x1, y1, x2, y2]``. + Shape ``(4,)``. + name: Class label string written to the ```` child element. + polygon: Optional segmentation polygon in zero-indexed pixel coordinates. + Shape ``(N, 2)``. + + Returns: + An XML ``Element`` rooted at ```` containing ````, + ````, and optionally ```` children. + + Examples: + >>> import numpy as np + >>> from supervision.dataset.formats.pascal_voc import object_to_pascal_voc + >>> elem = object_to_pascal_voc(np.array([0, 0, 9, 9]), name="cat") + >>> elem.find("bndbox/xmin").text + '1' + >>> elem.find("bndbox/xmax").text + '10' + """ + root = Element("object") + + object_name = SubElement(root, "name") + object_name.text = name + + # Pascal VOC coordinates are 1-indexed (https://github.com/roboflow/supervision/issues/144). + # Rebind to a new array instead of `+= 1`: `xyxy` is a view into the source + # `Detections.xyxy` (yielded by `Detections.__iter__`), so an in-place add + # would corrupt the caller's detections by +1 on every export. + xyxy = xyxy + 1 + + bndbox = SubElement(root, "bndbox") + xmin = SubElement(bndbox, "xmin") + xmin.text = str(int(xyxy[0])) + ymin = SubElement(bndbox, "ymin") + ymin.text = str(int(xyxy[1])) + xmax = SubElement(bndbox, "xmax") + xmax.text = str(int(xyxy[2])) + ymax = SubElement(bndbox, "ymax") + ymax.text = str(int(xyxy[3])) + + if polygon is not None: + # 1-indexed, rebound to avoid mutating the caller's array (see above). + polygon = polygon + 1 + object_polygon = SubElement(root, "polygon") + for index, point in enumerate(polygon, start=1): + x_coordinate, y_coordinate = point + x = SubElement(object_polygon, f"x{index}") + x.text = str(x_coordinate) + y = SubElement(object_polygon, f"y{index}") + y.text = str(y_coordinate) + + return root + + +def detections_to_pascal_voc( + detections: Detections, + classes: list[str], + filename: str, + image_shape: tuple[int, int, int], + min_image_area_percentage: float = 0.0, + max_image_area_percentage: float = 1.0, + approximation_percentage: float = 0.75, +) -> str: + """ + Converts Detections object to Pascal VOC XML format. + + Args: + detections: A Detections object containing bounding boxes, + class ids, and other relevant information. + classes: A list of class names corresponding to the + class ids in the Detections object. + filename: The name of the image file associated with the detections. + image_shape: The shape of the image + file associated with the detections. + min_image_area_percentage: Minimum detection area + relative to area of image associated with it. + max_image_area_percentage: Maximum detection area + relative to area of image associated with it. + approximation_percentage: The percentage of + polygon points to be removed from the input polygon, in the range [0, 1). + Returns: + An XML string in Pascal VOC format representing the detections. + + Note: + ``detections`` is never mutated by this function; the source ``xyxy`` + array is unchanged after the call. The function is therefore safe to + call multiple times on the same ``Detections`` object. + """ + height, width, depth = image_shape + + # Create root element + annotation = Element("annotation") + + # Add folder element + folder = SubElement(annotation, "folder") + folder.text = "VOC" + + # Add filename element + file_name = SubElement(annotation, "filename") + file_name.text = filename + + # Add source element + source = SubElement(annotation, "source") + database = SubElement(source, "database") + database.text = "roboflow.ai" + + # Add size element + size = SubElement(annotation, "size") + w = SubElement(size, "width") + w.text = str(width) + h = SubElement(size, "height") + h.text = str(height) + d = SubElement(size, "depth") + d.text = str(depth) + + # Add segmented element + segmented = SubElement(annotation, "segmented") + segmented.text = "0" + + # Add object elements + for xyxy, mask, _, class_id, _, _ in detections: + if class_id is None: + raise ValueError("Detections must include class_id for Pascal VOC export.") + if not isinstance(class_id, (int, np.integer)): + raise ValueError( + f"Detections class_id must be an integer for Pascal VOC export, " + f"got {type(class_id)!r}." + ) + name = classes[class_id] + if mask is not None: + polygons = approximate_mask_with_polygons( + mask=mask, + min_image_area_percentage=min_image_area_percentage, + max_image_area_percentage=max_image_area_percentage, + approximation_percentage=approximation_percentage, + ) + for polygon in polygons: + xyxy = polygon_to_xyxy(polygon=polygon) + next_object = object_to_pascal_voc( + xyxy=xyxy, name=name, polygon=polygon + ) + annotation.append(next_object) + else: + next_object = object_to_pascal_voc(xyxy=xyxy, name=name) + annotation.append(next_object) + + # Generate XML string + xml_string = str( + parseString(tostring(annotation).decode("utf-8")).toprettyxml(indent=" ") + ) + return xml_string + + +def load_pascal_voc_annotations( + images_directory_path: str, + annotations_directory_path: str, + force_masks: bool = False, + show_progress: bool = False, +) -> tuple[list[str], list[str], dict[str, Detections]]: + """ + Load Pascal VOC XML annotations in sorted image-path order. + + Args: + images_directory_path: The path to the directory containing the images. + annotations_directory_path: The path to the directory containing the + PASCAL VOC annotation files. + force_masks: If True, forces masks to be loaded for all + annotations, regardless of whether they are present. + show_progress: If True, display a progress bar during loading. + + Returns: + A tuple with a list of class names, a sorted list of paths to images, + and a dictionary with image paths as keys and corresponding + Detections instances as values. + """ + + image_paths = sorted( + str(path) + for path in list_files_with_extensions( + directory=images_directory_path, extensions=["jpg", "jpeg", "png"] + ) + ) + + classes: list[str] = [] + annotations = {} + + for image_path in tqdm( + image_paths, + total=len(image_paths), + desc="Loading Pascal VOC annotations", + disable=not show_progress, + ): + image_stem = Path(image_path).stem + annotation_path = os.path.join(annotations_directory_path, f"{image_stem}.xml") + if not os.path.exists(annotation_path): + annotations[image_path] = Detections.empty() + continue + + tree = parse(annotation_path) + root = tree.getroot() + if root is None: + raise ValueError(f"Failed to parse XML root from {annotation_path}") + + image = cv2.imread(image_path) + if image is None: + raise ValueError(f"Could not read image from path: {image_path}") + resolution_wh = (image.shape[1], image.shape[0]) + annotation, classes = detections_from_xml_obj( + root, classes, resolution_wh, force_masks + ) + annotations[image_path] = annotation + + return classes, image_paths, annotations + + +def detections_from_xml_obj( + root: Element, + classes: list[str], + resolution_wh: tuple[int, int], + force_masks: bool = False, +) -> tuple[Detections, list[str]]: + """ + Converts an XML object in Pascal VOC format to a Detections object. + Expected XML format: + + ... + + dog + + 48 + 240 + 195 + 371 + + + 48 + 240 + 195 + 240 + 195 + 371 + 48 + 371 + + + + + Args: + root: Parsed Pascal VOC ```` XML element. + classes: Existing class names used to assign stable class ids. + resolution_wh: Image resolution as ``(width, height)`` for mask + rasterization. + force_masks: If True, returns a mask array for every object even when + no ```` element is present. + + Returns: + A tuple containing a Detections object and an + updated list of class names, extended with the class names + from the XML object. + """ + xyxy: list[list[int]] = [] + class_names: list[str] = [] + masks: list[npt.NDArray[np.bool_]] = [] + with_masks = force_masks or any( + _with_poly_mask(obj) for obj in root.findall("object") + ) + extended_classes = classes[:] + for obj in root.findall("object"): + class_name = _get_required_text(obj, "name") + class_names.append(class_name) + + bbox = obj.find("bndbox") + if bbox is None: + raise ValueError("Missing bndbox in Pascal VOC annotation.") + x1 = int(_get_required_text(bbox, "xmin")) + y1 = int(_get_required_text(bbox, "ymin")) + x2 = int(_get_required_text(bbox, "xmax")) + y2 = int(_get_required_text(bbox, "ymax")) + + xyxy.append([x1, y1, x2, y2]) + + object_mask: npt.NDArray[np.bool_] = np.zeros( + (resolution_wh[1], resolution_wh[0]), dtype=bool + ) + for polygon_element in obj.findall("polygon"): + polygon = parse_polygon_points(polygon_element) + # https://github.com/roboflow/supervision/issues/144 + polygon -= 1 + + mask_from_polygon = polygon_to_mask( + polygon=polygon, + resolution_wh=resolution_wh, + ) + object_mask |= mask_from_polygon.astype(bool) + + if with_masks: + masks.append(object_mask) + + xyxy_arr: npt.NDArray[np.float32] + if xyxy: + xyxy_arr = np.array(xyxy, dtype=np.float32) + else: + xyxy_arr = np.empty((0, 4), dtype=np.float32) + + # https://github.com/roboflow/supervision/issues/144 + xyxy_arr -= 1 + + for k in sorted(set(class_names)): + if k not in extended_classes: + extended_classes.append(k) + class_id = np.array( + [extended_classes.index(class_name) for class_name in class_names] + ) + + annotation = Detections( + xyxy=xyxy_arr, + mask=np.array(masks, dtype=bool) if with_masks else None, + class_id=class_id, + ) + + return annotation, extended_classes + + +def _with_poly_mask(obj: Element) -> bool: + return obj.find("polygon") is not None + + +def parse_polygon_points(polygon: Element) -> npt.NDArray[np.int_]: + coordinates: list[int] = [] + for coord in polygon.findall(".//*"): + if coord.text is None: + raise ValueError("Missing polygon coordinate value in Pascal VOC.") + coordinates.append(int(coord.text)) + return np.array( + [(coordinates[i], coordinates[i + 1]) for i in range(0, len(coordinates), 2)], + dtype=int, + ) + + +def _get_required_text(element: Element, tag: str) -> str: + child = element.find(tag) + if child is None or child.text is None: + raise ValueError(f"Missing '{tag}' in Pascal VOC annotation.") + return child.text + + +def save_pascal_voc_annotations( + dataset: "DetectionDataset", + annotations_directory_path: str, + min_image_area_percentage: float = 0.0, + max_image_area_percentage: float = 1.0, + approximation_percentage: float = 0.75, + show_progress: bool = False, +) -> None: + """Write Pascal VOC XML annotation files for every image in *dataset*. + + Args: + dataset: Dataset whose annotations are saved. + annotations_directory_path: Destination directory for ``.xml`` files; + created automatically if it does not exist. + min_image_area_percentage: Minimum detection area as a fraction of the + image area. Detections below this threshold are omitted. Must be in + ``[0, 1]``. Default ``0.0`` keeps all detections. + max_image_area_percentage: Maximum detection area as a fraction of the + image area. Detections above this threshold are omitted. Must be in + ``[0, 1]``. Default ``1.0`` keeps all detections. + approximation_percentage: Fraction of polygon vertices to remove when + approximating instance masks as polygons. Range ``[0, 1)``. Default + ``0.75`` applies aggressive simplification. + show_progress: If ``True``, display a tqdm progress bar while writing + annotation files. Default ``False``. + + Raises: + ValueError: If two image paths map to the same ``.xml`` output name. + + Examples: + >>> import tempfile + >>> from supervision.dataset.core import DetectionDataset + >>> from supervision.dataset.formats.pascal_voc import ( + ... save_pascal_voc_annotations, + ... ) + >>> dataset = DetectionDataset(classes=[], images={}, annotations={}) + >>> with tempfile.TemporaryDirectory() as tmpdir: + ... save_pascal_voc_annotations(dataset, tmpdir) + """ + + check_no_basename_collisions( + image_paths=dataset.image_paths, + key=lambda image_path: f"{Path(image_path).stem}.xml", + output_kind="Pascal VOC annotation", + ) + Path(annotations_directory_path).mkdir(parents=True, exist_ok=True) + for image_path, image, annotations in tqdm( + dataset, + total=len(dataset), + desc="Saving Pascal VOC annotations", + disable=not show_progress, + ): + annotation_name = Path(image_path).stem + annotations_path = os.path.join( + annotations_directory_path, f"{annotation_name}.xml" + ) + image_name = Path(image_path).name + pascal_voc_xml = detections_to_pascal_voc( + detections=annotations, + classes=dataset.classes, + filename=image_name, + image_shape=(image.shape[0], image.shape[1], image.shape[2]), + min_image_area_percentage=min_image_area_percentage, + max_image_area_percentage=max_image_area_percentage, + approximation_percentage=approximation_percentage, + ) + with open(annotations_path, "w") as f: + f.write(pascal_voc_xml) diff --git a/src/supervision/dataset/formats/yolo.py b/src/supervision/dataset/formats/yolo.py new file mode 100644 index 0000000..476ebc7 --- /dev/null +++ b/src/supervision/dataset/formats/yolo.py @@ -0,0 +1,502 @@ +from __future__ import annotations + +import os +import warnings +from collections.abc import Sequence +from pathlib import Path +from typing import TYPE_CHECKING, Any, cast + +import numpy as np +import numpy.typing as npt +from PIL import Image +from tqdm.auto import tqdm + +from supervision.config import ORIENTED_BOX_COORDINATES +from supervision.dataset.utils import ( + approximate_mask_with_polygons, + check_no_basename_collisions, +) +from supervision.detection.core import Detections +from supervision.detection.utils._typing import _DetectionDataType +from supervision.detection.utils.converters import polygon_to_mask, polygon_to_xyxy +from supervision.utils.file import ( + list_files_with_extensions, + read_txt_file, + read_yaml_file, + save_text_file, + save_yaml_file, +) + +if TYPE_CHECKING: + from supervision.dataset.core import DetectionDataset + + +def _parse_box(values: list[str]) -> npt.NDArray[np.float32]: + x_center, y_center, width, height = values + return np.array( + [ + float(x_center) - float(width) / 2, + float(y_center) - float(height) / 2, + float(x_center) + float(width) / 2, + float(y_center) + float(height) / 2, + ], + dtype=np.float32, + ) + + +def _box_to_polygon(box: npt.NDArray[np.float32]) -> npt.NDArray[np.float32]: + return np.array( + [[box[0], box[1]], [box[2], box[1]], [box[2], box[3]], [box[0], box[3]]], + dtype=np.float32, + ) + + +def _parse_polygon(values: list[str]) -> npt.NDArray[np.float32]: + return np.array(values, dtype=np.float32).reshape(-1, 2) + + +def _polygons_to_masks( + polygons: Sequence[npt.NDArray[np.number]], resolution_wh: tuple[int, int] +) -> npt.NDArray[np.bool_]: + return np.array( + [ + polygon_to_mask( + polygon=np.round(polygon).astype(np.int32), + resolution_wh=resolution_wh, + ) + for polygon in polygons + ], + dtype=bool, + ) + + +def _with_seg_mask(lines: list[str]) -> bool: + return any([len(line.split()) > 5 for line in lines]) + + +def _extract_class_names(file_path: str) -> list[str]: + """Return class names from a YOLO data.yaml file ordered by class index. + + Supports list and dict forms of the ``names`` field. Dict keys that are + all int-like (plain ints or digit strings) are sorted numerically so + class index 10 follows index 9. All-non-numeric keys are sorted + lexicographically. Mixed numeric/non-numeric keys raise ``ValueError``. + Boolean YAML keys (``true``/``false``) are excluded from numeric sorting + because ``bool`` is a subclass of ``int`` in Python. + + Args: + file_path: Path to the data.yaml file. + + Returns: + Class names in class-index order. + + Raises: + ValueError: If the YAML root is not a mapping, if ``names`` is + neither a list nor a dict, or if the dict has mixed key types. + """ + data: dict[str, Any] = read_yaml_file(file_path=file_path) + if not isinstance(data, dict): + raise ValueError( + f"Expected mapping in data.yaml at '{file_path}'," + f" got {type(data).__name__}." + ) + names = data.get("names") + if isinstance(names, dict): + keys = list(names.keys()) + + def _is_int_like(key: Any) -> bool: + # bool subclasses int; YAML `true`/`false` must not become class indices + if isinstance(key, bool): + return False + if isinstance(key, int): + return True + if isinstance(key, str): + stripped = key.strip() + return stripped.isdigit() + return False + + int_like = [_is_int_like(k) for k in keys] + if any(int_like) and not all(int_like): + mixed_numeric = [k for k, il in zip(keys, int_like) if il][:3] + mixed_other = [k for k, il in zip(keys, int_like) if not il][:3] + raise ValueError( + f"Expected 'names' dict in data.yaml at '{file_path}' to have either " + f"all numeric or all non-numeric keys, got a mix: " + f"numeric {mixed_numeric} and non-numeric {mixed_other} keys." + ) + if all(int_like): + sorted_keys = sorted(keys, key=lambda k: int(k)) + else: + sorted_keys = sorted(keys, key=str) + return [str(names[key]) for key in sorted_keys] + if isinstance(names, list): + return [str(name) for name in names] + raise ValueError( + "Expected 'names' to be a list or dict in data.yaml at " + f"'{file_path}', got {type(names).__name__}." + ) + + +def _image_name_to_annotation_name(image_name: str) -> str: + base_name, _ = os.path.splitext(image_name) + return base_name + ".txt" + + +def yolo_annotations_to_detections( + lines: list[str], + resolution_wh: tuple[int, int], + with_masks: bool, + is_obb: bool = False, +) -> Detections: + if len(lines) == 0: + return Detections.empty() + + class_id_list: list[int] = [] + relative_xyxy_list: list[npt.NDArray[np.number]] = [] + relative_polygon_list: list[npt.NDArray[np.float32]] = [] + relative_xyxyxyxy_list: list[npt.NDArray[np.float32]] = [] + w, h = resolution_wh + for line in lines: + values = line.split() + class_id_list.append(int(values[0])) + if len(values) == 5: + box = _parse_box(values=values[1:]) + relative_xyxy_list.append(box) + if with_masks: + relative_polygon_list.append(_box_to_polygon(box=box)) + elif len(values) > 5: + polygon = _parse_polygon(values=values[1:]) + relative_xyxy_list.append(polygon_to_xyxy(polygon=polygon)) + if is_obb: + relative_xyxyxyxy_list.append(np.array(values[1:], dtype=np.float32)) + if with_masks: + relative_polygon_list.append(polygon) + + class_id = np.array(class_id_list, dtype=int) + relative_xyxy = np.array(relative_xyxy_list, dtype=np.float32) + xyxy = relative_xyxy * np.array([w, h, w, h], dtype=np.float32) + data: _DetectionDataType = {} + + if is_obb: + relative_xyxyxyxy = np.array(relative_xyxyxyxy_list, dtype=np.float32) + xyxyxyxy = relative_xyxyxyxy.reshape(-1, 4, 2) + xyxyxyxy *= np.array([w, h], dtype=np.float32) + data[ORIENTED_BOX_COORDINATES] = cast(npt.NDArray[np.generic], xyxyxyxy) + + if not with_masks: + return Detections(class_id=class_id, xyxy=xyxy, data=data) + + polygons = [ + polygon * np.array(resolution_wh, dtype=np.float32) + for polygon in relative_polygon_list + ] + mask = _polygons_to_masks(polygons=polygons, resolution_wh=resolution_wh) + return Detections(class_id=class_id, xyxy=xyxy, data=data, mask=mask) + + +def load_yolo_annotations( + images_directory_path: str, + annotations_directory_path: str, + data_yaml_path: str, + force_masks: bool = False, + is_obb: bool = False, + show_progress: bool = False, +) -> tuple[list[str], list[str], dict[str, Detections]]: + """ + Loads YOLO annotations and returns class names, images, + and their corresponding detections. + + Args: + images_directory_path: The path to the directory containing the images. + annotations_directory_path: The path to the directory + containing the YOLO annotation files. + data_yaml_path: The path to the data + YAML file containing class information. + force_masks: If True, forces masks to be loaded + for all annotations, regardless of whether they are present. + This parameter has no effect when `is_obb=True`; mask generation + is always disabled for OBB annotations. + is_obb: If True, loads the annotations in OBB format. + OBB annotations are defined as `[class_id, x, y, x, y, x, y, x, y]`, + where pairs of [x, y] are box corners. + show_progress: If True, display a progress bar during loading. + + Returns: + A tuple containing a list of class names, a dictionary with + image names as keys and images as values, and a dictionary + with image names as keys and corresponding Detections instances as values. + """ + if is_obb and force_masks: + warnings.warn( + "`force_masks=True` has no effect when `is_obb=True`; " + "mask generation is always disabled for OBB annotations.", + UserWarning, + stacklevel=2, + ) + image_paths = [ + str(path) + for path in list_files_with_extensions( + directory=images_directory_path, + extensions=[ + "bmp", + "dng", + "jpg", + "jpeg", + "mpo", + "png", + "tif", + "tiff", + "webp", + ], + ) + ] + + classes = _extract_class_names(file_path=data_yaml_path) + annotations = {} + + for image_path in tqdm( + image_paths, + total=len(image_paths), + desc="Loading YOLO annotations", + disable=not show_progress, + ): + image_stem = Path(image_path).stem + annotation_path = os.path.join(annotations_directory_path, f"{image_stem}.txt") + if not os.path.exists(annotation_path): + annotations[image_path] = Detections.empty() + continue + + # PIL is much faster than cv2 for checking image shape: https://github.com/roboflow/supervision/issues/1554 + with Image.open(image_path) as image: + w, h = image.size + lines = read_txt_file(file_path=annotation_path, skip_empty=True) + resolution_wh = (w, h) + + with_masks = not is_obb and (force_masks or _with_seg_mask(lines=lines)) + annotation = yolo_annotations_to_detections( + lines=lines, + resolution_wh=resolution_wh, + with_masks=with_masks, + is_obb=is_obb, + ) + annotations[image_path] = annotation + return classes, image_paths, annotations + + +def object_to_yolo( + xyxy: npt.NDArray[np.number], + class_id: int, + image_shape: tuple[int, int, int], + polygon: npt.NDArray[np.number] | None = None, +) -> str: + h, w, _ = image_shape + if polygon is None: + xyxy_relative = xyxy / np.array([w, h, w, h], dtype=np.float32) + x_min, y_min, x_max, y_max = xyxy_relative + x_center = (x_min + x_max) / 2 + y_center = (y_min + y_max) / 2 + width = x_max - x_min + height = y_max - y_min + return f"{int(class_id)} {x_center:.5f} {y_center:.5f} {width:.5f} {height:.5f}" + else: + polygon_relative = polygon / np.array([w, h], dtype=np.float32) + polygon_relative = polygon_relative.reshape(-1) + polygon_parsed = " ".join([f"{value:.5f}" for value in polygon_relative]) + return f"{int(class_id)} {polygon_parsed}" + + +def detections_to_yolo_annotations( + detections: Detections, + image_shape: tuple[int, int, int], + min_image_area_percentage: float = 0.0, + max_image_area_percentage: float = 1.0, + approximation_percentage: float = 0.75, + is_obb: bool = False, +) -> list[str]: + """Convert detections to YOLO annotation lines. + + Args: + detections: The detections to serialize. Each detection must have a + valid integer ``class_id``. When ``is_obb=True``, each non-empty + detection must also carry ``detections.data['xyxyxyxy']`` with + shape ``(N, 4, 2)``. + image_shape: The ``(height, width, channels)`` shape of the source + image, used to normalize coordinates to ``[0, 1]``. + min_image_area_percentage: Minimum detection area as a fraction of the + image area; smaller detections are omitted. Ignored when + ``is_obb=True``. + max_image_area_percentage: Maximum detection area as a fraction of the + image area; larger detections are omitted. Ignored when + ``is_obb=True``. + approximation_percentage: Fraction of polygon points removed during + contour approximation when saving mask annotations. Ignored when + ``is_obb=True``. + is_obb: If ``True``, serializes oriented bounding-box corners from + ``detections.data['xyxyxyxy']`` as a 9-token YOLO OBB line + ``class_id x1 y1 x2 y2 x3 y3 x4 y4``. Mask data is ignored. + + Returns: + A list of YOLO annotation strings, one per detection (or one per + polygon for instance-segmentation annotations). + + Raises: + ValueError: If any detection has ``class_id=None`` or a non-integer + ``class_id``. + ValueError: If ``is_obb=True`` and any non-empty detection is missing + ``'xyxyxyxy'`` in ``detections.data``. + + Examples: + >>> import numpy as np + >>> from supervision.detection.core import Detections + >>> from supervision.dataset.formats.yolo import detections_to_yolo_annotations + >>> detections = Detections( + ... xyxy=np.array([[10, 10, 90, 90]], dtype=np.float32), + ... class_id=np.array([0]), + ... ) + >>> detections_to_yolo_annotations(detections, image_shape=(100, 100, 3)) + ['0 0.50000 0.50000 0.80000 0.80000'] + """ + if ( + is_obb + and len(detections) > 0 + and ORIENTED_BOX_COORDINATES not in detections.data + ): + raise ValueError( + f"`is_obb=True` requires `'{ORIENTED_BOX_COORDINATES}'` in " + "`detections.data` with shape (N, 4, 2). Load OBB datasets via " + "`DetectionDataset.from_yolo(..., is_obb=True)` or set " + f"`detections.data['{ORIENTED_BOX_COORDINATES}']` " + "(shape (N, 4, 2)) before exporting." + ) + + if is_obb and detections.mask is not None: + warnings.warn( + "`detections.mask` is ignored when `is_obb=True`; " + "OBB annotations use corner coordinates from " + f"`detections.data['{ORIENTED_BOX_COORDINATES}']`.", + UserWarning, + stacklevel=2, + ) + + annotation: list[str] = [] + for xyxy, mask, _, class_id, _, data in detections: + if class_id is None: + raise ValueError("Class ID is required for YOLO annotations.") + if not isinstance(class_id, (int, np.integer)): + raise ValueError( + f"Detections class_id must be an integer for YOLO export, " + f"got {type(class_id)!r}." + ) + class_id_int = int(class_id) + + if is_obb: + corners = np.asarray(data[ORIENTED_BOX_COORDINATES], dtype=np.float32) + if corners.shape != (4, 2): + raise ValueError( + f"OBB data for each detection must have shape (4, 2), " + f"got {corners.shape}. Ensure " + f"`detections.data['{ORIENTED_BOX_COORDINATES}']` has " + "shape (N, 4, 2) before exporting." + ) + next_object = object_to_yolo( + xyxy=xyxy, + class_id=class_id_int, + image_shape=image_shape, + polygon=corners, + ) + annotation.append(next_object) + continue + + if mask is not None: + polygons = approximate_mask_with_polygons( + mask=mask, + min_image_area_percentage=min_image_area_percentage, + max_image_area_percentage=max_image_area_percentage, + approximation_percentage=approximation_percentage, + ) + for polygon in polygons: + xyxy = polygon_to_xyxy(polygon=polygon) + next_object = object_to_yolo( + xyxy=xyxy, + class_id=class_id_int, + image_shape=image_shape, + polygon=polygon, + ) + annotation.append(next_object) + else: + next_object = object_to_yolo( + xyxy=xyxy, class_id=class_id_int, image_shape=image_shape + ) + annotation.append(next_object) + return annotation + + +def save_yolo_annotations( + dataset: DetectionDataset, + annotations_directory_path: str, + min_image_area_percentage: float = 0.0, + max_image_area_percentage: float = 1.0, + approximation_percentage: float = 0.75, + is_obb: bool = False, + show_progress: bool = False, +) -> None: + """Save dataset annotations in YOLO format. + + Args: + dataset: The dataset whose annotations are saved. + annotations_directory_path: Path to the directory where annotation + ``.txt`` files are written; created automatically if absent. + min_image_area_percentage: Minimum detection area as a fraction of the + image area; smaller detections are omitted. Ignored when + ``is_obb=True``. + max_image_area_percentage: Maximum detection area as a fraction of the + image area; larger detections are omitted. Ignored when + ``is_obb=True``. + approximation_percentage: Fraction of polygon points removed during + contour approximation when saving mask annotations. Ignored when + ``is_obb=True``. + is_obb: If ``True``, writes oriented bounding-box annotations using + the 9-token format ``class_id x1 y1 x2 y2 x3 y3 x4 y4``. Each + non-empty detection must carry ``detections.data['xyxyxyxy']`` + with shape ``(N, 4, 2)``. + show_progress: If ``True``, display a tqdm progress bar while + saving annotations. + + Examples: + >>> from supervision.dataset.core import DetectionDataset + >>> from supervision.dataset.formats.yolo import save_yolo_annotations + >>> dataset = DetectionDataset(classes=["cat"], images={}, annotations={}) + >>> save_yolo_annotations(dataset, "/tmp/labels") + """ + check_no_basename_collisions( + image_paths=dataset.image_paths, + key=lambda image_path: _image_name_to_annotation_name(Path(image_path).name), + output_kind="YOLO annotation", + ) + Path(annotations_directory_path).mkdir(parents=True, exist_ok=True) + for image_path, image, annotation in tqdm( + dataset, + total=len(dataset), + desc="Saving YOLO annotations", + disable=not show_progress, + ): + image_name = Path(image_path).name + yolo_annotations_name = _image_name_to_annotation_name(image_name=image_name) + yolo_annotations_path = os.path.join( + annotations_directory_path, yolo_annotations_name + ) + lines = detections_to_yolo_annotations( + detections=annotation, + image_shape=image.shape, + min_image_area_percentage=min_image_area_percentage, + max_image_area_percentage=max_image_area_percentage, + approximation_percentage=approximation_percentage, + is_obb=is_obb, + ) + save_text_file(lines=lines, file_path=yolo_annotations_path) + + +def save_data_yaml(data_yaml_path: str, classes: list[str]) -> None: + data = {"nc": len(classes), "names": classes} + Path(data_yaml_path).parent.mkdir(parents=True, exist_ok=True) + save_yaml_file(data=data, file_path=data_yaml_path) diff --git a/src/supervision/dataset/utils.py b/src/supervision/dataset/utils.py new file mode 100644 index 0000000..45067de --- /dev/null +++ b/src/supervision/dataset/utils.py @@ -0,0 +1,265 @@ +from __future__ import annotations + +__all__ = ["check_no_basename_collisions", "train_test_split"] + +import copy +import os +import random +import shutil +from collections.abc import Callable +from pathlib import Path +from typing import TYPE_CHECKING, TypeVar, cast + +import cv2 +import numpy as np +import numpy.typing as npt +from deprecate import deprecated, void # type: ignore[import-untyped,unused-ignore] +from tqdm.auto import tqdm + +from supervision.detection.core import Detections +from supervision.detection.utils.converters import mask_to_polygons +from supervision.detection.utils.converters import ( + mask_to_rle as _mask_to_rle, +) +from supervision.detection.utils.converters import ( + rle_to_mask as _rle_to_mask, +) +from supervision.detection.utils.polygons import ( + approximate_polygon, + filter_polygons_by_area, +) + + +@deprecated(target=_mask_to_rle, deprecated_in="0.28.0", remove_in="0.31.0") # type: ignore[untyped-decorator] +def mask_to_rle( + mask: npt.NDArray[np.bool_], compressed: bool = False +) -> list[int] | str: + """Deprecated since 0.28.0. + + Use `supervision.detection.utils.converters.mask_to_rle`. + """ + return cast(list[int] | str, void(mask, compressed)) + + +@deprecated(target=_rle_to_mask, deprecated_in="0.28.0", remove_in="0.31.0") # type: ignore[untyped-decorator] +def rle_to_mask( + rle: npt.NDArray[np.integer] | list[int] | str | bytes, + resolution_wh: tuple[int, int], +) -> npt.NDArray[np.bool_]: + """Deprecated since 0.28.0. + + Use `supervision.detection.utils.converters.rle_to_mask`. + """ + return cast(npt.NDArray[np.bool_], void(rle, resolution_wh)) + + +if TYPE_CHECKING: + from supervision.dataset.core import DetectionDataset + +T = TypeVar("T") + + +def approximate_mask_with_polygons( + mask: npt.NDArray[np.bool_], + min_image_area_percentage: float = 0.0, + max_image_area_percentage: float = 1.0, + approximation_percentage: float = 0.0, +) -> list[npt.NDArray[np.number]]: + """Filter mask polygons by area and optionally simplify them. + + The default `approximation_percentage=0.0` preserves the original contour + unless callers explicitly ask for simplification. + """ + height, width = mask.shape + image_area = height * width + minimum_detection_area = min_image_area_percentage * image_area + maximum_detection_area = max_image_area_percentage * image_area + + polygons = cast(list[npt.NDArray[np.number]], mask_to_polygons(mask=mask)) + if len(polygons) == 1: + polygons = filter_polygons_by_area( + polygons=polygons, min_area=None, max_area=maximum_detection_area + ) + else: + polygons = filter_polygons_by_area( + polygons=polygons, + min_area=minimum_detection_area, + max_area=maximum_detection_area, + ) + return [ + approximate_polygon(polygon=polygon, percentage=approximation_percentage) + for polygon in polygons + ] + + +def merge_class_lists(class_lists: list[list[str]]) -> list[str]: + unique_classes = set() + + for class_list in class_lists: + for class_name in class_list: + unique_classes.add(class_name) + + return sorted(list(unique_classes)) + + +def build_class_index_mapping( + source_classes: list[str], target_classes: list[str] +) -> dict[int, int]: + """Returns the index map of source classes -> target classes.""" + index_mapping = {} + + for i, class_name in enumerate(source_classes): + if class_name not in target_classes: + raise ValueError( + f"Class {class_name} not found in target classes. " + "source_classes must be a subset of target_classes." + ) + corresponding_index = target_classes.index(class_name) + index_mapping[i] = corresponding_index + + return index_mapping + + +def map_detections_class_id( + source_to_target_mapping: dict[int, int], detections: Detections +) -> Detections: + if detections.class_id is None: + raise ValueError("Detections must have class_id attribute.") + if set(np.unique(detections.class_id)) - set(source_to_target_mapping.keys()): + raise ValueError( + "Detections class_id must be a subset of source_to_target_mapping keys." + ) + + detections_copy = copy.deepcopy(detections) + + if len(detections) > 0: + detections_copy.class_id = np.vectorize(source_to_target_mapping.get)( + detections_copy.class_id + ) + + return detections_copy + + +def check_no_basename_collisions( + image_paths: list[str], + key: Callable[[str], str], + output_kind: str, +) -> None: + """Raise if two image paths would be written to the same output file. + + Dataset image paths may share a basename when they originate from different + directories (a legal, common state after :meth:`DetectionDataset.merge`). + Exporting them into a single flat output directory keyed on the basename or + stem would silently overwrite one file with another and mispair images with + their annotations. This guard detects such collisions before any file is + written and names the colliding source paths. + + Args: + image_paths: The dataset image paths about to be written. + key: Maps an image path to the output file name it would be written to. + output_kind: Human-readable description of the output (e.g. ``"image"`` + or ``"YOLO annotation"``) used in the error message. + + Raises: + ValueError: If two image paths map to the same output file name. + + Examples: + >>> from pathlib import Path + >>> from supervision.dataset.utils import check_no_basename_collisions + >>> check_no_basename_collisions( + ... ["a/img.jpg", "b/img.jpg"], lambda p: Path(p).name, "image" + ... ) + Traceback (most recent call last): + ... + ValueError: Cannot export dataset: image paths 'a/img.jpg' and ... + """ + seen: dict[str, tuple[str, str]] = {} # casefold(key) โ†’ (original name, image_path) + for image_path in image_paths: + output_name = key(image_path) + case_key = output_name.casefold() + if case_key in seen: + first_name, first_path = seen[case_key] + raise ValueError( + f"Cannot export dataset: image paths {first_path!r} and " + f"{image_path!r} both map to {output_kind} file {first_name!r}. " + "Ensure all image basenames are unique before exporting." + ) + seen[case_key] = (output_name, image_path) + + +def save_dataset_images( + dataset: DetectionDataset, + images_directory_path: str, + show_progress: bool = False, +) -> None: + """Save all images from a dataset to a directory. + + Images already in memory are written with ``cv2.imwrite``; images stored + only as file paths are copied with ``shutil.copyfile``. + + Args: + dataset: The dataset whose images are saved. + images_directory_path: Destination directory path; created + automatically if it does not exist. + show_progress: If ``True``, display a tqdm progress bar while + saving images. + + Examples: + >>> from supervision.dataset.core import DetectionDataset + >>> from supervision.dataset.utils import save_dataset_images + >>> dataset = DetectionDataset(classes=["cat"], images={}, annotations={}) + >>> save_dataset_images(dataset, "/tmp/images") + """ + check_no_basename_collisions( + image_paths=dataset.image_paths, + key=lambda image_path: Path(image_path).name, + output_kind="image", + ) + Path(images_directory_path).mkdir(parents=True, exist_ok=True) + for image_path in tqdm( + dataset.image_paths, + desc="Saving images", + disable=not show_progress, + ): + final_path = os.path.join(images_directory_path, Path(image_path).name) + if image_path in dataset._images_in_memory: + image = dataset._images_in_memory[image_path] + cv2.imwrite(final_path, image) + else: + shutil.copyfile(image_path, final_path) + + +def train_test_split( + data: list[T], + train_ratio: float = 0.8, + random_state: int | None = None, + shuffle: bool = True, +) -> tuple[list[T], list[T]]: + """ + Splits the data into two parts using the provided train_ratio. + + Args: + data: The data to split. + train_ratio: The ratio of the training set to the entire dataset. + random_state: The seed for the random number generator. + shuffle: Whether to shuffle the data before splitting. + + Returns: + The split data. The input list is copied and never mutated. + + Examples: + >>> train, test = train_test_split( + ... [1, 2, 3, 4, 5], train_ratio=0.6, random_state=0 + ... ) + >>> len(train), len(test) + (3, 2) + """ + rng = random.Random(random_state) # noqa: S311 โ€” dataset split, not cryptographic + if shuffle: + data = list(data) + rng.shuffle(data) + else: + data = list(data) # copy to guarantee non-mutation + + split_index = int(len(data) * train_ratio) + return data[:split_index], data[split_index:] diff --git a/src/supervision/detection/__init__.py b/src/supervision/detection/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/src/supervision/detection/compact_mask.py b/src/supervision/detection/compact_mask.py new file mode 100644 index 0000000..e425eab --- /dev/null +++ b/src/supervision/detection/compact_mask.py @@ -0,0 +1,1706 @@ +"""Crop-RLE compact mask storage for memory-efficient instance segmentation. + +Dense ``(N, H, W)`` boolean masks use O(NยทHยทW) memory, which becomes +prohibitive for aerial imagery (e.g. 1000 objects x 4K image ~ 8.3 GB). +:class:`CompactMask` stores each mask as a run-length encoding of its +bounding-box crop, reducing typical usage to tens of MB. + +The bounding boxes (``xyxy``) already present in ``Detections`` serve as the +crop boundaries, so no extra metadata is required from the caller. + +CompactMask reduces memory footprint but does not improve computational +speed. The ingestion path (base48 decode, column split, RLE trim) is +Python-level and is typically slower than the dense NumPy path. The primary +benefit is memory savings for large images with many sparse masks. +""" + +from __future__ import annotations + +import os +from collections.abc import Iterator, Mapping, Sequence +from typing import Any, cast, overload + +import numpy as np +import numpy.typing as npt + +# _base48_decode and _delta_decode are private to the COCO RLE codec. They +# live in converters.py and are shared by public conversion helpers here and +# in that module. +from supervision.detection.utils.converters import ( + _base48_decode, + _delta_decode, + _mask_to_rle_counts, + _rle_counts_to_mask, +) + + +def _rle_area(rle: npt.NDArray[np.int32]) -> int: + """Return the number of ``True`` pixels in a run-length encoded mask. + + Args: + rle: int32 array of run lengths as produced by :func:`_mask_to_rle_counts`. + + Returns: + Total number of ``True`` pixels. + + Examples: + ```pycon + >>> import numpy as np + >>> from supervision.detection.compact_mask import _rle_area + >>> rle = np.array([1, 2, 1, 1, 1], dtype=np.int32) + >>> _rle_area(rle) + 3 + + ``` + """ + return int(np.sum(rle[1::2])) + + +def _rle_split_cols( + rle: npt.NDArray[np.int32], + crop_h: int, + crop_w: int, + x_start: int = 0, + x_stop: int | None = None, +) -> list[list[int]]: + """Split a flat F-order RLE into per-column run lists. + + With F-order (column-major) RLE the flat pixel sequence visits all rows + of column 0, then all rows of column 1, etc. Each column therefore + contains ``crop_h`` contiguous pixels. + + Runs that cross column boundaries are split at the boundary. Each + returned list starts with a ``False``-run count (possibly 0), matching + the convention of :func:`_mask_to_rle_counts`. + + When ``x_start`` and ``x_stop`` are provided, only columns in the closed + range ``[x_start, x_stop]`` are collected. Pixels in skipped columns + are consumed without being stored, which avoids O(W) allocation when + only a small crop of a wide image is needed. + + Note: + ``x_start`` uses ``np.cumsum`` + ``np.searchsorted`` to jump directly + to the first relevant run in O(log R) time, avoiding the O(pixel_prefix) + walk that previously made right-edge crops on wide images expensive. + + Args: + rle: int32 run-length array as produced by + :func:`~supervision.detection.utils.converters._mask_to_rle_counts`. + crop_h: Number of rows (pixels per column). + crop_w: Number of columns. + x_start: First column to collect (0-indexed, inclusive). Columns + before ``x_start`` are skipped. Defaults to ``0``. + x_stop: Last column to collect (0-indexed, inclusive). Processing + stops after column ``x_stop`` is complete. Defaults to + ``crop_w - 1`` (collect all columns). + + Returns: + List of ``x_stop - x_start + 1`` run lists. Index ``i`` in the + returned list corresponds to column ``x_start + i``. Each list + sums to ``crop_h``. + + Examples: + ```pycon + >>> import numpy as np + >>> from supervision.detection.compact_mask import _rle_split_cols + >>> from supervision.detection.utils.converters import _mask_to_rle_counts + >>> mask = np.array([[True, False], [True, True]], dtype=bool) + >>> rle = _mask_to_rle_counts(mask) + >>> rle.tolist() + [0, 2, 1, 1] + >>> _rle_split_cols(rle, 2, 2) + [[0, 2], [1, 1]] + >>> _rle_split_cols(rle, 2, 2, x_start=1) + [[1, 1]] + + ``` + """ + if x_stop is None: + x_stop = crop_w - 1 + + # Convert numpy int32 array to Python ints to avoid scalar boxing overhead + # in the inner loop (np.int32 boxing/unboxing slows pure-Python loops). + rle_list: list[int] = rle.tolist() + + n_cols = x_stop - x_start + 1 + per_col: list[list[int]] = [[] for _ in range(n_cols)] + + # Fast-forward to the first run that overlaps column x_start using O(log R) + # searchsorted instead of an O(pixel_prefix) sequential walk. + start_pixel = x_start * crop_h + if start_pixel > 0 and len(rle_list) > 0: + cumsum_ends = np.cumsum(rle, dtype=np.int64) + first_run = int(np.searchsorted(cumsum_ends, start_pixel, side="right")) + if first_run >= len(rle_list): + for c in range(n_cols): + per_col[c] = [crop_h] + return per_col + prefix = int(cumsum_ends[first_run - 1]) if first_run > 0 else 0 + else: + first_run = 0 + prefix = 0 + + col = prefix // crop_h + row = prefix % crop_h + + for run_idx in range(first_run, len(rle_list)): + run_len = rle_list[run_idx] + is_true = run_idx % 2 == 1 + remaining = run_len + while remaining > 0: + # Past the requested range โ€” stop early. + if col > x_stop: + remaining = 0 + break + space_in_col = crop_h - row + take = min(remaining, space_in_col) + if col >= x_start: + local_col = col - x_start + if len(per_col[local_col]) == 0: + if is_true: + per_col[local_col].append(0) # leading False count = 0 + # Check if last run has same parity (True/False) as current chunk. + # Last element's parity: index (len-1) odd โ†’ True, even โ†’ False. + elif is_true == ((len(per_col[local_col]) - 1) % 2 == 1): + per_col[local_col][-1] += take + remaining -= take + row += take + if row >= crop_h: + row = 0 + col += 1 + continue + per_col[local_col].append(take) + remaining -= take + row += take + if row >= crop_h: + row = 0 + col += 1 + if col > x_stop: + break + + # Fill any empty columns (all-False). + for c in range(n_cols): + if not per_col[c]: + per_col[c] = [crop_h] + + return per_col + + +def _rle_scale_col( + col_runs: list[int], + src_h: int, + row_map: npt.NDArray[np.int32], +) -> list[int]: + """Scale one column's run list to a new height using a precomputed row map. + + Each output row is mapped to a source row via ``row_map``, which + implements nearest-neighbour resampling in the vertical direction. + + Args: + col_runs: Per-column run list starting with a ``False``-run count. + src_h: Height of the source column (sum of ``col_runs``). + row_map: int32 array of length ``new_crop_h``; ``row_map[r']`` is the + source row index for output row ``r'``. Use + ``(np.arange(new_crop_h) * src_h // new_crop_h)`` for + ``cv2.INTER_NEAREST``-compatible mapping. + + Returns: + Scaled run list of total length ``len(row_map)``, always starting + with a ``False``-run count. + + Examples: + ```pycon + >>> import numpy as np + >>> from supervision.detection.compact_mask import _rle_scale_col + >>> col_runs = [0, 2, 2] # F=0, T=2, F=2 โ†’ [T, T, F, F] + >>> row_map = np.array([0, 1, 2, 3, 0, 1, 2, 3], dtype=np.int32) + >>> _rle_scale_col(col_runs, 4, row_map) + [0, 2, 2, 2, 2] + + ``` + """ + new_crop_h = len(row_map) + if new_crop_h == 0: + return [0] + + # Reconstruct per-source-row boolean values from run list. + src_values: npt.NDArray[np.bool_] = np.empty(src_h, dtype=np.bool_) + pos = 0 + for ri, rl in enumerate(col_runs): + src_values[pos : pos + rl] = ri % 2 == 1 # odd index โ†’ True + pos += rl + if pos < src_h: + src_values[pos:] = False # pad truncated RLE + + # Map output rows to source values. + out_values = src_values[row_map] + + # RLE-encode the output column; vectorised via np.diff on bool view. + out_uint8 = out_values.view(np.uint8) + boundaries = np.flatnonzero(np.diff(out_uint8)) + run_starts: npt.NDArray[np.int64] = np.empty(len(boundaries) + 1, dtype=np.int64) + run_ends: npt.NDArray[np.int64] = np.empty(len(boundaries) + 1, dtype=np.int64) + run_starts[0] = 0 + run_starts[1:] = boundaries + 1 + run_ends[:-1] = boundaries + 1 + run_ends[-1] = new_crop_h + result_runs: list[int] = (run_ends - run_starts).tolist() + # RLE starts with a False count; prepend 0 if output begins with True. + if bool(out_values[0]): + result_runs.insert(0, 0) + return result_runs + + +def _rle_join_cols( + scaled_cols: list[list[int]], + new_total: int, +) -> npt.NDArray[np.int32]: + """Concatenate per-column run lists into a flat RLE, merging junctions. + + Each column run list starts with a ``False``-run count. Two junction types + can be merged across column boundaries: + + * ``False``/``False``: the trailing False run merges with the leading False + run of the next column (leading count may be zero). + * ``True``/``True``: when the accumulated output ends on a True run and the + next column's leading False count is zero (column starts with True), the + two True runs are merged to avoid inserting a zero-length False run that + would inflate ``len(rle)`` and skew the density metric in + :func:`_resize_crop`. + + Args: + scaled_cols: List of per-column run lists, each starting with a + ``False``-run count. + new_total: Total pixel count of the output (fallback for empty input). + + Returns: + Flat int32 RLE array starting with a ``False``-run count. + + Examples: + ```pycon + >>> import numpy as np + >>> from supervision.detection.compact_mask import _rle_join_cols + >>> cols = [[1, 2], [1, 2]] # each col: F=1, T=2 + >>> _rle_join_cols(cols, 6).tolist() + [1, 2, 1, 2] + + ``` + """ + output_runs: list[int] = [] + for col_runs in scaled_cols: + if not output_runs: + output_runs.extend(col_runs) + else: + last_is_true = (len(output_runs) - 1) % 2 == 1 + # col_runs always starts with a False count โ†’ first_is_true=False + if not last_is_true: # last == False == first โ†’ merge + output_runs[-1] += col_runs[0] + output_runs.extend(col_runs[1:]) + elif col_runs[0] == 0 and len(col_runs) > 1: + # last run = True; column also starts True (leading False = 0) + # โ†’ merge to avoid a zero-length False run at the junction. + output_runs[-1] += col_runs[1] + output_runs.extend(col_runs[2:]) + else: + output_runs.extend(col_runs) + + return np.array(output_runs if output_runs else [new_total], dtype=np.int32) + + +def _rle_trim_col_runs(col_runs: Sequence[int], y1: int, y2: int) -> list[int]: + """Restrict one full-height column RLE to inclusive rows ``[y1, y2]``. + + Args: + col_runs: Run lengths for one full-height column, starting with a + ``False`` run. + y1: Inclusive top row of the crop. + y2: Inclusive bottom row of the crop. + + Returns: + Run lengths for the cropped column, also starting with a ``False`` run. + + Examples: + ```pycon + >>> from supervision.detection.compact_mask import _rle_trim_col_runs + >>> # Full column F=2, T=2, F=2 (height 6); crop to rows 1..4 inclusive + >>> # yields rows [F, T, T, F] โ†’ F=1, T=2, F=1. + >>> _rle_trim_col_runs([2, 2, 2], y1=1, y2=4) + [1, 2, 1] + + ``` + """ + target_height = y2 - y1 + 1 + # Sum invariant: returned list sums to target_height. Correctness depends + # on the caller (from_coco_rle) having already validated that counts sum + # equals img_h * img_w; no re-validation here. + collected: list[tuple[bool, int]] = [] + row = 0 + for run_idx, run_len in enumerate(col_runs): + is_true = run_idx % 2 == 1 + start = row + end = row + int(run_len) + row = end + + crop_start = max(start, y1) + crop_end = min(end, y2 + 1) + if crop_end > crop_start: + collected.append((is_true, crop_end - crop_start)) + if row > y2: + break + + if not collected: + return [target_height] + + result: list[int] = [] + if collected[0][0]: + result.append(0) + for is_true, length in collected: + last_is_true = bool(result) and (len(result) - 1) % 2 == 1 + if result and last_is_true == is_true: + result[-1] += length + else: + result.append(length) + return result + + +def _coco_rle_counts_to_array(counts: Any) -> npt.NDArray[np.int32]: + """Decode COCO RLE counts into absolute F-order run lengths. + + Args: + counts: COCO compressed counts (``str`` or ``bytes``), or uncompressed + integer run lengths. + + Returns: + One-dimensional ``int32`` run-length array. + + Raises: + ValueError: If counts cannot be decoded into non-negative run lengths. + + Examples: + ```pycon + >>> from supervision.detection.compact_mask import _coco_rle_counts_to_array + >>> _coco_rle_counts_to_array([0, 2, 2, 2, 10]) + array([ 0, 2, 2, 2, 10], dtype=int32) + + ``` + """ + try: + if isinstance(counts, bytes): + counts = counts.decode("utf-8") + if isinstance(counts, str): + decoded_counts = _delta_decode(_base48_decode(counts)) + counts_arr = np.array(decoded_counts, dtype=np.int32) + else: + # Convert to int64 first, then range-check against int32 bounds before + # narrowing. A direct int32 cast wraps silently on some numpy versions + # and raises on others; this makes overflow detection deterministic. + counts_arr64 = np.asarray(counts, dtype=np.int64) + int32_info = np.iinfo(np.int32) + if counts_arr64.size and ( + counts_arr64.max() > int32_info.max + or counts_arr64.min() < int32_info.min + ): + raise ValueError("COCO RLE counts exceed int32 range.") + counts_arr = counts_arr64.astype(np.int32) + except (TypeError, ValueError, OverflowError) as exc: + raise ValueError("Invalid COCO RLE counts.") from exc + + if counts_arr.ndim != 1: + raise ValueError("COCO RLE counts must be one-dimensional.") + if counts_arr.size == 0: + raise ValueError("COCO RLE counts cannot be empty.") + if np.any(counts_arr < 0): + raise ValueError("COCO RLE counts must be non-negative.") + return counts_arr + + +def _rle_resize( + rle: npt.NDArray[np.int32], + crop_h: int, + crop_w: int, + new_crop_h: int, + new_crop_w: int, +) -> npt.NDArray[np.int32]: + """Resize an F-order RLE-encoded crop via nearest-neighbour resampling. + + Manipulates run lengths directly without decoding to a full 2D boolean + array. Delegates to :func:`_rle_split_cols`, :func:`_rle_scale_col`, + and :func:`_rle_join_cols`. + + The nearest-neighbour mapping ``src = floor(dst * src_size / dst_size)`` + is bit-exact with ``cv2.INTER_NEAREST``. + + Args: + rle: int32 array of F-order run lengths as produced by + :func:`~supervision.detection.utils.converters._mask_to_rle_counts`. + Starts with a ``False``-run count (may be 0). + crop_h: Height of the original crop. + crop_w: Width of the original crop. + new_crop_h: Height of the resized crop. + new_crop_w: Width of the resized crop. + + Returns: + int32 array of F-order run lengths for the resized crop, starting + with the ``False``-run count. + + Examples: + Upscale a 3x3 mask with a diagonal True stripe to 6x6: + + ```pycon + >>> import numpy as np + >>> from supervision.detection.compact_mask import _rle_resize + >>> from supervision.detection.utils.converters import ( + ... _mask_to_rle_counts, _rle_counts_to_mask, + ... ) + >>> mask = np.array([ + ... [True, False, False], + ... [False, True, False], + ... [False, False, True ], + ... ], dtype=bool) + >>> rle = _mask_to_rle_counts(mask) + >>> resized_rle = _rle_resize(rle, 3, 3, 6, 6) + >>> result = _rle_counts_to_mask(resized_rle, 6, 6) + >>> result.astype(int) + array([[1, 1, 0, 0, 0, 0], + [1, 1, 0, 0, 0, 0], + [0, 0, 1, 1, 0, 0], + [0, 0, 1, 1, 0, 0], + [0, 0, 0, 0, 1, 1], + [0, 0, 0, 0, 1, 1]]) + + ``` + """ + new_total = new_crop_h * new_crop_w + + if crop_h * crop_w == 0 or new_total == 0: + return np.array([0], dtype=np.int32) + if len(rle) == 1 or int(np.sum(rle[1::2])) == 0: + return np.array([new_total], dtype=np.int32) + if len(rle) == 2 and rle[0] == 0: + return np.array([0, new_total], dtype=np.int32) + + per_col = _rle_split_cols(rle, crop_h, crop_w) + + # cv2.INTER_NEAREST column mapping: src = floor(dst * src_w / dst_w) + col_map = (np.arange(new_crop_w) * crop_w // new_crop_w).astype(np.int32) + + # cv2.INTER_NEAREST row mapping: src = floor(dst * src_h / dst_h) + row_map = (np.arange(new_crop_h) * crop_h // new_crop_h).astype(np.int32) + + # Scale each unique source column once; reuse via cache for repeated cols. + col_cache: dict[int, list[int]] = {} + scaled_cols = [] + for src_c in col_map: + src_col = int(src_c) + if src_col not in col_cache: + col_cache[src_col] = _rle_scale_col(per_col[src_col], crop_h, row_map) + scaled_cols.append(col_cache[src_col]) + + return _rle_join_cols(scaled_cols, new_total) + + +# Fraction of (run_count / pixel_count) below which _rle_resize is used +# instead of the decode โ†’ cv2 โ†’ re-encode path. Sparse masks have few long +# runs; dense/complex masks approach 1 run per 2 pixels. +_L3_DENSITY_THRESHOLD: float = 0.25 +# Thread overhead outweighs gains below this mask count. +_PARALLEL_THRESHOLD: int = 8 +# Hard ceiling on each image dimension accepted by from_coco_rle, guarding +# against crafted payloads that allocate O(H x W) column lists. +_MAX_IMAGE_DIMENSION: int = 32768 +# Images at or below this pixel count use a fully-vectorised numpy dense-decode +# path inside from_coco_rle instead of the pure-Python column-split loop. +# Crossover measured at ~8-16 K px (128x128); threshold set at 128x128 = 16 384. +_SMALL_IMAGE_DENSE_THRESHOLD: int = 128 * 128 + + +def _resize_crop( + rle: npt.NDArray[np.int32], + orig_h: int, + orig_w: int, + new_h: int, + new_w: int, +) -> npt.NDArray[np.int32]: + """Resize one RLE crop to ``(new_h, new_w)``, choosing the fastest path. + + Dispatch order: + + 1. **All-False fast path** โ€” returns a single False run; no decode. + 2. **L3 direct RLE path** โ€” used when run density is below + :data:`_L3_DENSITY_THRESHOLD`; manipulates run lengths without + allocating a 2D array. + 3. **cv2 fallback** โ€” decodes to ``uint8``, calls + ``cv2.resize(INTER_NEAREST)``, re-encodes; used for dense masks. + + Args: + rle: int32 run-length array for the source crop. + orig_h: Height of the source crop. + orig_w: Width of the source crop. + new_h: Target height. + new_w: Target width. + + Returns: + int32 RLE array for the resized crop. + """ + import cv2 + + # All-False: skip decode entirely. + if _rle_area(rle) == 0: + return np.array([new_h * new_w], dtype=np.int32) + + # L3: direct RLE arithmetic for sparse masks. + if len(rle) / max(1, orig_h * orig_w) < _L3_DENSITY_THRESHOLD: + return _rle_resize(rle, orig_h, orig_w, new_h, new_w) + + # cv2 fallback for dense masks. + crop = _rle_counts_to_mask(rle, orig_h, orig_w) + resized = cv2.resize( + crop.view(np.uint8), + (new_w, new_h), + interpolation=cv2.INTER_NEAREST, + ).astype(bool) + return _mask_to_rle_counts(resized) + + +class CompactMask: + """Memory-efficient crop-RLE mask storage for instance segmentation. + + Instead of storing N full ``(H, W)`` boolean arrays, :class:`CompactMask` + encodes each mask as a run-length sequence of its bounding-box crop. This + reduces memory from O(NยทHยทW) to roughly O(Nยทbbox_area), which is orders of + magnitude smaller for sparse masks on high-resolution images. + + The class exposes a duck-typed interface compatible with ``np.ndarray`` + masks used elsewhere in ``supervision``: + + * ``mask[int]`` โ†’ dense ``(H, W)`` bool array (annotators, converters). + * ``mask[slice | list | ndarray]`` โ†’ new :class:`CompactMask` (filtering). + * ``np.asarray(mask)`` โ†’ dense ``(N, H, W)`` bool array (numpy interop). + * ``mask.shape``, ``mask.dtype``, ``mask.area`` โ€” match the dense API. + + :class:`CompactMask` is **not** a drop-in ``np.ndarray`` replacement. + When you need to call arbitrary ndarray methods (``astype``, ``reshape``, + ``ravel``, ``any``, ``all``, โ€ฆ) call :meth:`to_dense` first: + ``cm.to_dense().astype(np.uint8)``. :meth:`to_dense` is the single + explicit materialisation boundary. + + .. note:: **RLE encoding โ€” COCO / pycocotools pixel-scan order** + + :class:`CompactMask` uses **column-major (Fortran-order, F-order)** + run-lengths scoped to each mask's bounding-box crop, matching the + pixel-scan order used by the COCO API (pycocotools). The crop scope + still differs from the full-image scope used by pycocotools, so a + :class:`CompactMask` RLE cannot be passed directly to + ``maskUtils.iou()`` or ``maskUtils.decode()`` without re-scoping to + the full canvas. Use :meth:`to_dense` to obtain a standard boolean + array for pycocotools interop. + + This scan order is part of CompactMask's internal RLE representation. + Switching from row-major (C-order) to column-major (F-order) is a + backward-incompatible format change for any persisted or serialized + :class:`CompactMask` state, including pickled objects and any + external storage of ``._rles``. Older stored RLE arrays will decode + incorrectly under the new convention. + + Migration note: load or decode legacy masks with the older version, + materialize them to dense boolean arrays, and then re-encode them + with the current version (for example via :meth:`to_dense` followed + by :meth:`from_dense`) before persisting them again. + + Args: + rles: List of N int32 run-length arrays. + crop_shapes: Array of shape ``(N, 2)`` โ€” ``(crop_h, crop_w)`` per mask. + offsets: Array of shape ``(N, 2)`` โ€” ``(x1, y1)`` bounding-box origins. + image_shape: ``(H, W)`` of the full image. + + Examples: + ```pycon + >>> import numpy as np + >>> from supervision.detection.compact_mask import CompactMask + >>> masks = np.zeros((2, 100, 100), dtype=bool) + >>> masks[0, 10:20, 10:20] = True + >>> masks[1, 50:70, 50:80] = True + >>> xyxy = np.array([[10, 10, 19, 19], [50, 50, 79, 69]], dtype=np.float32) + >>> cm = CompactMask.from_dense(masks, xyxy, image_shape=(100, 100)) + >>> len(cm) + 2 + >>> cm.shape + (2, 100, 100) + + ``` + """ + + __slots__ = ("_crop_shapes", "_image_shape", "_offsets", "_rles") + + def __init__( + self, + rles: list[npt.NDArray[np.int32]], + crop_shapes: npt.NDArray[np.int32], + offsets: npt.NDArray[np.int32], + image_shape: tuple[int, int], + ) -> None: + self._rles: list[npt.NDArray[np.int32]] = rles + self._crop_shapes: npt.NDArray[np.int32] = crop_shapes # (N,2): (h,w) + self._offsets: npt.NDArray[np.int32] = offsets # (N,2): (x1,y1) + self._image_shape: tuple[int, int] = image_shape # (H, W) + + # ------------------------------------------------------------------ + # Construction + # ------------------------------------------------------------------ + + @classmethod + def from_dense( + cls, + masks: npt.NDArray[np.bool_], + xyxy: npt.NDArray[np.number], + image_shape: tuple[int, int], + ) -> CompactMask: + """Create a :class:`CompactMask` from a dense ``(N, H, W)`` bool array. + + Bounding boxes are clipped to image bounds and interpreted in the + supervision ``xyxy`` convention (inclusive max coordinates). A + box with invalid ordering (``x2 < x1`` or ``y2 < y1``) is replaced by + a ``1x1`` all-False crop to avoid degenerate RLE. + + Args: + masks: Dense boolean mask array of shape ``(N, H, W)``. + xyxy: Bounding boxes of shape ``(N, 4)`` in ``[x1, y1, x2, y2]`` + format. + image_shape: ``(H, W)`` of the full image. + + Returns: + A new :class:`CompactMask` instance. + + Examples: + ```pycon + >>> import numpy as np + >>> from supervision.detection.compact_mask import CompactMask + >>> masks = np.zeros((1, 100, 100), dtype=bool) + >>> masks[0, 10:20, 10:20] = True + >>> xyxy = np.array([[10, 10, 19, 19]], dtype=np.float32) + >>> cm = CompactMask.from_dense(masks, xyxy, image_shape=(100, 100)) + >>> cm.shape + (1, 100, 100) + + ``` + """ + img_h, img_w = image_shape + num_masks = len(masks) + + if num_masks == 0: + return cls( + [], + np.empty((0, 2), dtype=np.int32), + np.empty((0, 2), dtype=np.int32), + image_shape, + ) + + rles: list[npt.NDArray[np.int32]] = [] + crop_shapes_list: list[tuple[int, int]] = [] + offsets_list: list[tuple[int, int]] = [] + + for mask_idx in range(num_masks): + x1, y1, x2, y2 = xyxy[mask_idx] + x1i, y1i, x2i, y2i = int(x1), int(y1), int(x2), int(y2) + x1c = int(max(0, min(x1i, img_w - 1))) + y1c = int(max(0, min(y1i, img_h - 1))) + crop: npt.NDArray[np.bool_] + + # supervision xyxy uses inclusive max coords, so slicing must add +1. + if ( + x2i < x1i + or y2i < y1i + or x2i < 0 + or y2i < 0 + or x1i >= img_w + or y1i >= img_h + ): + crop = np.zeros((1, 1), dtype=bool) + crop_h = 1 + crop_w = 1 + else: + x2c = int(max(0, min(x2i, img_w - 1))) + y2c = int(max(0, min(y2i, img_h - 1))) + crop = masks[mask_idx, y1c : y2c + 1, x1c : x2c + 1] + crop_h = y2c - y1c + 1 + crop_w = x2c - x1c + 1 + rles.append(_mask_to_rle_counts(crop)) + crop_shapes_list.append((crop_h, crop_w)) + offsets_list.append((x1c, y1c)) + + crop_shapes = np.array(crop_shapes_list, dtype=np.int32) + offsets = np.array(offsets_list, dtype=np.int32) + return cls(rles, crop_shapes, offsets, image_shape) + + @classmethod + def from_coco_rle( + cls, + rles: Sequence[Mapping[str, Any]], + xyxy: npt.NDArray[np.floating], + image_shape: tuple[int, int], + ) -> CompactMask: + """Create a :class:`CompactMask` from full-frame COCO RLE masks. + + Transcodes full-image COCO RLE payloads into the crop-scoped RLE format + used by :class:`CompactMask`. The conversion uses run-length arithmetic + scoped by ``xyxy`` boxes and does not materialise a dense ``(N, H, W)`` + mask stack. + + Args: + rles: Sequence of COCO RLE dictionaries. Each dictionary must contain + ``"size"`` as ``[height, width]`` and ``"counts"`` as compressed + counts (``str`` or ``bytes``) or uncompressed integer run lengths. + xyxy: Bounding boxes of shape ``(N, 4)`` in ``[x1, y1, x2, y2]`` + format. Max coordinates follow supervision's inclusive convention. + image_shape: ``(H, W)`` of the full image. This must match every RLE + ``"size"`` value. + + Returns: + A new :class:`CompactMask` instance. + + Raises: + ValueError: If the RLE payloads are malformed, are not aligned with + ``xyxy``, or their sizes/counts do not match ``image_shape``. + + Examples: + ```pycon + >>> import numpy as np + >>> from supervision.detection.compact_mask import CompactMask + >>> # 4x4 image with a 2x2 True block at the top-left corner. + >>> # Uncompressed F-order COCO counts: F=0, T=2, F=2, T=2, F=10 + >>> # (column-major: col0=[T,T,F,F], col1=[T,T,F,F], cols2-3 all F). + >>> rles = [{"size": [4, 4], "counts": [0, 2, 2, 2, 10]}] + >>> xyxy = np.array([[0, 0, 3, 3]], dtype=np.float32) + >>> cm = CompactMask.from_coco_rle(rles, xyxy, image_shape=(4, 4)) + >>> cm.shape + (1, 4, 4) + >>> cm.area.tolist() + [4] + + ``` + """ + img_h, img_w = (int(image_shape[0]), int(image_shape[1])) + if img_h <= 0 or img_w <= 0: + raise ValueError("image_shape must contain positive height and width.") + if img_h > _MAX_IMAGE_DIMENSION or img_w > _MAX_IMAGE_DIMENSION: + raise ValueError( + f"image_shape {(img_h, img_w)} exceeds the maximum allowed dimension " + f"of {_MAX_IMAGE_DIMENSION} pixels per side." + ) + + xyxy_arr = np.asarray(xyxy) + if xyxy_arr.shape != (len(rles), 4): + raise ValueError( + "xyxy must have shape (N, 4), where N matches the number of RLEs." + ) + + if len(rles) == 0: + return cls( + [], + np.empty((0, 2), dtype=np.int32), + np.empty((0, 2), dtype=np.int32), + (img_h, img_w), + ) + + crop_rles: list[npt.NDArray[np.int32]] = [] + crop_shapes_list: list[tuple[int, int]] = [] + offsets_list: list[tuple[int, int]] = [] + + for mask_idx, rle in enumerate(rles): + if not isinstance(rle, Mapping): + raise ValueError("Each RLE payload must be a mapping.") + if "size" not in rle or "counts" not in rle: + raise ValueError("Each RLE payload must contain 'size' and 'counts'.") + + try: + # COCO standard: size=[height, width] (h,w order per pycocotools spec) + rle_h, rle_w = rle["size"] + rle_h = int(rle_h) + rle_w = int(rle_w) + except (TypeError, ValueError) as exc: + raise ValueError("RLE size must be [height, width].") from exc + + if (rle_h, rle_w) != (img_h, img_w): + raise ValueError( + f"RLE size {(rle_h, rle_w)} must match image_shape " + f"{(img_h, img_w)}." + ) + + counts = _coco_rle_counts_to_array(rle["counts"]) + if int(np.sum(counts, dtype=np.int64)) != img_h * img_w: + raise ValueError( + "The sum of COCO RLE counts must match the image area." + ) + + x1, y1, x2, y2 = xyxy_arr[mask_idx] + x1i, y1i, x2i, y2i = int(x1), int(y1), int(x2), int(y2) + x1c = max(0, min(x1i, img_w - 1)) + y1c = max(0, min(y1i, img_h - 1)) + + if ( + x2i < x1i + or y2i < y1i + or x2i < 0 + or y2i < 0 + or x1i >= img_w + or y1i >= img_h + ): + crop_rles.append(np.array([1], dtype=np.int32)) + crop_shapes_list.append((1, 1)) + offsets_list.append((x1c, y1c)) + continue + + x2c = max(0, min(x2i, img_w - 1)) + y2c = max(0, min(y2i, img_h - 1)) + crop_h = y2c - y1c + 1 + crop_w = x2c - x1c + 1 + + if img_h * img_w <= _SMALL_IMAGE_DENSE_THRESHOLD: + # Small image: vectorised numpy decode avoids the O(img_w)-column + # Python loop. Decode RLE to flat F-order bool, extract crop, and + # re-encode directly. + ends = np.cumsum(counts, dtype=np.int64) + starts = ends - counts.astype(np.int64) + # Mark True runs (odd-indexed) via difference-array decode (O(R)). + true_starts = starts[1::2] + true_ends = ends[1::2] + if true_starts.size > 0: + indicator = np.zeros(img_h * img_w + 1, dtype=np.int32) + np.add.at(indicator, true_starts, 1) + np.add.at(indicator, true_ends, -1) + # cumsum in int32 avoids int8 overflow; cast to uint8 (0/1). + flat = np.cumsum(indicator[:-1], dtype=np.int32).astype(np.uint8) + else: + flat = np.zeros(img_h * img_w, dtype=np.uint8) + # Extract crop: reshape to (img_w, img_h) F-order view, slice. + flat_crop = flat.reshape(img_w, img_h)[ + x1c : x2c + 1, y1c : y2c + 1 + ].ravel() + # RLE-encode the flat crop: find value-change positions. + change_pos = np.where(np.diff(flat_crop.view(np.int8)))[0] + 1 + boundaries = np.concatenate([[0], change_pos, [len(flat_crop)]]) + run_lens = np.diff(boundaries) + if flat_crop[0]: + run_lens = np.concatenate([[0], run_lens]) + crop_rle_arr = run_lens.astype(np.int32) + else: + cols = _rle_split_cols(counts, img_h, img_w, x_start=x1c, x_stop=x2c) + selected_columns = [_rle_trim_col_runs(col, y1c, y2c) for col in cols] + crop_rle_arr = _rle_join_cols(selected_columns, crop_h * crop_w) + + crop_rles.append(crop_rle_arr) + crop_shapes_list.append((crop_h, crop_w)) + offsets_list.append((x1c, y1c)) + + crop_shapes = np.array(crop_shapes_list, dtype=np.int32) + offsets = np.array(offsets_list, dtype=np.int32) + return cls(crop_rles, crop_shapes, offsets, (img_h, img_w)) + + # ------------------------------------------------------------------ + # Materialisation + # ------------------------------------------------------------------ + + def to_dense(self) -> npt.NDArray[np.bool_]: + """Materialise all masks as a dense ``(N, H, W)`` boolean array. + + Returns: + Boolean array of shape ``(N, H, W)``. + + Examples: + ```pycon + >>> import numpy as np + >>> from supervision.detection.compact_mask import CompactMask + >>> masks = np.zeros((1, 50, 50), dtype=bool) + >>> masks[0, 10:20, 10:30] = True + >>> xyxy = np.array([[10, 10, 29, 19]], dtype=np.float32) + >>> cm = CompactMask.from_dense(masks, xyxy, image_shape=(50, 50)) + >>> cm.to_dense().shape + (1, 50, 50) + + ``` + """ + num_masks = len(self._rles) + img_h, img_w = self._image_shape + result: npt.NDArray[np.bool_] = np.zeros((num_masks, img_h, img_w), dtype=bool) + for mask_idx in range(num_masks): + crop_h, crop_w = ( + int(self._crop_shapes[mask_idx, 0]), + int(self._crop_shapes[mask_idx, 1]), + ) + x1, y1 = int(self._offsets[mask_idx, 0]), int(self._offsets[mask_idx, 1]) + crop = _rle_counts_to_mask(self._rles[mask_idx], crop_h, crop_w) + result[mask_idx, y1 : y1 + crop_h, x1 : x1 + crop_w] = crop + return result + + def crop(self, index: int) -> npt.NDArray[np.bool_]: + """Decode a single mask crop without allocating the full image array. + + This is an O(crop_area) operation โ€” ideal for annotators that only + need the cropped region. + + Args: + index: Index of the mask to decode. + + Returns: + Boolean array of shape ``(crop_h, crop_w)``. + + Examples: + ```pycon + >>> import numpy as np + >>> from supervision.detection.compact_mask import CompactMask + >>> masks = np.zeros((1, 100, 100), dtype=bool) + >>> masks[0, 20:30, 10:40] = True + >>> xyxy = np.array([[10, 20, 39, 29]], dtype=np.float32) + >>> cm = CompactMask.from_dense(masks, xyxy, image_shape=(100, 100)) + >>> cm.crop(0).shape + (10, 30) + + ``` + """ + crop_h = int(self._crop_shapes[index, 0]) + crop_w = int(self._crop_shapes[index, 1]) + return _rle_counts_to_mask(self._rles[index], crop_h, crop_w) + + # ------------------------------------------------------------------ + # Sequence / array protocol + # ------------------------------------------------------------------ + + def __len__(self) -> int: + """Return the number of masks. + + Returns: + Number of masks N. + + Examples: + ```pycon + >>> from supervision.detection.compact_mask import CompactMask + >>> import numpy as np + >>> cm = CompactMask( + ... [], np.empty((0, 2), dtype=np.int32), + ... np.empty((0, 2), dtype=np.int32), (100, 100)) + >>> len(cm) + 0 + + ``` + """ + return len(self._rles) + + def __iter__(self) -> Iterator[npt.NDArray[np.bool_]]: + """Iterate over masks as dense ``(H, W)`` boolean arrays.""" + for mask_idx in range(len(self)): + yield self[mask_idx] + + @property + def shape(self) -> tuple[int, int, int]: + """Return ``(N, H, W)`` matching the dense mask convention. + + Returns: + Tuple ``(N, H, W)``. + + Examples: + ```pycon + >>> from supervision.detection.compact_mask import CompactMask + >>> import numpy as np + >>> cm = CompactMask( + ... [], np.empty((0, 2), dtype=np.int32), + ... np.empty((0, 2), dtype=np.int32), (480, 640)) + >>> cm.shape + (0, 480, 640) + + ``` + """ + img_h, img_w = self._image_shape + return (len(self), img_h, img_w) + + @property + def image_shape(self) -> tuple[int, int]: + """Return ``(H, W)`` of the full image this mask is scoped to. + + Returns: + Tuple ``(H, W)``. + + Examples: + ```pycon + >>> from supervision.detection.compact_mask import CompactMask + >>> import numpy as np + >>> cm = CompactMask( + ... [], np.empty((0, 2), dtype=np.int32), + ... np.empty((0, 2), dtype=np.int32), (480, 640)) + >>> cm.image_shape + (480, 640) + + ``` + """ + return self._image_shape + + @property + def offsets(self) -> npt.NDArray[np.int32]: + """Return per-mask crop origins as ``(x1, y1)`` integer offsets. + + Returns: + Array of shape ``(N, 2)`` with ``int32`` offsets. + + Examples: + ```pycon + >>> import numpy as np + >>> from supervision.detection.compact_mask import CompactMask + >>> masks = np.zeros((1, 10, 10), dtype=bool) + >>> masks[0, 2:4, 3:5] = True + >>> xyxy = np.array([[3, 2, 4, 3]], dtype=np.float32) + >>> cm = CompactMask.from_dense(masks, xyxy, image_shape=(10, 10)) + >>> cm.offsets.tolist() + [[3, 2]] + + ``` + """ + return self._offsets + + @property + def bbox_xyxy(self) -> npt.NDArray[np.int32]: + """Return per-mask inclusive bounding boxes in ``xyxy`` format. + + Boxes are derived from crop metadata: + ``x2 = x1 + crop_w - 1``, ``y2 = y1 + crop_h - 1``. + + Returns: + Array of shape ``(N, 4)`` with ``int32`` boxes + ``[x1, y1, x2, y2]``. + + Examples: + ```pycon + >>> import numpy as np + >>> from supervision.detection.compact_mask import CompactMask + >>> masks = np.zeros((1, 10, 10), dtype=bool) + >>> masks[0, 2:5, 3:7] = True + >>> xyxy = np.array([[3, 2, 6, 4]], dtype=np.float32) + >>> cm = CompactMask.from_dense(masks, xyxy, image_shape=(10, 10)) + >>> cm.bbox_xyxy.tolist() + [[3, 2, 6, 4]] + + ``` + """ + if len(self) == 0: + return np.empty((0, 4), dtype=np.int32) + + x1: npt.NDArray[np.int32] = self._offsets[:, 0] + y1: npt.NDArray[np.int32] = self._offsets[:, 1] + x2: npt.NDArray[np.int32] = x1 + self._crop_shapes[:, 1] - 1 + y2: npt.NDArray[np.int32] = y1 + self._crop_shapes[:, 0] - 1 + return np.column_stack((x1, y1, x2, y2)).astype(np.int32, copy=False) + + @property + def dtype(self) -> np.dtype[np.bool_]: + """Return ``np.dtype(bool)`` โ€” always. + + Returns: + ``np.dtype(bool)``. + + Examples: + ```pycon + >>> from supervision.detection.compact_mask import CompactMask + >>> import numpy as np + >>> cm = CompactMask( + ... [], np.empty((0, 2), dtype=np.int32), + ... np.empty((0, 2), dtype=np.int32), (100, 100)) + >>> cm.dtype + dtype('bool') + + ``` + """ + return np.dtype(bool) + + @property + def area(self) -> npt.NDArray[np.int64]: + """Compute the area (``True`` pixel count) of each mask. + + Note: + The implementation iterates over the N individual RLE arrays in a + Python loop (one :func:`_rle_area` call per mask). This is negligible + for typical N, but callers processing thousands of detections per + frame should be aware of the per-mask Python-level overhead. + + Returns: + int64 array of shape ``(N,)`` with per-mask pixel counts. + + Examples: + ```pycon + >>> import numpy as np + >>> from supervision.detection.compact_mask import CompactMask + >>> masks = np.zeros((2, 100, 100), dtype=bool) + >>> masks[0, 0:10, 0:10] = True # 100 pixels + >>> masks[1, 0:5, 0:5] = True # 25 pixels + >>> xyxy = np.array([[0, 0, 9, 9], [0, 0, 4, 4]], dtype=np.float32) + >>> cm = CompactMask.from_dense(masks, xyxy, image_shape=(100, 100)) + >>> cm.area.tolist() + [100, 25] + + ``` + """ + return np.array([_rle_area(rle) for rle in self._rles], dtype=np.int64) + + def sum( + self, axis: int | tuple[int, ...] | None = None + ) -> npt.NDArray[np.int64] | np.int64: + """NumPy-compatible sum with a fast path for per-mask area. + + When ``axis=(1, 2)``, returns the per-mask True-pixel count via + :attr:`area` without materialising the full dense array. + + Args: + axis: Axis or axes to sum over. + + Returns: + Sum result matching NumPy semantics. + + Examples: + ```pycon + >>> import numpy as np + >>> from supervision.detection.compact_mask import CompactMask + >>> masks = np.zeros((1, 10, 10), dtype=bool) + >>> masks[0, 0:3, 0:3] = True + >>> xyxy = np.array([[0, 0, 2, 2]], dtype=np.float32) + >>> cm = CompactMask.from_dense(masks, xyxy, image_shape=(10, 10)) + >>> cm.sum(axis=(1, 2)).tolist() + [9] + + ``` + """ + if axis == (1, 2): + return self.area + return cast(npt.NDArray[np.int64] | np.int64, self.to_dense().sum(axis=axis)) + + @overload + def __getitem__(self, index: int | np.integer) -> npt.NDArray[np.bool_]: ... + + @overload + def __getitem__( + self, + index: slice + | list[int] + | list[bool] + | npt.NDArray[np.int_] + | npt.NDArray[np.bool_], + ) -> CompactMask: ... + + def __getitem__( + self, + index: ( + int + | np.integer + | slice + | list[int] + | list[bool] + | npt.NDArray[np.int_] + | npt.NDArray[np.bool_] + ), + ) -> npt.NDArray[np.bool_] | CompactMask: + """Index into the mask collection. + + * ``int`` โ†’ dense ``(H, W)`` bool array (for annotators, iterators). + * ``slice | list | ndarray`` โ†’ new :class:`CompactMask` (for filtering). + + Args: + index: An integer returns a dense ``(H, W)`` mask. Any other + supported index type returns a new :class:`CompactMask`. + + Returns: + Dense ``(H, W)`` ``np.ndarray`` for integer index, or a new + :class:`CompactMask` for all other index types. + + Examples: + ```pycon + >>> import numpy as np + >>> from supervision.detection.compact_mask import CompactMask + >>> masks = np.zeros((3, 20, 20), dtype=bool) + >>> xyxy = np.array( + ... [[0,0,5,5],[5,5,10,10],[10,10,15,15]], dtype=np.float32) + >>> cm = CompactMask.from_dense(masks, xyxy, image_shape=(20, 20)) + >>> cm[0].shape # int โ†’ dense (H, W) + (20, 20) + >>> len(cm[[0, 2]]) # list โ†’ CompactMask + 2 + + ``` + """ + if isinstance(index, (int, np.integer)): + idx = int(index) + img_h, img_w = self._image_shape + result: npt.NDArray[np.bool_] = np.zeros((img_h, img_w), dtype=bool) + crop_h = int(self._crop_shapes[idx, 0]) + crop_w = int(self._crop_shapes[idx, 1]) + x1 = int(self._offsets[idx, 0]) + y1 = int(self._offsets[idx, 1]) + crop = _rle_counts_to_mask(self._rles[idx], crop_h, crop_w) + result[y1 : y1 + crop_h, x1 : x1 + crop_w] = crop + return result + + if isinstance(index, slice): + selected_rles = [rle.copy() for rle in self._rles[index]] + return CompactMask( + selected_rles, + self._crop_shapes[index].copy(), + self._offsets[index].copy(), + self._image_shape, + ) + + # Boolean selectors and fancy index โ†’ convert to integer positions first. + if isinstance(index, np.ndarray) and index.dtype == bool: + idx_arr = np.where(index)[0] + elif isinstance(index, list) and all( + isinstance(item, (bool, np.bool_)) for item in index + ): + idx_arr = np.flatnonzero(np.asarray(index, dtype=bool)) + else: + idx_arr = np.asarray(list(index), dtype=np.intp) + + new_rles = [self._rles[int(mask_idx)].copy() for mask_idx in idx_arr] + new_crop_shapes: npt.NDArray[np.int32] = self._crop_shapes[idx_arr].copy() + new_offsets: npt.NDArray[np.int32] = self._offsets[idx_arr].copy() + return CompactMask(new_rles, new_crop_shapes, new_offsets, self._image_shape) + + def __array__( + self, dtype: np.dtype[np.generic] | None = None + ) -> npt.NDArray[np.generic]: + """NumPy interop: materialise as a dense ``(N, H, W)`` array. + + Called by ``np.asarray(compact_mask)`` and similar NumPy functions. + + Args: + dtype: Optional dtype to cast the result to. + + Returns: + Dense boolean array of shape ``(N, H, W)``. + + Examples: + ```pycon + >>> import numpy as np + >>> from supervision.detection.compact_mask import CompactMask + >>> masks = np.zeros((1, 10, 10), dtype=bool) + >>> xyxy = np.array([[0, 0, 5, 5]], dtype=np.float32) + >>> cm = CompactMask.from_dense(masks, xyxy, image_shape=(10, 10)) + >>> np.asarray(cm).shape + (1, 10, 10) + + ``` + """ + result = self.to_dense() + if dtype is not None: + return result.astype(dtype) + return result + + def __eq__(self, other: object) -> bool: + """Element-wise equality with another :class:`CompactMask` or ndarray. + + Args: + other: Another :class:`CompactMask` or ``np.ndarray``. + + Returns: + ``True`` if all masks are pixel-identical. + + Examples: + ```pycon + >>> import numpy as np + >>> from supervision.detection.compact_mask import CompactMask + >>> masks = np.zeros((1, 10, 10), dtype=bool) + >>> xyxy = np.array([[0, 0, 5, 5]], dtype=np.float32) + >>> cm1 = CompactMask.from_dense(masks, xyxy, image_shape=(10, 10)) + >>> cm2 = CompactMask.from_dense(masks, xyxy, image_shape=(10, 10)) + >>> cm1 == cm2 + True + + ``` + """ + if isinstance(other, CompactMask): + return bool(np.array_equal(self.to_dense(), other.to_dense())) + if isinstance(other, np.ndarray): + return bool(np.array_equal(self.to_dense(), other)) + return NotImplemented + + # ------------------------------------------------------------------ + # Collection utilities + # ------------------------------------------------------------------ + + @staticmethod + def merge(masks_list: list[CompactMask]) -> CompactMask: + """Concatenate multiple :class:`CompactMask` objects into one. + + All inputs must have the same ``image_shape``. + + Args: + masks_list: Non-empty list of :class:`CompactMask` objects. + + Returns: + A new :class:`CompactMask` containing every mask from the inputs, + in order. + + Raises: + ValueError: If ``masks_list`` is empty or image shapes differ. + + Examples: + ```pycon + >>> import numpy as np + >>> from supervision.detection.compact_mask import CompactMask + >>> masks1 = np.zeros((2, 50, 50), dtype=bool) + >>> masks2 = np.zeros((3, 50, 50), dtype=bool) + >>> xyxy1 = np.array([[0,0,10,10],[10,10,20,20]], dtype=np.float32) + >>> xyxy2 = np.array( + ... [[0,0,5,5],[5,5,10,10],[10,10,15,15]], dtype=np.float32) + >>> cm1 = CompactMask.from_dense(masks1, xyxy1, image_shape=(50, 50)) + >>> cm2 = CompactMask.from_dense(masks2, xyxy2, image_shape=(50, 50)) + >>> len(CompactMask.merge([cm1, cm2])) + 5 + + ``` + """ + if not masks_list: + raise ValueError("Cannot merge an empty list of CompactMask objects.") + + image_shape = masks_list[0]._image_shape + for cm in masks_list[1:]: + if cm._image_shape != image_shape: + raise ValueError( + f"Cannot merge CompactMask objects with different image shapes: " + f"{image_shape} vs {cm._image_shape}" + ) + + # list.extend is a C-level call and avoids the per-element Python + # bytecode overhead of a flat list comprehension. This matters under + # GIL contention when multiple threads call merge concurrently. + new_rles: list[npt.NDArray[np.int32]] = [] + for cm in masks_list: + new_rles.extend(cm._rles) + + # np.concatenate handles (0, 2) arrays correctly. + # No .astype() needed โ€” _crop_shapes and _offsets are already int32. + new_crop_shapes: npt.NDArray[np.int32] = np.concatenate( + [cm._crop_shapes for cm in masks_list], axis=0 + ) + new_offsets: npt.NDArray[np.int32] = np.concatenate( + [cm._offsets for cm in masks_list], axis=0 + ) + + return CompactMask(new_rles, new_crop_shapes, new_offsets, image_shape) + + def repack(self) -> CompactMask: + """Re-encode all masks using tight bounding boxes. + + When the original ``xyxy`` boxes are padded or loose โ€” common with + object-detector outputs and full-image boxes used in tests โ€” each RLE + crop encodes more background (``False``) pixels than necessary. This + method decodes every crop, trims it to the minimal rectangle that + contains all ``True`` pixels, and re-encodes. All-``False`` masks are + normalised to a ``1x1`` all-``False`` crop. + + The call is O(sum of crop areas) โ€” suitable as a one-time cleanup + after accumulating many merges (e.g. after + :class:`~supervision.detection.tools.inference_slicer.InferenceSlicer` + tiles are merged). + + Returns: + A new :class:`CompactMask` with minimal-area crops and updated + offsets. + + Examples: + ```pycon + >>> import numpy as np + >>> from supervision.detection.compact_mask import CompactMask + >>> masks = np.zeros((1, 10, 10), dtype=bool) + >>> masks[0, 3:7, 3:7] = True + >>> # Deliberately loose bbox: covers the full image. + >>> xyxy = np.array([[0, 0, 9, 9]], dtype=np.float32) + >>> cm = CompactMask.from_dense(masks, xyxy, image_shape=(10, 10)) + >>> repacked = cm.repack() + >>> repacked.offsets.tolist() # tight origin: x1=3, y1=3 + [[3, 3]] + + ``` + """ + num_masks = len(self._rles) + if num_masks == 0: + return CompactMask( + [], + np.empty((0, 2), dtype=np.int32), + np.empty((0, 2), dtype=np.int32), + self._image_shape, + ) + + new_rles: list[npt.NDArray[np.int32]] = [] + new_crop_shapes_list: list[tuple[int, int]] = [] + new_offsets_list: list[tuple[int, int]] = [] + + for mask_idx in range(num_masks): + crop = self.crop(mask_idx) + x1_off = int(self._offsets[mask_idx, 0]) + y1_off = int(self._offsets[mask_idx, 1]) + + rows_any = np.any(crop, axis=1) + cols_any = np.any(crop, axis=0) + + if not rows_any.any(): + # All-False: normalise to 1x1 to avoid zero-sized arrays. + new_rles.append(_mask_to_rle_counts(np.zeros((1, 1), dtype=bool))) + new_crop_shapes_list.append((1, 1)) + new_offsets_list.append((x1_off, y1_off)) + continue + + y_indices = np.where(rows_any)[0] + x_indices = np.where(cols_any)[0] + y_min, y_max = int(y_indices[0]), int(y_indices[-1]) + x_min, x_max = int(x_indices[0]), int(x_indices[-1]) + + tight = crop[y_min : y_max + 1, x_min : x_max + 1] + new_rles.append(_mask_to_rle_counts(tight)) + new_crop_shapes_list.append((y_max - y_min + 1, x_max - x_min + 1)) + new_offsets_list.append((x1_off + x_min, y1_off + y_min)) + + return CompactMask( + new_rles, + np.array(new_crop_shapes_list, dtype=np.int32), + np.array(new_offsets_list, dtype=np.int32), + self._image_shape, + ) + + # ------------------------------------------------------------------ + # Slicer support + # ------------------------------------------------------------------ + + def with_offset( + self, + dx: int, + dy: int, + new_image_shape: tuple[int, int], + ) -> CompactMask: + """Return a new :class:`CompactMask` with adjusted offsets and image shape. + + Used by :class:`~supervision.detection.tools.inference_slicer.InferenceSlicer` + to relocate tile-local masks into full-image coordinates without + materialising the dense ``(N, H, W)`` array. + + Args: + dx: Pixels to add to every mask's ``x1`` offset. + dy: Pixels to add to every mask's ``y1`` offset. + new_image_shape: ``(H, W)`` of the full (destination) image. + + Returns: + New :class:`CompactMask` with updated offsets and image shape. + Crops are clipped to stay inside ``new_image_shape``; masks fully + outside are represented as ``1x1`` all-False crops. + + Examples: + ```pycon + >>> import numpy as np + >>> from supervision.detection.compact_mask import CompactMask + >>> masks = np.zeros((1, 20, 20), dtype=bool) + >>> xyxy = np.array([[5, 5, 15, 15]], dtype=np.float32) + >>> cm = CompactMask.from_dense(masks, xyxy, image_shape=(20, 20)) + >>> cm2 = cm.with_offset(100, 200, new_image_shape=(400, 400)) + >>> cm2.offsets[0].tolist() + [105, 205] + + ``` + """ + new_h, new_w = new_image_shape + if new_h <= 0 or new_w <= 0: + raise ValueError("new_image_shape must contain positive dimensions") + + num_masks = len(self) + if num_masks == 0: + return CompactMask( + [], + np.empty((0, 2), dtype=np.int32), + np.empty((0, 2), dtype=np.int32), + new_image_shape, + ) + + # Vectorised bounds check: compute every new [x1,y1,x2,y2] at once. + # For the common case (InferenceSlicer tiles that fit fully inside the + # new canvas) this catches the "no clipping needed" path in O(N) numpy + # without touching any RLE data. + new_offsets: npt.NDArray[np.int32] = self._offsets + np.array( + [dx, dy], dtype=np.int32 + ) + x1s = new_offsets[:, 0] + y1s = new_offsets[:, 1] + x2s = x1s + self._crop_shapes[:, 1] - 1 + y2s = y1s + self._crop_shapes[:, 0] - 1 + + needs_clip: npt.NDArray[np.bool_] = ( + (x1s < 0) | (y1s < 0) | (x2s >= new_w) | (y2s >= new_h) + ) + + if not needs_clip.any(): + # Fast path: pure offset arithmetic, no decode/re-encode needed. + return CompactMask( + list(self._rles), + self._crop_shapes.copy(), + new_offsets, + new_image_shape, + ) + + # Slow path: only decode+clip+re-encode the masks that actually overflow. + out_rles: list[npt.NDArray[np.int32]] = [] + out_crop_shapes: list[tuple[int, int]] = [] + out_offsets_list: list[tuple[int, int]] = [] + + for mask_idx in range(num_masks): + x1 = int(x1s[mask_idx]) + y1 = int(y1s[mask_idx]) + x2 = int(x2s[mask_idx]) + y2 = int(y2s[mask_idx]) + + if not needs_clip[mask_idx]: + out_rles.append(self._rles[mask_idx]) + out_crop_shapes.append( + ( + int(self._crop_shapes[mask_idx, 0]), + int(self._crop_shapes[mask_idx, 1]), + ) + ) + out_offsets_list.append((x1, y1)) + continue + + ix1 = max(0, x1) + iy1 = max(0, y1) + ix2 = min(new_w - 1, x2) + iy2 = min(new_h - 1, y2) + + if ix1 > ix2 or iy1 > iy2: + anchor_x = min(max(x1, 0), new_w - 1) + anchor_y = min(max(y1, 0), new_h - 1) + out_rles.append(_mask_to_rle_counts(np.zeros((1, 1), dtype=bool))) + out_crop_shapes.append((1, 1)) + out_offsets_list.append((anchor_x, anchor_y)) + continue + + crop = self.crop(mask_idx) + clipped = crop[iy1 - y1 : iy2 - y1 + 1, ix1 - x1 : ix2 - x1 + 1] + out_rles.append(_mask_to_rle_counts(clipped)) + out_crop_shapes.append((iy2 - iy1 + 1, ix2 - ix1 + 1)) + out_offsets_list.append((ix1, iy1)) + + return CompactMask( + out_rles, + np.array(out_crop_shapes, dtype=np.int32), + np.array(out_offsets_list, dtype=np.int32), + new_image_shape, + ) + + # ------------------------------------------------------------------ + # Resize + # ------------------------------------------------------------------ + + def resize(self, new_image_shape: tuple[int, int]) -> CompactMask: + """Return a new CompactMask scaled to a different image resolution. + + Each crop mask is resized with nearest-neighbour interpolation. + Sparse masks use direct RLE arithmetic (:func:`_rle_resize`); dense + masks fall back to ``cv2.resize(INTER_NEAREST)``. Offsets and crop + dimensions are scaled proportionally to the new image size. + + Performance notes: + + * Coordinate arithmetic is fully vectorised (no Python loop over N). + * All-``False`` crops skip decode/resize entirely. + * For N >= 8, resize runs in a thread pool โ€” NumPy and OpenCV + release the GIL so crops execute in parallel on multi-core CPUs. + + Args: + new_image_shape: ``(H, W)`` of the target image. + + Returns: + New :class:`CompactMask` with updated ``image_shape``, scaled + offsets, scaled crop shapes, and re-encoded RLE crops. + + Raises: + ValueError: If any dimension in *new_image_shape* is ``<= 0``. + + Examples: + ```pycon + >>> import numpy as np + >>> from supervision.detection.compact_mask import CompactMask + >>> masks = np.zeros((1, 100, 100), dtype=bool) + >>> masks[0, 20:40, 30:60] = True + >>> xyxy = np.array([[30, 20, 59, 39]], dtype=np.float32) + >>> cm = CompactMask.from_dense(masks, xyxy, image_shape=(100, 100)) + >>> small = cm.resize((50, 50)) + >>> small.shape + (1, 50, 50) + >>> small.offsets[0].tolist() + [15, 10] + + ``` + """ + from concurrent.futures import ThreadPoolExecutor + + new_h, new_w = new_image_shape + if new_h <= 0 or new_w <= 0: + raise ValueError("new_image_shape must contain positive dimensions") + + # fast path โ€” identity resize; list() creates a new container but the + # individual RLE numpy arrays are shared (shallow copy). Callers must + # not mutate returned RLE arrays in-place. + if (new_h, new_w) == self._image_shape: + return CompactMask( + list(self._rles), + self._crop_shapes.copy(), + self._offsets.copy(), + new_image_shape, + ) + + # empty guard + if len(self) == 0: + return CompactMask( + [], + np.empty((0, 2), dtype=np.int32), + np.empty((0, 2), dtype=np.int32), + new_image_shape, + ) + + img_h, img_w = self._image_shape + sx = new_w / img_w + sy = new_h / img_h + + # L1 โ€” vectorised coordinate arithmetic; no Python loop over N masks. + x1s = self._offsets[:, 0].astype(np.float64) + y1s = self._offsets[:, 1].astype(np.float64) + x2s = x1s + self._crop_shapes[:, 1] - 1 # inclusive right edge + y2s = y1s + self._crop_shapes[:, 0] - 1 # inclusive bottom edge + + new_x1s = np.clip(np.round(x1s * sx), 0, new_w - 1).astype(np.int32) + new_y1s = np.clip(np.round(y1s * sy), 0, new_h - 1).astype(np.int32) + new_x2s = np.clip(np.round(x2s * sx), 0, new_w - 1).astype(np.int32) + new_y2s = np.clip(np.round(y2s * sy), 0, new_h - 1).astype(np.int32) + new_crop_ws: npt.NDArray[np.int32] = np.maximum( + 1, new_x2s - new_x1s + 1 + ).astype(np.int32) + new_crop_hs: npt.NDArray[np.int32] = np.maximum( + 1, new_y2s - new_y1s + 1 + ).astype(np.int32) + + # L2b โ€” parallel per-crop resize; NumPy and OpenCV release the GIL. + orig_crop_hs = self._crop_shapes[:, 0] + orig_crop_ws = self._crop_shapes[:, 1] + + args = [ + ( + self._rles[i], + int(orig_crop_hs[i]), + int(orig_crop_ws[i]), + int(new_crop_hs[i]), + int(new_crop_ws[i]), + ) + for i in range(len(self)) + ] + + n = len(self) + if n >= _PARALLEL_THRESHOLD: + with ThreadPoolExecutor(max_workers=min(n, os.cpu_count() or 4)) as pool: + new_rles: list[npt.NDArray[np.int32]] = list( + pool.map(lambda a: _resize_crop(*a), args) + ) + else: + new_rles = [_resize_crop(*a) for a in args] + + new_crop_shapes = np.column_stack((new_crop_hs, new_crop_ws)).astype(np.int32) + new_offsets = np.column_stack((new_x1s, new_y1s)).astype(np.int32) + return CompactMask(new_rles, new_crop_shapes, new_offsets, new_image_shape) diff --git a/src/supervision/detection/core.py b/src/supervision/detection/core.py new file mode 100644 index 0000000..50b6bf1 --- /dev/null +++ b/src/supervision/detection/core.py @@ -0,0 +1,3477 @@ +from __future__ import annotations + +import warnings +from collections.abc import Iterator +from dataclasses import dataclass, field +from functools import reduce +from typing import Any, cast + +import numpy as np +import numpy.typing as npt +from deprecate import deprecated, void + +from supervision.config import ( + CLASS_NAME_DATA_FIELD, + ORIENTED_BOX_COORDINATES, +) +from supervision.detection.compact_mask import CompactMask +from supervision.detection.tools.transformers import ( + process_transformers_detection_result, + process_transformers_v4_segmentation_result, + process_transformers_v5_segmentation_result, +) +from supervision.detection.utils._typing import ( + _DetectionDataType, + _DetectionDataValueType, + _MetadataType, +) +from supervision.detection.utils.boxes import ( + _oriented_box_anchors, + obb_polygon_area, + xyxyxyxy_to_xyxy, +) +from supervision.detection.utils.converters import ( + mask_to_xyxy, + polygon_to_mask, + rle_to_mask, + xywh_to_xyxy, +) +from supervision.detection.utils.internal import ( + extract_ultralytics_masks, + get_data_item, + is_data_equal, + is_metadata_equal, + merge_data, + merge_metadata, + process_roboflow_result, +) +from supervision.detection.utils.iou_and_nms import ( + OverlapMetric, + box_iou_batch, + box_non_max_merge, + box_non_max_suppression, + mask_iou_batch, + mask_non_max_merge, + mask_non_max_suppression, + oriented_box_non_max_merge, + oriented_box_non_max_suppression, +) +from supervision.detection.utils.masks import ( + calculate_masks_centroids, + count_mask_pixels, +) +from supervision.detection.vlm import ( + LMM, + VLM, + _validate_vlm_parameters, + from_deepseek_vl_2, + from_florence_2, + from_google_gemini_2_0, + from_google_gemini_2_5, + from_moondream, + from_paligemma, + from_qwen_2_5_vl, + from_qwen_3_vl, +) +from supervision.geometry.core import Position +from supervision.utils.internal import ( + SupervisionWarnings, + get_instance_variables, + warn_deprecated, +) +from supervision.validators import ( + _validate_data, + _validate_detections_fields, + _validate_resolution, +) + + +@dataclass +class Detections: + """ + The `sv.Detections` class in the Supervision library standardizes results from + various object detection and segmentation models into a consistent format. This + class simplifies data manipulation and filtering, providing a uniform API for + integration with Supervision [trackers](/trackers/), [annotators](/latest/detection/annotators/), and [tools](/detection/tools/line_zone/). + + === "Inference" + + Use [`sv.Detections.from_inference`](/detection/core/#supervision.detection.core.Detections.from_inference) + method, which accepts model results from both detection and segmentation models. + + ```python + import cv2 + import supervision as sv + from inference import get_model + + model = get_model(model_id="yolov8n-640") + image = cv2.imread("") + results = model.infer(image)[0] + detections = sv.Detections.from_inference(results) + ``` + + === "Ultralytics" + + Use [`sv.Detections.from_ultralytics`](/detection/core/#supervision.detection.core.Detections.from_ultralytics) + method, which accepts model results from both detection and segmentation models. + + ```python + import cv2 + import supervision as sv + from ultralytics import YOLO + + model = YOLO("yolov8n.pt") + image = cv2.imread("") + results = model(image)[0] + detections = sv.Detections.from_ultralytics(results) + ``` + + === "Transformers" + + Use [`sv.Detections.from_transformers`](/detection/core/#supervision.detection.core.Detections.from_transformers) + method, which accepts model results from both detection and segmentation models. + + ```python + import torch + import supervision as sv + from PIL import Image + from transformers import DetrImageProcessor, DetrForObjectDetection + + processor = DetrImageProcessor.from_pretrained("facebook/detr-resnet-50") + model = DetrForObjectDetection.from_pretrained("facebook/detr-resnet-50") + + image = Image.open("") + inputs = processor(images=image, return_tensors="pt") + + with torch.no_grad(): + outputs = model(**inputs) + + width, height = image.size + target_size = torch.tensor([[height, width]]) + results = processor.post_process_object_detection( + outputs=outputs, target_sizes=target_size)[0] + detections = sv.Detections.from_transformers( + transformers_results=results, + id2label=model.config.id2label) + ``` + + Attributes: + xyxy: An array of shape `(n, 4)` containing + the bounding boxes coordinates in format `[x1, y1, x2, y2]` + mask: An array of shape `(n, H, W)` containing the segmentation masks + (`bool` data type), or `None` when masks are not available, or as + :class:`~supervision.detection.compact_mask.CompactMask`. + confidence: An array of shape `(n,)` containing the confidence scores + of the detections, or `None` when confidence values are not available. + class_id: An array of shape `(n,)` containing the class ids of the + detections, or `None` when class ids are not available. + tracker_id: An array of shape `(n,)` containing the tracker ids of the + detections, or `None` when tracker ids are not available. + data: A dictionary containing additional + data where each key is a string representing the data type, and the value + is either a NumPy array or a list of corresponding data. + metadata: A dictionary containing collection-level metadata + that applies to the entire set of detections. This may include information such + as the video name, camera parameters, timestamp, or other global metadata. + """ # noqa: E501 // docs + + xyxy: npt.NDArray[np.number] + mask: npt.NDArray[np.bool_] | CompactMask | None = None + confidence: npt.NDArray[np.floating] | None = None + class_id: npt.NDArray[np.integer] | None = None + tracker_id: npt.NDArray[np.integer] | None = None + data: _DetectionDataType = field(default_factory=dict) + metadata: _MetadataType = field(default_factory=dict) + + def __post_init__(self) -> None: + _validate_detections_fields( + xyxy=self.xyxy, + mask=self.mask, + confidence=self.confidence, + class_id=self.class_id, + tracker_id=self.tracker_id, + data=self.data, + ) + + def __len__(self) -> int: + """ + Returns the number of detections in the Detections object. + """ + return len(self.xyxy) + + def __iter__( + self, + ) -> Iterator[ + tuple[ + npt.NDArray[np.number], + npt.NDArray[np.bool_] | None, + np.generic | None, + np.generic | None, + np.generic | None, + _DetectionDataType, + ] + ]: + """ + Iterates over the Detections object and yield a tuple of + `(xyxy, mask, confidence, class_id, tracker_id, data)` for each detection. + """ + for i in range(len(self.xyxy)): + yield ( + self.xyxy[i], + self.mask[i] if self.mask is not None else None, + self.confidence[i] if self.confidence is not None else None, + self.class_id[i] if self.class_id is not None else None, + self.tracker_id[i] if self.tracker_id is not None else None, + get_data_item(self.data, i), + ) + + def __eq__(self, other: object) -> bool: + if not isinstance(other, Detections): + return NotImplemented + + def array_equal_or_none( + a: npt.NDArray[np.generic] | None, + b: npt.NDArray[np.generic] | None, + ) -> bool: + if a is None or b is None: + return a is b + return bool(np.array_equal(a, b)) + + def mask_equal( + a: npt.NDArray[np.generic] | CompactMask | None, + b: npt.NDArray[np.generic] | CompactMask | None, + ) -> bool: + if a is None or b is None: + return a is b + if isinstance(a, CompactMask): + return bool(a == b) + if isinstance(b, CompactMask): + return bool(b == a) + return bool(np.array_equal(a, b)) + + return all( + [ + np.array_equal(self.xyxy, other.xyxy), + mask_equal(self.mask, other.mask), + array_equal_or_none(self.class_id, other.class_id), + array_equal_or_none(self.confidence, other.confidence), + array_equal_or_none(self.tracker_id, other.tracker_id), + is_data_equal(self.data, other.data), + is_metadata_equal(self.metadata, other.metadata), + ] + ) + + @classmethod + def from_yolov5(cls, yolov5_results: Any) -> Detections: + """ + Creates a Detections instance from a + [YOLOv5](https://github.com/ultralytics/yolov5) inference result. + + Args: + yolov5_results: The output Detections instance from YOLOv5. + + Returns: + A new Detections object. + + Example: + ```python + import cv2 + import torch + import supervision as sv + + image = cv2.imread("") + model = torch.hub.load('ultralytics/yolov5', 'yolov5s') + result = model(image) + detections = sv.Detections.from_yolov5(result) + ``` + """ + yolov5_detections_predictions = yolov5_results.pred[0].cpu().cpu().numpy() + + return cls( + xyxy=yolov5_detections_predictions[:, :4], + confidence=yolov5_detections_predictions[:, 4], + class_id=yolov5_detections_predictions[:, 5].astype(int), + ) + + @classmethod + def from_ultralytics(cls, ultralytics_results: Any) -> Detections: + """ + Creates a `sv.Detections` instance from a + [YOLOv8](https://github.com/ultralytics/ultralytics) inference result. + + !!! Note + + `from_ultralytics` is compatible with + [detection](https://docs.ultralytics.com/tasks/detect/), + [segmentation](https://docs.ultralytics.com/tasks/segment/), and + [OBB](https://docs.ultralytics.com/tasks/obb/) models. + + Args: + ultralytics_results: The output Results instance from Ultralytics. + + Returns: + A new Detections object. + + Example: + ```python + import cv2 + import supervision as sv + from ultralytics import YOLO + + image = cv2.imread("") + model = YOLO('yolov8s.pt') + results = model(image)[0] + detections = sv.Detections.from_ultralytics(results) + ``` + """ + + if hasattr(ultralytics_results, "obb") and ultralytics_results.obb is not None: + class_id = ultralytics_results.obb.cls.cpu().numpy().astype(int) + class_names = np.array([ultralytics_results.names[i] for i in class_id]) + oriented_box_coordinates = ultralytics_results.obb.xyxyxyxy.cpu().numpy() + return cls( + xyxy=ultralytics_results.obb.xyxy.cpu().numpy(), + confidence=ultralytics_results.obb.conf.cpu().numpy(), + class_id=class_id, + tracker_id=( + ultralytics_results.obb.id.int().cpu().numpy() + if ultralytics_results.obb.id is not None + else None + ), + data={ + ORIENTED_BOX_COORDINATES: oriented_box_coordinates, + CLASS_NAME_DATA_FIELD: class_names, + }, + ) + + if hasattr(ultralytics_results, "boxes") and ultralytics_results.boxes is None: + masks = extract_ultralytics_masks(ultralytics_results) + if masks is None: + empty = cls.empty() + empty.data = {CLASS_NAME_DATA_FIELD: np.empty(0, dtype=str)} + return empty + return cls( + xyxy=mask_to_xyxy(masks), + mask=masks, + class_id=np.arange(len(ultralytics_results)), + ) + + if ( + hasattr(ultralytics_results, "boxes") + and ultralytics_results.boxes is not None + ): + class_id = ultralytics_results.boxes.cls.cpu().numpy().astype(int) + class_names = np.array([ultralytics_results.names[i] for i in class_id]) + return cls( + xyxy=ultralytics_results.boxes.xyxy.cpu().numpy(), + confidence=ultralytics_results.boxes.conf.cpu().numpy(), + class_id=class_id, + mask=extract_ultralytics_masks(ultralytics_results), + tracker_id=( + ultralytics_results.boxes.id.int().cpu().numpy() + if ultralytics_results.boxes.id is not None + else None + ), + data={CLASS_NAME_DATA_FIELD: class_names}, + ) + + empty = cls.empty() + empty.data = {CLASS_NAME_DATA_FIELD: np.empty(0, dtype=str)} + return empty + + @classmethod + def from_yolo_nas(cls, yolo_nas_results: Any) -> Detections: + """ + Creates a Detections instance from a + [YOLO-NAS](https://github.com/Deci-AI/super-gradients/blob/master/YOLONAS.md) + inference result. + + Args: + yolo_nas_results: The output Results instance from YOLO-NAS. + ImageDetectionPrediction is coming from + 'super_gradients.training.models.prediction_results'. + + Returns: + A new Detections object. + + Example: + ```python + import cv2 + from super_gradients.training import models + import supervision as sv + + image = cv2.imread("") + model = models.get('yolo_nas_l', pretrained_weights="coco") + + result = list(model.predict(image, conf=0.35))[0] + detections = sv.Detections.from_yolo_nas(result) + ``` + """ + if np.asarray(yolo_nas_results.prediction.bboxes_xyxy).shape[0] == 0: + return cls.empty() + + return cls( + xyxy=yolo_nas_results.prediction.bboxes_xyxy, + confidence=yolo_nas_results.prediction.confidence, + class_id=yolo_nas_results.prediction.labels.astype(int), + ) + + @classmethod + def from_tensorflow( + cls, tensorflow_results: dict[str, Any], resolution_wh: tuple[int, int] + ) -> Detections: + """ + Creates a Detections instance from a + [Tensorflow Hub](https://www.tensorflow.org/hub/tutorials/tf2_object_detection) + inference result. + + Args: + tensorflow_results: Raw output dict from a TensorFlow Hub + object-detection model. Must contain: + ``"detection_boxes"`` (shape ``[1, N, 4]``, normalized + ``[ymin, xmin, ymax, xmax]``), ``"detection_scores"`` + (shape ``[1, N]``), and ``"detection_classes"`` + (shape ``[1, N]``). + resolution_wh: The input image resolution as `(width, height)`. + Bounding boxes from Tensorflow are normalized and are scaled + to absolute coordinates using this resolution. + + Returns: + A new Detections object. + + Note: + TensorFlow Hub object-detection models return bounding boxes + normalized as ``[ymin, xmin, ymax, xmax]``. This method rescales + them to absolute pixel coordinates and reorders them to ``xyxy`` + (``[xmin, ymin, xmax, ymax]``) before constructing the + :class:`Detections` object. + + Example: + ```python + import tensorflow as tf + import tensorflow_hub as hub + import numpy as np + import cv2 + + module_handle = "https://tfhub.dev/tensorflow/centernet/hourglass_512x512_kpts/1" + model = hub.load(module_handle) + img = np.array(cv2.imread("")) + result = model(img) + detections = sv.Detections.from_tensorflow( + result, resolution_wh=(img.shape[1], img.shape[0]) + ) + ``` + """ + + # Tensorflow returns normalized boxes as [ymin, xmin, ymax, xmax], so the + # y coordinates (cols 0, 2) scale by height and x (cols 1, 3) by width. + # `.numpy()` may share memory with the source tensor, so copy before the + # in-place scaling to avoid mutating the caller's result / double-scaling. + boxes = tensorflow_results["detection_boxes"][0].numpy().copy() + boxes[:, [0, 2]] *= resolution_wh[1] + boxes[:, [1, 3]] *= resolution_wh[0] + boxes = boxes[:, [1, 0, 3, 2]] + return cls( + xyxy=boxes, + confidence=tensorflow_results["detection_scores"][0].numpy(), + class_id=tensorflow_results["detection_classes"][0].numpy().astype(int), + ) + + @classmethod + def from_deepsparse(cls, deepsparse_results: Any) -> Detections: + """ + Creates a Detections instance from a + [DeepSparse](https://github.com/neuralmagic/deepsparse) + inference result. + + Args: + deepsparse_results: The output Results instance from DeepSparse. + + Returns: + A new Detections object. + + Example: + ```python + import supervision as sv + from deepsparse import Pipeline + + yolo_pipeline = Pipeline.create( + task="yolo", + model_path = "zoo:cv/detection/yolov5-l/pytorch/ultralytics/coco/pruned80_quant-none" + ) + result = yolo_pipeline() + detections = sv.Detections.from_deepsparse(result) + ``` + """ # noqa: E501 // docs + + if np.asarray(deepsparse_results.boxes[0]).shape[0] == 0: + return cls.empty() + + return cls( + xyxy=np.array(deepsparse_results.boxes[0]), + confidence=np.array(deepsparse_results.scores[0]), + class_id=np.array(deepsparse_results.labels[0]).astype(float).astype(int), + ) + + @classmethod + def from_mmdetection(cls, mmdet_results: Any) -> Detections: + """ + Creates a Detections instance from a + [mmdetection](https://github.com/open-mmlab/mmdetection) and + [mmyolo](https://github.com/open-mmlab/mmyolo) inference result. + + Args: + mmdet_results: The output Results instance from MMDetection. + + Returns: + A new Detections object. + + Example: + ```python + import cv2 + import supervision as sv + from mmdet.apis import init_detector, inference_detector + + image = cv2.imread("") + model = init_detector("", "", device="") + + result = inference_detector(model, image) + detections = sv.Detections.from_mmdetection(result) + ``` + """ + + return cls( + xyxy=mmdet_results.pred_instances.bboxes.cpu().numpy(), + confidence=mmdet_results.pred_instances.scores.cpu().numpy(), + class_id=mmdet_results.pred_instances.labels.cpu().numpy().astype(int), + mask=( + mmdet_results.pred_instances.masks.cpu().numpy() + if "masks" in mmdet_results.pred_instances + else None + ), + ) + + @classmethod + def from_transformers( + cls, + transformers_results: dict[str, Any], + id2label: dict[int, str] | None = None, + ) -> Detections: + """ + Creates a Detections instance from object detection or panoptic, semantic + and instance segmentation + [Transformer](https://github.com/huggingface/transformers) inference result. + + Args: + transformers_results: Inference results from your Transformers model. + This can be either a dictionary containing valuable outputs like + `scores`, `labels`, `boxes`, `masks`, `segments_info`, and + `segmentation`, or a `torch.Tensor` holding a segmentation map + where values represent class IDs. + id2label: A dictionary mapping class IDs to labels, typically part of + the `transformers` model configuration. If provided, the resulting + dictionary will include class names. + + Returns: + A new Detections object. + + Example: + ```python + import torch + import supervision as sv + from PIL import Image + from transformers import DetrImageProcessor, DetrForObjectDetection + + processor = DetrImageProcessor.from_pretrained("facebook/detr-resnet-50") + model = DetrForObjectDetection.from_pretrained("facebook/detr-resnet-50") + + image = Image.open("") + inputs = processor(images=image, return_tensors="pt") + + with torch.no_grad(): + outputs = model(**inputs) + + width, height = image.size + target_size = torch.tensor([[height, width]]) + results = processor.post_process_object_detection( + outputs=outputs, target_sizes=target_size)[0] + + detections = sv.Detections.from_transformers( + transformers_results=results, + id2label=model.config.id2label + ) + ``` + """ + + if ( + transformers_results.__class__.__name__ == "Tensor" + or "segmentation" in transformers_results + ): + return cls( + **process_transformers_v5_segmentation_result( + transformers_results, id2label + ) + ) + + if "masks" in transformers_results or "png_string" in transformers_results: + return cls( + **process_transformers_v4_segmentation_result( + transformers_results, id2label + ) + ) + + if "boxes" in transformers_results: + return cls( + **process_transformers_detection_result(transformers_results, id2label) + ) + + else: + raise ValueError( + "The provided Transformers results do not contain any valid fields." + " Expected fields are 'boxes', 'masks', 'segments_info' or" + " 'segmentation'." + ) + + @classmethod + def from_detectron2(cls, detectron2_results: Any) -> Detections: + """ + Create a Detections object from the + [Detectron2](https://github.com/facebookresearch/detectron2) inference result. + + Args: + detectron2_results: The output of a + Detectron2 model containing instances with prediction data. + + Returns: + A Detections object containing the bounding boxes, + class IDs, and confidences of the predictions. + + Example: + ```python + import cv2 + import supervision as sv + from detectron2.engine import DefaultPredictor + from detectron2.config import get_cfg + + + image = cv2.imread("") + cfg = get_cfg() + cfg.merge_from_file("") + cfg.MODEL.WEIGHTS = "" + predictor = DefaultPredictor(cfg) + + result = predictor(image) + detections = sv.Detections.from_detectron2(result) + ``` + """ + + return cls( + xyxy=detectron2_results["instances"].pred_boxes.tensor.cpu().numpy(), + confidence=detectron2_results["instances"].scores.cpu().numpy(), + mask=( + detectron2_results["instances"].pred_masks.cpu().numpy() + if hasattr(detectron2_results["instances"], "pred_masks") + else None + ), + class_id=detectron2_results["instances"] + .pred_classes.cpu() + .numpy() + .astype(int), + ) + + @classmethod + def from_inference( + cls, + roboflow_result: dict[str, Any] | Any, + *, + compact_masks: bool = False, + ) -> Detections: + """ + Create a `sv.Detections` object from the [Roboflow](https://roboflow.com/) + API inference result or the [Inference](https://inference.roboflow.com/) + package results. This method extracts bounding boxes, class IDs, + confidences, and class names from the Roboflow API result and encapsulates + them into a Detections object. + + Args: + roboflow_result: The result from the + Roboflow API or Inference package containing predictions. + compact_masks: When `True`, return segmentation masks as + :class:`~supervision.detection.compact_mask.CompactMask`. + The default `False` preserves the existing dense NumPy mask + representation. + + Warning: + When `compact_masks=True`, the crop policy depends on how + each prediction encodes its mask: + + - Native size-matched COCO-RLE (the RLE `size` equals the + image size) is **cropped to the detector bounding box** + (`xyxy`). For instance-segmentation models the detector + box may not tightly bound the mask, so pixels beyond the + box boundary are silently dropped. + - Polygon-derived masks (`points`) and size-mismatched + COCO-RLE masks (decoded, then resized to the image) are + retained **full-frame** and lose no pixels. + + Because only the box-cropped path is lossy, + `from_inference(r)` and + `from_inference(r, compact_masks=True)` can return masks + with different areas and IoU **only** for native + size-matched COCO-RLE predictions. Use `compact_masks=True` + only when the memory savings outweigh the boundary loss on + that path. + + Returns: + A Detections object containing the bounding boxes, class IDs, + and confidences of the predictions. + `detections.data["class_name"]` is always present as a + string-dtype NumPy array aligned with the detections; it is + empty (shape `(0,)`, dtype str) when `predictions` is empty + or absent. `detections.tracker_id` is `None` when no + predictions carry a tracker ID, or when only a subset do + (mixed batch) โ€” in that case all tracker IDs are dropped to + preserve alignment with the bounding boxes. Similarly, + `detections.mask` is `None` when no predictions include mask + data, or when only a subset carry masks โ€” all masks are dropped + to preserve xyxy alignment. + When `compact_masks=True` and all predictions carry mask data, + `detections.mask` is a + :class:`~supervision.detection.compact_mask.CompactMask` rather + than a dense boolean array. + + Example: + ```python + import cv2 + import supervision as sv + from inference import get_model + + image = cv2.imread("") + model = get_model(model_id="yolov8s-640") + + result = model.infer(image)[0] + detections = sv.Detections.from_inference(result) + compact_detections = sv.Detections.from_inference( + result, compact_masks=True + ) + ``` + """ + if hasattr(roboflow_result, "dict"): + roboflow_result = roboflow_result.dict(exclude_none=True, by_alias=True) + elif hasattr(roboflow_result, "json"): + roboflow_result = roboflow_result.json() + masks: npt.NDArray[np.bool_] | CompactMask | None + # Design note (ADR): the `compact_masks` flag changes the runtime type of + # `detections.mask` from `NDArray[bool_]` to `CompactMask`, so every mask + # consumer must branch on `isinstance(detections.mask, CompactMask)`. A + # typed factory / `mask_format=` enum would be cleaner but would require a + # deprecation cycle if introduced later. + if compact_masks: + xyxy, confidence, class_id, masks, trackers, data = process_roboflow_result( + roboflow_result=roboflow_result, compact_masks=True + ) + else: + xyxy, confidence, class_id, masks, trackers, data = process_roboflow_result( + roboflow_result=roboflow_result + ) + + if np.asarray(xyxy).shape[0] == 0: + empty_detection = cls.empty() + empty_detection.data = data + return empty_detection + + return cls( + xyxy=xyxy, + confidence=confidence, + class_id=class_id, + mask=masks, + tracker_id=trackers, + data=data, + ) + + @classmethod + def from_sam(cls, sam_result: list[dict[str, Any]]) -> Detections: + """ + Creates a Detections instance from + [Segment Anything Model](https://github.com/facebookresearch/segment-anything) + inference result. + + Args: + sam_result: The output Results instance from SAM. + + Returns: + A new Detections object. + + Example: + ```python + import supervision as sv + from segment_anything import ( + sam_model_registry, + SamAutomaticMaskGenerator + ) + + sam_model_reg = sam_model_registry[MODEL_TYPE] + sam = sam_model_reg(checkpoint=CHECKPOINT_PATH).to(device=DEVICE) + mask_generator = SamAutomaticMaskGenerator(sam) + sam_result = mask_generator.generate(IMAGE) + detections = sv.Detections.from_sam(sam_result=sam_result) + ``` + """ + + sorted_generated_masks = sorted( + sam_result, key=lambda x: x["area"], reverse=True + ) + if len(sorted_generated_masks) == 0: + return cls.empty() + + xywh = np.array([mask["bbox"] for mask in sorted_generated_masks]) + segmentations = [mask["segmentation"] for mask in sorted_generated_masks] + first_segmentation = segmentations[0] + + if all(isinstance(segmentation, np.ndarray) for segmentation in segmentations): + mask = np.stack(segmentations, axis=0) + elif all(isinstance(segmentation, dict) for segmentation in segmentations): + image_height, image_width = cast( + tuple[int, int], tuple(int(v) for v in first_segmentation["size"]) + ) + mask = np.stack( + [ + rle_to_mask( + segmentation["counts"], + (image_width, image_height), + ) + for segmentation in segmentations + ], + axis=0, + ) + else: + raise ValueError( + "SAM segmentations must all be dense arrays or COCO RLE dictionaries." + ) + + xyxy = xywh_to_xyxy(xywh=xywh) + return cls(xyxy=xyxy, mask=mask) + + @classmethod + def from_sam3( + cls, sam3_result: dict[str, Any] | Any, resolution_wh: tuple[int, int] + ) -> Detections: + """ + Creates a Detections instance from + [SAM 3](https://github.com/facebookresearch/sam3) inference result. + Supports both PVS and PCS SAM3 segmentation formats. + + Args: + sam3_result: The output result from SAM 3 inference, either + Sam3PromptResult from inference package or dict containing + prompt_results with polygon predictions. + resolution_wh: The width and height of the image used for mask + generation. + + Returns: + A new Detections object. The `class_id` field contains the prompt + index for each polygon. + + Example: + ```python + import cv2 + import supervision as sv + from inference.models.sam3 import SegmentAnything3 + from inference.core.entities.requests.sam3 import Sam3Prompt + + image = cv2.imread("") + model = SegmentAnything3( + model_id="sam3/sam3_final", + api_key="" + ) + + prompts = [ + Sam3Prompt(type="text", text="car"), + Sam3Prompt(type="text", text="tire"), + ] + + result = model.segment_image( + image=image, + prompts=prompts, + output_prob_thresh=0.5, + format="polygon" + ) + + height, width = image.shape[:2] + detections = sv.Detections.from_sam3( + sam3_result=result, + resolution_wh=(width, height) + ) + ``` + """ + width, height = _validate_resolution(resolution_wh) + + masks = [] + confidences = [] + class_ids = [] + + if isinstance(sam3_result, dict): + prompt_results = sam3_result.get("prompt_results", []) + if not prompt_results and "predictions" in sam3_result: + prompt_results = [ + {"predictions": sam3_result["predictions"], "prompt_index": 0} + ] + else: + prompt_results = getattr(sam3_result, "prompt_results", []) + if not prompt_results and hasattr(sam3_result, "predictions"): + prompt_results = [ + { + "predictions": getattr(sam3_result, "predictions"), + "prompt_index": 0, + } + ] + + for i, prompt_result in enumerate(prompt_results): + if isinstance(prompt_result, dict): + predictions = prompt_result.get("predictions", []) + prompt_index = prompt_result.get("prompt_index", i) + else: + predictions = getattr(prompt_result, "predictions", []) + prompt_index = getattr(prompt_result, "prompt_index", i) + + for prediction in predictions: + if isinstance(prediction, dict): + prediction_format = prediction.get("format") + if prediction_format and prediction_format != "polygon": + continue + pred_masks = prediction.get("masks", []) + confidence = prediction.get("confidence", 1.0) + else: + prediction_format = getattr(prediction, "format", None) + if prediction_format and prediction_format != "polygon": + continue + pred_masks = getattr(prediction, "masks", []) + confidence = getattr(prediction, "confidence", 1.0) + + if not pred_masks: + continue + + full_mask: npt.NDArray[np.bool_] = np.zeros((height, width), dtype=bool) + for poly in pred_masks: + polygon = np.array(poly, dtype=np.int32) + mask = polygon_to_mask( + polygon=polygon, resolution_wh=(width, height) + ) + mask = mask.astype(bool, copy=False) + np.logical_or(full_mask, mask, out=full_mask) + + masks.append(full_mask) + confidences.append(confidence) + class_ids.append(prompt_index) + + if not masks: + return cls.empty() + + masks_np = np.stack(masks, axis=0) + xyxy = mask_to_xyxy(masks_np) + + return cls( + xyxy=xyxy.astype(np.float32), + mask=masks_np, + confidence=np.array(confidences, dtype=np.float32), + class_id=np.array(class_ids, dtype=int), + ) + + @classmethod + def from_azure_analyze_image( + cls, azure_result: dict[str, Any], class_map: dict[int, str] | None = None + ) -> Detections: + """ + Creates a Detections instance from [Azure Image Analysis 4.0]( + https://learn.microsoft.com/en-us/azure/ai-services/computer-vision/ + concept-object-detection-40). + + Args: + azure_result: The result from Azure Image Analysis. It should + contain detected objects and their bounding box coordinates. + class_map: A mapping of class IDs to class names. If None, a new + mapping is created dynamically. + + Returns: + A new Detections object. + + Example: + ```python + import requests + import supervision as sv + + image = open(input, "rb").read() + + endpoint = "https://.cognitiveservices.azure.com/" + subscription_key = "" + + headers = { + "Content-Type": "application/octet-stream", + "Ocp-Apim-Subscription-Key": subscription_key + } + + response = requests.post(endpoint, + headers=self.headers, + data=image + ).json() + + detections = sv.Detections.from_azure_analyze_image(response) + ``` + """ + if "error" in azure_result: + raise ValueError( + f"Azure API returned an error {azure_result['error']['message']}" + ) + + xyxy, confidences, class_ids = [], [], [] + + is_dynamic_mapping = class_map is None + if class_map is None: + class_map = {} + + inverted_map: dict[str, int] = {value: key for key, value in class_map.items()} + + for detection in azure_result["objectsResult"]["values"]: + bbox = detection["boundingBox"] + + tags = detection["tags"] + + x0 = bbox["x"] + y0 = bbox["y"] + x1 = x0 + bbox["w"] + y1 = y0 + bbox["h"] + + selected_tag: dict[str, Any] | None = None + selected_class_id: int | None = None + for tag in sorted( + tags, key=lambda candidate: candidate["confidence"], reverse=True + ): + class_name = tag["name"] + class_id_val = inverted_map.get(class_name, None) + + if is_dynamic_mapping and class_id_val is None: + class_id_val = len(inverted_map) + inverted_map[class_name] = class_id_val + + if class_id_val is not None: + selected_tag = tag + selected_class_id = class_id_val + break + + if selected_tag is None: + if tags: + warnings.warn( + "Azure detection skipped because none of its tags matched " + "the provided class_map.", + category=SupervisionWarnings, + stacklevel=2, + ) + continue + + xyxy.append([x0, y0, x1, y1]) + confidences.append(selected_tag["confidence"]) + class_ids.append(cast(int, selected_class_id)) + + if len(xyxy) == 0: + return Detections.empty() + + return cls( + xyxy=np.array(xyxy), + class_id=np.array(class_ids), + confidence=np.array(confidences), + ) + + @classmethod + def from_paddledet(cls, paddledet_result: Any) -> Detections: + """ + Creates a Detections instance from + [PaddleDetection](https://github.com/PaddlePaddle/PaddleDetection) + inference result. + + Args: + paddledet_result: The output Results instance from PaddleDet. + + Returns: + A new Detections object. + + Example: + ```python + import supervision as sv + import paddle + from ppdet.engine import Trainer + from ppdet.core.workspace import load_config + + weights = () + config = () + + cfg = load_config(config) + trainer = Trainer(cfg, mode='test') + trainer.load_weights(weights) + + paddledet_result = trainer.predict([images])[0] + + detections = sv.Detections.from_paddledet(paddledet_result) + ``` + """ + + if np.asarray(paddledet_result["bbox"][:, 2:6]).shape[0] == 0: + return cls.empty() + + return cls( + xyxy=paddledet_result["bbox"][:, 2:6], + confidence=paddledet_result["bbox"][:, 1], + class_id=paddledet_result["bbox"][:, 0].astype(int), + ) + + @classmethod + def from_lmm( + cls, lmm: LMM | str, result: str | dict[str, Any], **kwargs: Any + ) -> Detections: + """ + !!! deprecated "Deprecated" + `Detections.from_lmm` is **deprecated** and will be removed in `supervision-0.31.0`. + Please use `Detections.from_vlm` instead. + + Creates a Detections object from the given result string based on the specified + Large Multimodal Model (LMM). + + | Name | Enum (sv.LMM) | Tasks | Required parameters | Optional parameters | + |---------------------|----------------------|-------------------------|-----------------------------|---------------------| + | PaliGemma | `PALIGEMMA` | detection | `resolution_wh` | `classes` | + | PaliGemma 2 | `PALIGEMMA` | detection | `resolution_wh` | `classes` | + | Qwen2.5-VL | `QWEN_2_5_VL` | detection | `resolution_wh`, `input_wh` | `classes` | + | Qwen3-VL | `QWEN_3_VL` | detection | `resolution_wh` | `classes` | + | Google Gemini 2.0 | `GOOGLE_GEMINI_2_0` | detection | `resolution_wh` | `classes` | + | Google Gemini 2.5 | `GOOGLE_GEMINI_2_5` | detection, segmentation | `resolution_wh` | `classes` | + | Moondream | `MOONDREAM` | detection | `resolution_wh` | | + | DeepSeek-VL2 | `DEEPSEEK_VL_2` | detection | `resolution_wh` | `classes` | + | Qwen3-VL | `QWEN_3_VL` | detection | `resolution_wh` | `classes` | + + Args: + lmm: The type of LMM (Large Multimodal Model) to use. + result: The result string containing the detection data. + **kwargs: Additional keyword arguments required by the specified LMM. + + Returns: + A new Detections object. + + Raises: + ValueError: If the LMM is invalid, required arguments are missing, or + disallowed arguments are provided. + ValueError: If the specified LMM is not supported. + + !!! example "PaliGemma" + ```python + + import supervision as sv + + paligemma_result = " cat" + detections = sv.Detections.from_lmm( + sv.LMM.PALIGEMMA, + paligemma_result, + resolution_wh=(1000, 1000), + classes=['cat', 'dog'] + ) + detections.xyxy + # array([[250., 250., 750., 750.]]) + + detections.class_id + # array([0]) + + detections.data + # {'class_name': array(['cat'], dtype='" + } + }, + { + "text": "Detect all the cats and dogs in the image..." + } + ] + } + ] + } + ``` + To get the best results from Google Gemini 2.0, use the following prompt. + + ``` + Detect all the cats and dogs in the image. The box_2d should be + [ymin, xmin, ymax, xmax] normalized to 0-1000. + ``` + + ```python + import supervision as sv + + gemini_response_text = \"\"\"```json + [ + {"box_2d": [543, 40, 728, 200], "label": "cat", "id": 1}, + {"box_2d": [653, 352, 820, 522], "label": "dog", "id": 2} + ] + ```\"\"\" + + detections = sv.Detections.from_lmm( + sv.LMM.GOOGLE_GEMINI_2_0, + gemini_response_text, + resolution_wh=(1000, 1000), + classes=['cat', 'dog'], + ) + + detections.xyxy + # array([[543., 40., 728., 200.], [653., 352., 820., 522.]]) + + detections.data + # {'class_name': array(['cat', 'dog'], dtype='\\n<|ref|>The giraffe at the front<|/ref|> + ``` + + **For visual grounding, use the following user prompt:** + + ``` + \\n<|grounding|>Detect the giraffes + ``` + + ```python + from PIL import Image + import supervision as sv + + deepseek_vl2_result = "<|ref|>The giraffe at the back<|/ref|><|det|>[[580, 270, 999, 904]]<|/det|><|ref|>The giraffe at the front<|/ref|><|det|>[[26, 31, 632, 998]]<|/det|><|endโ–ofโ–sentence|>" + + detections = sv.Detections.from_vlm( + vlm=sv.VLM.DEEPSEEK_VL_2, result=deepseek_vl2_result, resolution_wh=image.size + ) + + detections.xyxy + # array([[ 420, 293, 724, 982], + # [ 18, 33, 458, 1084]]) + + detections.class_id + # array([0, 1]) + + detections.data + # {'class_name': array(['The giraffe at the back', 'The giraffe at the front'], dtype=' Detections: + """ + + Creates a Detections object from the given result string based on the specified + Vision Language Model (VLM). + + | Name | Enum (sv.VLM) | Tasks | Required parameters | Optional parameters | + |---------------------|----------------------|-------------------------|-----------------------------|---------------------| + | PaliGemma | `PALIGEMMA` | detection | `resolution_wh` | `classes` | + | PaliGemma 2 | `PALIGEMMA` | detection | `resolution_wh` | `classes` | + | Qwen2.5-VL | `QWEN_2_5_VL` | detection | `resolution_wh`, `input_wh` | `classes` | + | Qwen3-VL | `QWEN_3_VL` | detection | `resolution_wh` | `classes` | + | Google Gemini 2.0 | `GOOGLE_GEMINI_2_0` | detection | `resolution_wh` | `classes` | + | Google Gemini 2.5 | `GOOGLE_GEMINI_2_5` | detection, segmentation | `resolution_wh` | `classes` | + | Moondream | `MOONDREAM` | detection | `resolution_wh` | | + | DeepSeek-VL2 | `DEEPSEEK_VL_2` | detection | `resolution_wh` | `classes` | + + Args: + vlm: The type of VLM (Vision Language Model) to use. + result: The result string containing the detection data. + **kwargs: Additional keyword arguments required by the specified VLM. + + Returns: + A new Detections object. + + Raises: + ValueError: If the VLM is invalid, required arguments are missing, or + disallowed arguments are provided. + ValueError: If the specified VLM is not supported. + + !!! example "PaliGemma" + ```python + + import supervision as sv + + paligemma_result = " cat" + detections = sv.Detections.from_vlm( + sv.VLM.PALIGEMMA, + paligemma_result, + resolution_wh=(1000, 1000), + classes=['cat', 'dog'] + ) + detections.xyxy + # array([[250., 250., 750., 750.]]) + + detections.class_id + # array([0]) + + detections.data + # {'class_name': array(['cat'], dtype='\\n<|ref|>The giraffe at the front<|/ref|> + ``` + + **For visual grounding, use the following user prompt:** + + ``` + \\n<|grounding|>Detect the giraffes + ``` + + ```python + from PIL import Image + import supervision as sv + + deepseek_vl2_result = "<|ref|>The giraffe at the back<|/ref|><|det|>[[580, 270, 999, 904]]<|/det|><|ref|>The giraffe at the front<|/ref|><|det|>[[26, 31, 632, 998]]<|/det|><|endโ–ofโ–sentence|>" + + detections = sv.Detections.from_vlm( + vlm=sv.VLM.DEEPSEEK_VL_2, result=deepseek_vl2_result, resolution_wh=image.size + ) + + detections.xyxy + # array([[ 420, 293, 724, 982], + # [ 18, 33, 458, 1084]]) + + detections.class_id + # array([0, 1]) + + detections.data + # {'class_name': array(['The giraffe at the back', 'The giraffe at the front'], dtype=' Detections: + """ + Create a Detections object from the + [EasyOCR](https://github.com/JaidedAI/EasyOCR) result. + + Results are placed in the `data` field with the key `"class_name"`. + When EasyOCR returns quadrilateral corners, the original corners are + preserved in ``ORIENTED_BOX_COORDINATES``. Call EasyOCR with + ``detail=1`` so bounding boxes are available; ``detail=0`` returns text + strings only and cannot be converted into detections. + + Args: + easyocr_results: The output Results instance from EasyOCR. + + Returns: + A new Detections object. + + Example: + ```python + import supervision as sv + import easyocr + + reader = easyocr.Reader(['en']) + results = reader.readtext("") + detections = sv.Detections.from_easyocr(results) + detected_text = detections["class_name"] + ``` + """ + if len(easyocr_results) == 0: + return cls.empty() + + if isinstance(easyocr_results[0], str): + raise ValueError( + "EasyOCR results produced with detail=0 do not include bounding " + "boxes. Call reader.readtext(..., detail=1) instead." + ) + + bbox = np.array([result[0] for result in easyocr_results], dtype=np.float32) + if bbox.ndim != 3 or bbox.shape[1:] != (4, 2): + raise ValueError( + "EasyOCR results must contain four corner points per detection." + ) + xyxy = np.hstack((np.min(bbox, axis=1), np.max(bbox, axis=1))) + confidence = np.array( + [ + result[2] if len(result) > 2 and result[2] else 0 + for result in easyocr_results + ] + ) + ocr_text = np.array([result[1] for result in easyocr_results]) + + data: _DetectionDataType = { + CLASS_NAME_DATA_FIELD: ocr_text, + ORIENTED_BOX_COORDINATES: bbox, + } + return cls( + xyxy=xyxy.astype(np.float32), + confidence=confidence.astype(np.float32), + data=data, + ) + + @classmethod + def from_ncnn(cls, ncnn_results: Any) -> Detections: + """ + Creates a Detections instance from the + [ncnn](https://github.com/Tencent/ncnn) inference result. + Supports object detection models. + + Args: + ncnn_results: The output Results instance from ncnn. + + Returns: + A new Detections object. + + Example: + ```python + import cv2 + from ncnn.model_zoo import get_model + import supervision as sv + + image = cv2.imread("") + model = get_model( + "yolov8s", + target_size=640 + prob_threshold=0.5, + nms_threshold=0.45, + num_threads=4, + use_gpu=True, + ) + result = model(image) + detections = sv.Detections.from_ncnn(result) + ``` + """ + + xywh, confidences, class_ids = [], [], [] + + if len(ncnn_results) == 0: + return cls.empty() + + for ncnn_result in ncnn_results: + rect = ncnn_result.rect + xywh.append( + [ + rect.x.astype(np.float32), + rect.y.astype(np.float32), + rect.w.astype(np.float32), + rect.h.astype(np.float32), + ] + ) + + confidences.append(ncnn_result.prob) + class_ids.append(ncnn_result.label) + + return cls( + xyxy=xywh_to_xyxy(np.array(xywh, dtype=np.float32)), + confidence=np.array(confidences, dtype=np.float32), + class_id=np.array(class_ids, dtype=int), + ) + + @classmethod + def empty(cls) -> Detections: + """ + Create an empty Detections object with no bounding boxes, + confidences, or class IDs. + + Returns: + An empty Detections object. + + Example: + >>> from supervision import Detections + >>> empty_detections = Detections.empty() + >>> empty_detections.xyxy.shape + (0, 4) + """ + return cls( + xyxy=np.empty((0, 4), dtype=np.float32), + confidence=np.array([], dtype=np.float32), + class_id=np.array([], dtype=int), + ) + + def is_empty(self) -> bool: + """ + Check whether the `Detections` object has zero bounding boxes. + + Returns: + `True` if there are no detections, `False` otherwise. + + Examples: + ```pycon + >>> import numpy as np + >>> import supervision as sv + >>> detections = sv.Detections( + ... xyxy=np.array([[10, 20, 110, 120]]), + ... class_id=np.array([1]), + ... tracker_id=np.array([1]), + ... ) + >>> filtered = detections[detections.class_id == 99] + >>> filtered.is_empty() + True + + ``` + """ + return len(self.xyxy) == 0 + + @classmethod + def merge(cls, detections_list: list[Detections]) -> Detections: + """ + Merge a list of Detections objects into a single Detections object. + + This method takes a list of Detections objects and combines their + respective fields (`xyxy`, `mask`, `confidence`, `class_id`, and `tracker_id`) + into a single Detections object. + + For example, if merging Detections with 3 and 4 detected objects, this method + will return a Detections with 7 objects (7 entries in `xyxy`, `mask`, etc). + + !!! Note + + When merging, empty `Detections` objects are ignored. + + !!! Note + + **Mask merge policy** โ€” the output mask type follows these rules: + + * All inputs carry + [`CompactMask`][supervision.detection.compact_mask.CompactMask] + โ†’ result mask is `CompactMask`. + * Mixed dense `ndarray` + `CompactMask` inputs โ†’ dense masks are converted + to `CompactMask` via + [`CompactMask.from_dense`][supervision.detection.compact_mask.CompactMask.from_dense]; + result is `CompactMask`. No full `(N, H, W)` stack is allocated. + + !!! warning "Lossy conversion" + + `from_dense` crops each dense mask to its detection bounding box + (`xyxy`). **True pixels outside the bounding box are silently + discarded.** This matches the behaviour of + `Detections.from_inference(compact_masks=True)`. If pixel-perfect + preservation is required, ensure all inputs are already `CompactMask` + or use the all-dense path (no `CompactMask` inputs). + + * All inputs carry dense `ndarray` โ†’ result is `ndarray` (backward + compatible). + * The pairwise merge path used by + [`with_nms`][supervision.detection.core.Detections.with_nms] / + [`with_nmm`][supervision.detection.core.Detections.with_nmm] + (`merge_inner_detection_object_pair`) does **not** preserve `CompactMask` + โ€” mixed inputs materialise to a dense `ndarray` on that path. + + Args: + detections_list: A list of Detections objects to merge. + + Returns: + A single Detections object containing the merged data from the input list. + + Raises: + ValueError: If some `Detections` have a `mask` and others do not. + ValueError: If `CompactMask` inputs have different `image_shape` values. + ValueError: If a dense mask `(H, W)` shape differs from the `CompactMask` + `image_shape` when mixing mask types. + + Example: + >>> import numpy as np + >>> import supervision as sv + >>> detections_1 = sv.Detections( + ... xyxy=np.array([[15, 15, 100, 100], [200, 200, 300, 300]]), + ... class_id=np.array([1, 2]), + ... data={'feature_vector': np.array([0.1, 0.2])} + ... ) + >>> detections_2 = sv.Detections( + ... xyxy=np.array([[30, 30, 120, 120]]), + ... class_id=np.array([1]), + ... data={'feature_vector': np.array([0.3])} + ... ) + >>> merged_detections = sv.Detections.merge([detections_1, detections_2]) + >>> merged_detections.xyxy + array([[ 15, 15, 100, 100], + [200, 200, 300, 300], + [ 30, 30, 120, 120]]) + >>> merged_detections.class_id + array([1, 2, 1]) + >>> merged_detections.data['feature_vector'] + array([0.1, 0.2, 0.3]) + + Compact mask merge example: + + ```python + import numpy as np + import supervision as sv + from supervision.detection.compact_mask import CompactMask + + H, W = 720, 1280 + masks_a = np.zeros((2, H, W), dtype=bool) + masks_a[0, 100:200, 100:300] = True + xyxy_a = np.array([[100., 100., 299., 199.], [400., 300., 600., 500.]]) + cm_a = CompactMask.from_dense(masks_a, xyxy_a, image_shape=(H, W)) + + det_compact = sv.Detections( + xyxy=xyxy_a, mask=cm_a, class_id=np.array([0, 1]) + ) + + masks_b = np.zeros((1, H, W), dtype=bool) + masks_b[0, 50:100, 50:150] = True + xyxy_b = np.array([[50., 50., 149., 99.]]) + det_dense = sv.Detections(xyxy=xyxy_b, mask=masks_b, class_id=np.array([2])) + + # Dense mask is converted to CompactMask; no (N, H, W) stack allocated. + merged = sv.Detections.merge([det_compact, det_dense]) + assert isinstance(merged.mask, CompactMask) + assert len(merged) == 3 + ``` + """ + detections_list = [ + detections for detections in detections_list if not detections.is_empty() + ] + + if len(detections_list) == 0: + return Detections.empty() + + for detections in detections_list: + _validate_detections_fields( + xyxy=detections.xyxy, + mask=detections.mask, + confidence=detections.confidence, + class_id=detections.class_id, + tracker_id=detections.tracker_id, + data=detections.data, + ) + + xyxy = np.vstack([d.xyxy for d in detections_list]) + + def stack_mask_or_none() -> npt.NDArray[np.generic] | CompactMask | None: + masks = [d.mask for d in detections_list] + if all(m is None for m in masks): + return None + if any(m is None for m in masks): + raise ValueError("All or none of the 'mask' fields must be None") + if all(isinstance(m, CompactMask) for m in masks): + return CompactMask.merge(cast(list[CompactMask], masks)) + if all(not isinstance(m, CompactMask) for m in masks): + # All-dense: preserve backward-compatible dense stacking. + return cast( + npt.NDArray[np.generic], np.vstack([np.asarray(m) for m in masks]) + ) + # Mixed dense and CompactMask: convert dense masks to CompactMask to + # avoid materialising a full (N, H, W) stack. + compact_image_shapes = { + m.image_shape for m in masks if isinstance(m, CompactMask) + } + if len(compact_image_shapes) != 1: + raise ValueError( + "Cannot merge CompactMask objects with different image shapes: " + f"{sorted(compact_image_shapes)}" + ) + image_shape: tuple[int, int] = next(iter(compact_image_shapes)) + compact_list: list[CompactMask] = [] + for d, m in zip(detections_list, masks): + if isinstance(m, CompactMask): + compact_list.append(m) + else: + dense = np.asarray(m, dtype=bool) + if dense.shape[1:] != image_shape: + raise ValueError( + f"Dense mask shape {dense.shape[1:]} does not match " + f"CompactMask image_shape {image_shape}." + ) + compact_list.append( + CompactMask.from_dense(dense, d.xyxy, image_shape) + ) + return CompactMask.merge(compact_list) + + def stack_or_none(name: str) -> npt.NDArray[np.generic] | None: + values = [getattr(d, name) for d in detections_list] + if all(v is None for v in values): + return None + if any(v is None for v in values): + raise ValueError(f"All or none of the '{name}' fields must be None") + return cast(npt.NDArray[np.generic], np.hstack(values)) + + mask = cast(npt.NDArray[np.bool_] | CompactMask | None, stack_mask_or_none()) + confidence = cast(npt.NDArray[np.floating] | None, stack_or_none("confidence")) + class_id = cast(npt.NDArray[np.integer] | None, stack_or_none("class_id")) + tracker_id = cast(npt.NDArray[np.integer] | None, stack_or_none("tracker_id")) + + data = merge_data([d.data for d in detections_list]) + + metadata_list = [detections.metadata for detections in detections_list] + metadata = merge_metadata(metadata_list) + + return cls( + xyxy=xyxy, + mask=mask, + confidence=confidence, + class_id=class_id, + tracker_id=tracker_id, + data=data, + metadata=metadata, + ) + + def get_anchors_coordinates(self, anchor: Position) -> npt.NDArray[np.generic]: + """Compute anchor-point coordinates for each detection. + + The anchor can be any position in the `Position` enum, such as + `CENTER`, `CENTER_LEFT`, `BOTTOM_RIGHT`, etc. + + Selection order: + + 1. If ``data[ORIENTED_BOX_COORDINATES]`` is set and ``anchor`` is not + ``Position.CENTER_OF_MASS``, coordinates are computed from the + oriented bounding box corners (result lies on the actual rotated + body). + 2. If ``anchor`` is ``Position.CENTER_OF_MASS``, the detection mask + centroid is returned regardless of OBB data presence. + 3. Otherwise, the anchor is derived from the axis-aligned envelope + (``xyxy``). + + Args: + anchor: Anchor position to compute. Supported positions are + defined in the `Position` enum. + + Returns: + Array of shape `(n, 2)` where each row is the `[x, y]` anchor + coordinate for the corresponding detection. + + Raises: + ValueError: If the provided `anchor` is not supported. + + Examples: + Axis-aligned detection: + + ```pycon + >>> import numpy as np + >>> import supervision as sv + >>> detections = sv.Detections( + ... xyxy=np.array([[0.0, 0.0, 10.0, 4.0]]) + ... ) + >>> detections.get_anchors_coordinates(sv.Position.BOTTOM_CENTER) + array([[5., 4.]]) + + ``` + + Oriented (rotated) detection โ€” anchor lies on the rotated body, + not the axis-aligned envelope: + + ```pycon + >>> import numpy as np + >>> import supervision as sv + >>> corners = np.array( + ... [[[0.0, 0.0], [10.0, 0.0], [10.0, 4.0], [0.0, 4.0]]] + ... ) + >>> detections = sv.Detections( + ... xyxy=np.array([[0.0, 0.0, 10.0, 4.0]]), + ... data={"xyxyxyxy": corners}, + ... ) + >>> detections.get_anchors_coordinates(sv.Position.BOTTOM_CENTER) + array([[5., 4.]]) + + ``` + """ + if ORIENTED_BOX_COORDINATES in self.data and anchor != Position.CENTER_OF_MASS: + return cast( + npt.NDArray[np.generic], + _oriented_box_anchors( + np.asarray(self.data[ORIENTED_BOX_COORDINATES]), anchor + ), + ) + + xyxy = self.xyxy + + def coordinates( + x: npt.NDArray[np.number], y: npt.NDArray[np.number] + ) -> npt.NDArray[np.generic]: + return cast(npt.NDArray[np.generic], np.array([x, y]).transpose()) + + if anchor == Position.CENTER: + return coordinates( + (xyxy[:, 0] + xyxy[:, 2]) / 2, + (xyxy[:, 1] + xyxy[:, 3]) / 2, + ) + elif anchor == Position.CENTER_OF_MASS: + if self.mask is None: + raise ValueError( + "Cannot use `Position.CENTER_OF_MASS` without a detection mask." + ) + return calculate_masks_centroids(masks=self.mask) + elif anchor == Position.CENTER_LEFT: + return coordinates(xyxy[:, 0], (xyxy[:, 1] + xyxy[:, 3]) / 2) + elif anchor == Position.CENTER_RIGHT: + return coordinates(xyxy[:, 2], (xyxy[:, 1] + xyxy[:, 3]) / 2) + elif anchor == Position.BOTTOM_CENTER: + return coordinates((xyxy[:, 0] + xyxy[:, 2]) / 2, xyxy[:, 3]) + elif anchor == Position.BOTTOM_LEFT: + return coordinates(xyxy[:, 0], xyxy[:, 3]) + elif anchor == Position.BOTTOM_RIGHT: + return coordinates(xyxy[:, 2], xyxy[:, 3]) + elif anchor == Position.TOP_CENTER: + return coordinates((xyxy[:, 0] + xyxy[:, 2]) / 2, xyxy[:, 1]) + elif anchor == Position.TOP_LEFT: + return coordinates(xyxy[:, 0], xyxy[:, 1]) + elif anchor == Position.TOP_RIGHT: + return coordinates(xyxy[:, 2], xyxy[:, 1]) + + raise ValueError(f"{anchor} is not supported.") + + def get_data(self, key: str) -> _DetectionDataValueType | None: + """Get a value from the detection data dictionary. + + Args: + key: Data field name. + + Returns: + The stored data value, or `None` when the key is absent. + + Example: + >>> import numpy as np + >>> from supervision import Detections + >>> detections = Detections( + ... xyxy=np.array([[0, 0, 1, 1]]), + ... data={"class_name": np.array(["cat"])}, + ... ) + >>> detections.get_data("class_name").tolist() + ['cat'] + """ + return self.data.get(key) + + def select( + self, + index: int | np.integer[Any] | slice | list[int] | npt.NDArray[np.generic], + ) -> Detections: + """Get a subset of the Detections object. + + Args: + index: Row index, indices, slice, or boolean mask selecting detections. + + Returns: + A new `Detections` instance containing the selected rows. Always returns + a fresh copy โ€” arrays and metadata are never shared with the original, + even when the selection is empty or the input has zero detections. + + Example: + >>> import numpy as np + >>> from supervision import Detections + >>> detections = Detections(xyxy=np.array([[0, 0, 1, 1], [1, 1, 2, 2]])) + >>> detections.select([1]).xyxy.tolist() + [[1, 1, 2, 2]] + """ + mask: npt.NDArray[np.bool_] | CompactMask | None + if len(self) == 0: + if isinstance(self.mask, CompactMask): + mask = self.mask[:0] + elif self.mask is not None: + mask = self.mask[:0].copy() + else: + mask = None + data = { + key: value.copy() if isinstance(value, np.ndarray) else list(value) + for key, value in self.data.items() + } + return Detections( + xyxy=self.xyxy.copy(), + mask=mask, + confidence=( + self.confidence.copy() if self.confidence is not None else None + ), + class_id=self.class_id.copy() if self.class_id is not None else None, + tracker_id=( + self.tracker_id.copy() if self.tracker_id is not None else None + ), + data=data, + metadata=dict(self.metadata), + ) + if isinstance(index, (int, np.integer)): + index = [int(index)] + array_index = cast( + slice | list[int] | npt.NDArray[np.integer | np.bool_], index + ) + data = { + key: value.copy() if isinstance(value, np.ndarray) else list(value) + for key, value in get_data_item(self.data, array_index).items() + } + if isinstance(self.mask, CompactMask): + mask = self.mask[cast(Any, array_index)] + elif self.mask is not None: + mask = self.mask[cast(Any, array_index)].copy() + else: + mask = None + return Detections( + xyxy=self.xyxy[array_index].copy(), + mask=mask, + confidence=( + self.confidence[array_index].copy() + if self.confidence is not None + else None + ), + class_id=( + self.class_id[array_index].copy() if self.class_id is not None else None + ), + tracker_id=( + self.tracker_id[array_index].copy() + if self.tracker_id is not None + else None + ), + data=data, + metadata=dict(self.metadata), + ) + + def __getitem__( + self, + index: int + | np.integer[Any] + | slice + | list[int] + | npt.NDArray[np.generic] + | str, + ) -> Detections | list[Any] | npt.NDArray[np.generic] | None: + """ + Get a subset of the Detections object or access an item from its data field. + + When provided with an integer, slice, list of integers, or a numpy array, this + method returns a new Detections object that represents a subset of the original + detections. When provided with a string, it accesses the corresponding item in + the data dictionary. + + Args: + index: The index, indices, or key to access a subset of the Detections + or an item from the data. + + Returns: + A subset of the Detections object or an item from the data field. + + Example: + ```python + import supervision as sv + + detections = sv.Detections() + + first_detection = detections[0] + first_10_detections = detections[0:10] + some_detections = detections[[0, 2, 4]] + class_0_detections = detections[detections.class_id == 0] + high_confidence_detections = detections[detections.confidence > 0.5] + + feature_vector = detections['feature_vector'] + ``` + """ + if isinstance(index, str): + return self.get_data(index) + return self.select(index) + + def __setitem__(self, key: str, value: npt.NDArray[np.generic] | list[Any]) -> None: + """ + Set a value in the data dictionary of the Detections object. + + Args: + key: The key in the data dictionary to set. + value: The value to set for the key. + + Example: + ```python + import cv2 + import supervision as sv + from ultralytics import YOLO + + image = cv2.imread("") + model = YOLO('yolov8s.pt') + + result = model(image)[0] + detections = sv.Detections.from_ultralytics(result) + + detections['names'] = [ + model.model.names[class_id] + for class_id + in detections.class_id + ] + ``` + + Raises: + TypeError: If `value` is not a `np.ndarray` or `list`. + ValueError: If `value` has a length or shape incompatible with + the detection count. + """ + if not isinstance(value, (np.ndarray, list)): + raise TypeError("Value must be a np.ndarray or a list") + + if isinstance(value, list): + value = np.array(value) + + _validate_data({key: value}, len(self)) + self.data[key] = value + + @property + def area(self) -> npt.NDArray[np.generic]: + """ + Calculate the area of each detection in the set of object detections. + + Selection order: + + 1. If ``mask`` is set, return the area of each mask. + 2. Else, if ``data[ORIENTED_BOX_COORDINATES]`` is set, return the area of + the rotated body (shoelace formula on the four corners). + 3. Otherwise, return the axis-aligned box area (``box_area``). + + **OBB dispatch contract**: presence of ``data[ORIENTED_BOX_COORDINATES]`` + with shape ``(N, 4, 2)`` is the canonical signal that a detection carries + oriented bounding box geometry. The same presence-of-key check governs + ``with_nms``, ``with_nmm``, and this property โ€” always store OBB corners + under ``config.ORIENTED_BOX_COORDINATES`` with that shape. + + **Return dtype**: ``float64`` (OBB branch), input dtype (AABB fallback), + ``int64`` (mask branch). + + Returns: + An array containing the area of each detection + in the format of `(area_1, area_2, ..., area_n)`, + where n is the number of detections. + + Example: + >>> import numpy as np + >>> import supervision as sv + >>> corners = np.array( + ... [[[0, 5], [5, 10], [10, 5], [5, 0]]], dtype=np.float32 + ... ) + >>> detections = sv.Detections( + ... xyxy=np.array([[0, 0, 10, 10]], dtype=np.float32), + ... class_id=np.array([0]), + ... data={"xyxyxyxy": corners}, + ... ) + >>> detections.area + array([50.]) + + Mask branch returns ``int64`` pixel counts: + + >>> mask = np.zeros((2, 10, 10), dtype=bool) + >>> mask[0, :3, :3] = True # 9 pixels + >>> mask[1, :5, :5] = True # 25 pixels + >>> detections = sv.Detections( + ... xyxy=np.array( + ... [[0, 0, 10, 10], [0, 0, 10, 10]], dtype=np.float32 + ... ), + ... mask=mask, + ... ) + >>> detections.area + array([ 9, 25]) + """ + if self.mask is not None: + if isinstance(self.mask, CompactMask): + return self.mask.area + return count_mask_pixels(self.mask) + if ORIENTED_BOX_COORDINATES in self.data: + return obb_polygon_area( + cast(npt.NDArray[np.number], self.data[ORIENTED_BOX_COORDINATES]) + ) + return self.box_area + + @property + def box_area(self) -> npt.NDArray[np.generic]: + """ + Calculate the area of each bounding box in the set of object detections. + + Returns: + An array of floats containing the area of each bounding + box in the format of `(area_1, area_2, ..., area_n)`, + where n is the number of detections. + """ + return (self.xyxy[:, 3] - self.xyxy[:, 1]) * (self.xyxy[:, 2] - self.xyxy[:, 0]) + + @property + def box_aspect_ratio(self) -> npt.NDArray[np.generic]: + """ + Compute the aspect ratio (width divided by height) for each bounding box. + + Returns: + Array of shape `(N,)` containing aspect ratios, where `N` is the + number of boxes (width / height for each box). + + Examples: + ```python + import numpy as np + import supervision as sv + + xyxy = np.array([ + [10, 10, 50, 50], + [60, 10, 180, 50], + [10, 60, 50, 180], + ]) + + detections = sv.Detections(xyxy=xyxy) + + detections.box_aspect_ratio + # array([1.0, 3.0, 0.33333333]) + + ar = detections.box_aspect_ratio + detections[(ar < 2.0) & (ar > 0.5)].xyxy + # array([[10., 10., 50., 50.]]) + ``` + """ + widths = self.xyxy[:, 2] - self.xyxy[:, 0] + heights = self.xyxy[:, 3] - self.xyxy[:, 1] + + aspect_ratios = np.full_like(widths, np.nan, dtype=np.float64) + np.divide(widths, heights, out=aspect_ratios, where=heights != 0) + return aspect_ratios + + def to_compact_masks(self) -> Detections: + """Return a copy of this Detections with masks converted to CompactMask. + + The dense :attr:`mask` field (``NDArray[np.bool_]``) is converted to a + :class:`~supervision.detection.compact_mask.CompactMask` without changing + mask pixels. When :attr:`mask` is already a + :class:`~supervision.detection.compact_mask.CompactMask` or is ``None``, + the instance is returned unchanged. + + Note: + The crop boundaries are set to the **full image dimensions**, not the + detector bounding box. No bbox-crop memory savings apply: the RLE + sparsity still reduces storage versus a dense array, but the + ``O(bbox_area)`` savings available from + ``from_inference(..., compact_masks=True)`` are absent here because + every crop spans the whole frame. Call + :meth:`~supervision.detection.compact_mask.CompactMask.repack` on the + resulting mask to tighten crops to their bounding boxes, at the cost + of potential pixel loss outside those boxes. + + Returns: + A new :class:`Detections` instance with ``mask`` set to a + :class:`~supervision.detection.compact_mask.CompactMask`, or ``self`` + when conversion is not needed. + + Example: + ```python + import numpy as np + import supervision as sv + detections = sv.Detections( + xyxy=np.array([[0, 0, 10, 10]]), + mask=np.ones((1, 20, 20), dtype=bool), + ) + compact = detections.to_compact_masks() + ``` + """ + from supervision.detection.compact_mask import CompactMask + + if self.mask is None or isinstance(self.mask, CompactMask): + return self + image_shape = (int(self.mask.shape[1]), int(self.mask.shape[2])) + full_image_xyxy = np.tile( + np.array( + [[0, 0, image_shape[1] - 1, image_shape[0] - 1]], dtype=np.float64 + ), + (len(self), 1), + ) + new = self.__class__( + xyxy=self.xyxy, + mask=CompactMask.from_dense( + masks=self.mask, + xyxy=full_image_xyxy, + image_shape=image_shape, + ), + confidence=self.confidence, + class_id=self.class_id, + tracker_id=self.tracker_id, + data=self.data, + metadata=dict(self.metadata), + ) + return new + + def with_nms( + self, + threshold: float = 0.5, + class_agnostic: bool = False, + overlap_metric: OverlapMetric = OverlapMetric.IOU, + ) -> Detections: + """ + Performs non-max suppression on detection set. Dispatch order: (1) if mask + data present, IoU mask is used; (2) else if oriented-box coordinates + (``data[ORIENTED_BOX_COORDINATES]``) present, oriented-box IoU is used; (3) + otherwise, axis-aligned box IoU is used. + + Args: + threshold: The intersection-over-union threshold + to use for non-maximum suppression. The lower the value the more + restrictive the NMS becomes. Defaults to 0.5. + class_agnostic: Whether to perform class-agnostic + non-maximum suppression. If True, the class_id of each detection + will be ignored. Defaults to False. + overlap_metric: Metric used to compute the degree of + overlap between pairs of masks or boxes (e.g., IoU, IoS). + + Returns: + A new Detections object containing the subset of detections + after non-maximum suppression. + + Raises: + ValueError: If `confidence` is None and class_agnostic is False. + If `class_id` is None and class_agnostic is False. + """ + if len(self) == 0: + return self + + if self.confidence is None: + raise ValueError( + "Detections confidence must be given for NMS to be executed." + ) + + if class_agnostic: + predictions = cast( + npt.NDArray[np.floating], + np.hstack((self.xyxy, self.confidence.reshape(-1, 1))), + ) + else: + if self.class_id is None: + raise ValueError( + "Detections class_id must be given for NMS to be executed. If " + "you intended to perform class agnostic NMS " + "set class_agnostic=True." + ) + predictions = cast( + npt.NDArray[np.floating], + np.hstack( + ( + self.xyxy, + self.confidence.reshape(-1, 1), + self.class_id.reshape(-1, 1), + ) + ), + ) + + if self.mask is not None: + indices = mask_non_max_suppression( + predictions=predictions, + masks=self.mask, + iou_threshold=threshold, + overlap_metric=overlap_metric, + ) + elif ORIENTED_BOX_COORDINATES in self.data: + indices = oriented_box_non_max_suppression( + predictions=predictions, + oriented_boxes=np.asarray( + self.data[ORIENTED_BOX_COORDINATES], dtype=np.float32 + ), + iou_threshold=threshold, + overlap_metric=overlap_metric, + ) + else: + indices = box_non_max_suppression( + predictions=predictions, + iou_threshold=threshold, + overlap_metric=overlap_metric, + ) + + return self.select(indices) + + def with_nmm( + self, + threshold: float = 0.5, + class_agnostic: bool = False, + overlap_metric: OverlapMetric = OverlapMetric.IOU, + ) -> Detections: + """ + Perform non-maximum merging on the current set of object detections. + Dispatch order: (1) if mask data present, IoU mask is used; (2) else if + oriented-box coordinates (``data[ORIENTED_BOX_COORDINATES]``) present, + oriented-box IoU is used; (3) otherwise, axis-aligned box IoU is used. + + Args: + threshold: The intersection-over-union threshold + to use for non-maximum merging. Defaults to 0.5. + class_agnostic: Whether to perform class-agnostic + non-maximum merging. If True, the class_id of each detection + will be ignored. Defaults to False. + overlap_metric: Metric used to compute the degree of + overlap between pairs of masks or boxes (e.g., IoU, IoS). + + Returns: + A new Detections object containing the subset of detections + after non-maximum merging. + + Note: + For detections carrying oriented bounding box data + (``data[ORIENTED_BOX_COORDINATES]``), each merge group's output OBB + is the tightest rectangle at the winner's orientation enclosing all + corners contributed by every detection in the group. The winner is + the highest-confidence detection in the group. The axis-aligned + ``xyxy`` field is updated to the tight bounding box of that rect. + For zero-rotation OBBs this equals the axis-aligned union exactly; + for rotated OBBs the merged rect inherits the winner's rotation angle. + Groups of size 1 keep the original OBB unchanged. + + Raises: + ValueError: If `confidence` is None or `class_id` is None and + class_agnostic is False. + + ![non-max-merging](https://media.roboflow.com/supervision-docs/non-max-merging.png){ align=center width="800" } + """ # noqa: E501 // docs + if len(self) == 0: + return self + + if self.confidence is None: + raise ValueError( + "Detections confidence must be given for NMM to be executed." + ) + + if class_agnostic: + predictions = cast( + npt.NDArray[np.floating], + np.hstack((self.xyxy, self.confidence.reshape(-1, 1))), + ) + else: + if self.class_id is None: + raise ValueError( + "Detections class_id must be given for NMM to be executed. If " + "you intended to perform class agnostic NMM " + "set class_agnostic=True." + ) + predictions = cast( + npt.NDArray[np.floating], + np.hstack( + ( + self.xyxy, + self.confidence.reshape(-1, 1), + self.class_id.reshape(-1, 1), + ) + ), + ) + + if self.mask is not None: + merge_groups = mask_non_max_merge( + predictions=predictions, + masks=self.mask, + iou_threshold=threshold, + overlap_metric=overlap_metric, + ) + elif ORIENTED_BOX_COORDINATES in self.data: + merge_groups = oriented_box_non_max_merge( + predictions=predictions, + oriented_boxes=np.asarray( + self.data[ORIENTED_BOX_COORDINATES], dtype=np.float32 + ), + iou_threshold=threshold, + overlap_metric=overlap_metric, + ) + else: + merge_groups = box_non_max_merge( + predictions=predictions, + iou_threshold=threshold, + overlap_metric=overlap_metric, + ) + + result: list[Detections] = [] + for merge_group in merge_groups: + group = [self.select(i) for i in merge_group] + result.append(_merge_detection_group(group)) + + return Detections.merge(result) + + +def _merge_obb_corners( + corners_list: list[npt.NDArray[np.floating]], +) -> npt.NDArray[np.floating]: + """Merge multiple OBB corner arrays using winner-angle projection. + + The first entry in *corners_list* is the winner. Its orientation angle + (derived from its first edge) defines the local frame in which the + tightest enclosing axis-aligned rectangle is computed. That rectangle is + then rotated back to produce the merged OBB. + + Args: + corners_list: List of (4, 2) corner arrays. First is the winner. + + Returns: + Merged OBB corners as a (4, 2) float32 array. + """ + all_corners = np.concatenate(corners_list, axis=0).astype(np.float32) + # Use winner's first edge to derive orientation angle -- avoids + # cv2.minAreaRect surprises (e.g. 90-degree flip for wide rects). + winner_edge = corners_list[0][1] - corners_list[0][0] + angle = float(np.arctan2(winner_edge[1], winner_edge[0])) + cos, sin = float(np.cos(angle)), float(np.sin(angle)) + + # De-rotate all corners into the winner's local frame + to_local = np.array([[cos, -sin], [sin, cos]], dtype=np.float32) + local_corners = all_corners @ to_local + x_min = float(local_corners[:, 0].min()) + x_max = float(local_corners[:, 0].max()) + y_min = float(local_corners[:, 1].min()) + y_max = float(local_corners[:, 1].max()) + + # Rotate the enclosing AABB back to world frame + to_world = np.array([[cos, sin], [-sin, cos]], dtype=np.float32) + merged: npt.NDArray[np.floating] = ( + np.array( + [[x_min, y_min], [x_max, y_min], [x_max, y_max], [x_min, y_max]], + dtype=np.float32, + ) + @ to_world + ) + return merged + + +def _merge_detection_group(detections: list[Detections]) -> Detections: + """Merge a group of single-object Detections into one merged detection. + + Used internally by :meth:`Detections.with_nmm` to combine each merge group + into a single output detection. The highest-confidence detection is the + "winner" whose class_id, tracker_id, and data fields are preserved. + + Args: + detections: List of Detections, each containing exactly one object. + + Returns: + A single merged Detections object of length 1. + """ + if len(detections) == 1: + return detections[0] + + confidences = np.array( + [d.confidence[0] if d.confidence is not None else 0.0 for d in detections], + dtype=np.float64, + ) + winner_idx = int(np.argmax(confidences)) + winner = detections[winner_idx] + + # Area-weighted confidence: each box contributes proportionally to its + # footprint so large overlapping boxes dominate over small slivers. + all_xyxy = np.array([d.xyxy[0] for d in detections], dtype=np.float32) + areas = (all_xyxy[:, 2] - all_xyxy[:, 0]) * (all_xyxy[:, 3] - all_xyxy[:, 1]) + + confidence: npt.NDArray[np.floating] | None + if winner.confidence is not None: + total_area = float(areas.sum()) + if total_area > 0: + confidence = np.array( + [float(np.dot(areas, confidences) / total_area)], + dtype=np.float32, + ) + else: + confidence = winner.confidence + else: + confidence = None + + # OBB path: merge corners via winner-angle projection, then derive xyxy + # from the merged OBB so both stay consistent. + has_obb = ORIENTED_BOX_COORDINATES in winner.data + if has_obb: + corners_list = [] + for det in detections: + c = np.asarray(det.data[ORIENTED_BOX_COORDINATES]) + if c.ndim != 3 or c.shape[1:] != (4, 2): + raise ValueError(f"corners must have shape (N, 4, 2); got {c.shape}") + corners_list.append(c[0].reshape(4, 2)) + merged_corners = _merge_obb_corners(corners_list) + xyxy = xyxyxyxy_to_xyxy(merged_corners[np.newaxis]) + data = {**winner.data, ORIENTED_BOX_COORDINATES: merged_corners[np.newaxis]} + else: + # AABB path: union bounding box across all group members + xyxy = np.array( + [ + [ + all_xyxy[:, 0].min(), + all_xyxy[:, 1].min(), + all_xyxy[:, 2].max(), + all_xyxy[:, 3].max(), + ] + ], + dtype=np.float32, + ) + data = winner.data + + # Mask union via logical OR. Preserve CompactMask outputs without re-cropping + # to the merged box, because source masks may legitimately extend outside it. + masks = [d.mask for d in detections if d.mask is not None] + if masks: + if all(isinstance(m, CompactMask) for m in masks): + compact_masks = cast(list[CompactMask], masks) + image_shape = compact_masks[0].image_shape + if any(m.image_shape != image_shape for m in compact_masks): + raise ValueError( + "Cannot merge CompactMask objects with different image shapes." + ) + union_mask = np.zeros(image_shape, dtype=bool) + for compact_mask in compact_masks: + union_mask |= compact_mask.to_dense()[0] + union_xyxy = mask_to_xyxy(union_mask[np.newaxis]).astype(np.float32) + mask = CompactMask.from_dense( + masks=union_mask[np.newaxis], + xyxy=union_xyxy, + image_shape=image_shape, + ) + else: + dense_masks = [ + m.to_dense() if isinstance(m, CompactMask) else m for m in masks + ] + mask = np.logical_or.reduce(np.concatenate(dense_masks, axis=0))[np.newaxis] + else: + mask = None + + metadata = merge_metadata([d.metadata for d in detections]) + + return Detections( + xyxy=xyxy, + mask=mask, + confidence=confidence, + class_id=winner.class_id, + tracker_id=winner.tracker_id, + data=data, + metadata=metadata, + ) + + +@deprecated(deprecated_in="0.29.0", remove_in="0.32.0") # type: ignore[untyped-decorator] +def merge_inner_detection_object_pair( + detections_1: Detections, detections_2: Detections +) -> Detections: + """ + Merges two Detections objects into a single Detections object. + Assumes each Detections contains exactly one object. + + A `winning` detection is determined based on the confidence score of the two + input detections. This winning detection is then used to specify which + `class_id`, `tracker_id`, and `data` to include in the merged Detections object. + + The resulting `confidence` of the merged object is calculated by the weighted + contribution of each detection to the merged object. + The bounding boxes and masks of the two input detections are merged into a + single bounding box and mask, respectively. + + Args: + detections_1: The first Detections object. + detections_2: The second Detections object. + + Returns: + A new Detections object, with merged attributes. + + Raises: + ValueError: If the input Detections objects do not have exactly 1 detected + object. + + Example: + ```python + import cv2 + import supervision as sv + from inference import get_model + + image = cv2.imread("") + model = get_model(model_id="yolov8s-640") + + result = model.infer(image)[0] + detections = sv.Detections.from_inference(result) + + merged_detections = merge_object_detection_pair( + detections[0], detections[1]) + ``` + """ + if len(detections_1) != 1 or len(detections_2) != 1: + raise ValueError("Both Detections should have exactly 1 detected object.") + + _validate_fields_both_defined_or_none(detections_1, detections_2) + + xyxy_1 = detections_1.xyxy[0] + xyxy_2 = detections_2.xyxy[0] + if detections_1.confidence is None and detections_2.confidence is None: + merged_confidence = None + else: + assert detections_1.confidence is not None + assert detections_2.confidence is not None + detection_1_area = (xyxy_1[2] - xyxy_1[0]) * (xyxy_1[3] - xyxy_1[1]) + detections_2_area = (xyxy_2[2] - xyxy_2[0]) * (xyxy_2[3] - xyxy_2[1]) + merged_confidence = ( + detection_1_area * detections_1.confidence[0] + + detections_2_area * detections_2.confidence[0] + ) / (detection_1_area + detections_2_area) + merged_confidence = np.array([merged_confidence]) + + merged_x1, merged_y1 = np.minimum(xyxy_1[:2], xyxy_2[:2]) + merged_x2, merged_y2 = np.maximum(xyxy_1[2:], xyxy_2[2:]) + merged_xyxy = np.array([[merged_x1, merged_y1, merged_x2, merged_y2]]) + + if detections_1.mask is None and detections_2.mask is None: + merged_mask = None + else: + merged_mask = np.logical_or( + cast(npt.NDArray[Any], detections_1.mask), + cast(npt.NDArray[Any], detections_2.mask), + ) + + if detections_1.confidence is None or detections_2.confidence is None: + winning_detection = detections_1 + elif detections_1.confidence[0] >= detections_2.confidence[0]: + winning_detection = detections_1 + else: + winning_detection = detections_2 + + metadata = merge_metadata([detections_1.metadata, detections_2.metadata]) + + return Detections( + xyxy=merged_xyxy, + mask=merged_mask, + confidence=merged_confidence, + class_id=winning_detection.class_id, + tracker_id=winning_detection.tracker_id, + data=winning_detection.data, + metadata=metadata, + ) + + +@deprecated(deprecated_in="0.29.0", remove_in="0.32.0") # type: ignore[untyped-decorator] +def merge_inner_detections_objects( + detections: list[Detections], + threshold: float = 0.5, + overlap_metric: OverlapMetric = OverlapMetric.IOU, +) -> Detections: + """ + Given N detections each of length 1 (exactly one object inside), combine them into a + single detection object of length 1. The contained inner object will be the merged + result of all the input detections. + + For example, this lets you merge N boxes into one big box, N masks into one mask, + etc. + """ + detections_1 = detections[0] + for detections_2 in detections[1:]: + if detections_1.mask is not None and detections_2.mask is not None: + iou = mask_iou_batch(detections_1.mask, detections_2.mask, overlap_metric)[ + 0 + ] + else: + iou = box_iou_batch( + detections_1.xyxy, + detections_2.xyxy, + overlap_metric, + )[0] + if iou < threshold: + break + detections_1 = merge_inner_detection_object_pair(detections_1, detections_2) + return detections_1 + + +@deprecated(deprecated_in="0.29.0", remove_in="0.32.0") # type: ignore[untyped-decorator] +def merge_inner_detections_objects_without_iou( + detections: list[Detections], +) -> Detections: + """ + Given N detections each of length 1 (exactly one object inside), combine them into a + single detection object of length 1. The contained inner object will be the merged + result of all the input detections. + + For example, this lets you merge N boxes into one big box, N masks into one mask, + etc. + """ + return reduce(merge_inner_detection_object_pair, detections) + + +def _validate_fields_both_defined_or_none( + detections_1: Detections, detections_2: Detections +) -> None: + """ + Verify that for each optional field in the Detections, both instances either have + the field set to None or both have it set to non-None values. + + `data` field is ignored. + + Raises: + ValueError: If one field is None and the other is not, for any of the fields. + """ + attributes = get_instance_variables(detections_1) + for attribute in attributes: + value_1 = getattr(detections_1, attribute) + value_2 = getattr(detections_2, attribute) + + if (value_1 is None) != (value_2 is None): + raise ValueError( + f"Field '{attribute}' should be consistently None or not None in both " + "Detections." + ) + + +@deprecated( # type: ignore[untyped-decorator] + target=_validate_fields_both_defined_or_none, + deprecated_in="0.29.0", + remove_in="0.32.0", +) +def validate_fields_both_defined_or_none( + detections_1: Detections, detections_2: Detections +) -> None: + void(detections_1, detections_2) diff --git a/src/supervision/detection/line_zone.py b/src/supervision/detection/line_zone.py new file mode 100644 index 0000000..d36b591 --- /dev/null +++ b/src/supervision/detection/line_zone.py @@ -0,0 +1,911 @@ +import math +import warnings +from collections import Counter, defaultdict, deque +from collections.abc import Iterable +from functools import lru_cache +from typing import Literal + +import cv2 +import numpy as np +import numpy.typing as npt + +from supervision.config import CLASS_NAME_DATA_FIELD +from supervision.detection.core import Detections +from supervision.detection.utils.internal import cross_product +from supervision.draw.color import Color +from supervision.draw.utils import draw_rectangle, draw_text +from supervision.geometry.core import Point, Position, Rect, Vector +from supervision.utils.image import _overlay_image +from supervision.utils.internal import SupervisionWarnings + +TEXT_MARGIN = 10 + + +class LineZone: + """ + This class is responsible for counting the number of objects that cross a + predefined line. + + + + !!! warning + + LineZone uses the `tracker_id`. Read + [here](/latest/trackers/) to learn how to plug + tracking into your inference pipeline. + + Attributes: + in_count: The number of objects that have crossed the line from outside + to inside. + out_count: The number of objects that have crossed the line from inside + to outside. + in_count_per_class: Number of objects of each class that have + crossed the line from outside to inside, keyed by `class_id` + (`int` for classified detections, `None` for unclassified ones). + out_count_per_class: Number of objects of each class that have + crossed the line from inside to outside, keyed by `class_id` + (`int` for classified detections, `None` for unclassified ones). + + Example: + ```pycon + >>> import numpy as np + >>> import supervision as sv + >>> def frames_generator(): + ... yield np.zeros((1080, 1920, 3), dtype=np.uint8) + ... + >>> start = sv.Point(x=0, y=100) + >>> end = sv.Point(x=200, y=100) + >>> line_zone = sv.LineZone(start=start, end=end) + >>> for frame in frames_generator(): + ... detections = sv.Detections( + ... xyxy=np.array([[10, 110, 20, 150]]), + ... tracker_id=np.array([1]) + ... ) + ... crossed_in, crossed_out = line_zone.trigger( + ... detections + ... ) + ... + >>> line_zone.in_count, line_zone.out_count + (0, 0) + >>> for frame in frames_generator(): + ... detections = sv.Detections( + ... xyxy=np.array([[10, 50, 20, 90]]), + ... tracker_id=np.array([1]) + ... ) + ... crossed_in, crossed_out = line_zone.trigger( + ... detections + ... ) + ... + >>> line_zone.in_count, line_zone.out_count + (1, 0) + + ``` + """ + + def __init__( + self, + start: Point, + end: Point, + triggering_anchors: Iterable[Position] = ( + Position.TOP_LEFT, + Position.TOP_RIGHT, + Position.BOTTOM_LEFT, + Position.BOTTOM_RIGHT, + ), + minimum_crossing_threshold: int = 1, + ) -> None: + """ + Args: + start: The starting point of the line. + end: The ending point of the line. + triggering_anchors: A list of positions specifying which anchors of + the detections bounding box to consider when deciding on whether + the detection has passed the line counter or not. By default, + this contains the four corners of the detection's bounding box. + minimum_crossing_threshold: Detection needs to be seen on the other + side of the line for this many frames to be considered as having + crossed the line. This is useful when dealing with unstable + bounding boxes or when detections may linger on the line. + """ + self.vector = Vector(start=start, end=end) + self.limits = self._calculate_region_of_interest_limits(vector=self.vector) + self.crossing_history_length = max(2, minimum_crossing_threshold + 1) + self.crossing_state_history: dict[int, deque[bool]] = defaultdict( + lambda: deque(maxlen=self.crossing_history_length) + ) + # Tracks consecutive frames a tracker key has been absent; eviction + # requires crossing_history_length absent frames so that ByteTrack + # coasting gaps (single-frame detection drops) don't reset mid-crossing + # state prematurely. + self._tracker_frames_absent: dict[int, int] = {} + self._in_count_per_class: Counter[int | None] = Counter() + self._out_count_per_class: Counter[int | None] = Counter() + self.triggering_anchors = triggering_anchors + if not list(self.triggering_anchors): + raise ValueError("Triggering anchors cannot be empty.") + self.class_id_to_name: dict[int, str] = {} + + @property + def in_count(self) -> int: + return sum(self._in_count_per_class.values()) + + @property + def out_count(self) -> int: + return sum(self._out_count_per_class.values()) + + @property + def in_count_per_class(self) -> dict[int | None, int]: + return dict(self._in_count_per_class) + + @property + def out_count_per_class(self) -> dict[int | None, int]: + return dict(self._out_count_per_class) + + def trigger( + self, detections: Detections + ) -> tuple[npt.NDArray[np.bool_], npt.NDArray[np.bool_]]: + """ + Update the `in_count` and `out_count` based on the objects that cross the line. + + Args: + detections: A Detections object for which to update the counts. + + Returns: + A tuple of two boolean NumPy arrays. The first array indicates which + detections have crossed the line from outside to inside. The second + array indicates which detections have crossed the line from inside to + outside. + """ + crossed_in = np.full(len(detections), False) + crossed_out = np.full(len(detections), False) + + if len(detections) == 0: + self._evict_stale_crossing_history(set()) + return crossed_in, crossed_out + + if detections.tracker_id is None: + warnings.warn( + "Line zone counting skipped. LineZone requires tracker_id. Refer to " + "https://supervision.roboflow.com/latest/trackers for more " + "information.", + category=SupervisionWarnings, + ) + return crossed_in, crossed_out + + class_ids: list[int | None] = ( + list(detections.class_id) + if detections.class_id is not None + else [None] * len(detections) + ) + current_keys = {int(tracker_id) for tracker_id in detections.tracker_id} + self._evict_stale_crossing_history(current_keys) + self._update_class_id_to_name(detections) + + in_limits, has_any_left_trigger, has_any_right_trigger = ( + self._compute_anchor_sides(detections) + ) + + for i, (class_id, tracker_id) in enumerate( + zip(class_ids, detections.tracker_id) + ): + if not in_limits[i]: + continue + + if has_any_left_trigger[i] and has_any_right_trigger[i]: + continue + + tracker_state: bool = has_any_left_trigger[i] + key = int(tracker_id) + crossing_history = self.crossing_state_history[key] + crossing_history.append(tracker_state) + + if len(crossing_history) < self.crossing_history_length: + continue + + oldest_state = crossing_history[0] + if crossing_history.count(oldest_state) > 1: + continue + + if tracker_state: + self._in_count_per_class[class_id] += 1 + crossed_in[i] = True + else: + self._out_count_per_class[class_id] += 1 + crossed_out[i] = True + + return crossed_in, crossed_out + + def _evict_stale_crossing_history(self, current_keys: set[int]) -> None: + for key in list(self.crossing_state_history): + if key in current_keys: + self._tracker_frames_absent.pop(key, None) + else: + absent = self._tracker_frames_absent.get(key, 0) + 1 + if absent >= self.crossing_history_length: + del self.crossing_state_history[key] + self._tracker_frames_absent.pop(key, None) + else: + self._tracker_frames_absent[key] = absent + + @staticmethod + def _calculate_region_of_interest_limits(vector: Vector) -> tuple[Vector, Vector]: + magnitude = vector.magnitude + + if magnitude == 0: + raise ValueError("The magnitude of the vector cannot be zero.") + + delta_x = vector.end.x - vector.start.x + delta_y = vector.end.y - vector.start.y + + unit_vector_x = delta_x / magnitude + unit_vector_y = delta_y / magnitude + + perpendicular_vector_x = -unit_vector_y + perpendicular_vector_y = unit_vector_x + + start_region_limit = Vector( + start=vector.start, + end=Point( + x=vector.start.x + perpendicular_vector_x, + y=vector.start.y + perpendicular_vector_y, + ), + ) + end_region_limit = Vector( + start=vector.end, + end=Point( + x=vector.end.x - perpendicular_vector_x, + y=vector.end.y - perpendicular_vector_y, + ), + ) + return start_region_limit, end_region_limit + + def _compute_anchor_sides( + self, detections: Detections + ) -> tuple[npt.NDArray[np.bool_], npt.NDArray[np.bool_], npt.NDArray[np.bool_]]: + """ + Find if detections' anchors are within the limit of the line + zone and which anchors are on its left and right side. + + Assumes: + * At least 1 detection is provided + * Detections have `tracker_id` + + The limit is defined as the region between the two lines, + perpendicular to the line zone, and passing through its start + and end points, as shown below: + + Limits: + ``` + | IN โ†‘ + | | + OUT o---LINE---o OUT + | | + โ†“ IN | + ``` + + Args: + detections: The detections to check. + + Returns: + All 3 arrays are boolean arrays of shape (N, ) where N is the + number of detections. The first array, `in_limits`, indicates + if the detection's anchor is within the line zone limits. + The second array, `has_any_left_trigger`, indicates if the + detection's anchor is on the left side of the line zone. + The third array, `has_any_right_trigger`, indicates if the + detection's anchor is on the right side of the line zone. + """ + assert len(detections) > 0 + assert detections.tracker_id is not None + + all_anchors = np.array( + [ + detections.get_anchors_coordinates(anchor) + for anchor in self.triggering_anchors + ] + ) + + cross_products_1 = cross_product(all_anchors, self.limits[0]) + cross_products_2 = cross_product(all_anchors, self.limits[1]) + + # Works because limit vectors are pointing in opposite directions + in_limits = (cross_products_1 > 0) == (cross_products_2 > 0) + in_limits = np.all(in_limits, axis=0) + + triggers = cross_product(all_anchors, self.vector) < 0 + has_any_left_trigger = np.any(triggers, axis=0) + has_any_right_trigger = np.any(~triggers, axis=0) + + return in_limits, has_any_left_trigger, has_any_right_trigger + + def _update_class_id_to_name(self, detections: Detections) -> None: + """ + Update the attribute keeping track of which class + IDs correspond to which class names. + + Assumes that class_names are only provided when class_ids are. + """ + class_names = detections.data.get(CLASS_NAME_DATA_FIELD) + assert class_names is None or detections.class_id is not None + + if detections.class_id is None: + return + + if class_names is None: + new_names = {class_id: str(class_id) for class_id in detections.class_id} + else: + new_names = { + class_id: class_name + for class_id, class_name in zip(detections.class_id, class_names) + } + self.class_id_to_name.update(new_names) + + +class LineZoneAnnotator: + """ + Draw a `LineZone` and its in/out counts on a video frame. + + Use this annotator after calling `LineZone.trigger` so the rendered counts + reflect the latest tracked detections. + """ + + def __init__( + self, + thickness: int = 2, + color: Color = Color.WHITE, + text_thickness: int = 2, + text_color: Color = Color.BLACK, + text_scale: float = 0.5, + text_offset: float = 1.5, + text_padding: int = 10, + custom_in_text: str | None = None, + custom_out_text: str | None = None, + display_in_count: bool = True, + display_out_count: bool = True, + display_text_box: bool = True, + text_orient_to_line: bool = False, + text_centered: bool = True, + ) -> None: + """ + A class for drawing the `LineZone` and its detected object count + on an image. + + Args: + thickness: Line thickness. + color: Line color. + text_thickness: Text thickness. + text_color: Text color. + text_scale: Text scale. + text_offset: How far the text will be from the line. + text_padding: The empty space in the text box, surrounding the text. + custom_in_text: Write something else instead of "in". + custom_out_text: Write something else instead of "out". + display_in_count: Pass `False` to hide the "in" count. + display_out_count: Pass `False` to hide the "out" count. + display_text_box: Pass `False` to hide the text background box. + text_orient_to_line: Match text orientation to the line. + Recommended to set to `True`. + text_centered: Pass `False` to disable text centering. Useful + when the label overlaps something important. + + """ + self.thickness: int = thickness + self.color: Color = color + self.text_thickness: int = text_thickness + self.text_color: Color = text_color + self.text_scale: float = text_scale + self.text_offset: float = text_offset + self.text_padding: int = text_padding + self.in_text: str = custom_in_text if custom_in_text else "in" + self.out_text: str = custom_out_text if custom_out_text else "out" + self.display_in_count: bool = display_in_count + self.display_out_count: bool = display_out_count + self.display_text_box: bool = display_text_box + self.text_orient_to_line: bool = text_orient_to_line + self.text_centered: bool = text_centered + + def annotate( + self, frame: npt.NDArray[np.uint8], line_counter: LineZone + ) -> npt.NDArray[np.uint8]: + """ + Draws the line on the frame using the line zone provided. + + Args: + frame: The image on which the line will be drawn. + line_counter: The line zone that will be used to draw the line. + + Returns: + The image with the line drawn on it. + + """ + line_start = line_counter.vector.start.as_xy_int_tuple() + line_end = line_counter.vector.end.as_xy_int_tuple() + cv2.line( + frame, + line_start, + line_end, + self.color.as_bgr(), + self.thickness, + lineType=cv2.LINE_AA, + shift=0, + ) + cv2.circle( + frame, + line_start, + radius=5, + color=self.text_color.as_bgr(), + thickness=-1, + lineType=cv2.LINE_AA, + ) + cv2.circle( + frame, + line_end, + radius=5, + color=self.text_color.as_bgr(), + thickness=-1, + lineType=cv2.LINE_AA, + ) + + in_text = f"{self.in_text}: {line_counter.in_count}" + out_text = f"{self.out_text}: {line_counter.out_count}" + line_angle_degrees = self._get_line_angle(line_counter) + + for text, is_shown, is_in_count in [ + (in_text, self.display_in_count, True), + (out_text, self.display_out_count, False), + ]: + if not is_shown: + continue + + if line_angle_degrees == 0 or not self.text_orient_to_line: + self._draw_basic_label( + frame=frame, + line_center=line_counter.vector.center, + text=text, + is_in_count=is_in_count, + ) + else: + self._draw_oriented_label( + frame=frame, + line_zone=line_counter, + text=text, + is_in_count=is_in_count, + ) + + return frame + + def _get_line_angle(self, line_zone: LineZone) -> float: + """ + Calculate the line counter angle (in degrees). + + Args: + line_zone: The line zone object. + + Returns: + Line counter angle, in degrees. + """ + start_point = line_zone.vector.start.as_xy_int_tuple() + end_point = line_zone.vector.end.as_xy_int_tuple() + + delta_x = end_point[0] - start_point[0] + delta_y = end_point[1] - start_point[1] + + if delta_x == 0: + line_angle = 90.0 + line_angle += 180 if delta_y < 0 else 0 + else: + line_angle = math.degrees(math.atan(delta_y / delta_x)) + line_angle += 180 if delta_x < 0 else 0 + + return line_angle + + def _calculate_anchor_in_frame( + self, + line_zone: LineZone, + text_width: int, + text_height: int, + is_in_count: bool, + label_dimension: int, + ) -> tuple[int, int]: + """ + Calculate insertion anchor in frame to position the center of the count image. + + Args: + line_zone: The line counter object used for counting. + text_width: Text width. + text_height: Text height. + is_in_count: Whether the count should be placed over or below line. + label_dimension: Size of the label image. Assumes the + label is rectangular. + + Returns: + xy, point in an image where the label will be placed. + """ + line_angle = self._get_line_angle(line_zone) + + if self.text_centered: + mid_point = Vector( + start=line_zone.vector.start, end=line_zone.vector.end + ).center.as_xy_int_tuple() + anchor = list(mid_point) + else: + end_point = line_zone.vector.end.as_xy_int_tuple() + anchor = list(end_point) + + move_along_x = int( + math.cos(math.radians(line_angle)) + * (text_width / 2 + self.text_padding) + ) + move_along_y = int( + math.sin(math.radians(line_angle)) + * (text_width / 2 + self.text_padding) + ) + + anchor[0] -= move_along_x + anchor[1] -= move_along_y + + move_perpendicular_x = int( + math.sin(math.radians(line_angle)) * (self.text_offset * text_height) + ) + move_perpendicular_y = int( + math.cos(math.radians(line_angle)) * (self.text_offset * text_height) + ) + + if is_in_count: + anchor[0] += move_perpendicular_x + anchor[1] -= move_perpendicular_y + else: + anchor[0] -= move_perpendicular_x + anchor[1] += move_perpendicular_y + + x1 = max(anchor[0] - label_dimension // 2, 0) + y1 = max(anchor[1] - label_dimension // 2, 0) + + return x1, y1 + + def _draw_basic_label( + self, + frame: npt.NDArray[np.uint8], + line_center: Point, + text: str, + is_in_count: bool, + ) -> npt.NDArray[np.uint8]: + """ + Draw the count label on the frame. For example: "out: 7". + The label contains horizontal text and is not rotated. + + Args: + frame: The entire scene, on which the label will be placed. + line_center: The center of the line zone. + text: The text that will be drawn. + is_in_count: Whether to display the in count (above line) + or out count (below line). + + Returns: + The scene with the label drawn on it. + """ + _, text_height = cv2.getTextSize( + text, cv2.FONT_HERSHEY_SIMPLEX, self.text_scale, self.text_thickness + )[0] + + if is_in_count: + line_center.y -= int(self.text_offset * text_height) + else: + line_center.y += int(self.text_offset * text_height) + + draw_text( + scene=frame, + text=text, + text_anchor=line_center, + text_color=self.text_color, + text_scale=self.text_scale, + text_thickness=self.text_thickness, + text_padding=self.text_padding, + background_color=self.color if self.display_text_box else None, + ) + + return frame + + def _draw_oriented_label( + self, + frame: npt.NDArray[np.uint8], + line_zone: LineZone, + text: str, + is_in_count: bool, + ) -> npt.NDArray[np.uint8]: + """ + Draw the count label on the frame. For example: "out: 7". + The label is oriented to match the line angle. + + Args: + frame: The entire scene, on which the label will be placed. + line_zone: The line zone responsible for counting objects crossing it. + text: The text that will be drawn. + is_in_count: Whether to display the in count (above line) + or out count (below line). + + Returns: + The scene with the label drawn on it. + """ + + line_angle_degrees = self._get_line_angle(line_zone) + label_image = self._make_label_image( + text, + text_scale=self.text_scale, + text_thickness=self.text_thickness, + text_padding=self.text_padding, + text_color=self.text_color, + text_box_show=self.display_text_box, + text_box_color=self.color, + line_angle_degrees=line_angle_degrees, + ) + assert label_image.shape[0] == label_image.shape[1] + + text_width, text_height = cv2.getTextSize( + text, cv2.FONT_HERSHEY_SIMPLEX, self.text_scale, self.text_thickness + )[0] + + label_anchor = self._calculate_anchor_in_frame( + line_zone=line_zone, + text_width=text_width, + text_height=text_height, + is_in_count=is_in_count, + label_dimension=label_image.shape[0], + ) + + frame = _overlay_image(frame, label_image, label_anchor) + + return frame + + @staticmethod + @lru_cache(maxsize=32) + def _make_label_image( + text: str, + *, + text_scale: float, + text_thickness: int, + text_padding: int, + text_color: Color, + text_box_show: bool, + text_box_color: Color, + line_angle_degrees: float, + ) -> npt.NDArray[np.uint8]: + """ + Create the small text box displaying line zone count. E.g. "out: 7". + + Args: + text: The text to display. + text_scale: The scale of the text. + text_thickness: The thickness of the text. + text_padding: The padding around the text. + text_color: The color of the text. + text_box_show: Whether to display the text box. + text_box_color: The color of the text box. + line_angle_degrees: The angle of the line in degrees. + + Returns: + The label of shape (H, W, 4), in BGRA format. + """ + text_width, text_height = cv2.getTextSize( + text, cv2.FONT_HERSHEY_SIMPLEX, text_scale, text_thickness + )[0] + + annotation_dim = int((max(text_width, text_height) + text_padding * 2) * 1.5) + annotation_shape = (annotation_dim, annotation_dim) + annotation_center = Point(annotation_dim // 2, annotation_dim // 2) + + annotation: npt.NDArray[np.uint8] = np.zeros( + (*annotation_shape, 3), dtype=np.uint8 + ) + annotation_alpha: npt.NDArray[np.uint8] = np.zeros( + (*annotation_shape, 1), dtype=np.uint8 + ) + draw_text( + scene=annotation, + text=text, + text_anchor=annotation_center, + text_scale=text_scale, + text_thickness=text_thickness, + text_padding=text_padding, + text_color=text_color, + background_color=text_box_color if text_box_show else None, + ) + draw_text( + scene=annotation_alpha, + text=text, + text_anchor=annotation_center, + text_scale=text_scale, + text_thickness=text_thickness, + text_padding=text_padding, + text_color=Color.WHITE, + background_color=Color.WHITE if text_box_show else None, + ) + annotation = np.dstack((annotation, annotation_alpha)).astype(np.uint8) + + # Make sure text is displayed upright + if 90 < line_angle_degrees % 360 < 270: + annotation = cv2.flip(annotation, flipCode=-1).astype(np.uint8) + + rotation_angle = -line_angle_degrees + rotation_matrix = cv2.getRotationMatrix2D( + annotation_center.as_xy_float_tuple(), rotation_angle, scale=1 + ) + annotation = cv2.warpAffine( + annotation, rotation_matrix, annotation_shape + ).astype(np.uint8) + + return annotation + + +class LineZoneAnnotatorMulticlass: + """ + Draw per-class crossing counts for one or more `LineZone` instances. + + The annotator renders a table with one row per line zone and one column per + class observed by the zones. + """ + + def __init__( + self, + *, + table_position: Literal[ + Position.TOP_LEFT, + Position.TOP_RIGHT, + Position.BOTTOM_LEFT, + Position.BOTTOM_RIGHT, + ] = Position.TOP_RIGHT, + table_color: Color = Color.WHITE, + table_margin: int = 10, + table_padding: int = 10, + table_max_width: int = 400, + text_color: Color = Color.BLACK, + text_scale: float = 0.75, + text_thickness: int = 1, + force_draw_class_ids: bool = False, + ) -> None: + """ + Draw a table showing how many items of each class crossed each line. + + Args: + table_position: The position of the table. + table_color: The color of the table. + table_margin: The margin of the table from the image border. + table_padding: The padding of the table. + table_max_width: The maximum width of the table. + text_color: The color of the text. + text_scale: The scale of the text. + text_thickness: The thickness of the text. + force_draw_class_ids: Instead of writing the class names, + on the table, write the class IDs. E.g. instead of `person: 6`, + write `0: 6`. + """ + if table_position not in { + Position.TOP_LEFT, + Position.TOP_RIGHT, + Position.BOTTOM_LEFT, + Position.BOTTOM_RIGHT, + }: + raise ValueError( + "Invalid table position. Supported values are:" + " TOP_LEFT, TOP_RIGHT, BOTTOM_LEFT, BOTTOM_RIGHT." + ) + + self.table_position = table_position + self.table_color = table_color + self.table_margin = table_margin + self.table_padding = table_padding + self.table_max_width = table_max_width + self.text_color = text_color + self.text_scale = text_scale + self.text_thickness = text_thickness + self.force_draw_class_ids = force_draw_class_ids + + def annotate( + self, + frame: npt.NDArray[np.uint8], + line_zones: list[LineZone], + line_zone_labels: list[str] | None = None, + ) -> npt.NDArray[np.uint8]: + """ + Draws a table with the number of objects of each class that crossed each line. + + Args: + frame: The image on which the table will be drawn. + line_zones: The line zones to be annotated. + line_zone_labels: The labels, one for each line zone. If not + provided, the default labels will be used. + + Returns: + The image with the table drawn on it. + + """ + if line_zone_labels is None: + line_zone_labels = [f"Line {i + 1}:" for i in range(len(line_zones))] + if len(line_zones) != len(line_zone_labels): + raise ValueError("The number of line zones and their labels must match.") + + text_lines = ["Line Crossings:"] + for line_zone, line_zone_label in zip(line_zones, line_zone_labels): + text_lines.append(line_zone_label) + class_id_to_name = line_zone.class_id_to_name + + for direction, count_per_class in [ + ("In", line_zone.in_count_per_class), + ("Out", line_zone.out_count_per_class), + ]: + if not count_per_class: + continue + + text_lines.append(f" {direction}:") + for class_id, count in count_per_class.items(): + if self.force_draw_class_ids: + class_name = str(class_id) + elif class_id is None: + class_name = "None" + else: + class_name = class_id_to_name.get(class_id, str(class_id)) + text_lines.append(f" {class_name}: {count}") + + table_width, table_height = 0, 0 + for line in text_lines: + text_width, text_height = cv2.getTextSize( + line, cv2.FONT_HERSHEY_SIMPLEX, self.text_scale, self.text_thickness + )[0] + text_height += TEXT_MARGIN + table_width = max(table_width, text_width) + table_height += text_height + + table_width += 2 * self.table_padding + table_height += 2 * self.table_padding + table_max_height = frame.shape[0] - 2 * self.table_margin + table_height = min(table_height, table_max_height) + table_width = min(table_width, self.table_max_width) + + position_map = { + Position.TOP_LEFT: (self.table_margin, self.table_margin), + Position.TOP_RIGHT: ( + frame.shape[1] - table_width - self.table_margin, + self.table_margin, + ), + Position.BOTTOM_LEFT: ( + self.table_margin, + frame.shape[0] - table_height - self.table_margin, + ), + Position.BOTTOM_RIGHT: ( + frame.shape[1] - table_width - self.table_margin, + frame.shape[0] - table_height - self.table_margin, + ), + } + table_x1, table_y1 = position_map[self.table_position] + + table_rect = Rect( + x=table_x1, y=table_y1, width=table_width, height=table_height + ) + frame = draw_rectangle( + scene=frame, rect=table_rect, color=self.table_color, thickness=-1 + ) + + for i, line in enumerate(text_lines): + _, text_height = cv2.getTextSize( + line, cv2.FONT_HERSHEY_SIMPLEX, self.text_scale, self.text_thickness + )[0] + text_height += TEXT_MARGIN + anchor_x = table_x1 + self.table_padding + anchor_y = table_y1 + self.table_padding + (i + 1) * text_height + + cv2.putText( + img=frame, + text=line, + org=(anchor_x, anchor_y), + fontFace=cv2.FONT_HERSHEY_SIMPLEX, + fontScale=self.text_scale, + color=self.text_color.as_bgr(), + thickness=self.text_thickness, + lineType=cv2.LINE_AA, + ) + + return frame diff --git a/src/supervision/detection/tools/__init__.py b/src/supervision/detection/tools/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/src/supervision/detection/tools/csv_sink.py b/src/supervision/detection/tools/csv_sink.py new file mode 100644 index 0000000..033db63 --- /dev/null +++ b/src/supervision/detection/tools/csv_sink.py @@ -0,0 +1,242 @@ +from __future__ import annotations + +import csv +import io +import os +from collections.abc import Iterable +from typing import Any, Protocol + +import numpy as np + +from supervision.detection.core import Detections +from supervision.utils.logger import _get_logger + +logger = _get_logger(__name__) + +BASE_HEADER = [ + "x_min", + "y_min", + "x_max", + "y_max", + "class_id", + "confidence", + "tracker_id", +] + + +class WriterProtocol(Protocol): + def writerow(self, row: Iterable[Any]) -> Any: ... + + +class CSVSink: + """ + A utility class for saving detection data to a CSV file. This class is designed to + efficiently serialize detection objects into a CSV format, allowing for the + inclusion of bounding box coordinates and additional attributes like `confidence`, + `class_id`, and `tracker_id`. + + !!! tip + + CSVSink allows passing custom data alongside detection fields, providing + flexibility for logging various types of information. + When a NumPy array, list, or tuple value in custom_data (or + detections.data) has the same length as the detection count, each + element is written to the corresponding detection row; any other value + is broadcast to all rows. + + Args: + file_name: The name of the CSV file where the detections will be stored. + Defaults to 'output.csv'. + + Example: + ```pycon + >>> import supervision as sv + >>> import numpy as np + >>> import tempfile + >>> import os + >>> # Create synthetic detections + >>> detections = sv.Detections( + ... xyxy=np.array([[10, 20, 30, 40], [50, 60, 70, 80]]), + ... confidence=np.array([0.9, 0.8]), + ... class_id=np.array([0, 1]) + ... ) + >>> # Use temporary file + >>> temp_file = tempfile.NamedTemporaryFile( + ... mode='w', suffix='.csv', delete=False + ... ) + >>> temp_file.close() + >>> csv_sink = sv.CSVSink(temp_file.name) + >>> with csv_sink as sink: + ... sink.append(detections, custom_data={'frame': 0}) + >>> os.unlink(temp_file.name) # Clean up + + ``` + """ + + def __init__(self, file_name: str = "output.csv") -> None: + """ + Initialize the CSVSink instance. + + Args: + file_name: The name of the CSV file. + """ + self.file_name = file_name + self.file: io.TextIOWrapper | None = None + self.writer: WriterProtocol | None = None + self.header_written = False + self.field_names: list[str] = [] + + def __enter__(self) -> CSVSink: + self.open() + return self + + def __exit__( + self, + exc_type: type | None, + exc_val: Exception | None, + exc_tb: Any | None, + ) -> None: + self.close() + + def open(self) -> None: + """ + Open the CSV file for writing. + """ + parent_directory = os.path.dirname(self.file_name) + if parent_directory and not os.path.exists(parent_directory): + os.makedirs(parent_directory) + + self.file = open(self.file_name, "w", newline="") + self.writer = csv.writer(self.file) + + def close(self) -> None: + """ + Close the CSV file. + """ + if self.file: + self.file.close() + + @staticmethod + def _slice_value(value: Any, i: int, n: int) -> Any: + """ + Return the i-th element when the value stores per-detection data. + + Dispatch rules: + - np.ndarray with ndim == 0: return as-is for broadcasting + - np.ndarray with len equal to n: return value[i] + - list or tuple with len equal to n: return value[i] + - any other type: return as-is for broadcasting + + Args: + value: Custom-data field value. + i: Zero-based detection index. + n: Total number of detections. + + Returns: + Element at position i if value is a per-detection sequence, + otherwise value unchanged. + """ + if isinstance(value, np.ndarray): + return value[i] if value.ndim > 0 and len(value) == n else value + if isinstance(value, (list, tuple)) and len(value) == n: + return value[i] + return value + + @staticmethod + def parse_detection_data( + detections: Detections, custom_data: dict[str, Any] | None = None + ) -> list[dict[str, Any]]: + """ + Convert detections and optional custom data into per-detection rows. + + Builds one dictionary per detection containing bounding box coordinates, + detection attributes, and any values from ``detections.data`` or + ``custom_data``. NumPy array, list, and tuple values in + ``custom_data`` with length equal to ``len(detections.xyxy)`` are + sliced one element per row; all other values are broadcast to every row. + + Args: + detections: Detection data to serialize into row dictionaries. + custom_data: Optional extra fields to include in each row. + + Returns: + A list of dictionaries, one per detection, containing ``xyxy`` + coordinates, ``class_id``, ``confidence``, ``tracker_id``, and any + values from ``detections.data`` or ``custom_data``. + """ + parsed_rows = [] + n = len(detections.xyxy) + for i in range(n): + row = { + "x_min": detections.xyxy[i][0], + "y_min": detections.xyxy[i][1], + "x_max": detections.xyxy[i][2], + "y_max": detections.xyxy[i][3], + "class_id": "" + if detections.class_id is None + else str(detections.class_id[i]), + "confidence": "" + if detections.confidence is None + else str(detections.confidence[i]), + "tracker_id": "" + if detections.tracker_id is None + else str(detections.tracker_id[i]), + } + + if hasattr(detections, "data"): + for key, value in detections.data.items(): + row[key] = CSVSink._slice_value(value, i, n) + + if custom_data: + for key, value in custom_data.items(): + row[key] = CSVSink._slice_value(value, i, n) + + parsed_rows.append(row) + return parsed_rows + + def append( + self, detections: Detections, custom_data: dict[str, Any] | None = None + ) -> None: + """ + Append detection data to the CSV file. + + Args: + detections: The detection data. + custom_data: Custom data to include. Scalars, dictionaries, and + other non-sequence values are broadcast to every detection in + this batch. NumPy arrays, lists, and tuples with length equal + to ``len(detections)`` are sliced per detection; other lists + and tuples are broadcast unchanged. + """ + if not self.writer: + raise Exception( + f"Cannot append to CSV: The file '{self.file_name}' is not open." + ) + field_names = CSVSink.parse_field_names(detections, custom_data) + if not self.header_written: + self.field_names = field_names + self.writer.writerow(field_names) + self.header_written = True + + if field_names != self.field_names: + logger.warning( + "Field names do not match the header. Expected: %s, given: %s", + self.field_names, + field_names, + ) + + parsed_rows = CSVSink.parse_detection_data(detections, custom_data) + for row in parsed_rows: + self.writer.writerow( + [row.get(field_name, "") for field_name in self.field_names] + ) + + @staticmethod + def parse_field_names( + detections: Detections, custom_data: dict[str, Any] | None = None + ) -> list[str]: + custom_keys = set(custom_data.keys()) if custom_data else set() + dynamic_header = sorted( + custom_keys | set(getattr(detections, "data", {}).keys()) + ) + return BASE_HEADER + dynamic_header diff --git a/src/supervision/detection/tools/inference_slicer.py b/src/supervision/detection/tools/inference_slicer.py new file mode 100644 index 0000000..ac5863f --- /dev/null +++ b/src/supervision/detection/tools/inference_slicer.py @@ -0,0 +1,776 @@ +from __future__ import annotations + +import threading +import warnings +from collections.abc import Callable +from concurrent.futures import ThreadPoolExecutor, as_completed +from typing import TYPE_CHECKING, Any, Protocol, cast, runtime_checkable + +if TYPE_CHECKING: + from typing import TypeGuard + +import numpy as np +import numpy.typing as npt + +from supervision.config import ORIENTED_BOX_COORDINATES +from supervision.detection.compact_mask import CompactMask +from supervision.detection.core import Detections +from supervision.detection.utils.boxes import move_boxes, move_oriented_boxes +from supervision.detection.utils.iou_and_nms import OverlapFilter, OverlapMetric +from supervision.detection.utils.masks import move_masks +from supervision.draw.base import ImageType +from supervision.utils.image import crop_image, get_image_resolution_wh +from supervision.utils.internal import SupervisionWarnings +from supervision.utils.iterables import create_batches + + +@runtime_checkable +class WindowedRasterDataset(Protocol): + """Structural type for a rasterio-style dataset read window-by-window. + + Matched structurally by `_is_windowed_raster` rather than by import so + `rasterio` stays an optional dependency โ€” any object exposing these members + works. `rasterio.io.DatasetReader` satisfies this protocol. + """ + + width: int + height: int + crs: object | None + + def read(self, window: Any) -> npt.NDArray[Any]: ... + + +def _is_windowed_raster(image: object) -> TypeGuard[WindowedRasterDataset]: + """Duck-type check for a rasterio-style dataset that supports windowed reads. + + Avoids importing rasterio so it remains an optional dependency. numpy arrays + and PIL images do not expose this combination of attributes. + """ + return ( + callable(getattr(image, "read", None)) + and hasattr(image, "crs") + and hasattr(image, "width") + and hasattr(image, "height") + ) + + +def move_detections( + detections: Detections, + offset: npt.NDArray[Any], + resolution_wh: tuple[int, int] | None = None, +) -> Detections: + """Translate detections by a pixel offset, repositioning boxes and masks. + + Args: + detections: Detections object to be moved. The input is left unchanged; + a fresh copy is returned. + offset: An array of shape `(2,)` containing offset values in the + format `[dx, dy]`. + resolution_wh: The width and height of the desired mask + resolution. Required for segmentation detections. + + Returns: + Repositioned Detections object. + """ + detections = detections.select(slice(None)) + detections.xyxy = move_boxes(xyxy=detections.xyxy, offset=offset) + if ORIENTED_BOX_COORDINATES in detections.data: + detections.data[ORIENTED_BOX_COORDINATES] = move_oriented_boxes( + xyxyxyxy=cast( + npt.NDArray[np.number], detections.data[ORIENTED_BOX_COORDINATES] + ), + offset=offset, + ) + if detections.mask is not None: + if resolution_wh is None: + raise ValueError( + "Resolution width and height are required for moving segmentation " + "detections. This should be the same as (width, height) of image shape." + ) + if isinstance(detections.mask, CompactMask): + # Preserve move_masks clipping semantics without dense materialisation. + detections.mask = detections.mask.with_offset( + dx=int(offset[0]), + dy=int(offset[1]), + new_image_shape=(resolution_wh[1], resolution_wh[0]), + ) + else: + detections.mask = move_masks( + masks=detections.mask, offset=offset, resolution_wh=resolution_wh + ) + return detections + + +class InferenceSlicer: + """ + Perform tiled inference on large images by slicing them into overlapping patches. + + This class divides an input image into overlapping slices of configurable size + and overlap, runs inference on each slice through a user-provided callback, and + merges the resulting detections. The slicing process allows efficient processing + of large images with limited resources while preserving detection accuracy via + configurable overlap and post-processing of overlaps. Uses multi-threading for + parallel slice inference. + + Args: + callback: Inference function called for each slice (or batch of slices). + + When ``batch_size=1`` (default) the function receives a single + ``np.ndarray`` and must return a single + :class:`~supervision.detection.core.Detections` โ€” the original + single-image contract, fully backward-compatible. + + When ``batch_size > 1`` the function receives + ``list[np.ndarray]`` (one array per slice) and must return + ``list[Detections]`` of the **same length** in the same order. + A length mismatch or non-list return raises :exc:`ValueError`. + + The two signatures are **not interchangeable**: a callback written + for ``batch_size=1`` will fail when ``batch_size > 1``, and vice + versa. + slice_wh: Size of each slice `(width, height)`. If int, both width and + height are set to this value. + overlap_wh: Overlap size `(width, height)` between slices. If int, both + width and height are set to this value. + overlap_filter: Strategy to merge overlapping detections + (`NON_MAX_SUPPRESSION`, `NON_MAX_MERGE`, or `NONE`). + iou_threshold: IOU threshold used in merging overlap filtering. + overlap_metric: Metric to compute overlap (`IOU` or `IOS`). + thread_workers: Number of threads for concurrent slice inference. + Must be a positive integer. When the first slice returns oriented + bounding boxes (OBB), Supervision probes additional slices until a + non-empty result is found, then falls back to sequential processing + for all remaining slices to avoid thread-safety issues in common OBB + inference backends. When passing a rasterio-style dataset, tile reads + are serialized via an internal lock regardless of this setting โ€” + model inference runs in parallel, but ``raster.read()`` is protected. + Note: the first slice always runs synchronously + regardless of this setting, so for grids with few slices + (e.g. two-slice images) effective parallelism is reduced. + compact_masks: If ``True``, dense ``(N, H, W)`` boolean mask + arrays returned by the callback are immediately converted to a + :class:`~supervision.detection.compact_mask.CompactMask`. This + keeps masks in run-length-encoded form for the entire pipeline โ€” + merge, NMS, and annotation โ€” avoiding the large ``(N, H, W)`` + allocations that cause OOM on high-resolution images with many + objects. IoU and NMS are computed directly on the RLE crops + without ever materialising a full ``(N, H, W)`` array. + Defaults to ``False`` for backward compatibility. + + When ``compact_masks=True``, each detection's CompactMask crop spans + the entire slice tile bbox (not the tight detection bbox). Call + :meth:`~supervision.detection.compact_mask.CompactMask.repack` on the + merged result to tighten crops to the detection bounding boxes. + batch_size: Number of slices passed to the callback per call. + Defaults to ``1``, which uses the single-image callback contract + (``np.ndarray`` โ†’ :class:`~supervision.detection.core.Detections`). + Set to ``> 1`` to enable the batch callback contract + (``list[np.ndarray]`` โ†’ ``list[Detections]``). + + For GPU-backed models, prefer ``batch_size > 1`` with + ``thread_workers=1``. A single batched forward pass is faster than + concurrent single-image calls that compete for the same CUDA device, + and avoids multiplying peak VRAM by ``thread_workers * batch_size``. + Must be a positive integer. + + Raises: + ValueError: If ``slice_wh``, ``overlap_wh``, or ``thread_workers`` are + invalid or inconsistent. + ValueError: If ``batch_size < 1``. + ValueError: If the callback returns a non-list when ``batch_size > 1``. + ValueError: If the callback returns a list whose length differs from the + number of slices passed when ``batch_size > 1``. + + Example: + ```python + import cv2 + import supervision as sv + from rfdetr import RFDETRMedium + + model = RFDETRMedium() + + def callback(tile): + return model.predict(tile) + + slicer = sv.InferenceSlicer(callback, slice_wh=640, overlap_wh=100) + + image = cv2.imread("example.png") + detections = slicer(image) + ``` + + ```python + import supervision as sv + from PIL import Image + from ultralytics import YOLO + + model = YOLO("yolo11m.pt") + + def callback(tile): + results = model(tile)[0] + return sv.Detections.from_ultralytics(results) + + slicer = sv.InferenceSlicer(callback, slice_wh=640, overlap_wh=100) + + image = Image.open("example.png") + detections = slicer(image) + ``` + + ```python + import rasterio + import supervision as sv + + def callback(tile): # tile is (H, W, C); select/convert bands as needed + ... + + slicer = sv.InferenceSlicer(callback, slice_wh=640, overlap_wh=100) + + with rasterio.open("large_orthomosaic.tif") as dataset: + detections = slicer(dataset) + ``` + + Passing an open rasterio dataset reads each tile lazily via a windowed + read, so multi-GB GeoTIFFs never need to be loaded into memory at once. + `rasterio` is an optional dependency installable via + `pip install "supervision[geotiff]"`. + + Batch inference โ€” pass multiple slices per callback call for GPU models + that benefit from batched forward passes: + + ```python + import cv2 + import numpy as np + import supervision as sv + + # Batch callback: receives list[np.ndarray], returns list[Detections] + def batch_callback(tiles: list[np.ndarray]) -> list[sv.Detections]: + # Run your model on the batch; return one Detections per tile. + return [sv.Detections.empty() for _ in tiles] + + slicer = sv.InferenceSlicer( + callback=batch_callback, + slice_wh=640, + overlap_wh=100, + batch_size=8, + thread_workers=1, # recommended for GPU: batch not threads + ) + + image = cv2.imread("example.png") + detections = slicer(image) + ``` + """ + + def __init__( + self, + callback: ( + Callable[[ImageType], Detections] + | Callable[[list[npt.NDArray[Any]]], list[Detections]] + ), + slice_wh: int | tuple[int, int] = 640, + overlap_wh: int | tuple[int, int] = 100, + overlap_filter: OverlapFilter | str = OverlapFilter.NON_MAX_SUPPRESSION, + iou_threshold: float = 0.5, + overlap_metric: OverlapMetric | str = OverlapMetric.IOU, + thread_workers: int = 1, + compact_masks: bool = False, + batch_size: int = 1, + ): + slice_wh_norm = self._normalize_slice_wh(slice_wh) + overlap_wh_norm = self._normalize_overlap_wh(overlap_wh) + + self._validate_overlap(slice_wh=slice_wh_norm, overlap_wh=overlap_wh_norm) + + if thread_workers < 1: + raise ValueError( + "`thread_workers` must be a positive integer. " + f"Received: {thread_workers}" + ) + if batch_size < 1: + raise ValueError( + f"`batch_size` must be a positive integer. Received: {batch_size}" + ) + + self.slice_wh = slice_wh_norm + self.overlap_wh = overlap_wh_norm + self.iou_threshold = iou_threshold + self.overlap_metric = OverlapMetric.from_value(overlap_metric) + self.overlap_filter = OverlapFilter.from_value(overlap_filter) + # Stored as single-image type; batch path calls with list[ndarray] via + # _run_callback_batch which suppresses the arg-type mismatch there. + self.callback: Callable[[npt.NDArray[Any]], Detections] = callback # type: ignore[assignment] + self.thread_workers = thread_workers + self.compact_masks = compact_masks + self.batch_size = batch_size + self._out_of_slice_bounds_warned: bool = False + self._out_of_slice_bounds_lock = threading.Lock() + self._obb_thread_workers_warned: bool = False + self._obb_thread_workers_lock = threading.Lock() + self._raster_read_lock = threading.Lock() + + def __call__(self, image: ImageType | WindowedRasterDataset) -> Detections: + """ + Perform tiled inference on the full image and return merged detections. + + The first slice always runs synchronously so the output type can be + inspected before committing to a threading strategy. Detections are + merged in a deterministic order: the first slice is always at index 0, + followed by any probe slices, then the remaining slices in source order. + If oriented bounding boxes are detected, all remaining slices are + processed sequentially and a ``SupervisionWarnings`` warning is emitted + once per slicer instance. + + Args: + image: The full image to run inference on. In addition to in-memory + images (NumPy arrays or PIL images), this also accepts an open + rasterio-style dataset. When a dataset is provided, each tile is + read lazily via a windowed read instead of loading the whole image + into memory, enabling tiled inference on multi-GB GeoTIFFs. Tiles + read from a dataset preserve the source dtype (e.g. ``uint16`` for + 16-bit sensors) and keep every band; convert or select bands to + the dtype/channels your model expects inside the callback. + + Returns: + Merged detections across all slices. + + Raises: + ValueError: If ``image`` is a rasterio-style dataset whose CRS is + geographic (non-projected). Reproject to a projected CRS + (e.g. with ``gdalwarp``) before calling. + """ + detections_list: list[Detections] = [] + resolution_wh = self._get_resolution_wh(image) + + offsets = self._generate_offset( + resolution_wh=resolution_wh, + slice_wh=self.slice_wh, + overlap_wh=self.overlap_wh, + ) + + if self.batch_size > 1: + batched = list(create_batches(offsets, self.batch_size)) + # Run first batch synchronously: fail-fast type validation + OBB probe. + first_batch_results = self._run_callback_batch(image, batched[0]) + detections_list.extend(first_batch_results) + obb_detected = any( + ORIENTED_BOX_COORDINATES in det.data for det in first_batch_results + ) + if obb_detected and self.thread_workers > 1: + with self._obb_thread_workers_lock: + if not self._obb_thread_workers_warned: + self._obb_thread_workers_warned = True + warnings.warn( + "InferenceSlicer detected oriented bounding boxes while " + "`thread_workers > 1`. Remaining batches will be processed " + "sequentially because many OBB inference backends are not " + "thread-safe and can crash when shared across threads.", + category=SupervisionWarnings, + stacklevel=2, + ) + remaining_batches = batched[1:] + if self.thread_workers == 1 or obb_detected: + for offset_batch in remaining_batches: + detections_list.extend( + self._run_callback_batch(image, offset_batch) + ) + else: + with ThreadPoolExecutor(max_workers=self.thread_workers) as executor: + batch_futures = [ + executor.submit(self._run_callback_batch, image, ob) + for ob in remaining_batches + ] + for batch_future in as_completed(batch_futures): + detections_list.extend(batch_future.result()) + merged = Detections.merge(detections_list=detections_list) + return self._apply_overlap_filter(merged) + + first_offset = offsets[0] + first_detections = self._run_callback(image, first_offset) + detections_list.append(first_detections) + + remaining_offsets = offsets[1:] + obb_detected = ORIENTED_BOX_COORDINATES in first_detections.data + should_run_sequentially = self.thread_workers <= 1 or obb_detected + + probe_index = 0 + if not should_run_sequentially and len(first_detections) == 0: + while probe_index < len(remaining_offsets): + probe_offset = remaining_offsets[probe_index] + probe_detections = self._run_callback(image, probe_offset) + detections_list.append(probe_detections) + probe_index += 1 + + if ORIENTED_BOX_COORDINATES in probe_detections.data: + obb_detected = True + should_run_sequentially = True + break + + if len(probe_detections) > 0: + break + + remaining_offsets = remaining_offsets[probe_index:] + + if should_run_sequentially: + if self.thread_workers > 1 and obb_detected: + with self._obb_thread_workers_lock: + if not self._obb_thread_workers_warned: + self._obb_thread_workers_warned = True + warnings.warn( + "InferenceSlicer detected oriented bounding boxes while " + "`thread_workers > 1`. Remaining slices will be processed " + "sequentially because many OBB inference backends are not " + "thread-safe and can crash when shared across threads.", + category=SupervisionWarnings, + stacklevel=2, + ) + for offset in remaining_offsets: + detections_list.append(self._run_callback(image, offset)) + else: + with ThreadPoolExecutor(max_workers=self.thread_workers) as executor: + futures = [ + executor.submit(self._run_callback, image, offset) + for offset in remaining_offsets + ] + for future in as_completed(futures): + detections_list.append(future.result()) + + merged = Detections.merge(detections_list=detections_list) + return self._apply_overlap_filter(merged) + + def _get_resolution_wh( + self, image: ImageType | WindowedRasterDataset + ) -> tuple[int, int]: + """Return ``(width, height)`` for the image, validating CRS for rasters.""" + if _is_windowed_raster(image): + crs = image.crs + if crs is not None and not getattr(crs, "is_projected", True): + raise ValueError( + "InferenceSlicer requires a projected coordinate reference " + "system for pixel-space tiled inference on a raster dataset. " + f"The provided dataset uses a geographic CRS ({crs}). Reproject " + "it to a projected CRS (e.g. with `gdalwarp`) before slicing." + ) + return (image.width, image.height) + return get_image_resolution_wh(image) + + def _apply_overlap_filter(self, merged: Detections) -> Detections: + """Apply the configured overlap filter strategy to merged detections.""" + if self.overlap_filter == OverlapFilter.NONE: + return merged + if self.overlap_filter == OverlapFilter.NON_MAX_SUPPRESSION: + return merged.with_nms( + threshold=self.iou_threshold, + overlap_metric=self.overlap_metric, + ) + if self.overlap_filter == OverlapFilter.NON_MAX_MERGE: + return merged.with_nmm( + threshold=self.iou_threshold, + overlap_metric=self.overlap_metric, + ) + warnings.warn( + f"Invalid overlap filter strategy: {self.overlap_filter}", + category=SupervisionWarnings, + ) + return merged + + def _run_callback( + self, image: ImageType | WindowedRasterDataset, offset: npt.NDArray[Any] + ) -> Detections: + """ + Run detection callback on a sliced portion of the image and adjust coordinates. + + Args: + image: The full image. + offset: Coordinates `(x_min, y_min, x_max, y_max)` defining + the slice region. + + Returns: + Detections adjusted to the full image coordinate system. + """ + if _is_windowed_raster(image): + x_min, y_min, x_max, y_max = (int(v) for v in offset) + # rasterio tuple window: ((row_start, row_stop), (col_start, col_stop)) + window = ((y_min, y_max), (x_min, x_max)) + with self._raster_read_lock: + bands = image.read(window=window) # shape (channels, height, width) + image_slice = np.ascontiguousarray( + np.transpose(bands, (1, 2, 0)) + ) # -> (H, W, C) + resolution_wh = (image.width, image.height) + else: + image_slice = crop_image(image=image, xyxy=offset) + resolution_wh = get_image_resolution_wh(image) + + detections = self.callback(image_slice) + + if ( + self.compact_masks + and detections.mask is not None + and isinstance(detections.mask, np.ndarray) + ): + slice_w, slice_h = get_image_resolution_wh(image_slice) + full_slice_xyxy = np.tile( + np.array([[0, 0, slice_w - 1, slice_h - 1]], dtype=np.float64), + (len(detections), 1), + ) + detections.mask = CompactMask.from_dense( + detections.mask, + full_slice_xyxy, + image_shape=(slice_h, slice_w), + ) + + # Fast-path: skip locking and bounds checking when the warning has already + # been emitted or when there are no detections to inspect. + needs_warning_check = ( + not self._out_of_slice_bounds_warned and len(detections) > 0 + ) + + if needs_warning_check: + with self._out_of_slice_bounds_lock: + # Re-check under the lock to ensure correctness with multiple threads. + if not self._out_of_slice_bounds_warned and len(detections) > 0: + slice_width = offset[2] - offset[0] + slice_height = offset[3] - offset[1] + x_exceeds = np.any(detections.xyxy[:, [0, 2]] > slice_width) + y_exceeds = np.any(detections.xyxy[:, [1, 3]] > slice_height) + x_negative = np.any(detections.xyxy[:, [0, 2]] < 0) + y_negative = np.any(detections.xyxy[:, [1, 3]] < 0) + if x_exceeds or y_exceeds or x_negative or y_negative: + self._out_of_slice_bounds_warned = True + msg = ( + "Detections returned by the callback have coordinates " + "outside the slice bounds. This may be caused by the " + "callback running inference on the full image instead of " + "the provided image slice. Ensure your callback uses the " + "input slice for inference, not the original " + "full-resolution image." + ) + warnings.warn(msg, category=SupervisionWarnings, stacklevel=2) + detections = move_detections( + detections=detections, + offset=offset[:2], + resolution_wh=resolution_wh, + ) + return detections + + def _run_callback_batch( + self, + image: ImageType | WindowedRasterDataset, + offsets: list[npt.NDArray[Any]], + ) -> list[Detections]: + """Run batch inference callback on multiple slices. + + Args: + image: The full image or rasterio dataset. + offsets: List of slice coordinates `(x_min, y_min, x_max, y_max)`. + + Returns: + Detections adjusted to full-image coordinates, one per offset. + """ + if _is_windowed_raster(image): + slices = [] + for offset in offsets: + x_min, y_min, x_max, y_max = (int(v) for v in offset) + window = ((y_min, y_max), (x_min, x_max)) + with self._raster_read_lock: + bands = image.read(window=window) + slices.append(np.ascontiguousarray(np.transpose(bands, (1, 2, 0)))) + resolution_wh = (image.width, image.height) + else: + slices = [crop_image(image=image, xyxy=offset) for offset in offsets] + resolution_wh = get_image_resolution_wh(image) + + batch_callback = cast( + Callable[[list[npt.NDArray[Any]]], list[Detections]], self.callback + ) + detections_in_slices = batch_callback(slices) + if not isinstance(detections_in_slices, list): + raise ValueError( + "Callback must return `list[Detections]` when `batch_size > 1`. " + f"Got: {type(detections_in_slices)}" + ) + if len(detections_in_slices) != len(offsets): + raise ValueError( + f"Callback returned {len(detections_in_slices)} Detections " + f"for {len(offsets)} slices. Lengths must match." + ) + + if self.compact_masks: + for det, image_slice in zip(detections_in_slices, slices): + if det.mask is not None and isinstance(det.mask, np.ndarray): + slice_w, slice_h = get_image_resolution_wh(image_slice) + full_slice_xyxy = np.tile( + np.array([[0, 0, slice_w - 1, slice_h - 1]], dtype=np.float64), + (len(det), 1), + ) + det.mask = CompactMask.from_dense( + det.mask, + full_slice_xyxy, + image_shape=(slice_h, slice_w), + ) + + if not self._out_of_slice_bounds_warned: + for det, offset in zip(detections_in_slices, offsets): + if self._out_of_slice_bounds_warned or len(det) == 0: + continue + with self._out_of_slice_bounds_lock: + if not self._out_of_slice_bounds_warned and len(det) > 0: + slice_width = offset[2] - offset[0] + slice_height = offset[3] - offset[1] + x_exceeds = np.any(det.xyxy[:, [0, 2]] > slice_width) + y_exceeds = np.any(det.xyxy[:, [1, 3]] > slice_height) + x_negative = np.any(det.xyxy[:, [0, 2]] < 0) + y_negative = np.any(det.xyxy[:, [1, 3]] < 0) + if x_exceeds or y_exceeds or x_negative or y_negative: + self._out_of_slice_bounds_warned = True + warnings.warn( + "Detections returned by the callback have coordinates " + "outside the slice bounds. This may be caused by the " + "callback running inference on the full image instead " + "of the provided image slice. Ensure your callback " + "uses the input slice for inference, not the original " + "full-resolution image.", + category=SupervisionWarnings, + stacklevel=2, + ) + + return [ + move_detections( + detections=det, offset=offset[:2], resolution_wh=resolution_wh + ) + for det, offset in zip(detections_in_slices, offsets) + ] + + @staticmethod + def _normalize_slice_wh( + slice_wh: int | tuple[int, int], + ) -> tuple[int, int]: + if isinstance(slice_wh, int): + if slice_wh <= 0: + raise ValueError( + f"`slice_wh` must be a positive integer. Received: {slice_wh}" + ) + return slice_wh, slice_wh + + if isinstance(slice_wh, tuple) and len(slice_wh) == 2: + width, height = slice_wh + if width <= 0 or height <= 0: + raise ValueError( + f"`slice_wh` values must be positive. Received: {slice_wh}" + ) + return width, height + + raise ValueError( + "`slice_wh` must be an int or a tuple of two positive integers " + "(slice_w, slice_h). " + f"Received: {slice_wh}" + ) + + @staticmethod + def _normalize_overlap_wh( + overlap_wh: int | tuple[int, int], + ) -> tuple[int, int]: + if isinstance(overlap_wh, int): + if overlap_wh < 0: + raise ValueError( + "`overlap_wh` must be a non negative integer. " + f"Received: {overlap_wh}" + ) + return overlap_wh, overlap_wh + + if isinstance(overlap_wh, tuple) and len(overlap_wh) == 2: + overlap_w, overlap_h = overlap_wh + if overlap_w < 0 or overlap_h < 0: + raise ValueError( + f"`overlap_wh` values must be non negative. Received: {overlap_wh}" + ) + return overlap_w, overlap_h + + raise ValueError( + "`overlap_wh` must be an int or a tuple of two non negative integers " + "(overlap_w, overlap_h). " + f"Received: {overlap_wh}" + ) + + @staticmethod + def _generate_offset( + resolution_wh: tuple[int, int], + slice_wh: tuple[int, int], + overlap_wh: tuple[int, int], + ) -> npt.NDArray[Any]: + """ + Generate bounding boxes defining the coordinates of image slices with overlap. + + Args: + resolution_wh: Image resolution `(width, height)`. + slice_wh: Size of each slice `(width, height)`. + overlap_wh: Overlap size between slices `(width, height)`. + + Returns: + Array of shape `(num_slices, 4)` with each row as + `(x_min, y_min, x_max, y_max)` coordinates for a slice. + """ + slice_width, slice_height = slice_wh + image_width, image_height = resolution_wh + overlap_width, overlap_height = overlap_wh + + stride_x = slice_width - overlap_width + stride_y = slice_height - overlap_height + + def _compute_axis_starts( + image_size: int, + slice_size: int, + stride: int, + ) -> list[int]: + if image_size <= slice_size: + return [0] + + if stride == slice_size: + return list(np.arange(0, image_size, stride).tolist()) + + last_start = image_size - slice_size + starts: list[int] = list(np.arange(0, last_start, stride).tolist()) + if not starts or starts[-1] != last_start: + starts.append(last_start) + return starts + + x_starts = _compute_axis_starts( + image_size=image_width, + slice_size=slice_width, + stride=stride_x, + ) + y_starts = _compute_axis_starts( + image_size=image_height, + slice_size=slice_height, + stride=stride_y, + ) + + x_min, y_min = np.meshgrid(x_starts, y_starts) + x_max = np.clip(x_min + slice_width, 0, image_width) + y_max = np.clip(y_min + slice_height, 0, image_height) + + offsets: npt.NDArray[Any] = np.stack( + [x_min, y_min, x_max, y_max], + axis=-1, + ).reshape(-1, 4) + + return offsets + + @staticmethod + def _validate_overlap( + slice_wh: tuple[int, int], + overlap_wh: tuple[int, int], + ) -> None: + overlap_w, overlap_h = overlap_wh + slice_w, slice_h = slice_wh + + if overlap_w < 0 or overlap_h < 0: + raise ValueError( + "Overlap values must be greater than or equal to 0. " + f"Received: {overlap_wh}" + ) + + if overlap_w >= slice_w or overlap_h >= slice_h: + raise ValueError( + "`overlap_wh` must be smaller than `slice_wh` in both dimensions " + f"to keep a positive stride. Received overlap_wh={overlap_wh}, " + f"slice_wh={slice_wh}." + ) diff --git a/src/supervision/detection/tools/json_sink.py b/src/supervision/detection/tools/json_sink.py new file mode 100644 index 0000000..b6ddbbc --- /dev/null +++ b/src/supervision/detection/tools/json_sink.py @@ -0,0 +1,215 @@ +from __future__ import annotations + +import io +import json +import os +from typing import Any + +import numpy as np + +from supervision.detection.core import Detections + + +class JSONSink: + """ + A utility class for saving detection data to a JSON file. This class is designed to + efficiently serialize detection objects into a JSON format, allowing for the + inclusion of bounding box coordinates and additional attributes like `confidence`, + `class_id`, and `tracker_id`. + + !!! tip + + JSONSink allows passing custom data alongside detection fields, providing + flexibility for logging various types of information. + When a NumPy array, list, or tuple value in custom_data (or + detections.data) has the same length as the detection count, each + element is written to the corresponding detection row; any other value + is broadcast to all rows. + NumPy scalars (e.g. ``np.int64``, ``np.float32``) are serialized as + JSON numbers; NumPy arrays are serialized as JSON arrays. + + Args: + file_name: The name of the JSON file where the detections will be stored. + Defaults to 'output.json'. + + Example: + ```python + import supervision as sv + from ultralytics import YOLO + + model = YOLO("") + json_sink = sv.JSONSink() + frames_generator = sv.get_video_frames_generator("") + + with json_sink as sink: + for frame in frames_generator: + result = model(frame)[0] + detections = sv.Detections.from_ultralytics(result) + sink.append(detections, custom_data={"":""}) + ``` + """ + + def __init__(self, file_name: str = "output.json") -> None: + """ + Initialize the JSONSink instance. + + Args: + file_name: The name of the JSON file. + """ + self.file_name = file_name + self.file: io.TextIOWrapper | None = None + self.data: list[dict[str, Any]] = [] + + def __enter__(self) -> JSONSink: + self.open() + return self + + def __exit__( + self, + exc_type: type | None, + exc_val: Exception | None, + exc_tb: Any | None, + ) -> None: + self.write_and_close() + + def open(self) -> None: + """ + Open the JSON file for writing. + """ + parent_directory = os.path.dirname(self.file_name) + if parent_directory and not os.path.exists(parent_directory): + os.makedirs(parent_directory) + + self.file = open(self.file_name, "w") + + @staticmethod + def _json_default(value: Any) -> Any: + """Return a JSON-serializable equivalent of a NumPy scalar or array. + + Called as the ``default`` hook by :func:`json.dump`. Converts + :class:`numpy.generic` scalars via ``.item()`` and + :class:`numpy.ndarray` instances via ``.tolist()``. + + Args: + value: Object the standard JSON encoder could not serialize. + + Returns: + A Python scalar or nested list equivalent of ``value``. + + Raises: + TypeError: If ``value`` is neither a NumPy scalar nor an ndarray. + """ + if isinstance(value, np.generic): + return value.item() + if isinstance(value, np.ndarray): + return value.tolist() + raise TypeError( + f"Object of type {type(value).__name__} is not JSON serializable" + ) + + def write_and_close(self) -> None: + """ + Write and close the JSON file. + """ + if self.file: + try: + json.dump( + self.data, self.file, indent=4, default=JSONSink._json_default + ) + finally: + self.file.close() + + @staticmethod + def _slice_value(value: Any, i: int, n: int) -> Any: + """ + Return the i-th element when the value stores per-detection data. + + Dispatch rules: + - np.ndarray with ndim == 0: return as-is for broadcasting + - np.ndarray with len equal to n: return value[i] + - list or tuple with len equal to n: return value[i] + - any other type: return as-is for broadcasting + + Args: + value: Custom-data field value. + i: Zero-based detection index. + n: Total number of detections. + + Returns: + Element at position i if value is a per-detection sequence, + otherwise value unchanged. + """ + if isinstance(value, np.ndarray): + return value[i] if value.ndim > 0 and len(value) == n else value + if isinstance(value, (list, tuple)) and len(value) == n: + return value[i] + return value + + @staticmethod + def parse_detection_data( + detections: Detections, custom_data: dict[str, Any] | None = None + ) -> list[dict[str, Any]]: + """ + Convert detections and optional custom data into per-detection rows. + + Builds one dictionary per detection containing bounding box coordinates, + detection attributes, and any values from ``detections.data`` or + ``custom_data``. NumPy array, list, and tuple values in + ``custom_data`` with length equal to ``len(detections.xyxy)`` are + sliced one element per row; all other values are broadcast to every row. + + Args: + detections: Detection data to serialize into row dictionaries. + custom_data: Optional extra fields to include in each row. + + Returns: + A list of dictionaries, one per detection, containing ``xyxy`` + coordinates, ``class_id``, ``confidence``, ``tracker_id``, and any + values from ``detections.data`` or ``custom_data``. + """ + parsed_rows = [] + n = len(detections.xyxy) + for i in range(n): + row = { + "x_min": float(detections.xyxy[i][0]), + "y_min": float(detections.xyxy[i][1]), + "x_max": float(detections.xyxy[i][2]), + "y_max": float(detections.xyxy[i][3]), + "class_id": "" + if detections.class_id is None + else int(detections.class_id[i]), + "confidence": "" + if detections.confidence is None + else float(detections.confidence[i]), + "tracker_id": "" + if detections.tracker_id is None + else int(detections.tracker_id[i]), + } + + if hasattr(detections, "data"): + for key, value in detections.data.items(): + row[key] = JSONSink._slice_value(value, i, n) + + if custom_data: + for key, value in custom_data.items(): + row[key] = JSONSink._slice_value(value, i, n) + + parsed_rows.append(row) + return parsed_rows + + def append( + self, detections: Detections, custom_data: dict[str, Any] | None = None + ) -> None: + """ + Append detection data to the JSON file. + + Args: + detections: The detection data. + custom_data: Custom data to include. Scalars, dictionaries, and + other non-sequence values are broadcast to every detection in + this batch. NumPy arrays, lists, and tuples with length equal + to ``len(detections)`` are sliced per detection; other lists + and tuples are broadcast unchanged. + """ + parsed_rows = JSONSink.parse_detection_data(detections, custom_data) + self.data.extend(parsed_rows) diff --git a/src/supervision/detection/tools/polygon_zone.py b/src/supervision/detection/tools/polygon_zone.py new file mode 100644 index 0000000..561472a --- /dev/null +++ b/src/supervision/detection/tools/polygon_zone.py @@ -0,0 +1,215 @@ +from collections.abc import Iterable +from typing import Any, cast + +import cv2 +import numpy as np +import numpy.typing as npt + +from supervision import Detections +from supervision.detection.utils.converters import polygon_to_mask +from supervision.draw.color import Color +from supervision.draw.utils import draw_filled_polygon, draw_polygon, draw_text +from supervision.geometry.core import Position +from supervision.geometry.utils import get_polygon_center + + +class PolygonZone: + """ + A class for defining a polygon-shaped zone within a frame for detecting objects. + + !!! warning + + PolygonZone uses the `tracker_id`. Read + [here](/latest/trackers/) to learn how to plug + tracking into your inference pipeline. + + Attributes: + polygon: A polygon represented by a numpy array of shape + `(N, 2)`, containing the `x`, `y` coordinates of the points. + triggering_anchors: A list of positions specifying + which anchors of the detections bounding box to consider when deciding on + whether the detection fits within the PolygonZone + (default: (sv.Position.BOTTOM_CENTER,)). + current_count: The current count of detected objects within the zone + mask: The 2D bool mask for the polygon zone + + Example: + ```pycon + >>> import numpy as np + >>> import supervision as sv + >>> polygon = np.array([[100, 200], [200, 100], [300, 200], [200, 300]]) + >>> polygon_zone = sv.PolygonZone(polygon=polygon) + >>> detections = sv.Detections( + ... xyxy=np.array([[180, 100, 220, 200], [400, 400, 450, 500]]) + ... ) + >>> is_detections_in_zone = polygon_zone.trigger(detections) + >>> is_detections_in_zone + array([ True, False]) + >>> polygon_zone.current_count + 1 + + ``` + """ + + def __init__( + self, + polygon: npt.NDArray[np.int64], + triggering_anchors: Iterable[Position] = (Position.BOTTOM_CENTER,), + ) -> None: + self.polygon = polygon.astype(int) + self.triggering_anchors = triggering_anchors + if not list(self.triggering_anchors): + raise ValueError("Triggering anchors cannot be empty.") + + self.current_count = 0 + + x_max, y_max = np.max(polygon, axis=0) + self.mask = polygon_to_mask( + polygon=polygon, resolution_wh=(x_max + 2, y_max + 2) + ) + + def trigger(self, detections: Detections) -> npt.NDArray[np.bool_]: + """ + Determines if the detections are within the polygon zone. + + Anchor points are calculated from original (unclipped) detection boxes to + avoid per-zone clipping shifting anchor positions. This prevents a single + detection from being counted in multiple non-overlapping zones due to + clipping artifacts, although overlapping zones may still legitimately + contain the same detection. + + Args: + detections: The detections to be checked against the polygon zone + + Returns: + A boolean numpy array indicating + if each detection is within the polygon zone + """ + if len(detections) == 0: + self.current_count = 0 + return cast(npt.NDArray[np.bool_], np.array([], dtype=bool)) + + all_anchors = np.array( + [ + np.rint(detections.get_anchors_coordinates(anchors)).astype(int) + for anchors in self.triggering_anchors + ] + ) + + mask_h, mask_w = self.mask.shape + x, y = all_anchors[:, :, 0], all_anchors[:, :, 1] + in_bounds = (x >= 0) & (y >= 0) & (x < mask_w) & (y < mask_h) + x_safe = np.clip(x, 0, mask_w - 1) + y_safe = np.clip(y, 0, mask_h - 1) + is_in_zone = np.all(in_bounds & self.mask[y_safe, x_safe], axis=0) + self.current_count = int(np.sum(is_in_zone)) + return cast(npt.NDArray[np.bool_], is_in_zone.astype(bool)) + + +class PolygonZoneAnnotator: + """ + A class for annotating a polygon-shaped zone within a frame with a count of + detected objects. + + Attributes: + zone: The polygon zone to be annotated + color: The color to draw the polygon lines, default is white + thickness: The thickness of the polygon lines, default is 2 + text_color: The color of the text on the polygon, default is black + text_scale: The scale of the text on the polygon, default is 0.5 + text_thickness: The thickness of the text on the polygon, default is 1 + text_padding: The padding around the text on the polygon, default is 10 + font: The font type for the text on the polygon, + default is cv2.FONT_HERSHEY_SIMPLEX + center: The center of the polygon for text placement + display_in_zone_count: Show the label of the zone or not. Default is True + opacity: The opacity of zone filling when drawn on the scene. Default is 0 + + Example: + ```pycon + >>> import numpy as np + >>> import supervision as sv + >>> polygon = np.array([[100, 200], [200, 100], [300, 200], [200, 300]]) + >>> polygon_zone = sv.PolygonZone(polygon=polygon) + >>> zone_annotator = sv.PolygonZoneAnnotator(zone=polygon_zone, thickness=2) + >>> scene = np.zeros((400, 400, 3), dtype=np.uint8) + >>> annotated_scene = zone_annotator.annotate(scene=scene) + >>> annotated_scene.shape + (400, 400, 3) + + ``` + """ + + def __init__( + self, + zone: PolygonZone, + color: Color = Color.WHITE, + thickness: int = 2, + text_color: Color = Color.BLACK, + text_scale: float = 0.5, + text_thickness: int = 1, + text_padding: int = 10, + display_in_zone_count: bool = True, + opacity: float = 0, + ) -> None: + self.zone = zone + self.color = color + self.thickness = thickness + self.text_color = text_color + self.text_scale = text_scale + self.text_thickness = text_thickness + self.text_padding = text_padding + self.font = cv2.FONT_HERSHEY_SIMPLEX + self.center = get_polygon_center(polygon=zone.polygon) + self.display_in_zone_count = display_in_zone_count + self.opacity = opacity + + def annotate( + self, scene: npt.NDArray[Any], label: str | None = None + ) -> npt.NDArray[Any]: + """ + Annotates the polygon zone within a frame with a count of detected objects. + + Args: + scene: The image on which the polygon zone will be annotated + label: A label for the count of detected objects + within the polygon zone (default: None) + + Returns: + The image with the polygon zone and count of detected objects + """ + if self.opacity == 0: + annotated_frame = draw_polygon( + scene=scene, + polygon=self.zone.polygon, + color=self.color, + thickness=self.thickness, + ) + else: + annotated_frame = draw_filled_polygon( + scene=scene.copy(), + polygon=self.zone.polygon, + color=self.color, + opacity=self.opacity, + ) + annotated_frame = draw_polygon( + scene=annotated_frame, + polygon=self.zone.polygon, + color=self.color, + thickness=self.thickness, + ) + + if self.display_in_zone_count: + annotated_frame = draw_text( + scene=annotated_frame, + text=str(self.zone.current_count) if label is None else label, + text_anchor=self.center, + background_color=self.color, + text_color=self.text_color, + text_scale=self.text_scale, + text_thickness=self.text_thickness, + text_padding=self.text_padding, + text_font=self.font, + ) + + return cast(npt.NDArray[Any], annotated_frame) diff --git a/src/supervision/detection/tools/smoother.py b/src/supervision/detection/tools/smoother.py new file mode 100644 index 0000000..84569fa --- /dev/null +++ b/src/supervision/detection/tools/smoother.py @@ -0,0 +1,218 @@ +import warnings +from collections import defaultdict, deque +from copy import deepcopy + +import numpy as np + +from supervision.detection.core import Detections +from supervision.utils.internal import SupervisionWarnings + + +class DetectionsSmoother: + """ + A utility class for smoothing detections over multiple frames in video tracking. + It maintains a history of detections for each track and provides smoothed + predictions based on these histories. + + + + !!! warning + + - `DetectionsSmoother` requires the `tracker_id` for each detection. Refer to + [Roboflow Trackers](/latest/trackers/) for + information on integrating tracking into your inference pipeline. + - This class is not compatible with segmentation models. + - When detections in a frame disagree on confidence presence โ€” some tracks + carry confidence scores and others do not โ€” `confidence` is set to `None` + for all smoothed detections in that frame. + + Example: + ```pycon + >>> import numpy as np + >>> import supervision as sv + >>> smoother = sv.DetectionsSmoother(length=3) + >>> detections_1 = sv.Detections( + ... xyxy=np.array([[0, 0, 10, 10]]), + ... confidence=np.array([0.5]), + ... tracker_id=np.array([1]) + ... ) + >>> detections_2 = sv.Detections( + ... xyxy=np.array([[2, 2, 12, 12]]), + ... confidence=np.array([0.7]), + ... tracker_id=np.array([1]) + ... ) + >>> smoothed = smoother.update_with_detections(detections_1) + >>> smoothed.xyxy + array([[ 0., 0., 10., 10.]]) + >>> smoothed = smoother.update_with_detections(detections_2) + >>> smoothed.xyxy + array([[ 1., 1., 11., 11.]]) + >>> smoothed.confidence + array([0.6]) + + ``` + + + ```python + import supervision as sv + + from ultralytics import YOLO + + video_info = sv.VideoInfo.from_video_path(video_path="") + frame_generator = sv.get_video_frames_generator( + source_path="") + + model = YOLO("") + tracker = sv.ByteTrack(frame_rate=video_info.fps) + smoother = sv.DetectionsSmoother() + + box_annotator = sv.BoxAnnotator() + + with sv.VideoSink("", video_info=video_info) as sink: + for frame in frame_generator: + result = model(frame)[0] + detections = sv.Detections.from_ultralytics(result) + detections = tracker.update_with_detections(detections) + detections = smoother.update_with_detections(detections) + + annotated_frame = box_annotator.annotate(frame.copy(), detections) + sink.write_frame(annotated_frame) + ``` + """ + + def __init__(self, length: int = 5) -> None: + """ + Args: + length: The maximum number of frames to consider for smoothing + detections. Defaults to 5. + """ + self.tracks: defaultdict[int, deque[Detections | None]] = defaultdict( + lambda: deque(maxlen=length) + ) + + def reset(self) -> None: + """ + Clears the per-track detection history so the smoother can be reused + across independent streams without carrying over frames from a + previous stream. The configured window `length` is preserved. + + Examples: + ```pycon + >>> import numpy as np + >>> import supervision as sv + >>> smoother = sv.DetectionsSmoother() + >>> detections = sv.Detections( + ... xyxy=np.array([[0, 0, 10, 10]]), + ... confidence=np.array([0.5]), + ... tracker_id=np.array([1]) + ... ) + >>> _ = smoother.update_with_detections(detections) + >>> len(smoother.tracks) + 1 + >>> smoother.reset() + >>> len(smoother.tracks) + 0 + + ``` + """ + self.tracks.clear() + + def update_with_detections(self, detections: Detections) -> Detections: + """ + Updates the smoother with a new set of detections from a frame. + + Args: + detections: The detections to add to the smoother. + """ + + if detections.tracker_id is None: + warnings.warn( + "Smoothing skipped. DetectionsSmoother requires tracker_id. Refer to " + "https://supervision.roboflow.com/latest/trackers for more " + "information.", + category=SupervisionWarnings, + ) + return detections + + for detection_idx in range(len(detections)): + tracker_id_value = detections.tracker_id[detection_idx] + tracker_id = int(tracker_id_value) + + self.tracks[tracker_id].append(detections.select(detection_idx)) + + for track_id in self.tracks.keys(): + if track_id not in detections.tracker_id: + self.tracks[track_id].append(None) + + for track_id in list(self.tracks.keys()): + if all([d is None for d in self.tracks[track_id]]): + del self.tracks[track_id] + + current_track_ids = {int(track_id) for track_id in detections.tracker_id} + return self.get_smoothed_detections(track_ids=current_track_ids) + + def get_track(self, track_id: int) -> Detections | None: + """Return the smoothed `Detections` for a single track. + + Averages `xyxy` over all valid (non-`None`) frames in the track window. + `confidence` is averaged only over frames that carry it; frames with + `confidence=None` are excluded. Returns `None` when the track is unknown + or its entire window is empty. + + Args: + track_id: The tracker ID whose smoothed detection to retrieve. + + Returns: + Smoothed `Detections` for the track, or `None` if the track is + unknown or all frames in its window are empty. + """ + track = self.tracks.get(track_id, None) + if track is None: + return None + + valid: list[Detections] = [d for d in track if d is not None] + if len(valid) == 0: + return None + + ret = deepcopy(valid[0]) + ret.xyxy = np.mean(np.stack([d.xyxy for d in valid], axis=0), axis=0) + # Average confidence only over frames that carry it; frames with + # confidence=None contribute nothing to the mean. Retain None when + # no frame in the window carries confidence. + confidences = [d.confidence for d in valid if d.confidence is not None] + ret.confidence = np.mean(np.array(confidences), axis=0) if confidences else None + + return ret + + def get_smoothed_detections(self, track_ids: set[int] | None = None) -> Detections: + """Return the smoothed detections for the requested active tracks. + + Args: + track_ids: Optional set of track IDs to include in the output. When + provided, tracks absent from the current frame are excluded from the + emitted detections but their history stays cached. + """ + tracked_detections = [] + for track_id in self.tracks: + if track_ids is not None and track_id not in track_ids: + continue + track = self.get_track(track_id) + if track is not None: + tracked_detections.append(track) + + # Detections.merge requires all-or-none for optional fields. + # When tracks disagree on confidence presence, drop it from all to + # prevent ValueError inside Detections.merge (stack_or_none invariant). + if tracked_detections and any(d.confidence is None for d in tracked_detections): + for d in tracked_detections: + d.confidence = None + + detections = Detections.merge(tracked_detections) + if len(detections) == 0: + detections.tracker_id = np.array([], dtype=int) + + return detections diff --git a/src/supervision/detection/tools/transformers.py b/src/supervision/detection/tools/transformers.py new file mode 100644 index 0000000..440caa2 --- /dev/null +++ b/src/supervision/detection/tools/transformers.py @@ -0,0 +1,265 @@ +from __future__ import annotations + +import io +from typing import Any, cast + +import numpy as np +import numpy.typing as npt +from PIL import Image + +from supervision.config import CLASS_NAME_DATA_FIELD +from supervision.detection.utils.converters import mask_to_xyxy + + +def process_transformers_detection_result( + detection_result: dict[str, Any], id2label: dict[int, str] | None +) -> dict[str, Any]: + """ + Process the result of Transformers object detection functions such as + `post_process` (v4) and `post_process_detection` (v5). + + Args: + detection_result: Dictionary containing detection results with keys + 'boxes', 'labels', and 'scores'. + id2label: A dictionary mapping class IDs to labels, + typically part of the `transformers` model configuration. If provided, the + resulting dictionary will include class names. + + Returns: + Processed detection result including bounding boxes, confidence scores, + class IDs, and data. + """ + class_ids = detection_result["labels"].cpu().detach().numpy().astype(int) + data = append_class_names_to_data(class_ids, id2label, {}) + + return dict( + xyxy=detection_result["boxes"].cpu().detach().numpy(), + confidence=detection_result["scores"].cpu().detach().numpy(), + class_id=class_ids, + data=data, + ) + + +def process_transformers_v4_segmentation_result( + segmentation_result: dict[str, Any], id2label: dict[int, str] | None +) -> dict[str, Any]: + """ + Process the result of Transformers segmentation functions such as + `post_process_panoptic`, `post_process_segmentation`, and `post_process_instance` + (v4). + + Args: + segmentation_result: Dictionary containing segmentation results with keys + 'masks', 'labels', and 'scores'. + id2label: A dictionary mapping class IDs to labels, + typically part of the `transformers` model configuration. If provided, the + resulting dictionary will include class names. + + Returns: + Processed segmentation result including bounding boxes, masks, confidence + scores, class IDs, and data. + """ + if "png_string" in segmentation_result: + return process_transformers_v4_panoptic_segmentation_result( + segmentation_result, id2label + ) + else: + boxes = None + if "boxes" in segmentation_result: + boxes = segmentation_result["boxes"].cpu().detach().numpy() + masks = segmentation_result["masks"].cpu().detach().numpy().astype(bool) + class_ids = segmentation_result["labels"].cpu().detach().numpy().astype(int) + + return dict( + xyxy=boxes if boxes is not None else mask_to_xyxy(masks), + mask=np.squeeze(masks, axis=1) if boxes is not None else masks, + confidence=segmentation_result["scores"].cpu().detach().numpy(), + class_id=class_ids, + data=append_class_names_to_data(class_ids, id2label, {}), + ) + + +def process_transformers_v5_segmentation_result( + segmentation_result: Any, id2label: dict[int, str] | None +) -> dict[str, Any]: + """ + Process the result of Transformers segmentation functions such as + `post_process_semantic_segmentation`, `post_process_instance_segmentation`, and + `post_process_panoptic_segmentation` (v5). + + Args: + segmentation_result: Either a dictionary containing segmentation results + (`segments_info` and `segmentation`) or a tensor object + representing a semantic segmentation map. + id2label: A dictionary mapping class IDs to labels, + typically part of the `transformers` model configuration. If provided, the + resulting dictionary will include class names. + + Returns: + Processed segmentation result including bounding boxes, masks, confidence + scores, class IDs, and data. + """ + if segmentation_result.__class__.__name__ == "Tensor": + segmentation_array = segmentation_result.cpu().detach().numpy() + return process_transformers_v5_panoptic_segmentation_result( + segmentation_array, id2label + ) + return process_transformers_v5_semantic_or_instance_segmentation_result( + cast(dict[str, Any], segmentation_result), id2label + ) + + +def process_transformers_v5_semantic_or_instance_segmentation_result( + segmentation_result: dict[str, Any], id2label: dict[int, str] | None +) -> dict[str, Any]: + """ + Process the result of Transformers segmentation functions such as + `post_process_semantic_segmentation` and `post_process_instance_segmentation` (v5). + + Args: + segmentation_result: Dictionary containing segmentation results with keys + `segments_info` and `segmentation`. + id2label: A dictionary mapping class IDs to labels, + typically part of the `transformers` model configuration. If provided, the + resulting dictionary will include class names. + + Returns: + Processed segmentation result including bounding boxes, masks, confidence + scores, class IDs, and data. + """ + segments_info = segmentation_result["segments_info"] + segmentation_array = segmentation_result["segmentation"].cpu().detach().numpy() + scores = np.array([segment["score"] for segment in segments_info], dtype=float) + class_ids = np.array([segment["label_id"] for segment in segments_info], dtype=int) + if len(segments_info) == 0: + masks = np.empty((0, *segmentation_array.shape), dtype=bool) + else: + masks = np.array( + [segmentation_array == segment["id"] for segment in segments_info] + ).astype(bool) + data = append_class_names_to_data(class_ids, id2label, {}) + + return dict( + xyxy=mask_to_xyxy(masks), + mask=masks, + confidence=scores, + class_id=class_ids, + data=data, + ) + + +def process_transformers_v4_panoptic_segmentation_result( + segmentation_result: dict[str, Any], id2label: dict[int, str] | None +) -> dict[str, Any]: + """ + Process the result of the Transformers function `post_process_panoptic` (v4). + + Args: + segmentation_result: Dictionary containing segmentation results with keys + such as 'png_string' and 'segments_info'. + id2label: A dictionary mapping class IDs to labels, + typically part of the `transformers` model configuration. If provided, the + resulting dictionary will include class names. + + Returns: + Processed segmentation result including bounding boxes, masks, + class IDs, and data. + """ + segments_info = segmentation_result["segments_info"] + png_string = segmentation_result["png_string"] + class_ids = np.array([segment["category_id"] for segment in segments_info]) + segmentation_array = png_string_to_segmentation_array(png_string=png_string) + masks = np.array( + [segmentation_array == segment["id"] for segment in segments_info] + ).astype(bool) + data = append_class_names_to_data(class_ids, id2label, {}) + + return dict( + xyxy=mask_to_xyxy(masks), + mask=masks, + class_id=class_ids, + data=data, + ) + + +def process_transformers_v5_panoptic_segmentation_result( + segmentation_array: npt.NDArray[Any], id2label: dict[int, str] | None +) -> dict[str, Any]: + """ + Process a v5 Transformers semantic segmentation tensor. + + Args: + segmentation_array: Segmentation array where unique values are class IDs. + id2label: A dictionary mapping class IDs to labels, + typically part of the `transformers` model configuration. If provided, the + resulting dictionary will include class names. + + Returns: + Processed segmentation result including bounding boxes, masks, + class IDs, and data. + """ + class_ids = np.unique(segmentation_array).astype(int) + if len(class_ids) == 0: + masks = np.empty((0, *segmentation_array.shape), dtype=bool) + else: + masks = np.stack( + [segmentation_array == class_id for class_id in class_ids], axis=0 + ).astype(bool) + data = append_class_names_to_data(class_ids, id2label, {}) + return dict(xyxy=mask_to_xyxy(masks), mask=masks, class_id=class_ids, data=data) + + +def png_string_to_segmentation_array(png_string: bytes) -> npt.NDArray[Any]: + """ + Convert a PNG byte string to a panoptic segmentation array. + + Args: + png_string: A byte string representing the PNG image. + + Returns: + A segmentation ID array with shape (H, W), where each unique value + represents a different object or category. RGB-encoded panoptic + PNGs are decoded as little-endian 24-bit integers; alpha is ignored. + """ + image = Image.open(io.BytesIO(png_string)) + mask = np.array(image, dtype=np.uint8) + if mask.ndim == 2: + return mask.astype(np.uint32) + if mask.shape[2] < 3: + raise ValueError("Panoptic PNG masks must have at least 3 channels.") + + segmentation = ( + mask[:, :, 0].astype(np.uint32) + + (mask[:, :, 1].astype(np.uint32) << 8) + + (mask[:, :, 2].astype(np.uint32) << 16) + ) + return cast(npt.NDArray[Any], segmentation) + + +def append_class_names_to_data( + class_ids: npt.NDArray[Any], + id2label: dict[int, str] | None, + data: dict[str, Any] | None = None, +) -> dict[str, Any]: + """ + Helper function to create or append to a data dictionary with class names if + available. + + Args: + class_ids: Array of class IDs. + id2label: A dictionary mapping class IDs to labels, + typically part of the `transformers` model configuration. If provided, the + resulting dictionary will include class names. + data: An existing data dictionary to append to. + + Returns: + Dictionary containing class names if id2label is provided. + """ + if data is None: + data = {} + + if id2label is not None: + class_names = np.array([id2label[class_id] for class_id in class_ids]) + data[CLASS_NAME_DATA_FIELD] = class_names + + return data diff --git a/src/supervision/detection/utils/__init__.py b/src/supervision/detection/utils/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/src/supervision/detection/utils/_typing.py b/src/supervision/detection/utils/_typing.py new file mode 100644 index 0000000..7b903ab --- /dev/null +++ b/src/supervision/detection/utils/_typing.py @@ -0,0 +1,8 @@ +from typing import Any, TypeAlias + +import numpy as np +import numpy.typing as npt + +_DetectionDataValueType: TypeAlias = npt.NDArray[np.generic] | list[Any] +_DetectionDataType: TypeAlias = dict[str, _DetectionDataValueType] +_MetadataType: TypeAlias = dict[str, Any] diff --git a/src/supervision/detection/utils/boxes.py b/src/supervision/detection/utils/boxes.py new file mode 100644 index 0000000..767fce5 --- /dev/null +++ b/src/supervision/detection/utils/boxes.py @@ -0,0 +1,510 @@ +from typing import Any, cast + +import numpy as np +import numpy.typing as npt +from deprecate import ( # type: ignore[import-untyped,unused-ignore] + TargetMode, + deprecated, +) + +from supervision.detection.utils.iou_and_nms import box_iou_batch +from supervision.geometry.core import Position + + +def clip_boxes( + xyxy: npt.NDArray[np.number], + resolution_wh: tuple[int, int], +) -> npt.NDArray[np.number]: + """ + Clips bounding boxes coordinates to fit within the frame resolution. + + Args: + xyxy: A numpy array of shape `(N, 4)` where each + row corresponds to a bounding box in + the format `(x_min, y_min, x_max, y_max)`. + resolution_wh: A tuple of the form + `(width, height)` representing the resolution of the frame. + + Returns: + A numpy array of shape `(N, 4)` where each row + corresponds to a bounding box with coordinates clipped to fit + within the frame resolution. + + Examples: + ```pycon + >>> import numpy as np + >>> import supervision as sv + >>> xyxy = np.array([ + ... [10, 20, 300, 200], + ... [15, 25, 350, 450], + ... [-10, -20, 30, 40] + ... ]) + >>> sv.clip_boxes(xyxy=xyxy, resolution_wh=(320, 240)) + array([[ 10, 20, 300, 200], + [ 15, 25, 320, 240], + [ 0, 0, 30, 40]]) + + ``` + """ + result: npt.NDArray[np.number] = np.copy(xyxy) + width, height = resolution_wh + result[:, [0, 2]] = result[:, [0, 2]].clip(0, width) + result[:, [1, 3]] = result[:, [1, 3]].clip(0, height) + return result + + +def pad_boxes( + xyxy: npt.NDArray[np.number], + px: int, + py: int | None = None, +) -> npt.NDArray[np.number]: + """ + Pads bounding boxes coordinates with a constant padding. + + Args: + xyxy: A numpy array of shape `(N, 4)` where each + row corresponds to a bounding box in the format + `(x_min, y_min, x_max, y_max)`. + px: The padding value to be added to both the left and right sides of + each bounding box. + py: The padding value to be added to both the top and bottom + sides of each bounding box. If not provided, `px` will be used for both + dimensions. + + Returns: + A numpy array of shape `(N, 4)` where each row corresponds to a + bounding box with coordinates padded according to the provided padding + values. + + Examples: + ```pycon + >>> import numpy as np + >>> import supervision as sv + >>> xyxy = np.array([ + ... [10, 20, 30, 40], + ... [15, 25, 35, 45] + ... ]) + >>> sv.pad_boxes(xyxy=xyxy, px=5, py=10) + array([[ 5, 10, 35, 50], + [10, 15, 40, 55]]) + + ``` + """ + if py is None: + py = px + + result = cast(npt.NDArray[Any], xyxy.copy()) + result[:, [0, 1]] -= [px, py] + result[:, [2, 3]] += [px, py] + + return cast(npt.NDArray[np.number], result) + + +@deprecated( # type: ignore[untyped-decorator] + target=TargetMode.ARGS_REMAP, + deprecated_in="0.27.0", + remove_in="0.31.0", + args_mapping={"normalized_xyxy": "xyxy"}, +) +def denormalize_boxes( + xyxy: npt.NDArray[np.number], + resolution_wh: tuple[int, int], + normalization_factor: float = 1.0, + normalized_xyxy: npt.NDArray[np.number] | None = None, +) -> npt.NDArray[np.number]: + """ + Convert normalized bounding box coordinates to absolute pixel coordinates. + + Multiplies each bounding box coordinate by image size and divides by + `normalization_factor`, mapping values from normalized `[0, normalization_factor]` + to absolute pixel values for a given resolution. + + Args: + xyxy: Normalized bounding boxes of shape `(N, 4)`, + where each row is `(x_min, y_min, x_max, y_max)`, values in + `[0, normalization_factor]`. + resolution_wh: Target image resolution as `(width, height)`. + normalization_factor: Maximum value of input coordinate range. + Defaults to `1.0`. + + Returns: + Array of shape `(N, 4)` with absolute coordinates in + `(x_min, y_min, x_max, y_max)` format. + + Examples: + ```pycon + >>> import numpy as np + >>> import supervision as sv + >>> xyxy = np.array([ + ... [0.1, 0.2, 0.5, 0.6], + ... [0.3, 0.4, 0.7, 0.8], + ... [0.2, 0.1, 0.6, 0.5] + ... ]) + >>> sv.denormalize_boxes(xyxy, (1280, 720)) + array([[128., 144., 640., 432.], + [384., 288., 896., 576.], + [256., 72., 768., 360.]]) + + ``` + + ```pycon + >>> xyxy = np.array([ + ... [256., 128., 768., 640.] + ... ]) + >>> sv.denormalize_boxes(xyxy, (1280, 720), normalization_factor=1024.0) + array([[320., 90., 960., 450.]]) + + ``` + """ + width, height = resolution_wh + result = cast(npt.NDArray[Any], xyxy.copy()) + + result[:, [0, 2]] = (result[:, [0, 2]] * width) / normalization_factor + result[:, [1, 3]] = (result[:, [1, 3]] * height) / normalization_factor + + return cast(npt.NDArray[np.number], result) + + +def move_boxes( + xyxy: npt.NDArray[np.number], offset: npt.NDArray[np.integer] +) -> npt.NDArray[np.number]: + """ + Args: + xyxy: An array of shape `(n, 4)` containing the + bounding boxes coordinates in format `[x1, y1, x2, y2]` + offset: An array of shape `(2,)` containing offset values in format + is `[dx, dy]`. + + Returns: + Repositioned bounding boxes. + + Examples: + ```pycon + >>> import numpy as np + >>> import supervision as sv + >>> xyxy = np.array([ + ... [10, 10, 20, 20], + ... [30, 30, 40, 40] + ... ]) + >>> offset = np.array([5, 5]) + >>> sv.move_boxes(xyxy=xyxy, offset=offset) + array([[15, 15, 25, 25], + [35, 35, 45, 45]]) + + ``` + """ + return xyxy + np.hstack([offset, offset]) + + +def move_oriented_boxes( + xyxyxyxy: npt.NDArray[np.number], offset: npt.NDArray[np.integer] +) -> npt.NDArray[np.number]: + """ + Args: + xyxyxyxy: An array of shape `(n, 4, 2)` containing the + oriented bounding boxes coordinates in format + `[[x1, y1], [x2, y2], [x3, y3], [x3, y3]]` + offset: An array of shape `(2,)` containing offset values in format + is `[dx, dy]`. + + Returns: + Repositioned bounding boxes. + + Examples: + ```pycon + >>> import numpy as np + >>> from supervision.detection.utils.boxes import move_oriented_boxes + >>> xyxyxyxy = np.array([ + ... [ + ... [20, 10], + ... [10, 20], + ... [20, 30], + ... [30, 20] + ... ], + ... [ + ... [30, 30], + ... [20, 40], + ... [30, 50], + ... [40, 40] + ... ] + ... ]) + >>> offset = np.array([5, 5]) + >>> move_oriented_boxes(xyxyxyxy=xyxyxyxy, offset=offset) + array([[[25, 15], + [15, 25], + [25, 35], + [35, 25]], + + [[35, 35], + [25, 45], + [35, 55], + [45, 45]]]) + + ``` + """ + return xyxyxyxy + offset + + +def obb_polygon_area(corners: npt.NDArray[np.number]) -> npt.NDArray[np.float64]: + """Compute the area of N oriented bounding boxes using the shoelace formula. + + Args: + corners: OBB corner coordinates with shape `(N, 4, 2)`. + + Returns: + Area of each box as a 1-D float64 array of shape `(N,)`. + + Raises: + ValueError: If `corners` does not have shape `(N, 4, 2)`. + + Examples: + >>> import numpy as np + >>> from supervision.detection.utils.boxes import obb_polygon_area + >>> corners = np.array([[[0, 5], [5, 10], [10, 5], [5, 0]]], dtype=np.float32) + >>> obb_polygon_area(corners) + array([50.]) + """ + corners = cast(npt.NDArray[np.number], np.asarray(corners)) + if corners.ndim != 3 or corners.shape[-2:] != (4, 2): + raise ValueError(f"corners must have shape (N, 4, 2); got {corners.shape}") + x = corners[..., 0].astype(np.float64, copy=False) + y = corners[..., 1].astype(np.float64, copy=False) + cross = x * np.roll(y, -1, axis=-1) - y * np.roll(x, -1, axis=-1) + return cast(npt.NDArray[np.float64], 0.5 * np.abs(np.sum(cross, axis=-1))) + + +def xyxyxyxy_to_xyxy( + xyxyxyxy: npt.NDArray[np.number], +) -> npt.NDArray[np.number]: + """Convert oriented bounding box corners to axis-aligned bounding boxes. + + Args: + xyxyxyxy: OBB corner coordinates with shape `(N, 4, 2)` where each + box is represented as `[[x1, y1], [x2, y2], [x3, y3], [x4, y4]]`. + + Returns: + Axis-aligned bounding boxes as an array of shape `(N, 4)` + in `(x_min, y_min, x_max, y_max)` format. + + Raises: + ValueError: If `xyxyxyxy` does not have shape `(N, 4, 2)`. + + Examples: + ```pycon + >>> import numpy as np + >>> import supervision as sv + >>> corners = np.array([ + ... [[0, 0], [10, 0], [10, 5], [0, 5]], + ... [[5, 5], [15, 5], [15, 10], [5, 10]], + ... ], dtype=np.float32) + >>> sv.xyxyxyxy_to_xyxy(corners) + array([[ 0., 0., 10., 5.], + [ 5., 5., 15., 10.]], dtype=float32) + + ``` + """ + xyxyxyxy = cast(npt.NDArray[np.number], np.asarray(xyxyxyxy)) + if xyxyxyxy.ndim != 3 or xyxyxyxy.shape[-2:] != (4, 2): + raise ValueError(f"xyxyxyxy must have shape (N, 4, 2); got {xyxyxyxy.shape}") + x_min = xyxyxyxy[..., 0].min(axis=-1) + y_min = xyxyxyxy[..., 1].min(axis=-1) + x_max = xyxyxyxy[..., 0].max(axis=-1) + y_max = xyxyxyxy[..., 1].max(axis=-1) + return cast(npt.NDArray[np.number], np.stack([x_min, y_min, x_max, y_max], axis=-1)) + + +# Anchor position -> (sx, sy) offset from the box center, in units of the box +# half-width and half-height. Image coordinates, so +y points down. +_ANCHOR_OFFSETS: dict[Position, tuple[float, float]] = { + Position.CENTER: (0.0, 0.0), + Position.CENTER_LEFT: (-1.0, 0.0), + Position.CENTER_RIGHT: (1.0, 0.0), + Position.TOP_CENTER: (0.0, -1.0), + Position.BOTTOM_CENTER: (0.0, 1.0), + Position.TOP_LEFT: (-1.0, -1.0), + Position.TOP_RIGHT: (1.0, -1.0), + Position.BOTTOM_LEFT: (-1.0, 1.0), + Position.BOTTOM_RIGHT: (1.0, 1.0), +} + + +def _oriented_box_anchors( + xyxyxyxy: npt.NDArray[np.number], anchor: Position +) -> npt.NDArray[np.float64]: + """Locate an anchor point on each oriented bounding box. + + The returned point always lies on the oriented rectangle itself: corners map + to corners, side anchors to side midpoints, and `CENTER` to the box center. + For an axis-aligned box the result matches the anchor derived from the + envelope, so this is a drop-in replacement that stops the anchor from drifting + off a rotated body. + + Args: + xyxyxyxy: OBB corner coordinates with shape `(N, 4, 2)` in winding order, + each box as `[[x1, y1], [x2, y2], [x3, y3], [x4, y4]]`. + anchor: The anchor position to locate. `Position.CENTER_OF_MASS` is not + supported here, as it is defined on a mask rather than a box. + + Returns: + Anchor coordinates as an array of shape `(N, 2)`. + + Raises: + ValueError: If `xyxyxyxy` does not have shape `(N, 4, 2)`, or the anchor + is not supported. + + Note: + Corners must be in consecutive winding order (clockwise or + counter-clockwise). Non-sequential ordering (e.g. diagonal pairs) + silently produces incorrect results. + + Width and height are determined by x-axis projection of each half-side + vector. When a box rotates past ``arctan(w/h)`` (approx. 68 deg for a + 10 x 4 box) the assigned *width* side flips discontinuously, producing + a jump in anchor position (~``|w - h|`` pixels for ``BOTTOM_CENTER``). + The anchor always lies on the box; the effect is cosmetic for static + images but visible on rotating objects in video. + + Examples: + ```pycon + >>> import numpy as np + >>> from supervision.detection.utils.boxes import _oriented_box_anchors + >>> from supervision.geometry.core import Position + >>> corners = np.array( + ... [[[0, 0], [10, 0], [10, 4], [0, 4]]], dtype=np.float32 + ... ) + >>> _oriented_box_anchors(corners, Position.BOTTOM_CENTER) + array([[5., 4.]]) + + ``` + """ + corners = np.asarray(xyxyxyxy, dtype=np.float64) + if corners.ndim != 3 or corners.shape[-2:] != (4, 2): + raise ValueError(f"xyxyxyxy must have shape (N, 4, 2); got {corners.shape}") + if anchor not in _ANCHOR_OFFSETS: + raise ValueError(f"{anchor} is not supported.") + sx, sy = _ANCHOR_OFFSETS[anchor] + + center = corners.mean(axis=1) + # Two perpendicular half-side vectors per box. + half_side_a = (corners[:, 1] - corners[:, 0]) / 2 + half_side_b = (corners[:, 2] - corners[:, 1]) / 2 + + # Map each box's own sides onto the image axes: the side more aligned with + # the x-axis plays the role of width, the other of height. This makes the + # offsets collapse to the axis-aligned frame when the box is not rotated. + is_width = np.abs(half_side_a[:, 0]) >= np.abs(half_side_b[:, 0]) + width = np.where(is_width[:, None], half_side_a, half_side_b) + height = np.where(is_width[:, None], half_side_b, half_side_a) + # Point width toward +x and height toward +y so the offset signs are stable. + width = np.where((width[:, 0] < 0)[:, None], -width, width) + height = np.where((height[:, 1] < 0)[:, None], -height, height) + + return cast(npt.NDArray[np.float64], center + sx * width + sy * height) + + +def scale_boxes( + xyxy: npt.NDArray[np.float64], factor: float +) -> npt.NDArray[np.float64]: + """ + Scale the dimensions of bounding boxes. + + Args: + xyxy: An array of shape `(n, 4)` containing the + bounding boxes coordinates in format `[x1, y1, x2, y2]` + factor: A float value representing the factor by which the box + dimensions are scaled. A factor greater than 1 enlarges the boxes, while a + factor less than 1 shrinks them. + + Returns: + Scaled bounding boxes. + + Examples: + ```pycon + >>> import numpy as np + >>> import supervision as sv + >>> xyxy = np.array([ + ... [10, 10, 20, 20], + ... [30, 30, 40, 40] + ... ]) + >>> sv.scale_boxes(xyxy=xyxy, factor=1.5) + array([[ 7.5, 7.5, 22.5, 22.5], + [27.5, 27.5, 42.5, 42.5]]) + + ``` + """ + centers = (xyxy[:, :2] + xyxy[:, 2:]) / 2 + new_sizes = (xyxy[:, 2:] - xyxy[:, :2]) * factor + return np.concatenate((centers - new_sizes / 2, centers + new_sizes / 2), axis=1) + + +def spread_out_boxes( + xyxy: npt.NDArray[np.number], + max_iterations: int = 100, +) -> npt.NDArray[np.number]: + """ + Spread out boxes that overlap with each other. + + Args: + xyxy: Numpy array of shape (N, 4) where N is the number of boxes. + max_iterations: Maximum number of iterations to run the algorithm for. + + Example: + ```pycon + >>> import numpy as np + >>> from supervision.detection.utils.boxes import spread_out_boxes + >>> xyxy = np.array([ + ... [10, 10, 20, 20], + ... [12, 12, 22, 22] + ... ]) + >>> spread_out = spread_out_boxes(xyxy=xyxy, max_iterations=10) + >>> # The boxes should be moved apart + >>> bool(spread_out[0, 0] < 10 and spread_out[0, 1] < 10) + True + >>> bool(spread_out[1, 0] > 12 and spread_out[1, 1] > 12) + True + + ``` + """ + if len(xyxy) == 0: + return xyxy + + xyxy_padded = cast(npt.NDArray[Any], pad_boxes(xyxy, px=1)) + for _ in range(max_iterations): + # NxN + iou = box_iou_batch(xyxy_padded, xyxy_padded) + np.fill_diagonal(iou, 0) + if np.all(iou == 0): + break + + overlap_mask = iou > 0 + + # Nx2 + centers = (xyxy_padded[:, :2] + xyxy_padded[:, 2:]) / 2 + + # NxNx2 + delta_centers = centers[:, np.newaxis, :] - centers[np.newaxis, :, :] + delta_centers *= overlap_mask[:, :, np.newaxis] + + # Nx2 + delta_sum = np.sum(delta_centers, axis=1) + delta_magnitude = np.linalg.norm(delta_sum, axis=1, keepdims=True) + direction_vectors = np.divide( + delta_sum, + delta_magnitude, + out=np.zeros_like(delta_sum), + where=delta_magnitude != 0, + ) + + force_vectors = np.sum(iou, axis=1) + force_vectors = force_vectors[:, np.newaxis] * direction_vectors + + force_vectors *= 10 + force_vectors[(force_vectors > 0) & (force_vectors < 2)] = 2 + force_vectors[(force_vectors < 0) & (force_vectors > -2)] = -2 + + force_vectors = force_vectors.astype(int) + + xyxy_padded[:, [0, 1]] += force_vectors + xyxy_padded[:, [2, 3]] += force_vectors + + return pad_boxes(xyxy_padded, px=-1) diff --git a/src/supervision/detection/utils/converters.py b/src/supervision/detection/utils/converters.py new file mode 100644 index 0000000..7051342 --- /dev/null +++ b/src/supervision/detection/utils/converters.py @@ -0,0 +1,827 @@ +from __future__ import annotations + +from typing import Any, Literal, cast + +import cv2 +import numpy as np +import numpy.typing as npt + +MIN_POLYGON_POINT_COUNT = 3 +CoordinateConvention = Literal["inclusive", "exclusive"] + + +def xyxy_to_polygons(box: npt.NDArray[np.number]) -> npt.NDArray[np.number]: + """ + Convert an array of boxes to an array of polygons. + Retains the input datatype. + + Args: + box: An array of boxes (N, 4), where each box is represented as a + list of four coordinates in the format `(x_min, y_min, x_max, y_max)`. + + Returns: + An array of polygons (N, 4, 2), where each polygon is + represented as a list of four coordinates in the format `(x, y)`. + + Examples: + ```pycon + >>> import numpy as np + >>> import supervision as sv + >>> box = np.array([[10, 20, 30, 40]]) + >>> sv.xyxy_to_polygons(box) + array([[[10, 20], + [30, 20], + [30, 40], + [10, 40]]]) + + ``` + """ + polygon = np.zeros((box.shape[0], 4, 2), dtype=box.dtype) + polygon[:, :, 0] = box[:, [0, 2, 2, 0]] + polygon[:, :, 1] = box[:, [1, 1, 3, 3]] + return polygon + + +def polygon_to_mask( + polygon: npt.NDArray[np.number], + resolution_wh: tuple[int, int], +) -> npt.NDArray[np.uint8]: + """Generate a mask from a polygon. + + Args: + polygon: The polygon for which the mask should be generated, + given as a list of vertices. + resolution_wh: The width and height of the desired resolution. + + Returns: + The generated 2D mask, where the polygon is marked with + `1`s and the rest is filled with `0`s. + + Examples: + ```pycon + >>> import numpy as np + >>> import supervision as sv + >>> polygon = np.array([[2, 2], [6, 2], [6, 6], [2, 6]]) + >>> mask = sv.polygon_to_mask(polygon, resolution_wh=(10, 10)) + >>> int(mask.sum()) + 25 + + ``` + """ + width, height = map(int, resolution_wh) + mask = np.zeros((height, width), dtype=np.uint8) + cv2.fillPoly(mask, [polygon.astype(np.int32)], color=(1,)) + return mask + + +def xywh_to_xyxy(xywh: npt.NDArray[np.number]) -> npt.NDArray[np.number]: + """ + Converts bounding box coordinates from `(x, y, width, height)` + format to `(x_min, y_min, x_max, y_max)` format. + + Args: + xywh: A numpy array of shape `(N, 4)` where each row + corresponds to a bounding box in the format `(x, y, width, height)`. + + Returns: + A numpy array of shape `(N, 4)` where each row corresponds + to a bounding box in the format `(x_min, y_min, x_max, y_max)`. + + Examples: + ```pycon + >>> import numpy as np + >>> import supervision as sv + >>> xywh = np.array([ + ... [10, 20, 30, 40], + ... [15, 25, 35, 45] + ... ]) + >>> sv.xywh_to_xyxy(xywh=xywh) + array([[10, 20, 40, 60], + [15, 25, 50, 70]]) + + ``` + """ + xyxy = xywh.copy() + xyxy[:, 2] = xywh[:, 0] + xywh[:, 2] + xyxy[:, 3] = xywh[:, 1] + xywh[:, 3] + return cast(npt.NDArray[np.number], np.asarray(xyxy)) + + +def xyxy_to_xywh(xyxy: npt.NDArray[np.number]) -> npt.NDArray[np.number]: + """ + Converts bounding box coordinates from `(x_min, y_min, x_max, y_max)` + format to `(x, y, width, height)` format. + + Args: + xyxy: A numpy array of shape `(N, 4)` where each row + corresponds to a bounding box in the format `(x_min, y_min, x_max, + y_max)`. + + Returns: + A numpy array of shape `(N, 4)` where each row corresponds + to a bounding box in the format `(x, y, width, height)`. + + Examples: + ```pycon + >>> import numpy as np + >>> import supervision as sv + >>> xyxy = np.array([ + ... [10, 20, 40, 60], + ... [15, 25, 50, 70] + ... ]) + >>> sv.xyxy_to_xywh(xyxy=xyxy) + array([[10, 20, 30, 40], + [15, 25, 35, 45]]) + + ``` + """ + xywh = xyxy.copy() + xywh[:, 2] = xyxy[:, 2] - xyxy[:, 0] + xywh[:, 3] = xyxy[:, 3] - xyxy[:, 1] + return cast(npt.NDArray[np.number], np.asarray(xywh)) + + +def xcycwh_to_xyxy(xcycwh: npt.NDArray[np.number]) -> npt.NDArray[np.number]: + """ + Converts bounding box coordinates from `(center_x, center_y, width, height)` + format to `(x_min, y_min, x_max, y_max)` format. + + Args: + xcycwh: A numpy array of shape `(N, 4)` where each row + corresponds to a bounding box in the format `(center_x, center_y, width, + height)`. + + Returns: + A numpy array of shape `(N, 4)` where each row corresponds + to a bounding box in the format `(x_min, y_min, x_max, y_max)`. + + Examples: + ```pycon + >>> import numpy as np + >>> import supervision as sv + >>> xcycwh = np.array([ + ... [50.0, 50.0, 20.0, 30.0], + ... [30.0, 40.0, 10.0, 15.0] + ... ]) + >>> sv.xcycwh_to_xyxy(xcycwh=xcycwh) + array([[40. , 35. , 60. , 65. ], + [25. , 32.5, 35. , 47.5]]) + + ``` + """ + xyxy = xcycwh.copy() + xyxy[:, 0] = xcycwh[:, 0] - xcycwh[:, 2] / 2 + xyxy[:, 1] = xcycwh[:, 1] - xcycwh[:, 3] / 2 + xyxy[:, 2] = xcycwh[:, 0] + xcycwh[:, 2] / 2 + xyxy[:, 3] = xcycwh[:, 1] + xcycwh[:, 3] / 2 + return cast(npt.NDArray[np.number], np.asarray(xyxy)) + + +def xyxy_to_xcycarh(xyxy: npt.NDArray[np.number]) -> npt.NDArray[np.floating]: + """ + Converts bounding box coordinates from `(x_min, y_min, x_max, y_max)` + into measurement space to format `(center x, center y, aspect ratio, height)`, + where the aspect ratio is `width / height`. + + Args: + xyxy: Bounding box in format `(x1, y1, x2, y2)`. + Expected shape is `(N, 4)`. + Returns: + Bounding box in format + `(center x, center y, aspect ratio, height)`. Shape `(N, 4)`. + + Examples: + ```pycon + >>> import numpy as np + >>> import supervision as sv + >>> xyxy = np.array([ + ... [10, 20, 40, 60], + ... [15, 25, 50, 70] + ... ]) + >>> sv.xyxy_to_xcycarh(xyxy=xyxy) # doctest: +ELLIPSIS + array([[25. , 40. , 0.75 , 40. ], + [32.5 , 47.5 , 0.77..., 45. ]]) + + ``` + + """ + if xyxy.size == 0: + return np.empty((0, 4), dtype=float) + + x1, y1, x2, y2 = xyxy.T + width = x2 - x1 + height = y2 - y1 + center_x = x1 + width / 2 + center_y = y1 + height / 2 + + aspect_ratio = np.divide( + width, + height, + out=np.zeros_like(width, dtype=float), + where=height != 0, + ) + result = np.column_stack((center_x, center_y, aspect_ratio, height)) + return result.astype(float) + + +def mask_to_xyxy( + masks: npt.NDArray[np.bool_], + coordinate_convention: CoordinateConvention = "inclusive", +) -> npt.NDArray[np.int_]: + """ + Converts a 3D `np.array` of 2D bool masks into a 2D `np.array` of bounding boxes. + + Args: + masks: A 3D `np.array` of shape `(N, H, W)` containing 2D bool masks. + coordinate_convention: How to interpret the returned max corner. + Use `"inclusive"` to preserve the legacy Supervision behavior, + where `x_max` and `y_max` are the last covered pixel. Use + `"exclusive"` for half-open boxes that match area and IoU arithmetic. + + Returns: + A 2D `np.array` of shape `(N, 4)` containing the bounding boxes + `(x_min, y_min, x_max, y_max)` for each mask. + + Examples: + ```pycon + >>> import numpy as np + >>> import supervision as sv + >>> masks = np.array([ + ... [[False, False, False], + ... [False, True, True], + ... [False, True, True]], + ... ]) + >>> sv.mask_to_xyxy(masks) + array([[1, 1, 2, 2]]) + + ``` + """ + n, height, width = masks.shape + if masks.size == 0: + return np.zeros((n, 4), dtype=int) + + # Reduce the mask stack to per-row / per-column occupancy, then read the + # tight bounds straight off those 1D profiles instead of scanning every + # pixel of every mask with `np.where`. + rows_any = cast(npt.NDArray[np.bool_], masks.any(axis=2)) # (N, H) + cols_any = cast(npt.NDArray[np.bool_], masks.any(axis=1)) # (N, W) + + x_min = cols_any.argmax(axis=1) + y_min = rows_any.argmax(axis=1) + + if coordinate_convention == "inclusive": + x_max = width - 1 - cols_any[:, ::-1].argmax(axis=1) + y_max = height - 1 - rows_any[:, ::-1].argmax(axis=1) + elif coordinate_convention == "exclusive": + x_max = width - cols_any[:, ::-1].argmax(axis=1) + y_max = height - rows_any[:, ::-1].argmax(axis=1) + else: + raise ValueError( + "coordinate_convention must be 'inclusive' or 'exclusive', " + f"got {coordinate_convention!r}." + ) + + xyxy = np.stack((x_min, y_min, x_max, y_max), axis=1).astype(int) + # Empty masks have no bounds; keep the original all-zeros box for them. + xyxy[~rows_any.any(axis=1)] = 0 + return xyxy + + +def xyxy_to_mask( + boxes: npt.NDArray[np.number], + resolution_wh: tuple[int, int], + coordinate_convention: CoordinateConvention = "inclusive", +) -> npt.NDArray[np.bool_]: + """ + Converts a 2D `np.ndarray` of bounding boxes into a 3D `np.ndarray` of bool masks. + + Args: + boxes: A 2D `np.ndarray` of shape `(N, 4)` containing bounding boxes + `(x_min, y_min, x_max, y_max)`. + resolution_wh: A tuple `(width, height)` specifying the resolution of + the output masks. + coordinate_convention: How to interpret `x_max` and `y_max`. + Use `"inclusive"` for closed boxes with the legacy Supervision + convention. Use `"exclusive"` for half-open boxes that align with + box area and IoU calculations. + + Returns: + A 3D `np.ndarray` of shape `(N, height, width)` containing 2D bool masks + for each bounding box. + + Examples: + ```pycon + >>> import numpy as np + >>> import supervision as sv + >>> boxes = np.array([[0, 0, 2, 2]]) + >>> sv.xyxy_to_mask(boxes, (5, 5)) + array([[[ True, True, True, False, False], + [ True, True, True, False, False], + [ True, True, True, False, False], + [False, False, False, False, False], + [False, False, False, False, False]]]) + >>> boxes = np.array([[0, 0, 1, 1], [3, 3, 4, 4]]) + >>> sv.xyxy_to_mask(boxes, (5, 5)) + array([[[ True, True, False, False, False], + [ True, True, False, False, False], + [False, False, False, False, False], + [False, False, False, False, False], + [False, False, False, False, False]], + + [[False, False, False, False, False], + [False, False, False, False, False], + [False, False, False, False, False], + [False, False, False, True, True], + [False, False, False, True, True]]]) + + ``` + """ + width, height = resolution_wh + n = boxes.shape[0] + masks = np.zeros((n, height, width), dtype=bool) + + for i, (x_min, y_min, x_max, y_max) in enumerate(boxes): + x_min = max(0, int(x_min)) + y_min = max(0, int(y_min)) + if coordinate_convention == "inclusive": + x_max = min(width - 1, int(x_max)) + y_max = min(height - 1, int(y_max)) + if x_max >= x_min and y_max >= y_min: + masks[i, y_min : y_max + 1, x_min : x_max + 1] = True + elif coordinate_convention == "exclusive": + x_max = min(width, int(x_max)) + y_max = min(height, int(y_max)) + if x_max > x_min and y_max > y_min: + masks[i, y_min:y_max, x_min:x_max] = True + else: + raise ValueError( + "coordinate_convention must be 'inclusive' or 'exclusive', " + f"got {coordinate_convention!r}." + ) + + return masks + + +def mask_to_polygons(mask: npt.NDArray[np.bool_]) -> list[npt.NDArray[np.int32]]: + """ + Converts a binary mask to a list of polygons. + + Args: + mask: A binary mask represented as a 2D NumPy array of shape `(H, W)`, + where H and W are the height and width of the mask, respectively. + + Returns: + A list of polygons, where each polygon is represented by a NumPy array + of shape `(N, 2)`, containing the `x`, `y` coordinates of the + points. Polygons with fewer points than `MIN_POLYGON_POINT_COUNT = 3` + are excluded from the output. + + Examples: + ```pycon + >>> import numpy as np + >>> import supervision as sv + >>> mask = np.zeros((10, 10), dtype=bool) + >>> mask[2:6, 2:6] = True + >>> sv.mask_to_polygons(mask) + [array([[2, 2], + [2, 5], + [5, 5], + [5, 2]], dtype=int32)] + + ``` + """ + + contours, _ = cv2.findContours( + mask.astype(np.uint8), cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE + ) + return [ + np.squeeze(contour, axis=1) + for contour in contours + if contour.shape[0] >= MIN_POLYGON_POINT_COUNT + ] + + +def _base48_decode(s: str) -> list[int]: + """Decode a COCO base-48 string to raw (delta-encoded) integers. + + Implements the variable-length base-48 codec from the COCO API + (pycocotools). Each integer is encoded across one or more 6-bit + characters: bits 0-4 carry data; bit 5 signals continuation; bit 4 + of the final character signals a negative value. + + This is the pure codec layer โ€” call :func:`_delta_decode` on the + result to obtain absolute run-length counts. + + Args: + s: COCO compressed RLE string. + + Returns: + Raw delta-encoded integers, one per run. + + Raises: + ValueError: If the string is truncated mid-integer. + + Examples: + ```pycon + >>> from supervision.detection.utils.converters import _base48_decode + >>> _base48_decode("52203") + [5, 2, 2, 0, 3] + + ``` + """ + values: list[int] = [] + i = 0 + while i < len(s): + x = 0 + k = 0 + more = True + while more: + if i >= len(s): + raise ValueError( + f"Malformed compressed RLE string: unexpected end at position {i}" + ) + c = ord(s[i]) - 48 + x |= (c & 0x1F) << (5 * k) + more = bool(c & 0x20) + i += 1 + k += 1 + if not more and (c & 0x10): + x |= ~0 << (5 * k) + values.append(x) + return values + + +def _base48_encode(values: list[int]) -> str: + """Encode raw (delta-encoded) integers to a COCO base-48 string. + + The inverse of :func:`_base48_decode`. Applies the same variable-length + base-48 codec used by pycocotools. + + Apply :func:`_delta_encode` to absolute run-length counts before calling + this function to produce a valid COCO compressed RLE string. + + Args: + values: Raw (delta-encoded) integers to encode. + + Returns: + COCO base-48 encoded string. + + Examples: + ```pycon + >>> from supervision.detection.utils.converters import _base48_encode + >>> _base48_encode([5, 2, 2, 0, 3]) + '52203' + + ``` + """ + chars: list[str] = [] + for x in values: + more = True + while more: + c = x & 0x1F + x >>= 5 + more = (x != -1) if (c & 0x10) else (x != 0) + if more: + c |= 0x20 + chars.append(chr(c + 48)) + return "".join(chars) + + +def _delta_decode(values: list[int]) -> list[int]: + """Undo COCO delta encoding: ``counts[i] += counts[i - 2]`` for ``i > 2``. + + The COCO compressed RLE format stores run lengths as deltas relative to + the count two positions earlier (starting at index 3). This function + converts those relative values back to absolute run lengths. + + Args: + values: Raw delta-encoded integers from :func:`_base48_decode`. + + Returns: + Absolute run-length counts (alternating background / foreground). + + Examples: + ```pycon + >>> from supervision.detection.utils.converters import _delta_decode + >>> _delta_decode([5, 2, 2, 0, 3]) + [5, 2, 2, 2, 5] + + ``` + """ + # The recurrence ``counts[i] += counts[i - 2]`` for ``i >= 3`` decomposes + # into two independent stride-2 chains: the odd indices (1, 3, 5, ...) and + # the even indices from 2 onward (2, 4, 6, ...). A cumulative sum over each + # chain recovers the absolute counts. Index 0 is absolute and untouched. + # int64 accumulation avoids overflow; ``tolist`` returns native Python ints. + counts = np.asarray(values, dtype=np.int64) + counts[1::2] = np.cumsum(counts[1::2]) + counts[2::2] = np.cumsum(counts[2::2]) + return cast("list[int]", counts.tolist()) + + +def _delta_encode(counts: list[int]) -> list[int]: + """Apply COCO delta encoding: ``d[i] = counts[i] - counts[i - 2]`` for ``i > 2``. + + The inverse of :func:`_delta_decode`. Converts absolute run lengths to + the relative representation required by the COCO compressed RLE format. + + Args: + counts: Absolute run-length counts (alternating background / foreground). + + Returns: + Delta-encoded integers ready for :func:`_base48_encode`. + + Examples: + ```pycon + >>> from supervision.detection.utils.converters import _delta_encode + >>> _delta_encode([5, 2, 2, 2, 5]) + [5, 2, 2, 0, 3] + + ``` + """ + deltas = list(counts) + for i in range(3, len(deltas)): + deltas[i] = counts[i] - counts[i - 2] + return deltas + + +def is_compressed_rle(rle: object) -> bool: + """Return ``True`` if ``rle`` is a COCO compressed RLE (``str`` or ``bytes``). + + Use this to branch between the compressed-string pipeline + (:func:`_base48_decode` โ†’ :func:`_delta_decode`) and the uncompressed + integer-list / array pipeline before calling :func:`rle_to_mask`. + + Args: + rle: Candidate RLE value to inspect. + + Returns: + ``True`` for ``str`` or ``bytes`` inputs; ``False`` otherwise. + + Examples: + ```pycon + >>> from supervision.detection.utils.converters import is_compressed_rle + >>> is_compressed_rle("52203") + True + >>> is_compressed_rle([5, 2, 2, 2, 5]) + False + + ``` + """ + return isinstance(rle, (str, bytes)) + + +def _mask_to_rle_counts(mask_2d: npt.NDArray[Any]) -> npt.NDArray[np.int32]: + """Encode a 2D boolean mask as COCO F-order run lengths (int32 array). + + Pixels are scanned column-by-column (Fortran order), matching the COCO / + pycocotools RLE convention. The first value is always the count of leading + ``False`` pixels (may be 0 if the mask starts with ``True``). + + This is the shared low-level encoder used by both :func:`mask_to_rle` and + :class:`~supervision.detection.compact_mask.CompactMask`. + + Args: + mask_2d: 2D boolean array of shape ``(H, W)``. + + Returns: + int32 array of run lengths starting with the False count. + + Examples: + ```pycon + >>> import numpy as np + >>> from supervision.detection.utils.converters import _mask_to_rle_counts + >>> mask = np.array([[False, True], [True, False]]) + >>> _mask_to_rle_counts(mask).tolist() + [1, 2, 1] + + ``` + """ + flat = np.asarray(mask_2d, dtype=np.bool_).ravel(order="F") + if len(flat) == 0: + return np.array([0], dtype=np.int32) + + changes = np.diff(flat.view(np.uint8)) + boundaries = np.where(changes != 0)[0] + 1 + positions = np.concatenate(([0], boundaries, [len(flat)])) + run_lengths = np.diff(positions).astype(np.int32) + + if flat[0]: + run_lengths = np.concatenate(([np.int32(0)], run_lengths)) + + return run_lengths + + +def _rle_counts_to_mask( + rle: npt.NDArray[np.int32], height: int, width: int +) -> npt.NDArray[np.bool_]: + """Decode COCO F-order run lengths back to a 2D boolean mask. + + This is the shared low-level decoder used by both :func:`rle_to_mask` and + :class:`~supervision.detection.compact_mask.CompactMask`. + + Args: + rle: int32 array of run lengths as produced by :func:`_mask_to_rle_counts`. + height: Height of the output mask. + width: Width of the output mask. + + Returns: + 2D boolean array of shape ``(height, width)``. + + Examples: + ```pycon + >>> import numpy as np + >>> from supervision.detection.utils.converters import _rle_counts_to_mask + >>> rle = np.array([0, 1, 2, 1], dtype=np.int32) + >>> _rle_counts_to_mask(rle, 2, 2) + array([[ True, False], + [False, True]]) + + ``` + """ + is_true = np.arange(len(rle)) % 2 == 1 + flat: npt.NDArray[np.bool_] = np.repeat(is_true, rle) + num_pixels = height * width + if len(flat) < num_pixels: + flat = np.pad(flat, (0, num_pixels - len(flat))) + return cast( + npt.NDArray[np.bool_], flat[:num_pixels].reshape(height, width, order="F") + ) + + +def rle_to_mask( + rle: npt.NDArray[np.integer[Any]] | list[int] | str | bytes, + resolution_wh: tuple[int, int], +) -> npt.NDArray[np.bool_]: + """ + Converts a COCO run-length encoding (RLE) to a binary mask. + + Implements the COCO RLE format used by ``pycocotools``: pixels are counted + in **column-major (Fortran) order** โ€” top-to-bottom within each column, + left-to-right across columns. This is the opposite of the row-major order + used by NumPy's default ``'C'`` layout. Passing RLE data produced by a + different row-major convention will yield an incorrect mask. + + Args: + rle: The COCO RLE data in one of the following formats: + + - A 1D array or list of integers (uncompressed COCO RLE, where + values at even indices are background run-lengths and values at + odd indices are foreground run-lengths, both counted column-major). + - A compressed COCO RLE string or bytes, as produced by + ``pycocotools.mask.encode``. + resolution_wh: The width (w) and height (h) + of the desired binary mask. + + Returns: + The generated 2D Boolean mask of shape `(h, w)`, where the foreground object is + marked with `True`'s and the rest is filled with `False`'s. + + Raises: + ValueError: If the sum of pixels encoded in RLE differs from the + number of pixels in the expected mask (computed based on resolution_wh). + + Examples: + ```pycon + >>> import numpy as np + >>> import supervision as sv + >>> mask = sv.rle_to_mask([5, 2, 2, 2, 5], (4, 4)) + >>> mask # doctest: +NORMALIZE_WHITESPACE + array([[False, False, False, False], + [False, True, True, False], + [False, True, True, False], + [False, False, False, False]]) + + >>> mask = sv.rle_to_mask("52203", (4, 4)) + >>> mask # doctest: +NORMALIZE_WHITESPACE + array([[False, False, False, False], + [False, True, True, False], + [False, True, True, False], + [False, False, False, False]]) + + ``` + """ + if isinstance(rle, bytes): + rle = rle.decode("utf-8") + if isinstance(rle, str): + counts: npt.NDArray[np.int32] = np.array( + _delta_decode(_base48_decode(rle)), dtype=np.int32 + ) + elif isinstance(rle, list): + counts = np.array(rle, dtype=np.int32) + else: + counts = np.asarray(rle, dtype=np.int32) + + width, height = resolution_wh + + if width * height != np.sum(counts): + raise ValueError( + "the sum of the number of pixels in the RLE must be the same " + "as the number of pixels in the expected mask" + ) + + return _rle_counts_to_mask(counts, height, width) + + +def mask_to_rle( + mask: npt.NDArray[np.bool_], compressed: bool = False +) -> list[int] | str: + """ + Converts a binary mask into a COCO run-length encoding (RLE). + + Produces RLE in the COCO format used by ``pycocotools``: pixels are counted + in **column-major (Fortran) order** โ€” top-to-bottom within each column, + left-to-right across columns. The output is directly compatible with + ``pycocotools.mask.decode`` and COCO annotation JSON files. + + Args: + mask: 2D binary mask where `True` indicates foreground + object and `False` indicates background. + compressed: If ``True``, return a compressed COCO RLE string + compatible with ``pycocotools``. If ``False`` (default), + return a list of integers. + + Returns: + The COCO run-length encoded mask. When ``compressed`` is ``False``, + values of a list with even indices represent the number of pixels + assigned as background (`False`), values of a list with odd indices + represent the number of pixels assigned as foreground object (`True`), + both counted in column-major order. + When ``compressed`` is ``True``, a COCO compressed RLE string. + + Raises: + ValueError: If input mask is not 2D or is empty. + + Examples: + ```pycon + >>> import numpy as np + >>> import supervision as sv + >>> mask = np.array([ + ... [True, True, True, True], + ... [True, True, True, True], + ... [True, True, True, True], + ... [True, True, True, True], + ... ]) + >>> rle = sv.mask_to_rle(mask) + >>> [int(x) for x in rle] + [0, 16] + + ``` + + ```pycon + >>> import numpy as np + >>> import supervision as sv + >>> mask = np.array([ + ... [False, False, False, False], + ... [False, True, True, False], + ... [False, True, True, False], + ... [False, False, False, False], + ... ]) + >>> rle = sv.mask_to_rle(mask) + >>> [int(x) for x in rle] + [5, 2, 2, 2, 5] + + >>> sv.mask_to_rle(mask, compressed=True) + '52203' + + ``` + + ![mask_to_rle](https://media.roboflow.com/supervision-docs/ + mask-to-rle.png){ align=center width="800" } + """ + if mask.ndim != 2: + raise ValueError("Input mask must be 2D") + if mask.size == 0: + raise ValueError("Input mask cannot be empty") + + counts: list[int] = cast(list[int], _mask_to_rle_counts(mask).tolist()) + if compressed: + return _base48_encode(_delta_encode(counts)) + return counts + + +def polygon_to_xyxy(polygon: npt.NDArray[np.number]) -> npt.NDArray[np.number]: + """ + Converts a polygon represented by a NumPy array into a bounding box. + + Args: + polygon: A polygon represented by a NumPy array of shape `(N, 2)`, + containing the `x`, `y` coordinates of the points. + + Returns: + A 1D NumPy array containing the bounding box + `(x_min, y_min, x_max, y_max)` of the input polygon. + + Examples: + ```pycon + >>> import numpy as np + >>> import supervision as sv + >>> polygon = np.array([[10, 20], [30, 20], [30, 40], [10, 40]]) + >>> sv.polygon_to_xyxy(polygon) + array([10, 20, 30, 40]) + + ``` + """ + x_min, y_min = np.min(polygon, axis=0) + x_max, y_max = np.max(polygon, axis=0) + return np.array([x_min, y_min, x_max, y_max]) diff --git a/src/supervision/detection/utils/internal.py b/src/supervision/detection/utils/internal.py new file mode 100644 index 0000000..cb7eed9 --- /dev/null +++ b/src/supervision/detection/utils/internal.py @@ -0,0 +1,724 @@ +import logging +from itertools import chain +from typing import Any, Literal, cast, overload + +import cv2 +import numpy as np +import numpy.typing as npt + +from supervision.config import CLASS_NAME_DATA_FIELD +from supervision.detection.compact_mask import CompactMask +from supervision.detection.utils._typing import _DetectionDataType, _MetadataType +from supervision.detection.utils.converters import polygon_to_mask, rle_to_mask +from supervision.geometry.core import Vector + +logger = logging.getLogger(__name__) + + +def _full_image_xyxy( + count: int, + image_height: int, + image_width: int, + dtype: npt.DTypeLike = np.float64, +) -> npt.NDArray[Any]: + """Return full-frame inclusive boxes for lossless mask compaction.""" + return np.tile( + np.array([[0, 0, image_width - 1, image_height - 1]], dtype=dtype), + (count, 1), + ) + + +def _valid_rle_payload(prediction: dict[str, Any]) -> dict[str, Any] | None: + """Return the first valid RLE payload from ``rle`` then ``rle_mask``.""" + for key in ("rle", "rle_mask"): + rle_data = prediction.get(key) + if isinstance(rle_data, dict) and {"size", "counts"}.issubset(rle_data): + return rle_data + return None + + +def extract_ultralytics_masks(yolov8_results: Any) -> npt.NDArray[np.bool_] | None: + """Extract boolean masks from Ultralytics results, cropping letterbox padding. + + Handles the case where the inference resolution differs from the original image + shape by computing the letterbox padding offsets, cropping them out, and resizing + each proto mask back to `orig_shape`. Thresholds at 0.5 to match Ultralytics' + semantics and avoid dilating masks through float interpolation. + + Args: + yolov8_results: Ultralytics results object with `.masks` and `.orig_shape`. + + Returns: + Boolean array of shape `(N, H, W)` aligned with the detections, or `None` + when no masks are present. + """ + if not yolov8_results.masks: + return None + + orig_shape = yolov8_results.orig_shape + inference_shape = tuple(yolov8_results.masks.data.shape[1:]) + + pad = (0, 0) + + if inference_shape != orig_shape: + gain = min( + inference_shape[0] / orig_shape[0], + inference_shape[1] / orig_shape[1], + ) + pad = ( + (inference_shape[1] - orig_shape[1] * gain) / 2, + (inference_shape[0] - orig_shape[0] * gain) / 2, + ) + + top, left = int(pad[1]), int(pad[0]) + bottom, right = int(inference_shape[0] - pad[1]), int(inference_shape[1] - pad[0]) + + mask_maps = [] + masks = yolov8_results.masks.data.cpu().numpy() + for i in range(masks.shape[0]): + mask = masks[i] + mask = mask[top:bottom, left:right] + + if mask.shape != orig_shape: + # `cv2.resize` interpolates the float proto mask, so threshold at 0.5 + # (matching Ultralytics' own semantics) instead of casting every + # nonzero interpolated value to True, which would dilate the mask. + mask = cv2.resize(mask, (orig_shape[1], orig_shape[0])) > 0.5 + # else: slice-crop (no interpolation) preserves the binary 0/1 float values + # produced by Ultralytics; the final np.asarray(..., dtype=bool) is equivalent. + + mask_maps.append(mask) + + return cast(npt.NDArray[np.bool_], np.asarray(mask_maps, dtype=bool)) + + +def _resolve_rle_mask( + rle_data: dict[str, Any], + image_height: int, + image_width: int, + compact_masks: bool, +) -> tuple[npt.NDArray[np.bool_] | None, dict[str, Any] | None]: + """Decode one RLE prediction into (dense_mask, compact_pending). + + Returns ``(dense_mask, None)`` when ``compact_masks=False`` or when the + RLE size does not match the image size (fall back to dense decode). + Returns ``(None, rle_data)`` when ``compact_masks=True`` and the RLE size + matches, deferring the item to the post-loop batch call. + Returns ``(None, None)`` on decode failure (caller should skip mask). + + Args: + rle_data: Validated COCO RLE dict with ``"size"`` and ``"counts"`` keys. + image_height: Full-image height in pixels. + image_width: Full-image width in pixels. + compact_masks: Whether to return a deferred item for batch processing. + + Returns: + A 2-tuple ``(dense_mask, pending)`` where at most one element is + non-``None``. + """ + try: + h, w = rle_data["size"] + if compact_masks and (h, w) == (image_height, image_width): + # Sizes match; defer to the post-loop CompactMask.from_coco_rle call. + return None, rle_data + if compact_masks and (h, w) != (image_height, image_width): + logger.debug( + "compact_masks=True: RLE size %s does not match image " + "size (%d, %d); falling back to dense decode.", + (h, w), + image_height, + image_width, + ) + mask: npt.NDArray[np.bool_] = rle_to_mask(rle_data["counts"], (w, h)) + if (h, w) != (image_height, image_width): + mask = cv2.resize( + mask.astype(np.uint8), + (image_width, image_height), + interpolation=cv2.INTER_NEAREST, + ).astype(bool) + return mask, None + except (ValueError, AssertionError, KeyError, TypeError, OverflowError) as exc: + logger.warning( + "Failed to decode RLE mask payload; falling back to box-only " + "detection. Reason: %s", + exc, + ) + return None, None + + +def _all_present_or_none( + values: list[Any], + label: str, + dtype: npt.DTypeLike, +) -> npt.NDArray[Any] | None: + # Identity check (`v is None`) is required when values may contain numpy arrays: + # `None in values` triggers element-wise comparison and raises ValueError. + missing = sum(v is None for v in values) + if 0 < missing < len(values): + logger.warning( + "Partial %s in batch; dropping all to preserve alignment with xyxy.", label + ) + if not values or missing > 0: + return None + return np.array(values, dtype=dtype) + + +def _decode_compact_masks( + coco_rle_pending: list[tuple[int, Any, list[float]]], + polygon_compact_map: dict[int, CompactMask], + image_height: int, + image_width: int, + n_predictions: int, +) -> CompactMask | None: + """Decode deferred COCO-RLE entries and merge with polygon compact masks. + + Attempts a single batched ``CompactMask.from_coco_rle`` call for all pending + items to eliminate per-prediction call overhead on the happy path. On any + decode failure the call is retried per-prediction so that one malformed RLE + payload does not abort the entire batch. + + Isolation note: this function isolates the *decode* step only. If the + per-prediction fallback still leaves some predictions without masks, the + mixed-modality guard drops ALL masks to preserve alignment with ``xyxy``. + + Args: + coco_rle_pending: Deferred COCO-RLE items collected during the prediction + loop, each as ``(xyxy_idx, rle_dict, bbox)``. + polygon_compact_map: Already-decoded polygon masks keyed by ``xyxy_idx``. + image_height: Frame height in pixels. + image_width: Frame width in pixels. + n_predictions: Total number of accepted predictions; used by the + mixed-modality alignment guard. + + Returns: + A merged ``CompactMask`` when all predictions that carry masks decoded + successfully, or ``None`` when no masks are present or the + mixed-modality guard triggers. + + Examples: + >>> _decode_compact_masks([], {}, 1080, 1920, 5) is None + True + """ + coco_compact_map: dict[int, CompactMask] = {} + if coco_rle_pending: + pending_indices = [t[0] for t in coco_rle_pending] + pending_rles = [t[1] for t in coco_rle_pending] + pending_xyxy = np.array([t[2] for t in coco_rle_pending], dtype=np.float64) + try: + batch_cm = CompactMask.from_coco_rle( + pending_rles, pending_xyxy, (image_height, image_width) + ) + for local_idx, global_idx in enumerate(pending_indices): + coco_compact_map[global_idx] = batch_cm[local_idx : local_idx + 1] + except (ValueError, AssertionError, KeyError, TypeError, OverflowError) as exc: + logger.warning( + "Batch compact RLE decode failed (%s); retrying " + "per-prediction for fault isolation.", + exc, + ) + for xyxy_idx, rle_dict, bbox in coco_rle_pending: + try: + single_cm = CompactMask.from_coco_rle( + [rle_dict], + np.array([bbox], dtype=np.float64), + (image_height, image_width), + ) + coco_compact_map[xyxy_idx] = single_cm[0:1] + except ( + ValueError, + AssertionError, + KeyError, + TypeError, + OverflowError, + ) as per_exc: + logger.warning( + "Compact RLE decode failed for prediction at index %d; " + "dropping that mask. Reason: %s", + xyxy_idx, + per_exc, + ) + all_compact = {**coco_compact_map, **polygon_compact_map} + compact_parts: list[CompactMask] = [ + all_compact[i] for i in sorted(all_compact.keys()) + ] + if 0 < len(compact_parts) < n_predictions: + logger.warning( + "Mixed-modality compact batch: %d of %d predictions carry masks; " + "dropping all masks to preserve alignment with xyxy.", + len(compact_parts), + n_predictions, + ) + compact_parts = [] + return CompactMask.merge(compact_parts) if compact_parts else None + + +@overload +def process_roboflow_result( + roboflow_result: dict[str, Any], + *, + compact_masks: Literal[False] = False, +) -> tuple[ + npt.NDArray[np.floating], + npt.NDArray[np.floating], + npt.NDArray[np.integer], + npt.NDArray[np.bool_] | None, + npt.NDArray[np.integer] | None, + _DetectionDataType, +]: ... + + +@overload +def process_roboflow_result( + roboflow_result: dict[str, Any], + *, + compact_masks: Literal[True], +) -> tuple[ + npt.NDArray[np.floating], + npt.NDArray[np.floating], + npt.NDArray[np.integer], + CompactMask | None, + npt.NDArray[np.integer] | None, + _DetectionDataType, +]: ... + + +def process_roboflow_result( + roboflow_result: dict[str, Any], + *, + compact_masks: bool = False, +) -> tuple[ + npt.NDArray[np.floating], + npt.NDArray[np.floating], + npt.NDArray[np.integer], + npt.NDArray[np.bool_] | CompactMask | None, + npt.NDArray[np.integer] | None, + _DetectionDataType, +]: + """Parse a Roboflow API or Inference package result into detection arrays. + + The returned ``data`` dict always contains ``CLASS_NAME_DATA_FIELD`` as a + string-dtype NumPy array. When ``predictions`` is empty, the array has + shape ``(0,)`` with ``dtype=str``, preserving dtype contracts for callers + that mix empty and non-empty results. + + Args: + roboflow_result: Raw dict from the Roboflow REST API or the Inference + package (after ``.dict()`` serialisation). + compact_masks: When ``True``, return segmentation masks as + :class:`~supervision.detection.compact_mask.CompactMask` instead of + a dense boolean array when mask data is present. + + Returns: + A 6-tuple of ``(xyxy, confidence, class_id, masks, tracker_ids, data)`` + where each array is aligned with the others. ``masks`` is ``None`` + when no predictions include mask data, or when only a subset do + (mixed-modality batch) โ€” in that case all masks are dropped to preserve + alignment with ``xyxy``. Note: a single malformed polygon prediction + (fewer than 3 points) in an otherwise fully-segmented batch causes all + masks to be dropped from the result; the detection itself is kept as a + box-only entry with a ``logger.warning``. When ``compact_masks=True`` + and masks are + present, ``masks`` is a :class:`CompactMask`; otherwise it is a dense + boolean array. ``tracker_ids`` is ``None`` when no predictions carry a + tracker ID, or when only a subset do (mixed batch) โ€” in that case all + tracker IDs are dropped to preserve alignment with ``xyxy``. + + Examples: + >>> from supervision.detection.utils.internal import process_roboflow_result + >>> result = {"predictions": [], "image": {"width": 100, "height": 100}} + >>> _, _, _, _, _, data = process_roboflow_result(result) + >>> data["class_name"].dtype.kind + 'U' + """ + if not roboflow_result["predictions"]: + return ( + np.empty((0, 4), dtype=np.float64), + np.empty(0, dtype=np.float64), + np.empty(0, dtype=np.int64), + None, + None, + {CLASS_NAME_DATA_FIELD: np.empty(0, dtype=str)}, + ) + + xyxy: list[list[float]] = [] + confidence: list[float] = [] + class_id: list[int] = [] + class_name: list[str] = [] + masks: list[npt.NDArray[np.bool_] | None] = [] + # Deferred COCO-RLE processing: collect validated pairs here, then after the + # loop attempt a single batched from_coco_rle call (happy path). If that batch + # call fails, fall back to decoding each pending prediction individually for + # fault isolation. + _coco_rle_pending: list[tuple[int, Any, list[float]]] = [] # (xyxy_idx, rle, bbox) + _polygon_compact_map: dict[int, CompactMask] = {} # xyxy_idx โ†’ CompactMask + tracker_ids: list[int | None] = [] + + image_width = int(roboflow_result["image"]["width"]) + image_height = int(roboflow_result["image"]["height"]) + + for prediction in roboflow_result["predictions"]: + x = prediction["x"] + y = prediction["y"] + width = prediction["width"] + height = prediction["height"] + x_min = x - width / 2 + y_min = y - height / 2 + x_max = x_min + width + y_max = y_min + height + + rle_data = _valid_rle_payload(prediction) + mask: npt.NDArray[np.bool_] | None = None + compact_mask: CompactMask | None = None + if rle_data is not None: + _dense, _pending = _resolve_rle_mask( + rle_data, image_height, image_width, compact_masks + ) + if _dense is None and _pending is None: + # Decode failed; treat as no-mask prediction. + rle_data = None + elif _pending is None: + # Dense result: compact_masks=False, or size-mismatch fallback. + mask = _dense + if compact_masks and mask is not None: + compact_mask = CompactMask.from_dense( + masks=mask[np.newaxis, ...], + xyxy=_full_image_xyxy(1, image_height, image_width), + image_shape=(image_height, image_width), + ) + # else: _pending set โ†’ deferred to batch; mask and compact_mask stay None + if rle_data is not None: + xyxy_idx = len(xyxy) + xyxy.append([x_min, y_min, x_max, y_max]) + class_id.append(prediction["class_id"]) + class_name.append(prediction["class"]) + confidence.append(prediction["confidence"]) + if compact_masks: + if compact_mask is not None: + # Fallback dense path (size mismatch): compact_mask always set. + _polygon_compact_map[xyxy_idx] = compact_mask + else: + # Main COCO-RLE path: (h, w) == image size; defer to batch. + # Pass the detector bbox so _rle_split_cols only walks + # crop columns, not the full image width. + _coco_rle_pending.append( + ( + xyxy_idx, + rle_data, + [x_min, y_min, x_max, y_max], + ) + ) + elif mask is not None: + masks.append(mask) + tracker_ids.append(prediction.get("tracker_id")) + elif "points" not in prediction: + xyxy.append([x_min, y_min, x_max, y_max]) + class_id.append(prediction["class_id"]) + class_name.append(prediction["class"]) + confidence.append(prediction["confidence"]) + masks.append(None) + tracker_ids.append(prediction.get("tracker_id")) + elif len(prediction["points"]) >= 3: + polygon = np.array( + [[point["x"], point["y"]] for point in prediction["points"]], dtype=int + ) + mask = polygon_to_mask( + polygon, resolution_wh=(image_width, image_height) + ).astype(bool) + xyxy_idx = len(xyxy) + xyxy.append([x_min, y_min, x_max, y_max]) + class_id.append(prediction["class_id"]) + class_name.append(prediction["class"]) + confidence.append(prediction["confidence"]) + if compact_masks: + _polygon_compact_map[xyxy_idx] = CompactMask.from_dense( + masks=mask[np.newaxis, ...], + xyxy=_full_image_xyxy(1, image_height, image_width), + image_shape=(image_height, image_width), + ) + else: + masks.append(mask) + tracker_ids.append(prediction.get("tracker_id")) + else: + logger.warning( + "Invalid polygon prediction with fewer than 3 points; falling back " + "to box-only detection." + ) + xyxy.append([x_min, y_min, x_max, y_max]) + class_id.append(prediction["class_id"]) + class_name.append(prediction["class"]) + confidence.append(prediction["confidence"]) + masks.append(None) + tracker_ids.append(prediction.get("tracker_id")) + + xyxy_arr: npt.NDArray[np.floating] = ( + np.array(xyxy, dtype=np.float64) if len(xyxy) > 0 else np.empty((0, 4)) + ) + confidence_arr: npt.NDArray[np.floating] = ( + np.array(confidence, dtype=np.float64) if len(confidence) > 0 else np.empty(0) + ) + class_id_arr: npt.NDArray[np.integer] = ( + np.array(class_id, dtype=np.int64) + if len(class_id) > 0 + else np.empty(0, dtype=np.int64) + ) + class_name_arr: npt.NDArray[np.str_] = ( + np.array(class_name) if len(class_name) > 0 else np.empty(0, dtype=str) + ) + masks_arr: npt.NDArray[np.bool_] | CompactMask | None + if compact_masks: + masks_arr = _decode_compact_masks( + _coco_rle_pending, + _polygon_compact_map, + image_height, + image_width, + len(xyxy), + ) + else: + masks_arr = _all_present_or_none(masks, "mask", dtype=bool) + tracker_id_arr: npt.NDArray[np.integer] | None = _all_present_or_none( + tracker_ids, "tracker_id", dtype=np.int64 + ) + data: _DetectionDataType = {CLASS_NAME_DATA_FIELD: class_name_arr} + + return ( + xyxy_arr, + confidence_arr, + class_id_arr, + masks_arr, + tracker_id_arr, + data, + ) + + +def is_data_equal( + data_a: _DetectionDataType, + data_b: _DetectionDataType, +) -> bool: + """ + Compares the data payloads of two Detections instances. + + Args: + data_a, data_b: The data payloads of the instances. + + Returns: + True if the data payloads are equal, False otherwise. + """ + return set(data_a.keys()) == set(data_b.keys()) and all( + np.array_equal(data_a[key], data_b[key]) for key in data_a + ) + + +def is_metadata_equal(metadata_a: _MetadataType, metadata_b: _MetadataType) -> bool: + """ + Compares the metadata payloads of two Detections instances. + + Args: + metadata_a, metadata_b: The metadata payloads of the instances. + + Returns: + True if the metadata payloads are equal, False otherwise. + """ + return set(metadata_a.keys()) == set(metadata_b.keys()) and all( + np.array_equal(metadata_a[key], metadata_b[key]) + if ( + isinstance(metadata_a[key], np.ndarray) + and isinstance(metadata_b[key], np.ndarray) + ) + else metadata_a[key] == metadata_b[key] + for key in metadata_a + ) + + +def merge_data( + data_list: list[_DetectionDataType], +) -> _DetectionDataType: + """ + Merges the data payloads of a list of Detections instances. + + Warning: Assumes that empty detections were filtered-out before passing data to + this function. + + Args: + data_list: The data payloads of the Detections instances. Each data payload + is a dictionary with the same keys, and the values are either lists or + npt.NDArray[np.generic]. + + Returns: + A single data payload containing the merged data, preserving the original data + types (list or npt.NDArray[np.generic]). + + Raises: + ValueError: If data values within a single object have different lengths or if + dictionaries have different keys. + """ + if not data_list: + return {} + + all_keys_sets = [set(data.keys()) for data in data_list] + if not all(keys_set == all_keys_sets[0] for keys_set in all_keys_sets): + raise ValueError("All data dictionaries must have the same keys to merge.") + + for data in data_list: + lengths = [len(value) for value in data.values()] + if len(set(lengths)) > 1: + raise ValueError( + "All data values within a single object must have equal length." + ) + + merged_data: dict[str, Any] = {key: [] for key in all_keys_sets[0]} + for data in data_list: + for key in data: + merged_data[key].append(data[key]) + + for key in merged_data: + if all(isinstance(item, list) for item in merged_data[key]): + merged_data[key] = list(chain.from_iterable(merged_data[key])) + elif all(isinstance(item, np.ndarray) for item in merged_data[key]): + ndim = merged_data[key][0].ndim + if ndim == 1: + merged_data[key] = np.hstack(merged_data[key]) + elif ndim > 1: + merged_data[key] = np.vstack(merged_data[key]) + else: + raise ValueError(f"Unexpected array dimension for key '{key}'.") + else: + raise ValueError( + f"Inconsistent data types for key '{key}'. Only np.ndarray and list " + f"types are allowed." + ) + + return cast(_DetectionDataType, merged_data) + + +def merge_metadata(metadata_list: list[_MetadataType]) -> _MetadataType: + """ + Merge metadata from a list of metadata dictionaries. + + This function combines the metadata dictionaries. If a key appears in more than one + dictionary, the values must be identical for the merge to succeed. + + Warning: Assumes that empty detections were filtered-out before passing metadata to + this function. + + Args: + metadata_list: A list of metadata dictionaries to merge. + + Returns: + A single merged metadata dictionary. + + Raises: + ValueError: If there are conflicting values for the same key or if + dictionaries have different keys. + """ + if not metadata_list: + return {} + + all_keys_sets = [set(metadata.keys()) for metadata in metadata_list] + if not all(keys_set == all_keys_sets[0] for keys_set in all_keys_sets): + raise ValueError("All metadata dictionaries must have the same keys to merge.") + + merged_metadata: _MetadataType = {} + for metadata in metadata_list: + for key, value in metadata.items(): + if key not in merged_metadata: + merged_metadata[key] = value + continue + + other_value = merged_metadata[key] + if isinstance(value, np.ndarray) and isinstance(other_value, np.ndarray): + if not np.array_equal(merged_metadata[key], value): + raise ValueError( + f"Conflicting metadata for key: '{key}': " + f"{type(value)}, {type(other_value)}." + ) + elif isinstance(value, np.ndarray) or isinstance(other_value, np.ndarray): + # Since [] == np.array([]). + raise ValueError( + f"Conflicting metadata for key: '{key}': " + f"{type(value)}, {type(other_value)}." + ) + else: + if merged_metadata[key] != value: + raise ValueError(f"Conflicting metadata for key: '{key}'.") + + return merged_metadata + + +def get_data_item( + data: _DetectionDataType, + index: int | slice | list[int] | npt.NDArray[np.integer | np.bool_], +) -> _DetectionDataType: + """ + Retrieve a subset of the data dictionary based on the given index. + + Args: + data: The data dictionary of the Detections object. + index: The index or indices specifying the subset to retrieve. + + Returns: + A subset of the data dictionary corresponding to the specified index. + """ + subset_data: _DetectionDataType = {} + for key, value in data.items(): + if isinstance(value, np.ndarray): + subset_data[key] = value[index] + elif isinstance(value, list): + if isinstance(index, slice): + subset_data[key] = value[index] + elif isinstance(index, list): + subset_data[key] = [value[i] for i in index] + elif isinstance(index, np.ndarray): + if index.dtype == bool: + subset_data[key] = [ + value[i] for i, index_value in enumerate(index) if index_value + ] + else: + subset_data[key] = [value[i] for i in index] + elif isinstance(index, int): + subset_data[key] = [value[index]] + else: + raise TypeError(f"Unsupported index type: {type(index)}") + else: + raise TypeError(f"Unsupported data type for key '{key}': {type(value)}") + + return subset_data + + +def cross_product( + anchors: npt.NDArray[np.number], vector: Vector +) -> npt.NDArray[np.number]: + """Get signed z-component of cross product (2-D determinant) per anchor. + + Replaces the deprecated `np.cross` 2-D path (NumPy 2.0) with an explicit + determinant: ``a[..., 0] * b[..., 1] - a[..., 1] * b[..., 0]``. + + Args: + anchors: Array of anchors of shape (number of anchors, detections, 2). + vector: Vector to calculate cross product with. + + Returns: + Array of signed cross-product values, shape (number of anchors, + detections). Positive = anchor is to the left of the vector direction; + negative = to the right; zero = on the line. + + Examples: + >>> import numpy as np + >>> from supervision.geometry.core import Point, Vector + >>> anchors = np.array([[[10.0, 5.0]], [[20.0, 5.0]]]) + >>> vector = Vector(start=Point(0, 0), end=Point(1, 0)) + >>> cross_product(anchors, vector) + array([[5.], + [5.]]) + """ + vector_at_zero = np.array( + [ + vector.end.x - vector.start.x, + vector.end.y - vector.start.y, + ] + ) + vector_start = np.array([vector.start.x, vector.start.y]) + diff = anchors - vector_start + return cast( + npt.NDArray[np.number], + vector_at_zero[0] * diff[..., 1] - vector_at_zero[1] * diff[..., 0], + ) diff --git a/src/supervision/detection/utils/iou_and_nms.py b/src/supervision/detection/utils/iou_and_nms.py new file mode 100644 index 0000000..0504865 --- /dev/null +++ b/src/supervision/detection/utils/iou_and_nms.py @@ -0,0 +1,1606 @@ +from __future__ import annotations + +import warnings +from collections.abc import Callable, Sequence +from enum import Enum +from typing import Any, cast + +import cv2 +import numpy as np +import numpy.typing as npt + +from supervision.detection.compact_mask import CompactMask +from supervision.detection.utils.converters import mask_to_xyxy +from supervision.utils.internal import warn_deprecated + + +class OverlapFilter(Enum): + """ + Enum specifying the strategy for filtering overlapping detections. + + Attributes: + NONE: Do not filter detections based on overlap. + NON_MAX_SUPPRESSION: Filter detections using non-max suppression. This means, + detections that overlap by more than a set threshold will be discarded, + except for the one with the highest confidence. + NON_MAX_MERGE: Merge detections with non-max merging. This means, + detections that overlap by more than a set threshold will be merged + into a single detection. + """ + + NONE = "none" + NON_MAX_SUPPRESSION = "non_max_suppression" + NON_MAX_MERGE = "non_max_merge" + + @classmethod + def list(cls) -> list[str]: + return list(map(lambda member: member.value, cls)) + + @classmethod + def from_value(cls, value: OverlapFilter | str) -> OverlapFilter: + if isinstance(value, cls): + return value + if isinstance(value, str): + value = value.lower() + try: + return cls(value) + except ValueError: + raise ValueError(f"Invalid value: {value}. Must be one of {cls.list()}") + raise ValueError( + f"Invalid value type: {type(value)}. Must be an instance of " + f"{cls.__name__} or str." + ) + + +class OverlapMetric(Enum): + """ + Enum specifying the metric for measuring overlap between detections. + + Attributes: + IOU: Intersection over Union. A region-overlap metric that compares + two shapes (usually bounding boxes or masks) by normalising the + shared area with the area of their union. + IOS: Intersection over Smaller, a region-overlap metric that compares + two shapes (usually bounding boxes or masks) by normalising the + shared area with the smaller of the two shapes. + """ + + IOU = "IOU" + IOS = "IOS" + + @classmethod + def list(cls) -> list[str]: + return list(map(lambda member: member.value, cls)) + + @classmethod + def from_value(cls, value: OverlapMetric | str) -> OverlapMetric: + if isinstance(value, cls): + return value + if isinstance(value, str): + value = value.upper() + try: + return cls(value) + except ValueError: + raise ValueError(f"Invalid value: {value}. Must be one of {cls.list()}") + raise ValueError( + f"Invalid value type: {type(value)}. Must be an instance of " + f"{cls.__name__} or str." + ) + + +def _validate_iou_threshold(iou_threshold: float) -> None: + """Raise `ValueError` when an IoU threshold falls outside `[0, 1]`.""" + if not 0 <= iou_threshold <= 1: + raise ValueError( + "Value of `iou_threshold` must be in the closed range from 0 to 1, " + f"{iou_threshold} given." + ) + + +def box_iou( + box_true: list[float] | npt.NDArray[np.floating], + box_detection: list[float] | npt.NDArray[np.floating], + overlap_metric: OverlapMetric | str = OverlapMetric.IOU, +) -> float: + """ + Compute overlap metric between two bounding boxes. + + Supports standard IOU (intersection-over-union) and IOS + (intersection-over-smaller-area) metrics. Returns the overlap value in range + `[0, 1]`. + + Args: + box_true: Ground truth box in format + `(x_min, y_min, x_max, y_max)`. + box_detection: Detected box in format + `(x_min, y_min, x_max, y_max)`. + overlap_metric: Overlap type. + Use `OverlapMetric.IOU` for IOU or + `OverlapMetric.IOS` for IOS. Defaults to `OverlapMetric.IOU`. + + Returns: + Overlap value between boxes in `[0, 1]`. + + Raises: + ValueError: If `overlap_metric` is not IOU or IOS. + + Examples: + ```pycon + >>> import supervision as sv + >>> box_true = [100, 100, 200, 200] + >>> box_detection = [150, 150, 250, 250] + >>> sv.box_iou(box_true, box_detection, overlap_metric=sv.OverlapMetric.IOU) + 0.142857... + >>> sv.box_iou(box_true, box_detection, overlap_metric=sv.OverlapMetric.IOS) + 0.25 + + ``` + """ + overlap_metric = OverlapMetric.from_value(overlap_metric) + x_min_true, y_min_true, x_max_true, y_max_true = np.array(box_true) + x_min_det, y_min_det, x_max_det, y_max_det = np.array(box_detection) + + x_min_inter = max(x_min_true, x_min_det) + y_min_inter = max(y_min_true, y_min_det) + x_max_inter = min(x_max_true, x_max_det) + y_max_inter = min(y_max_true, y_max_det) + + inter_w = max(0.0, x_max_inter - x_min_inter) + inter_h = max(0.0, y_max_inter - y_min_inter) + + area_inter = inter_w * inter_h + + area_true = (x_max_true - x_min_true) * (y_max_true - y_min_true) + area_det = (x_max_det - x_min_det) * (y_max_det - y_min_det) + + if overlap_metric == OverlapMetric.IOU: + area_norm = area_true + area_det - area_inter + elif overlap_metric == OverlapMetric.IOS: + area_norm = min(area_true, area_det) + else: + raise ValueError( + f"overlap_metric {overlap_metric} is not supported, " + "only 'IOU' and 'IOS' are supported" + ) + + if area_norm <= 0.0: + return 0.0 + + return float(area_inter / area_norm) + + +def box_iou_batch( + boxes_true: npt.NDArray[np.number], + boxes_detection: npt.NDArray[np.number], + overlap_metric: OverlapMetric | str = OverlapMetric.IOU, +) -> npt.NDArray[np.float32]: + """ + Compute pairwise overlap scores between batches of bounding boxes. + + Supports standard IOU (intersection-over-union) and IOS + (intersection-over-smaller-area) metrics for all `boxes_true` and + `boxes_detection` pairs. Returns a matrix of overlap values in range + `[0, 1]`, matching each box from the first batch to each from the second. + + Args: + boxes_true: Array of reference boxes in + shape `(N, 4)` as `(x_min, y_min, x_max, y_max)`. + boxes_detection: Array of detected boxes in + shape `(M, 4)` as `(x_min, y_min, x_max, y_max)`. + overlap_metric: Overlap type. + Use `OverlapMetric.IOU` for intersection-over-union, + `OverlapMetric.IOS` for intersection-over-smaller-area. + Defaults to `OverlapMetric.IOU`. + + Returns: + Overlap matrix of shape `(N, M)`, where entry + `[i, j]` is the overlap between `boxes_true[i]` and + `boxes_detection[j]`. + + Raises: + ValueError: If `overlap_metric` is not IOU or IOS. + + Examples: + ```pycon + >>> import numpy as np + >>> import supervision as sv + >>> boxes_true = np.array([ + ... [100, 100, 200, 200], + ... [300, 300, 400, 400] + ... ]) + >>> boxes_detection = np.array([ + ... [150, 150, 250, 250], + ... [320, 320, 420, 420] + ... ]) + >>> sv.box_iou_batch( + ... boxes_true, boxes_detection, overlap_metric=sv.OverlapMetric.IOU + ... ) + array([[0.14285..., 0. ], + [0. , 0.47058...]], dtype=float32) + >>> sv.box_iou_batch( + ... boxes_true, boxes_detection, overlap_metric=sv.OverlapMetric.IOS + ... ) + array([[0.25, 0. ], + [0. , 0.64]], dtype=float32) + + ``` + """ + overlap_metric = OverlapMetric.from_value(overlap_metric) + # Upcast the corners to float64 right after unpacking so every subtraction + # and multiplication below runs in float64. This prevents integer-dtype + # overflow: an int32 box area such as 50000 * 50000 = 2.5e9 wraps to a + # negative value in int32 before any later cast could run, yielding wrong + # (often zero) IoU. Upcasting here also gives full float64 precision to + # float64/int64 callers. It does NOT recover precision already lost when a + # caller stores coordinates as float32 upstream, because that float32 + # rounding happens before this function is ever called. The final matrix is + # cast back to float32 to preserve the public return-type contract. + x_min_true, y_min_true, x_max_true, y_max_true = boxes_true.T.astype(np.float64) + x_min_det, y_min_det, x_max_det, y_max_det = boxes_detection.T.astype(np.float64) + count_true, count_det = boxes_true.shape[0], boxes_detection.shape[0] + + if count_true == 0 or count_det == 0: + return cast( + npt.NDArray[np.float32], np.empty((count_true, count_det), dtype=np.float32) + ) + + x_min_inter = np.empty((count_true, count_det), dtype=np.float64) + x_max_inter = np.empty_like(x_min_inter) + y_min_inter = np.empty_like(x_min_inter) + y_max_inter = np.empty_like(x_min_inter) + + np.maximum(x_min_true[:, None], x_min_det[None, :], out=x_min_inter) + np.minimum(x_max_true[:, None], x_max_det[None, :], out=x_max_inter) + np.maximum(y_min_true[:, None], y_min_det[None, :], out=y_min_inter) + np.minimum(y_max_true[:, None], y_max_det[None, :], out=y_max_inter) + + # we reuse x_max_inter and y_max_inter to store inter_w and inter_h + np.subtract(x_max_inter, x_min_inter, out=x_max_inter) # inter_w + np.subtract(y_max_inter, y_min_inter, out=y_max_inter) # inter_h + np.clip(x_max_inter, 0.0, None, out=x_max_inter) + np.clip(y_max_inter, 0.0, None, out=y_max_inter) + + area_inter = x_max_inter * y_max_inter # inter_w * inter_h + + area_true = (x_max_true - x_min_true) * (y_max_true - y_min_true) + area_det = (x_max_det - x_min_det) * (y_max_det - y_min_det) + + if overlap_metric == OverlapMetric.IOU: + area_norm = area_true[:, None] + area_det[None, :] - area_inter + elif overlap_metric == OverlapMetric.IOS: + area_norm = np.minimum(area_true[:, None], area_det[None, :]) + else: + raise ValueError( + f"overlap_metric {overlap_metric} is not supported, " + "only 'IOU' and 'IOS' are supported" + ) + + out: npt.NDArray[np.float32] = np.zeros_like(area_inter, dtype=np.float32) + np.divide(area_inter, area_norm, out=out, where=area_norm > 0) + return out + + +def box_iou_batch_with_jaccard( + boxes_true: Sequence[Sequence[float]], + boxes_detection: Sequence[Sequence[float]], + is_crowd: Sequence[bool], +) -> npt.NDArray[np.float64]: + """ + Calculate the intersection over union (IoU) between detection bounding boxes (dt) + and ground-truth bounding boxes (gt). + Reference: https://github.com/rafaelpadilla/review_object_detection_metrics + + Args: + boxes_true: Sequence of ground-truth bounding boxes in the + format [x, y, width, height]. + boxes_detection: Sequence of detection bounding boxes in the + format [x, y, width, height]. + is_crowd: Sequence indicating if each ground-truth bounding box + is a crowd region or not. + + Note: + This function expects bounding boxes in ``[x, y, width, height]`` format + (COCO convention). All other batch IoU functions in this module use + ``[x_min, y_min, x_max, y_max]``. + + NaN coordinates propagate silently: if any box value is ``NaN``, the + corresponding IoU values will be ``NaN``. + + Returns: + Array of IoU values of shape ``(len(boxes_detection), len(boxes_true))``, + where row ``i`` contains the IoU of detection ``i`` against all ground-truth + boxes, and column ``j`` contains the IoU of all detections against ground-truth + box ``j``. + + Examples: + ```pycon + >>> import numpy as np + >>> import supervision as sv + >>> boxes_true = [ + ... [10, 20, 30, 40], # x, y, w, h + ... [15, 25, 35, 45] + ... ] + >>> boxes_detection = [ + ... [12, 22, 28, 38], + ... [16, 26, 36, 46] + ... ] + >>> is_crowd = [False, False] + >>> ious = sv.box_iou_batch_with_jaccard( + ... boxes_true=boxes_true, + ... boxes_detection=boxes_detection, + ... is_crowd=is_crowd + ... ) + >>> ious # doctest: +ELLIPSIS + array([[0.886..., 0.496...], + [0.4 ..., 0.862...]]) + + ``` + """ + if len(is_crowd) != len(boxes_true): + raise ValueError( + f"`is_crowd` length ({len(is_crowd)}) must match " + f"`boxes_true` length ({len(boxes_true)})." + ) + if len(boxes_detection) == 0 or len(boxes_true) == 0: + return np.empty((len(boxes_detection), len(boxes_true)), dtype=np.float64) + + # Smallest number to avoid division by zero. + eps = np.spacing(1) + gt = np.asarray(boxes_true, dtype=np.float64) + dt = np.asarray(boxes_detection, dtype=np.float64) + crowd = np.asarray(is_crowd, dtype=bool) + + # Boxes are [x, y, w, h]. Build the far corners as `x2 = x + w` (rather than + # reusing `w`) so that the area/intersection arithmetic is bit-identical to + # the per-pair reference it replaces. + gt_x2, gt_y2 = gt[:, 0] + gt[:, 2], gt[:, 1] + gt[:, 3] + dt_x2, dt_y2 = dt[:, 0] + dt[:, 2], dt[:, 1] + dt[:, 3] + + # Pairwise intersection: rows index detections, columns index ground truth. + inter_x1 = np.maximum(dt[:, 0][:, None], gt[:, 0][None, :]) + inter_y1 = np.maximum(dt[:, 1][:, None], gt[:, 1][None, :]) + inter_x2 = np.minimum(dt_x2[:, None], gt_x2[None, :]) + inter_y2 = np.minimum(dt_y2[:, None], gt_y2[None, :]) + area_inter = np.maximum(inter_x2 - inter_x1, 0.0) * np.maximum( + inter_y2 - inter_y1, 0.0 + ) + + area_det = np.maximum(dt_x2 - dt[:, 0], 0.0) * np.maximum(dt_y2 - dt[:, 1], 0.0) + area_gt = np.maximum(gt_x2 - gt[:, 0], 0.0) * np.maximum(gt_y2 - gt[:, 1], 0.0) + + # For a crowd ground truth a detection may match any subregion, so its union + # collapses to the detection area; otherwise use the standard box union. + iou: npt.NDArray[np.float64] = np.empty((len(dt), len(gt)), dtype=np.float64) + if not np.any(crowd): + area_norm = area_det[:, None] + area_gt[None, :] - area_inter + eps + else: + area_norm = np.where( + crowd[None, :], + area_det[:, None] + eps, + area_det[:, None] + area_gt[None, :] - area_inter + eps, + ) + np.divide(area_inter, area_norm, out=iou) + return iou + + +def _polygon_areas(polygons: npt.NDArray[np.floating]) -> npt.NDArray[np.floating]: + """Compute the area of each oriented-box polygon using the shoelace formula. + + Args: + polygons: ``(N, 4, 2)`` array of polygon corners. + + Returns: + ``(N,)`` array of polygon areas. + """ + x = polygons[:, :, 0] + y = polygons[:, :, 1] + cross = x * np.roll(y, -1, axis=1) - np.roll(x, -1, axis=1) * y + return cast(npt.NDArray[np.floating], 0.5 * np.abs(cross.sum(axis=1))) + + +def _aabb_envelopes(polygons: npt.NDArray[np.floating]) -> npt.NDArray[np.floating]: + """Compute the axis-aligned bounding envelope of each oriented box. + + Args: + polygons: ``(N, 4, 2)`` array of polygon corners. + + Returns: + ``(N, 4)`` array of ``(x_min, y_min, x_max, y_max)`` envelopes. + """ + xs = polygons[:, :, 0] + ys = polygons[:, :, 1] + return np.stack( + [xs.min(axis=1), ys.min(axis=1), xs.max(axis=1), ys.max(axis=1)], axis=1 + ) + + +def _overlapping_envelope_pairs( + envelopes_true: npt.NDArray[np.floating], + envelopes_detection: npt.NDArray[np.floating], +) -> tuple[npt.NDArray[np.intp], npt.NDArray[np.intp]]: + """Return index pairs ``(i, j)`` whose axis-aligned envelopes overlap. + + Uses a fused boolean evaluation to halve peak transient memory compared to + named-intermediate form (4 separate NxM float64 arrays vs 1 boolean array). + + Note: + This gate is a correctness guarantee, not an approximation: if two + axis-aligned bounding boxes do not overlap, the convex polygons they + contain cannot overlap either. + + Args: + envelopes_true: ``(N, 4)`` array of ``(x_min, y_min, x_max, y_max)`` + envelopes for the ground-truth boxes. + envelopes_detection: ``(M, 4)`` array of ``(x_min, y_min, x_max, y_max)`` + envelopes for the detection boxes. + + Returns: + A pair of 1-D index arrays ``(rows, cols)`` identifying the overlapping + pairs. + """ + et = envelopes_true[:, None, :] + ed = envelopes_detection[None, :, :] + overlap = ( + np.minimum(et[..., 2], ed[..., 2]) > np.maximum(et[..., 0], ed[..., 0]) + ) & (np.minimum(et[..., 3], ed[..., 3]) > np.maximum(et[..., 1], ed[..., 1])) + return cast(tuple[npt.NDArray[np.intp], npt.NDArray[np.intp]], np.nonzero(overlap)) + + +def oriented_box_iou_batch( + boxes_true: npt.NDArray[np.number], + boxes_detection: npt.NDArray[np.number], + overlap_metric: OverlapMetric = OverlapMetric.IOU, +) -> npt.NDArray[np.floating]: + """ + Compute pairwise overlap scores between two sets of oriented bounding boxes + using the configured `overlap_metric`. + + Overlap areas are computed exactly via convex-polygon intersection, gated by + a cheap axis-aligned envelope pre-filter โ€” no rasterization is involved, so + the result is exact (free of pixel-quantization error) and independent of the + coordinate magnitudes. + + `boxes_true` and `boxes_detection` are expected to be in + `((x1, y1), (x2, y2), (x3, y3), (x4, y4))` format. + + Note: + Inputs must be **convex** quads with finite coordinates. Self-intersecting + or non-convex polygons produce undefined results via + ``cv2.intersectConvexConvex``. NaN or Inf coordinates propagate silently + as ``0.0`` โ€” validate inputs before calling if needed. + + When ``boxes_true is boxes_detection`` (the same Python object, not just + equal values), the function computes only the upper triangle of the + matrix and mirrors it. This optimization is used automatically by the + NMS/NMM callers that pass the same array twice. A defensive ``.copy()`` + at the call site would disable the optimization silently โ€” see the + NMS caller comment for context. + + Args: + boxes_true: A `np.ndarray` representing ground-truth boxes. + `shape = (N, 4, 2)` where `N` is number of true objects. + Last axis convention: `[..., 0]` = x-coordinates, + `[..., 1]` = y-coordinates. + boxes_detection: A `np.ndarray` representing detection boxes. + `shape = (M, 4, 2)` where `M` is number of detected objects. + Last axis convention: `[..., 0]` = x-coordinates, + `[..., 1]` = y-coordinates. + overlap_metric: Metric used to compute the degree of overlap + between pairs of oriented boxes (e.g., IoU, IoS). + + Returns: + Overlap matrix of shape `(N, M)`, where entry `[i, j]` is the overlap + score between `boxes_true[i]` and `boxes_detection[j]`, in the range + `[0, 1]` under the configured :attr:`overlap_metric`. + + Raises: + ValueError: If ``boxes_true`` or ``boxes_detection`` is 3-D with inner + dimensions other than ``(4, 2)``. + ValueError: If ``boxes_true`` or ``boxes_detection`` is 2-D with a + column count other than 8. + ValueError: If ``boxes_true`` or ``boxes_detection`` is not 2-D or 3-D. + ValueError: If ``overlap_metric`` is not + :attr:`~supervision.config.OverlapMetric.IOU` or + :attr:`~supervision.config.OverlapMetric.IOS`. + + Examples: + >>> import numpy as np + >>> import supervision as sv + >>> a = np.array([[[0, 0], [2, 0], [2, 2], [0, 2]]], dtype=np.float32) + >>> b = np.array([[[1, 0], [3, 0], [3, 2], [1, 2]]], dtype=np.float32) + >>> sv.oriented_box_iou_batch(a, b) # doctest: +ELLIPSIS + array([[0.333...]]) + """ + + for name, arr in (("boxes_true", boxes_true), ("boxes_detection", boxes_detection)): + if arr.ndim == 3 and arr.shape[1:] != (4, 2): + raise ValueError( + f"`{name}` has shape {arr.shape}; expected (N, 4, 2) " + f"โ€” each box must have exactly 4 corners with (x, y) coordinates." + ) + elif arr.ndim == 2 and arr.shape[1] != 8: + raise ValueError( + f"`{name}` has shape {arr.shape}; expected (N, 8) for flat " + f"YOLO format or (N, 4, 2) for corner format." + ) + elif arr.ndim not in (2, 3): + raise ValueError( + f"`{name}` must be 2-D (N, 8) or 3-D (N, 4, 2), got shape {arr.shape}." + ) + + if overlap_metric == OverlapMetric.IOU: + normalize_by_union = True + elif overlap_metric == OverlapMetric.IOS: + normalize_by_union = False + else: + raise ValueError( + f"overlap_metric {overlap_metric} is not supported, " + "only 'IOU' and 'IOS' are supported" + ) + + # Capture identity before reshape: NMS / NMM pass the same array twice, so + # the matrix is symmetric and we can compute only its upper triangle. + is_self_comparison = boxes_true is boxes_detection + boxes_true = cast( + npt.NDArray[np.floating], boxes_true.reshape(-1, 4, 2).astype(np.float64) + ) + boxes_detection = cast( + npt.NDArray[np.floating], + boxes_detection.reshape(-1, 4, 2).astype(np.float64), + ) + + n, m = len(boxes_true), len(boxes_detection) + if n == 0 or m == 0: + return np.zeros((n, m), dtype=np.float64) + + areas_true = _polygon_areas(boxes_true) + areas_detection = _polygon_areas(boxes_detection) + + envelopes_true = _aabb_envelopes(boxes_true) + envelopes_detection = ( + envelopes_true if is_self_comparison else _aabb_envelopes(boxes_detection) + ) + rows, cols = _overlapping_envelope_pairs(envelopes_true, envelopes_detection) + if is_self_comparison: + upper = rows <= cols + rows, cols = rows[upper], cols[upper] + + polygons_true = [box.astype(np.float32) for box in boxes_true] + polygons_detection = [box.astype(np.float32) for box in boxes_detection] + + ious: npt.NDArray[np.float64] = np.zeros((n, m), dtype=np.float64) + for i, j in zip(rows, cols): + intersection, _ = cv2.intersectConvexConvex( + polygons_true[i], polygons_detection[j] + ) + if intersection <= 0: + continue + denominator = ( + areas_true[i] + areas_detection[j] - intersection + if normalize_by_union + else min(areas_true[i], areas_detection[j]) + ) + if denominator > 0: + score = intersection / denominator + ious[i, j] = score + if is_self_comparison: + ious[j, i] = score + + # DO NOT remove this clip. cv2.intersectConvexConvex computes in float32 + # internally while polygon areas are computed in float64; the intersection + # area can exceed the float64 area by ~25 ULP (~1e-7), producing raw IoU + # or IoS values microscopically above 1.0 for identical boxes. The clip is + # load-bearing, not defensive duplication. + return cast(npt.NDArray[np.floating], np.clip(ious, 0.0, 1.0)) + + +def compact_mask_iou_batch( + masks_true: Any, + masks_detection: Any, + overlap_metric: OverlapMetric = OverlapMetric.IOU, +) -> npt.NDArray[np.floating]: + """Compute pairwise overlap between two :class:`CompactMask` collections. + + Avoids materialising full ``(N, H, W)`` arrays by: + + 1. Vectorised bounding-box pre-filter โ€” pairs whose boxes do not overlap + get IoU = 0 without any mask decoding. + 2. Sub-crop decoding โ€” for overlapping pairs, only the intersection region + of each crop is decoded and compared. + 3. Crop caching โ€” each individual crop is decoded at most once even when it + participates in many pairs. + + The result is numerically identical to running the dense + :func:`mask_iou_batch` on ``np.asarray(masks_true)`` / + ``np.asarray(masks_detection)``. + + Args: + masks_true: :class:`~supervision.detection.compact_mask.CompactMask` + holding the ground-truth masks. + masks_detection: :class:`~supervision.detection.compact_mask.CompactMask` + holding the detection masks. + overlap_metric: :class:`OverlapMetric` โ€” ``IOU`` or ``IOS``. + + Returns: + Float array of shape ``(N1, N2)`` with pairwise overlap values. + """ + n1: int = len(masks_true) + n2: int = len(masks_detection) + result: npt.NDArray[np.floating] = np.zeros((n1, n2), dtype=float) + + if n1 == 0 or n2 == 0: + return result + + areas_a: npt.NDArray[np.int64] = masks_true.area + areas_b: npt.NDArray[np.int64] = masks_detection.area + + # Inclusive per-mask bounding boxes obtained from public accessors. + # bbox_xyxy: (N, 4) โ†’ (x1, y1, x2, y2) + bboxes_a: npt.NDArray[np.int32] = masks_true.bbox_xyxy.astype(np.int32) + x1a: npt.NDArray[np.int32] = bboxes_a[:, 0] + y1a: npt.NDArray[np.int32] = bboxes_a[:, 1] + x2a: npt.NDArray[np.int32] = bboxes_a[:, 2] + y2a: npt.NDArray[np.int32] = bboxes_a[:, 3] + + bboxes_b: npt.NDArray[np.int32] = masks_detection.bbox_xyxy.astype(np.int32) + x1b: npt.NDArray[np.int32] = bboxes_b[:, 0] + y1b: npt.NDArray[np.int32] = bboxes_b[:, 1] + x2b: npt.NDArray[np.int32] = bboxes_b[:, 2] + y2b: npt.NDArray[np.int32] = bboxes_b[:, 3] + + # Pairwise intersection bounding box โ€” shape (N1, N2). + ix1: npt.NDArray[np.int32] = np.maximum(x1a[:, None], x1b[None, :]) + iy1: npt.NDArray[np.int32] = np.maximum(y1a[:, None], y1b[None, :]) + ix2: npt.NDArray[np.int32] = np.minimum(x2a[:, None], x2b[None, :]) + iy2: npt.NDArray[np.int32] = np.minimum(y2a[:, None], y2b[None, :]) + bbox_overlap: npt.NDArray[np.bool_] = (ix1 <= ix2) & (iy1 <= iy2) + + # Decode each crop at most once, even if it participates in many pairs. + crops_a: dict[int, npt.NDArray[np.bool_]] = {} + crops_b: dict[int, npt.NDArray[np.bool_]] = {} + + for idx_pair in np.argwhere(bbox_overlap): + idx_a, idx_b = int(idx_pair[0]), int(idx_pair[1]) + + if idx_a not in crops_a: + crops_a[idx_a] = masks_true.crop(idx_a) + if idx_b not in crops_b: + crops_b[idx_b] = masks_detection.crop(idx_b) + + lx1 = int(ix1[idx_a, idx_b]) + ly1 = int(iy1[idx_a, idx_b]) + lx2 = int(ix2[idx_a, idx_b]) + ly2 = int(iy2[idx_a, idx_b]) + + ox_a, oy_a = int(x1a[idx_a]), int(y1a[idx_a]) + sub_a = crops_a[idx_a][ly1 - oy_a : ly2 - oy_a + 1, lx1 - ox_a : lx2 - ox_a + 1] + + ox_b, oy_b = int(x1b[idx_b]), int(y1b[idx_b]) + sub_b = crops_b[idx_b][ly1 - oy_b : ly2 - oy_b + 1, lx1 - ox_b : lx2 - ox_b + 1] + + inter = int(np.logical_and(sub_a, sub_b).sum()) + area_a_i = int(areas_a[idx_a]) + area_b_j = int(areas_b[idx_b]) + + if overlap_metric == OverlapMetric.IOU: + union = area_a_i + area_b_j - inter + result[idx_a, idx_b] = inter / union if union > 0 else 0.0 + elif overlap_metric == OverlapMetric.IOS: + small = min(area_a_i, area_b_j) + result[idx_a, idx_b] = inter / small if small > 0 else 0.0 + else: + raise ValueError( + f"overlap_metric {overlap_metric} is not supported, " + "only 'IOU' and 'IOS' are supported" + ) + + return result + + +def _mask_iou_batch_split( + masks_true: npt.NDArray[Any], + masks_detection: npt.NDArray[Any], + overlap_metric: OverlapMetric = OverlapMetric.IOU, +) -> npt.NDArray[np.floating]: + """ + Internal function. + Compute Intersection over Union (IoU) of two sets of masks - + `masks_true` and `masks_detection`. + + Args: + masks_true: 3D `np.ndarray` representing ground-truth masks. + masks_detection: 3D `np.ndarray` representing detection masks. + overlap_metric: Metric used to compute the degree of overlap + between pairs of masks (e.g., IoU, IoS). + + Returns: + Pairwise IoU of masks from `masks_true` and `masks_detection`. + """ + # The overlap of two binary masks is the dot product of their flattened + # pixels, so the whole (N, M) intersection matrix is a single matmul. + # float32 counts pixels exactly up to 2**24; for larger masks (beyond + # ~4096x4096) we promote to float64 so the counts stay exact. + pixels = int(np.prod(masks_true.shape[1:])) + count_dtype = np.float32 if pixels <= 2**24 else np.float64 + true_flat = cast( + npt.NDArray[np.floating], + masks_true.reshape(masks_true.shape[0], pixels).astype(count_dtype, copy=False), + ) + detection_flat = cast( + npt.NDArray[np.floating], + masks_detection.reshape(masks_detection.shape[0], pixels).astype( + count_dtype, copy=False + ), + ) + with np.errstate(divide="ignore", over="ignore", invalid="ignore"): + intersection_area: npt.NDArray[np.floating[Any]] = true_flat @ detection_flat.T + + masks_true_area = true_flat.sum(axis=1) + masks_detection_area = detection_flat.sum(axis=1) + + if overlap_metric == OverlapMetric.IOU: + union_area = masks_true_area[:, None] + masks_detection_area - intersection_area + ious = np.divide( + intersection_area, + union_area, + out=np.zeros_like(intersection_area, dtype=float), + where=union_area != 0, + ) + elif overlap_metric == OverlapMetric.IOS: + # ios = intersection_area / min(area1, area2) + small_area = np.minimum(masks_true_area[:, None], masks_detection_area) + ious = np.divide( + intersection_area, + small_area, + out=np.zeros_like(intersection_area, dtype=float), + where=small_area != 0, + ) + else: + raise ValueError( + f"overlap_metric {overlap_metric} is not supported, " + "only 'IOU' and 'IOS' are supported" + ) + + ious = np.nan_to_num(ious) + return cast(npt.NDArray[np.floating], ious) + + +def mask_iou_batch( + masks_true: npt.NDArray[Any] | CompactMask, + masks_detection: npt.NDArray[Any] | CompactMask, + overlap_metric: OverlapMetric = OverlapMetric.IOU, + memory_limit: int = 1024 * 5, +) -> npt.NDArray[np.floating]: + """ + Compute Intersection over Union (IoU) of two sets of masks - + `masks_true` and `masks_detection`. + + Accepts both dense ``(N, H, W)`` boolean arrays and + :class:`~supervision.detection.compact_mask.CompactMask` objects. + When both inputs are :class:`~supervision.detection.compact_mask.CompactMask`, + the computation uses :func:`compact_mask_iou_batch` to avoid materialising + full ``(N, H, W)`` arrays. + + Args: + masks_true: 3D `np.ndarray` representing ground-truth masks. + masks_detection: 3D `np.ndarray` representing detection masks. + overlap_metric: Metric used to compute the degree of overlap + between pairs of masks (e.g., IoU, IoS). + memory_limit: Memory limit in MB, default is 1024 * 5 MB (5GB). + Controls chunking of ``masks_true`` so that flattened detection + masks plus each chunk's buffers stay within this limit. A + ``UserWarning`` is raised when ``masks_detection`` alone + exceeds the limit, as chunking cannot reduce peak memory + below that floor. Ignored when both inputs are + :class:`~supervision.detection.compact_mask.CompactMask`. + + Returns: + Pairwise IoU of masks from `masks_true` and `masks_detection`. + + Raises: + ValueError: If ``masks_true`` or ``masks_detection`` are not 3D + ``(N, H, W)`` arrays, or if they do not share the same + spatial dimensions ``(H, W)``. + + Examples: + ```pycon + >>> import numpy as np + >>> import supervision as sv + >>> masks_true = np.zeros((1, 4, 4), dtype=bool) + >>> masks_true[:, :2, :2] = True + >>> masks_detection = np.zeros((1, 4, 4), dtype=bool) + >>> masks_detection[:, :3, :3] = True + >>> sv.mask_iou_batch(masks_true, masks_detection) + array([[0.44444445]]) + + ``` + """ + + if isinstance(masks_true, CompactMask) and isinstance(masks_detection, CompactMask): + return compact_mask_iou_batch(masks_true, masks_detection, overlap_metric) + + # Materialise any CompactMask that was passed alongside a dense array. + if isinstance(masks_true, CompactMask): + masks_true = np.asarray(masks_true) + if isinstance(masks_detection, CompactMask): + masks_detection = np.asarray(masks_detection) + + if masks_true.ndim != 3 or masks_detection.ndim != 3: + raise ValueError( + "masks_true and masks_detection must be 3D (N, H, W); got " + f"ndim={masks_true.ndim} and ndim={masks_detection.ndim}." + ) + if masks_true.shape[1:] != masks_detection.shape[1:]: + raise ValueError( + "masks_true and masks_detection must share the same (H, W); got " + f"{masks_true.shape[1:]} and {masks_detection.shape[1:]}." + ) + # A single pass already handles empty inputs and avoids np.vstack([]) below. + if masks_true.shape[0] == 0 or masks_detection.shape[0] == 0: + return _mask_iou_batch_split(masks_true, masks_detection, overlap_metric) + + # Peak memory of a single matmul pass: the flattened detection masks (shared + # across chunks) plus, per true-mask row, its flattened pixels and the three + # (N, M) matrices it touches (intersection, denominator and output). The + # previous (N, M, H, W) estimate overcounted by a factor of M and forced + # needless chunking now that the intersection is a matmul. + pixels = masks_true.shape[1] * masks_true.shape[2] + itemsize = 4 if pixels <= 2**24 else 8 + limit_bytes = memory_limit * 1024 * 1024 + detection_bytes = masks_detection.shape[0] * pixels * itemsize + per_true_row = pixels * itemsize + 3 * masks_detection.shape[0] * 8 + if detection_bytes > limit_bytes > 0: + warnings.warn( + f"detection masks ({detection_bytes // 1024 // 1024} MB) exceed " + f"memory_limit ({memory_limit} MB); chunking cannot reduce peak " + "memory below this floor.", + UserWarning, + stacklevel=2, + ) + if detection_bytes + masks_true.shape[0] * per_true_row <= limit_bytes: + return _mask_iou_batch_split(masks_true, masks_detection, overlap_metric) + + ious = [] + step = max((limit_bytes - detection_bytes) // per_true_row, 1) + for chunk_start in range(0, masks_true.shape[0], step): + ious.append( + _mask_iou_batch_split( + masks_true[chunk_start : chunk_start + step], + masks_detection, + overlap_metric, + ) + ) + + return cast(npt.NDArray[np.floating], np.vstack(ious)) + + +def mask_non_max_suppression( + predictions: npt.NDArray[np.floating], + masks: npt.NDArray[Any] | CompactMask, + iou_threshold: float = 0.5, + overlap_metric: OverlapMetric = OverlapMetric.IOU, + mask_dimension: int = 640, +) -> npt.NDArray[np.bool_]: + """ + Perform Non-Maximum Suppression (NMS) on segmentation predictions. + + IoU is computed exactly on the full-resolution masks for both dense and + :class:`~supervision.detection.compact_mask.CompactMask` inputs. The + ``mask_dimension`` parameter is kept for backward compatibility but is no + longer used โ€” dense masks are **not** resized before IoU computation. + + Args: + predictions: A 2D array of object detection predictions in + the format of `(x_min, y_min, x_max, y_max, score)` + or `(x_min, y_min, x_max, y_max, score, class)`. Shape: `(N, 5)` or + `(N, 6)`, where N is the number of predictions. + masks: A 3D array of binary masks corresponding to the predictions. + Shape: `(N, H, W)`, where N is the number of predictions, and H, W are the + dimensions of each mask. + iou_threshold: The intersection-over-union threshold + to use for non-maximum suppression. + overlap_metric: Metric used to compute the degree of overlap + between pairs of masks (e.g., IoU, IoS). + mask_dimension: Deprecated, no longer used. Kept for backward + compatibility. + + Returns: + A boolean array indicating which predictions to keep after + non-maximum suppression. + + Raises: + ValueError: If `iou_threshold` is not within the closed range + from `0` to `1`. + + Examples: + ```pycon + >>> import numpy as np + >>> import supervision as sv + >>> predictions = np.array([ + ... [0, 0, 4, 4, 0.9, 0], + ... [0, 0, 4, 4, 0.8, 0], + ... ]) + >>> masks = np.zeros((2, 4, 4), dtype=bool) + >>> masks[:, :2, :2] = True + >>> sv.mask_non_max_suppression(predictions, masks, iou_threshold=0.5) + array([ True, False]) + + ``` + """ + _validate_iou_threshold(iou_threshold) + rows, columns = predictions.shape + + if columns == 5: + predictions = np.c_[predictions, np.zeros(rows)] + + sort_index = predictions[:, 4].argsort()[::-1] + predictions = predictions[sort_index] + masks = masks[sort_index] + + ious = mask_iou_batch(masks, masks, overlap_metric) + categories = predictions[:, 5] + + keep = np.ones(rows, dtype=bool) + for row_idx in range(rows): + if keep[row_idx]: + condition = (ious[row_idx] > iou_threshold) & ( + categories[row_idx] == categories + ) + keep[row_idx + 1 :] = np.where( + condition[row_idx + 1 :], False, keep[row_idx + 1 :] + ) + + return cast(npt.NDArray[np.bool_], keep[sort_index.argsort()]) + + +def _prepare_predictions_for_nms( + predictions: npt.NDArray[np.floating], +) -> tuple[npt.NDArray[np.int_], npt.NDArray[np.floating], npt.NDArray[np.floating]]: + """Add an agnostic class column when missing, sort by descending score. + + Returns the score-descending sort index, the reordered predictions, and the + category vector for the loop callers to consume. + """ + rows, columns = predictions.shape + if columns == 5: + predictions = np.c_[predictions, np.zeros(rows)] + sort_index = np.flip(predictions[:, 4].argsort()) + predictions = predictions[sort_index] + categories = predictions[:, 5] + return sort_index, predictions, categories + + +def _nms_loop_from_iou_matrix( + ious: npt.NDArray[np.floating], + categories: npt.NDArray[np.floating], + iou_threshold: float, +) -> npt.NDArray[np.bool_]: + """Greedy NMS suppression loop given a precomputed pairwise IoU matrix. + + Assumes `ious` is square with row/column order matching `categories`. + Detections sharing a category whose IoU exceeds `iou_threshold` are dropped + in favour of the higher-confidence entry. + """ + rows = len(ious) + ious = ious - np.eye(rows) + keep: npt.NDArray[np.bool_] = np.ones(rows, dtype=bool) + for index, (iou, category) in enumerate(zip(ious, categories)): + if not keep[index]: + continue + condition = (iou > iou_threshold) & (categories == category) + keep = keep & ~condition + return keep + + +def box_non_max_suppression( + predictions: npt.NDArray[np.floating], + iou_threshold: float = 0.5, + overlap_metric: OverlapMetric = OverlapMetric.IOU, +) -> npt.NDArray[np.bool_]: + """ + Perform Non-Maximum Suppression (NMS) on object detection predictions. + + Args: + predictions: An array of object detection predictions in + the format of `(x_min, y_min, x_max, y_max, score)` + or `(x_min, y_min, x_max, y_max, score, class)`. + iou_threshold: The intersection-over-union threshold + to use for non-maximum suppression. + overlap_metric: Metric used to compute the degree of overlap + between pairs of boxes (e.g., IoU, IoS). + + Returns: + A boolean array indicating which predictions to keep after + non-maximum suppression. + + Raises: + ValueError: If `iou_threshold` is not within the closed range + from `0` to `1`. + + Examples: + ```pycon + >>> import numpy as np + >>> import supervision as sv + >>> predictions = np.array([ + ... [0, 0, 4, 4, 0.9, 0], + ... [0, 0, 4, 4, 0.8, 0], + ... ]) + >>> sv.box_non_max_suppression(predictions, iou_threshold=0.5) + array([ True, False]) + + ``` + """ + _validate_iou_threshold(iou_threshold) + sort_index, predictions, categories = _prepare_predictions_for_nms(predictions) + ious = box_iou_batch(predictions[:, :4], predictions[:, :4], overlap_metric) + keep = _nms_loop_from_iou_matrix(ious, categories, iou_threshold) + result: npt.NDArray[np.bool_] = keep[sort_index.argsort()] + return result + + +def _group_overlapping_masks( + predictions: npt.NDArray[np.floating], + masks: npt.NDArray[np.bool_], + iou_threshold: float = 0.5, + overlap_metric: OverlapMetric = OverlapMetric.IOU, +) -> list[list[int]]: + """ + Apply greedy version of non-maximum merging to avoid detecting too many + + Args: + predictions: An array of shape `(n, 5)` containing + the bounding boxes coordinates in format `[x1, y1, x2, y2]` + and the confidence scores. + masks: A 3D array of binary masks corresponding to + the predictions. + iou_threshold: The intersection-over-union threshold + to use for non-maximum suppression. Defaults to 0.5. + overlap_metric: Metric used to compute the degree of overlap + between pairs of masks (e.g., IoU, IoS). + + Returns: + Groups of prediction indices to be merged. + Each group may have 1 or more elements. + """ + merge_groups: list[list[int]] = [] + + scores = predictions[:, 4] + order = scores.argsort() + + while len(order) > 0: + idx = int(order[-1]) + + order = order[:-1] + if len(order) == 0: + merge_groups.append([idx]) + break + + merge_candidate = masks[idx][None, ...] + candidate_groups = [idx] + while len(order) > 0: + ious = mask_iou_batch(masks[order], merge_candidate, overlap_metric) + above_threshold: npt.NDArray[np.bool_] = ious.flatten() >= iou_threshold + if not above_threshold.any(): + break + above_idx = order[above_threshold] + merge_candidate = np.logical_or.reduce( + np.concatenate([masks[above_idx], merge_candidate]), + axis=0, + keepdims=True, + ) + candidate_groups.extend(np.flip(above_idx).tolist()) + order = order[~above_threshold] + + merge_groups.append(candidate_groups) + return merge_groups + + +def mask_non_max_merge( + predictions: npt.NDArray[np.floating], + masks: npt.NDArray[Any] | CompactMask, + iou_threshold: float = 0.5, + *args: Any, + overlap_metric: OverlapMetric = OverlapMetric.IOU, + mask_dimension: int = 640, +) -> list[list[int]]: + """ + Perform Non-Maximum Merging (NMM) on segmentation predictions. + + Args: + predictions: A 2D array of object detection predictions in + the format of `(x_min, y_min, x_max, y_max, score)` + or `(x_min, y_min, x_max, y_max, score, class)`. Shape: `(N, 5)` or + `(N, 6)`, where N is the number of predictions. + masks: A 3D array of binary masks corresponding to the predictions. + Shape: `(N, H, W)`, where N is the number of predictions, and H, W are the + dimensions of each mask. + iou_threshold: The intersection-over-union threshold + to use for non-maximum merging. + overlap_metric: Metric used to compute the degree of overlap + between pairs of masks (e.g., IoU, IoS). + mask_dimension: Deprecated in `0.30.0`, removed in `0.33.0`. No longer + used; the parameter is silently ignored. Passing `mask_dimension` + positionally emits a deprecation warning. + + Returns: + A list of groups of prediction indices. Each inner list contains + the indices of predictions whose masks overlap above `iou_threshold` + according to the chosen `overlap_metric`, and should be merged or + kept together as a single detection by non-maximum merging. + + Raises: + ValueError: If `iou_threshold` is not within the closed range + from `0` to `1`. + TypeError: If more than five positional arguments are passed. + + Examples: + ```pycon + >>> import numpy as np + >>> import supervision as sv + >>> predictions = np.array([ + ... [0, 0, 4, 4, 0.9, 0], + ... [0, 0, 4, 4, 0.8, 0], + ... ]) + >>> masks = np.zeros((2, 4, 4), dtype=bool) + >>> masks[:, :2, :2] = True + >>> sv.mask_non_max_merge(predictions, masks, iou_threshold=0.5) + [[0, 1]] + + ``` + """ + + _validate_iou_threshold(iou_threshold) + if len(args) > 2: + raise TypeError( + "mask_non_max_merge accepts at most five positional arguments. " + "Pass overlap_metric and mask_dimension by keyword." + ) + if args: + warn_deprecated( + "Passing `overlap_metric` or `mask_dimension` positionally to " + "`mask_non_max_merge` is deprecated in `0.30.0` and will be removed " + "in `0.33.0`. Pass them by keyword instead." + ) + first = args[0] + if isinstance(first, OverlapMetric): + overlap_metric = first + else: + mask_dimension = cast(int, first) + if len(args) == 2: + second = args[1] + if isinstance(first, OverlapMetric): + mask_dimension = cast(int, second) + else: + overlap_metric = cast(OverlapMetric, second) + + del mask_dimension + + def group_within(global_indices: npt.NDArray[np.int_]) -> list[list[int]]: + if isinstance(masks, CompactMask): + return _group_overlapping_masks_pairwise( + predictions[global_indices], + masks[global_indices], + iou_threshold, + overlap_metric, + ) + return _group_overlapping_masks( + predictions[global_indices], + masks[global_indices], + iou_threshold, + overlap_metric, + ) + + return _non_max_merge_per_category(predictions, group_within) + + +def _update_mask_candidate( + masks: npt.NDArray[Any] | CompactMask, + candidate: npt.NDArray[Any] | CompactMask, + above_idx: npt.NDArray[np.int_], +) -> npt.NDArray[Any] | CompactMask: + if isinstance(masks, CompactMask): + compact_candidate = cast(CompactMask, candidate) + union_mask = np.logical_or.reduce( + np.concatenate([masks[above_idx].to_dense(), compact_candidate.to_dense()]), + axis=0, + keepdims=True, + ) + return CompactMask.from_dense( + masks=union_mask, + xyxy=mask_to_xyxy(union_mask), + image_shape=masks.image_shape, + ) + dense_candidate = cast(npt.NDArray[Any], candidate) + dense_union: npt.NDArray[Any] = np.logical_or.reduce( + np.concatenate([masks[above_idx], dense_candidate]), + axis=0, + keepdims=True, + ) + return dense_union + + +def _greedy_nmm_via_mask_candidate( + predictions: npt.NDArray[np.floating], + masks: npt.NDArray[Any] | CompactMask, + iou_threshold: float = 0.5, + overlap_metric: OverlapMetric = OverlapMetric.IOU, +) -> list[list[int]]: + """Group masks by exact overlap while updating the merged candidate union.""" + merge_groups: list[list[int]] = [] + scores = predictions[:, 4] + order = scores.argsort() + while len(order) > 0: + idx = int(order[-1]) + order = order[:-1] + if len(order) == 0: + merge_groups.append([idx]) + break + candidate = masks[[idx]] + merge_group = [idx] + while len(order) > 0: + ious = mask_iou_batch(masks[order], candidate, overlap_metric).flatten() + above_threshold = ious >= iou_threshold + if not above_threshold.any(): + break + above_idx = order[above_threshold] + candidate = _update_mask_candidate(masks, candidate, above_idx) + merge_group.extend(np.flip(above_idx).tolist()) + order = order[~above_threshold] + merge_groups.append(merge_group) + return merge_groups + + +def _group_overlapping_masks_pairwise( + predictions: npt.NDArray[np.floating], + masks: npt.NDArray[Any] | CompactMask, + iou_threshold: float = 0.5, + overlap_metric: OverlapMetric = OverlapMetric.IOU, +) -> list[list[int]]: + return _greedy_nmm_via_mask_candidate( + predictions, masks, iou_threshold, overlap_metric + ) + + +def _non_max_merge_per_category( + predictions: npt.NDArray[np.floating], + group_within: Callable[[npt.NDArray[np.int_]], list[list[int]]], +) -> list[list[int]]: + """Dispatch NMM grouping per class, then translate local indices back to + the global row positions of ``predictions``. + + ``group_within(global_indices)`` must return merge groups expressed in + terms of *positions inside `global_indices`*, not absolute row positions. + When ``predictions`` has no class column, a single pass over all rows is + performed instead of per-category iteration. + """ + if predictions.shape[1] == 5: + global_indices = np.arange(len(predictions), dtype=int) + return [ + global_indices[group].tolist() for group in group_within(global_indices) + ] + + category_ids = predictions[:, 5] + merge_groups: list[list[int]] = [] + for category_id in np.unique(category_ids): + curr_indices = np.where(category_ids == category_id)[0] + for local_group in group_within(curr_indices): + merge_groups.append(curr_indices[local_group].tolist()) + + for merge_group in merge_groups: + if len(merge_group) == 0: + raise ValueError( + f"Empty group detected when non-max-merging detections: {merge_groups}" + ) + return merge_groups + + +def _group_overlapping_boxes( + predictions: npt.NDArray[np.floating], + iou_threshold: float = 0.5, + overlap_metric: OverlapMetric = OverlapMetric.IOU, +) -> list[list[int]]: + """ + Apply greedy version of non-maximum merging to avoid detecting too many + overlapping bounding boxes for a given object. + + Args: + predictions: An array of shape `(n, 5)` containing + the bounding boxes coordinates in format `[x1, y1, x2, y2]` + and the confidence scores. + iou_threshold: The intersection-over-union threshold + to use for non-maximum suppression. Defaults to 0.5. + overlap_metric: Metric used to compute the degree of overlap + between pairs of boxes (e.g., IoU, IoS). + + Returns: + Groups of prediction indices to be merged. + Each group may have 1 or more elements. + """ + merge_groups: list[list[int]] = [] + scores = predictions[:, 4] + order = scores.argsort() + while len(order) > 0: + idx = int(order[-1]) + order = order[:-1] + if len(order) == 0: + merge_groups.append([idx]) + break + ious = box_iou_batch( + predictions[order][:, :4], + predictions[idx : idx + 1, :4], + overlap_metric, + ).flatten() + above_threshold = ious >= iou_threshold + merge_group = [idx, *np.flip(order[above_threshold]).tolist()] + merge_groups.append(merge_group) + order = order[~above_threshold] + return merge_groups + + +def box_non_max_merge( + predictions: npt.NDArray[np.floating], + iou_threshold: float = 0.5, + overlap_metric: OverlapMetric = OverlapMetric.IOU, +) -> list[list[int]]: + """ + Apply greedy version of non-maximum merging per category to avoid detecting + too many overlapping bounding boxes for a given object. + + Args: + predictions: An array of shape `(n, 5)` or `(n, 6)` + containing the bounding boxes coordinates in format `[x1, y1, x2, y2]`, + the confidence scores and class_ids. Omit class_id column to allow + detections of different classes to be merged. + iou_threshold: The intersection-over-union threshold + to use for non-maximum suppression. Defaults to 0.5. + overlap_metric: Metric used to compute the degree of overlap + between pairs of boxes (e.g., IoU, IoS). + + Returns: + list[list[int]]: Groups of prediction indices be merged. + Each group may have 1 or more elements. + + Raises: + ValueError: If `iou_threshold` is not within the closed range + from `0` to `1`. + + Examples: + ```pycon + >>> import numpy as np + >>> import supervision as sv + >>> predictions = np.array([ + ... [0, 0, 4, 4, 0.9, 0], + ... [0, 0, 4, 4, 0.8, 0], + ... ]) + >>> sv.box_non_max_merge(predictions, iou_threshold=0.5) + [[0, 1]] + + ``` + """ + _validate_iou_threshold(iou_threshold) + + def group_within(global_indices: npt.NDArray[np.int_]) -> list[list[int]]: + return _group_overlapping_boxes( + predictions[global_indices], iou_threshold, overlap_metric + ) + + return _non_max_merge_per_category(predictions, group_within) + + +def oriented_box_non_max_suppression( + predictions: npt.NDArray[np.floating], + oriented_boxes: npt.NDArray[np.floating], + iou_threshold: float = 0.5, + overlap_metric: OverlapMetric = OverlapMetric.IOU, +) -> npt.NDArray[np.bool_]: + """ + Perform Non-Maximum Suppression on oriented bounding box predictions. + + Overlap is computed via :func:`oriented_box_iou_batch` on the four + corners of each box, so detections whose axis-aligned bounding boxes + overlap heavily but whose oriented bodies do not are kept โ€” unlike + :func:`box_non_max_suppression`, which would suppress them. + + Args: + predictions: An array of object detection predictions in the + format ``(x_min, y_min, x_max, y_max, score)`` or + ``(x_min, y_min, x_max, y_max, score, class)``. Shape ``(N, 5)`` + or ``(N, 6)``. Only the score (column 4) and optional class + (column 5) are read; the axis-aligned coordinates are not used. + oriented_boxes: Array of shape ``(N, 4, 2)`` containing the four + ``(x, y)`` corners of each oriented box, aligned with + ``predictions`` row-by-row. + iou_threshold: The intersection-over-union threshold to use for + non-maximum suppression. + overlap_metric: Metric used to compute the degree of overlap + between pairs of oriented boxes (e.g., IoU, IoS). + + Returns: + A boolean array of shape ``(N,)`` indicating which predictions + to keep after non-maximum suppression. + + Raises: + ValueError: If ``iou_threshold`` is not within the closed range + from 0 to 1. + ValueError: If ``predictions`` and ``oriented_boxes`` have + mismatched lengths or invalid shapes. + + Examples: + >>> import numpy as np + >>> import supervision as sv + >>> oriented_boxes = np.array([ + ... [[10, 10], [50, 10], [50, 30], [10, 30]], + ... [[11, 11], [51, 11], [51, 31], [11, 31]], + ... ], dtype=np.float32) + >>> predictions = np.array([ + ... [10, 10, 50, 30, 0.9, 0], + ... [11, 11, 51, 31, 0.8, 0], + ... ], dtype=np.float32) + >>> keep = sv.oriented_box_non_max_suppression( + ... predictions=predictions, + ... oriented_boxes=oriented_boxes, + ... iou_threshold=0.5, + ... ) + >>> keep + array([ True, False]) + """ + _validate_iou_threshold(iou_threshold) + for name, arr in (("predictions", predictions), ("oriented_boxes", oriented_boxes)): + if name == "predictions": + if arr.ndim != 2 or arr.shape[1] not in (5, 6): + raise ValueError( + f"`{name}` has shape {arr.shape}; expected (N, 5) or (N, 6)." + ) + continue + if arr.ndim == 3 and arr.shape[1:] != (4, 2): + raise ValueError( + f"`{name}` has shape {arr.shape}; expected (N, 4, 2) " + f"โ€” each box must have exactly 4 corners with (x, y) coordinates." + ) + elif arr.ndim == 2 and arr.shape[1] != 8: + raise ValueError( + f"`{name}` has shape {arr.shape}; expected (N, 8) for flat " + f"YOLO format or (N, 4, 2) for corner format." + ) + elif arr.ndim not in (2, 3): + raise ValueError( + f"`{name}` must be 2-D (N, 8) or 3-D (N, 4, 2), got shape {arr.shape}." + ) + if len(predictions) != len(oriented_boxes): + raise ValueError( + f"`predictions` and `oriented_boxes` must have the same length, " + f"got {len(predictions)} and {len(oriented_boxes)}." + ) + sort_index, _, categories = _prepare_predictions_for_nms(predictions) + oriented_boxes = oriented_boxes[sort_index] + # same object intentional โ€” triggers upper-triangle optimization + ious = oriented_box_iou_batch(oriented_boxes, oriented_boxes, overlap_metric) + keep = _nms_loop_from_iou_matrix(ious, categories, iou_threshold) + result: npt.NDArray[np.bool_] = keep[sort_index.argsort()] + return result + + +def _group_overlapping_oriented_boxes( + predictions: npt.NDArray[np.floating], + oriented_boxes: npt.NDArray[np.floating], + iou_threshold: float = 0.5, + overlap_metric: OverlapMetric = OverlapMetric.IOU, +) -> list[list[int]]: + """ + Greedy non-maximum merging on oriented boxes. Mirrors + :func:`_group_overlapping_boxes` but uses :func:`oriented_box_iou_batch`. + """ + merge_groups: list[list[int]] = [] + scores = predictions[:, 4] + order = scores.argsort() + while len(order) > 0: + idx = int(order[-1]) + order = order[:-1] + if len(order) == 0: + merge_groups.append([idx]) + break + ious = oriented_box_iou_batch( + oriented_boxes[order], + oriented_boxes[idx][None, ...], + overlap_metric, + ).flatten() + above_threshold = ious >= iou_threshold + merge_group = [idx, *np.flip(order[above_threshold]).tolist()] + merge_groups.append(merge_group) + order = order[~above_threshold] + return merge_groups + + +def oriented_box_non_max_merge( + predictions: npt.NDArray[np.floating], + oriented_boxes: npt.NDArray[np.floating], + iou_threshold: float = 0.5, + overlap_metric: OverlapMetric = OverlapMetric.IOU, +) -> list[list[int]]: + """ + Perform Non-Maximum Merging on oriented bounding box predictions, + grouped per category. + + Mirrors :func:`box_non_max_merge` but uses oriented-box IoU, so groups + of rotated detections sharing the same body โ€” rather than the same + axis-aligned bounding box โ€” are merged. + + Args: + predictions: An array of shape ``(n, 5)`` or ``(n, 6)`` containing + the axis-aligned coordinates ``[x1, y1, x2, y2]``, confidence + scores, and optionally class ids. Only the score and optional + class are used by the grouping logic; overlap is computed on + ``oriented_boxes``. + oriented_boxes: Array of shape ``(N, 4, 2)`` containing the four + ``(x, y)`` corners of each oriented box. + iou_threshold: The intersection-over-union threshold to use for + non-maximum merging. + overlap_metric: Metric used to compute the degree of overlap + between pairs of oriented boxes (e.g., IoU, IoS). + + Returns: + Groups of prediction indices to be merged. Each group may have 1 + or more elements. + + Raises: + ValueError: If ``iou_threshold`` is not within the closed range + from 0 to 1. + ValueError: If ``predictions`` and ``oriented_boxes`` have + mismatched lengths or invalid shapes. + + Examples: + >>> import numpy as np + >>> import supervision as sv + >>> oriented_boxes = np.array([ + ... [[10, 10], [50, 10], [50, 30], [10, 30]], + ... [[11, 11], [51, 11], [51, 31], [11, 31]], + ... ], dtype=np.float32) + >>> predictions = np.array([ + ... [10, 10, 50, 30, 0.9, 0], + ... [11, 11, 51, 31, 0.8, 0], + ... ], dtype=np.float32) + >>> groups = sv.oriented_box_non_max_merge( + ... predictions=predictions, + ... oriented_boxes=oriented_boxes, + ... iou_threshold=0.5, + ... ) + >>> len(groups) + 1 + """ + for name, arr in (("predictions", predictions), ("oriented_boxes", oriented_boxes)): + if name == "predictions": + if arr.ndim != 2 or arr.shape[1] not in (5, 6): + raise ValueError( + f"`{name}` has shape {arr.shape}; expected (N, 5) or (N, 6)." + ) + continue + if arr.ndim == 3 and arr.shape[1:] != (4, 2): + raise ValueError( + f"`{name}` has shape {arr.shape}; expected (N, 4, 2) " + f"โ€” each box must have exactly 4 corners with (x, y) coordinates." + ) + elif arr.ndim == 2 and arr.shape[1] != 8: + raise ValueError( + f"`{name}` has shape {arr.shape}; expected (N, 8) for flat " + f"YOLO format or (N, 4, 2) for corner format." + ) + elif arr.ndim not in (2, 3): + raise ValueError( + f"`{name}` must be 2-D (N, 8) or 3-D (N, 4, 2), got shape {arr.shape}." + ) + if len(predictions) != len(oriented_boxes): + raise ValueError( + f"`predictions` and `oriented_boxes` must have the same length, " + f"got {len(predictions)} and {len(oriented_boxes)}." + ) + _validate_iou_threshold(iou_threshold) + + def group_within(global_indices: npt.NDArray[np.int_]) -> list[list[int]]: + return _group_overlapping_oriented_boxes( + predictions[global_indices], + oriented_boxes[global_indices], + iou_threshold, + overlap_metric, + ) + + return _non_max_merge_per_category(predictions, group_within) diff --git a/src/supervision/detection/utils/masks.py b/src/supervision/detection/utils/masks.py new file mode 100644 index 0000000..65acc09 --- /dev/null +++ b/src/supervision/detection/utils/masks.py @@ -0,0 +1,588 @@ +from typing import Any, Literal, cast + +import cv2 +import numpy as np +import numpy.typing as npt + +from supervision.detection.compact_mask import CompactMask + + +def count_mask_pixels(masks: npt.NDArray[np.bool_]) -> npt.NDArray[np.int64]: + """Count the number of True pixels in each mask. + + Uses ``np.count_nonzero`` (no axis), which dispatches to a SIMD popcount + over the raw bool buffer and is ~6x faster than ``np.sum(mask, axis=(1, 2))``. + + Args: + masks: Boolean mask array of shape ``(N, H, W)``. + + Returns: + Int64 array of shape ``(N,)`` with the True-pixel count per mask. + + Example: + >>> import numpy as np + >>> from supervision.detection.utils.masks import count_mask_pixels + >>> m = np.zeros((2, 4, 4), dtype=bool) + >>> m[0, :2, :2] = True # 4 pixels + >>> m[1, :3, :3] = True # 9 pixels + >>> count_mask_pixels(m) + array([4, 9]) + """ + return np.fromiter( + (np.count_nonzero(m) for m in masks), dtype=np.int64, count=len(masks) + ) + + +def move_masks( + masks: npt.NDArray[np.bool_], + offset: npt.NDArray[np.integer], + resolution_wh: tuple[int, int], +) -> npt.NDArray[np.bool_]: + """ + Offset the masks in an array by the specified (x, y) amount. + + Args: + masks: A 3D array of binary masks corresponding to the + predictions. Shape: `(N, H, W)`, where N is the number of predictions, and + H, W are the dimensions of each mask. + offset: An array of shape `(2,)` containing int values + `[dx, dy]`. Supports both positive and negative values for bidirectional + movement. + resolution_wh: The width and height of the desired mask + resolution. + + Returns: + Repositioned masks, optionally padded to the specified shape. + + Examples: + ```pycon + >>> import numpy as np + >>> import supervision as sv + >>> mask = np.array([[[False, False, False, False], + ... [False, True, True, False], + ... [False, True, True, False], + ... [False, False, False, False]]], dtype=bool) + >>> offset = np.array([1, 1]) + >>> sv.move_masks(mask, offset, resolution_wh=(4, 4)) + array([[[False, False, False, False], + [False, False, False, False], + [False, False, True, True], + [False, False, True, True]]]) + >>> offset = np.array([-2, 2]) + >>> sv.move_masks(mask, offset, resolution_wh=(4, 4)) + array([[[False, False, False, False], + [False, False, False, False], + [False, False, False, False], + [ True, False, False, False]]]) + + ``` + """ + mask_array = np.full((masks.shape[0], resolution_wh[1], resolution_wh[0]), False) + + if offset[0] < 0: + source_x_start = -offset[0] + source_x_end = min(masks.shape[2], resolution_wh[0] - offset[0]) + destination_x_start = 0 + destination_x_end = min(resolution_wh[0], masks.shape[2] + offset[0]) + else: + source_x_start = 0 + source_x_end = min(masks.shape[2], resolution_wh[0] - offset[0]) + destination_x_start = offset[0] + destination_x_end = offset[0] + source_x_end - source_x_start + + if offset[1] < 0: + source_y_start = -offset[1] + source_y_end = min(masks.shape[1], resolution_wh[1] - offset[1]) + destination_y_start = 0 + destination_y_end = min(resolution_wh[1], masks.shape[1] + offset[1]) + else: + source_y_start = 0 + source_y_end = min(masks.shape[1], resolution_wh[1] - offset[1]) + destination_y_start = offset[1] + destination_y_end = offset[1] + source_y_end - source_y_start + + if source_x_end > source_x_start and source_y_end > source_y_start: + mask_array[ + :, + destination_y_start:destination_y_end, + destination_x_start:destination_x_end, + ] = masks[:, source_y_start:source_y_end, source_x_start:source_x_end] + + return mask_array + + +def calculate_masks_centroids( + masks: npt.NDArray[np.bool_] | CompactMask, +) -> npt.NDArray[np.int_]: + """ + Calculate the centroids of binary masks in a tensor. + + Args: + masks: A 3D NumPy array of shape (num_masks, height, width). + Each 2D array in the tensor represents a binary mask. + Also accepts a :class:`~supervision.detection.compact_mask.CompactMask`. + + Returns: + A 2D NumPy array of shape (num_masks, 2), where each row contains the x and y + coordinates (in that order) of the centroid of the corresponding mask. + + Examples: + ```pycon + >>> import numpy as np + >>> import supervision as sv + >>> masks = np.zeros((1, 10, 10), dtype=bool) + >>> masks[0, 2:6, 2:6] = True + >>> sv.calculate_masks_centroids(masks) + array([[4, 4]]) + + ``` + """ + if isinstance(masks, CompactMask): + # Compute centroids per-crop to avoid materialising the full (N, H, W) array. + n = len(masks) + if n == 0: + return cast(npt.NDArray[np.int_], np.empty((0, 2), dtype=int)) + + centroids: npt.NDArray[np.float64] = np.zeros((n, 2), dtype=np.float64) + for i in range(n): + crop = masks.crop(i) + crop_h, crop_w = crop.shape + x1 = int(masks.offsets[i, 0]) + y1 = int(masks.offsets[i, 1]) + total = int(crop.sum()) + if total == 0: + centroids[i] = [0.0, 0.0] + continue + # Match the +0.5 offset used by the dense implementation. + crop_rows, crop_cols = np.indices((crop_h, crop_w)) + cx = float(np.sum((crop_cols + 0.5)[crop])) / total + x1 + cy = float(np.sum((crop_rows + 0.5)[crop])) / total + y1 + centroids[i] = [cx, cy] + + return cast(npt.NDArray[np.int_], centroids.astype(int)) + + _num_masks, height, width = masks.shape + total_pixels: npt.NDArray[np.int64] = count_mask_pixels(masks) + + # offset for 1-based indexing + vertical_indices, horizontal_indices = np.indices((height, width)) + 0.5 + # avoid division by zero for empty masks + total_pixels[total_pixels == 0] = 1 + + def sum_over_mask( + indices: npt.NDArray[np.floating], axis: tuple[list[int], list[int]] + ) -> npt.NDArray[np.floating]: + return cast(npt.NDArray[np.floating], np.tensordot(masks, indices, axes=axis)) + + aggregation_axis: tuple[list[int], list[int]] = ([1, 2], [0, 1]) + centroid_x = sum_over_mask(horizontal_indices, aggregation_axis) / total_pixels + centroid_y = sum_over_mask(vertical_indices, aggregation_axis) / total_pixels + + return cast( + npt.NDArray[np.int_], np.column_stack((centroid_x, centroid_y)).astype(int) + ) + + +def contains_holes(mask: npt.NDArray[np.bool_]) -> bool: + """ + Checks if the binary mask contains holes (background pixels fully enclosed by + foreground pixels). + + Args: + mask: 2D binary mask where `True` indicates foreground + object and `False` indicates background. + + Returns: + True if holes are detected, False otherwise. + + Examples: + ```pycon + >>> import numpy as np + >>> import supervision as sv + >>> mask = np.array([ + ... [0, 0, 0, 0, 0], + ... [0, 1, 1, 1, 0], + ... [0, 1, 0, 1, 0], + ... [0, 1, 1, 1, 0], + ... [0, 0, 0, 0, 0] + ... ]).astype(bool) + >>> sv.contains_holes(mask=mask) + True + >>> mask = np.array([ + ... [0, 0, 0, 0, 0], + ... [0, 1, 1, 1, 0], + ... [0, 1, 1, 1, 0], + ... [0, 1, 1, 1, 0], + ... [0, 0, 0, 0, 0] + ... ]).astype(bool) + >>> sv.contains_holes(mask=mask) + False + + ``` + + ![contains_holes](https://media.roboflow.com/supervision-docs/contains-holes.png){ align=center width="800" } + """ # noqa E501 // docs + mask_uint8 = mask.astype(np.uint8) + _, hierarchy = cv2.findContours(mask_uint8, cv2.RETR_CCOMP, cv2.CHAIN_APPROX_SIMPLE) + + if hierarchy is not None: + parent_contour_index = 3 + for h in hierarchy[0]: + if h[parent_contour_index] != -1: + return True + return False + + +def contains_multiple_segments( + mask: npt.NDArray[np.bool_], connectivity: int = 4 +) -> bool: + """ + Checks if the binary mask contains multiple unconnected foreground segments. + + Args: + mask: 2D binary mask where `True` indicates foreground + object and `False` indicates background. + connectivity: Default: 4 is 4-way connectivity, which means that + foreground pixels are the part of the same segment/component + if their edges touch. + Alternatively: 8 for 8-way connectivity, when foreground pixels are + connected by their edges or corners touch. + + Returns: + True when the mask contains multiple not connected components, False otherwise. + + Raises: + ValueError: If connectivity(int) parameter value is not 4 or 8. + + Examples: + ```pycon + >>> import numpy as np + >>> import supervision as sv + >>> mask = np.array([ + ... [0, 0, 0, 0, 0, 0], + ... [0, 1, 1, 0, 1, 1], + ... [0, 1, 1, 0, 1, 1], + ... [0, 0, 0, 0, 0, 0], + ... [0, 1, 1, 1, 0, 0], + ... [0, 1, 1, 1, 0, 0] + ... ]).astype(bool) + >>> sv.contains_multiple_segments(mask=mask, connectivity=4) + True + >>> mask = np.array([ + ... [0, 0, 0, 0, 0, 0], + ... [0, 1, 1, 1, 1, 1], + ... [0, 1, 1, 1, 1, 1], + ... [0, 1, 1, 1, 1, 1], + ... [0, 1, 1, 1, 1, 1], + ... [0, 0, 0, 0, 0, 0] + ... ]).astype(bool) + >>> sv.contains_multiple_segments(mask=mask, connectivity=4) + False + + ``` + + ![contains_multiple_segments](https://media.roboflow.com/supervision-docs/contains-multiple-segments.png){ align=center width="800" } + """ # noqa E501 // docs + if connectivity != 4 and connectivity != 8: + raise ValueError( + "Incorrect connectivity value. Possible connectivity values: 4 or 8." + ) + mask_uint8 = mask.astype(np.uint8) + labels = np.zeros_like(mask_uint8, dtype=np.int32) + number_of_labels, _ = cv2.connectedComponents( + mask_uint8, labels, connectivity=connectivity + ) + return bool(number_of_labels > 2) + + +def resize_masks( + masks: npt.NDArray[np.bool_], max_dimension: int = 640 +) -> npt.NDArray[np.bool_]: + """ + Resize all masks in the array to have a maximum dimension of max_dimension, + maintaining aspect ratio. + + Args: + masks: 3D array of binary masks with shape (N, H, W). + max_dimension: The maximum dimension for the resized masks. + + Returns: + Array of resized masks. + """ + max_height: int = masks.shape[1] + max_width: int = masks.shape[2] + scale = min(1.0, max_dimension / max_height, max_dimension / max_width) + if scale == 1.0: + return masks + + new_height = int(scale * max_height) + new_width = int(scale * max_width) + + x = np.linspace(0, max_width - 1, new_width).astype(int) + y = np.linspace(0, max_height - 1, new_height).astype(int) + xv, yv = np.meshgrid(x, y) + + resized_masks = masks[:, yv, xv] + + return resized_masks.reshape(masks.shape[0], new_height, new_width) + + +def filter_segments_by_distance( + mask: npt.NDArray[np.bool_], + absolute_distance: float | None = 100.0, + relative_distance: float | None = None, + connectivity: int = 8, + mode: Literal["edge", "centroid"] = "edge", +) -> npt.NDArray[np.bool_]: + """ + Keep the largest connected component and any other components within a distance + threshold. + + Distance can be absolute in pixels or relative to the image diagonal. + + Args: + mask: Boolean mask HxW. + absolute_distance: Max allowed distance in pixels to the main component. + Ignored if `relative_distance` is provided. + relative_distance: Fraction of the diagonal. If set, threshold = fraction * sqrt(H^2 + W^2). + connectivity: Defines which neighboring pixels are considered connected. + - 4-connectedness: Only orthogonal neighbors. + ``` + [ ][X][ ] + [X][O][X] + [ ][X][ ] + ``` + - 8-connectedness: Includes diagonal neighbors. + ``` + [X][X][X] + [X][O][X] + [X][X][X] + ``` + Default is 8. + mode: Defines how distance between components is measured. + - "edge": Uses distance between nearest edges (via distance transform). + - "centroid": Uses distance between component centroids. + + Returns: + Boolean mask after filtering. + + Examples: + ```pycon + >>> import numpy as np + >>> import supervision as sv + >>> mask = np.array([ + ... [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], + ... [0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0], + ... [0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0], + ... [0, 1, 1, 1, 0, 0, 1, 1, 0, 0, 0, 0], + ... [0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0], + ... [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], + ... [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], + ... [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], + ... [0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0], + ... [0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0], + ... [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], + ... [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], + ... ], dtype=bool) + >>> sv.filter_segments_by_distance( + ... mask, + ... absolute_distance=3, + ... mode="edge", + ... connectivity=8 + ... ).astype(int) + array([[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], + [0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0], + [0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0], + [0, 1, 1, 1, 0, 0, 1, 1, 0, 0, 0, 0], + [0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0], + [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], + [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], + [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], + [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], + [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], + [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], + [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]) + + ``` + + The nearby 2x2 block at columns 6-7 is kept because its edge distance + is within 3 pixels. The distant block at columns 9-10 is removed. + """ # noqa E501 // docs + if mask.dtype != bool: + raise TypeError("mask must be boolean") + + height, width = mask.shape + if not np.any(mask): + return cast(npt.NDArray[np.bool_], mask.copy()) + + image = cast(npt.NDArray[np.uint8], mask.astype(np.uint8)) + components = cv2.connectedComponentsWithStats(image, connectivity=connectivity) + num_labels = int(components[0]) + labels = cast(npt.NDArray[np.int32], components[1]) + stats = cast(npt.NDArray[np.int32], components[2]) + centroids = cast(npt.NDArray[np.float64], components[3]) + + if num_labels <= 1: + return cast(npt.NDArray[np.bool_], mask.copy()) + + areas = stats[1:, cv2.CC_STAT_AREA] + main_label = 1 + int(np.argmax(areas)) + + if relative_distance is not None: + diagonal = float(np.hypot(height, width)) + threshold = float(relative_distance) * diagonal + elif absolute_distance is not None: + threshold = float(absolute_distance) + else: + raise ValueError("Either absolute_distance or relative_distance must be set.") + + keep_labels: npt.NDArray[np.bool_] = np.zeros(num_labels, dtype=bool) + keep_labels[main_label] = True + + if mode == "centroid": + differences = centroids[1:] - centroids[main_label] + distances = np.sqrt(np.sum(differences**2, axis=1)) + nearby = 1 + np.where(distances <= threshold)[0] + keep_labels[nearby] = True + elif mode == "edge": + main_mask = (labels == main_label).astype(np.uint8) + inverse = 1 - main_mask + distance_transform = cv2.distanceTransform(inverse, cv2.DIST_L2, 3) + for label in range(1, num_labels): + if label == main_label: + continue + component = labels == label + if not np.any(component): + continue + min_distance = float(distance_transform[component].min()) + if min_distance <= threshold: + keep_labels[label] = True + else: + raise ValueError("mode must be 'edge' or 'centroid'") + + return keep_labels[labels] + + +def mask_to_roi(mask: npt.NDArray[np.bool_]) -> tuple[int, int, int, int] | None: + """Return exclusive ``(x1, y1, x2, y2)`` bounds for true mask pixels. + + Use this helper when you need NumPy slice semantics. Unlike + :func:`~supervision.detection.utils.converters.mask_to_xyxy`, this + function uses exclusive upper bounds (``+1``) and returns ``None`` for + empty masks instead of zeros. The inclusive ``mask_to_xyxy`` convention + stays in place for compatibility with CompactMask and box-based adapters. + + Args: + mask: 2D boolean array of shape ``(H, W)``. + + Returns: + Exclusive ``(x1, y1, x2, y2)`` bounds, or ``None`` when the mask + has no true pixels. + + Examples: + ```pycon + >>> import numpy as np + >>> from supervision.detection.utils.masks import mask_to_roi + >>> mask = np.zeros((10, 10), dtype=bool) + >>> mask[2:5, 3:6] = True + >>> mask_to_roi(mask) + (3, 2, 6, 5) + + ``` + """ + rows = np.flatnonzero(np.any(mask, axis=1)) + if len(rows) == 0: + return None + cols = np.flatnonzero(np.any(mask, axis=0)) + return int(cols[0]), int(rows[0]), int(cols[-1]) + 1, int(rows[-1]) + 1 + + +_mask_to_roi = mask_to_roi + + +def _compact_masks_to_roi( + masks: CompactMask, + image_shape: tuple[int, int], +) -> tuple[int, int, int, int] | None: + """Return exclusive bounding-box union for compact masks. + + Uses crop metadata (offsets + shapes) โ€” no RLE decode required. + + Args: + masks: Compact mask collection. + image_shape: Image dimensions as ``(height, width)``. + + Returns: + Exclusive ``(x1, y1, x2, y2)`` bounds, or ``None`` when empty. + """ + if len(masks) == 0: + return None + image_h, image_w = image_shape + bboxes = masks.bbox_xyxy # shape (N, 4), inclusive int32 + x_min = int(bboxes[:, 0].min()) + y_min = int(bboxes[:, 1].min()) + x_max = int(bboxes[:, 2].max()) + 1 # convert inclusive to exclusive + y_max = int(bboxes[:, 3].max()) + 1 + return ( + max(0, x_min), + max(0, y_min), + min(image_w, x_max), + min(image_h, y_max), + ) + + +def _masks_to_roi( + masks: CompactMask | npt.NDArray[Any], + image_shape: tuple[int, int], + xyxy: npt.NDArray[np.number] | None = None, +) -> tuple[int, int, int, int] | None: + """Return exclusive true-pixel bounds for dense or compact masks. + + Args: + masks: Dense boolean mask array of shape ``(N, H, W)`` or ``(H, W)``, + or a :class:`~supervision.detection.compact_mask.CompactMask`. + image_shape: Image dimensions as ``(height, width)``. + xyxy: Optional detection boxes of shape ``(N, 4)`` in + ``[x1, y1, x2, y2]`` format. When provided, the dense path + first checks whether all true pixels fall within the box union; + if so the box bounds are returned without a full pixel scan. + + Returns: + Exclusive ``(x1, y1, x2, y2)`` bounds, or ``None`` when no true + pixels exist. + """ + if isinstance(masks, CompactMask): + return _compact_masks_to_roi(masks=masks, image_shape=image_shape) + mask_array = np.asarray(masks, dtype=bool) + if mask_array.size == 0 or not mask_array.any(): + return None + # Fast path: union of detection boxes (O(N)) avoids a full NยทHยทW pixel scan + # when boxes are mask-derived. Guard it with an `any()` check over the ROI so + # loose boxes cannot clip true pixels that lie outside the box union. + if xyxy is not None and len(xyxy) > 0: + image_h, image_w = image_shape + box_roi = ( + max(0, int(np.floor(xyxy[:, 0].min()))), + max(0, int(np.floor(xyxy[:, 1].min()))), + min(image_w, int(np.floor(xyxy[:, 2].max())) + 1), + min(image_h, int(np.floor(xyxy[:, 3].max())) + 1), + ) + x1, y1, x2, y2 = box_roi + if x1 < x2 and y1 < y2: + union = mask_array if mask_array.ndim == 2 else np.any(mask_array, axis=0) + # Return box bounds only when all true pixels fall within the box. + # Slice-based checks avoid allocating a full-frame copy. + if ( + union[y1:y2, x1:x2].any() + and not union[:y1].any() + and not union[y2:].any() + and not union[y1:y2, :x1].any() + and not union[y1:y2, x2:].any() + ): + return box_roi + return mask_to_roi(union) + if mask_array.ndim == 2: + union = mask_array + else: + union = np.any(mask_array, axis=0) + return mask_to_roi(union) diff --git a/src/supervision/detection/utils/polygons.py b/src/supervision/detection/utils/polygons.py new file mode 100644 index 0000000..0efb508 --- /dev/null +++ b/src/supervision/detection/utils/polygons.py @@ -0,0 +1,128 @@ +import cv2 +import numpy as np +import numpy.typing as npt + + +def filter_polygons_by_area( + polygons: list[npt.NDArray[np.number]], + min_area: float | None = None, + max_area: float | None = None, +) -> list[npt.NDArray[np.number]]: + """ + Filters a list of polygons based on their area. + + Args: + polygons: A list of polygons, where each polygon is + represented by a NumPy array of shape `(N, 2)`, + containing the `x`, `y` coordinates of the points. + min_area: The minimum area threshold. + Only polygons with an area greater than or equal to this value + will be included in the output. If set to None, + no minimum area constraint will be applied. + max_area: The maximum area threshold. + Only polygons with an area less than or equal to this value + will be included in the output. If set to None, + no maximum area constraint will be applied. + + Returns: + A new list of polygons containing only those with + areas within the specified thresholds. + + Examples: + ```pycon + >>> import numpy as np + >>> import supervision as sv + >>> small = np.array([[0, 0], [2, 0], [2, 2], [0, 2]]) + >>> big = np.array([[0, 0], [10, 0], [10, 10], [0, 10]]) + >>> sv.filter_polygons_by_area([small, big], min_area=50) + [array([[ 0, 0], + [10, 0], + [10, 10], + [ 0, 10]])] + + ``` + """ + if min_area is None and max_area is None: + return polygons + ares = [cv2.contourArea(polygon) for polygon in polygons] + return [ + polygon + for polygon, area in zip(polygons, ares) + if (min_area is None or area >= min_area) + and (max_area is None or area <= max_area) + ] + + +def approximate_polygon( + polygon: npt.NDArray[np.number], percentage: float, epsilon_step: float = 0.05 +) -> npt.NDArray[np.number]: + """ + Approximates a given polygon by reducing a certain percentage of points. + + This function uses the Ramer-Douglas-Peucker algorithm to simplify the input + polygon by reducing the number of points while preserving the general shape. + + Args: + polygon: A 2D NumPy array of shape `(N, 2)` containing + the `x`, `y` coordinates of the input polygon's points. + percentage: The percentage of points to be removed from the + input polygon, in the range `[0, 1)`. + epsilon_step: Approximation accuracy step, must be positive. + Epsilon is the maximum distance between the original curve + and its approximation. + + Returns: + A new 2D NumPy array of shape `(M, 2)` containing the `x`, `y` + coordinates of the approximated polygon's points. `M` is at most + `floor(N * (1 - percentage))` (minimum 3). Because epsilon + advances in discrete `epsilon_step` increments, `M` may be + noticeably smaller than the budget when a single step crosses + the target band. At least 3 points are always kept; when further + simplification would collapse the polygon below 3 points the last + valid approximation is returned and `M` may exceed the budget. + + Raises: + ValueError: If `percentage` is outside the range `[0, 1)`. + ValueError: If `epsilon_step` is not positive. + + Examples: + Reduce a polygon to at most half its original point count: + + >>> import numpy as np + >>> polygon = np.array([[0, 0], [10, 0], [10, 10], [0, 10], + ... [5, 10], [5, 5], [3, 7], [1, 9]]) + >>> result = approximate_polygon(polygon, percentage=0.5) + >>> result.shape[1] + 2 + >>> len(result) <= max(int(len(polygon) * 0.5), 3) + True + + Polygon already at or below target โ€” returned unchanged: + + >>> tiny = np.array([[0, 0], [5, 0], [2, 4]]) + >>> approximate_polygon(tiny, percentage=0.5) is tiny + True + """ + + if percentage < 0 or percentage >= 1: + raise ValueError("Percentage must be in the range [0, 1).") + if epsilon_step <= 0: + raise ValueError("epsilon_step must be positive.") + + target_points = max(int(len(polygon) * (1 - percentage)), 3) + + if len(polygon) <= target_points: + return polygon + + epsilon: float = 0 + approximated_points = polygon + while len(approximated_points) > target_points: + epsilon += epsilon_step + candidate = np.squeeze(cv2.approxPolyDP(polygon, epsilon, closed=True), axis=1) + # Stop before the approximation collapses below a valid polygon; keep the + # last result with at least three points. + if len(candidate) < 3: + break + approximated_points = candidate + + return approximated_points diff --git a/src/supervision/detection/utils/vlms.py b/src/supervision/detection/utils/vlms.py new file mode 100644 index 0000000..24a784e --- /dev/null +++ b/src/supervision/detection/utils/vlms.py @@ -0,0 +1,97 @@ +def edit_distance(string_1: str, string_2: str, case_sensitive: bool = True) -> int: + """ + Calculates the minimum number of single-character edits required + to transform one string into another. Allowed operations are insertion, + deletion, and substitution. + + Args: + string_1: The source string to be transformed. + string_2: The target string to transform into. + case_sensitive: Whether comparison should be case-sensitive. + Defaults to True. + + Returns: + The minimum number of edits required to convert `string_1` + into `string_2`. + + Examples: + ```pycon + >>> import supervision as sv + >>> sv.edit_distance("hello", "hello") + 0 + >>> sv.edit_distance("Test", "test", case_sensitive=True) + 1 + >>> sv.edit_distance("abc", "xyz") + 3 + >>> sv.edit_distance("hello", "") + 5 + >>> sv.edit_distance("", "") + 0 + >>> sv.edit_distance("hello world", "helloworld") + 1 + + ``` + """ + if not case_sensitive: + string_1 = string_1.lower() + string_2 = string_2.lower() + + if len(string_1) < len(string_2): + string_1, string_2 = string_2, string_1 + + prev_row = list(range(len(string_2) + 1)) + curr_row = [0] * (len(string_2) + 1) + + for i in range(1, len(string_1) + 1): + curr_row[0] = i + for j in range(1, len(string_2) + 1): + if string_1[i - 1] == string_2[j - 1]: + substitution_cost = 0 + else: + substitution_cost = 1 + curr_row[j] = min( + prev_row[j] + 1, + curr_row[j - 1] + 1, + prev_row[j - 1] + substitution_cost, + ) + prev_row, curr_row = curr_row, prev_row + + return prev_row[len(string_2)] + + +def fuzzy_match_index( + candidates: list[str], + query: str, + threshold: int, + case_sensitive: bool = True, +) -> int | None: + """ + Searches for the first string in `candidates` whose edit distance + to `query` is less than or equal to `threshold`. + + Args: + candidates: List of strings to search. + query: String to compare against the candidates. + threshold: Maximum allowed edit distance for a match. + case_sensitive: Whether matching should be case-sensitive. + + Returns: + Index of the first matching string in candidates, + or None if no match is found. + + Examples: + ```pycon + >>> from supervision.detection.utils.vlms import fuzzy_match_index + >>> fuzzy_match_index(["cat", "dog", "rat"], "dat", threshold=1) + 0 + >>> fuzzy_match_index(["alpha", "beta", "gamma"], "bata", threshold=1) + 1 + >>> fuzzy_match_index(["one", "two", "three"], "xyz", threshold=2) is None + True + + ``` + """ + for idx, candidate in enumerate(candidates): + if edit_distance(candidate, query, case_sensitive=case_sensitive) <= threshold: + return idx + return None diff --git a/src/supervision/detection/vlm.py b/src/supervision/detection/vlm.py new file mode 100644 index 0000000..8cf0534 --- /dev/null +++ b/src/supervision/detection/vlm.py @@ -0,0 +1,932 @@ +from __future__ import annotations + +import ast +import base64 +import io +import json +import re +from enum import Enum +from typing import Any, cast + +import numpy as np +import numpy.typing as npt +from deprecate import deprecated, void +from PIL import Image + +from supervision.detection.utils.boxes import denormalize_boxes +from supervision.detection.utils.converters import polygon_to_mask, polygon_to_xyxy +from supervision.utils.internal import warn_deprecated +from supervision.validators import _validate_resolution + + +class LMM(Enum): + """ + Enum specifying supported Large Multimodal Models (LMMs). + + !!! deprecated "Deprecated" + + `LMM` is deprecated and will be removed in `supervision-0.31.0`. + Use `VLM` instead. + + Attributes: + PALIGEMMA: Google's PaliGemma vision-language model. + FLORENCE_2: Microsoft's Florence-2 vision-language model. + QWEN_2_5_VL: Qwen2.5-VL open vision-language model from Alibaba.\ + QWEN_3_VL: Qwen3-VL open vision-language model from Alibaba. + GOOGLE_GEMINI_2_0: Google Gemini 2.0 vision-language model. + GOOGLE_GEMINI_2_5: Google Gemini 2.5 vision-language model. + MOONDREAM: The Moondream vision-language model. + """ + + PALIGEMMA = "paligemma" + FLORENCE_2 = "florence_2" + QWEN_2_5_VL = "qwen_2_5_vl" + QWEN_3_VL = "qwen_3_vl" + DEEPSEEK_VL_2 = "deepseek_vl_2" + GOOGLE_GEMINI_2_0 = "gemini_2_0" + GOOGLE_GEMINI_2_5 = "gemini_2_5" + MOONDREAM = "moondream" + + @classmethod + def list(cls) -> list[str]: + return [c.value for c in cls] + + @classmethod + def from_value(cls, value: LMM | str) -> LMM: + warn_deprecated( + "`LMM` is deprecated since `supervision-0.27.0` and will be removed in " + "`supervision-0.31.0`. Use `VLM` instead." + ) + if isinstance(value, cls): + return value + if isinstance(value, str): + value = value.lower() + try: + return cls(value) + except ValueError: + raise ValueError(f"Invalid value: {value}. Must be one of {cls.list()}") + raise ValueError( + f"Invalid value type: {type(value)}. Must be an instance of " + f"{cls.__name__} or str." + ) + + +class VLM(Enum): + """ + Enum specifying supported Vision-Language Models (VLMs). + + Attributes: + PALIGEMMA: Google's PaliGemma vision-language model. + FLORENCE_2: Microsoft's Florence-2 vision-language model. + QWEN_2_5_VL: Qwen2.5-VL open vision-language model from Alibaba. + QWEN_3_VL: Qwen3-VL open vision-language model from Alibaba. + GOOGLE_GEMINI_2_0: Google Gemini 2.0 vision-language model. + GOOGLE_GEMINI_2_5: Google Gemini 2.5 vision-language model. + MOONDREAM: The Moondream vision-language model. + """ + + PALIGEMMA = "paligemma" + FLORENCE_2 = "florence_2" + QWEN_2_5_VL = "qwen_2_5_vl" + QWEN_3_VL = "qwen_3_vl" + DEEPSEEK_VL_2 = "deepseek_vl_2" + GOOGLE_GEMINI_2_0 = "gemini_2_0" + GOOGLE_GEMINI_2_5 = "gemini_2_5" + MOONDREAM = "moondream" + + @classmethod + def list(cls) -> list[str]: + return [c.value for c in cls] + + @classmethod + def from_value(cls, value: VLM | str) -> VLM: + if isinstance(value, cls): + return value + if isinstance(value, str): + value = value.lower() + try: + return cls(value) + except ValueError: + raise ValueError(f"Invalid value: {value}. Must be one of {cls.list()}") + raise ValueError( + f"Invalid value type: {type(value)}. Must be an instance of " + f"{cls.__name__} or str." + ) + + +RESULT_TYPES: dict[VLM, type] = { + VLM.PALIGEMMA: str, + VLM.FLORENCE_2: dict, + VLM.QWEN_2_5_VL: str, + VLM.QWEN_3_VL: str, + VLM.DEEPSEEK_VL_2: str, + VLM.GOOGLE_GEMINI_2_0: str, + VLM.GOOGLE_GEMINI_2_5: str, + VLM.MOONDREAM: dict, +} + +REQUIRED_ARGUMENTS: dict[VLM, list[str]] = { + VLM.PALIGEMMA: ["resolution_wh"], + VLM.FLORENCE_2: ["resolution_wh"], + VLM.QWEN_2_5_VL: ["input_wh", "resolution_wh"], + VLM.QWEN_3_VL: ["resolution_wh"], + VLM.DEEPSEEK_VL_2: ["resolution_wh"], + VLM.GOOGLE_GEMINI_2_0: ["resolution_wh"], + VLM.GOOGLE_GEMINI_2_5: ["resolution_wh"], + VLM.MOONDREAM: ["resolution_wh"], +} + +ALLOWED_ARGUMENTS: dict[VLM, list[str]] = { + VLM.PALIGEMMA: ["resolution_wh", "classes"], + VLM.FLORENCE_2: ["resolution_wh"], + VLM.QWEN_2_5_VL: ["input_wh", "resolution_wh", "classes"], + VLM.QWEN_3_VL: ["resolution_wh", "classes"], + VLM.DEEPSEEK_VL_2: ["resolution_wh", "classes"], + VLM.GOOGLE_GEMINI_2_0: ["resolution_wh", "classes"], + VLM.GOOGLE_GEMINI_2_5: ["resolution_wh", "classes"], + VLM.MOONDREAM: ["resolution_wh"], +} + +SUPPORTED_TASKS_FLORENCE_2 = [ + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", +] + + +def _validate_vlm_parameters( + vlm: VLM | str, result: Any, kwargs: dict[str, Any] +) -> VLM: + """ + Validates the parameters and result type for a given Vision-Language Model (VLM). + + Args: + vlm: The VLM enum or string specifying the model. + result: The result object to validate (type depends on VLM). + kwargs: Dictionary of arguments to validate against required/allowed lists. + + Returns: + The validated VLM enum value. + + Raises: + ValueError: If the VLM, result type, or arguments are invalid. + """ + if isinstance(vlm, str): + try: + vlm = VLM(vlm.lower()) + except ValueError: + raise ValueError( + f"Invalid vlm value: {vlm}. Must be one of {[e.value for e in VLM]}" + ) + + if not isinstance(result, RESULT_TYPES[vlm]): + raise ValueError( + f"Invalid VLM result type: {type(result)}. Must be {RESULT_TYPES[vlm]}" + ) + + required_args = REQUIRED_ARGUMENTS.get(vlm, []) + for arg in required_args: + if arg not in kwargs: + raise ValueError(f"Missing required argument: {arg}") + + allowed_args = ALLOWED_ARGUMENTS.get(vlm, []) + for arg in kwargs: + if arg not in allowed_args: + raise ValueError(f"Argument {arg} is not allowed for {vlm.name}") + + return vlm + + +@deprecated( # type: ignore[untyped-decorator] + target=_validate_vlm_parameters, + deprecated_in="0.29.0", + remove_in="0.32.0", +) +def validate_vlm_parameters(vlm: VLM | str, result: Any, kwargs: dict[str, Any]) -> VLM: + return void(vlm, result, kwargs) # type: ignore[no-any-return] + + +def from_paligemma( + result: str, resolution_wh: tuple[int, int], classes: list[str] | None = None +) -> tuple[npt.NDArray[Any], npt.NDArray[Any] | None, npt.NDArray[Any]]: + """ + Parse bounding boxes from paligemma-formatted text, scale them to the specified + resolution, and optionally filter by classes. + + Args: + result: String containing paligemma-formatted locations and labels. + resolution_wh: tuple (width, height) to which we scale the box coordinates. + classes: Optional list of valid class names. If provided, boxes and labels not + in this list are filtered out. + + Returns: + A tuple of `(xyxy, class_id, class_name)` where `xyxy` is an array of + shape `(n, 4)` in format `[x1, y1, x2, y2]`, `class_id` is an + optional array of shape `(n,)` with class indices, and `class_name` + is an array of shape `(n,)` with class labels. + """ + + w, h = _validate_resolution(resolution_wh) + + pattern = re.compile( + r"(?) ([\w\s\-]+)" + ) + matches = pattern.findall(result) + matches_arr: npt.NDArray[Any] = np.array(matches) if matches else np.empty((0, 5)) + + if matches_arr.shape[0] == 0: + return np.empty((0, 4)), np.empty((0,), dtype=int), np.empty(0, dtype=str) + + xyxy_arr = np.array(matches_arr[:, [1, 0, 3, 2]], dtype=float) + xyxy_arr = xyxy_arr.astype(int) / 1024 * np.array([w, h, w, h]) + class_name = np.char.strip(matches_arr[:, 4].astype(str)) + class_id: npt.NDArray[Any] | None = None + + if classes is not None: + mask = np.array([name in classes for name in class_name], dtype=bool) + xyxy_arr = xyxy_arr[mask] + class_name = class_name[mask] + class_id = np.array([classes.index(name) for name in class_name]) + + return xyxy_arr, class_id, class_name + + +def recover_truncated_qwen_2_5_vl_response(text: str) -> Any | None: + """ + Attempt to recover and parse a truncated or malformed JSON snippet from Qwen-2.5-VL + output. + + This utility extracts a JSON-like portion from a string that may be truncated or + malformed, cleans trailing commas, and attempts to parse it into a Python object. + + Args: + text: Raw text containing the JSON snippet possibly truncated or + incomplete. + + Returns: + Parsed Python object (usually list) if recovery and parsing succeed; + otherwise `None`. + """ + try: + first_bracket = text.find("[") + if first_bracket == -1: + return None + snippet = text[first_bracket:] + + last_brace = snippet.rfind("}") + if last_brace == -1: + return None + + snippet = snippet[: last_brace + 1] + + prefix_end = snippet.find("[") + if prefix_end == -1: + return None + + prefix = snippet[: prefix_end + 1] + body = snippet[prefix_end + 1 :].rstrip() + + if body.endswith(","): + body = body[:-1].rstrip() + + repaired = prefix + body + "]" + + return json.loads(repaired) + except Exception: + return None + + +def from_qwen_2_5_vl( + result: str, + input_wh: tuple[int, int], + resolution_wh: tuple[int, int], + classes: list[str] | None = None, +) -> tuple[npt.NDArray[Any], npt.NDArray[Any] | None, npt.NDArray[Any]]: + """ + Parse and rescale bounding boxes and class labels from Qwen-2.5-VL JSON output. + + The JSON is expected to be enclosed in triple backticks with the format: + ```json + [ + {"bbox_2d": [x1, y1, x2, y2], "label": "some class name"}, + ... + ] + ``` + + Args: + result: String containing Qwen-2.5-VL JSON bounding box and label data. + input_wh: Width and height of the coordinate space where boxes + are normalized. + resolution_wh: Target width and height to scale bounding boxes. + classes: Optional list of valid class names to filter results. If provided, + only boxes with labels in this list are returned. + + Returns: + A tuple of `(xyxy, class_id, class_name)` where `xyxy` is an array of + shape `(N, 4)` in `(x_min, y_min, x_max, y_max)` format, `class_id` + is an optional array of shape `(N,)` with class indices, and + `class_name` is an array of shape `(N,)` with class names. + """ + + in_w, in_h = _validate_resolution(input_wh) + out_w, out_h = _validate_resolution(resolution_wh) + + text = result.strip() + text = re.sub(r"^```(json)?", "", text, flags=re.IGNORECASE).strip() + text = re.sub(r"```$", "", text).strip() + + start = text.find("[") + end = text.rfind("]") + if start != -1 and end != -1 and end > start: + text = text[start : end + 1].strip() + + try: + data = json.loads(text) + except json.JSONDecodeError: + repaired = recover_truncated_qwen_2_5_vl_response(text) + if repaired is not None: + data = repaired + else: + try: + data = ast.literal_eval(text) + except (ValueError, SyntaxError, TypeError): + return ( + np.empty((0, 4)), + np.empty((0,), dtype=int), + np.empty((0,), dtype=str), + ) + + if not isinstance(data, list): + return (np.empty((0, 4)), np.empty((0,), dtype=int), np.empty((0,), dtype=str)) + + boxes_list = [] + labels_list = [] + + for item in data: + if not isinstance(item, dict) or "bbox_2d" not in item or "label" not in item: + continue + boxes_list.append(item["bbox_2d"]) + labels_list.append(item["label"]) + + if not boxes_list: + return (np.empty((0, 4)), np.empty((0,), dtype=int), np.empty((0,), dtype=str)) + + xyxy = np.array(boxes_list, dtype=float) + class_name = np.array(labels_list, dtype=str) + + xyxy = xyxy / [in_w, in_h, in_w, in_h] + xyxy = xyxy * [out_w, out_h, out_w, out_h] + + class_id = None + + if classes is not None: + mask = np.array([label in classes for label in class_name], dtype=bool) + xyxy = xyxy[mask] + class_name = class_name[mask] + class_id = np.array([classes.index(label) for label in class_name], dtype=int) + + return xyxy, class_id, class_name + + +def from_qwen_3_vl( + result: str, + resolution_wh: tuple[int, int], + classes: list[str] | None = None, +) -> tuple[npt.NDArray[Any], npt.NDArray[Any] | None, npt.NDArray[Any]]: + """ + Parse and scale bounding boxes from Qwen-3-VL style JSON output. + + Args: + result: String containing the Qwen-3-VL JSON output. + resolution_wh: Target resolution `(width, height)` to scale bounding boxes. + classes: Optional list of valid classes to filter results. + + Returns: + A tuple of `(xyxy, class_id, class_name)` where `xyxy` is an array of + shape `(N, 4)` in `(x_min, y_min, x_max, y_max)` format scaled to + `resolution_wh`, `class_id` is an optional array of class indices, + and `class_name` is an array of class names. + """ + return from_qwen_2_5_vl( + result=result, + input_wh=(1000, 1000), + resolution_wh=resolution_wh, + classes=classes, + ) + + +def from_deepseek_vl_2( + result: str, resolution_wh: tuple[int, int], classes: list[str] | None = None +) -> tuple[npt.NDArray[Any], npt.NDArray[Any] | None, npt.NDArray[Any]]: + """ + Parse bounding boxes from deepseek-vl2-formatted text, scale them to the specified + resolution, and optionally filter by classes. + + The DeepSeek-VL2 output typically contains pairs of <|ref|> ... <|/ref|> labels + and <|det|> ... <|/det|> bounding box definitions. Each <|det|> section may + contain one or more bounding boxes in the form [[x1, y1, x2, y2], [x1, y1, x2, y2], ...] + (scaled to 0..999). For example: + + ``` + <|ref|>The giraffe at the back<|/ref|><|det|>[[580, 270, 999, 904]]<|/det|><|ref|>The giraffe at the front<|/ref|><|det|>[[26, 31, 632, 998]]<|/det|><|endโ–ofโ–sentence|> + ``` + + Args: + result: String containing deepseek-vl2-formatted locations and labels. + resolution_wh: Tuple (width, height) to which we scale the box coordinates. + classes: Optional list of valid class names. If provided, boxes and labels not + in this list are filtered out. + + Returns: + A tuple of `(xyxy, class_id, class_name)` where `xyxy` is an array of + shape `(n, 4)` in format `[x1, y1, x2, y2]`, `class_id` is an + optional array of shape `(n,)` with class indices, and `class_name` + is an array of shape `(n,)` with class labels. When the input + contains no detections (or all are filtered by `classes`), returns + `(np.empty((0, 4)), np.empty(0), np.empty(0))`. + """ # noqa: E501 + + width, height = resolution_wh + label_segments = re.findall(r"<\|ref\|>(.*?)<\|/ref\|>", result, flags=re.S) + detection_segments = re.findall(r"<\|det\|>(.*?)<\|/det\|>", result, flags=re.S) + + if len(label_segments) != len(detection_segments): + raise ValueError( + f"Number of ref tags ({len(label_segments)}) " + f"and det tags ({len(detection_segments)}) in the result must be equal." + ) + + xyxy_list: list[list[float]] = [] + class_name_list: list[str] = [] + for label, detection_blob in zip(label_segments, detection_segments): + current_class_name = label.strip() + for box in re.findall(r"\[(.*?)\]", detection_blob): + x1, y1, x2, y2 = map(float, box.strip("[]").split(",")) + xyxy_list.append( + [ + (x1 / 999 * width), + (y1 / 999 * height), + (x2 / 999 * width), + (y2 / 999 * height), + ] + ) + class_name_list.append(current_class_name) + + xyxy = ( + np.array(xyxy_list, dtype=np.float32) + if xyxy_list + else np.empty((0, 4), dtype=np.float32) + ) + class_name = ( + np.array(class_name_list) if class_name_list else np.array([], dtype=object) + ) + + if classes is not None: + mask = np.array([name in classes for name in class_name], dtype=bool) + xyxy = xyxy[mask] + class_name = class_name[mask] + class_id = np.array([classes.index(name) for name in class_name]) + else: + unique_classes = sorted(list(set(class_name))) + class_to_id = {name: i for i, name in enumerate(unique_classes)} + class_id = np.array([class_to_id[name] for name in class_name]) + + return xyxy, class_id, class_name + + +def from_florence_2( + result: dict[str, Any], resolution_wh: tuple[int, int] +) -> tuple[ + npt.NDArray[Any], + npt.NDArray[Any] | None, + npt.NDArray[Any] | None, + npt.NDArray[Any] | None, +]: + """ + Parse results from the Florence 2 multi-model model. + https://huggingface.co/microsoft/Florence-2-large + + Args: + result: dict containing the model output + resolution_wh: (output_width, output_height) to which we rescale the boxes. + + Returns: + A tuple of `(xyxy, labels, masks, obb_boxes)` where `xyxy` is an array + of shape `(n, 4)` in format `[x1, y1, x2, y2]`, `labels` is an + optional array of shape `(n,)` with class labels, `masks` is an + optional array of shape `(n, h, w)` with segmentation masks, and + `obb_boxes` is an optional array of shape `(n, 4, 2)` with oriented + bounding boxes. + + Raises: + ValueError: If the top-level Florence 2 payload has multiple tasks or + if a task payload is malformed. + """ + if len(result) != 1: + raise ValueError(f"Expected result with a single element. Got: {result}") + task = next(iter(result.keys())) + if task not in SUPPORTED_TASKS_FLORENCE_2: + raise ValueError( + f"{task} not supported. Supported tasks are: {SUPPORTED_TASKS_FLORENCE_2}" + ) + result = result[task] + + if task in ["", "", ""]: + xyxy = np.array(result["bboxes"], dtype=np.float32) + labels = np.array(result["labels"]) + return xyxy, labels, None, None + + if task == "": + xyxy = np.array(result["bboxes"], dtype=np.float32) + # provides labels, but they are ["", "", "", ...] + return xyxy, None, None, None + + if task == "": + xyxyxyxy = np.array(result["quad_boxes"], dtype=np.float32) + xyxyxyxy = xyxyxyxy.reshape(-1, 4, 2) + xyxy = np.array([polygon_to_xyxy(polygon) for polygon in xyxyxyxy]) + labels = np.array(result["labels"]) + return xyxy, labels, None, xyxyxyxy + + if task in ["", ""]: + xyxy_list: list[npt.NDArray[Any]] = [] + masks_list: list[npt.NDArray[Any]] = [] + for polygons_of_same_class in result["polygons"]: + for polygon in polygons_of_same_class: + polygon = np.reshape(polygon, (-1, 2)).astype(np.int32) + mask = polygon_to_mask(polygon, resolution_wh).astype(bool) + masks_list.append(mask) + xyxy_box = polygon_to_xyxy(polygon) + xyxy_list.append(xyxy_box) + # per-class labels also provided, but they are ["", "", "", ...] + # when we figure out how to set class names, we can do + # zip(result["labels"], result["polygons"]) + xyxy = np.array(xyxy_list, dtype=np.float32) + masks = np.array(masks_list) + return xyxy, None, masks, None + + if task == "": + xyxy = np.array(result["bboxes"], dtype=np.float32) + labels = np.array(result["bboxes_labels"]) + # Also has "polygons" and "polygons_labels", but they don't seem to be used + return xyxy, labels, None, None + + if task in ["", ""]: + if not isinstance(result, str): + raise ValueError(f"Expected string as {task} result, got {type(result)}") + + if result == "No object detected.": + return np.empty((0, 4), dtype=np.float32), np.array([]), None, None + + pattern = re.compile(r"") + match = pattern.search(result) + if match is None: + raise ValueError( + f"Expected string to end in location tags, but got {result}" + ) + + w, h = _validate_resolution(resolution_wh) + xyxy = np.array([match.groups()], dtype=np.float32) + xyxy *= np.array([w, h, w, h]) / 1000 + result_string = result[: match.start()] + labels = np.array([result_string]) + return xyxy, labels, None, None + + raise RuntimeError(f"Unimplemented task: {task}") + + +def from_google_gemini_2_0( + result: str, + resolution_wh: tuple[int, int], + classes: list[str] | None = None, +) -> tuple[npt.NDArray[Any], npt.NDArray[Any] | None, npt.NDArray[Any]]: + """ + Parse and scale bounding boxes from Google Gemini style + [JSON output](https://ai.google.dev/gemini-api/docs/vision?lang=python). + + The JSON is expected to be enclosed in triple backticks with the format: + ```json + [ + {"box_2d": [x1, y1, x2, y2], "label": "some class name"}, + ... + ] + ``` + + For example: + ```json + [ + {"box_2d": [10, 20, 110, 120], "label": "cat"}, + {"box_2d": [50, 100, 150, 200], "label": "dog"} + ] + ``` + + Args: + result: String containing the JSON snippet enclosed by triple backticks. + resolution_wh: (output_width, output_height) to which we rescale the boxes. + classes: Optional list of valid class names. If provided, returned boxes/labels + are filtered to only those classes found here. + + Returns: + A tuple of `(xyxy, class_id, class_name)` where `xyxy` is an array of + shape `(n, 4)` in format `[x1, y1, x2, y2]`, `class_id` is an + optional array of shape `(n,)` with class indices, and `class_name` + is an array of shape `(n,)` with class labels. + + """ + + w, h = _validate_resolution(resolution_wh) + + lines = result.splitlines() + for i, line in enumerate(lines): + if line == "```json": + result = "\n".join(lines[i + 1 :]) + result = result.split("```")[0] + break + + try: + data = json.loads(result) + except json.JSONDecodeError: + return np.empty((0, 4)), np.empty((0,), dtype=int), np.empty((0,), dtype=str) + + if not isinstance(data, list): + return np.empty((0, 4)), np.empty((0,), dtype=int), np.empty((0,), dtype=str) + + labels = [] + xyxy = [] + + for item in data: + if not isinstance(item, dict) or "box_2d" not in item or "label" not in item: + continue + labels.append(item["label"]) + box = item["box_2d"] + # Gemini bbox order is [y_min, x_min, y_max, x_max] + xyxy.append([box[1], box[0], box[3], box[2]]) + + if len(xyxy) == 0: + return np.empty((0, 4)), np.empty((0,), dtype=int), np.empty((0,), dtype=str) + + xyxy = denormalize_boxes( + np.array(xyxy, dtype=np.float64), + resolution_wh=(w, h), + normalization_factor=1000, + ) + class_name = np.array(labels) + class_id = None + + if classes is not None: + mask = np.array([name in classes for name in class_name], dtype=bool) + xyxy = xyxy[mask] + class_name = class_name[mask] + class_id = np.array([classes.index(name) for name in class_name]) + + return xyxy, class_id, class_name + + +def from_google_gemini_2_5( + result: str, + resolution_wh: tuple[int, int], + classes: list[str] | None = None, +) -> tuple[ + npt.NDArray[Any], + npt.NDArray[Any] | None, + npt.NDArray[Any], + npt.NDArray[Any] | None, + npt.NDArray[Any] | None, +]: + """ + Parse and scale bounding boxes and masks from Google Gemini 2.5 style + [JSON output](https://ai.google.dev/gemini-api/docs/vision?lang=python). + + The JSON is expected to be enclosed in triple backticks with the format: + ```json + [ + { + "box_2d": [x1, y1, x2, y2], + "mask": "data:image/png;base64,...", + "label": "some class name", + "confidence": 0.95, + }, + ... + ] + ``` + + Args: + result: String containing the JSON snippet enclosed by triple backticks. + resolution_wh: (output_width, output_height) to which we rescale the boxes. + classes: Optional list of valid class names. If provided, returned boxes/labels + are filtered to only those classes found here. + + Returns: + A tuple of `(xyxy, class_id, class_name, confidence, masks)` where + `xyxy` is an array of shape `(n, 4)` in format `[x1, y1, x2, y2]`, + `class_id` is an array of shape `(n,)` with class indices, + `class_name` is an array of shape `(n,)` with class labels, + `confidence` is an optional array of shape `(n,)` with confidence + scores, and `masks` is an optional array of shape `(n, h, w)` with + segmentation masks. + """ + w, h = _validate_resolution(resolution_wh) + + lines = result.splitlines() + for i, line in enumerate(lines): + if line == "```json": + result = "\n".join(lines[i + 1 :]) + result = result.split("```")[0] + break + + try: + data = json.loads(result) + except json.JSONDecodeError: + return ( + np.empty((0, 4)), + np.array([], dtype=int), + np.array([], dtype=str), + np.array([], dtype=float), + None, + ) + + if not isinstance(data, list): + return ( + np.empty((0, 4)), + np.array([], dtype=int), + np.array([], dtype=str), + np.array([], dtype=float), + None, + ) + + boxes_list: list[Any] = [] + labels_list: list[str] = [] + confidence_list: list[float] | None = [] + masks_list: list[npt.NDArray[Any]] | None = [] + + for item in data: + if not isinstance(item, dict) or "box_2d" not in item or "label" not in item: + continue + labels_list.append(item["label"]) + box = item["box_2d"] + # Gemini bbox order is [y_min, x_min, y_max, x_max] + absolute_bbox = denormalize_boxes( + np.array([[box[1], box[0], box[3], box[2]]]).astype(np.float64), + resolution_wh=(w, h), + normalization_factor=1000, + )[0] + boxes_list.append(absolute_bbox) + + if "mask" in item: + if masks_list is not None: + png_str = item["mask"] + if not isinstance(png_str, str) or not png_str.startswith( + "data:image/png;base64," + ): + # Malformed mask: keep an empty mask but still fall through to + # the confidence handling below, so the per-item arrays stay + # aligned (a `continue` here desynced confidence vs boxes). + masks_list.append(np.zeros((h, w), dtype=bool)) + else: + png_str = png_str.removeprefix("data:image/png;base64,") + try: + png_bytes = base64.b64decode(png_str) + mask_img = Image.open(io.BytesIO(png_bytes)).convert("L") + except Exception: + masks_list.append(np.zeros((h, w), dtype=bool)) + else: + y_min, y_max = int(absolute_bbox[1]), int(absolute_bbox[3]) + x_min, x_max = int(absolute_bbox[0]), int(absolute_bbox[2]) + + bbox_height = y_max - y_min + bbox_width = x_max - x_min + + if bbox_height > 0 and bbox_width > 0: + mask_img = mask_img.resize( + (bbox_width, bbox_height), + resample=Image.Resampling.BILINEAR, + ) + np_mask: npt.NDArray[np.bool_] = np.zeros( + (h, w), dtype=bool + ) + np_mask[y_min:y_max, x_min:x_max] = np.array(mask_img) > 0 + masks_list.append(np_mask) + else: + masks_list.append(np.zeros((h, w), dtype=bool)) + else: + masks_list = None + + if "confidence" in item: + if confidence_list is not None: + confidence_list.append(item["confidence"]) + else: + confidence_list = None + + if not boxes_list: + return ( + np.empty((0, 4)), + np.array([], dtype=int), + np.array([], dtype=str), + np.array([], dtype=float), + None, + ) + + xyxy = np.array(boxes_list, dtype=float) + class_name = np.array(labels_list) + class_id: npt.NDArray[Any] + + if classes is not None: + mask = np.array([name in classes for name in class_name], dtype=bool) + xyxy = xyxy[mask] + class_name = class_name[mask] + class_id = np.array([classes.index(name) for name in class_name]) + if masks_list is not None: + masks_list = [m for m, keep in zip(masks_list, mask) if keep] + + if confidence_list is not None: + confidence_list = [c for c, keep in zip(confidence_list, mask) if keep] + else: + unique_labels = sorted(list(set(class_name))) + label_to_id = {label: i for i, label in enumerate(unique_labels)} + class_id = np.array([label_to_id[name] for name in class_name]) + + confidence = ( + np.array(confidence_list, dtype=float) if confidence_list is not None else None + ) + masks = np.array(masks_list) if masks_list is not None else None + + return ( + xyxy, + class_id, + class_name, + confidence, + masks, + ) + + +def from_moondream( + result: dict[str, Any], + resolution_wh: tuple[int, int], +) -> npt.NDArray[Any]: + """ + Parse and scale bounding boxes from moondream JSON output. + + The JSON is expected to have a key "objects" with a list of dictionaries: + { + "objects": [ + {"x_min": 0.1, "y_min": 0.2, "x_max": 0.3, "y_max": 0.4}, + ... + ] + } + + For Example: + { + "objects": [ + {"x_min": 0.1, "y_min": 0.2, "x_max": 0.3, "y_max": 0.4}, + {"x_min": 0.5, "y_min": 0.6, "x_max": 0.7, "y_max": 0.8} + ] + } + + Args: + result: Dictionary containing the JSON output from the model. + resolution_wh: (output_width, output_height) to which we rescale the boxes. + + Returns: + An array of shape `(n, 4)` containing the bounding boxes coordinates + in format `[x1, y1, x2, y2]`. + """ + + w, h = resolution_wh + if w <= 0 or h <= 0: + raise ValueError( + f"Both dimensions in resolution_wh must be positive. Got ({w}, {h})." + ) + + if "objects" not in result or not isinstance(result["objects"], list): + return np.empty((0, 4), dtype=float) + + xyxy = [] + + for item in result["objects"]: + if not all(k in item for k in ["x_min", "y_min", "x_max", "y_max"]): + continue + + x_min = item["x_min"] + y_min = item["y_min"] + x_max = item["x_max"] + y_max = item["y_max"] + + xyxy.append([x_min, y_min, x_max, y_max]) + + if len(xyxy) == 0: + return cast(npt.NDArray[Any], np.empty((0, 4))) + + return cast( + npt.NDArray[Any], + denormalize_boxes( + np.array(xyxy).astype(np.float64), + resolution_wh=(w, h), + ), + ) diff --git a/src/supervision/draw/__init__.py b/src/supervision/draw/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/src/supervision/draw/base.py b/src/supervision/draw/base.py new file mode 100644 index 0000000..0f3d50c --- /dev/null +++ b/src/supervision/draw/base.py @@ -0,0 +1,14 @@ +from typing import TypeVar + +import numpy as np +import numpy.typing as npt +from PIL import Image + +ImageType = TypeVar("ImageType", npt.NDArray[np.uint8], Image.Image) +""" +An image of type `np.ndarray` or `PIL.Image.Image`. + +Unlike a `Union`, ensures the type remains consistent. If a function +takes an `ImageType` argument and returns an `ImageType`, when you +pass an `np.ndarray`, you will get an `np.ndarray` back. +""" diff --git a/src/supervision/draw/color.py b/src/supervision/draw/color.py new file mode 100644 index 0000000..c99f4cc --- /dev/null +++ b/src/supervision/draw/color.py @@ -0,0 +1,598 @@ +from __future__ import annotations + +from dataclasses import dataclass +from typing import Any, cast + +from supervision.utils.internal import classproperty + +DEFAULT_COLOR_PALETTE = [ + "A351FB", + "FF4040", + "FFA1A0", + "FF7633", + "FFB633", + "D1D435", + "4CFB12", + "94CF1A", + "40DE8A", + "1B9640", + "00D6C1", + "2E9CAA", + "00C4FF", + "364797", + "6675FF", + "0019EF", + "863AFF", + "530087", + "CD3AFF", + "FF97CA", + "FF39C9", +] + +LEGACY_COLOR_PALETTE = [ + "#A351FB", + "#E6194B", + "#3CB44B", + "#FFE119", + "#0082C8", + "#F58231", + "#911EB4", + "#46F0F0", + "#F032E6", + "#D2F53C", + "#FABEBE", + "#008080", + "#E6BEFF", + "#AA6E28", + "#FFFAC8", + "#800000", + "#AAFFC3", +] + +ROBOFLOW_COLOR_PALETTE = ["C28DFC", "A351FB", "8315F9", "6706CE", "5905B3", "4D049A"] + + +def _validate_color_hex(color_hex: str) -> None: + color_hex = color_hex.lstrip("#") + if not all(c in "0123456789abcdefABCDEF" for c in color_hex): + raise ValueError("Invalid characters in color hash") + if len(color_hex) not in (3, 4, 6, 8): + raise ValueError("Invalid length of color hash") + + +@dataclass +class Color: + """ + Represents a color in RGBA format. + + This class provides methods to work with colors, including creating colors from hex + codes, converting colors to hex strings, RGB tuples, BGR tuples, RGBA tuples, + and BGRA tuples. + + Attributes: + r: Red channel value (0-255). + g: Green channel value (0-255). + b: Blue channel value (0-255). + a: Alpha channel value (0-255). Default is 255 (fully opaque). + + Example: + ```pycon + >>> import supervision as sv + >>> sv.Color.WHITE + Color(r=255, g=255, b=255) + + ``` + + | Constant | Hex Code | RGB | + |------------|------------|-------------------| + | `WHITE` | `#FFFFFF` | `(255, 255, 255)` | + | `BLACK` | `#000000` | `(0, 0, 0)` | + | `GREY` | `#808080` | `(128, 128, 128)` | + | `RED` | `#FF0000` | `(255, 0, 0)` | + | `GREEN` | `#00FF00` | `(0, 255, 0)` | + | `BLUE` | `#0000FF` | `(0, 0, 255)` | + | `YELLOW` | `#FFFF00` | `(255, 255, 0)` | + | `ROBOFLOW` | `#A351FB` | `(163, 81, 251)` | + """ + + r: int + g: int + b: int + a: int = 255 + + def __post_init__(self) -> None: + """Validate that direct Color construction uses byte-sized channels.""" + if not ( + 0 <= self.r <= 255 + and 0 <= self.g <= 255 + and 0 <= self.b <= 255 + and 0 <= self.a <= 255 + ): + raise ValueError( + "Color values must be in range 0-255, " + f"got ({self.r}, {self.g}, {self.b}, {self.a})" + ) + + @classmethod + def from_hex(cls, color_hex: str) -> Color: + """ + Create a Color instance from a hex string. + + Args: + color_hex: The hex string representing the color. This string can + start with '#' followed by 3, 4, 6, or 8 hexadecimal characters. + For 3- or 4-character codes, each character is doubled to form the + full hex code. + + Returns: + An instance representing the color. + + Example: + ```pycon + >>> import supervision as sv + >>> sv.Color.from_hex('#ff00ff') + Color(r=255, g=0, b=255) + >>> sv.Color.from_hex('#f0f') + Color(r=255, g=0, b=255) + + >>> sv.Color.from_hex('#ff00ff80') + Color(r=255, g=0, b=255, a=128) + >>> sv.Color.from_hex('#f0f8') + Color(r=255, g=0, b=255, a=136) + + ``` + """ + _validate_color_hex(color_hex) + color_hex = color_hex.lstrip("#") + if len(color_hex) == 3: + color_hex = "".join(c * 2 for c in color_hex) + elif len(color_hex) == 4: + color_hex = "".join(c * 2 for c in color_hex) + + if len(color_hex) == 6: + r, g, b = (int(color_hex[i : i + 2], 16) for i in range(0, 6, 2)) + return cls(r, g, b) + else: # len(color_hex) == 8 + r, g, b, a = (int(color_hex[i : i + 2], 16) for i in range(0, 8, 2)) + return cls(r, g, b, a) + + @classmethod + def from_rgb_tuple(cls, color_tuple: tuple[int, int, int]) -> Color: + """ + Create a Color instance from an RGB tuple. + + Args: + color_tuple: A tuple representing the color in RGB format, where each + element is an integer in the range 0-255. + + Returns: + An instance representing the color. + + Raises: + ValueError: If any RGB value is outside the range 0-255. + + Example: + ```pycon + >>> import supervision as sv + >>> sv.Color.from_rgb_tuple((255, 255, 0)) + Color(r=255, g=255, b=0) + + ``` + """ + r, g, b = color_tuple + if not (0 <= r <= 255 and 0 <= g <= 255 and 0 <= b <= 255): + raise ValueError(f"RGB values must be in range 0-255, got ({r}, {g}, {b})") + return cls(r=r, g=g, b=b) + + @classmethod + def from_bgr_tuple(cls, color_tuple: tuple[int, int, int]) -> Color: + """ + Create a Color instance from a BGR tuple. + + Args: + color_tuple: A tuple representing the color in BGR format, where each + element is an integer in the range 0-255. + + Returns: + An instance representing the color. + + Raises: + ValueError: If any BGR value is outside the range 0-255. + + Example: + ```pycon + >>> import supervision as sv + >>> sv.Color.from_bgr_tuple((0, 255, 255)) + Color(r=255, g=255, b=0) + + ``` + """ + b, g, r = color_tuple + if not (0 <= r <= 255 and 0 <= g <= 255 and 0 <= b <= 255): + raise ValueError(f"BGR values must be in range 0-255, got ({b}, {g}, {r})") + return cls(r=r, g=g, b=b) + + @classmethod + def from_rgba_tuple(cls, color_tuple: tuple[int, int, int, int]) -> Color: + """ + Create a Color instance from an RGBA tuple. + + Args: + color_tuple: A tuple representing the color in RGBA format, where each + element is an integer in the range 0-255. + + Returns: + An instance representing the color. + + Raises: + ValueError: If any RGBA value is outside the range 0-255. + + Example: + ```pycon + >>> import supervision as sv + >>> sv.Color.from_rgba_tuple((255, 255, 0, 128)) + Color(r=255, g=255, b=0, a=128) + + ``` + """ + r, g, b, a = color_tuple + if not (0 <= r <= 255 and 0 <= g <= 255 and 0 <= b <= 255 and 0 <= a <= 255): + raise ValueError( + f"RGBA values must be in range 0-255, got ({r}, {g}, {b}, {a})" + ) + return cls(r=r, g=g, b=b, a=a) + + @classmethod + def from_bgra_tuple(cls, color_tuple: tuple[int, int, int, int]) -> Color: + """ + Create a Color instance from a BGRA tuple. + + Args: + color_tuple: A tuple representing the color in BGRA format, where each + element is an integer in the range 0-255. + + Returns: + An instance representing the color. + + Raises: + ValueError: If any BGRA value is outside the range 0-255. + + Example: + ```pycon + >>> import supervision as sv + >>> sv.Color.from_bgra_tuple((0, 255, 255, 128)) + Color(r=255, g=255, b=0, a=128) + + ``` + """ + b, g, r, a = color_tuple + if not (0 <= r <= 255 and 0 <= g <= 255 and 0 <= b <= 255 and 0 <= a <= 255): + raise ValueError( + f"BGRA values must be in range 0-255, got ({b}, {g}, {r}, {a})" + ) + return cls(r=r, g=g, b=b, a=a) + + def as_hex(self) -> str: + """ + Converts the Color instance to a hex string. + + Returns: + The hexadecimal color string. Returns `#RRGGBBAA` if alpha is not 255, + otherwise returns `#RRGGBB`. + + Example: + ```pycon + >>> import supervision as sv + >>> sv.Color(r=255, g=255, b=0).as_hex() + '#ffff00' + + >>> sv.Color(r=255, g=0, b=255, a=128).as_hex() + '#ff00ff80' + + ``` + """ + if self.a != 255: + return f"#{self.r:02x}{self.g:02x}{self.b:02x}{self.a:02x}" + return f"#{self.r:02x}{self.g:02x}{self.b:02x}" + + def as_rgb(self) -> tuple[int, int, int]: + """ + Returns the color as an RGB tuple. + + Returns: + RGB tuple. + + Example: + ```pycon + >>> import supervision as sv + >>> sv.Color(r=255, g=255, b=0).as_rgb() + (255, 255, 0) + + ``` + """ + return self.r, self.g, self.b + + def as_bgr(self) -> tuple[int, int, int]: + """ + Returns the color as a BGR tuple. + + Returns: + BGR tuple. + + Example: + ```pycon + >>> import supervision as sv + >>> sv.Color(r=255, g=255, b=0).as_bgr() + (0, 255, 255) + + ``` + """ + return self.b, self.g, self.r + + def as_rgba(self) -> tuple[int, int, int, int]: + """ + Returns the color as an RGBA tuple. + + Returns: + RGBA tuple. + + Example: + ```pycon + >>> import supervision as sv + >>> sv.Color(r=255, g=255, b=0, a=128).as_rgba() + (255, 255, 0, 128) + + ``` + """ + return self.r, self.g, self.b, self.a + + def as_bgra(self) -> tuple[int, int, int, int]: + """ + Returns the color as a BGRA tuple. + + Returns: + BGRA tuple. + + Example: + ```pycon + >>> import supervision as sv + >>> sv.Color(r=255, g=255, b=0, a=128).as_bgra() + (0, 255, 255, 128) + + ``` + """ + return self.b, self.g, self.r, self.a + + @classproperty + def WHITE(cls) -> Color: + return Color.from_hex("#FFFFFF") + + @classproperty + def BLACK(cls) -> Color: + return Color.from_hex("#000000") + + @classproperty + def GREY(cls) -> Color: + return Color.from_hex("#808080") + + @classproperty + def RED(cls) -> Color: + return Color.from_hex("#FF0000") + + @classproperty + def GREEN(cls) -> Color: + return Color.from_hex("#00FF00") + + @classproperty + def BLUE(cls) -> Color: + return Color.from_hex("#0000FF") + + @classproperty + def YELLOW(cls) -> Color: + return Color.from_hex("#FFFF00") + + @classproperty + def ROBOFLOW(cls) -> Color: + return Color.from_hex("#A351FB") + + def __hash__(self) -> int: + return hash((self.r, self.g, self.b, self.a)) + + def __repr__(self) -> str: + if self.a == 255: + return f"Color(r={self.r}, g={self.g}, b={self.b})" + return f"Color(r={self.r}, g={self.g}, b={self.b}, a={self.a})" + + def __eq__(self, other: Any) -> bool: + return ( + isinstance(other, Color) + and self.r == other.r + and self.g == other.g + and self.b == other.b + and self.a == other.a + ) + + +@dataclass +class ColorPalette: + colors: list[Color] + + @classproperty + def DEFAULT(cls) -> ColorPalette: + """ + Returns a default color palette. + + Returns: + A ColorPalette instance with default colors. + + Example: + ```pycon + >>> import supervision as sv + >>> sv.ColorPalette.DEFAULT # doctest: +ELLIPSIS + ColorPalette(colors=[Color(r=163, g=81, b=251), Color(r=255, g=64, b=64), ...]) + + ``` + + ![default-color-palette](https://media.roboflow.com/ + supervision-annotator-examples/default-color-palette.png) + """ # noqa: E501 // docs + return ColorPalette.from_hex(color_hex_list=DEFAULT_COLOR_PALETTE) + + @classproperty + def ROBOFLOW(cls) -> ColorPalette: + """ + Returns a Roboflow color palette. + + Returns: + A ColorPalette instance with Roboflow colors. + + Example: + ```pycon + >>> import supervision as sv + >>> sv.ColorPalette.ROBOFLOW # doctest: +ELLIPSIS + ColorPalette(colors=[Color(r=194, g=141, b=252), Color(r=163, g=81, b=251), ...]) + + ``` + + ![roboflow-color-palette](https://media.roboflow.com/ + supervision-annotator-examples/roboflow-color-palette.png) + """ # noqa: E501 // docs + return ColorPalette.from_hex(color_hex_list=ROBOFLOW_COLOR_PALETTE) + + @classproperty + def LEGACY(cls) -> ColorPalette: + return ColorPalette.from_hex(color_hex_list=LEGACY_COLOR_PALETTE) + + @classmethod + def from_hex(cls, color_hex_list: list[str]) -> ColorPalette: + """ + Create a ColorPalette instance from a list of hex strings. + + Args: + color_hex_list: List of color hex strings. + + Returns: + A ColorPalette instance. + + Example: + ```pycon + >>> import supervision as sv + >>> colors = ['#ff0000', '#00ff00', '#0000ff'] + >>> sv.ColorPalette.from_hex(colors) # doctest: +ELLIPSIS + ColorPalette(colors=[Color(r=255, g=0, b=0), Color(r=0, g=255, b=0), ...]) + + ``` + """ + colors = [Color.from_hex(color_hex) for color_hex in color_hex_list] + return cls(colors) + + @classmethod + def from_matplotlib(cls, palette_name: str, color_count: int) -> ColorPalette: + """ + Create a ColorPalette instance from a Matplotlib color palette. + + Args: + palette_name: Name of the Matplotlib palette. + color_count: Number of colors to sample from the palette. + + Returns: + A ColorPalette instance. + + Example: + ```pycon + >>> import supervision as sv + >>> sv.ColorPalette.from_matplotlib('viridis', 5) # doctest: +ELLIPSIS + ColorPalette(colors=[Color(r=68, g=1, b=84), Color(r=58, g=82, b=139), ...]) + + ``` + + ![visualized_color_palette](https://media.roboflow.com/ + supervision-annotator-examples/visualized_color_palette.png) + """ + if color_count < 1: + raise ValueError("color_count must be greater than or equal to 1") + + # Keep pyplot lazy so importing color utilities does not import matplotlib. + import matplotlib.pyplot as plt + + mpl_palette = plt.get_cmap(palette_name) + if hasattr(mpl_palette, "resampled"): + mpl_palette = mpl_palette.resampled(color_count) + + if hasattr(mpl_palette, "colors"): + colors = mpl_palette.colors + else: + # A single color samples the palette start and avoids division by zero. + positions = ( + [0.0] + if color_count == 1 + else [i / (color_count - 1) for i in range(color_count)] + ) + colors = [mpl_palette(position) for position in positions] + + return cls( + [Color(int(r * 255), int(g * 255), int(b * 255)) for r, g, b, _ in colors] + ) + + def by_idx(self, idx: int) -> Color: + """ + Return the color at a given index in the palette. + + Args: + idx: Index of the color in the palette. + + Returns: + Color at the given index. + + Example: + ```pycon + >>> import supervision as sv + >>> colors = ['#ff0000', '#00ff00', '#0000ff'] + >>> color_palette = sv.ColorPalette.from_hex(colors) + >>> color_palette.by_idx(1) + Color(r=0, g=255, b=0) + + ``` + """ + if not self.colors: + raise ValueError("ColorPalette must contain at least one color") + # Modulo preserves Python-like wrapping for negative and oversized indexes. + idx = idx % len(self.colors) + return self.colors[idx] + + def __len__(self) -> int: + """ + Returns the number of colors in the palette. + + Returns: + The number of colors. + """ + return len(self.colors) + + +def unify_to_bgr(color: tuple[int, int, int] | Color) -> tuple[int, int, int]: + """ + Converts a color input in multiple formats to a standardized BGR format. + + Args: + color: The color input to be converted, + which can be either a tuple of BGR values or an instance of a Color class. + + Returns: + The color in BGR format as a tuple of three integers. + + Example: + ```pycon + >>> from supervision.draw.color import unify_to_bgr, Color + >>> unify_to_bgr(Color.WHITE) + (255, 255, 255) + >>> unify_to_bgr((0, 255, 255)) + (0, 255, 255) + + ``` + """ + if issubclass(type(color), Color): + color = cast(Color, color) + return color.as_bgr() + color = cast(tuple[int, int, int], color) + return color diff --git a/src/supervision/draw/utils.py b/src/supervision/draw/utils.py new file mode 100644 index 0000000..52e53db --- /dev/null +++ b/src/supervision/draw/utils.py @@ -0,0 +1,527 @@ +import os +from typing import cast + +import cv2 +import numpy as np +import numpy.typing as npt + +from supervision.draw.color import Color +from supervision.geometry.core import Point, Rect + + +def draw_line( + scene: npt.NDArray[np.uint8], + start: Point, + end: Point, + color: Color = Color.ROBOFLOW, + thickness: int = 2, +) -> npt.NDArray[np.uint8]: + """ + Draws a line on a given scene. + + Args: + scene: The scene on which the line will be drawn + start: The starting point of the line + end: The end point of the line + color: The color of the line, defaults to Color.ROBOFLOW + thickness: The thickness of the line + + Returns: + The scene with the line drawn on it + + Example: + ```python + import numpy as np + from supervision.draw.utils import draw_line + from supervision.draw.color import Color + from supervision.geometry.core import Point + + scene = np.zeros((100, 100, 3), dtype=np.uint8) + scene = draw_line( + scene, start=Point(x=10, y=10), end=Point(x=90, y=90), color=Color.RED + ) + ``` + """ + cv2.line( + scene, + start.as_xy_int_tuple(), + end.as_xy_int_tuple(), + color.as_bgr(), + thickness=thickness, + ) + return scene + + +def draw_rectangle( + scene: npt.NDArray[np.uint8], + rect: Rect, + color: Color = Color.ROBOFLOW, + thickness: int = 2, +) -> npt.NDArray[np.uint8]: + """ + Draws a rectangle on an image. + + Args: + scene: The scene on which the rectangle will be drawn + rect: The rectangle to be drawn + color: The color of the rectangle + thickness: The thickness of the rectangle border + + Returns: + The scene with the rectangle drawn on it + + Example: + ```python + import numpy as np + from supervision.draw.utils import draw_rectangle + from supervision.draw.color import Color + from supervision.geometry.core import Rect + + scene = np.zeros((100, 100, 3), dtype=np.uint8) + rect = Rect(x=10, y=10, width=50, height=30) + scene = draw_rectangle(scene, rect, color=Color.RED) + ``` + """ + cv2.rectangle( + scene, + rect.top_left.as_xy_int_tuple(), + rect.bottom_right.as_xy_int_tuple(), + color.as_bgr(), + thickness=thickness, + ) + return scene + + +def draw_filled_rectangle( + scene: npt.NDArray[np.uint8], + rect: Rect, + color: Color = Color.ROBOFLOW, + opacity: float = 1, +) -> npt.NDArray[np.uint8]: + """ + Draws a filled rectangle on an image. + + Args: + scene: The scene on which the rectangle will be drawn + rect: The rectangle to be drawn + color: The color of the rectangle + opacity: The opacity of rectangle when drawn on the scene. + + Returns: + The scene with the rectangle drawn on it + + Example: + ```python + import numpy as np + from supervision.draw.utils import draw_filled_rectangle + from supervision.draw.color import Color + from supervision.geometry.core import Rect + + scene = np.zeros((100, 100, 3), dtype=np.uint8) + rect = Rect(x=10, y=10, width=50, height=30) + scene = draw_filled_rectangle(scene, rect, color=Color.RED, opacity=0.5) + ``` + """ + if opacity == 1: + cv2.rectangle( + scene, + rect.top_left.as_xy_int_tuple(), + rect.bottom_right.as_xy_int_tuple(), + color.as_bgr(), + -1, + ) + else: + scene_with_annotations = scene.copy() + cv2.rectangle( + scene_with_annotations, + rect.top_left.as_xy_int_tuple(), + rect.bottom_right.as_xy_int_tuple(), + color.as_bgr(), + -1, + ) + cv2.addWeighted( + scene_with_annotations, opacity, scene, 1 - opacity, gamma=0, dst=scene + ) + + return scene + + +def draw_rounded_rectangle( + scene: npt.NDArray[np.uint8], + rect: Rect, + color: Color, + border_radius: int, +) -> npt.NDArray[np.uint8]: + """ + Draws a rounded rectangle on an image. + + Args: + scene: The image on which the rounded rectangle will be drawn. + rect: The rectangle to be drawn. + color: The color of the rounded rectangle. + border_radius: The radius of the corner rounding in pixels. Values <= 0 + (or values clamped to 0 when the rectangle is too small) draw a + plain filled rectangle with square corners. Note: previously, + a negative value that remained negative after clamping would raise + ``cv2.error``; it now draws square corners silently. + + Returns: + The image with the rounded rectangle drawn on it. + + Example: + ```python + import numpy as np + from supervision.draw.utils import draw_rounded_rectangle + from supervision.draw.color import Color + from supervision.geometry.core import Rect + + scene = np.zeros((200, 300, 3), dtype=np.uint8) + rect = Rect(x=20, y=30, width=120, height=80) + scene = draw_rounded_rectangle(scene, rect, Color.RED, border_radius=0) + ``` + """ + x1, y1, x2, y2 = rect.as_xyxy_int_tuple() + width, height = x2 - x1, y2 - y1 + border_radius = min(border_radius, min(width, height) // 2) + + if border_radius <= 0: + # square corners: a single fill rectangle (the common default), rather + # than two rectangles plus four zero-radius corner circles + cv2.rectangle( + img=scene, + pt1=(x1, y1), + pt2=(x2, y2), + color=color.as_bgr(), + thickness=-1, + ) + return scene + + rectangle_coordinates = [ + ((x1 + border_radius, y1), (x2 - border_radius, y2)), + ((x1, y1 + border_radius), (x2, y2 - border_radius)), + ] + circle_centers = [ + (x1 + border_radius, y1 + border_radius), + (x2 - border_radius, y1 + border_radius), + (x1 + border_radius, y2 - border_radius), + (x2 - border_radius, y2 - border_radius), + ] + + for coordinates in rectangle_coordinates: + cv2.rectangle( + img=scene, + pt1=coordinates[0], + pt2=coordinates[1], + color=color.as_bgr(), + thickness=-1, + ) + for center in circle_centers: + cv2.circle( + img=scene, + center=center, + radius=border_radius, + color=color.as_bgr(), + thickness=-1, + ) + return scene + + +def draw_polygon( + scene: npt.NDArray[np.uint8], + polygon: npt.NDArray[np.int_], + color: Color = Color.ROBOFLOW, + thickness: int = 2, +) -> npt.NDArray[np.uint8]: + """Draw a polygon on a scene. + + Args: + scene: The scene to draw the polygon on. + polygon: The polygon to be drawn, given as a list of vertices. + color: The color of the polygon. Defaults to Color.ROBOFLOW. + thickness: The thickness of the polygon lines, by default 2. + + Returns: + The scene with the polygon drawn on it. + + Example: + ```python + import numpy as np + from supervision.draw.utils import draw_polygon + from supervision.draw.color import Color + + scene = np.zeros((100, 100, 3), dtype=np.uint8) + polygon = np.array([[10, 10], [90, 10], [90, 90], [10, 90]]) + scene = draw_polygon(scene, polygon, color=Color.RED) + ``` + """ + cv2.polylines( + scene, [polygon], isClosed=True, color=color.as_bgr(), thickness=thickness + ) + return scene + + +def draw_filled_polygon( + scene: npt.NDArray[np.uint8], + polygon: npt.NDArray[np.int_], + color: Color = Color.ROBOFLOW, + opacity: float = 1, +) -> npt.NDArray[np.uint8]: + """Draw a filled polygon on a scene. + + Args: + scene: The scene to draw the polygon on. + polygon: The polygon to be drawn, given as a list of vertices. + color: The color of the polygon. Defaults to Color.ROBOFLOW. + opacity: The opacity of polygon when drawn on the scene. + + Returns: + The scene with the polygon drawn on it. + + Example: + ```python + import numpy as np + from supervision.draw.utils import draw_filled_polygon + from supervision.draw.color import Color + + scene = np.zeros((100, 100, 3), dtype=np.uint8) + polygon = np.array([[10, 10], [90, 10], [90, 90], [10, 90]]) + scene = draw_filled_polygon(scene, polygon, color=Color.RED, opacity=0.5) + ``` + """ + if opacity == 1: + cv2.fillPoly(scene, [polygon], color=color.as_bgr()) + else: + scene_with_annotations = scene.copy() + cv2.fillPoly(scene_with_annotations, [polygon], color=color.as_bgr()) + cv2.addWeighted( + scene_with_annotations, opacity, scene, 1 - opacity, gamma=0, dst=scene + ) + + return scene + + +def draw_text( + scene: npt.NDArray[np.uint8], + text: str, + text_anchor: Point, + text_color: Color = Color.BLACK, + text_scale: float = 0.5, + text_thickness: int = 1, + text_padding: int = 10, + text_font: int = cv2.FONT_HERSHEY_SIMPLEX, + background_color: Color | None = None, +) -> npt.NDArray[np.uint8]: + """ + Draw text with background on a scene. + + Args: + scene: A numpy ndarray representing the image, typically of shape + (H, W, 3) for a color BGR image or (H, W) for grayscale, + with dtype uint8. + text: The text to be drawn. + text_anchor: The anchor point for the text, represented as a + Point object with x and y attributes. + text_color: The color of the text. Defaults to black. + text_scale: The scale of the text. Defaults to 0.5. + text_thickness: The thickness of the text. Defaults to 1. + text_padding: The amount of padding to add around the text + when drawing a rectangle in the background. Defaults to 10. + text_font: The font to use for the text. + Defaults to cv2.FONT_HERSHEY_SIMPLEX. + background_color: The color of the background rectangle, + if one is to be drawn. Defaults to None. + + Returns: + The input scene with the text drawn on it. + + Examples: + ```pycon + >>> import numpy as np + >>> from supervision.geometry.core import Point + >>> from supervision.draw.utils import draw_text + >>> scene = np.zeros((100, 100, 3), dtype=np.uint8) + >>> text_anchor = Point(x=50, y=50) + >>> scene = draw_text( + ... scene=scene, text="Hello, world!", text_anchor=text_anchor + ... ) + >>> scene.shape + (100, 100, 3) + + ``` + """ + text_width, text_height = cv2.getTextSize( + text=text, + fontFace=text_font, + fontScale=text_scale, + thickness=text_thickness, + )[0] + + text_anchor_x, text_anchor_y = text_anchor.as_xy_int_tuple() + + text_rect = Rect( + x=text_anchor_x - text_width // 2, + y=text_anchor_y - text_height // 2, + width=text_width, + height=text_height, + ).pad(text_padding) + + if background_color is not None: + scene = draw_filled_rectangle( + scene=scene, rect=text_rect, color=background_color + ) + + cv2.putText( + img=scene, + text=text, + org=(text_anchor_x - text_width // 2, text_anchor_y + text_height // 2), + fontFace=text_font, + fontScale=text_scale, + color=text_color.as_bgr(), + thickness=text_thickness, + lineType=cv2.LINE_AA, + ) + return scene + + +def draw_image( + scene: npt.NDArray[np.uint8], + image: str | npt.NDArray[np.uint8], + opacity: float, + rect: Rect, +) -> npt.NDArray[np.uint8]: + """ + Draws an image onto a given scene with specified opacity and dimensions. + + Args: + scene: Background image where the new image will be drawn. + image: Image to draw, either a file path or an already-loaded image array. + opacity: Opacity of the image to be drawn. + rect: Rectangle specifying where to draw the image. + + Returns: + The updated scene. + + Raises: + FileNotFoundError: If the image path does not exist. + OSError: If the image path exists but cannot be decoded. + ValueError: For invalid opacity or rectangle dimensions. + + Example: + ```python + import numpy as np + from supervision.draw.utils import draw_image + from supervision.geometry.core import Rect + + scene = np.zeros((100, 100, 3), dtype=np.uint8) + image = np.full((40, 40, 3), 255, dtype=np.uint8) + rect = Rect(x=10, y=10, width=40, height=40) + scene = draw_image(scene, image, opacity=0.8, rect=rect) + ``` + """ + + # Validate and load image + if isinstance(image, str): + if not os.path.exists(image): + raise FileNotFoundError(f"Image path ('{image}') does not exist.") + loaded_image = cv2.imread(image, cv2.IMREAD_UNCHANGED) + if loaded_image is None: + raise OSError(f"Could not decode image path ('{image}').") + image_np = cast(npt.NDArray[np.uint8], loaded_image) + else: + image_np = image + + if image_np.ndim != 3 or image_np.shape[2] not in (3, 4): + raise ValueError("Image must have 3 or 4 channels.") + + # Validate opacity + if not 0.0 <= opacity <= 1.0: + raise ValueError("Opacity must be between 0.0 and 1.0.") + + rect_x = int(rect.x) + rect_y = int(rect.y) + rect_width = int(rect.width) + rect_height = int(rect.height) + # Validate rectangle dimensions + if ( + rect_x < 0 + or rect_y < 0 + or rect_x + rect_width > scene.shape[1] + or rect_y + rect_height > scene.shape[0] + ): + raise ValueError("Invalid rectangle dimensions.") + + # Resize and isolate alpha channel + image_np = cast( + npt.NDArray[np.uint8], cv2.resize(image_np, (rect_width, rect_height)) + ) + alpha_channel = ( + image_np[:, :, 3] + if image_np.shape[2] == 4 + else np.ones((rect_height, rect_width), dtype=image_np.dtype) * 255 + ) + alpha_scaled = cv2.convertScaleAbs(alpha_channel * opacity) + + # Perform blending + scene_roi = scene[rect_y : rect_y + rect_height, rect_x : rect_x + rect_width] + alpha_float = alpha_scaled.astype(np.float32) / 255.0 + blended_roi = cv2.convertScaleAbs( + (1 - alpha_float[..., np.newaxis]) * scene_roi + + alpha_float[..., np.newaxis] * image_np[:, :, :3] + ) + + # Update the scene + scene[rect_y : rect_y + rect_height, rect_x : rect_x + rect_width] = blended_roi + + return scene + + +def calculate_optimal_text_scale(resolution_wh: tuple[int, int]) -> float: + """ + Calculate optimal font scale based on image resolution. Adjusts font scale + proportionally to the smallest dimension of the given image resolution for + consistent readability. + + Args: + resolution_wh: A tuple of `(width, height)` of the image in pixels. + + Returns: + Recommended font scale factor. + + Examples: + ```pycon + >>> import supervision as sv + >>> sv.calculate_optimal_text_scale((1920, 1080)) + 1.08 + >>> sv.calculate_optimal_text_scale((640, 480)) + 0.48 + + ``` + """ + return min(resolution_wh) * 1e-3 + + +def calculate_optimal_line_thickness(resolution_wh: tuple[int, int]) -> int: + """ + Calculate optimal line thickness based on image resolution. Adjusts the line + thickness for readability depending on the smallest dimension of the provided + image resolution. + + Args: + resolution_wh: A tuple of `(width, height)` of the image in pixels. + + Returns: + Recommended line thickness in pixels. + + Examples: + ```pycon + >>> import supervision as sv + >>> sv.calculate_optimal_line_thickness((1920, 1080)) + 4 + >>> sv.calculate_optimal_line_thickness((640, 480)) + 2 + + ``` + """ + if min(resolution_wh) < 1080: + return 2 + return 4 diff --git a/src/supervision/geometry/__init__.py b/src/supervision/geometry/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/src/supervision/geometry/core.py b/src/supervision/geometry/core.py new file mode 100644 index 0000000..5f41e9b --- /dev/null +++ b/src/supervision/geometry/core.py @@ -0,0 +1,208 @@ +from __future__ import annotations + +from dataclasses import dataclass +from enum import Enum +from math import sqrt + + +class Position(Enum): + """ + Enum representing the position of an anchor point. + """ + + CENTER = "CENTER" + CENTER_LEFT = "CENTER_LEFT" + CENTER_RIGHT = "CENTER_RIGHT" + TOP_CENTER = "TOP_CENTER" + TOP_LEFT = "TOP_LEFT" + TOP_RIGHT = "TOP_RIGHT" + BOTTOM_LEFT = "BOTTOM_LEFT" + BOTTOM_CENTER = "BOTTOM_CENTER" + BOTTOM_RIGHT = "BOTTOM_RIGHT" + CENTER_OF_MASS = "CENTER_OF_MASS" + + @classmethod + def list(cls) -> list[str]: + """Return all position values in their definition order.""" + return [position.value for position in cls] + + +@dataclass +class Point: + """ + Represents a point in 2D space. + + Attributes: + x: The x-coordinate of the point. + y: The y-coordinate of the point. + + Example: + ```pycon + >>> from supervision.geometry.core import Point + >>> point = Point(x=10.0, y=20.0) + >>> point.as_xy_int_tuple() + (10, 20) + >>> point.as_xy_float_tuple() + (10.0, 20.0) + + ``` + """ + + x: float + y: float + + def as_xy_int_tuple(self) -> tuple[int, int]: + """ + Returns the point as a tuple of integers. + + Returns: + The point as (x, y) integers. + """ + return int(self.x), int(self.y) + + def as_xy_float_tuple(self) -> tuple[float, float]: + """ + Returns the point as a tuple of floats. + + Returns: + The point as (x, y) floats. + """ + return self.x, self.y + + +@dataclass +class Vector: + """ + Represents a vector in 2D space, defined by a start and an end point. + + Attributes: + start: The starting point of the vector. + end: The end point of the vector. + + Example: + ```pycon + >>> from supervision.geometry.core import Point, Vector + >>> start_point = Point(x=0.0, y=0.0) + >>> end_point = Point(x=3.0, y=4.0) + >>> vector = Vector(start=start_point, end=end_point) + >>> vector.magnitude + 5.0 + >>> vector.center + Point(x=1.5, y=2.0) + + ``` + """ + + start: Point + end: Point + + @property + def magnitude(self) -> float: + """ + Calculate the magnitude (length) of the vector. + + Returns: + The magnitude of the vector. + """ + dx = self.end.x - self.start.x + dy = self.end.y - self.start.y + return sqrt(dx**2 + dy**2) + + @property + def center(self) -> Point: + """ + Calculate the center point of the vector. + + Returns: + The center point of the vector. + """ + return Point( + x=(self.start.x + self.end.x) / 2, + y=(self.start.y + self.end.y) / 2, + ) + + def cross_product(self, point: Point) -> float: + """ + Calculate the 2D cross product (also known as the vector product or outer + product) of the vector and a point, treated as vectors in 2D space. + + Args: + point: The point to be evaluated, treated as the endpoint of a + vector originating from the 'start' of the main vector. + + Returns: + The scalar value of the cross product. It is positive if 'point' + lies to the left of the vector (when moving from 'start' to 'end'), + negative if it lies to the right, and 0 if it is collinear with the + vector. + """ + dx_vector = self.end.x - self.start.x + dy_vector = self.end.y - self.start.y + dx_point = point.x - self.start.x + dy_point = point.y - self.start.y + return (dx_vector * dy_point) - (dy_vector * dx_point) + + +@dataclass +class Rect: + """ + Represents a rectangle in 2D space. + + Attributes: + x: The x-coordinate of the top-left corner of the rectangle. + y: The y-coordinate of the top-left corner of the rectangle. + width: The width of the rectangle. + height: The height of the rectangle. + + Example: + ```pycon + >>> from supervision.geometry.core import Rect + >>> rect = Rect(x=10.0, y=20.0, width=30.0, height=40.0) + >>> rect.top_left + Point(x=10.0, y=20.0) + >>> rect.bottom_right + Point(x=40.0, y=60.0) + >>> rect.as_xyxy_int_tuple() + (10, 20, 40, 60) + + ``` + """ + + x: float + y: float + width: float + height: float + + @classmethod + def from_xyxy(cls, xyxy: tuple[float, float, float, float]) -> Rect: + """Create a rectangle from `(x_min, y_min, x_max, y_max)` coordinates.""" + x1, y1, x2, y2 = xyxy + return cls(x=x1, y=y1, width=x2 - x1, height=y2 - y1) + + @property + def top_left(self) -> Point: + """Return the top-left corner as a `Point`.""" + return Point(x=self.x, y=self.y) + + @property + def bottom_right(self) -> Point: + """Return the bottom-right corner as a `Point`.""" + return Point(x=self.x + self.width, y=self.y + self.height) + + def pad(self, padding: int) -> Rect: + """Return a rectangle expanded by `padding` pixels on every side.""" + return Rect( + x=self.x - padding, + y=self.y - padding, + width=self.width + 2 * padding, + height=self.height + 2 * padding, + ) + + def as_xyxy_int_tuple(self) -> tuple[int, int, int, int]: + """Return `(x_min, y_min, x_max, y_max)` coordinates as integers.""" + return ( + int(self.x), + int(self.y), + int(self.x + self.width), + int(self.y + self.height), + ) diff --git a/src/supervision/geometry/utils.py b/src/supervision/geometry/utils.py new file mode 100644 index 0000000..cb2897f --- /dev/null +++ b/src/supervision/geometry/utils.py @@ -0,0 +1,54 @@ +import numpy as np +import numpy.typing as npt + +from supervision.geometry.core import Point + + +def get_polygon_center(polygon: npt.NDArray[np.float64]) -> Point: + """ + Calculate the center of a polygon. The center is calculated as the center + of the solid figure formed by the points of the polygon + + Args: + polygon: A 2-dimensional numpy ndarray representing the vertices of the + polygon. + + Returns: + The center of the polygon, represented as a Point object with x and y + attributes. + + Raises: + ValueError: If the polygon has no vertices. + + Examples: + ```pycon + >>> import numpy as np + >>> import supervision as sv + >>> polygon = np.array([[0, 0], [0, 2], [2, 2], [2, 0]]) + >>> center = sv.get_polygon_center(polygon=polygon) + >>> float(center.x) + 1.0 + >>> float(center.y) + 1.0 + + ``` + """ + + # This is one of the 3 candidate algorithms considered for centroid calculation. + # For a more detailed discussion, see PR #1084 and commit eb33176 + + if len(polygon) == 0: + raise ValueError("Polygon must have at least one vertex.") + + shift_polygon = np.roll(polygon, -1, axis=0) + signed_areas = ( + polygon[..., 0] * shift_polygon[..., 1] + - polygon[..., 1] * shift_polygon[..., 0] + ) / 2 + if signed_areas.sum() == 0: + center = np.mean(polygon, axis=0).round() + return Point(x=center[0], y=center[1]) + centroids = (polygon + shift_polygon) / 3.0 + center = np.average(centroids, axis=0, weights=signed_areas).round() + + return Point(x=center[0], y=center[1]) diff --git a/src/supervision/key_points/__init__.py b/src/supervision/key_points/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/src/supervision/key_points/annotators.py b/src/supervision/key_points/annotators.py new file mode 100644 index 0000000..46f45c1 --- /dev/null +++ b/src/supervision/key_points/annotators.py @@ -0,0 +1,994 @@ +from abc import ABC, abstractmethod +from collections.abc import Sequence +from typing import cast + +import cv2 +import numpy as np +import numpy.typing as npt + +from supervision.detection.utils.boxes import pad_boxes, spread_out_boxes +from supervision.draw.base import ImageType +from supervision.draw.color import Color +from supervision.draw.utils import draw_rounded_rectangle +from supervision.geometry.core import Rect +from supervision.key_points.core import KeyPoints +from supervision.key_points.skeletons import SKELETONS_BY_VERTEX_COUNT +from supervision.utils.conversion import ensure_cv2_image_for_class_method +from supervision.utils.logger import _get_logger + +logger = _get_logger(__name__) + + +def _validate_edge_indices(edge: tuple[int, int], vertex_count: int) -> tuple[int, int]: + """Validate 1-based skeleton edges and return zero-based vertex indexes.""" + vertex_a, vertex_b = edge + if not (1 <= vertex_a <= vertex_count and 1 <= vertex_b <= vertex_count): + raise ValueError( + "Edge indices must use the 1-based convention and be within the " + f"available keypoint range [1, {vertex_count}], got {edge}." + ) + # Public skeleton definitions are 1-based; keypoint arrays are zero-based. + return vertex_a - 1, vertex_b - 1 + + +class BaseKeyPointAnnotator(ABC): + @abstractmethod + def annotate(self, scene: ImageType, key_points: KeyPoints) -> ImageType: + pass + + +class VertexAnnotator(BaseKeyPointAnnotator): + """ + A class that specializes in drawing skeleton vertices on images. It uses + specified key points to determine the locations where the vertices should be + drawn. + """ + + def __init__( + self, + color: Color = Color.ROBOFLOW, + radius: int = 4, + ) -> None: + """ + Args: + color: The color to use for annotating key points. + radius: The radius of the circles used to represent the key points. + """ + self.color = color + self.radius = radius + + @ensure_cv2_image_for_class_method + def annotate(self, scene: ImageType, key_points: KeyPoints) -> ImageType: + """ + Annotates the given scene with skeleton vertices based on the provided key + points. It draws circles at each key point location. Anchors marked as + not visible via ``key_points.visible`` are skipped. + + Args: + scene: The image where skeleton vertices will be drawn. `ImageType` is a + flexible type, accepting either `numpy.ndarray` or `PIL.Image.Image`. + key_points: A collection of key points where each key point consists of x + and y coordinates. + + Returns: + The annotated image, matching the type of `scene` (`numpy.ndarray` + or `PIL.Image.Image`) + + Raises: + TypeError: If `scene` is not a `numpy.ndarray` or `PIL.Image.Image`. + + Example: + ```pycon + >>> import numpy as np + >>> import supervision as sv + >>> image = np.zeros((800, 800, 3), dtype=np.uint8) + >>> key_points = sv.KeyPoints( + ... xy=np.array( + ... [[[400, 200], [300, 500], [500, 500]]], + ... dtype=np.float32, + ... ), + ... class_id=np.array([0]), + ... visible=np.array([[True, True, True]]), + ... ) + >>> annotator = sv.VertexAnnotator( + ... color=sv.Color.ROBOFLOW, radius=10 + ... ) + >>> result = annotator.annotate(image.copy(), key_points) + + ``` + """ + if len(key_points) == 0: + return scene + + for detection_index, xy in enumerate(key_points.xy): + for point_index, (x, y) in enumerate(xy): + if np.allclose((x, y), 0): + continue + if ( + key_points.visible is not None + and not key_points.visible[detection_index, point_index] + ): + continue + cv2.circle( + img=scene, + center=(int(x), int(y)), + radius=self.radius, + color=self.color.as_bgr(), + thickness=-1, + ) + + return scene + + +class EdgeAnnotator(BaseKeyPointAnnotator): + """ + A class that specializes in drawing skeleton edges on images using specified key + points. It connects key points with lines to form the skeleton structure. + """ + + def __init__( + self, + color: Color = Color.ROBOFLOW, + thickness: int = 2, + edges: ( + Sequence[tuple[int, int]] | dict[int, Sequence[tuple[int, int]]] | None + ) = None, + ) -> None: + """ + Args: + color: The color to use for the edges. + thickness: The thickness of the edges. + edges: The edges to draw. If set to ``None``, will attempt to + auto-detect the skeleton by vertex count. A + ``Sequence[tuple[int, int]]`` applies a single skeleton to + every instance. A ``dict[int, Sequence[tuple[int, int]]]`` + maps ``class_id`` to skeleton edges, enabling correct + rendering for datasets with multiple skeleton types. + """ + self.color = color + self.thickness = thickness + self.edges = edges + + @ensure_cv2_image_for_class_method + def annotate(self, scene: ImageType, key_points: KeyPoints) -> ImageType: + """ + Annotates the given scene by drawing lines between specified key points to form + edges. Edges where either endpoint is marked as not visible via + ``key_points.visible`` are skipped. + + Args: + scene: The image where skeleton edges will be drawn. `ImageType` is a + flexible type, accepting either `numpy.ndarray` or `PIL.Image.Image`. + key_points: A collection of key points where each key point consists of x + and y coordinates. + + Returns: + The annotated image, matching the type of `scene` (`numpy.ndarray` + or `PIL.Image.Image`) + + Raises: + TypeError: If `scene` is not a `numpy.ndarray` or `PIL.Image.Image`. + + Example: + Single-skeleton example: + + ```pycon + >>> import numpy as np + >>> import supervision as sv + >>> image = np.zeros((800, 800, 3), dtype=np.uint8) + >>> key_points = sv.KeyPoints( + ... xy=np.array( + ... [[[400, 200], [300, 500], [500, 500]]], + ... dtype=np.float32, + ... ), + ... class_id=np.array([0]), + ... visible=np.array([[True, True, True]]), + ... ) + >>> annotator = sv.EdgeAnnotator( + ... color=sv.Color.ROBOFLOW, + ... thickness=3, + ... edges=[(1, 2), (1, 3)], + ... ) + >>> result = annotator.annotate(image.copy(), key_points) + + ``` + + Multi-skeleton example with per-class edges: + + ```pycon + >>> import numpy as np + >>> import supervision as sv + >>> image = np.zeros((800, 800, 3), dtype=np.uint8) + >>> key_points = sv.KeyPoints( + ... xy=np.array( + ... [[[400, 200], [300, 500], [500, 500]], + ... [[700, 300], [650, 500], [0, 0]]], + ... dtype=np.float32, + ... ), + ... class_id=np.array([0, 1]), + ... visible=np.array( + ... [[True, True, True], + ... [True, True, False]], + ... ), + ... ) + >>> annotator = sv.EdgeAnnotator( + ... color=sv.Color.ROBOFLOW, + ... thickness=3, + ... edges={0: [(1, 2), (1, 3)], 1: [(1, 2)]}, + ... ) + >>> result = annotator.annotate(image.copy(), key_points) + + ``` + """ + if len(key_points) == 0: + return scene + + for detection_index, xy in enumerate(key_points.xy): + if isinstance(self.edges, dict): + class_id = ( + int(key_points.class_id[detection_index]) + if key_points.class_id is not None + else None + ) + if class_id is None: + raise ValueError( + "edges is a dict but class_id is None; " + "KeyPoints must have class_id set." + ) + if class_id not in self.edges: + raise ValueError(f"No edges defined for class_id={class_id}.") + edges = self.edges[class_id] + elif self.edges: + edges = self.edges + else: + _looked_up = SKELETONS_BY_VERTEX_COUNT.get(len(xy)) + if not _looked_up: + logger.warning("No skeleton found with %d vertices", len(xy)) + continue + edges = _looked_up + + for edge in edges: + idx_a, idx_b = _validate_edge_indices(edge=edge, vertex_count=len(xy)) + xy_a = xy[idx_a] + xy_b = xy[idx_b] + if np.allclose(xy_a, 0) or np.allclose(xy_b, 0): + continue + if key_points.visible is not None: + if ( + not key_points.visible[detection_index, idx_a] + or not key_points.visible[detection_index, idx_b] + ): + continue + + cv2.line( + img=scene, + pt1=(int(xy_a[0]), int(xy_a[1])), + pt2=(int(xy_b[0]), int(xy_b[1])), + color=self.color.as_bgr(), + thickness=self.thickness, + ) + + return scene + + +class _BaseVertexEllipseAnnotator(BaseKeyPointAnnotator): + """Private base for ellipse-based keypoint annotators. + + Handles sigma/color validation, sorting, covariance extraction and + eigendecomposition shared by all VertexEllipse* variants. + """ + + def __init__( + self, + sigma: float | Sequence[float] = (1.0, 2.0, 3.0), + color: Color | Sequence[Color] = (Color.GREEN, Color.YELLOW, Color.RED), + max_axis: float | None = None, + ) -> None: + sigma_seq: Sequence[float] = ( + (sigma,) if isinstance(sigma, (int, float)) else sigma + ) + color_seq: Sequence[Color] = (color,) if isinstance(color, Color) else color + + if len(sigma_seq) == 0: + raise ValueError("sigma must contain at least one value") + if any(s <= 0 for s in sigma_seq): + raise ValueError("All sigma values must be positive") + if max_axis is not None and max_axis <= 0: + raise ValueError("max_axis must be positive when provided") + if len(color_seq) != len(sigma_seq): + raise ValueError( + f"color length ({len(color_seq)}) must match " + f"sigma length ({len(sigma_seq)})" + ) + + sorted_indices = sorted( + range(len(sigma_seq)), key=lambda i: sigma_seq[i], reverse=True + ) + self.sigma = [sigma_seq[i] for i in sorted_indices] + self.color = [color_seq[i] for i in sorted_indices] + self.max_axis = max_axis + + def _get_covariances(self, key_points: KeyPoints) -> npt.NDArray[np.float32]: + covariances = key_points.data.get("covariance") + if covariances is None: + raise ValueError( + "key_points.data must contain 'covariance' with shape (N, K, 2, 2)." + ) + covariances_array = cast( + npt.NDArray[np.float32], np.asarray(covariances, dtype=np.float32) + ) + expected_shape = (*key_points.xy.shape[:2], 2, 2) + if covariances_array.shape != expected_shape: + raise ValueError( + f"Expected covariance shape {expected_shape}, " + f"got {covariances_array.shape}." + ) + return covariances_array + + def _decompose_covariance( + self, covariance: npt.NDArray[np.float32] + ) -> tuple[npt.NDArray[np.float64], npt.NDArray[np.float64]] | None: + """Eigendecompose a 2x2 covariance, returning sorted (eigenvalues, vectors).""" + if not np.isfinite(covariance).all(): + return None + try: + eigenvalues, eigenvectors = np.linalg.eigh(covariance.astype(np.float64)) + except np.linalg.LinAlgError: + return None + if not np.isfinite(eigenvalues).all() or np.any(eigenvalues <= 0): + return None + order = np.argsort(eigenvalues)[::-1] + return eigenvalues[order], eigenvectors[:, order] + + def _iter_ellipse_params( + self, key_points: KeyPoints + ) -> list[list[tuple[tuple[int, int], tuple[int, int], float, float, Color]]]: + """Return ellipse params grouped by sigma level (outermost first).""" + covariances = self._get_covariances(key_points) + levels: list[ + list[tuple[tuple[int, int], tuple[int, int], float, float, Color]] + ] = [[] for _ in self.sigma] + for detection_index, xy in enumerate(key_points.xy): + for point_index, (x, y) in enumerate(xy): + if np.allclose((x, y), 0): + continue + if ( + key_points.visible is not None + and not key_points.visible[detection_index, point_index] + ): + continue + covariance = covariances[detection_index, point_index] + decomposition = self._decompose_covariance(covariance) + if decomposition is None: + continue + eigenvalues, eigenvectors = decomposition + angle = float( + np.degrees(np.arctan2(eigenvectors[1, 0], eigenvectors[0, 0])) + ) + center = (round(x), round(y)) + for level_idx, (sigma, color) in enumerate(zip(self.sigma, self.color)): + axes = sigma * np.sqrt(eigenvalues) + if self.max_axis is not None: + axes = np.minimum(axes, self.max_axis) + axis_lengths = ( + max(1, round(axes[0])), + max(1, round(axes[1])), + ) + levels[level_idx].append( + (center, axis_lengths, angle, sigma, color) + ) + return levels + + +class VertexEllipseAreaAnnotator(_BaseVertexEllipseAnnotator): + """ + Draws filled semi-transparent covariance ellipses at multiple sigma levels + around each keypoint, each ring in a different color. This produces a + bullseye-like uncertainty visualization where inner rings represent higher + probability density. + + !!! warning + + This annotator uses `key_points.data["covariance"]` with shape + `(N, K, 2, 2)` in pixel coordinates. + """ + + def __init__( + self, + sigma: float | Sequence[float] = (1.0, 2.0, 3.0), + color: Color | Sequence[Color] = (Color.GREEN, Color.YELLOW, Color.RED), + opacity: float = 0.4, + max_axis: float | None = None, + ) -> None: + """ + Args: + sigma: Sigma multipliers for each ring, drawn from outermost to + innermost. Accepts a single float or a sequence of floats. + Defaults to ``(1.0, 2.0, 3.0)``. + color: The color for each sigma level. Accepts a single + ``Color`` or a sequence of colors (one per sigma level). + Defaults to ``(Color.GREEN, Color.YELLOW, Color.RED)``. + opacity: Opacity of the overlay mask. Must be between ``0`` and + ``1``. + max_axis: Optional cap for ellipse semi-axis lengths in pixels. + """ + super().__init__(sigma=sigma, color=color, max_axis=max_axis) + self.opacity = opacity + + @ensure_cv2_image_for_class_method + def annotate(self, scene: ImageType, key_points: KeyPoints) -> ImageType: + """ + Draws filled semi-transparent covariance ellipses around each keypoint. + + Args: + scene: The image to annotate. ``ImageType`` accepts either + ``numpy.ndarray`` or ``PIL.Image.Image``. + key_points: Key points with covariance data in + ``key_points.data["covariance"]``. + + Returns: + The annotated image, matching the type of ``scene``. + + Raises: + TypeError: If `scene` is not a `numpy.ndarray` or `PIL.Image.Image`. + + Example: + ```pycon + >>> import numpy as np + >>> import supervision as sv + >>> image = np.zeros((800, 800, 3), dtype=np.uint8) + >>> key_points = sv.KeyPoints( + ... xy=np.array( + ... [[[400, 200], [300, 500], [500, 500]]], + ... dtype=np.float32, + ... ), + ... class_id=np.array([0]), + ... visible=np.array([[True, True, True]]), + ... data={ + ... "covariance": np.array( + ... [[[[800, 0], [0, 400]], + ... [[400, 0], [0, 800]], + ... [[600, 0], [0, 600]]]], + ... dtype=np.float32, + ... ) + ... }, + ... ) + >>> annotator = sv.VertexEllipseAreaAnnotator( + ... sigma=[1.0, 2.0], + ... color=[sv.Color.GREEN, sv.Color.RED], + ... ) + >>> result = annotator.annotate(image.copy(), key_points) + + ``` + """ + if len(key_points) == 0: + return scene + + overlay = scene.copy() + for level in self._iter_ellipse_params(key_points): + for center, axis_lengths, angle, _sigma, color in level: + cv2.ellipse( + img=overlay, + center=center, + axes=axis_lengths, + angle=angle, + startAngle=0, + endAngle=360, + color=color.as_bgr(), + thickness=-1, + lineType=cv2.LINE_AA, + ) + + cv2.addWeighted(overlay, self.opacity, scene, 1 - self.opacity, 0, dst=scene) + return scene + + +class VertexEllipseOutlineAnnotator(_BaseVertexEllipseAnnotator): + """ + Draws stroke-only concentric covariance ellipse rings at multiple sigma + levels around each keypoint. + + !!! warning + + This annotator uses `key_points.data["covariance"]` with shape + `(N, K, 2, 2)` in pixel coordinates. + """ + + def __init__( + self, + sigma: float | Sequence[float] = (1.0, 2.0, 3.0), + color: Color | Sequence[Color] = (Color.GREEN, Color.YELLOW, Color.RED), + thickness: int = 2, + max_axis: float | None = None, + ) -> None: + """ + Args: + sigma: Sigma multipliers for each ring, drawn from outermost to + innermost. Accepts a single float or a sequence of floats. + Defaults to ``(1.0, 2.0, 3.0)``. + color: The color for each sigma level. Accepts a single + ``Color`` or a sequence of colors (one per sigma level). + Defaults to ``(Color.GREEN, Color.YELLOW, Color.RED)``. + thickness: Line thickness of the ellipse outlines. + max_axis: Optional cap for ellipse semi-axis lengths in pixels. + """ + super().__init__(sigma=sigma, color=color, max_axis=max_axis) + self.thickness = thickness + + @ensure_cv2_image_for_class_method + def annotate(self, scene: ImageType, key_points: KeyPoints) -> ImageType: + """ + Draws stroke-only covariance ellipse outlines around each keypoint. + + Args: + scene: The image to annotate. ``ImageType`` accepts either + ``numpy.ndarray`` or ``PIL.Image.Image``. + key_points: Key points with covariance data in + ``key_points.data["covariance"]``. + + Returns: + The annotated image, matching the type of ``scene``. + + Raises: + TypeError: If `scene` is not a `numpy.ndarray` or `PIL.Image.Image`. + + Example: + ```pycon + >>> import numpy as np + >>> import supervision as sv + >>> image = np.zeros((800, 800, 3), dtype=np.uint8) + >>> key_points = sv.KeyPoints( + ... xy=np.array( + ... [[[400, 200], [300, 500], [500, 500]]], + ... dtype=np.float32, + ... ), + ... class_id=np.array([0]), + ... visible=np.array([[True, True, True]]), + ... data={ + ... "covariance": np.array( + ... [[[[800, 0], [0, 400]], + ... [[400, 0], [0, 800]], + ... [[600, 0], [0, 600]]]], + ... dtype=np.float32, + ... ) + ... }, + ... ) + >>> annotator = sv.VertexEllipseOutlineAnnotator( + ... sigma=[1.0, 2.0], + ... color=[sv.Color.GREEN, sv.Color.RED], + ... thickness=2, + ... ) + >>> result = annotator.annotate(image.copy(), key_points) + + ``` + """ + if len(key_points) == 0: + return scene + + for level in self._iter_ellipse_params(key_points): + for center, axis_lengths, angle, _sigma, color in level: + cv2.ellipse( + img=scene, + center=center, + axes=axis_lengths, + angle=angle, + startAngle=0, + endAngle=360, + color=color.as_bgr(), + thickness=self.thickness, + lineType=cv2.LINE_AA, + ) + + return scene + + +class VertexEllipseHaloAnnotator(_BaseVertexEllipseAnnotator): + """ + Draws filled covariance ellipses with a radial fade: full opacity at the + center, smoothly falling off to zero at the ellipse boundary. The falloff + follows a power curve controlled by ``decay``, producing a soft glow that + is strongest near the keypoint. + + !!! warning + + This annotator uses `key_points.data["covariance"]` with shape + `(N, K, 2, 2)` in pixel coordinates. + """ + + _DECAY: float = 2.0 + + def __init__( + self, + sigma: float | Sequence[float] = (1.0, 2.0, 3.0), + color: Color | Sequence[Color] = (Color.GREEN, Color.YELLOW, Color.RED), + opacity: float = 0.6, + max_axis: float | None = None, + ) -> None: + """ + Args: + sigma: Sigma multipliers for each ring, drawn from outermost to + innermost. Accepts a single float or a sequence of floats. + Defaults to ``(1.0, 2.0, 3.0)``. + color: The color for each sigma level. Accepts a single + ``Color`` or a sequence of colors (one per sigma level). + Defaults to ``(Color.GREEN, Color.YELLOW, Color.RED)``. + opacity: Peak opacity at the ellipse center. Must be between ``0`` + and ``1``. + max_axis: Optional cap for ellipse semi-axis lengths in pixels. + """ + super().__init__(sigma=sigma, color=color, max_axis=max_axis) + self.opacity = opacity + + @ensure_cv2_image_for_class_method + def annotate(self, scene: ImageType, key_points: KeyPoints) -> ImageType: + """ + Draws radially-fading covariance ellipses around each keypoint. + + Args: + scene: The image to annotate. ``ImageType`` accepts either + ``numpy.ndarray`` or ``PIL.Image.Image``. + key_points: Key points with covariance data in + ``key_points.data["covariance"]``. + + Returns: + The annotated image, matching the type of ``scene``. + + Raises: + TypeError: If `scene` is not a `numpy.ndarray` or `PIL.Image.Image`. + + Example: + ```pycon + >>> import numpy as np + >>> import supervision as sv + >>> image = np.zeros((800, 800, 3), dtype=np.uint8) + >>> key_points = sv.KeyPoints( + ... xy=np.array( + ... [[[400, 200], [300, 500], [500, 500]]], + ... dtype=np.float32, + ... ), + ... class_id=np.array([0]), + ... visible=np.array([[True, True, True]]), + ... data={ + ... "covariance": np.array( + ... [[[[800, 0], [0, 400]], + ... [[400, 0], [0, 800]], + ... [[600, 0], [0, 600]]]], + ... dtype=np.float32, + ... ) + ... }, + ... ) + >>> annotator = sv.VertexEllipseHaloAnnotator( + ... sigma=[1.0, 2.0], + ... color=[sv.Color.GREEN, sv.Color.RED], + ... ) + >>> result = annotator.annotate(image.copy(), key_points) + + ``` + """ + if len(key_points) == 0: + return scene + + h, w = scene.shape[:2] + composite: npt.NDArray[np.float32] = scene.astype(np.float32) + + for level in self._iter_ellipse_params(key_points): + for center, axis_lengths, angle, _sigma, color in level: + ax, ay = axis_lengths + if ax == 0 or ay == 0: + continue + + pad = 2 + roi_half_w = ax + pad + roi_half_h = ay + pad + cx, cy = center + + x_min = max(cx - roi_half_w, 0) + x_max = min(cx + roi_half_w, w) + y_min = max(cy - roi_half_h, 0) + y_max = min(cy + roi_half_h, h) + if x_min >= x_max or y_min >= y_max: + continue + + ys = np.arange(y_min, y_max, dtype=np.float32) - cy + xs = np.arange(x_min, x_max, dtype=np.float32) - cx + grid_x, grid_y = np.meshgrid(xs, ys) + + angle_rad = np.radians(-angle) + cos_a = np.cos(angle_rad) + sin_a = np.sin(angle_rad) + rx = grid_x * cos_a - grid_y * sin_a + ry = grid_x * sin_a + grid_y * cos_a + + dist_sq = (rx / ax) ** 2 + (ry / ay) ** 2 + inside = dist_sq <= 1.0 + + falloff = np.zeros_like(dist_sq) + falloff[inside] = (1.0 - dist_sq[inside]) ** self._DECAY + + scaled_alpha = falloff * self.opacity + + bgr = np.array(color.as_bgr(), dtype=np.float32) + roi = composite[y_min:y_max, x_min:x_max] + alpha_3 = scaled_alpha[:, :, np.newaxis] + roi[:] = roi * (1 - alpha_3) + bgr * alpha_3 + + np.copyto(scene, composite.astype(np.uint8)) + return scene + + +VertexEllipseAnnotator = VertexEllipseAreaAnnotator + + +class VertexLabelAnnotator: + """ + A class that draws labels of skeleton vertices on images. It uses specified key + points to determine the locations where the vertices should be drawn. + """ + + def __init__( + self, + color: Color | list[Color] = Color.ROBOFLOW, + text_color: Color | list[Color] = Color.WHITE, + text_scale: float = 0.5, + text_thickness: int = 1, + text_padding: int = 10, + border_radius: int = 0, + smart_position: bool = False, + ): + """ + Args: + color: The color to use for each keypoint label. If a list is + provided, the colors will be used in order for each keypoint. + text_color: The color to use for the labels. If a list is + provided, the colors will be used in order for each keypoint. + text_scale: The scale of the text. + text_thickness: The thickness of the text. + text_padding: The padding around the text. + border_radius: The radius of the rounded corners of the boxes. + Set to a high value to produce circles. + smart_position: Spread out the labels to avoid overlap. + """ + self.border_radius: int = border_radius + self.color: Color | list[Color] = color + self.text_color: Color | list[Color] = text_color + self.text_scale: float = text_scale + self.text_thickness: int = text_thickness + self.text_padding: int = text_padding + self.smart_position = smart_position + + @ensure_cv2_image_for_class_method + def annotate( + self, + scene: ImageType, + key_points: KeyPoints, + labels: list[str] | dict[int, list[str]] | None = None, + ) -> ImageType: + """ + Draws labels at skeleton vertex positions on the image. Vertices + marked not visible via ``key_points.visible`` are skipped. + + Args: + scene: The image where vertex labels will be drawn. `ImageType` is a + flexible type, accepting either `numpy.ndarray` or `PIL.Image.Image`. + key_points: A collection of key points where each key point consists of x + and y coordinates. + labels: Labels to display at each keypoint. If ``None``, keypoint + indices are used. A ``list[str]`` applies the same labels to + every instance. A ``dict[int, list[str]]`` maps ``class_id`` + to per-class label lists, enabling correct labeling for + datasets with multiple skeleton types. + + Returns: + The annotated image, matching the type of `scene` (`numpy.ndarray` + or `PIL.Image.Image`) + + Raises: + TypeError: If `scene` is not a `numpy.ndarray` or `PIL.Image.Image`. + + Example: + Single-skeleton example: + + ```pycon + >>> import numpy as np + >>> import supervision as sv + >>> image = np.zeros((800, 800, 3), dtype=np.uint8) + >>> key_points = sv.KeyPoints( + ... xy=np.array( + ... [[[400, 200], [300, 500], [500, 500]]], + ... dtype=np.float32, + ... ), + ... class_id=np.array([0]), + ... visible=np.array([[True, True, True]]), + ... ) + >>> annotator = sv.VertexLabelAnnotator( + ... color=sv.Color.ROBOFLOW, + ... text_color=sv.Color.WHITE, + ... border_radius=5, + ... ) + >>> result = annotator.annotate( + ... scene=image.copy(), + ... key_points=key_points, + ... labels=["head", "L-foot", "R-foot"], + ... ) + + ``` + + Multi-skeleton example with per-class labels: + + ```pycon + >>> import numpy as np + >>> import supervision as sv + >>> image = np.zeros((800, 800, 3), dtype=np.uint8) + >>> key_points = sv.KeyPoints( + ... xy=np.array( + ... [[[400, 200], [300, 500], [500, 500]], + ... [[700, 300], [650, 500], [0, 0]]], + ... dtype=np.float32, + ... ), + ... class_id=np.array([0, 1]), + ... visible=np.array( + ... [[True, True, True], + ... [True, True, False]], + ... ), + ... ) + >>> annotator = sv.VertexLabelAnnotator( + ... color=sv.Color.ROBOFLOW, + ... text_color=sv.Color.WHITE, + ... border_radius=5, + ... ) + >>> result = annotator.annotate( + ... scene=image.copy(), + ... key_points=key_points, + ... labels={ + ... 0: ["head", "L-foot", "R-foot"], + ... 1: ["top", "bottom", "pad"], + ... }, + ... ) + + ``` + """ + font = cv2.FONT_HERSHEY_SIMPLEX + + skeletons_count, points_count, _ = key_points.xy.shape + if skeletons_count == 0: + return scene + + all_anchors: list[tuple[int, int]] = [] + all_labels: list[str] = [] + all_colors: list[Color] = [] + all_text_colors: list[Color] = [] + + for i in range(skeletons_count): + xy = key_points.xy[i] + + class_id = ( + int(key_points.class_id[i]) if key_points.class_id is not None else None + ) + instance_labels = self._resolve_labels(labels, points_count, class_id) + instance_colors = self._resolve_color_list(self.color, points_count) + instance_text_colors = self._resolve_color_list( + self.text_color, points_count + ) + + for j in range(points_count): + if key_points.visible is not None: + if not key_points.visible[i, j]: + continue + elif np.allclose(xy[j], 0): + continue + + anchor = (int(xy[j][0]), int(xy[j][1])) + all_anchors.append(anchor) + all_labels.append(instance_labels[j]) + all_colors.append(instance_colors[j]) + all_text_colors.append(instance_text_colors[j]) + + if not all_anchors: + return scene + + xyxy = np.array( + [ + self.get_text_bounding_box( + text=label, + font=font, + text_scale=self.text_scale, + text_thickness=self.text_thickness, + center_coordinates=anchor, + ) + for anchor, label in zip(all_anchors, all_labels) + ] + ) + xyxy_padded = pad_boxes(xyxy=xyxy, px=self.text_padding) + + if self.smart_position: + xyxy_padded = spread_out_boxes(xyxy_padded) + xyxy = pad_boxes(xyxy=xyxy_padded, px=-self.text_padding) + + for text, color, text_color, box, box_padded in zip( + all_labels, all_colors, all_text_colors, xyxy, xyxy_padded + ): + draw_rounded_rectangle( + scene=scene, + rect=Rect.from_xyxy(box_padded), + color=color, + border_radius=self.border_radius, + ) + cv2.putText( + img=scene, + text=text, + org=(box[0], box[3]), + fontFace=font, + fontScale=self.text_scale, + color=text_color.as_bgr(), + thickness=self.text_thickness, + lineType=cv2.LINE_AA, + ) + + return scene + + @staticmethod + def get_text_bounding_box( + text: str, + font: int, + text_scale: float, + text_thickness: int, + center_coordinates: tuple[int, int], + ) -> tuple[int, int, int, int]: + text_w, text_h = cv2.getTextSize( + text=text, + fontFace=font, + fontScale=text_scale, + thickness=text_thickness, + )[0] + center_x, center_y = center_coordinates + return ( + center_x - text_w // 2, + center_y - text_h // 2, + center_x + text_w // 2, + center_y + text_h // 2, + ) + + @staticmethod + def _resolve_labels( + labels: list[str] | dict[int, list[str]] | None, + points_count: int, + class_id: int | None = None, + ) -> list[str]: + """Return the label list for a single instance.""" + if labels is None: + return [str(j) for j in range(points_count)] + + resolved: list[str] + if isinstance(labels, dict): + if class_id is None: + raise ValueError( + "labels is a dict but class_id is None; " + "KeyPoints must have class_id set." + ) + if class_id not in labels: + raise ValueError(f"No labels defined for class_id={class_id}.") + resolved = labels[class_id] + else: + resolved = labels + + if len(resolved) != points_count: + raise ValueError( + f"Number of labels ({len(resolved)}) must match " + f"number of key points ({points_count})." + ) + return resolved + + @staticmethod + def _resolve_color_list( + colors: Color | list[Color], + points_count: int, + ) -> list[Color]: + """Return a per-keypoint color list for a single instance.""" + if isinstance(colors, list): + if len(colors) != points_count: + raise ValueError( + f"Number of colors ({len(colors)}) must match " + f"number of key points ({points_count})." + ) + return colors + return [colors] * points_count diff --git a/src/supervision/key_points/core.py b/src/supervision/key_points/core.py new file mode 100644 index 0000000..cd2c0b2 --- /dev/null +++ b/src/supervision/key_points/core.py @@ -0,0 +1,1456 @@ +from __future__ import annotations + +import logging +from collections.abc import Iterable, Iterator +from dataclasses import dataclass, field +from typing import Any, cast + +import numpy as np +import numpy.typing as npt + +from supervision.config import CLASS_NAME_DATA_FIELD +from supervision.detection.core import Detections +from supervision.detection.utils._typing import ( + _DetectionDataType, + _DetectionDataValueType, +) +from supervision.detection.utils.internal import ( + get_data_item, + is_data_equal, + merge_data, +) +from supervision.detection.utils.iou_and_nms import ( + OverlapMetric, + box_non_max_suppression, +) +from supervision.utils.internal import warn_deprecated +from supervision.validators import _validate_keypoints_fields + +logger = logging.getLogger(__name__) + +Index1D = ( + int | slice | list[int] | list[bool] | npt.NDArray[np.int_] | npt.NDArray[np.bool_] +) +Index2D = tuple[Index1D, Index1D] +_RowIndexInput = int | np.integer[Any] | npt.NDArray[np.generic] | list[Any] | slice +_NormalizedRowIndex = npt.NDArray[np.generic] | list[Any] | slice + + +def _optional_array_equal( + first: npt.NDArray[np.generic] | None, + second: npt.NDArray[np.generic] | None, +) -> bool: + if first is None or second is None: + return first is None and second is None + return np.array_equal(first, second) + + +def _normalize_row_index( + i: _RowIndexInput, +) -> _NormalizedRowIndex: + """Normalise *i* to a 1-D row index for 1-D per-object fields. + + Handles: + - Python int or np.integer scalar -> np.array([int(i)]) + - boolean np.ndarray (any shape) -> np.flatnonzero(i.ravel()) + - non-bool 0-d np.ndarray -> reshaped to shape (1,) + - list of bool -> np.flatnonzero(np.array(i)) + - slice, list of ints, 1-D ndarray -> returned as-is + """ + if isinstance(i, (int, np.integer)): + return cast(_NormalizedRowIndex, np.array([int(i)])) + if isinstance(i, np.ndarray) and i.dtype == bool: + return cast(_NormalizedRowIndex, np.flatnonzero(i.ravel())) + if isinstance(i, np.ndarray) and i.ndim == 0: + return cast(_NormalizedRowIndex, i.reshape(1)) + if isinstance(i, list) and i and all(isinstance(x, bool) for x in i): + return cast(_NormalizedRowIndex, np.flatnonzero(np.array(i))) + return i + + +@dataclass(init=False) +class KeyPoints: + """ + The `sv.KeyPoints` class in the Supervision library standardizes results from + various keypoint detection and pose estimation models into a consistent format. This + class simplifies data manipulation and filtering, providing a uniform API for + integration with Supervision [keypoints annotators](/latest/keypoint/annotators). + + === "RF-DETR" + + [RF-DETR](https://github.com/roboflow/rf-detr) keypoint models return + `sv.KeyPoints` directly from `model.predict()` โ€” no additional + conversion is needed. + + ```python + import cv2 + import supervision as sv + from rfdetr import RFDETRKeypointPreview + + image = cv2.imread("") + model = RFDETRKeypointPreview() + + key_points = model.predict(image) + ``` + + === "Ultralytics" + + Use [`sv.KeyPoints.from_ultralytics`](/latest/keypoint/core/#supervision.key_points.core.KeyPoints.from_ultralytics) + method, which accepts [YOLOv8-pose](https://docs.ultralytics.com/models/yolov8/), [YOLO11-pose](https://docs.ultralytics.com/models/yolo11/) + [pose](https://docs.ultralytics.com/tasks/pose/) result. + + ```python + import cv2 + import supervision as sv + from ultralytics import YOLO + + image = cv2.imread("") + model = YOLO('yolo11s-pose.pt') + + result = model(image)[0] + key_points = sv.KeyPoints.from_ultralytics(result) + ``` + + === "Inference" + + Use [`sv.KeyPoints.from_inference`](/latest/keypoint/core/#supervision.key_points.core.KeyPoints.from_inference) + method, which accepts [Inference](https://inference.roboflow.com/) pose result. + + ```python + import cv2 + import supervision as sv + from inference import get_model + + image = cv2.imread("") + model = get_model(model_id="", api_key="") + + result = model.infer(image)[0] + key_points = sv.KeyPoints.from_inference(result) + ``` + + === "MediaPipe" + + Use [`sv.KeyPoints.from_mediapipe`](/latest/keypoint/core/#supervision.key_points.core.KeyPoints.from_mediapipe) + method, which accepts [MediaPipe](https://github.com/google-ai-edge/mediapipe) + pose result. + + + ```python + import cv2 + import mediapipe as mp + import supervision as sv + + image = cv2.imread("") + image_height, image_width, _ = image.shape + mediapipe_image = mp.Image( + image_format=mp.ImageFormat.SRGB, + data=cv2.cvtColor(image, cv2.COLOR_BGR2RGB)) + + options = mp.tasks.vision.PoseLandmarkerOptions( + base_options=mp.tasks.BaseOptions( + model_asset_path="pose_landmarker_heavy.task" + ), + running_mode=mp.tasks.vision.RunningMode.IMAGE, + num_poses=2) + + PoseLandmarker = mp.tasks.vision.PoseLandmarker + with PoseLandmarker.create_from_options(options) as landmarker: + pose_landmarker_result = landmarker.detect(mediapipe_image) + + key_points = sv.KeyPoints.from_mediapipe( + pose_landmarker_result, (image_width, image_height)) + ``` + + === "Transformers" + + Use [`sv.KeyPoints.from_transformers`](/latest/keypoint/core/#supervision.key_points.core.KeyPoints.from_transformers) + method, which accepts [ViTPose](https://huggingface.co/docs/transformers/en/model_doc/vitpose) result. + + ```python + from PIL import Image + import requests + import supervision as sv + import torch + from transformers import ( + AutoProcessor, + RTDetrForObjectDetection, + VitPoseForPoseEstimation, + ) + + device = "cuda" if torch.cuda.is_available() else "cpu" + image = Image.open("") + + DETECTION_MODEL_ID = "PekingU/rtdetr_r50vd_coco_o365" + + detection_processor = AutoProcessor.from_pretrained(DETECTION_MODEL_ID, use_fast=True) + detection_model = RTDetrForObjectDetection.from_pretrained(DETECTION_MODEL_ID, device_map=DEVICE) + + inputs = detection_processor(images=frame, return_tensors="pt").to(DEVICE) + + with torch.no_grad(): + outputs = detection_model(**inputs) + + target_size = torch.tensor([(frame.height, frame.width)]) + results = detection_processor.post_process_object_detection( + outputs, target_sizes=target_size, threshold=0.3) + + detections = sv.Detections.from_transformers(results[0]) + boxes = sv.xyxy_to_xywh(detections[detections.class_id == 0].xyxy) + + POSE_ESTIMATION_MODEL_ID = "usyd-community/vitpose-base-simple" + + pose_estimation_processor = AutoProcessor.from_pretrained(POSE_ESTIMATION_MODEL_ID) + pose_estimation_model = VitPoseForPoseEstimation.from_pretrained( + POSE_ESTIMATION_MODEL_ID, device_map=DEVICE) + + inputs = pose_estimation_processor(frame, boxes=[boxes], return_tensors="pt").to(DEVICE) + + with torch.no_grad(): + outputs = pose_estimation_model(**inputs) + + results = pose_estimation_processor.post_process_pose_estimation(outputs, boxes=[boxes]) + key_point = sv.KeyPoints.from_transformers(results[0]) + ``` + + Attributes: + xy: An array of shape `(n, m, 2)` containing + `n` detected objects, each composed of `m` equally-sized + sets of key points, where each point is `[x, y]`. + class_id: An array of shape + `(n,)` containing the class ids of the detected objects. + keypoint_confidence: An array of shape + `(n, m)` containing the confidence scores of each keypoint. + detection_confidence: An array of shape + `(n,)` containing the detection-level confidence scores. + visible: An optional boolean array of shape + `(n, m)` indicating which keypoints are visible. When ``None``, + all keypoints are treated as visible. Set this to filter anchors + without removing data: ``key_points.visible = key_points.keypoint_confidence > 0.3``. + data: A dictionary containing additional + data where each key is a string representing the data type, and the value + is either a NumPy array or a list of corresponding data of length `n` + (one entry per detected object). + """ # noqa: E501 // docs + + xy: npt.NDArray[np.float32] + class_id: npt.NDArray[np.int_] | None = None + keypoint_confidence: npt.NDArray[np.float32] | None = None + detection_confidence: npt.NDArray[np.float32] | None = None + visible: npt.NDArray[np.bool_] | None = None + data: _DetectionDataType = field(default_factory=dict) + + def __init__( + self, + xy: npt.NDArray[np.float32], + class_id: npt.NDArray[np.int_] | None = None, + keypoint_confidence: npt.NDArray[np.float32] | None = None, + detection_confidence: npt.NDArray[np.float32] | None = None, + visible: npt.NDArray[np.bool_] | None = None, + data: _DetectionDataType | None = None, + *, + confidence: npt.NDArray[np.float32] | None = None, + ) -> None: + """Initialize KeyPoints. + + Args: + xy: Array of shape `(n, m, 2)` with keypoint coordinates. + class_id: Array of shape `(n,)` with class IDs. Defaults to None. + keypoint_confidence: Array of shape `(n, m)` with per-keypoint + confidence scores. Defaults to None. + detection_confidence: Array of shape `(n,)` with detection-level + confidence scores. Defaults to None. + visible: Boolean array of shape `(n, m)` indicating visible + keypoints. Defaults to None. + data: Dictionary of additional per-detection data arrays. + Defaults to an empty dict. + confidence: Deprecated since `0.29.0`, removed in `0.32.0`. + Use ``keypoint_confidence`` instead. Raises ``ValueError`` + if passed together with ``keypoint_confidence``. + + Raises: + ValueError: If both ``confidence`` and ``keypoint_confidence`` + are provided. + """ + if confidence is not None: + if keypoint_confidence is not None: + raise ValueError( + "Cannot pass both 'confidence' and 'keypoint_confidence'. " + "'confidence' is deprecated โ€” use 'keypoint_confidence' only." + ) + warn_deprecated( + "'confidence' parameter in `KeyPoints()` is deprecated since " + "`0.29.0` and will be removed in `0.32.0`. Use " + "'keypoint_confidence' instead." + ) + keypoint_confidence = confidence + + self.xy = xy + self.class_id = class_id + self.keypoint_confidence = keypoint_confidence + self.detection_confidence = detection_confidence + self.visible = visible + self.data = data if data is not None else {} + self.__post_init__() + + def __post_init__(self) -> None: + _validate_keypoints_fields( + xy=self.xy, + class_id=self.class_id, + confidence=self.keypoint_confidence, + detection_confidence=self.detection_confidence, + visible=self.visible, + data=self.data, + ) + + @property + def confidence(self) -> npt.NDArray[np.float32] | None: + """Deprecated since 0.29.0. Use ``keypoint_confidence`` instead.""" + warn_deprecated( + "'KeyPoints.confidence' is deprecated since 0.29.0 and will be " + "removed in 0.32.0. Use 'KeyPoints.keypoint_confidence' instead." + ) + return self.keypoint_confidence + + @confidence.setter + def confidence(self, value: npt.NDArray[np.float32] | None) -> None: + warn_deprecated( + "'KeyPoints.confidence' is deprecated since 0.29.0 and will be " + "removed in 0.32.0. Use 'KeyPoints.keypoint_confidence' instead." + ) + self.keypoint_confidence = value + + def __len__(self) -> int: + """ + Returns the number of objects in the `sv.KeyPoints` object. + + Returns: + The number of objects. + + Example: + ```pycon + >>> import numpy as np + >>> import supervision as sv + >>> xy = np.array([[[10, 20], [30, 40]]], dtype=np.float32) + >>> key_points = sv.KeyPoints(xy=xy) + >>> len(key_points) + 1 + + ``` + """ + return len(self.xy) + + def __iter__( + self, + ) -> Iterator[ + tuple[ + npt.NDArray[np.float32], + npt.NDArray[np.float32] | None, + npt.NDArray[np.int_] | None, + _DetectionDataType, + ] + ]: + """ + Iterates over the Keypoint object and yield a tuple of + `(xy, keypoint_confidence, class_id, data)` for each object detection. + """ + for i in range(len(self.xy)): + yield ( + self.xy[i], + self.keypoint_confidence[i] + if self.keypoint_confidence is not None + else None, + self.class_id[i] if self.class_id is not None else None, + get_data_item(self.data, i), + ) + + def __eq__(self, other: object) -> bool: + if not isinstance(other, KeyPoints): + return NotImplemented + return all( + [ + np.array_equal(self.xy, other.xy), + _optional_array_equal(self.class_id, other.class_id), + _optional_array_equal( + self.keypoint_confidence, other.keypoint_confidence + ), + _optional_array_equal( + self.detection_confidence, other.detection_confidence + ), + _optional_array_equal(self.visible, other.visible), + is_data_equal(self.data, other.data), + ] + ) + + @classmethod + def from_inference(cls, inference_result: Any) -> KeyPoints: + """ + Create a `sv.KeyPoints` object from the [Roboflow](https://roboflow.com/) + API inference result or the [Inference](https://inference.roboflow.com/) + package results. + + Args: + inference_result: The result from the + Roboflow API or Inference package containing predictions with keypoints. + + Returns: + A `sv.KeyPoints` object containing the keypoint coordinates, class IDs, + and class names, and confidences of each keypoint. + + Examples: + ```python + import cv2 + import supervision as sv + from inference import get_model + + image = cv2.imread("") + model = get_model(model_id="", api_key="") + + result = model.infer(image)[0] + key_points = sv.KeyPoints.from_inference(result) + ``` + + ```python + import cv2 + import supervision as sv + from inference_sdk import InferenceHTTPClient + + image = cv2.imread("") + client = InferenceHTTPClient( + api_url="https://detect.roboflow.com", + api_key="" + ) + + result = client.infer(image, model_id="") + key_points = sv.KeyPoints.from_inference(result) + ``` + """ + if isinstance(inference_result, list): + raise ValueError( + "from_inference() operates on a single result at a time." + "You can retrieve it like so: inference_result = model.infer(image)[0]" + ) + + if hasattr(inference_result, "dict"): + inference_result = inference_result.dict(exclude_none=True, by_alias=True) + elif hasattr(inference_result, "json"): + inference_result = inference_result.json() + if not inference_result.get("predictions"): + return cls.empty() + + xy = [] + confidence = [] + class_id = [] + class_names = [] + + for prediction in inference_result["predictions"]: + prediction_xy = [] + prediction_confidence = [] + for keypoint in prediction["keypoints"]: + prediction_xy.append([keypoint["x"], keypoint["y"]]) + prediction_confidence.append(keypoint["confidence"]) + xy.append(prediction_xy) + confidence.append(prediction_confidence) + + class_id.append(prediction["class_id"]) + class_names.append(prediction["class"]) + + data: _DetectionDataType = {CLASS_NAME_DATA_FIELD: np.array(class_names)} + + return cls( + xy=np.array(xy, dtype=np.float32), + keypoint_confidence=np.array(confidence, dtype=np.float32), + class_id=np.array(class_id, dtype=int), + data=data, + ) + + @classmethod + def from_mediapipe( + cls, mediapipe_results: Any, resolution_wh: tuple[int, int] + ) -> KeyPoints: + """ + Creates a `sv.KeyPoints` instance from a + [MediaPipe](https://github.com/google-ai-edge/mediapipe) + pose landmark detection inference result. + + Args: + mediapipe_results: The output results from Mediapipe. It supports pose + and face landmarks from `PoseLandmarker`, `FaceLandmarker` and the + legacy ones from `Pose` and `FaceMesh`. + resolution_wh: A tuple of the form `(width, height)` representing the + resolution of the frame. + + Returns: + A `sv.KeyPoints` object containing the keypoint coordinates and + confidences of each keypoint. + + !!! tip + Before you start, download model bundles from the + [MediaPipe website](https://ai.google.dev/edge/mediapipe/solutions/vision/pose_landmarker/index#models). + + Examples: + ```python + import cv2 + import mediapipe as mp + import supervision as sv + + image = cv2.imread("") + image_height, image_width, _ = image.shape + mediapipe_image = mp.Image( + image_format=mp.ImageFormat.SRGB, + data=cv2.cvtColor(image, cv2.COLOR_BGR2RGB)) + + options = mp.tasks.vision.PoseLandmarkerOptions( + base_options=mp.tasks.BaseOptions( + model_asset_path="pose_landmarker_heavy.task" + ), + running_mode=mp.tasks.vision.RunningMode.IMAGE, + num_poses=2) + + PoseLandmarker = mp.tasks.vision.PoseLandmarker + with PoseLandmarker.create_from_options(options) as landmarker: + pose_landmarker_result = landmarker.detect(mediapipe_image) + + key_points = sv.KeyPoints.from_mediapipe( + pose_landmarker_result, (image_width, image_height)) + ``` + + ```python + import cv2 + import mediapipe as mp + import supervision as sv + + image = cv2.imread("") + image_height, image_width, _ = image.shape + mediapipe_image = mp.Image( + image_format=mp.ImageFormat.SRGB, + data=cv2.cvtColor(image, cv2.COLOR_BGR2RGB)) + + options = mp.tasks.vision.FaceLandmarkerOptions( + base_options=mp.tasks.BaseOptions( + model_asset_path="face_landmarker.task" + ), + output_face_blendshapes=True, + output_facial_transformation_matrixes=True, + num_faces=2) + + FaceLandmarker = mp.tasks.vision.FaceLandmarker + with FaceLandmarker.create_from_options(options) as landmarker: + face_landmarker_result = landmarker.detect(mediapipe_image) + + key_points = sv.KeyPoints.from_mediapipe( + face_landmarker_result, (image_width, image_height)) + ``` + + """ + if hasattr(mediapipe_results, "pose_landmarks"): + results = mediapipe_results.pose_landmarks + if not isinstance(mediapipe_results.pose_landmarks, list): + if mediapipe_results.pose_landmarks is None: + results = [] + else: + results = [ + [ + landmark + for landmark in mediapipe_results.pose_landmarks.landmark + ] + ] + elif hasattr(mediapipe_results, "face_landmarks"): + results = mediapipe_results.face_landmarks + elif hasattr(mediapipe_results, "multi_face_landmarks"): + if mediapipe_results.multi_face_landmarks is None: + results = [] + else: + results = [ + face_landmark.landmark + for face_landmark in mediapipe_results.multi_face_landmarks + ] + else: + # Reject unsupported MediaPipe-like payloads before landmark parsing. + raise ValueError( + "Unsupported MediaPipe result type. Expected an object with " + "pose_landmarks, face_landmarks, or multi_face_landmarks." + ) + + if len(results) == 0: + return cls.empty() + + xy = [] + confidence = [] + for pose in results: + prediction_xy = [] + prediction_confidence = [] + for landmark in pose: + keypoint_xy = [ + landmark.x * resolution_wh[0], + landmark.y * resolution_wh[1], + ] + prediction_xy.append(keypoint_xy) + prediction_confidence.append(landmark.visibility) + + xy.append(prediction_xy) + confidence.append(prediction_confidence) + + return cls( + xy=np.array(xy, dtype=np.float32), + keypoint_confidence=np.array(confidence, dtype=np.float32), + ) + + @classmethod + def from_ultralytics(cls, ultralytics_results: Any) -> KeyPoints: + """ + Creates a `sv.KeyPoints` instance from a + [YOLOv8](https://github.com/ultralytics/ultralytics) pose inference result. + + Args: + ultralytics_results: The output Results instance from YOLOv8. + + Returns: + A `sv.KeyPoints` object containing the keypoint coordinates, class IDs, + and class names, and confidences of each keypoint. + + Examples: + ```python + import cv2 + import supervision as sv + from ultralytics import YOLO + + image = cv2.imread("") + model = YOLO('yolov8s-pose.pt') + + result = model(image)[0] + key_points = sv.KeyPoints.from_ultralytics(result) + ``` + """ + if ultralytics_results.keypoints.xy.numel() == 0: + return cls.empty() + + xy = ultralytics_results.keypoints.xy.cpu().numpy() + class_id = ultralytics_results.boxes.cls.cpu().numpy().astype(int) + class_names = np.array([ultralytics_results.names[i] for i in class_id]) + + confidence = ultralytics_results.keypoints.conf.cpu().numpy() + data: _DetectionDataType = {CLASS_NAME_DATA_FIELD: class_names} + return cls(xy=xy, class_id=class_id, keypoint_confidence=confidence, data=data) + + @classmethod + def from_yolo_nas(cls, yolo_nas_results: Any) -> KeyPoints: + """ + Create a `sv.KeyPoints` instance from a [YOLO-NAS](https://github.com/Deci-AI/super-gradients/blob/master/YOLONAS-POSE.md) + pose inference results. + + Args: + yolo_nas_results: The output object from YOLO NAS. + + Returns: + A `sv.KeyPoints` object containing the keypoint coordinates, class IDs, + and class names, and confidences of each keypoint. + + Examples: + ```python + import cv2 + import torch + import supervision as sv + import super_gradients + + image = cv2.imread("") + + device = "cuda" if torch.cuda.is_available() else "cpu" + model = super_gradients.training.models.get( + "yolo_nas_pose_s", pretrained_weights="coco_pose").to(device) + + results = model.predict(image, conf=0.1) + key_points = sv.KeyPoints.from_yolo_nas(results) + ``` + """ + if len(yolo_nas_results.prediction.poses) == 0: + return cls.empty() + + xy = yolo_nas_results.prediction.poses[:, :, :2] + confidence = yolo_nas_results.prediction.poses[:, :, 2] + + # yolo_nas_results treats params differently. + # prediction.labels may not exist, whereas class_names might be None + if hasattr(yolo_nas_results.prediction, "labels"): + class_id = yolo_nas_results.prediction.labels # np.array[int] + else: + class_id = None + + data: _DetectionDataType = {} + if class_id is not None and yolo_nas_results.class_names is not None: + class_names = [] + for c_id in class_id: + name = yolo_nas_results.class_names[c_id] # tuple[str] + class_names.append(name) + data[CLASS_NAME_DATA_FIELD] = class_names + + return cls( + xy=xy, + keypoint_confidence=confidence, + class_id=class_id, + data=data, + ) + + @classmethod + def from_detectron2(cls, detectron2_results: Any) -> KeyPoints: + """ + Create a `sv.KeyPoints` object from the + [Detectron2](https://github.com/facebookresearch/detectron2) inference result. + + Args: + detectron2_results: The output of a + Detectron2 model containing instances with prediction data. + + Returns: + A `sv.KeyPoints` object containing the keypoint coordinates, class IDs, + and class names, and confidences of each keypoint. + + Examples: + ```python + import cv2 + import supervision as sv + from detectron2.engine import DefaultPredictor + from detectron2.config import get_cfg + + + image = cv2.imread("") + cfg = get_cfg() + cfg.merge_from_file("") + cfg.MODEL.WEIGHTS = "" + predictor = DefaultPredictor(cfg) + + result = predictor(image) + keypoints = sv.KeyPoints.from_detectron2(result) + ``` + """ + + if hasattr(detectron2_results["instances"], "pred_keypoints"): + if detectron2_results["instances"].pred_keypoints.cpu().numpy().size == 0: + return cls.empty() + return cls( + xy=detectron2_results["instances"] + .pred_keypoints.cpu() + .numpy()[:, :, :2], + keypoint_confidence=detectron2_results["instances"] + .pred_keypoints.cpu() + .numpy()[:, :, 2], + class_id=detectron2_results["instances"] + .pred_classes.cpu() + .numpy() + .astype(int), + ) + else: + return cls.empty() + + @classmethod + def from_transformers(cls, transformers_results: Any) -> KeyPoints: + """ + Create a `sv.KeyPoints` object from the + [Transformers](https://github.com/huggingface/transformers) inference result. + + Args: + transformers_results: The output of a + Transformers model containing instances with prediction data. + + Returns: + A `sv.KeyPoints` object containing the keypoint coordinates, class IDs, + and class names, and confidences of each keypoint. + + Examples: + ```python + from PIL import Image + import requests + import supervision as sv + import torch + from transformers import ( + AutoProcessor, + RTDetrForObjectDetection, + VitPoseForPoseEstimation, + ) + + device = "cuda" if torch.cuda.is_available() else "cpu" + image = Image.open("") + + DETECTION_MODEL_ID = "PekingU/rtdetr_r50vd_coco_o365" + + detection_processor = AutoProcessor.from_pretrained(DETECTION_MODEL_ID, use_fast=True) + detection_model = RTDetrForObjectDetection.from_pretrained(DETECTION_MODEL_ID, device_map=device) + + inputs = detection_processor(images=frame, return_tensors="pt").to(device) + + with torch.no_grad(): + outputs = detection_model(**inputs) + + target_size = torch.tensor([(frame.height, frame.width)]) + results = detection_processor.post_process_object_detection( + outputs, target_sizes=target_size, threshold=0.3) + + detections = sv.Detections.from_transformers(results[0]) + boxes = sv.xyxy_to_xywh(detections[detections.class_id == 0].xyxy) + + POSE_ESTIMATION_MODEL_ID = "usyd-community/vitpose-base-simple" + + pose_estimation_processor = AutoProcessor.from_pretrained(POSE_ESTIMATION_MODEL_ID) + pose_estimation_model = VitPoseForPoseEstimation.from_pretrained( + POSE_ESTIMATION_MODEL_ID, device_map=device) + + inputs = pose_estimation_processor(frame, boxes=[boxes], return_tensors="pt").to(device) + + with torch.no_grad(): + outputs = pose_estimation_model(**inputs) + + results = pose_estimation_processor.post_process_pose_estimation(outputs, boxes=[boxes]) + key_point = sv.KeyPoints.from_transformers(results[0]) + ``` + + """ # noqa: E501 // docs + + if "keypoints" in transformers_results[0]: + if transformers_results[0]["keypoints"].cpu().numpy().size == 0: + return cls.empty() + + result_data = [ + ( + result["keypoints"].cpu().numpy(), + result["scores"].cpu().numpy(), + ) + for result in transformers_results + ] + + xy, scores = zip(*result_data) + + return cls( + xy=np.stack(xy).astype(np.float32), + keypoint_confidence=np.stack(scores).astype(np.float32), + class_id=np.arange(len(xy)).astype(int), + ) + else: + return cls.empty() + + def _get_by_2d_bool_mask(self, mask: npt.NDArray[np.bool_]) -> KeyPoints: + """Filter keypoints using a 2D boolean mask of shape `(n, m)`. + + This method selects the **same set of keypoints from every object**, so + every row of `mask` must contain the same number of `True` values. The + result is a new `KeyPoints` whose keypoint count is that uniform `k`. + + This is suitable for use cases such as *"keep only the left-side joints for + all persons"* โ€” where the selected joint indices are identical across objects. + + It is **not** suitable for per-object confidence filtering + (`kp[kp.confidence > 0.5]`) when the threshold yields a different number of + passing keypoints per object, because NumPy cannot represent a ragged + `(n, ?, 2)` array. For that pattern either process objects individually or + zero out low-confidence entries in-place via `kp.confidence`. + + For the single-object case (`n == 1`) any boolean mask always satisfies the + uniform-count requirement, so `kp[kp.confidence > 0.5]` works as expected. + + Args: + mask: A boolean array of shape `(n, m)` where `n` is the number of + objects and `m` is the number of keypoints per object. Every row + must select the same number of keypoints so that the result can be + stored in a uniform `(n, k, ...)` array. + + Returns: + A new `KeyPoints` instance containing only the keypoints selected by + the mask for each object. + + Raises: + ValueError: If `mask.shape[0]` does not match the number of objects, if + `mask.shape[1]` does not match the number of keypoints, or if + different rows of the mask select different numbers of `True` values. + """ + n = len(self.xy) + if mask.shape[0] != n: + raise ValueError( + f"2D boolean mask row count {mask.shape[0]} does not match " + f"object count {n}." + ) + if mask.shape[1] != self.xy.shape[1]: + raise ValueError( + f"2D boolean mask column count {mask.shape[1]} does not match " + f"keypoint count {self.xy.shape[1]}." + ) + counts = np.sum(mask, axis=1) + if n > 0 and not np.all(counts == counts[0]): + raise ValueError( + "Cannot filter keypoints with a 2D boolean mask where rows have " + "different numbers of True values. " + "All objects must select the same number of keypoints. " + f"Got counts per object: {counts.tolist()}" + ) + k = int(counts[0]) if n > 0 else 0 + xy_selected = np.zeros((n, k, self.xy.shape[2]), dtype=self.xy.dtype) + keypoint_confidence_selected: npt.NDArray[np.float32] | None = None + if self.keypoint_confidence is not None: + keypoint_confidence_selected = cast( + npt.NDArray[np.float32], + np.zeros((n, k), dtype=self.keypoint_confidence.dtype), + ) + visible_selected: npt.NDArray[np.bool_] | None = None + if self.visible is not None: + visible_selected = np.zeros((n, k), dtype=bool) + for row in range(n): + row_indices = np.flatnonzero(mask[row]) + xy_selected[row] = self.xy[row, row_indices] + if ( + keypoint_confidence_selected is not None + and self.keypoint_confidence is not None + ): + keypoint_confidence_selected[row] = self.keypoint_confidence[ + row, row_indices + ] + if visible_selected is not None and self.visible is not None: + visible_selected[row] = self.visible[row, row_indices] + detection_confidence_selected = None + if self.detection_confidence is not None: + detection_confidence_selected = self.detection_confidence.copy() + + class_id_selected = None + if self.class_id is not None: + class_id_selected = self.class_id.copy() + + data_selected = get_data_item(self.data, slice(None)) + + return KeyPoints( + xy=xy_selected, + keypoint_confidence=keypoint_confidence_selected, + detection_confidence=detection_confidence_selected, + visible=visible_selected, + class_id=class_id_selected, + data=data_selected, + ) + + def get_data(self, key: str) -> _DetectionDataValueType | None: + """Get a value from the keypoint data dictionary. + + Args: + key: Data field name. + + Returns: + The stored data value, or `None` when the key is absent. + + Example: + >>> import numpy as np + >>> from supervision import KeyPoints + >>> key_points = KeyPoints( + ... xy=np.array([[[0, 0]]]), + ... data={"class_name": np.array(["person"])}, + ... ) + >>> key_points.get_data("class_name").tolist() + ['person'] + """ + return self.data.get(key) + + def select( + self, + index: Index1D | Index2D, + ) -> KeyPoints: + """Get a subset of the KeyPoints object. + + Supports detection-level (skeleton) filtering, keypoint-level (anchor) + filtering, and combined tuple indexing. + + Args: + index: Index, indices, slice, or boolean mask selecting key points. + + Returns: + A new `KeyPoints` instance containing the selected rows or anchors. + + Example: + >>> import numpy as np + >>> from supervision import KeyPoints + >>> key_points = KeyPoints(xy=np.array([[[0, 1]], [[2, 3]]])) + >>> key_points.select([1]).xy.tolist() + [[[2, 3]]] + """ + if isinstance(index, np.ndarray) and index.ndim == 2 and index.dtype == bool: + return self._get_by_2d_bool_mask(cast(npt.NDArray[np.bool_], index)) + + if not isinstance(index, tuple): + index = (index, slice(None)) + + i, j = index + + if isinstance(i, int): + i = [i] + + if isinstance(i, list) and i and all(isinstance(x, bool) for x in i): + i = np.array(i) + if isinstance(j, list) and j and all(isinstance(x, bool) for x in j): + j = np.array(j) + + if isinstance(i, np.ndarray) and i.dtype == bool: + i = np.flatnonzero(i) + if isinstance(j, np.ndarray) and j.dtype == bool: + j = np.flatnonzero(j) + + raw_i = i + + if ( + isinstance(i, (list, np.ndarray)) + and isinstance(j, (list, np.ndarray)) + and not np.isscalar(i) + and not np.isscalar(j) + ): + i_ix, j_ix = np.ix_(cast(Any, i), cast(Any, j)) + i = cast(Any, i_ix) + j = cast(Any, j_ix) + + row_i = _normalize_row_index(raw_i) + + xy_selected = self.xy[i, j] + + keypoint_confidence_selected = None + if self.keypoint_confidence is not None: + keypoint_confidence_selected = self.keypoint_confidence[i, j] + + detection_confidence_selected = None + if self.detection_confidence is not None: + detection_confidence_selected = self.detection_confidence[row_i] + + visible_selected = None + if self.visible is not None: + visible_selected = self.visible[i, j] + + class_id_selected = self.class_id[row_i] if self.class_id is not None else None + + data_selected = get_data_item(self.data, cast(Any, row_i)) + + if xy_selected.ndim == 1: + xy_selected = xy_selected.reshape(1, 1, 2) + if keypoint_confidence_selected is not None: + keypoint_confidence_selected = keypoint_confidence_selected.reshape( + 1, 1 + ) + if visible_selected is not None: + visible_selected = visible_selected.reshape(1, 1) + elif xy_selected.ndim == 2: + if np.isscalar(index[0]) or ( + isinstance(index[0], np.ndarray) and index[0].ndim == 0 + ): + xy_selected = xy_selected[np.newaxis, ...] + if keypoint_confidence_selected is not None: + keypoint_confidence_selected = keypoint_confidence_selected[ + np.newaxis, ... + ] + if visible_selected is not None: + visible_selected = visible_selected[np.newaxis, ...] + elif np.isscalar(index[1]) or ( + isinstance(index[1], np.ndarray) and index[1].ndim == 0 + ): + xy_selected = xy_selected[:, np.newaxis, :] + if keypoint_confidence_selected is not None: + keypoint_confidence_selected = keypoint_confidence_selected[ + :, np.newaxis + ] + if visible_selected is not None: + visible_selected = visible_selected[:, np.newaxis] + + return KeyPoints( + xy=xy_selected, + keypoint_confidence=keypoint_confidence_selected, + detection_confidence=detection_confidence_selected, + visible=visible_selected, + class_id=class_id_selected, + data=data_selected, + ) + + def __getitem__( + self, + index: Index1D | Index2D | str, + ) -> KeyPoints | npt.NDArray[np.generic] | list[Any] | None: + """ + Get a subset of the KeyPoints object or access an item from its data field. + + Supports detection-level (skeleton) filtering, keypoint-level (anchor) + filtering, combined tuple indexing, and data field access by string key. + + Args: + index: The index, indices, or key to access a subset of the KeyPoints + or an item from the data. + + Returns: + A subset of the KeyPoints object or an item from the data field. + + Examples: + ```python + import supervision as sv + + key_points = sv.KeyPoints(...) + + # detection-level filtering (returns KeyPoints) + high_conf = key_points[key_points.detection_confidence > 0.5] + class_0 = key_points[key_points.class_id == 0] + + # keypoint-level filtering (returns KeyPoints) + visible = key_points[key_points.keypoint_confidence > 0.3] + + # indexing + first = key_points[0] + first_two = key_points[0:2] + subset = key_points[[0, 2]] + + # anchor selection (uniform across all skeletons) + nose_and_eyes = key_points[:, [0, 1, 2]] + + # data field access + class_names = key_points['class_name'] + ``` + """ + if isinstance(index, str): + return self.get_data(index) + return self.select(index) + + def __setitem__(self, key: str, value: npt.NDArray[np.generic] | list[Any]) -> None: + """ + Set a value in the data dictionary of the `sv.KeyPoints` object. + + Args: + key: The key in the data dictionary to set. + value: The value to set for the key. + + Examples: + ```python + import cv2 + import supervision as sv + from ultralytics import YOLO + + image = cv2.imread("") + model = YOLO('yolov8s.pt') + + result = model(image)[0] + key_points = sv.KeyPoints.from_ultralytics(result) + + key_points['class_name'] = [ + model.model.names[class_id] + for class_id + in key_points.class_id + ] + ``` + """ + if not isinstance(value, (np.ndarray, list)): + raise TypeError("Value must be a np.ndarray or a list") + + if isinstance(value, list): + value = np.array(value) + + self.data[key] = value + + @classmethod + def empty(cls) -> KeyPoints: + """ + Create an empty KeyPoints object with no key points. + + Returns: + An empty `sv.KeyPoints` object. + + Examples: + ```pycon + >>> import supervision as sv + >>> key_points = sv.KeyPoints.empty() + >>> len(key_points) + 0 + + ``` + """ + return cls(xy=np.empty((0, 0, 2), dtype=np.float32)) + + def is_empty(self) -> bool: + """ + Returns `True` if the `KeyPoints` object is considered empty. + + Returns: + `True` if the object is empty, `False` otherwise. + + Example: + ```pycon + >>> import supervision as sv + >>> key_points = sv.KeyPoints.empty() + >>> key_points.is_empty() + True + + ``` + """ + return len(self) == 0 + + @classmethod + def merge(cls, key_points_list: list[KeyPoints]) -> KeyPoints: + """ + Merge a list of KeyPoints objects into a single KeyPoints object. + + This method takes a list of KeyPoints objects and combines their + respective fields (`xy`, `class_id`, `keypoint_confidence`, + `detection_confidence`, and `visible`) into a single KeyPoints object. + The `data` dictionaries are merged key-wise, following the same rules + as `Detections.merge`. + + For example, if merging KeyPoints with 2 and 3 skeletons, this method + will return a KeyPoints with 5 skeletons (5 entries in `xy`, etc). + + !!! Note + + When merging, empty `KeyPoints` objects are ignored. + + Args: + key_points_list: A list of KeyPoints objects to merge. + + Returns: + A single KeyPoints object containing the merged data from the input list. + + Raises: + ValueError: If the non-empty inputs do not share the same number + of keypoints per skeleton. + ValueError: If the non-empty inputs do not share the same + coordinate depth (`xy.shape[2]`) per skeleton. + ValueError: If some inputs have a field set (`class_id`, + `keypoint_confidence`, `detection_confidence`, or `visible`) + and others do not. + ValueError: If the input `data` dictionaries do not share the + same keys. + + Example: + >>> import numpy as np + >>> import supervision as sv + >>> key_points_1 = sv.KeyPoints( + ... xy=np.array([[[10, 10], [20, 20]]], dtype=np.float32), + ... class_id=np.array([0]), + ... data={'class_name': np.array(['person'])}, + ... ) + >>> key_points_2 = sv.KeyPoints( + ... xy=np.array([[[30, 30], [40, 40]]], dtype=np.float32), + ... class_id=np.array([1]), + ... data={'class_name': np.array(['dog'])}, + ... ) + >>> merged = sv.KeyPoints.merge([key_points_1, key_points_2]) + >>> len(merged) + 2 + >>> merged.class_id + array([0, 1]) + >>> merged.data['class_name'] + array(['person', 'dog'], dtype=' 1: + raise ValueError( + "All KeyPoints must have the same number of keypoints per " + f"skeleton to be merged; got counts {sorted(keypoint_counts)}." + ) + + keypoint_depths = {key_points.xy.shape[2] for key_points in key_points_list} + if len(keypoint_depths) > 1: + raise ValueError( + "All KeyPoints must have the same coordinate depth per " + f"skeleton to be merged; got depths {sorted(keypoint_depths)}." + ) + + xy = np.vstack([key_points.xy for key_points in key_points_list]) + + def stack_or_none(name: str) -> npt.NDArray[np.generic] | None: + values = [getattr(key_points, name) for key_points in key_points_list] + if all(value is None for value in values): + return None + if any(value is None for value in values): + raise ValueError(f"All or none of the '{name}' fields must be None") + return cast(npt.NDArray[np.generic], np.concatenate(values, axis=0)) + + class_id = cast(npt.NDArray[np.int_] | None, stack_or_none("class_id")) + keypoint_confidence = cast( + npt.NDArray[np.float32] | None, stack_or_none("keypoint_confidence") + ) + detection_confidence = cast( + npt.NDArray[np.float32] | None, stack_or_none("detection_confidence") + ) + visible = cast(npt.NDArray[np.bool_] | None, stack_or_none("visible")) + + data = merge_data([key_points.data for key_points in key_points_list]) + + return cls( + xy=xy, + class_id=class_id, + keypoint_confidence=keypoint_confidence, + detection_confidence=detection_confidence, + visible=visible, + data=data, + ) + + def with_nms( + self, + threshold: float = 0.5, + class_agnostic: bool = False, + overlap_metric: OverlapMetric = OverlapMetric.IOU, + ) -> KeyPoints: + """ + Performs non-max suppression on the keypoint detections. Bounding boxes + are derived from valid keypoints of each skeleton, and standard box NMS + is applied. A keypoint is considered valid when its coordinates are not + all-zero and its `visible` flag is `True` (if `visible` is set). + + Args: + threshold: The intersection-over-union threshold to use for + non-maximum suppression. Must be in [0, 1]. Defaults to 0.5. + class_agnostic: Whether to perform class-agnostic non-maximum + suppression. If True, the class_id of each detection will be + ignored. Defaults to False. + overlap_metric: Metric used to compute the degree of overlap + between pairs of bounding boxes. Defaults to + `OverlapMetric.IOU`. + + Returns: + A new `sv.KeyPoints` object after non-maximum suppression. + + Raises: + ValueError: If `detection_confidence` is None. + ValueError: If `class_agnostic` is False and `class_id` + is None. + + Examples: + ```python + import cv2 + import supervision as sv + from rfdetr import RFDETRKeypointPreview + + image = cv2.imread("") + model = RFDETRKeypointPreview() + + key_points = model.predict(image) + key_points = key_points.with_nms(threshold=0.5) + ``` + """ + if len(self) == 0: + return self + + if self.detection_confidence is None: + raise ValueError( + "KeyPoints detection_confidence must be given for NMS to be executed." + ) + + if not class_agnostic and self.class_id is None: + raise ValueError( + "KeyPoints class_id must be given for NMS to be executed. If " + "you intended to perform class agnostic NMS set " + "class_agnostic=True." + ) + + xy = self.xy + valid = ~np.all(xy == 0, axis=-1) + if self.visible is not None: + valid = valid & self.visible + x_min = np.min(np.where(valid, xy[..., 0], np.inf), axis=1) + y_min = np.min(np.where(valid, xy[..., 1], np.inf), axis=1) + x_max = np.max(np.where(valid, xy[..., 0], -np.inf), axis=1) + y_max = np.max(np.where(valid, xy[..., 1], -np.inf), axis=1) + xyxy = np.stack([x_min, y_min, x_max, y_max], axis=1).astype(np.float32) + + if class_agnostic: + predictions = np.hstack([xyxy, self.detection_confidence.reshape(-1, 1)]) + else: + class_id = cast(npt.NDArray[np.int_], self.class_id) + predictions = np.hstack( + [ + xyxy, + self.detection_confidence.reshape(-1, 1), + class_id.reshape(-1, 1), + ] + ) + + keep = box_non_max_suppression( + predictions=predictions, + iou_threshold=threshold, + overlap_metric=overlap_metric, + ) + + return self.select(keep) + + def as_detections( + self, selected_keypoint_indices: Iterable[int] | None = None + ) -> Detections: + """ + Convert a KeyPoints object to a Detections object. This + approximates the bounding box of the detected object by + taking the bounding box that fits all key points. + + Args: + selected_keypoint_indices: The + indices of the key points to include in the bounding box + calculation. This helps focus on a subset of key points, + e.g. when some are occluded. Captures all key points by + default. An empty sequence (`[]`) is treated the same as + `None` and selects all key points. + + Returns: + detections: The converted detections object. + + Examples: + ```pycon + >>> import numpy as np + >>> import supervision as sv + >>> key_points = sv.KeyPoints( + ... xy=np.array([[[10, 20], [30, 40]]], dtype=np.float32) + ... ) + >>> detections = key_points.as_detections() + >>> detections.xyxy + array([[10., 20., 30., 40.]], dtype=float32) + + ``` + """ + if self.is_empty(): + return Detections.empty() + + xy = self.xy + indices: npt.NDArray[np.intp] | None = None + if selected_keypoint_indices is not None: + candidate = np.asarray(list(selected_keypoint_indices), dtype=np.intp) + if candidate.size > 0: + indices = candidate + if indices is not None: + xy = xy[:, indices, :] + + # [0, 0] is used by some frameworks to indicate a missing keypoint. Non-finite + # coordinates cannot form a valid detection box, so both cases are excluded. + valid = ~np.all(xy == 0, axis=2) & np.isfinite(xy).all(axis=2) # (N, M) + has_valid = valid.any(axis=1) # (N,) + + x, y = xy[:, :, 0], xy[:, :, 1] + x_min = np.where(valid, x, np.inf).min(axis=1) + y_min = np.where(valid, y, np.inf).min(axis=1) + x_max = np.where(valid, x, -np.inf).max(axis=1) + y_max = np.where(valid, y, -np.inf).max(axis=1) + + xyxy = np.stack((x_min, y_min, x_max, y_max), axis=1).astype(np.float32) + # Skeletons with no valid keypoints keep the original empty [0, 0, 0, 0] box. + xyxy[~has_valid] = 0.0 + + if self.detection_confidence is not None: + confidence = self.detection_confidence.astype(np.float32) + elif self.keypoint_confidence is not None: + keypoint_confidence = self.keypoint_confidence + if indices is not None: + keypoint_confidence = keypoint_confidence[:, indices] + confidence = keypoint_confidence.mean(axis=1).astype(np.float32) + else: + confidence = None + + detections = Detections(xyxy=xyxy, confidence=confidence) + detections.class_id = self.class_id + detections.data = self.data + detections = detections.select(has_valid) + + return detections diff --git a/src/supervision/key_points/skeletons.py b/src/supervision/key_points/skeletons.py new file mode 100644 index 0000000..71edfd6 --- /dev/null +++ b/src/supervision/key_points/skeletons.py @@ -0,0 +1,2646 @@ +from enum import Enum + +Edges = tuple[tuple[int, int], ...] + + +class Skeleton(Enum): + COCO = ( + (1, 2), + (1, 3), + (2, 3), + (2, 4), + (3, 5), + (6, 12), + (6, 7), + (6, 8), + (7, 13), + (7, 9), + (8, 10), + (9, 11), + (12, 13), + (14, 12), + (15, 13), + (16, 14), + (17, 15), + ) + + GHUM = ( + (1, 2), + (1, 5), + (2, 3), + (3, 4), + (4, 8), + (5, 6), + (6, 7), + (7, 9), + (10, 11), + (12, 13), + (12, 14), + (12, 24), + (13, 15), + (13, 25), + (14, 16), + (15, 17), + (16, 18), + (15, 19), + (16, 22), + (17, 19), + (17, 21), + (17, 23), + (18, 20), + (19, 21), + (24, 25), + (24, 26), + (25, 27), + (26, 28), + (27, 29), + (28, 30), + (28, 32), + (29, 31), + (29, 33), + (30, 32), + (31, 33), + ) + + FACEMESH_TESSELATION_NO_IRIS = ( + (128, 35), + (35, 140), + (140, 128), + (12, 1), + (1, 38), + (38, 12), + (233, 232), + (232, 121), + (121, 233), + (73, 38), + (38, 40), + (40, 73), + (129, 122), + (122, 48), + (48, 129), + (233, 122), + (122, 129), + (129, 233), + (105, 70), + (70, 68), + (68, 105), + (176, 172), + (172, 149), + (149, 176), + (119, 51), + (51, 102), + (102, 119), + (74, 40), + (40, 41), + (41, 74), + (10, 152), + (152, 109), + (109, 10), + (49, 116), + (116, 132), + (132, 49), + (195, 205), + (205, 212), + (212, 195), + (75, 41), + (41, 186), + (186, 75), + (81, 43), + (43, 184), + (184, 81), + (41, 93), + (93, 187), + (187, 41), + (231, 230), + (230, 119), + (119, 231), + (203, 213), + (213, 215), + (215, 203), + (84, 19), + (19, 18), + (18, 84), + (77, 62), + (62, 147), + (147, 77), + (161, 30), + (30, 31), + (31, 161), + (57, 158), + (158, 174), + (174, 57), + (107, 205), + (205, 195), + (195, 107), + (136, 215), + (215, 193), + (193, 136), + (204, 166), + (166, 99), + (99, 204), + (22, 72), + (72, 69), + (69, 22), + (52, 46), + (46, 5), + (5, 52), + (145, 25), + (25, 24), + (24, 145), + (78, 147), + (147, 92), + (92, 78), + (206, 51), + (51, 188), + (188, 206), + (202, 201), + (201, 19), + (19, 202), + (92, 107), + (107, 183), + (183, 92), + (91, 92), + (92, 182), + (182, 91), + (86, 85), + (85, 18), + (18, 86), + (207, 204), + (204, 37), + (37, 207), + (149, 172), + (172, 141), + (141, 149), + (93, 41), + (41, 40), + (40, 93), + (194, 190), + (190, 245), + (245, 194), + (160, 159), + (159, 29), + (29, 160), + (248, 247), + (247, 162), + (162, 248), + (237, 4), + (4, 197), + (197, 237), + (55, 69), + (69, 105), + (105, 55), + (194, 169), + (169, 9), + (9, 194), + (118, 229), + (229, 32), + (32, 118), + (190, 194), + (194, 56), + (56, 190), + (99, 98), + (98, 100), + (100, 99), + (127, 48), + (48, 101), + (101, 127), + (167, 80), + (80, 219), + (219, 167), + (156, 155), + (155, 27), + (27, 156), + (210, 50), + (50, 132), + (132, 210), + (136, 137), + (137, 151), + (151, 136), + (48, 127), + (127, 218), + (218, 48), + (224, 53), + (53, 54), + (54, 224), + (46, 52), + (52, 135), + (135, 46), + (212, 171), + (171, 141), + (141, 212), + (68, 70), + (70, 109), + (109, 68), + (44, 107), + (107, 92), + (92, 44), + (231, 120), + (120, 121), + (121, 231), + (227, 131), + (131, 248), + (248, 227), + (64, 54), + (54, 53), + (53, 64), + (239, 21), + (21, 243), + (243, 239), + (47, 71), + (71, 157), + (157, 47), + (79, 63), + (63, 97), + (97, 79), + (47, 54), + (54, 64), + (64, 47), + (144, 35), + (35, 228), + (228, 144), + (124, 118), + (118, 112), + (112, 124), + (45, 126), + (126, 20), + (20, 45), + (237, 135), + (135, 52), + (52, 237), + (217, 207), + (207, 206), + (206, 217), + (155, 154), + (154, 23), + (23, 155), + (40, 38), + (38, 168), + (168, 40), + (201, 202), + (202, 209), + (209, 201), + (37, 143), + (143, 101), + (101, 37), + (58, 213), + (213, 203), + (203, 58), + (21, 61), + (61, 100), + (100, 21), + (29, 159), + (159, 158), + (158, 29), + (36, 227), + (227, 114), + (114, 36), + (161, 160), + (160, 28), + (28, 161), + (205, 203), + (203, 211), + (211, 205), + (114, 226), + (226, 47), + (47, 114), + (44, 203), + (203, 205), + (205, 44), + (63, 77), + (77, 78), + (78, 63), + (138, 124), + (124, 117), + (117, 138), + (42, 39), + (39, 73), + (73, 42), + (204, 130), + (130, 143), + (143, 204), + (65, 99), + (99, 241), + (241, 65), + (50, 103), + (103, 65), + (65, 50), + (42, 74), + (74, 75), + (75, 42), + (213, 217), + (217, 208), + (208, 213), + (43, 75), + (75, 185), + (185, 43), + (170, 171), + (171, 212), + (212, 170), + (171, 150), + (150, 177), + (177, 171), + (106, 67), + (67, 70), + (70, 106), + (123, 7), + (7, 169), + (169, 123), + (124, 148), + (148, 188), + (188, 124), + (97, 78), + (78, 91), + (91, 97), + (66, 56), + (56, 108), + (108, 66), + (90, 91), + (91, 181), + (181, 90), + (102, 101), + (101, 121), + (121, 102), + (64, 106), + (106, 105), + (105, 64), + (94, 138), + (138, 228), + (228, 94), + (16, 87), + (87, 86), + (86, 16), + (130, 103), + (103, 50), + (50, 130), + (15, 88), + (88, 87), + (87, 15), + (56, 9), + (9, 10), + (10, 56), + (101, 48), + (48, 122), + (122, 101), + (146, 24), + (24, 23), + (23, 146), + (89, 90), + (90, 180), + (180, 89), + (7, 123), + (123, 197), + (197, 7), + (89, 96), + (96, 97), + (97, 89), + (139, 173), + (173, 137), + (137, 139), + (216, 59), + (59, 173), + (173, 216), + (116, 49), + (49, 220), + (220, 116), + (43, 81), + (81, 82), + (82, 43), + (196, 4), + (4, 52), + (52, 196), + (44, 147), + (147, 62), + (62, 44), + (172, 176), + (176, 200), + (200, 172), + (82, 83), + (83, 39), + (39, 82), + (54, 47), + (47, 226), + (226, 54), + (145, 164), + (164, 111), + (111, 145), + (53, 66), + (66, 67), + (67, 53), + (230, 229), + (229, 118), + (118, 230), + (35, 128), + (128, 235), + (235, 35), + (108, 109), + (109, 70), + (70, 108), + (110, 109), + (109, 152), + (152, 110), + (49, 65), + (65, 236), + (236, 49), + (63, 79), + (79, 192), + (192, 63), + (130, 210), + (210, 127), + (127, 130), + (112, 36), + (36, 144), + (144, 112), + (118, 124), + (124, 51), + (51, 118), + (223, 66), + (66, 53), + (53, 223), + (20, 126), + (126, 142), + (142, 20), + (222, 56), + (56, 66), + (66, 222), + (4, 196), + (196, 198), + (198, 4), + (26, 8), + (8, 34), + (34, 26), + (221, 238), + (238, 45), + (45, 221), + (71, 72), + (72, 140), + (140, 71), + (123, 194), + (194, 246), + (246, 123), + (248, 131), + (131, 34), + (34, 248), + (72, 22), + (22, 163), + (163, 72), + (171, 170), + (170, 151), + (151, 171), + (189, 175), + (175, 197), + (197, 189), + (217, 187), + (187, 93), + (93, 217), + (3, 98), + (98, 168), + (168, 3), + (142, 126), + (126, 242), + (242, 142), + (165, 168), + (168, 38), + (38, 165), + (73, 39), + (39, 13), + (13, 73), + (39, 83), + (83, 14), + (14, 39), + (64, 69), + (69, 72), + (72, 64), + (227, 36), + (36, 112), + (112, 227), + (102, 51), + (51, 206), + (206, 102), + (207, 93), + (93, 166), + (166, 207), + (210, 199), + (199, 218), + (218, 210), + (166, 168), + (168, 98), + (98, 166), + (221, 116), + (116, 219), + (219, 221), + (134, 113), + (113, 244), + (244, 134), + (240, 239), + (239, 242), + (242, 240), + (215, 136), + (136, 170), + (170, 215), + (191, 174), + (174, 134), + (134, 191), + (172, 209), + (209, 33), + (33, 172), + (126, 45), + (45, 238), + (238, 126), + (87, 88), + (88, 179), + (179, 87), + (86, 87), + (87, 180), + (180, 86), + (85, 86), + (86, 181), + (181, 85), + (84, 85), + (85, 182), + (182, 84), + (202, 84), + (84, 183), + (183, 202), + (138, 94), + (94, 133), + (133, 138), + (77, 63), + (63, 184), + (184, 77), + (62, 77), + (77, 185), + (185, 62), + (58, 62), + (62, 186), + (186, 58), + (213, 58), + (58, 187), + (187, 213), + (215, 208), + (208, 188), + (188, 215), + (35, 144), + (144, 157), + (157, 35), + (80, 240), + (240, 238), + (238, 80), + (124, 138), + (138, 178), + (178, 124), + (45, 2), + (2, 5), + (5, 45), + (202, 195), + (195, 33), + (33, 202), + (65, 103), + (103, 130), + (130, 65), + (214, 216), + (216, 139), + (139, 214), + (60, 167), + (167, 220), + (220, 60), + (243, 100), + (100, 98), + (98, 243), + (3, 95), + (95, 142), + (142, 3), + (76, 60), + (60, 236), + (236, 76), + (25, 111), + (111, 229), + (229, 25), + (26, 131), + (131, 227), + (227, 26), + (24, 25), + (25, 230), + (230, 24), + (23, 24), + (24, 231), + (231, 23), + (27, 23), + (23, 232), + (232, 27), + (113, 27), + (27, 233), + (233, 113), + (190, 191), + (191, 244), + (244, 190), + (222, 57), + (57, 191), + (191, 222), + (29, 57), + (57, 222), + (222, 29), + (28, 29), + (29, 223), + (223, 28), + (30, 28), + (28, 224), + (224, 30), + (31, 30), + (30, 225), + (225, 31), + (248, 31), + (31, 226), + (226, 248), + (239, 80), + (80, 21), + (21, 239), + (167, 60), + (60, 76), + (76, 167), + (61, 76), + (76, 241), + (241, 61), + (148, 178), + (178, 216), + (216, 148), + (21, 80), + (80, 167), + (167, 21), + (188, 148), + (148, 214), + (214, 188), + (113, 234), + (234, 245), + (245, 113), + (234, 129), + (129, 246), + (246, 234), + (129, 115), + (115, 189), + (189, 129), + (115, 218), + (218, 175), + (175, 115), + (132, 116), + (116, 221), + (221, 132), + (218, 199), + (199, 237), + (237, 218), + (199, 132), + (132, 135), + (135, 199), + (178, 133), + (133, 59), + (59, 178), + (144, 36), + (36, 125), + (125, 144), + (111, 164), + (164, 8), + (8, 111), + (229, 111), + (111, 26), + (26, 229), + (357, 390), + (390, 369), + (369, 357), + (12, 303), + (303, 268), + (268, 12), + (453, 351), + (351, 350), + (350, 453), + (303, 304), + (304, 270), + (270, 303), + (358, 344), + (344, 278), + (278, 358), + (453, 454), + (454, 358), + (358, 453), + (334, 333), + (333, 298), + (298, 334), + (176, 153), + (153, 378), + (378, 176), + (348, 349), + (349, 331), + (331, 348), + (304, 305), + (305, 271), + (271, 304), + (10, 337), + (337, 338), + (338, 10), + (279, 280), + (280, 361), + (361, 279), + (419, 263), + (263, 432), + (432, 419), + (305, 409), + (409, 410), + (410, 305), + (311, 416), + (416, 408), + (408, 311), + (271, 410), + (410, 411), + (411, 271), + (451, 349), + (349, 348), + (348, 451), + (423, 431), + (431, 435), + (435, 423), + (314, 315), + (315, 18), + (18, 314), + (307, 308), + (308, 376), + (376, 307), + (388, 389), + (389, 261), + (261, 388), + (287, 415), + (415, 399), + (399, 287), + (336, 407), + (407, 419), + (419, 336), + (365, 368), + (368, 417), + (417, 365), + (424, 359), + (359, 328), + (328, 424), + (252, 285), + (285, 299), + (299, 252), + (282, 6), + (6, 5), + (5, 282), + (374, 375), + (375, 254), + (254, 374), + (308, 321), + (321, 322), + (322, 308), + (426, 428), + (428, 412), + (412, 426), + (422, 314), + (314, 19), + (19, 422), + (322, 406), + (406, 407), + (407, 322), + (321, 405), + (405, 406), + (406, 321), + (316, 17), + (17, 18), + (18, 316), + (427, 426), + (426, 267), + (267, 427), + (378, 401), + (401, 370), + (370, 378), + (323, 392), + (392, 270), + (270, 323), + (418, 466), + (466, 465), + (465, 418), + (387, 258), + (258, 259), + (259, 387), + (467, 261), + (261, 389), + (389, 467), + (457, 400), + (400, 420), + (420, 457), + (285, 333), + (333, 334), + (334, 285), + (418, 286), + (286, 9), + (9, 418), + (347, 341), + (341, 262), + (262, 347), + (414, 442), + (442, 286), + (286, 414), + (328, 461), + (461, 329), + (329, 328), + (356, 372), + (372, 330), + (330, 356), + (393, 440), + (440, 439), + (439, 393), + (383, 342), + (342, 257), + (257, 383), + (430, 421), + (421, 361), + (361, 430), + (365, 395), + (395, 380), + (380, 365), + (278, 344), + (344, 438), + (438, 278), + (444, 445), + (445, 284), + (284, 444), + (276, 441), + (441, 364), + (364, 276), + (432, 263), + (263, 370), + (370, 432), + (298, 339), + (339, 338), + (338, 298), + (274, 376), + (376, 322), + (322, 274), + (451, 452), + (452, 350), + (350, 451), + (447, 343), + (343, 468), + (468, 447), + (294, 335), + (335, 283), + (283, 294), + (459, 462), + (462, 463), + (463, 459), + (277, 354), + (354, 384), + (384, 277), + (309, 325), + (325, 326), + (326, 309), + (277, 301), + (301, 294), + (294, 277), + (373, 346), + (346, 448), + (448, 373), + (353, 346), + (346, 341), + (341, 353), + (275, 2), + (2, 20), + (20, 275), + (457, 249), + (249, 282), + (282, 457), + (437, 428), + (428, 426), + (426, 437), + (382, 257), + (257, 253), + (253, 382), + (270, 392), + (392, 394), + (394, 270), + (201, 200), + (200, 429), + (429, 201), + (267, 331), + (331, 330), + (330, 267), + (288, 274), + (274, 423), + (423, 288), + (251, 463), + (463, 329), + (329, 251), + (259, 287), + (287, 385), + (385, 259), + (266, 354), + (354, 343), + (343, 266), + (388, 260), + (260, 258), + (258, 388), + (425, 432), + (432, 431), + (431, 425), + (343, 354), + (354, 277), + (277, 343), + (274, 336), + (336, 425), + (425, 274), + (293, 326), + (326, 308), + (308, 293), + (367, 448), + (448, 346), + (346, 367), + (272, 304), + (304, 303), + (303, 272), + (424, 267), + (267, 372), + (372, 424), + (295, 456), + (456, 461), + (461, 295), + (280, 279), + (279, 295), + (295, 280), + (272, 273), + (273, 305), + (305, 272), + (433, 435), + (435, 428), + (428, 433), + (273, 408), + (408, 409), + (409, 273), + (395, 431), + (431, 432), + (432, 395), + (396, 370), + (370, 401), + (401, 396), + (335, 334), + (334, 300), + (300, 335), + (352, 418), + (418, 169), + (169, 352), + (353, 281), + (281, 412), + (412, 353), + (326, 320), + (320, 321), + (321, 326), + (296, 297), + (297, 337), + (337, 296), + (320, 404), + (404, 405), + (405, 320), + (331, 349), + (349, 350), + (350, 331), + (294, 299), + (299, 334), + (334, 294), + (324, 455), + (455, 448), + (448, 324), + (16, 17), + (17, 316), + (316, 16), + (359, 430), + (430, 280), + (280, 359), + (15, 16), + (16, 317), + (317, 15), + (286, 337), + (337, 10), + (10, 286), + (330, 350), + (350, 351), + (351, 330), + (375, 381), + (381, 253), + (253, 375), + (319, 403), + (403, 404), + (404, 319), + (7, 198), + (198, 420), + (420, 7), + (319, 320), + (320, 326), + (326, 319), + (368, 365), + (365, 366), + (366, 368), + (436, 368), + (368, 398), + (398, 436), + (345, 439), + (439, 440), + (440, 345), + (273, 272), + (272, 312), + (312, 273), + (196, 6), + (6, 282), + (282, 196), + (274, 288), + (288, 292), + (292, 274), + (397, 429), + (429, 200), + (200, 397), + (312, 272), + (272, 269), + (269, 312), + (284, 445), + (445, 446), + (446, 284), + (374, 255), + (255, 340), + (340, 374), + (283, 335), + (335, 297), + (297, 283), + (450, 348), + (348, 347), + (347, 450), + (265, 448), + (448, 455), + (455, 265), + (337, 297), + (297, 300), + (300, 337), + (339, 11), + (11, 152), + (152, 339), + (279, 440), + (440, 456), + (456, 279), + (293, 408), + (408, 416), + (416, 293), + (359, 372), + (372, 356), + (356, 359), + (341, 346), + (346, 373), + (373, 341), + (347, 348), + (348, 281), + (281, 347), + (443, 444), + (444, 283), + (283, 443), + (20, 95), + (95, 371), + (371, 20), + (442, 443), + (443, 296), + (296, 442), + (249, 420), + (420, 198), + (198, 249), + (264, 256), + (256, 360), + (360, 264), + (441, 276), + (276, 275), + (275, 441), + (301, 384), + (384, 369), + (369, 301), + (352, 413), + (413, 466), + (466, 352), + (264, 468), + (468, 467), + (467, 264), + (302, 369), + (369, 390), + (390, 302), + (396, 379), + (379, 380), + (380, 396), + (413, 352), + (352, 420), + (420, 413), + (437, 427), + (427, 323), + (323, 437), + (3, 165), + (165, 394), + (394, 3), + (371, 463), + (463, 462), + (462, 371), + (165, 1), + (1, 268), + (268, 165), + (303, 12), + (12, 13), + (13, 303), + (269, 13), + (13, 14), + (14, 269), + (294, 301), + (301, 302), + (302, 294), + (447, 262), + (262, 341), + (341, 447), + (331, 267), + (267, 426), + (426, 331), + (427, 424), + (424, 392), + (392, 427), + (430, 356), + (356, 438), + (438, 430), + (392, 328), + (328, 327), + (327, 392), + (441, 458), + (458, 439), + (439, 441), + (342, 383), + (383, 363), + (363, 342), + (460, 458), + (458, 462), + (462, 460), + (435, 431), + (431, 395), + (395, 435), + (415, 464), + (464, 363), + (363, 415), + (397, 370), + (370, 263), + (263, 397), + (355, 462), + (462, 458), + (458, 355), + (317, 404), + (404, 403), + (403, 317), + (316, 405), + (405, 404), + (404, 316), + (315, 406), + (406, 405), + (405, 315), + (314, 407), + (407, 406), + (406, 314), + (422, 419), + (419, 407), + (407, 422), + (367, 402), + (402, 362), + (362, 367), + (307, 409), + (409, 408), + (408, 307), + (292, 410), + (410, 409), + (409, 292), + (288, 411), + (411, 410), + (410, 288), + (433, 437), + (437, 411), + (411, 433), + (435, 417), + (417, 412), + (412, 435), + (265, 369), + (369, 384), + (384, 265), + (310, 439), + (439, 458), + (458, 310), + (353, 377), + (377, 402), + (402, 353), + (275, 276), + (276, 5), + (5, 275), + (422, 429), + (429, 263), + (263, 422), + (295, 328), + (328, 359), + (359, 295), + (434, 417), + (417, 368), + (368, 434), + (290, 456), + (456, 440), + (440, 290), + (463, 371), + (371, 327), + (327, 463), + (3, 327), + (327, 371), + (371, 3), + (306, 461), + (461, 456), + (456, 306), + (255, 450), + (450, 449), + (449, 255), + (256, 262), + (262, 447), + (447, 256), + (254, 451), + (451, 450), + (450, 254), + (253, 452), + (452, 451), + (451, 253), + (257, 453), + (453, 452), + (452, 257), + (342, 454), + (454, 453), + (453, 342), + (414, 465), + (465, 464), + (464, 414), + (442, 414), + (414, 415), + (415, 442), + (259, 443), + (443, 442), + (442, 259), + (258, 444), + (444, 443), + (443, 258), + (260, 445), + (445, 444), + (444, 260), + (261, 446), + (446, 445), + (445, 261), + (468, 343), + (343, 446), + (446, 468), + (460, 459), + (459, 251), + (251, 460), + (290, 393), + (393, 291), + (291, 290), + (291, 329), + (329, 461), + (461, 291), + (377, 434), + (434, 436), + (436, 377), + (251, 291), + (291, 393), + (393, 251), + (412, 417), + (417, 434), + (434, 412), + (342, 464), + (464, 465), + (465, 342), + (454, 465), + (465, 466), + (466, 454), + (358, 466), + (466, 413), + (413, 358), + (344, 413), + (413, 400), + (400, 344), + (361, 364), + (364, 441), + (441, 361), + (438, 400), + (400, 457), + (457, 438), + (421, 457), + (457, 364), + (364, 421), + (402, 436), + (436, 289), + (289, 402), + (373, 384), + (384, 354), + (354, 373), + (340, 256), + (256, 250), + (250, 340), + (449, 262), + (262, 256), + (256, 449), + (134, 244), + (244, 191), + (191, 134), + (134, 156), + (156, 113), + (113, 134), + (34, 247), + (247, 248), + (248, 34), + (34, 131), + (131, 26), + (26, 34), + (399, 385), + (385, 287), + (287, 399), + (363, 399), + (399, 415), + (415, 363), + (363, 464), + (464, 342), + (342, 363), + (264, 360), + (360, 468), + (468, 264), + (264, 250), + (250, 256), + (256, 264), + (467, 468), + (468, 261), + (261, 467), + (76, 61), + (61, 167), + (167, 76), + (239, 240), + (240, 80), + (80, 239), + (163, 128), + (128, 140), + (140, 163), + (73, 12), + (12, 38), + (38, 73), + (122, 233), + (233, 121), + (121, 122), + (74, 73), + (73, 40), + (40, 74), + (115, 129), + (129, 48), + (48, 115), + (234, 233), + (233, 129), + (129, 234), + (104, 105), + (105, 68), + (68, 104), + (153, 176), + (176, 149), + (149, 153), + (120, 119), + (119, 102), + (102, 120), + (75, 74), + (74, 41), + (41, 75), + (108, 10), + (10, 109), + (109, 108), + (50, 49), + (49, 132), + (132, 50), + (33, 195), + (195, 212), + (212, 33), + (185, 75), + (75, 186), + (186, 185), + (192, 81), + (81, 184), + (184, 192), + (186, 41), + (41, 187), + (187, 186), + (120, 231), + (231, 119), + (119, 120), + (211, 203), + (203, 215), + (215, 211), + (85, 84), + (84, 18), + (18, 85), + (78, 77), + (77, 147), + (147, 78), + (162, 161), + (161, 31), + (31, 162), + (191, 57), + (57, 174), + (174, 191), + (183, 107), + (107, 195), + (195, 183), + (139, 136), + (136, 193), + (193, 139), + (130, 204), + (204, 99), + (99, 130), + (55, 22), + (22, 69), + (69, 55), + (6, 52), + (52, 5), + (5, 6), + (146, 145), + (145, 24), + (24, 146), + (91, 78), + (78, 92), + (92, 91), + (208, 206), + (206, 188), + (188, 208), + (84, 202), + (202, 19), + (19, 84), + (182, 92), + (92, 183), + (183, 182), + (181, 91), + (91, 182), + (182, 181), + (17, 86), + (86, 18), + (18, 17), + (206, 207), + (207, 37), + (37, 206), + (177, 149), + (149, 141), + (141, 177), + (166, 93), + (93, 40), + (40, 166), + (246, 194), + (194, 245), + (245, 246), + (28, 160), + (160, 29), + (29, 28), + (31, 248), + (248, 162), + (162, 31), + (175, 237), + (237, 197), + (197, 175), + (104, 55), + (55, 105), + (105, 104), + (56, 194), + (194, 9), + (9, 56), + (112, 118), + (118, 32), + (32, 112), + (222, 190), + (190, 56), + (56, 222), + (241, 99), + (99, 100), + (100, 241), + (143, 127), + (127, 101), + (101, 143), + (220, 167), + (167, 219), + (219, 220), + (113, 156), + (156, 27), + (27, 113), + (199, 210), + (210, 132), + (132, 199), + (170, 136), + (136, 151), + (151, 170), + (115, 48), + (48, 218), + (218, 115), + (225, 224), + (224, 54), + (54, 225), + (221, 46), + (46, 135), + (135, 221), + (33, 212), + (212, 141), + (141, 33), + (110, 68), + (68, 109), + (109, 110), + (147, 44), + (44, 92), + (92, 147), + (232, 231), + (231, 121), + (121, 232), + (114, 227), + (227, 248), + (248, 114), + (106, 64), + (64, 53), + (53, 106), + (242, 239), + (239, 243), + (243, 242), + (125, 47), + (47, 157), + (157, 125), + (96, 79), + (79, 97), + (97, 96), + (71, 47), + (47, 64), + (64, 71), + (117, 144), + (144, 228), + (228, 117), + (117, 124), + (124, 112), + (112, 117), + (2, 45), + (45, 20), + (20, 2), + (4, 237), + (237, 52), + (52, 4), + (208, 217), + (217, 206), + (206, 208), + (27, 155), + (155, 23), + (23, 27), + (166, 40), + (40, 168), + (168, 166), + (200, 201), + (201, 209), + (209, 200), + (102, 37), + (37, 101), + (101, 102), + (44, 58), + (58, 203), + (203, 44), + (243, 21), + (21, 100), + (100, 243), + (57, 29), + (29, 158), + (158, 57), + (125, 36), + (36, 114), + (114, 125), + (30, 161), + (161, 28), + (28, 30), + (212, 205), + (205, 211), + (211, 212), + (125, 114), + (114, 47), + (47, 125), + (107, 44), + (44, 205), + (205, 107), + (97, 63), + (63, 78), + (78, 97), + (228, 138), + (138, 117), + (117, 228), + (74, 42), + (42, 73), + (73, 74), + (37, 204), + (204, 143), + (143, 37), + (236, 65), + (65, 241), + (241, 236), + (49, 50), + (50, 65), + (65, 49), + (43, 42), + (42, 75), + (75, 43), + (215, 213), + (213, 208), + (208, 215), + (184, 43), + (43, 185), + (185, 184), + (211, 170), + (170, 212), + (212, 211), + (141, 171), + (171, 177), + (177, 141), + (105, 106), + (106, 70), + (70, 105), + (194, 123), + (123, 169), + (169, 194), + (51, 124), + (124, 188), + (188, 51), + (90, 97), + (97, 91), + (91, 90), + (67, 66), + (66, 108), + (108, 67), + (180, 90), + (90, 181), + (181, 180), + (120, 102), + (102, 121), + (121, 120), + (69, 64), + (64, 105), + (105, 69), + (235, 94), + (94, 228), + (228, 235), + (17, 16), + (16, 86), + (86, 17), + (210, 130), + (130, 50), + (50, 210), + (16, 15), + (15, 87), + (87, 16), + (108, 56), + (56, 10), + (10, 108), + (121, 101), + (101, 122), + (122, 121), + (154, 146), + (146, 23), + (23, 154), + (179, 89), + (89, 180), + (180, 179), + (198, 7), + (7, 197), + (197, 198), + (90, 89), + (89, 97), + (97, 90), + (136, 139), + (139, 137), + (137, 136), + (139, 216), + (216, 173), + (173, 139), + (219, 116), + (116, 220), + (220, 219), + (42, 43), + (43, 82), + (82, 42), + (6, 196), + (196, 52), + (52, 6), + (58, 44), + (44, 62), + (62, 58), + (209, 172), + (172, 200), + (200, 209), + (42, 82), + (82, 39), + (39, 42), + (225, 54), + (54, 226), + (226, 225), + (25, 145), + (145, 111), + (111, 25), + (106, 53), + (53, 67), + (67, 106), + (119, 230), + (230, 118), + (118, 119), + (228, 35), + (35, 235), + (235, 228), + (67, 108), + (108, 70), + (70, 67), + (11, 110), + (110, 152), + (152, 11), + (220, 49), + (49, 236), + (236, 220), + (184, 63), + (63, 192), + (192, 184), + (143, 130), + (130, 127), + (127, 143), + (117, 112), + (112, 144), + (144, 117), + (119, 118), + (118, 51), + (51, 119), + (224, 223), + (223, 53), + (53, 224), + (95, 20), + (20, 142), + (142, 95), + (223, 222), + (222, 66), + (66, 223), + (197, 4), + (4, 198), + (198, 197), + (46, 221), + (221, 45), + (45, 46), + (157, 71), + (71, 140), + (140, 157), + (189, 123), + (123, 246), + (246, 189), + (140, 72), + (72, 163), + (163, 140), + (150, 171), + (171, 151), + (151, 150), + (123, 189), + (189, 197), + (197, 123), + (207, 217), + (217, 93), + (93, 207), + (165, 3), + (3, 168), + (168, 165), + (243, 142), + (142, 242), + (242, 243), + (1, 165), + (165, 38), + (38, 1), + (12, 73), + (73, 13), + (13, 12), + (13, 39), + (39, 14), + (14, 13), + (71, 64), + (64, 72), + (72, 71), + (32, 227), + (227, 112), + (112, 32), + (37, 102), + (102, 206), + (206, 37), + (204, 207), + (207, 166), + (166, 204), + (127, 210), + (210, 218), + (218, 127), + (99, 166), + (166, 98), + (98, 99), + (238, 221), + (221, 219), + (219, 238), + (238, 240), + (240, 242), + (242, 238), + (211, 215), + (215, 170), + (170, 211), + (141, 172), + (172, 33), + (33, 141), + (242, 126), + (126, 238), + (238, 242), + (180, 87), + (87, 179), + (179, 180), + (181, 86), + (86, 180), + (180, 181), + (182, 85), + (85, 181), + (181, 182), + (183, 84), + (84, 182), + (182, 183), + (195, 202), + (202, 183), + (183, 195), + (178, 138), + (138, 133), + (133, 178), + (185, 77), + (77, 184), + (184, 185), + (186, 62), + (62, 185), + (185, 186), + (187, 58), + (58, 186), + (186, 187), + (217, 213), + (213, 187), + (187, 217), + (193, 215), + (215, 188), + (188, 193), + (140, 35), + (35, 157), + (157, 140), + (219, 80), + (80, 238), + (238, 219), + (148, 124), + (124, 178), + (178, 148), + (46, 45), + (45, 5), + (5, 46), + (209, 202), + (202, 33), + (33, 209), + (99, 65), + (65, 130), + (130, 99), + (193, 214), + (214, 139), + (139, 193), + (236, 60), + (60, 220), + (220, 236), + (142, 243), + (243, 98), + (98, 142), + (98, 3), + (3, 142), + (142, 98), + (241, 76), + (76, 236), + (236, 241), + (230, 25), + (25, 229), + (229, 230), + (32, 26), + (26, 227), + (227, 32), + (231, 24), + (24, 230), + (230, 231), + (232, 23), + (23, 231), + (231, 232), + (233, 27), + (27, 232), + (232, 233), + (234, 113), + (113, 233), + (233, 234), + (245, 190), + (190, 244), + (244, 245), + (190, 222), + (222, 191), + (191, 190), + (223, 29), + (29, 222), + (222, 223), + (224, 28), + (28, 223), + (223, 224), + (225, 30), + (30, 224), + (224, 225), + (226, 31), + (31, 225), + (225, 226), + (114, 248), + (248, 226), + (226, 114), + (100, 61), + (61, 241), + (241, 100), + (214, 148), + (148, 216), + (216, 214), + (61, 21), + (21, 167), + (167, 61), + (193, 188), + (188, 214), + (214, 193), + (244, 113), + (113, 245), + (245, 244), + (245, 234), + (234, 246), + (246, 245), + (246, 129), + (129, 189), + (189, 246), + (189, 115), + (115, 175), + (175, 189), + (135, 132), + (132, 221), + (221, 135), + (175, 218), + (218, 237), + (237, 175), + (237, 199), + (199, 135), + (135, 237), + (216, 178), + (178, 59), + (59, 216), + (157, 144), + (144, 125), + (125, 157), + (26, 111), + (111, 8), + (8, 26), + (32, 229), + (229, 26), + (26, 32), + (265, 357), + (357, 369), + (369, 265), + (1, 12), + (12, 268), + (268, 1), + (452, 453), + (453, 350), + (350, 452), + (268, 303), + (303, 270), + (270, 268), + (351, 358), + (358, 278), + (278, 351), + (351, 453), + (453, 358), + (358, 351), + (300, 334), + (334, 298), + (298, 300), + (397, 176), + (176, 378), + (378, 397), + (281, 348), + (348, 331), + (331, 281), + (270, 304), + (304, 271), + (271, 270), + (152, 10), + (10, 338), + (338, 152), + (345, 279), + (279, 361), + (361, 345), + (425, 419), + (419, 432), + (432, 425), + (271, 305), + (305, 410), + (410, 271), + (273, 311), + (311, 408), + (408, 273), + (323, 271), + (271, 411), + (411, 323), + (450, 451), + (451, 348), + (348, 450), + (433, 423), + (423, 435), + (435, 433), + (19, 314), + (314, 18), + (18, 19), + (292, 307), + (307, 376), + (376, 292), + (260, 388), + (388, 261), + (261, 260), + (425, 336), + (336, 419), + (419, 425), + (435, 365), + (365, 417), + (417, 435), + (392, 424), + (424, 328), + (328, 392), + (302, 252), + (252, 299), + (299, 302), + (276, 282), + (282, 5), + (5, 276), + (255, 374), + (374, 254), + (254, 255), + (376, 308), + (308, 322), + (322, 376), + (281, 426), + (426, 412), + (412, 281), + (201, 422), + (422, 19), + (19, 201), + (336, 322), + (322, 407), + (407, 336), + (322, 321), + (321, 406), + (406, 322), + (315, 316), + (316, 18), + (18, 315), + (424, 427), + (427, 267), + (267, 424), + (397, 378), + (378, 370), + (370, 397), + (271, 323), + (323, 270), + (270, 271), + (414, 418), + (418, 465), + (465, 414), + (386, 387), + (387, 259), + (259, 386), + (249, 457), + (457, 420), + (420, 249), + (299, 285), + (285, 334), + (334, 299), + (169, 418), + (418, 9), + (9, 169), + (449, 347), + (347, 262), + (262, 449), + (418, 414), + (414, 286), + (286, 418), + (327, 328), + (328, 329), + (329, 327), + (278, 356), + (356, 330), + (330, 278), + (310, 393), + (393, 439), + (439, 310), + (382, 383), + (383, 257), + (257, 382), + (280, 430), + (430, 361), + (361, 280), + (366, 365), + (365, 380), + (380, 366), + (356, 278), + (278, 438), + (438, 356), + (283, 444), + (444, 284), + (284, 283), + (282, 276), + (276, 364), + (364, 282), + (396, 432), + (432, 370), + (370, 396), + (300, 298), + (298, 338), + (338, 300), + (336, 274), + (274, 322), + (322, 336), + (349, 451), + (451, 350), + (350, 349), + (360, 447), + (447, 468), + (468, 360), + (284, 294), + (294, 283), + (283, 284), + (251, 459), + (459, 463), + (463, 251), + (301, 277), + (277, 384), + (384, 301), + (293, 309), + (309, 326), + (326, 293), + (284, 277), + (277, 294), + (294, 284), + (265, 373), + (373, 448), + (448, 265), + (347, 353), + (353, 341), + (341, 347), + (355, 275), + (275, 20), + (20, 355), + (364, 457), + (457, 282), + (282, 364), + (427, 437), + (437, 426), + (426, 427), + (381, 382), + (382, 253), + (253, 381), + (268, 270), + (270, 394), + (394, 268), + (422, 201), + (201, 429), + (429, 422), + (372, 267), + (267, 330), + (330, 372), + (433, 288), + (288, 423), + (423, 433), + (291, 251), + (251, 329), + (329, 291), + (386, 259), + (259, 385), + (385, 386), + (447, 266), + (266, 343), + (343, 447), + (387, 388), + (388, 258), + (258, 387), + (423, 425), + (425, 431), + (431, 423), + (446, 343), + (343, 277), + (277, 446), + (423, 274), + (274, 425), + (425, 423), + (307, 293), + (293, 308), + (308, 307), + (353, 367), + (367, 346), + (346, 353), + (269, 272), + (272, 303), + (303, 269), + (359, 424), + (424, 372), + (372, 359), + (328, 295), + (295, 461), + (461, 328), + (332, 280), + (280, 295), + (295, 332), + (304, 272), + (272, 305), + (305, 304), + (437, 433), + (433, 428), + (428, 437), + (305, 273), + (273, 409), + (409, 305), + (396, 395), + (395, 432), + (432, 396), + (379, 396), + (396, 401), + (401, 379), + (297, 335), + (335, 300), + (300, 297), + (7, 352), + (352, 169), + (169, 7), + (377, 353), + (353, 412), + (412, 377), + (308, 326), + (326, 321), + (321, 308), + (286, 296), + (296, 337), + (337, 286), + (321, 320), + (320, 405), + (405, 321), + (330, 331), + (331, 350), + (350, 330), + (335, 294), + (294, 334), + (334, 335), + (367, 324), + (324, 448), + (448, 367), + (317, 16), + (16, 316), + (316, 317), + (332, 359), + (359, 280), + (280, 332), + (318, 15), + (15, 317), + (317, 318), + (9, 286), + (286, 10), + (10, 9), + (278, 330), + (330, 351), + (351, 278), + (254, 375), + (375, 253), + (253, 254), + (320, 319), + (319, 404), + (404, 320), + (352, 7), + (7, 420), + (420, 352), + (325, 319), + (319, 326), + (326, 325), + (398, 368), + (368, 366), + (366, 398), + (289, 436), + (436, 398), + (398, 289), + (279, 345), + (345, 440), + (440, 279), + (311, 273), + (273, 312), + (312, 311), + (249, 196), + (196, 282), + (282, 249), + (376, 274), + (274, 292), + (292, 376), + (176, 397), + (397, 200), + (200, 176), + (313, 312), + (312, 269), + (269, 313), + (277, 284), + (284, 446), + (446, 277), + (391, 374), + (374, 340), + (340, 391), + (296, 283), + (283, 297), + (297, 296), + (449, 450), + (450, 347), + (347, 449), + (357, 265), + (265, 455), + (455, 357), + (338, 337), + (337, 300), + (300, 338), + (338, 339), + (339, 152), + (152, 338), + (295, 279), + (279, 456), + (456, 295), + (309, 293), + (293, 416), + (416, 309), + (430, 359), + (359, 356), + (356, 430), + (266, 341), + (341, 373), + (373, 266), + (353, 347), + (347, 281), + (281, 353), + (296, 443), + (443, 283), + (283, 296), + (355, 20), + (20, 371), + (371, 355), + (286, 442), + (442, 296), + (296, 286), + (196, 249), + (249, 198), + (198, 196), + (458, 441), + (441, 275), + (275, 458), + (302, 301), + (301, 369), + (369, 302), + (418, 352), + (352, 466), + (466, 418), + (252, 302), + (302, 390), + (390, 252), + (395, 396), + (396, 380), + (380, 395), + (400, 413), + (413, 420), + (420, 400), + (411, 437), + (437, 323), + (323, 411), + (327, 3), + (3, 394), + (394, 327), + (355, 371), + (371, 462), + (462, 355), + (394, 165), + (165, 268), + (268, 394), + (269, 303), + (303, 13), + (13, 269), + (313, 269), + (269, 14), + (14, 313), + (299, 294), + (294, 302), + (302, 299), + (266, 447), + (447, 341), + (341, 266), + (281, 331), + (331, 426), + (426, 281), + (323, 427), + (427, 392), + (392, 323), + (421, 430), + (430, 438), + (438, 421), + (394, 392), + (392, 327), + (327, 394), + (345, 441), + (441, 439), + (439, 345), + (459, 460), + (460, 462), + (462, 459), + (365, 435), + (435, 395), + (395, 365), + (429, 397), + (397, 263), + (263, 429), + (275, 355), + (355, 458), + (458, 275), + (318, 317), + (317, 403), + (403, 318), + (317, 316), + (316, 404), + (404, 317), + (316, 315), + (315, 405), + (405, 316), + (315, 314), + (314, 406), + (406, 315), + (314, 422), + (422, 407), + (407, 314), + (324, 367), + (367, 362), + (362, 324), + (293, 307), + (307, 408), + (408, 293), + (307, 292), + (292, 409), + (409, 307), + (292, 288), + (288, 410), + (410, 292), + (288, 433), + (433, 411), + (411, 288), + (428, 435), + (435, 412), + (412, 428), + (373, 265), + (265, 384), + (384, 373), + (460, 310), + (310, 458), + (458, 460), + (367, 353), + (353, 402), + (402, 367), + (2, 275), + (275, 5), + (5, 2), + (419, 422), + (422, 263), + (263, 419), + (332, 295), + (295, 359), + (359, 332), + (436, 434), + (434, 368), + (368, 436), + (393, 290), + (290, 440), + (440, 393), + (329, 463), + (463, 327), + (327, 329), + (95, 3), + (3, 371), + (371, 95), + (290, 306), + (306, 456), + (456, 290), + (340, 255), + (255, 449), + (449, 340), + (360, 256), + (256, 447), + (447, 360), + (255, 254), + (254, 450), + (450, 255), + (254, 253), + (253, 451), + (451, 254), + (253, 257), + (257, 452), + (452, 253), + (257, 342), + (342, 453), + (453, 257), + (415, 414), + (414, 464), + (464, 415), + (287, 442), + (442, 415), + (415, 287), + (287, 259), + (259, 442), + (442, 287), + (259, 258), + (258, 443), + (443, 259), + (258, 260), + (260, 444), + (444, 258), + (260, 261), + (261, 445), + (445, 260), + (261, 468), + (468, 446), + (446, 261), + (310, 460), + (460, 251), + (251, 310), + (306, 290), + (290, 291), + (291, 306), + (306, 291), + (291, 461), + (461, 306), + (402, 377), + (377, 436), + (436, 402), + (310, 251), + (251, 393), + (393, 310), + (377, 412), + (412, 434), + (434, 377), + (454, 342), + (342, 465), + (465, 454), + (358, 454), + (454, 466), + (466, 358), + (344, 358), + (358, 413), + (413, 344), + (438, 344), + (344, 400), + (400, 438), + (345, 361), + (361, 441), + (441, 345), + (421, 438), + (438, 457), + (457, 421), + (361, 421), + (421, 364), + (364, 361), + (362, 402), + (402, 289), + (289, 362), + (266, 373), + (373, 354), + (354, 266), + (391, 340), + (340, 250), + (250, 391), + (340, 449), + (449, 256), + (256, 340), + ) + + FACEMESH_TESSELATION = ( + (474, 474), + (475, 476), + (476, 477), + (477, 478), + (478, 475), + (469, 469), + (470, 471), + (471, 472), + (472, 473), + (473, 470), + *FACEMESH_TESSELATION_NO_IRIS, + ) + + +SKELETONS_BY_EDGE_COUNT: dict[int, Edges] = {} +SKELETONS_BY_VERTEX_COUNT: dict[int, Edges] = {} + +for skeleton in Skeleton: + SKELETONS_BY_EDGE_COUNT[len(skeleton.value)] = skeleton.value + + unique_vertices = {vertex for edge in skeleton.value for vertex in edge} + SKELETONS_BY_VERTEX_COUNT[len(unique_vertices)] = skeleton.value diff --git a/src/supervision/keypoint/__init__.py b/src/supervision/keypoint/__init__.py new file mode 100644 index 0000000..7bda3ed --- /dev/null +++ b/src/supervision/keypoint/__init__.py @@ -0,0 +1,13 @@ +from supervision.utils.internal import warn_deprecated + +warn_deprecated( + "The 'supervision.keypoint' module is deprecated in `0.27.0` and will be removed " + "in `0.31.0`. Please use 'supervision.key_points' instead." +) + +from supervision.key_points.annotators import ( + EdgeAnnotator, + VertexAnnotator, + VertexLabelAnnotator, +) +from supervision.key_points.core import KeyPoints diff --git a/src/supervision/keypoint/annotators.py b/src/supervision/keypoint/annotators.py new file mode 100644 index 0000000..1bb0a3a --- /dev/null +++ b/src/supervision/keypoint/annotators.py @@ -0,0 +1,13 @@ +from supervision.utils.internal import warn_deprecated + +warn_deprecated( + "The 'supervision.keypoint' module is deprecated in `0.27.0` and will be removed " + "in `0.31.0`. Please use 'supervision.key_points' instead." +) + +from supervision.key_points.annotators import ( # noqa: E402, F401 + BaseKeyPointAnnotator, + EdgeAnnotator, + VertexAnnotator, + VertexLabelAnnotator, +) diff --git a/src/supervision/keypoint/core.py b/src/supervision/keypoint/core.py new file mode 100644 index 0000000..cc01155 --- /dev/null +++ b/src/supervision/keypoint/core.py @@ -0,0 +1,8 @@ +from supervision.utils.internal import warn_deprecated + +warn_deprecated( + "The 'supervision.keypoint' module is deprecated in `0.27.0` and will be removed " + "in `0.31.0`. Please use 'supervision.key_points' instead." +) + +from supervision.key_points.core import KeyPoints # noqa: E402, F401 diff --git a/src/supervision/metrics/__init__.py b/src/supervision/metrics/__init__.py new file mode 100644 index 0000000..e1cba4c --- /dev/null +++ b/src/supervision/metrics/__init__.py @@ -0,0 +1,40 @@ +from supervision.metrics.core import ( + AveragingMethod, + Metric, + MetricTarget, +) +from supervision.metrics.f1_score import F1Score, F1ScoreResult +from supervision.metrics.mean_average_precision import ( + MeanAveragePrecision, + MeanAveragePrecisionResult, +) +from supervision.metrics.mean_average_recall import ( + MeanAverageRecall, + MeanAverageRecallResult, +) +from supervision.metrics.precision import Precision, PrecisionResult +from supervision.metrics.recall import Recall, RecallResult +from supervision.metrics.utils.object_size import ( + ObjectSizeCategory, + get_detection_size_category, + get_object_size_category, +) + +__all__ = [ + "AveragingMethod", + "F1Score", + "F1ScoreResult", + "MeanAveragePrecision", + "MeanAveragePrecisionResult", + "MeanAverageRecall", + "MeanAverageRecallResult", + "Metric", + "MetricTarget", + "ObjectSizeCategory", + "Precision", + "PrecisionResult", + "Recall", + "RecallResult", + "get_detection_size_category", + "get_object_size_category", +] diff --git a/src/supervision/metrics/core.py b/src/supervision/metrics/core.py new file mode 100644 index 0000000..347b61d --- /dev/null +++ b/src/supervision/metrics/core.py @@ -0,0 +1,74 @@ +from __future__ import annotations + +from abc import ABC, abstractmethod +from enum import Enum +from typing import Any, Generic, TypeVar + +R = TypeVar("R") + + +class Metric(ABC, Generic[R]): + """ + The base class for all supervision metrics. + """ + + @abstractmethod + def update(self, *args: Any, **kwargs: Any) -> Metric[R]: + """ + Add data to the metric, without computing the result. + Return the metric itself to allow method chaining. + """ + raise NotImplementedError + + @abstractmethod + def reset(self) -> None: + """ + Reset internal metric state. + """ + raise NotImplementedError + + @abstractmethod + def compute(self, *args: Any, **kwargs: Any) -> R: + """ + Compute the metric from the internal state and return the result. + """ + raise NotImplementedError + + +class MetricTarget(Enum): + """ + Specifies what type of detection is used to compute the metric. + + Attributes: + BOXES: xyxy bounding boxes + MASKS: Binary masks + ORIENTED_BOUNDING_BOXES: Oriented bounding boxes (OBB) + """ + + BOXES = "boxes" + MASKS = "masks" + ORIENTED_BOUNDING_BOXES = "obb" + + +class AveragingMethod(Enum): + """ + Defines different ways of averaging the metric results. + + Suppose, before returning the final result, a metric is computed for each class. + How do you combine those to get the final number? + + Attributes: + MACRO: Calculate the metric for each class and average the results. The simplest + averaging method, but it does not take class imbalance into account. + MICRO: Calculate the metric globally by counting the total true positives, false + positives, and false negatives. Micro averaging is useful when you want to + give more importance to classes with more samples. It's also more + appropriate if you have an imbalance in the number of instances per class. + WEIGHTED: Calculate the metric for each class and average the results, weighted + by the number of true instances of each class. Use weighted averaging if + you want to take class imbalance into account. + """ + + MACRO = "macro" + MICRO = "micro" + WEIGHTED = "weighted" diff --git a/src/supervision/metrics/detection.py b/src/supervision/metrics/detection.py new file mode 100644 index 0000000..390e7d9 --- /dev/null +++ b/src/supervision/metrics/detection.py @@ -0,0 +1,1632 @@ +from __future__ import annotations + +import warnings +from collections.abc import Callable +from dataclasses import dataclass +from pathlib import Path +from typing import TYPE_CHECKING, Any, cast + +import numpy as np +import numpy.typing as npt +from deprecate import ( # type: ignore[import-untyped,unused-ignore] + TargetMode, + deprecated, + deprecated_class, + void, +) + +from supervision.config import ORIENTED_BOX_COORDINATES +from supervision.dataset.core import DetectionDataset +from supervision.detection.core import Detections +from supervision.detection.utils.iou_and_nms import ( + box_iou_batch, + oriented_box_iou_batch, +) +from supervision.metrics.core import MetricTarget +from supervision.metrics.utils.matching import _greedy_match + +if TYPE_CHECKING: + from matplotlib.figure import Figure + + +def _assert_supported_target(metric_target: MetricTarget) -> None: + if metric_target == MetricTarget.MASKS: + raise ValueError( + "MetricTarget.MASKS is not currently supported for ConfusionMatrix." + ) + + +def _validated_class_ids( + values: npt.NDArray[np.float32], + num_classes: int, + role: str, +) -> npt.NDArray[np.int64]: + """Return class ids that are safe to use as confusion-matrix indexes.""" + if values.size == 0: + return np.asarray(values, dtype=np.int64) + + finite = np.isfinite(values) + integral = values == np.floor(values) + if not np.all(finite & integral): + raise ValueError(f"{role} class ids must be finite integers.") + + class_ids = values.astype(np.int64) + invalid = (class_ids < 0) | (class_ids >= num_classes) + if np.any(invalid): + invalid_values = np.unique(class_ids[invalid]).tolist() + raise ValueError( + f"{role} class ids must be in [0, {num_classes - 1}], got {invalid_values}." + ) + return class_ids + + +def detections_to_tensor( + detections: Detections, + with_confidence: bool = False, + metric_target: MetricTarget = MetricTarget.BOXES, +) -> npt.NDArray[np.float32]: + """ + Convert Supervision Detections to a numpy tensor for metric computation. + + Args: + detections: Detections/Targets in the format of sv.Detections. + with_confidence: Whether to include confidence as the last column. + metric_target: The type of detection data to use. + Supports `MetricTarget.BOXES` and + `MetricTarget.ORIENTED_BOUNDING_BOXES`. + + Returns: + Detections as a float32 numpy array. Shape depends on `metric_target` + and `with_confidence`: + + | `metric_target` | `with_confidence` | shape | + |----------------------------------------|-------------------|-----------| + | `MetricTarget.BOXES` | `False` | `(N, 5)` | + | `MetricTarget.BOXES` | `True` | `(N, 6)` | + | `MetricTarget.ORIENTED_BOUNDING_BOXES` | `False` | `(N, 9)` | + | `MetricTarget.ORIENTED_BOUNDING_BOXES` | `True` | `(N, 10)` | + + Column layout: + + - `BOXES`: ``[x_min, y_min, x_max, y_max, class_id [, confidence]]`` + - `ORIENTED_BOUNDING_BOXES`: + ``[x1, y1, x2, y2, x3, y3, x4, y4, class_id [, confidence]]`` + + Raises: + ValueError: If `metric_target` is `MetricTarget.MASKS`. + ValueError: If `detections.class_id` is `None`. + ValueError: If `with_confidence=True` and `detections.confidence` is `None`. + ValueError: If `metric_target` is `MetricTarget.ORIENTED_BOUNDING_BOXES` + and `detections.data` does not contain `ORIENTED_BOX_COORDINATES`, + or if the stored array does not have exactly `N * 8` elements. + + Examples: + ```pycon + >>> import numpy as np + >>> import supervision as sv + >>> from supervision.metrics.core import MetricTarget + >>> from supervision.config import ORIENTED_BOX_COORDINATES + >>> detections = sv.Detections( + ... xyxy=np.array([[0, 0, 10, 10]], dtype=np.float32), + ... class_id=np.array([0]), + ... confidence=np.array([0.9]), + ... ) + >>> tensor = detections_to_tensor(detections, with_confidence=True) + >>> tensor.shape + (1, 6) + >>> obb_coords = np.array([[0, 0, 10, 0, 10, 10, 0, 10]], dtype=np.float32) + >>> det_obb = sv.Detections( + ... xyxy=np.array([[0, 0, 10, 10]], dtype=np.float32), + ... class_id=np.array([0]), + ... data={ORIENTED_BOX_COORDINATES: obb_coords}, + ... ) + >>> tensor_obb = detections_to_tensor( + ... det_obb, metric_target=MetricTarget.ORIENTED_BOUNDING_BOXES + ... ) + >>> tensor_obb.shape + (1, 9) + + ``` + """ + _assert_supported_target(metric_target) + + if detections.class_id is None: + raise ValueError( + "ConfusionMatrix can only be calculated for Detections with class_id" + ) + + box_data: npt.NDArray[np.float32] + if metric_target == MetricTarget.ORIENTED_BOUNDING_BOXES: + obb = detections.data.get(ORIENTED_BOX_COORDINATES) + if obb is None: + if len(detections) > 0: + raise ValueError( + "ORIENTED_BOUNDING_BOXES requested, but " + f"{ORIENTED_BOX_COORDINATES} is missing from detections.data" + ) + box_data = np.empty((0, 8), dtype=np.float32) + else: + obb_arr = np.asarray(obb, dtype=np.float32) + # Normalize (N, 4, 2) โ†’ (N, 8) as produced by from_ultralytics. + if obb_arr.ndim == 3 and obb_arr.shape[1:] == (4, 2): + obb_arr = obb_arr.reshape(-1, 8) + if obb_arr.size != len(detections) * 8: + raise ValueError( + f"Expected {ORIENTED_BOX_COORDINATES} to contain " + f"{len(detections) * 8} elements " + f"(N={len(detections)} detections x 8 coordinates), " + f"but got {obb_arr.size}. " + "Each OBB must be stored as [x1, y1, x2, y2, x3, y3, x4, y4]." + ) + box_data = obb_arr.reshape(-1, 8) + else: + box_data = np.asarray(detections.xyxy, dtype=np.float32) + + arrays_to_concat = [ + box_data, + np.expand_dims(detections.class_id.astype(np.float32), 1), + ] + + if with_confidence: + if detections.confidence is None: + raise ValueError( + "ConfusionMatrix can only be calculated for Detections with confidence" + ) + arrays_to_concat.append(np.expand_dims(detections.confidence, 1)) + + result: npt.NDArray[np.float32] = np.concatenate(arrays_to_concat, axis=1) + return result + + +def _validate_input_tensors( + predictions: list[npt.NDArray[np.float32]], + targets: list[npt.NDArray[np.float32]], + metric_target: MetricTarget = MetricTarget.BOXES, +) -> None: + """ + Checks for shape consistency of input tensors. + """ + if len(predictions) != len(targets): + raise ValueError( + f"Number of predictions ({len(predictions)}) and" + f"targets ({len(targets)}) must be equal." + ) + if len(predictions) > 0: + if not isinstance(predictions[0], np.ndarray) or not isinstance( + targets[0], np.ndarray + ): + raise ValueError( + "Predictions and targets must be lists of numpy arrays. " + f"Got {type(predictions[0])} and {type(targets[0])} instead." + ) + + expected_pred_cols = ( + 10 if metric_target == MetricTarget.ORIENTED_BOUNDING_BOXES else 6 + ) + expected_target_cols = ( + 9 if metric_target == MetricTarget.ORIENTED_BOUNDING_BOXES else 5 + ) + + if predictions[0].shape[1] != expected_pred_cols: + raise ValueError( + f"Predictions must have shape (N, {expected_pred_cols}). " + f"Got {predictions[0].shape} instead." + ) + if targets[0].shape[1] != expected_target_cols: + raise ValueError( + f"Targets must have shape (N, {expected_target_cols}). " + f"Got {targets[0].shape} instead." + ) + + +def _split_detections_by_outcome( + predictions: Detections, + targets: Detections, + conf_threshold: float, + iou_threshold: float, + metric_target: MetricTarget = MetricTarget.BOXES, +) -> tuple[Detections, Detections, Detections]: + """ + Split detections into true positives, false positives, and false negatives. + + Matching follows the same attribution logic as + ``ConfusionMatrix.evaluate_detection_batch``: + - matches are computed globally across classes + - same-class matches are prioritized + - higher-IoU matches are preferred + - each prediction and target can be matched at most once + + Cross-class spatial matches are treated as: + - false positives for the prediction + - false negatives for the target + + Args: + predictions: Predicted detections for a single image. + targets: Ground-truth detections for a single image. + conf_threshold: Confidence threshold; predictions below this are excluded. + iou_threshold: IoU threshold; candidate pairs below this are not matched. + metric_target: Coordinate representation to use for IoU computation. + Use ``MetricTarget.ORIENTED_BOUNDING_BOXES`` for rotated-box datasets. + + Returns: + A 3-tuple ``(true_positives, false_positives, false_negatives)`` where + each element is a ``Detections`` instance sliced from the input arrays. + """ + + if predictions.class_id is None: + raise ValueError("Predictions must contain class_id values.") + + if targets.class_id is None: + raise ValueError("Targets must contain class_id values.") + + target_class_ids = targets.class_id + + if predictions.confidence is None: + filtered_predictions = predictions + else: + prediction_confidence = np.asarray(predictions.confidence, dtype=np.float32) + filtered_predictions = predictions.select( + prediction_confidence >= conf_threshold + ) + + filtered_prediction_class_ids = filtered_predictions.class_id + if filtered_prediction_class_ids is None: + raise ValueError("Predictions must contain class_id values.") + + prediction_count = len(filtered_predictions) + target_count = len(targets) + + tp_indices: list[int] = [] + fp_indices: list[int] = [] + fn_indices: list[int] = [] + + if prediction_count == 0: + fn_indices = list(range(target_count)) + return ( + filtered_predictions.select(tp_indices), + filtered_predictions.select(fp_indices), + targets.select(fn_indices), + ) + + if target_count == 0: + fp_indices = list(range(prediction_count)) + return ( + filtered_predictions.select(tp_indices), + filtered_predictions.select(fp_indices), + targets.select(fn_indices), + ) + + # IoU computation mirrors evaluate_detection_batch โ€” keep in sync if either changes. + if metric_target == MetricTarget.ORIENTED_BOUNDING_BOXES: + iou_matrix = oriented_box_iou_batch( + boxes_true=np.asarray( + targets.data[ORIENTED_BOX_COORDINATES], dtype=np.float32 + ).reshape(len(targets), 8), + boxes_detection=np.asarray( + filtered_predictions.data[ORIENTED_BOX_COORDINATES], dtype=np.float32 + ).reshape(len(filtered_predictions), 8), + ) + else: + iou_matrix = box_iou_batch( + boxes_true=targets.xyxy, + boxes_detection=filtered_predictions.xyxy, + ) + + target_candidate_indices, prediction_candidate_indices = np.where( + iou_matrix > iou_threshold + ) + + matched_predictions: npt.NDArray[np.bool_] = np.zeros(prediction_count, dtype=bool) + matched_targets: npt.NDArray[np.bool_] = np.zeros(target_count, dtype=bool) + + cross_class_prediction_indices: list[int] = [] + cross_class_target_indices: list[int] = [] + + if len(target_candidate_indices) > 0: + candidate_ious = iou_matrix[ + target_candidate_indices, + prediction_candidate_indices, + ] + + same_class_candidates = ( + target_class_ids[target_candidate_indices] + == filtered_prediction_class_ids[prediction_candidate_indices] + ) + + candidate_order = np.lexsort( + ( + -candidate_ious, + ~same_class_candidates, + ) + ) + + for candidate_index in candidate_order: + target_index = int(target_candidate_indices[candidate_index]) + prediction_index = int(prediction_candidate_indices[candidate_index]) + + if matched_predictions[prediction_index] or matched_targets[target_index]: + continue + + matched_predictions[prediction_index] = True + matched_targets[target_index] = True + + prediction_class = filtered_prediction_class_ids[prediction_index] + target_class = target_class_ids[target_index] + + if prediction_class == target_class: + tp_indices.append(prediction_index) + else: + cross_class_prediction_indices.append(prediction_index) + cross_class_target_indices.append(target_index) + + fp_indices.extend(np.flatnonzero(~matched_predictions).tolist()) + fn_indices.extend(np.flatnonzero(~matched_targets).tolist()) + + fp_indices.extend(cross_class_prediction_indices) + fn_indices.extend(cross_class_target_indices) + + return ( + filtered_predictions.select(tp_indices), + filtered_predictions.select(fp_indices), + targets.select(fn_indices), + ) + + +def _build_error_labels( + detections: Detections, + class_names: list[str] | None, +) -> list[str]: + """Build per-detection label strings for annotation panels. + + Produces labels like ``"cat 0.95"`` (class name + confidence when available) + or numeric class-id strings when ``class_names`` is ``None``. + + Args: + detections: Detections whose labels to build. + class_names: Optional list mapping class integer ids to name strings. + + Returns: + List of label strings, one per detection. Returns empty strings when + ``detections.class_id`` is ``None``. + """ + if detections.class_id is None: + return [""] * len(detections) + + labels: list[str] = [] + for index, class_id in enumerate(detections.class_id): + if class_names is not None and 0 <= int(class_id) < len(class_names): + class_label = class_names[int(class_id)] + else: + class_label = str(int(class_id)) + + confidence = "" + if detections.confidence is not None: + confidence = f" {detections.confidence[index]:.2f}" + + labels.append(f"{class_label}{confidence}") + + return labels + + +def _get_annotation_parameters( + scene: npt.NDArray[np.uint8], +) -> tuple[int, float, int, int, int]: + """Compute adaptive annotation parameters scaled to the panel size. + + Args: + scene: The image panel for which to compute parameters. + + Returns: + A 5-tuple ``(box_thickness, text_scale, text_thickness, text_padding, + font_size)`` where all values are ``int`` except ``text_scale`` (``float``). + """ + height, width = scene.shape[:2] + panel_size = max(min(height, width), 1) + grid_factor = 2 + + font_size = max(18, round(panel_size / (26 * grid_factor))) + box_thickness = max(2, round(font_size / 5)) + text_scale = float(max(1.0, font_size / 20.0)) + text_thickness = max(1, round(font_size / 15.0)) + text_padding = max(6, round(font_size / 3)) + + return box_thickness, text_scale, text_thickness, text_padding, font_size + + +def _annotate_detection_panel( + scene: npt.NDArray[np.uint8], + detections: Detections, + title: str, + class_names: list[str] | None, + annotation_parameters: tuple[int, float, int, int, int], +) -> npt.NDArray[np.uint8]: + """Render detections onto a copy of ``scene`` with a title overlay. + + Args: + scene: Source image panel (not mutated). + detections: Detections to annotate on the panel. + title: Text label rendered in the top-left corner of the panel. + class_names: Optional list mapping class integer ids to name strings. + annotation_parameters: Pre-computed parameters from + ``_get_annotation_parameters``. + + Returns: + Annotated copy of ``scene`` as a ``np.uint8`` array. + """ + import cv2 # lazy: only needed when save_directory_path is set + + from supervision.annotators.core import BoxAnnotator, LabelAnnotator + from supervision.annotators.utils import ColorLookup + from supervision.draw.color import ColorPalette + + panel = scene.copy() + + box_thickness, text_scale, text_thickness, text_padding, font_size = ( + annotation_parameters + ) + + if len(detections) > 0: + box_annotator = BoxAnnotator( + color=ColorPalette.DEFAULT, + color_lookup=ColorLookup.CLASS, + thickness=box_thickness, + ) + label_annotator = LabelAnnotator( + color=ColorPalette.DEFAULT, + color_lookup=ColorLookup.CLASS, + text_scale=text_scale, + text_thickness=text_thickness, + text_padding=text_padding, + ) + labels = _build_error_labels(detections, class_names) + panel = box_annotator.annotate(panel, detections) + panel = cast( + npt.NDArray[np.uint8], + label_annotator.annotate(cast(Any, panel), detections, labels=labels), + ) + + title_scale = float(max(1.0, font_size / 18.0)) + title_thickness = max(2, round(font_size / 8)) + panel_height, panel_width = panel.shape[:2] + (title_width, title_height), title_baseline = cv2.getTextSize( + title, + cv2.FONT_HERSHEY_SIMPLEX, + title_scale, + title_thickness, + ) + title_x = max(0, min(text_padding, panel_width - title_width - 1)) + title_y = max(title_height + text_padding, 0) + title_y = min(title_y, max(panel_height - title_baseline - 1, 0)) + + cv2.putText( + panel, + title, + (title_x, title_y), + cv2.FONT_HERSHEY_SIMPLEX, + title_scale, + (240, 240, 240), + title_thickness, + cv2.LINE_AA, + ) + panel_array: npt.NDArray[np.uint8] = panel + return panel_array + + +def _save_detection_validation_visualization( + scene: npt.NDArray[np.uint8], + predictions: Detections, + targets: Detections, + save_path: Path, + conf_threshold: float, + iou_threshold: float, + class_names: list[str] | None, + metric_target: MetricTarget = MetricTarget.BOXES, +) -> None: + """Build and save a 2x2 GT/TP/FP/FN mosaic for one image. + + Splits ``predictions`` into true-positive, false-positive, and false-negative + groups using the same matching logic as + ``ConfusionMatrix.evaluate_detection_batch``, renders four annotation panels, + concatenates them into a 2x2 grid, and writes the result to ``save_path``. + + A ``UserWarning`` is emitted if ``cv2.imwrite`` fails (e.g. unsupported + extension or permission error); the benchmark loop continues regardless. + + Args: + scene: The original image for this dataset entry. + predictions: Raw model predictions for ``scene``. + targets: Ground-truth annotations for ``scene``. + save_path: Destination file path for the mosaic image. + conf_threshold: Confidence threshold forwarded to + ``_split_detections_by_outcome``. + iou_threshold: IoU threshold forwarded to ``_split_detections_by_outcome``. + class_names: Optional list mapping class integer ids to name strings. + metric_target: Coordinate representation used for IoU matching. + """ + import cv2 # lazy: only needed when save_directory_path is set + + tp_predictions, fp_predictions, fn_targets = _split_detections_by_outcome( + predictions=predictions, + targets=targets, + conf_threshold=conf_threshold, + iou_threshold=iou_threshold, + metric_target=metric_target, + ) + + annotation_parameters = _get_annotation_parameters(scene) + + gt_panel = _annotate_detection_panel( + scene=scene, + detections=targets, + title="Ground Truth", + class_names=class_names, + annotation_parameters=annotation_parameters, + ) + tp_panel = _annotate_detection_panel( + scene=scene, + detections=tp_predictions, + title="True Positives", + class_names=class_names, + annotation_parameters=annotation_parameters, + ) + fp_panel = _annotate_detection_panel( + scene=scene, + detections=fp_predictions, + title="False Positives", + class_names=class_names, + annotation_parameters=annotation_parameters, + ) + fn_panel = _annotate_detection_panel( + scene=scene, + detections=fn_targets, + title="False Negatives", + class_names=class_names, + annotation_parameters=annotation_parameters, + ) + + top_row = np.concatenate((gt_panel, tp_panel), axis=1) + bottom_row = np.concatenate((fp_panel, fn_panel), axis=1) + result = np.concatenate((top_row, bottom_row), axis=0) + + panel_height = result.shape[0] // 2 + panel_width = result.shape[1] // 2 + divider_thickness = max(1, min(8, min(panel_height, panel_width) // 32)) + + cv2.rectangle( + result, + (0, 0), + (result.shape[1] - 1, result.shape[0] - 1), + (255, 255, 255), + thickness=divider_thickness, + ) + + center_x = result.shape[1] // 2 + center_y = result.shape[0] // 2 + cv2.line( + result, + (center_x, 0), + (center_x, result.shape[0] - 1), + (255, 255, 255), + divider_thickness, + ) + cv2.line( + result, + (0, center_y), + (result.shape[1] - 1, center_y), + (255, 255, 255), + divider_thickness, + ) + + write_success = cv2.imwrite(str(save_path), result) + if not write_success: + warnings.warn( + f"Failed to write validation image to '{save_path}'.", + UserWarning, + stacklevel=2, + ) + + +@deprecated( # type: ignore[untyped-decorator] + target=_validate_input_tensors, + deprecated_in="0.29.0", + remove_in="0.32.0", +) +def validate_input_tensors( + predictions: list[npt.NDArray[np.float32]], + targets: list[npt.NDArray[np.float32]], +) -> None: + void(predictions, targets) + + +@dataclass +class ConfusionMatrix: + """ + Confusion matrix for object detection tasks. + + Attributes: + matrix: An 2D `np.ndarray` of shape `(len(classes) + 1, len(classes) + 1)` + containing the number of `TP`, `FP`, `FN` and `TN` for each class. + classes: Model class names. + conf_threshold: Detection confidence threshold between `0` and `1`. + Detections with lower confidence will be excluded from the matrix. + iou_threshold: Detection IoU threshold between `0` and `1`. + Detections with lower IoU will be classified as `FP`. + metric_target: The type of detection data used for IoU computation. + Informational metadata set by `from_detections` and `from_tensors`. + Excluded from `__eq__` comparisons โ€” two `ConfusionMatrix` instances + with identical `matrix`, `classes`, `conf_threshold`, and + `iou_threshold` compare as equal regardless of `metric_target`. + """ + + matrix: npt.NDArray[np.int32] + classes: list[str] + conf_threshold: float + iou_threshold: float + metric_target: MetricTarget = MetricTarget.BOXES + + def __eq__(self, other: object) -> bool: + if not isinstance(other, ConfusionMatrix): + return NotImplemented + return ( + np.array_equal(self.matrix, other.matrix) + and self.classes == other.classes + and self.conf_threshold == other.conf_threshold + and self.iou_threshold == other.iou_threshold + ) + + __hash__ = None # type: ignore[assignment] + + @classmethod + def from_detections( + cls, + predictions: list[Detections], + targets: list[Detections], + classes: list[str], + conf_threshold: float = 0.3, + iou_threshold: float = 0.5, + metric_target: MetricTarget = MetricTarget.BOXES, + ) -> ConfusionMatrix: + """ + Calculate confusion matrix based on predicted and ground-truth detections. + + Args: + targets: Detections objects from ground-truth. + predictions: Detections objects predicted by the model. + classes: Model class names. + conf_threshold: Detection confidence threshold between `0` and `1`. + Detections with lower confidence will be excluded. + iou_threshold: Detection IoU threshold between `0` and `1`. + Detections with lower IoU will be classified as `FP`. + metric_target: The type of detection data to use. + Supports `MetricTarget.BOXES` (default) and + `MetricTarget.ORIENTED_BOUNDING_BOXES`. When using + `MetricTarget.ORIENTED_BOUNDING_BOXES`, each `Detections` + object must include OBB coordinates in + `detections.data[ORIENTED_BOX_COORDINATES]` as a float32 + array of shape `(N, 8)` (flat) or `(N, 4, 2)` (as stored by + `from_ultralytics`); both are normalised to `(N, 8)` internally. + `MetricTarget.MASKS` is not supported. + + Returns: + New instance of ConfusionMatrix. + + Examples: + ```pycon + >>> import numpy as np + >>> import supervision as sv + >>> targets = [ + ... sv.Detections( + ... xyxy=np.array([[0, 0, 10, 10], [50, 50, 60, 60]]), + ... class_id=np.array([0, 0]) + ... ) + ... ] + >>> predictions = [ + ... sv.Detections( + ... xyxy=np.array([[0, 0, 10, 10], [100, 100, 110, 110]]), + ... class_id=np.array([0, 0]), + ... confidence=np.array([0.9, 0.8]) + ... ) + ... ] + >>> confusion_matrix = sv.ConfusionMatrix.from_detections( + ... predictions=predictions, + ... targets=targets, + ... classes=['person'] + ... ) + >>> confusion_matrix.matrix + array([[1, 1], + [1, 0]], dtype=int32) + + ``` + """ + prediction_tensors = [] + target_tensors = [] + for prediction, target in zip(predictions, targets): + prediction_tensors.append( + detections_to_tensor( + prediction, with_confidence=True, metric_target=metric_target + ) + ) + target_tensors.append( + detections_to_tensor( + target, with_confidence=False, metric_target=metric_target + ) + ) + return cls.from_tensors( + predictions=prediction_tensors, + targets=target_tensors, + classes=classes, + conf_threshold=conf_threshold, + iou_threshold=iou_threshold, + metric_target=metric_target, + ) + + @classmethod + def from_tensors( + cls, + predictions: list[npt.NDArray[np.float32]], + targets: list[npt.NDArray[np.float32]], + classes: list[str], + conf_threshold: float = 0.3, + iou_threshold: float = 0.5, + metric_target: MetricTarget = MetricTarget.BOXES, + ) -> ConfusionMatrix: + """ + Calculate confusion matrix based on predicted and ground-truth detections. + + Args: + predictions: Each element of the list describes a single + image and has `shape = (M, 6)` or `shape = (M, 10)` depending on + `metric_target`. + If `MetricTarget.BOXES`, each row is in + `(x_min, y_min, x_max, y_max, class, conf)` format. + If `MetricTarget.ORIENTED_BOUNDING_BOXES`, each row is in + `(x1, y1, x2, y2, x3, y3, x4, y4, class, conf)` format. + targets: Each element of the list describes a single + image and has `shape = (N, 5)` or `shape = (N, 9)` depending on + `metric_target`. + If `MetricTarget.BOXES`, each row is in + `(x_min, y_min, x_max, y_max, class)` format. + If `MetricTarget.ORIENTED_BOUNDING_BOXES`, each row is in + `(x1, y1, x2, y2, x3, y3, x4, y4, class)` format. + classes: Model class names. + conf_threshold: Detection confidence threshold between `0` and `1`. + Detections with lower confidence will be excluded. + iou_threshold: Detection iou threshold between `0` and `1`. + Detections with lower iou will be classified as `FP`. + metric_target: The type of detection data to use. + Determines expected tensor shapes (see Args above for column + layouts). `MetricTarget.MASKS` is not supported. + + Returns: + New instance of ConfusionMatrix. + + Examples: + ```pycon + >>> import supervision as sv + >>> import numpy as np + >>> targets = [ + ... np.array([ + ... [0.0, 0.0, 3.0, 3.0, 0], + ... [2.0, 2.0, 5.0, 5.0, 0], + ... [6.0, 1.0, 8.0, 3.0, 1], + ... ]) + ... ] + >>> predictions = [ + ... np.array([ + ... [0.0, 0.0, 3.0, 3.0, 0, 0.9], + ... [0.1, 0.1, 3.0, 3.0, 0, 0.9], + ... [6.0, 1.0, 8.0, 3.0, 1, 0.8], + ... ]) + ... ] + >>> confusion_matrix = sv.ConfusionMatrix.from_tensors( + ... predictions=predictions, + ... targets=targets, + ... classes=['person', 'dog'] + ... ) + >>> confusion_matrix.matrix + array([[1, 0, 1], + [0, 1, 0], + [1, 0, 0]], dtype=int32) + + ``` + """ + _assert_supported_target(metric_target) + _validate_input_tensors(predictions, targets, metric_target=metric_target) + + num_classes = len(classes) + matrix: npt.NDArray[np.int32] = np.zeros( + (num_classes + 1, num_classes + 1), dtype=np.int32 + ) + for true_batch, detection_batch in zip(targets, predictions): + matrix += cls.evaluate_detection_batch( + predictions=detection_batch, + targets=true_batch, + num_classes=num_classes, + conf_threshold=conf_threshold, + iou_threshold=iou_threshold, + metric_target=metric_target, + ) + return cls( + matrix=matrix, + classes=classes, + conf_threshold=conf_threshold, + iou_threshold=iou_threshold, + metric_target=metric_target, + ) + + @staticmethod + def evaluate_detection_batch( + predictions: npt.NDArray[np.float32], + targets: npt.NDArray[np.float32], + num_classes: int, + conf_threshold: float, + iou_threshold: float, + metric_target: MetricTarget = MetricTarget.BOXES, + ) -> npt.NDArray[np.int32]: + """ + Calculate confusion matrix for a batch of detections for a single image. + + Args: + predictions: Batch prediction. Describes a single image and + has `shape = (M, 6)` or `shape = (M, 10)` depending on + `metric_target`. + If `MetricTarget.BOXES`, each row is in + `(x_min, y_min, x_max, y_max, class, conf)` format. + If `MetricTarget.ORIENTED_BOUNDING_BOXES`, each row is in + `(x1, y1, x2, y2, x3, y3, x4, y4, class, conf)` format. + targets: Batch target labels. Describes a single image and + has `shape = (N, 5)` or `shape = (N, 9)` depending on + `metric_target`. + If `MetricTarget.BOXES`, each row is in + `(x_min, y_min, x_max, y_max, class)` format. + If `MetricTarget.ORIENTED_BOUNDING_BOXES`, each row is in + `(x1, y1, x2, y2, x3, y3, x4, y4, class)` format. + num_classes: Number of classes. + conf_threshold: Detection confidence threshold between `0` and `1`. + Detections with lower confidence will be excluded. + iou_threshold: Detection iou threshold between `0` and `1`. + Detections with lower iou will be classified as `FP`. + metric_target: The type of detection data to use. + Determines IoU function (`box_iou_batch` vs + `oriented_box_iou_batch`) and coordinate column count. + `MetricTarget.MASKS` is not supported. + + Returns: + Confusion matrix based on a single image. + """ + _assert_supported_target(metric_target) + + expected_pred_cols = ( + 10 if metric_target == MetricTarget.ORIENTED_BOUNDING_BOXES else 6 + ) + expected_target_cols = ( + 9 if metric_target == MetricTarget.ORIENTED_BOUNDING_BOXES else 5 + ) + if predictions.ndim != 2 or predictions.shape[1] != expected_pred_cols: + raise ValueError( + f"Predictions must have shape (M, {expected_pred_cols}). " + f"Got {predictions.shape} instead." + ) + if targets.ndim != 2 or targets.shape[1] != expected_target_cols: + raise ValueError( + f"Targets must have shape (N, {expected_target_cols}). " + f"Got {targets.shape} instead." + ) + + result_matrix: npt.NDArray[np.int32] = np.zeros( + (num_classes + 1, num_classes + 1), dtype=np.int32 + ) + + # Filter predictions by confidence threshold + coords_dim = 8 if metric_target == MetricTarget.ORIENTED_BOUNDING_BOXES else 4 + class_id_idx = coords_dim + conf_idx = coords_dim + 1 + + confidence = predictions[:, conf_idx] + detection_batch_filtered = predictions[confidence >= conf_threshold] + + if len(detection_batch_filtered) == 0: + true_classes = _validated_class_ids( + targets[:, class_id_idx], num_classes, "Target" + ) + for gt_class in true_classes: + result_matrix[gt_class, num_classes] += 1 + return result_matrix + + if len(targets) == 0: + detection_classes = _validated_class_ids( + detection_batch_filtered[:, class_id_idx], num_classes, "Prediction" + ) + for det_class in detection_classes: + result_matrix[num_classes, det_class] += 1 + return result_matrix + + true_classes = _validated_class_ids( + targets[:, class_id_idx], num_classes, "Target" + ) + detection_classes = _validated_class_ids( + detection_batch_filtered[:, class_id_idx], num_classes, "Prediction" + ) + true_boxes = targets[:, :coords_dim] + detection_boxes = detection_batch_filtered[:, :coords_dim] + + # Calculate IoU matrix + if metric_target == MetricTarget.ORIENTED_BOUNDING_BOXES: + iou_batch = oriented_box_iou_batch( + boxes_true=true_boxes, boxes_detection=detection_boxes + ) + else: + iou_batch = box_iou_batch( + boxes_true=true_boxes, boxes_detection=detection_boxes + ) + + # Find all valid matches (IoU > threshold, regardless of class) + # Use vectorized operations to avoid nested Python loops + iou_mask = iou_batch > iou_threshold + gt_indices, det_indices = np.nonzero(iou_mask) + + # If no pairs exceed the IoU threshold, skip matching + if gt_indices.size == 0: + valid_matches = [] + else: + ious = iou_batch[gt_indices, det_indices] + gt_match_classes = true_classes[gt_indices] + det_match_classes = detection_classes[det_indices] + class_matches = gt_match_classes == det_match_classes + + # Sort matches by class match first (True before False), + # then by IoU descending. + # np.lexsort sorts by the last key first, in ascending order. + # We use ~class_matches so that True becomes 0 + # and False becomes 1 (True first), + # and -ious so that larger IoUs come first. + sort_indices = np.lexsort((-ious, ~class_matches)) + + # Build list of matches in the same format as before: + # (gt_idx, det_idx, iou, class_match) + valid_matches = [ + ( + int(gt_indices[idx]), + int(det_indices[idx]), + float(ious[idx]), + bool(class_matches[idx]), + ) + for idx in sort_indices + ] + # Greedily assign matches, ensuring each GT + # and detection is matched at most once + matched_gt_idx = set() + matched_det_idx = set() + + for gt_idx, det_idx, iou, class_match in valid_matches: + if gt_idx not in matched_gt_idx and det_idx not in matched_det_idx: + # Valid spatial match - record the class prediction + gt_class = true_classes[gt_idx] + det_class = detection_classes[det_idx] + + # This handles both correct classification (TP) and misclassification + result_matrix[gt_class, det_class] += 1 + matched_gt_idx.add(gt_idx) + matched_det_idx.add(det_idx) + + # Count unmatched ground truth as FN + for gt_idx, gt_class in enumerate(true_classes): + if gt_idx not in matched_gt_idx: + result_matrix[gt_class, num_classes] += 1 + + # Count unmatched detections as FP + for det_idx, det_class in enumerate(detection_classes): + if det_idx not in matched_det_idx: + result_matrix[num_classes, det_class] += 1 + + return result_matrix + + @staticmethod + def _drop_extra_matches( + matches: npt.NDArray[np.float32], + ) -> npt.NDArray[np.float32]: + """ + Deduplicate matches. If there are multiple matches for the same true or + predicted box, only the one with the highest IoU is kept. + """ + if matches.shape[0] > 0: + matches = matches[matches[:, 2].argsort()[::-1]] + matches = matches[np.unique(matches[:, 1], return_index=True)[1]] + matches = matches[matches[:, 2].argsort()[::-1]] + matches = matches[np.unique(matches[:, 0], return_index=True)[1]] + result: npt.NDArray[np.float32] = matches + return result + + @classmethod + def benchmark( + cls, + dataset: DetectionDataset, + callback: Callable[[npt.NDArray[np.uint8]], Detections], + conf_threshold: float = 0.3, + iou_threshold: float = 0.5, + metric_target: MetricTarget = MetricTarget.BOXES, + *, + save_directory_path: str | Path | None = None, + ) -> ConfusionMatrix: + """ + Calculate confusion matrix from dataset and callback function. + + Args: + dataset: Object detection dataset used for evaluation. + callback: Function that takes an image as input and returns a + Detections object. + conf_threshold: Detection confidence threshold between `0` and `1`. + Detections with lower confidence will be excluded. + iou_threshold: Detection IoU threshold between `0` and `1`. + Detections with lower IoU will be classified as `FP`. + save_directory_path: Optional directory where per-image validation + result grids are saved using the original image filenames. Images + are written directly to this directory (no subdirectory is added). + When ``None`` (default), no images are saved. + metric_target: The type of detection data to use. + Supports `MetricTarget.BOXES` and + `MetricTarget.ORIENTED_BOUNDING_BOXES`. Passed through to + `from_detections`. `MetricTarget.MASKS` is not supported. + + Returns: + New instance of ConfusionMatrix. + + Example: + ```python + import supervision as sv + from ultralytics import YOLO + + dataset = sv.DetectionDataset.from_yolo(...) + + model = YOLO(...) + def callback(image: np.ndarray) -> sv.Detections: + result = model(image)[0] + return sv.Detections.from_ultralytics(result) + + confusion_matrix = sv.ConfusionMatrix.benchmark( + dataset = dataset, + callback = callback + ) + + print(confusion_matrix.matrix) + # np.array([ + # [0., 0., 0., 0.], + # [0., 1., 0., 1.], + # [0., 1., 1., 0.], + # [1., 1., 0., 0.] + # ]) + ``` + """ + if save_directory_path is not None: + save_directory = Path(save_directory_path) + save_directory.mkdir(parents=True, exist_ok=True) + + predictions, targets = [], [] + for index, (image_name, image, annotation) in enumerate(dataset): + predictions_batch = callback(image) + predictions.append(predictions_batch) + targets.append(annotation) + + if save_directory_path is not None: + if isinstance(image_name, Path): + image_filename = image_name.name + elif isinstance(image_name, str): + image_filename = Path(image_name).name + else: + image_filename = f"image_{index:06d}.jpg" + + if Path(image_filename).suffix == "": + image_filename = f"{image_filename}.jpg" + + save_path = save_directory / image_filename + if save_path.exists(): + warnings.warn( + f"Validation image '{image_filename}' already exists at " + f"'{save_path}' and will be overwritten.", + UserWarning, + stacklevel=2, + ) + _save_detection_validation_visualization( + scene=image, + predictions=predictions_batch, + targets=annotation, + save_path=save_path, + conf_threshold=conf_threshold, + iou_threshold=iou_threshold, + class_names=dataset.classes, + metric_target=metric_target, + ) + return cls.from_detections( + predictions=predictions, + targets=targets, + classes=dataset.classes, + conf_threshold=conf_threshold, + iou_threshold=iou_threshold, + metric_target=metric_target, + ) + + def plot( + self, + save_path: str | None = None, + title: str | None = None, + classes: list[str] | None = None, + normalize: bool = False, + fig_size: tuple[int, int] = (12, 10), + ) -> Figure: + """ + Create confusion matrix plot and save it at selected location. + + Args: + save_path: Path to save the plot. If not provided, + plot will be displayed. + title: Title of the plot. + classes: List of classes to be displayed on the plot. + If not provided, all classes will be displayed. + normalize: If True, normalize the confusion matrix. + fig_size: Size of the plot. + + Returns: + Confusion matrix plot. + """ + from matplotlib import pyplot as plt + + # Cast to float so that the NaN masking below never hits an integer + # matrix (assigning NaN into an int array raises ValueError). + array = self.matrix.astype(np.float64) + + if normalize: + eps = 1e-8 + array = array / (array.sum(0).reshape(1, -1) + eps) + + array[array < 0.005] = np.nan + + fig, ax = plt.subplots(figsize=fig_size, tight_layout=True, facecolor="white") + + class_names = classes if classes is not None else self.classes + use_labels_for_ticks = class_names is not None and (0 < len(class_names) < 99) + if use_labels_for_ticks: + x_tick_labels = [*class_names, "FN"] + y_tick_labels = [*class_names, "FP"] + num_ticks = len(x_tick_labels) + else: + x_tick_labels = None + y_tick_labels = None + num_ticks = len(array) + im = ax.imshow(array, cmap="Blues") + + cbar = ax.figure.colorbar(im, ax=ax) + cbar.mappable.set_clim(vmin=0, vmax=float(np.nanmax(array))) + + if x_tick_labels is None: + tick_interval = 2 + else: + tick_interval = 1 + ax.set_xticks(np.arange(0, num_ticks, tick_interval), labels=x_tick_labels) + ax.set_yticks(np.arange(0, num_ticks, tick_interval), labels=y_tick_labels) + + plt.setp(ax.get_xticklabels(), rotation=90, ha="right", rotation_mode="default") + + labelsize = 10 if num_ticks < 50 else 8 + ax.tick_params(axis="both", which="both", labelsize=labelsize) + + if num_ticks < 30: + for i in range(array.shape[0]): + for j in range(array.shape[1]): + n_preds = array[i, j] + if not np.isnan(n_preds): + ax.text( + j, + i, + f"{n_preds:.2f}" if normalize else f"{n_preds:.0f}", + ha="center", + va="center", + color="black" + if n_preds < 0.5 * np.nanmax(array) + else "white", + ) + + if title: + ax.set_title(title, fontsize=20) + + ax.set_xlabel("Predicted") + ax.set_ylabel("True") + ax.set_facecolor("white") + if save_path: + fig.savefig( + save_path, dpi=250, facecolor=fig.get_facecolor(), transparent=True + ) + return fig + + +@deprecated_class( + target=TargetMode.NOTIFY, + deprecated_in="0.27.0", + remove_in="0.31.0", +) +@dataclass(frozen=True) +class MeanAveragePrecision: + """ + !!! deprecated "Deprecated" + `MeanAveragePrecision` is **deprecated** and will be removed in + `supervision-0.31.0`. + + The deprecated implementation provides results that are inconsistent with + `pycocotools`. Please use + `supervision.metrics.mean_average_precision.MeanAveragePrecision` instead, + which matches the results of `pycocotools` and is now the recommended approach. + + Mean Average Precision for object detection tasks. + + Attributes: + map50_95: Mean Average Precision (mAP) calculated over IoU thresholds + ranging from `0.50` to `0.95` with a step size of `0.05`. + map50: Mean Average Precision (mAP) calculated specifically at + an IoU threshold of `0.50`. + map75: Mean Average Precision (mAP) calculated specifically at + an IoU threshold of `0.75`. + per_class_ap50_95: Average Precision (AP) values calculated over + IoU thresholds ranging from `0.50` to `0.95` with a step size of `0.05`, + provided for each individual class. + """ + + map50_95: float + map50: float + map75: float + per_class_ap50_95: npt.NDArray[np.float64] + + @classmethod + def from_detections( + cls, + predictions: list[Detections], + targets: list[Detections], + ) -> MeanAveragePrecision: + """ + Calculate mean average precision based on predicted and ground-truth detections. + + Args: + targets: Detections objects from ground-truth. + predictions: Detections objects predicted by the model. + Returns: + New instance of ConfusionMatrix. + + Examples: + ```pycon + >>> import numpy as np + >>> import supervision as sv + >>> targets = [ + ... sv.Detections( + ... xyxy=np.array([[0, 0, 10, 10]]), + ... class_id=np.array([0]) + ... ) + ... ] + >>> predictions = [ + ... sv.Detections( + ... xyxy=np.array([[0, 0, 10, 10]]), + ... class_id=np.array([0]), + ... confidence=np.array([0.9]) + ... ) + ... ] + >>> mAP = sv.MeanAveragePrecision.from_detections( + ... predictions=predictions, + ... targets=targets, + ... ) + >>> round(float(mAP.map50), 2) + 1.0 + + ``` + """ + prediction_tensors = [] + target_tensors = [] + for prediction, target in zip(predictions, targets): + prediction_tensors.append( + detections_to_tensor(prediction, with_confidence=True) + ) + target_tensors.append(detections_to_tensor(target, with_confidence=False)) + return cls.from_tensors( + predictions=prediction_tensors, + targets=target_tensors, + ) + + @classmethod + def benchmark( + cls, + dataset: DetectionDataset, + callback: Callable[[npt.NDArray[np.uint8]], Detections], + ) -> MeanAveragePrecision: + """ + Calculate mean average precision from dataset and callback function. + + Args: + dataset: Object detection dataset used for evaluation. + callback: Function that takes + an image as input and returns Detections object. + Returns: + New instance of MeanAveragePrecision. + + Example: + ```python + import supervision as sv + from ultralytics import YOLO + + dataset = sv.DetectionDataset.from_yolo(...) + + model = YOLO(...) + def callback(image: np.ndarray) -> sv.Detections: + result = model(image)[0] + return sv.Detections.from_ultralytics(result) + + mean_average_precision = sv.MeanAveragePrecision.benchmark( + dataset = dataset, + callback = callback + ) + + print(mean_average_precision.map50_95) + # 0.433 + ``` + """ + predictions, targets = [], [] + for _, image, annotation in dataset: + predictions_batch = callback(image) + predictions.append(predictions_batch) + targets.append(annotation) + return cls.from_detections( + predictions=predictions, + targets=targets, + ) + + @classmethod + def from_tensors( + cls, + predictions: list[npt.NDArray[np.float32]], + targets: list[npt.NDArray[np.float32]], + ) -> MeanAveragePrecision: + """ + Calculate Mean Average Precision based on predicted and ground-truth + detections at different threshold. + + Args: + predictions: Each element of the list describes + a single image and has `shape = (M, 6)` where `M` is + the number of detected objects. Each row is expected to be + in `(x_min, y_min, x_max, y_max, class, conf)` format. + targets: Each element of the list describes a single + image and has `shape = (N, 5)` where `N` is the + number of ground-truth objects. Each row is expected to be in + `(x_min, y_min, x_max, y_max, class)` format. An empty array + (``N = 0``) represents a background image; all predictions on + that image count as false positives and reduce AP accordingly. + + Returns: + MeanAveragePrecision: New instance computed from the provided + predictions and targets. + + Examples: + ```pycon + >>> import supervision as sv + >>> import numpy as np + >>> targets = [ + ... np.array([ + ... [0.0, 0.0, 3.0, 3.0, 0], + ... [2.0, 2.0, 5.0, 5.0, 0], + ... [6.0, 1.0, 8.0, 3.0, 1], + ... ]) + ... ] + >>> predictions = [ + ... np.array([ + ... [0.0, 0.0, 3.0, 3.0, 0, 0.9], + ... [0.1, 0.1, 3.0, 3.0, 0, 0.9], + ... [6.0, 1.0, 8.0, 3.0, 1, 0.8], + ... ]) + ... ] + >>> mAP = sv.MeanAveragePrecision.from_tensors( + ... predictions=predictions, + ... targets=targets, + ... ) + >>> round(float(mAP.map50), 2) + 0.75 + + >>> bg_pred = [np.array([[0., 0., 10., 10., 0, 0.9]], dtype=np.float32)] + >>> bg_tgt = [np.zeros((0, 5), dtype=np.float32)] + >>> mAP_bg = sv.MeanAveragePrecision.from_tensors( + ... predictions=bg_pred, + ... targets=bg_tgt, + ... ) + >>> float(mAP_bg.map50) + 0.0 + + ``` + """ + _validate_input_tensors(predictions, targets) + iou_thresholds = np.linspace(0.5, 0.95, 10, dtype=np.float32) + stats = [] + + # Gather matching stats for predictions and targets + for true_objs, predicted_objs in zip(targets, predictions): + if predicted_objs.shape[0] == 0: + if true_objs.shape[0]: + stats.append( + ( + np.zeros((0, iou_thresholds.size), dtype=bool), + *np.zeros((2, 0)), + true_objs[:, 4], + ) + ) + continue + + if true_objs.shape[0]: + matches = cls._match_detection_batch( + predicted_objs, true_objs, iou_thresholds + ) + stats.append( + ( + matches, + predicted_objs[:, 5], + predicted_objs[:, 4], + true_objs[:, 4], + ) + ) + else: + # Background image: no GT boxes, so all predictions are FP matches. + # This lowers AP for classes that appear in at least one GT image + # elsewhere; classes absent from all GT images are excluded from AP + # (they never appear in true_class_ids and are skipped by the AP loop). + stats.append( + ( + np.zeros( + (predicted_objs.shape[0], iou_thresholds.size), dtype=bool + ), + predicted_objs[:, 5], + predicted_objs[:, 4], + np.zeros((0,), dtype=np.float32), + ) + ) + + # Compute average precisions if any matches exist + if stats: + concatenated_stats = [np.concatenate(items, 0) for items in zip(*stats)] + average_precisions = cls._average_precisions_per_class( + cast(npt.NDArray[np.bool_], concatenated_stats[0]), + cast(npt.NDArray[np.float32], concatenated_stats[1]), + cast(npt.NDArray[np.int32], concatenated_stats[2]), + cast(npt.NDArray[np.int32], concatenated_stats[3]), + ) + if average_precisions.size == 0: + # All images had no ground-truth objects; FPs recorded but no class + # to accumulate AP over โ†’ return 0.0 rather than NaN. + map50, map75, map50_95 = 0.0, 0.0, 0.0 + else: + map50 = float(average_precisions[:, 0].mean()) + map75 = float(average_precisions[:, 5].mean()) + map50_95 = float(average_precisions.mean()) + else: + map50, map75, map50_95 = 0, 0, 0 + average_precisions = np.array([]) + + return cls( + map50_95=map50_95, + map50=map50, + map75=map75, + per_class_ap50_95=average_precisions, + ) + + @staticmethod + def compute_average_precision( + recall: npt.NDArray[np.float64], + precision: npt.NDArray[np.float64], + ) -> float: + """ + Compute the average precision using 101-point interpolation (COCO), given + the recall and precision curves. + + Args: + recall: The recall curve. + precision: The precision curve. + + Returns: + Average precision. + """ + extended_recall = np.concatenate(([0.0], recall, [1.0])) + extended_precision = np.concatenate(([0.0], precision, [0.0])) + max_accumulated_precision = np.flip( + np.maximum.accumulate(np.flip(extended_precision)) + ) + interpolated_recall_levels = np.linspace(0, 1, 101) + recall_indices = np.searchsorted( + extended_recall, interpolated_recall_levels, side="left" + ) + interpolated_precision = max_accumulated_precision[recall_indices] + average_precision = np.mean(interpolated_precision) + + return float(average_precision) + + @staticmethod + def _match_detection_batch( + predictions: npt.NDArray[np.float32], + targets: npt.NDArray[np.float32], + iou_thresholds: npt.NDArray[np.float32], + ) -> npt.NDArray[np.bool_]: + """ + Match predictions with target labels based on IoU levels. + + Args: + predictions: Batch prediction. Describes a single image and + has `shape = (M, 6)` where `M` is the number of detected objects. + Each row is expected to be in + `(x_min, y_min, x_max, y_max, class, conf)` format. + targets: Batch target labels. Describes a single image and + has `shape = (N, 5)` where `N` is the number of ground-truth objects. + Each row is expected to be in + `(x_min, y_min, x_max, y_max, class)` format. + iou_thresholds: Array contains different IoU thresholds. + + Returns: + Matched prediction with target labels result. + """ + num_predictions, num_iou_levels = predictions.shape[0], iou_thresholds.shape[0] + correct = np.zeros((num_predictions, num_iou_levels), dtype=bool) + iou = box_iou_batch(targets[:, :4], predictions[:, :4]) + correct_class = targets[:, 4:5] == predictions[:, 4] + + for i, iou_level in enumerate(iou_thresholds): + matched_indices = np.where((iou >= iou_level) & correct_class) + + for t, p in _greedy_match(iou, matched_indices): + correct[p, i] = True + result: npt.NDArray[np.bool_] = correct + return result + + @staticmethod + def _average_precisions_per_class( + matches: npt.NDArray[np.bool_], + prediction_confidence: npt.NDArray[np.float32], + prediction_class_ids: npt.NDArray[np.int32], + true_class_ids: npt.NDArray[np.int32], + eps: float = 1e-16, + ) -> npt.NDArray[np.float64]: + """ + Compute the average precision, given the recall and precision curves. + Source: https://github.com/rafaelpadilla/Object-Detection-Metrics. + + Args: + matches: True positives. + prediction_confidence: Objectness value from 0-1. + prediction_class_ids: Predicted object classes. + true_class_ids: True object classes. + eps: Small value to prevent division by zero. + + Returns: + Average precision for different IoU levels. + """ + sorted_indices = np.argsort(-prediction_confidence) + matches = matches[sorted_indices] + prediction_class_ids = prediction_class_ids[sorted_indices] + + unique_classes, class_counts = np.unique(true_class_ids, return_counts=True) + num_classes = unique_classes.shape[0] + + average_precisions: npt.NDArray[np.float64] = np.zeros( + (num_classes, matches.shape[1]), dtype=np.float64 + ) + + for class_idx, class_id in enumerate(unique_classes): + is_class = prediction_class_ids == class_id + total_true = class_counts[class_idx] + total_prediction = is_class.sum() + + if total_prediction == 0 or total_true == 0: + continue + + false_positives = (1 - matches[is_class]).cumsum(0) + true_positives = matches[is_class].cumsum(0) + recall = true_positives / (total_true + eps) + precision = true_positives / (true_positives + false_positives) + + for iou_level_idx in range(matches.shape[1]): + average_precisions[class_idx, iou_level_idx] = ( + MeanAveragePrecision.compute_average_precision( + recall[:, iou_level_idx], precision[:, iou_level_idx] + ) + ) + + result: npt.NDArray[np.float64] = average_precisions + return result diff --git a/src/supervision/metrics/f1_score.py b/src/supervision/metrics/f1_score.py new file mode 100644 index 0000000..e4a58d5 --- /dev/null +++ b/src/supervision/metrics/f1_score.py @@ -0,0 +1,815 @@ +from __future__ import annotations + +from copy import deepcopy +from dataclasses import dataclass +from typing import TYPE_CHECKING, Any, cast + +import numpy as np +import numpy.typing as npt + +from supervision.config import ORIENTED_BOX_COORDINATES +from supervision.detection.compact_mask import CompactMask +from supervision.detection.core import Detections +from supervision.detection.utils.iou_and_nms import ( + box_iou_batch, + mask_iou_batch, + oriented_box_iou_batch, +) +from supervision.draw.color import LEGACY_COLOR_PALETTE +from supervision.metrics.core import AveragingMethod, Metric, MetricTarget +from supervision.metrics.utils.matching import ( + _match_detection_batch_with_target_indices, +) +from supervision.metrics.utils.object_size import ( + ObjectSizeCategory, + get_detection_size_category, +) +from supervision.metrics.utils.utils import ensure_pandas_installed + +if TYPE_CHECKING: + import pandas as pd + + +class F1Score(Metric["F1ScoreResult"]): + """ + F1 Score is a metric used to evaluate object detection models. It is the harmonic + mean of precision and recall, calculated at different IoU thresholds. + + In simple terms, F1 Score is a measure of a model's balance between precision and + recall (accuracy and completeness), calculated as: + + `F1 = 2 * (precision * recall) / (precision + recall)` + + Examples: + ```pycon + >>> import numpy as np + >>> import supervision as sv + >>> from supervision.metrics import F1Score + >>> predictions = sv.Detections( + ... xyxy=np.array([[0, 0, 10, 10]]), + ... class_id=np.array([0]), + ... confidence=np.array([0.9]) + ... ) + >>> targets = sv.Detections( + ... xyxy=np.array([[0, 0, 10, 10]]), + ... class_id=np.array([0]) + ... ) + >>> f1_metric = F1Score() + >>> f1_result = f1_metric.update(predictions, targets).compute() + >>> round(float(f1_result.f1_50), 2) + 1.0 + + ``` + + ![example_plot]( + https://media.roboflow.com/supervision-docs/metrics/f1_plot_example.png + ){ align=center width="800" } + """ + + def __init__( + self, + metric_target: MetricTarget = MetricTarget.BOXES, + averaging_method: AveragingMethod = AveragingMethod.WEIGHTED, + ): + """ + Initialize the F1Score metric. + + Args: + metric_target: The type of detection data to use. + averaging_method: The averaging method used to compute the + F1 scores. Determines how the F1 scores are aggregated across classes. + """ + self._metric_target = metric_target + self.averaging_method = averaging_method + + self._predictions_list: list[Detections] = [] + self._targets_list: list[Detections] = [] + + def reset(self) -> None: + """ + Reset the metric to its initial state, clearing all stored data. + """ + self._predictions_list = [] + self._targets_list = [] + + def update( + self, + predictions: Detections | list[Detections], + targets: Detections | list[Detections], + ) -> F1Score: + """ + Add new predictions and targets to the metric, but do not compute the result. + + Args: + predictions: The predicted detections. + targets: The target detections. + + Returns: + The updated metric instance. + """ + if not isinstance(predictions, list): + predictions = [predictions] + if not isinstance(targets, list): + targets = [targets] + + if len(predictions) != len(targets): + raise ValueError( + f"The number of predictions ({len(predictions)}) and" + f" targets ({len(targets)}) during the update must be the same." + ) + + self._predictions_list.extend(predictions) + self._targets_list.extend(targets) + + return self + + def compute(self) -> F1ScoreResult: + """ + Calculate the F1 score metric based on the stored predictions and ground-truth + data, at different IoU thresholds. + + Returns: + The F1 score metric result. + """ + result = self._compute(self._predictions_list, self._targets_list) + result.small_objects = self._compute( + self._predictions_list, self._targets_list, ObjectSizeCategory.SMALL + ) + result.medium_objects = self._compute( + self._predictions_list, self._targets_list, ObjectSizeCategory.MEDIUM + ) + result.large_objects = self._compute( + self._predictions_list, self._targets_list, ObjectSizeCategory.LARGE + ) + + return result + + def _compute( + self, + predictions_list: list[Detections], + targets_list: list[Detections], + size_category: ObjectSizeCategory = ObjectSizeCategory.ANY, + ) -> F1ScoreResult: + """Build per-image stats tuples and delegate to class-level computation. + + Each stats tuple is + ``(matches, ignored_matches, confidence, class_ids, true_class_ids)``: + - Both empty: skip (no information). + - Targets empty, predictions present: all predictions are FPs; true_class_ids + is ``zeros((0,))``. + - Targets present: IoU matching produces ``matches`` array. + """ + if size_category != ObjectSizeCategory.ANY: + # Score the requested bucket on bucket-filtered targets so detections + # outside the bucket cannot consume the only available target. + targets_list = [ + self._filter_detections_by_size(targets, size_category) + for targets in targets_list + ] + size_category = ObjectSizeCategory.ANY + + iou_thresholds = np.linspace(0.5, 0.95, 10, dtype=np.float32) + stats: list[Any] = [] + + for predictions, targets in zip(predictions_list, targets_list): + prediction_contents = self._detections_content(predictions) + target_contents = self._detections_content(targets) + prediction_size_mask = np.ones(len(predictions), dtype=bool) + target_size_mask = np.ones(len(targets), dtype=bool) + if size_category != ObjectSizeCategory.ANY: + if len(predictions) > 0: + prediction_size_mask = ( + get_detection_size_category(predictions, self._metric_target) + == size_category.value + ) + if len(targets) > 0: + target_size_mask = ( + get_detection_size_category(targets, self._metric_target) + == size_category.value + ) + + if len(targets) == 0 and len(predictions) > 0: + # Only predictions are present (e.g. a background image); every + # prediction is a false positive. + if predictions.class_id is None or predictions.confidence is None: + raise ValueError( + "F1Score metric requires `class_id` and `confidence` " + "on predictions." + ) + prediction_class_ids = np.asarray(predictions.class_id, dtype=np.int32)[ + prediction_size_mask + ] + prediction_confidence = np.asarray( + predictions.confidence, dtype=np.float32 + )[prediction_size_mask] + if len(prediction_class_ids) == 0: + continue + stats.append( + ( + np.zeros( + (len(prediction_class_ids), iou_thresholds.size), + dtype=np.bool_, + ), + np.zeros( + (len(prediction_class_ids), iou_thresholds.size), + dtype=np.bool_, + ), + prediction_confidence, + prediction_class_ids, + np.zeros((0,), dtype=np.int32), + ) + ) + elif len(targets) > 0: + if predictions.class_id is None or targets.class_id is None: + raise ValueError( + "F1Score metric requires `class_id` on both predictions " + "and targets." + ) + if len(predictions) == 0: + target_class_ids = np.asarray(targets.class_id, dtype=np.int32)[ + target_size_mask + ] + if len(target_class_ids) == 0: + continue + stats.append( + ( + np.zeros((0, iou_thresholds.size), dtype=bool), + np.zeros((0, iou_thresholds.size), dtype=bool), + np.zeros((0,), dtype=np.float32), + np.zeros((0,), dtype=int), + target_class_ids, + ) + ) + + else: + if predictions.confidence is None: + raise ValueError( + "F1Score metric requires `confidence` on predictions." + ) + prediction_class_ids = np.asarray( + predictions.class_id, dtype=np.int32 + ) + target_class_ids = np.asarray(targets.class_id, dtype=np.int32) + prediction_confidence = np.asarray( + predictions.confidence, dtype=np.float32 + ) + if self._metric_target == MetricTarget.BOXES: + # BOXES target never yields CompactMask; narrow for mypy. + iou = box_iou_batch( + cast(npt.NDArray[np.number], target_contents), + cast(npt.NDArray[np.number], prediction_contents), + ) + elif self._metric_target == MetricTarget.MASKS: + iou = mask_iou_batch(target_contents, prediction_contents) + elif self._metric_target == MetricTarget.ORIENTED_BOUNDING_BOXES: + # OBB target never yields CompactMask; narrow for mypy. + iou = oriented_box_iou_batch( + cast(npt.NDArray[np.number], target_contents), + cast(npt.NDArray[np.number], prediction_contents), + ) + else: + raise ValueError( + "Unsupported metric target for IoU calculation" + ) + + matches, matched_target_indices = ( + _match_detection_batch_with_target_indices( + prediction_class_ids, + target_class_ids, + iou, + iou_thresholds, + ) + ) + ignored_matches = np.zeros_like(matches, dtype=bool) + if size_category != ObjectSizeCategory.ANY: + valid_target_match = matched_target_indices >= 0 + matched_scored_target = np.zeros_like(matches, dtype=bool) + if np.any(valid_target_match): + matched_scored_target[valid_target_match] = ( + target_size_mask[ + matched_target_indices[valid_target_match] + ] + ) + prediction_scored = ( + prediction_size_mask[:, None] | matched_scored_target + ) + ignored_matches = ~prediction_scored | ( + valid_target_match & ~matched_scored_target + ) + prediction_keep = np.any(~ignored_matches, axis=1) + matches = ( + matches[prediction_keep] + & matched_scored_target[prediction_keep] + ) + ignored_matches = ignored_matches[prediction_keep] + prediction_confidence = prediction_confidence[prediction_keep] + prediction_class_ids = prediction_class_ids[prediction_keep] + target_class_ids = target_class_ids[target_size_mask] + if ( + len(prediction_class_ids) == 0 + and len(target_class_ids) == 0 + ): + continue + stats.append( + ( + matches, + ignored_matches, + prediction_confidence, + prediction_class_ids, + target_class_ids, + ) + ) + + if not stats: + return F1ScoreResult( + metric_target=self._metric_target, + averaging_method=self.averaging_method, + f1_scores=np.zeros(iou_thresholds.shape[0]), + f1_per_class=np.zeros((0, iou_thresholds.shape[0])), + iou_thresholds=iou_thresholds, + matched_classes=np.array([], dtype=int), + small_objects=None, + medium_objects=None, + large_objects=None, + ) + + concatenated_stats = [np.concatenate(items, 0) for items in zip(*stats)] + f1_scores, f1_per_class, unique_classes = self._compute_f1_for_classes( + *concatenated_stats + ) + + return F1ScoreResult( + metric_target=self._metric_target, + averaging_method=self.averaging_method, + f1_scores=f1_scores, + f1_per_class=f1_per_class, + iou_thresholds=iou_thresholds, + matched_classes=unique_classes, + small_objects=None, + medium_objects=None, + large_objects=None, + ) + + def _compute_f1_for_classes( + self, + matches: npt.NDArray[np.bool_], + ignored_matches: npt.NDArray[np.bool_], + prediction_confidence: npt.NDArray[np.float32], + prediction_class_ids: npt.NDArray[np.int32], + true_class_ids: npt.NDArray[np.int32], + ) -> tuple[ + npt.NDArray[np.float64], + npt.NDArray[np.float64], + npt.NDArray[np.int32], + ]: + """Compute F1 scores from concatenated stats across all images. + + ``unique_classes`` is the union of GT and predicted classes so that + predictions of classes absent from GT still count as false positives. + """ + sorted_indices = np.argsort(-prediction_confidence) + matches = matches[sorted_indices] + ignored_matches = ignored_matches[sorted_indices] + prediction_class_ids = prediction_class_ids[sorted_indices] + # Predictions whose class never appears in the ground truth are still + # false positives, so include those classes in the confusion matrix + # (their true-instance count is zero). + unique_classes = np.unique( + np.concatenate((true_class_ids, prediction_class_ids)) + ) + true_classes, true_counts = np.unique(true_class_ids, return_counts=True) + class_counts = np.zeros(unique_classes.shape[0], dtype=int) + class_counts[np.searchsorted(unique_classes, true_classes)] = true_counts + + # Shape: PxTh,P,C,C -> CxThx3 + confusion_matrix = self._compute_confusion_matrix( + matches, ignored_matches, prediction_class_ids, unique_classes, class_counts + ) + + # Shape: CxThx3 -> CxTh + f1_per_class = self._compute_f1(confusion_matrix) + + # Shape: CxTh -> Th + if self.averaging_method == AveragingMethod.MACRO: + f1_scores = np.mean(f1_per_class, axis=0) + elif self.averaging_method == AveragingMethod.MICRO: + confusion_matrix_merged = confusion_matrix.sum(0) + f1_scores = self._compute_f1(confusion_matrix_merged) + elif self.averaging_method == AveragingMethod.WEIGHTED: + class_counts = class_counts.astype(np.float32) + if class_counts.sum() == 0: + # No ground-truth support (e.g. only false-positive classes, or a + # size bucket with predictions but no targets): weighting is + # undefined, so report 0 as the empty case did before. + f1_scores = np.zeros(f1_per_class.shape[1]) + else: + f1_scores = np.average(f1_per_class, axis=0, weights=class_counts) + + return f1_scores, f1_per_class, unique_classes + + @staticmethod + def _match_detection_batch( + predictions_classes: npt.NDArray[np.int32], + target_classes: npt.NDArray[np.int32], + iou: npt.NDArray[np.float32], + iou_thresholds: npt.NDArray[np.float32], + ) -> npt.NDArray[np.bool_]: + result_correct, _ = _match_detection_batch_with_target_indices( + predictions_classes, target_classes, iou, iou_thresholds + ) + return result_correct + + @staticmethod + def _compute_confusion_matrix( + sorted_matches: npt.NDArray[np.bool_], + sorted_ignored_matches: npt.NDArray[np.bool_], + sorted_prediction_class_ids: npt.NDArray[np.int32], + unique_classes: npt.NDArray[np.int32], + class_counts: npt.NDArray[np.int32], + ) -> npt.NDArray[np.float64]: + """ + Compute the confusion matrix for each class and IoU threshold. + + Assumes the matches and prediction_class_ids are sorted by confidence + in descending order. + + Args: + sorted_matches: shape (P, Th), that is True + if the prediction is a true positive at the given IoU threshold. + sorted_ignored_matches: shape (P, Th), that is True + if the prediction should not affect the given IoU threshold. + sorted_prediction_class_ids: shape (P,), containing + the class id for each prediction. + unique_classes: shape (C,), containing the unique + class ids. + class_counts: shape (C,), containing the number + of true instances for each class. + + Returns: + shape (C, Th, 3), containing the true positives, false + positives, and false negatives for each class and IoU threshold. + """ + + num_thresholds = sorted_matches.shape[1] + num_classes = unique_classes.shape[0] + + confusion_matrix: npt.NDArray[np.float64] = np.zeros( + (num_classes, num_thresholds, 3), dtype=np.float64 + ) + for class_idx, class_id in enumerate(unique_classes): + is_class = sorted_prediction_class_ids == class_id + num_true = class_counts[class_idx] + num_predictions = is_class.sum() + + if num_predictions == 0: + true_positives = np.zeros(num_thresholds) + false_positives = np.zeros(num_thresholds) + false_negatives = np.full(num_thresholds, num_true) + elif num_true == 0: + true_positives = np.zeros(num_thresholds) + false_positives = (~sorted_ignored_matches[is_class]).sum(0) + false_negatives = np.zeros(num_thresholds) + else: + true_positives = sorted_matches[is_class].sum(0) + false_positives = ( + ~sorted_matches[is_class] & ~sorted_ignored_matches[is_class] + ).sum(0) + false_negatives = num_true - true_positives + confusion_matrix[class_idx] = np.stack( + [true_positives, false_positives, false_negatives], axis=1 + ) + + result_confusion_matrix: npt.NDArray[np.float64] = confusion_matrix + return result_confusion_matrix + + @staticmethod + def _compute_f1( + confusion_matrix: npt.NDArray[np.float64], + ) -> npt.NDArray[np.float64]: + """ + Broadcastable function, computing the F1 score from the confusion matrix. + + Args: + confusion_matrix: shape (N, ..., 3), where the last dimension + contains the true positives, false positives, and false negatives. + + Returns: + shape (N, ...), containing the F1 score for each element. + """ + if not confusion_matrix.shape[-1] == 3: + raise ValueError( + f"Confusion matrix must have shape (..., 3), got " + f"{confusion_matrix.shape}" + ) + true_positives = confusion_matrix[..., 0] + false_positives = confusion_matrix[..., 1] + false_negatives = confusion_matrix[..., 2] + + # Alternate formula, avoids multiple zero division checks + denominator = 2 * true_positives + false_positives + false_negatives + f1_score = np.where(denominator == 0, 0, 2 * true_positives / denominator) + + result_f1_score: npt.NDArray[np.float64] = f1_score + return result_f1_score + + def _detections_content( + self, detections: Detections + ) -> npt.NDArray[Any] | CompactMask: + """Return boxes, masks or oriented bounding boxes from detections. + + For the mask target this may return a + :class:`~supervision.detection.compact_mask.CompactMask` rather than a + dense boolean array when the detections carry compact masks. + """ + if self._metric_target == MetricTarget.BOXES: + return cast(npt.NDArray[Any], detections.xyxy) + if self._metric_target == MetricTarget.MASKS: + if detections.mask is not None: + # detections.mask is NDArray[bool] | CompactMask; return as-is. + return detections.mask + if len(detections) > 0: + raise ValueError( + "F1Score with `MetricTarget.MASKS` requires detections to " + "include masks." + ) + return self._make_empty_content() + if self._metric_target == MetricTarget.ORIENTED_BOUNDING_BOXES: + obb = detections.data.get(ORIENTED_BOX_COORDINATES) + if obb is not None and len(obb) > 0: + result_obb: npt.NDArray[np.float32] = np.array(obb, dtype=np.float32) + return result_obb + return self._make_empty_content() + raise ValueError(f"Invalid metric target: {self._metric_target}") + + def _make_empty_content(self) -> npt.NDArray[Any]: + if self._metric_target == MetricTarget.BOXES: + empty_boxes: npt.NDArray[np.float32] = np.empty((0, 4), dtype=np.float32) + return empty_boxes + if self._metric_target == MetricTarget.MASKS: + empty_masks: npt.NDArray[np.bool_] = np.empty((0, 0, 0), dtype=bool) + return empty_masks + if self._metric_target == MetricTarget.ORIENTED_BOUNDING_BOXES: + empty_obb: npt.NDArray[np.float32] = np.empty((0, 4, 2), dtype=np.float32) + return empty_obb + raise ValueError(f"Invalid metric target: {self._metric_target}") + + def _filter_detections_by_size( + self, detections: Detections, size_category: ObjectSizeCategory + ) -> Detections: + """Return a copy of detections with contents filtered by object size.""" + new_detections = deepcopy(detections) + if detections.is_empty() or size_category == ObjectSizeCategory.ANY: + return new_detections + + sizes = get_detection_size_category(new_detections, self._metric_target) + size_mask = sizes == size_category.value + + new_detections.xyxy = new_detections.xyxy[size_mask] + if new_detections.mask is not None: + new_detections.mask = new_detections.mask[size_mask] + if new_detections.class_id is not None: + new_detections.class_id = new_detections.class_id[size_mask] + if new_detections.confidence is not None: + new_detections.confidence = new_detections.confidence[size_mask] + if new_detections.tracker_id is not None: + new_detections.tracker_id = new_detections.tracker_id[size_mask] + if new_detections.data is not None: + for key, value in new_detections.data.items(): + new_detections.data[key] = np.array(value)[size_mask] + + return new_detections + + def _filter_predictions_and_targets_by_size( + self, + predictions_list: list[Detections], + targets_list: list[Detections], + size_category: ObjectSizeCategory, + ) -> tuple[list[Detections], list[Detections]]: + """ + Filter predictions and targets by object size category. + """ + new_predictions_list = [] + new_targets_list = [] + for predictions, targets in zip(predictions_list, targets_list): + new_predictions_list.append( + self._filter_detections_by_size(predictions, size_category) + ) + new_targets_list.append( + self._filter_detections_by_size(targets, size_category) + ) + return new_predictions_list, new_targets_list + + +@dataclass +class F1ScoreResult: + """ + The results of the F1 score metric calculation. + + Defaults to `0` if no detections or targets were provided. + + Attributes: + metric_target: the type of data used for the metric - + boxes, masks or oriented bounding boxes. + averaging_method: the averaging method used to compute the + F1 scores. Determines how the F1 scores are aggregated across classes. + f1_50: the F1 score at IoU threshold of `0.5`. + f1_75: the F1 score at IoU threshold of `0.75`. + f1_scores: the F1 scores at each IoU threshold. + Shape: `(num_iou_thresholds,)` + f1_per_class: the F1 scores per class and IoU threshold. + Shape: `(num_classes, num_iou_thresholds)` + iou_thresholds: the IoU thresholds used in the calculations. + matched_classes: the class IDs present in either predictions or ground + truth. Corresponds to the rows of `f1_per_class`. Classes that + appear only in predictions (no ground-truth instances) are + included; their per-threshold F1 values will be `0.0`. + small_objects: the F1 metric results + for small objects (area < 32ยฒ). + medium_objects: the F1 metric results + for medium objects (32ยฒ โ‰ค area < 96ยฒ). + large_objects: the F1 metric results + for large objects (area โ‰ฅ 96ยฒ). + """ + + metric_target: MetricTarget + averaging_method: AveragingMethod + + @property + def f1_50(self) -> float: + return float(self.f1_scores[0]) + + @property + def f1_75(self) -> float: + return float(self.f1_scores[5]) + + f1_scores: npt.NDArray[np.float64] + f1_per_class: npt.NDArray[np.float64] + iou_thresholds: npt.NDArray[np.float32] + matched_classes: npt.NDArray[np.int32] + + small_objects: F1ScoreResult | None + medium_objects: F1ScoreResult | None + large_objects: F1ScoreResult | None + + def __str__(self) -> str: + """ + Format as a pretty string. + + Example: + ```pycon + >>> import numpy as np + >>> import supervision as sv + >>> from supervision.metrics import F1Score + >>> predictions = sv.Detections( + ... xyxy=np.array([[0, 0, 10, 10]]), + ... class_id=np.array([0]), + ... confidence=np.array([0.9]) + ... ) + >>> targets = sv.Detections( + ... xyxy=np.array([[0, 0, 10, 10]]), + ... class_id=np.array([0]) + ... ) + >>> f1_metric = F1Score() + >>> f1_result = f1_metric.update(predictions, targets).compute() + >>> print(f1_result) # doctest: +ELLIPSIS + F1ScoreResult: + Metric target: MetricTarget.BOXES + Averaging method: AveragingMethod.WEIGHTED + F1 @ 50: 1.0000 + F1 @ 75: 1.0000 + F1 @ thresh: [1. ... 1.] + IoU thresh: [0.5 0.55 ... 0.95] + F1 per class: + 0: [1. ... 1.] + ... + Medium objects: + F1ScoreResult: + Metric target: MetricTarget.BOXES + Averaging method: AveragingMethod.WEIGHTED + F1 @ 50: 0.0000 + ... + + ``` + """ + out_str = ( + f"{self.__class__.__name__}:\n" + f"Metric target: {self.metric_target}\n" + f"Averaging method: {self.averaging_method}\n" + f"F1 @ 50: {self.f1_50:.4f}\n" + f"F1 @ 75: {self.f1_75:.4f}\n" + f"F1 @ thresh: {self.f1_scores}\n" + f"IoU thresh: {self.iou_thresholds}\n" + f"F1 per class:\n" + ) + if self.f1_per_class.size == 0: + out_str += " No results\n" + for class_id, f1_of_class in zip(self.matched_classes, self.f1_per_class): + out_str += f" {class_id}: {f1_of_class}\n" + + indent = " " + if self.small_objects is not None: + indented = indent + str(self.small_objects).replace("\n", f"\n{indent}") + out_str += f"\nSmall objects:\n{indented}" + if self.medium_objects is not None: + indented = indent + str(self.medium_objects).replace("\n", f"\n{indent}") + out_str += f"\nMedium objects:\n{indented}" + if self.large_objects is not None: + indented = indent + str(self.large_objects).replace("\n", f"\n{indent}") + out_str += f"\nLarge objects:\n{indented}" + + return out_str + + def to_pandas(self) -> pd.DataFrame: + """ + Convert the result to a pandas DataFrame. + + Returns: + The result as a DataFrame. + """ + ensure_pandas_installed() + import pandas as pd + + pandas_data: dict[str, Any] = { + "F1@50": self.f1_50, + "F1@75": self.f1_75, + } + + if self.small_objects is not None: + small_objects_df = self.small_objects.to_pandas() + for key, value in small_objects_df.items(): + pandas_data[f"small_objects_{key}"] = value + if self.medium_objects is not None: + medium_objects_df = self.medium_objects.to_pandas() + for key, value in medium_objects_df.items(): + pandas_data[f"medium_objects_{key}"] = value + if self.large_objects is not None: + large_objects_df = self.large_objects.to_pandas() + for key, value in large_objects_df.items(): + pandas_data[f"large_objects_{key}"] = value + + return pd.DataFrame(pandas_data, index=[0]) + + def plot(self) -> None: + """ + Plot the F1 results. + + ![example_plot]( + https://media.roboflow.com/supervision-docs/metrics/f1_plot_example.png + ){ align=center width="800" } + """ + from matplotlib import pyplot as plt + + labels = ["F1@50", "F1@75"] + values = [self.f1_50, self.f1_75] + colors = [LEGACY_COLOR_PALETTE[0]] * 2 + + if self.small_objects is not None: + small_objects = self.small_objects + labels += ["Small: F1@50", "Small: F1@75"] + values += [small_objects.f1_50, small_objects.f1_75] + colors += [LEGACY_COLOR_PALETTE[3]] * 2 + + if self.medium_objects is not None: + medium_objects = self.medium_objects + labels += ["Medium: F1@50", "Medium: F1@75"] + values += [medium_objects.f1_50, medium_objects.f1_75] + colors += [LEGACY_COLOR_PALETTE[2]] * 2 + + if self.large_objects is not None: + large_objects = self.large_objects + labels += ["Large: F1@50", "Large: F1@75"] + values += [large_objects.f1_50, large_objects.f1_75] + colors += [LEGACY_COLOR_PALETTE[4]] * 2 + + plt.rcParams["font.family"] = "monospace" + + _, ax = plt.subplots(figsize=(10, 6)) + ax.set_ylim(0, 1) + ax.set_ylabel("Value", fontweight="bold") + title = ( + f"F1 Score, by Object Size" + f"\n(target: {self.metric_target.value}," + f" averaging: {self.averaging_method.value})" + ) + ax.set_title(title, fontweight="bold") + + x_positions = range(len(labels)) + bars = ax.bar(x_positions, values, color=colors, align="center") + + ax.set_xticks(x_positions) + ax.set_xticklabels(labels, rotation=45, ha="right") + + for bar in bars: + y_value = bar.get_height() + ax.text( + bar.get_x() + bar.get_width() / 2, + y_value + 0.02, + f"{y_value:.2f}", + ha="center", + va="bottom", + ) + + plt.rcParams["font.family"] = "sans-serif" + + plt.tight_layout() + plt.show() diff --git a/src/supervision/metrics/mean_average_precision.py b/src/supervision/metrics/mean_average_precision.py new file mode 100644 index 0000000..388be7b --- /dev/null +++ b/src/supervision/metrics/mean_average_precision.py @@ -0,0 +1,1723 @@ +from __future__ import annotations + +import copy +import datetime +import itertools +from collections import defaultdict +from copy import deepcopy +from dataclasses import dataclass +from enum import Enum +from typing import TYPE_CHECKING, Any, TypeAlias, TypedDict + +import numpy as np +import numpy.typing as npt + +from supervision.config import ORIENTED_BOX_COORDINATES +from supervision.detection.core import Detections +from supervision.detection.utils.iou_and_nms import ( + box_iou_batch_with_jaccard, + mask_iou_batch, + oriented_box_iou_batch, +) +from supervision.draw.color import LEGACY_COLOR_PALETTE +from supervision.metrics.core import Metric, MetricTarget +from supervision.metrics.utils.utils import ensure_pandas_installed +from supervision.utils.logger import _get_logger + +logger = _get_logger(__name__) + +if TYPE_CHECKING: + import pandas as pd + + +class _TypeCocoDict(TypedDict, total=False): + id: int + image_id: int + category_id: int + bbox: list[float] + area: float + iscrowd: int + ignore: int + _ignore: int + score: float + segmentation: list[list[float]] + name: str + supercategory: str + caption: str + keypoints: list[float] + # Metric-target-specific content: a boolean mask of shape (H, W) for + # `MetricTarget.MASKS` or an oriented box of shape (4, 2) for + # `MetricTarget.ORIENTED_BOUNDING_BOXES`. Absent for `MetricTarget.BOXES`. + # Invariant: shape/dtype match `metric_target` of the owning COCOEvaluator. + content: npt.NDArray[Any] + + +_TypeCocoDataset: TypeAlias = dict[str, list[_TypeCocoDict]] + + +class _TypeEvaluationImageResult(TypedDict): + image_id: int + category_id: int + area_range: list[float] | tuple[float, float] + max_det: int + dt_ids: list[int] + gt_ids: list[int] + dtMatches: npt.NDArray[np.int64] + gtMatches: npt.NDArray[np.int64] + dtScores: list[float] + gtIgnore: npt.NDArray[np.int64] + dtIgnore: npt.NDArray[np.bool_] + + +@dataclass +class MeanAveragePrecisionResult: + """ + The result of the Mean Average Precision calculation. + + Returns `-1` sentinel scores when no detections or targets are present. + + Attributes: + metric_target: the type of data used for the metric - + boxes, masks or oriented bounding boxes. + is_class_agnostic: When computing class-agnostic results, class ID + is set to `-1`. + mAP_scores: the mAP scores at each IoU threshold. + Shape: `(num_iou_thresholds,)` + ap_per_class: the average precision scores per + class and IoU threshold. Shape: `(num_target_classes, num_iou_thresholds)` + iou_thresholds: the IoU thresholds used in the calculations. + matched_classes: the class IDs of all matched classes. + Corresponds to the rows of `ap_per_class`. + small_objects: the mAP results + for small objects (area < 32ยฒ). + medium_objects: the mAP results + for medium objects (32ยฒ โ‰ค area < 96ยฒ). + large_objects: the mAP results + for large objects (area โ‰ฅ 96ยฒ). + """ + + metric_target: MetricTarget + is_class_agnostic: bool + + @property + def map50_95(self) -> float: + """the mAP score at IoU thresholds from `0.5` to `0.95`.""" + valid_scores = self.mAP_scores[self.mAP_scores > -1] + if len(valid_scores) > 0: + return float(valid_scores.mean()) + else: + return -1 + + @property + def map50(self) -> float: + """the mAP score at IoU threshold of `0.5`.""" + return float(self.mAP_scores[0]) + + @property + def map75(self) -> float: + """the mAP score at IoU threshold of `0.75`.""" + return float(self.mAP_scores[5]) + + mAP_scores: npt.NDArray[np.float64] + ap_per_class: npt.NDArray[np.float64] + iou_thresholds: npt.NDArray[np.float64] + matched_classes: npt.NDArray[np.int32] + small_objects: MeanAveragePrecisionResult | None = None + medium_objects: MeanAveragePrecisionResult | None = None + large_objects: MeanAveragePrecisionResult | None = None + + def __str__(self) -> str: + """ + Formats the evaluation output metrics to match the structure used by pycocotools + + Example: + ```pycon + >>> import numpy as np + >>> import supervision as sv + >>> from supervision.metrics import MeanAveragePrecision + >>> predictions = sv.Detections( + ... xyxy=np.array([[0, 0, 10, 10]]), + ... class_id=np.array([0]), + ... confidence=np.array([0.9]) + ... ) + >>> targets = sv.Detections( + ... xyxy=np.array([[0, 0, 10, 10]]), + ... class_id=np.array([0]) + ... ) + >>> map_metric = MeanAveragePrecision() + >>> map_result = map_metric.update(predictions, targets).compute() + >>> print(map_result) # doctest: +ELLIPSIS + Average Precision (AP) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = ... + Average Precision (AP) @[ IoU=0.50 | area= all | maxDets=100 ] = ... + Average Precision (AP) @[ IoU=0.75 | area= all | maxDets=100 ] = ... + Average Precision (AP) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = ... + Average Precision (AP) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = ... + Average Precision (AP) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = ... + + ``` + """ + if ( + self.small_objects is None + or self.medium_objects is None + or self.large_objects is None + ): + return ( + f"Average Precision (AP) @[ IoU=0.50:0.95 | area= all | " + f"maxDets=100 ] = {self.map50_95:.3f}\n" + f"Average Precision (AP) @[ IoU=0.50 | area= all | " + f"maxDets=100 ] = {self.map50:.3f}\n" + f"Average Precision (AP) @[ IoU=0.75 | area= all | " + f"maxDets=100 ] = {self.map75:.3f}" + ) + + return ( + f"Average Precision (AP) @[ IoU=0.50:0.95 | area= all | " + f"maxDets=100 ] = {self.map50_95:.3f}\n" + f"Average Precision (AP) @[ IoU=0.50 | area= all | " + f"maxDets=100 ] = {self.map50:.3f}\n" + f"Average Precision (AP) @[ IoU=0.75 | area= all | " + f"maxDets=100 ] = {self.map75:.3f}\n" + f"Average Precision (AP) @[ IoU=0.50:0.95 | area= small | " + f"maxDets=100 ] = {self.small_objects.map50_95:.3f}\n" + f"Average Precision (AP) @[ IoU=0.50:0.95 | area=medium | " + f"maxDets=100 ] = {self.medium_objects.map50_95:.3f}\n" + f"Average Precision (AP) @[ IoU=0.50:0.95 | area= large | " + f"maxDets=100 ] = {self.large_objects.map50_95:.3f}" + ) + + def to_pandas(self) -> pd.DataFrame: + """ + Convert the result to a pandas DataFrame. + + Returns: + The result as a DataFrame. + """ + ensure_pandas_installed() + import pandas as pd + + pandas_data: dict[str, object] = { + "mAP@50:95": self.map50_95, + "mAP@50": self.map50, + "mAP@75": self.map75, + } + + if self.small_objects is not None: + small_objects_df = self.small_objects.to_pandas() + for key, value in small_objects_df.items(): + pandas_data[f"small_objects_{key}"] = value + if self.medium_objects is not None: + medium_objects_df = self.medium_objects.to_pandas() + for key, value in medium_objects_df.items(): + pandas_data[f"medium_objects_{key}"] = value + if self.large_objects is not None: + large_objects_df = self.large_objects.to_pandas() + for key, value in large_objects_df.items(): + pandas_data[f"large_objects_{key}"] = value + + # Average precisions are currently not included in the DataFrame. + return pd.DataFrame( + pandas_data, + index=[0], + ) + + def plot(self) -> None: + """ + Plot the mAP results. + + ![example_plot]( + https://media.roboflow.com/supervision-docs/metrics/mAP_plot_example.png + ){ align=center width="800" } + """ + from matplotlib import pyplot as plt + + labels = ["mAP@50:95", "mAP@50", "mAP@75"] + values = [self.map50_95, self.map50, self.map75] + colors = [LEGACY_COLOR_PALETTE[0]] * 3 + + if self.small_objects is not None: + labels += ["Small: mAP@50:95", "Small: mAP@50", "Small: mAP@75"] + values += [ + self.small_objects.map50_95, + self.small_objects.map50, + self.small_objects.map75, + ] + colors += [LEGACY_COLOR_PALETTE[3]] * 3 + + if self.medium_objects is not None: + labels += ["Medium: mAP@50:95", "Medium: mAP@50", "Medium: mAP@75"] + values += [ + self.medium_objects.map50_95, + self.medium_objects.map50, + self.medium_objects.map75, + ] + colors += [LEGACY_COLOR_PALETTE[2]] * 3 + + if self.large_objects is not None: + labels += ["Large: mAP@50:95", "Large: mAP@50", "Large: mAP@75"] + values += [ + self.large_objects.map50_95, + self.large_objects.map50, + self.large_objects.map75, + ] + colors += [LEGACY_COLOR_PALETTE[4]] * 3 + + plt.rcParams["font.family"] = "monospace" + + _, ax = plt.subplots(figsize=(10, 6)) + ax.set_ylim(0, 1) + ax.set_ylabel("Value", fontweight="bold") + ax.set_title("Mean Average Precision", fontweight="bold") + + x_positions = range(len(labels)) + bars = ax.bar(x_positions, values, color=colors, align="center") + + ax.set_xticks(x_positions) + ax.set_xticklabels(labels, rotation=45, ha="right") + + for bar in bars: + y_value = bar.get_height() + ax.text( + bar.get_x() + bar.get_width() / 2, + y_value + 0.02, + f"{y_value:.2f}", + ha="center", + va="bottom", + ) + + plt.rcParams["font.family"] = "sans-serif" + + plt.tight_layout() + plt.show() + + +class EvaluationDataset: + """ + Class used representing a dataset in the right format needed by the + `COCOEvaluator` class. + """ + + def __init__(self, targets: _TypeCocoDataset | None = None) -> None: + """ + Constructor of EvaluationDataset object used to evaluate models with + Mean Average Precision. + + Args: + targets: The targets (ground truth) of the dataset in a the + COCO format. + """ + # Initialize members + # Initialize members + self.dataset: _TypeCocoDataset = {} + self.anns: dict[int, _TypeCocoDict] = {} + self.cats: dict[int, _TypeCocoDict] = {} + self.imgs: dict[int, _TypeCocoDict] = {} + self.img_to_anns: dict[int, list[_TypeCocoDict]] = defaultdict(list) + self.cat_to_imgs: dict[int, list[int]] = defaultdict(list) + + if targets is None: + return + + # Load dataset + self.dataset = targets + self.create_class_members() + + @classmethod + def empty(cls) -> EvaluationDataset: + return cls(targets=None) + + def create_class_members(self) -> None: + """ + Create index elements for the dataset. + """ + anns: dict[int, _TypeCocoDict] = {} + cats: dict[int, _TypeCocoDict] = {} + imgs: dict[int, _TypeCocoDict] = {} + img_to_anns: dict[int, list[_TypeCocoDict]] = defaultdict(list) + cat_to_imgs: dict[int, list[int]] = defaultdict(list) + if "annotations" in self.dataset: + for ann in self.dataset["annotations"]: + img_to_anns[ann["image_id"]].append(ann) + anns[ann["id"]] = ann + + if "images" in self.dataset: + for img in self.dataset["images"]: + imgs[img["id"]] = img + + if "categories" in self.dataset: + for cat in self.dataset["categories"]: + cats[cat["id"]] = cat + + if "annotations" in self.dataset and "categories" in self.dataset: + for ann in self.dataset["annotations"]: + cat_to_imgs[ann["category_id"]].append(ann["image_id"]) + + # Populate class members + self.anns = anns + self.img_to_anns = img_to_anns + self.cat_to_imgs = cat_to_imgs + self.imgs = imgs + self.cats = cats + + def get_annotation_ids( + self, + img_ids: list[int] | None = None, + cat_ids: list[int] | None = None, + area_range: tuple[float, float] | None = None, + iscrowd: bool = False, + ) -> list[int]: + """ + Get annotation ids that satisfy given filter conditions. + + Args: + img_ids: ids of the images that we want to retrieve. + cat_ids: ids of the categories that we want to retrieve. + area_range: area range of the annotations that we want to retrieve + in the format [min_area, max_area]. + iscrowd: if annotations to retrieve are `iscrowded=1`. + """ + # If there are no filters, we use all annotations + if not img_ids and not cat_ids and not area_range: + anns = self.dataset["annotations"] + else: + if img_ids: + lists = [ + self.img_to_anns[img_id] + for img_id in img_ids + if img_id in self.img_to_anns + ] + anns = list(itertools.chain.from_iterable(lists)) + else: + anns = self.dataset["annotations"] + + # Filter by category + anns = ( + anns + if not cat_ids + else [ann for ann in anns if ann["category_id"] in cat_ids] + ) + + # Filter by area + anns = ( + anns + if not area_range + else [ + ann for ann in anns if area_range[0] < ann["area"] < area_range[1] + ] + ) + + # Filter by iscrowd + if iscrowd is True: + ids = [ann["id"] for ann in anns if ann["iscrowd"] == 1] + else: + ids = [ann["id"] for ann in anns] + return ids + + def get_category_ids( + self, + cat_names: list[str] | None = None, + supercategory_names: list[str] | None = None, + cat_ids: list[int] | None = None, + ) -> list[int]: + """ + Get category ids that satisfy given filter conditions. + + Args: + cat_names: names of the categories to retrieve. + supercategory_names: names of the supercategories to retrieve. + cat_ids: ids of the categories to retrieve. + + Returns: + ids: integer array of category ids. + """ + # If there are no filters, we use all categories + if not cat_names and not supercategory_names and not cat_ids: + cats = self.dataset["categories"] + else: + cats = self.dataset["categories"] + + # Filter by name + cats = ( + cats + if not cat_names + else [cat for cat in cats if cat["name"] in cat_names] + ) + + # Filter by supercategory + cats = ( + cats + if not supercategory_names + else [ + cat for cat in cats if cat["supercategory"] in supercategory_names + ] + ) + + # Filter by id + cats = ( + cats if not cat_ids else [cat for cat in cats if cat["id"] in cat_ids] + ) + ids = [cat["id"] for cat in cats] + return ids + + def get_image_ids( + self, + img_ids: list[int] | None = None, + cat_ids: list[int] | None = None, + ) -> list[int]: + """ + Get image ids that satisfy given filter conditions. + + Args: + img_ids: ids of the images to retrieve. + cat_ids: ids of the categories to retrieve. + + Returns: + ids: integer array of image ids. + """ + # If there are no filters, we use all images + if not img_ids and not cat_ids: + ids = self.imgs.keys() + return list(ids) + + ids_set = set(img_ids) if img_ids else set() + + if cat_ids: + for i, cat_id in enumerate(cat_ids): + if i == 0 and not ids_set: + ids_set = set(self.cat_to_imgs[cat_id]) + else: + ids_set &= set(self.cat_to_imgs[cat_id]) + + return list(ids_set) + + def get_annotations(self, ids: list[int] | None = None) -> list[_TypeCocoDict]: + """ + Get annotations with the specified ids. + + Args: + ids: integer ids specifying annotations. + + Returns: + anns: loaded annotations. + """ + if ids is None: + return [] + return [self.anns[idx] for idx in ids] + + def load_predictions(self, predictions: list[_TypeCocoDict]) -> EvaluationDataset: + """ + Load prediction result into an EvaluationDataset object. + + Args: + predictions: prediction result. + + Returns: + EvaluationDataset object representing the predictions. + """ + # Create an empty EvaluationDataset object for the predictions + predictions_dataset = EvaluationDataset.empty() + predictions_dataset.dataset["images"] = list(self.dataset["images"]) + + if not isinstance(predictions, list): + raise ValueError("results must be a list") + + # Handle empty predictions + if len(predictions) == 0: + predictions_dataset.dataset["annotations"] = [] + return predictions_dataset + + ids = [pred["image_id"] for pred in predictions] + + # Make sure the image ids from predictions exist in the current dataset. + # A plain ``assert`` would be stripped under ``python -O``, so validate + # this public-input contract with an explicit exception instead. + if not set(ids) <= set(self.get_image_ids()): + raise ValueError("Results do not correspond to current coco set") + + # Check if the predictions contain any unsupported keys + if "caption" in predictions[0]: + raise NotImplementedError( + "Evaluating predictions with caption is not supported." + ) + elif "segmentation" in predictions[0]: + raise NotImplementedError( + "Evaluating predictions with segmentation is not supported." + ) + elif "keypoints" in predictions[0]: + raise NotImplementedError( + "Evaluating predictions with keypoints is not supported." + ) + + elif "bbox" in predictions[0] and not predictions[0]["bbox"] == []: + predictions_dataset.dataset["categories"] = copy.deepcopy( + self.dataset["categories"] + ) + + # Prepare fields for every prediction of the given image + for idx, pred in enumerate(predictions): + x, y, w, h = pred["bbox"] + x1, x2, y1, y2 = [x, x + w, y, y + h] + + # Make segmentation from bounding box coordinates + if "segmentation" not in pred: + pred["segmentation"] = [[x1, y1, x1, y2, x2, y2, x2, y1]] + # Use provided area if available + if "area" not in pred: + pred["area"] = w * h + pred["id"] = idx + 1 + # For predictions we set iscrowd to 0 + pred["iscrowd"] = 0 + predictions_dataset.dataset["annotations"] = predictions + predictions_dataset.create_class_members() + return predictions_dataset + + +# Area ranges for object size in pixels +SMALL_OBJECT_AREA = 32**2 +MEDIUM_OBJECT_AREA = 96**2 +MAX_ALL_OBJECT_AREA = 1e5**2 + +# Smallest number to avoid division by zero +EPS = np.finfo(np.float32).eps + + +def _mask_iou_with_jaccard( + masks_true: list[npt.NDArray[np.bool_]], + masks_detection: list[npt.NDArray[np.bool_]], + is_crowd: list[bool], +) -> npt.NDArray[np.float64]: + """ + Calculate the IoU between detection masks (dt) and ground-truth masks (gt), + following the COCO convention: a detection may match any subregion of a + crowd ground truth, so for crowd rows the union collapses to the detection + area (mask counterpart of `box_iou_batch_with_jaccard`). + + Args: + masks_true: List of ground-truth masks of shape `(H, W)`. + masks_detection: List of detection masks of shape `(H, W)`. + is_crowd: List indicating if each ground-truth mask is a crowd region. + + Returns: + Array of IoU values of shape `(len(masks_detection), len(masks_true))`. + """ + if len(masks_detection) == 0 or len(masks_true) == 0: + return np.empty((len(masks_detection), len(masks_true)), dtype=np.float64) + + gt_masks = np.stack(masks_true).astype(bool) + dt_masks = np.stack(masks_detection).astype(bool) + crowd = np.asarray(is_crowd, dtype=bool) + + # Compute base IoU via the optimised path (float32 + memory-chunked). + # mask_iou_batch returns (gt, dt); the evaluator expects (dt, gt). + iou: npt.NDArray[np.float64] = mask_iou_batch(gt_masks, dt_masks).T.astype( + np.float64 + ) + + if not np.any(crowd): + return iou + + # Override crowd columns: COCO convention collapses the union to the + # detection area, so a small detection inside a large crowd region scores + # IoU โ‰ˆ 1. Recompute only the crowd columns to avoid a full float64 matmul. + eps = np.spacing(1) + crowd_idx = np.where(crowd)[0] + gt_flat = gt_masks[crowd_idx].reshape(len(crowd_idx), -1).astype(np.float32) + dt_flat = dt_masks.reshape(dt_masks.shape[0], -1).astype(np.float32) + area_inter = (dt_flat @ gt_flat.T).astype(np.float64) # (dt, N_crowd) + area_dt = dt_flat.sum(axis=1).astype(np.float64) # (dt,) + iou[:, crowd_idx] = area_inter / (area_dt[:, None] + eps) + return iou + + +class ObjectSize(Enum): + """ + Enum for object size. + """ + + ALL = "all" + SMALL = "small" + MEDIUM = "medium" + LARGE = "large" + + +class COCOEvaluatorParameters: + """ + Parameters for COCOEvaluator + """ + + def __init__(self) -> None: + """Initialize all parameters for evaluation""" + + self.img_ids: list[int] = [] + self.cat_ids: list[int] = [] + + # IoU thresholds [0.5, 0.55, 0.6, 0.65, ..., 0.95] + self.iou_thrs = np.linspace( + 0.5, + 0.95, + int(np.round((0.95 - 0.5) / 0.05)) + 1, + endpoint=True, + dtype=np.float32, + ) + # 101 recall thresholds [0.0, 0.01, 0.02, ..., 1.00] + self.rec_thrs = np.linspace( + 0.0, + 1.00, + int(np.round((1.00 - 0.0) / 0.01)) + 1, + endpoint=True, + dtype=np.float32, + ) + # 3 maximum detection thresholds [1, 10, 100] + self.max_dets = [1, 10, 100] + # Area ranges [0, 1e5], [0, 32], [32, 96], [96, 1e5] + self.area_range: list[list[float]] = [ + [0, MAX_ALL_OBJECT_AREA], + [0, SMALL_OBJECT_AREA], + [SMALL_OBJECT_AREA, MEDIUM_OBJECT_AREA], + [MEDIUM_OBJECT_AREA, MAX_ALL_OBJECT_AREA], + ] + + +class COCOEvaluator: + """ + Evaluator class to compute COCO metrics. + """ + + def __init__( + self, + coco_targets: EvaluationDataset, + coco_predictions: EvaluationDataset, + metric_target: MetricTarget = MetricTarget.BOXES, + ) -> None: + """ + Constructor of COCOEvaluator object. + + Args: + coco_targets: The dataset with the ground truths. + coco_predictions: The dataset with the predictions. + metric_target: The type of detection data used to compute the IoU - + boxes, masks or oriented bounding boxes. + """ + if coco_targets is None: + raise ValueError("coco_targets must be provided") + if coco_predictions is None: + raise ValueError("coco_predictions must be provided") + + self.coco_targets = coco_targets + self.coco_predictions = coco_predictions + self.metric_target = metric_target + # List of dictionaries containing the evaluation results + # len(eval_imgs) = (categories) * (area_ranges) * (images) + # For COCO 2017: len(eval_images) = 80 * 4 * 5000 = 1600000 + self.eval_imgs: list[_TypeEvaluationImageResult | None] = [] + # Dictionary of accumulated results + self.results: dict[str, object] = {} + # Dictionary of targets for evaluation + self._targets: defaultdict[tuple[int, int], list[_TypeCocoDict]] = defaultdict( + list + ) + self._predictions: defaultdict[tuple[int, int], list[_TypeCocoDict]] = ( + defaultdict(list) + ) + # Parameters for evaluation + self.params = COCOEvaluatorParameters() + # List of results summarization + self.stats: list[object] = [] + # Dictionary of IOUs between all targets and predictions + self.ious: dict[tuple[int, int], npt.NDArray[np.float32]] = {} + # Set image and category ids + self.params.img_ids = sorted(self.coco_targets.get_image_ids()) + self.params.cat_ids = sorted(self.coco_targets.get_category_ids()) + + def _prepare_targets_and_predictions(self) -> None: + """ + Prepare targets and predictions for evaluation. + """ + # Get the target samples for the evaluation + annotation_ids = self.coco_targets.get_annotation_ids( + img_ids=self.params.img_ids, cat_ids=self.params.cat_ids + ) + targets = self.coco_targets.get_annotations(annotation_ids) + # Get the prediction samples for the evaluation + prediction_ids = self.coco_predictions.get_annotation_ids( + img_ids=self.params.img_ids, cat_ids=self.params.cat_ids + ) + predictions = self.coco_predictions.get_annotations(prediction_ids) + + # Set ignore flag + for gt in targets: + ignore = int(gt.get("ignore", 0)) + iscrowd = int(gt.get("iscrowd", 0)) + gt["ignore"] = int(bool(ignore or iscrowd)) + + # Select targets + self._targets = defaultdict(list) + for gt in targets: + self._targets[gt["image_id"], gt["category_id"]].append(gt) + + # Select predictions + self._predictions = defaultdict(list) + for dt in predictions: + self._predictions[dt["image_id"], dt["category_id"]].append(dt) + + # Initialize evaluation results + self.eval_imgs = [] + self.results = {} + + def _compute_iou(self, img_id: int, cat_id: int) -> npt.NDArray[np.float32]: + """ + Compute the IoU between the targets and predictions for a given image and + category, using boxes, masks or oriented bounding boxes depending on the + configured metric target. + + Args: + img_id: The image id. + cat_id: The category id. + + Returns: + The IoU between the targets and predictions. + """ + + gt = self._targets[img_id, cat_id] + dt = self._predictions[img_id, cat_id] + + # If there is nothing to evaluate + if len(gt) == 0 and len(dt) == 0: + empty_result: npt.NDArray[np.float32] = np.array([], dtype=np.float32) + return empty_result + + # Sort predictions by highest score first + inds = np.argsort([-d["score"] for d in dt], kind="stable") + dt = [dt[i] for i in inds] + + # Truncate the predictions if there are more predictions than the max detections + # to evaluate + if len(dt) > self.params.max_dets[-1]: + dt = dt[0 : self.params.max_dets[-1]] + + # Get the iscrowd flag for each gt + is_crowd = [bool(o["iscrowd"]) for o in gt] + + # Compute iou between each prediction and gt region + if self.metric_target == MetricTarget.MASKS: + iou = _mask_iou_with_jaccard( + [g["content"] for g in gt], [d["content"] for d in dt], is_crowd + ) + elif self.metric_target == MetricTarget.ORIENTED_BOUNDING_BOXES: + # Crowd regions are not supported for oriented boxes; the standard + # IoU is used for every ground truth. + if len(gt) == 0 or len(dt) == 0: + iou = np.empty((len(dt), len(gt)), dtype=np.float64) + else: + gt_obb = np.stack([g["content"] for g in gt]) + dt_obb = np.stack([d["content"] for d in dt]) + # oriented_box_iou_batch returns (gt, dt); + # the evaluator expects (dt, gt). + iou = oriented_box_iou_batch(gt_obb, dt_obb).T.astype(np.float64) + else: + gt_boxes = [g["bbox"] for g in gt] + dt_boxes = [d["bbox"] for d in dt] + iou = box_iou_batch_with_jaccard(gt_boxes, dt_boxes, is_crowd) + return iou.astype(np.float32) + + def _evaluate_image( + self, + img_id: int, + cat_id: int, + area_range: list[float] | tuple[float, float], + max_det: int, + ) -> _TypeEvaluationImageResult | None: + """ + Perform evaluation for single category and image. + Args: + img_id: The image id. + cat_id: The category id. + area_range: The area range. + max_det: The maximum number of detections. + + Returns: + The evaluation results. + """ + # Get targets (gt) and predictions (dt) for the given image and category + gt: list[_TypeCocoDict] = self._targets[img_id, cat_id] + dt: list[_TypeCocoDict] = self._predictions[img_id, cat_id] + + # If there is nothing to evaluate + if len(gt) == 0 and len(dt) == 0: + return None + + min_area, max_area = area_range + + # Create an `_ignore` flag for targets if they are set as ignore or their area + # is not in the range [min_area, max_area] + for g in gt: + if g["ignore"] or not (min_area <= g["area"] <= max_area): + g["_ignore"] = 1 + else: + g["_ignore"] = 0 + + # Sort ground-truths by ignore flag (0: non ignored, 1: ignored) + gt_sorted = np.argsort([g["_ignore"] for g in gt], kind="stable") + gt = [gt[i] for i in gt_sorted] + + # Sort predictions by scores in descending order + dt_sorted = np.argsort([-d["score"] for d in dt], kind="stable") + dt = [dt[i] for i in dt_sorted[0:max_det]] + + # Load computed ious for the given image and category + ious = ( + self.ious[img_id, cat_id][:, gt_sorted] + if len(self.ious[img_id, cat_id]) > 0 + else self.ious[img_id, cat_id] + ) + + # Get the number of thresholds, ground truths and detections + num_thresholds = len(self.params.iou_thrs) + num_ground_truths = len(gt) + num_detections = len(dt) + + # Initialize matches: 0 means no match + gt_matches = np.zeros((num_thresholds, num_ground_truths), dtype=np.int64) + dt_matches = np.zeros((num_thresholds, num_detections), dtype=np.int64) + # Initialize ignore flags: 0 means no ignore + gt_ignore = np.array([g["_ignore"] for g in gt], dtype=np.int64) + dt_ignore = np.zeros((num_thresholds, num_detections), dtype=np.bool_) + if len(ious) != 0: + # Go through the iou thresholds + for tresh_idx, thresh in enumerate(self.params.iou_thrs): + # Go through the detections + for det_idx, det in enumerate(dt): + # Start the iou of the best match + iou_best_match = min([thresh, 1 - 1e-10]) + # Set the best match index to -1 (unmatched) + best_match_idx = -1 + # Go through the ground truths + for g_idx, g in enumerate(gt): + # If current gt is already matched, and not a crowd, continue + # if gt_matches[tresh_idx, g_idx] > 0 and not iscrowd[g_idx]: + iscrowd = int(g.get("iscrowd", 0)) + if gt_matches[tresh_idx, g_idx] > 0 and not iscrowd: + continue + # Stop searching the ground truths + if ( + best_match_idx > -1 # detection is matched to a gt + and gt_ignore[best_match_idx] + == 0 # matched gt is not ignored + and gt_ignore[g_idx] == 1 # current gt is ignored + ): + break + + # A new best match was found + if ious[det_idx, g_idx] >= iou_best_match: + iou_best_match = ious[det_idx, g_idx] + best_match_idx = g_idx + + # A best match was found + if best_match_idx != -1: + dt_ignore[tresh_idx, det_idx] = gt_ignore[best_match_idx] + dt_matches[tresh_idx, det_idx] = gt[best_match_idx]["id"] + gt_matches[tresh_idx, best_match_idx] = det["id"] + + # Set unmatched detections outside of area range to ignore + area_range_mask = np.array( + [d["area"] < min_area or d["area"] > max_area for d in dt] + ).reshape((1, len(dt))) + + # Update the ignore flags for detections + dt_ignore = np.logical_or( + dt_ignore, + np.logical_and( + dt_matches == 0, np.repeat(area_range_mask, num_thresholds, 0) + ), + ) + + return { + "image_id": img_id, + "category_id": cat_id, + "area_range": area_range, + "max_det": max_det, + "dt_ids": [d["id"] for d in dt], + "gt_ids": [g["id"] for g in gt], + "dtMatches": dt_matches, + "gtMatches": gt_matches, + "dtScores": [d["score"] for d in dt], + "gtIgnore": gt_ignore, + "dtIgnore": dt_ignore, + } + + def _accumulate(self) -> None: + """ + Accumulate per image evaluation results and store the result in self.results + """ + # Get the number of thresholds, categories, area ranges, and max detections + num_iou_thresholds = len(self.params.iou_thrs) + num_recall_thresholds = len(self.params.rec_thrs) + num_categories = len(self.params.cat_ids) + num_area_ranges = len(self.params.area_range) + num_max_detections = len(self.params.max_dets) + num_imgs = len(self.params.img_ids) + + # Initialize precision, recall, and scores arrays + # -1 means absent categories + precision = -np.ones( + ( + num_iou_thresholds, + num_recall_thresholds, + num_categories, + num_area_ranges, + num_max_detections, + ), + dtype=np.float32, + ) + recall = -np.ones( + (num_iou_thresholds, num_categories, num_area_ranges, num_max_detections), + dtype=np.float32, + ) + scores = -np.ones( + ( + num_iou_thresholds, + num_recall_thresholds, + num_categories, + num_area_ranges, + num_max_detections, + ), + dtype=np.float32, + ) + + # Create sets for indexing + set_categories = set(self.params.cat_ids) + set_area_ranges: set[tuple[float, ...]] = { + tuple(a) for a in self.params.area_range + } + set_max_detections = set(self.params.max_dets) + set_image_ids = set(self.params.img_ids) + + # Select category indexes to evaluate + selected_category_ids = [ + n for n, k in enumerate(self.params.cat_ids) if k in set_categories + ] + # Select max detections to evaluate + selected_max_detections = [ + m for m in self.params.max_dets if m in set_max_detections + ] + # Select area ranges to evaluate + selected_area_ranges_ids = [ + idx + for idx, area in enumerate(self.params.area_range) + if tuple(area) in set_area_ranges + ] + # Select image indexes to evaluate + image_inds = [ + n for n, i in enumerate(self.params.img_ids) if i in set_image_ids + ] + + # Evaluating at all categories, area ranges, max number of detections, and + # IoU thresholds + + # Loop through categories + for cat_idx, cat_eval_idx in enumerate(selected_category_ids): + cat_offset = cat_eval_idx * num_area_ranges * num_imgs + + # Loop through area ranges + for area_idx, area_eval_idx in enumerate(selected_area_ranges_ids): + area_offset = area_eval_idx * num_imgs + + # Loop through max detections + for max_det_idx, max_det in enumerate(selected_max_detections): + eval_img_data_raw = [ + self.eval_imgs[cat_offset + area_offset + i] for i in image_inds + ] + eval_img_data: list[_TypeEvaluationImageResult] = [ + e for e in eval_img_data_raw if e is not None + ] + + # No image to evaluate + if len(eval_img_data) == 0: + continue + + # Sort detected scores in descending order + dt_scores = np.concatenate( + [e["dtScores"][0:max_det] for e in eval_img_data] + ) + inds = np.argsort(-dt_scores, kind="stable") + dt_scores_sorted = dt_scores[inds] + + # Get matches and ignored matches + dt_matches = np.concatenate( + [e["dtMatches"][:, 0:max_det] for e in eval_img_data], axis=1 + )[:, inds] + dt_ignored = np.concatenate( + [e["dtIgnore"][:, 0:max_det] for e in eval_img_data], axis=1 + )[:, inds] + + # Get ignored ground truth objects + gt_ignored = np.concatenate([e["gtIgnore"] for e in eval_img_data]) + num_non_ignored_gt = np.count_nonzero(gt_ignored == 0) + + # No ground truth objects to evaluate + if num_non_ignored_gt == 0: + continue + + # Compute true positives and false positives + true_positives = np.logical_and( + dt_matches, np.logical_not(dt_ignored) + ) + false_positives = np.logical_and( + np.logical_not(dt_matches), np.logical_not(dt_ignored) + ) + + tp_sum = np.cumsum(true_positives, axis=1).astype(dtype=np.float32) + fp_sum = np.cumsum(false_positives, axis=1).astype(dtype=np.float32) + + # Loop through thresholds + for iou_thresh_idx, (tp, fp) in enumerate(zip(tp_sum, fp_sum)): + tp = np.array(tp) + fp = np.array(fp) + num_tps = len(tp) + # Recall: TP / Total number of ground truth objects + rc = tp / np.float32(num_non_ignored_gt) + # Precision: TP / (FP + TP) + pr = (tp / (fp + tp + EPS)).tolist() + # List to compute the precision at each recall threshold + precision_at_recall = [0.0] * num_recall_thresholds + # List to compute the score at each recall threshold + score_at_recall = [0.0] * num_recall_thresholds + + # Set recall to either the final recall value or 0 (when there + # is no TP) + recall[iou_thresh_idx, cat_idx, area_idx, max_det_idx] = ( + rc[-1] if num_tps else 0 + ) + + # Loop through precision values + for i in range(num_tps - 1, 0, -1): + if pr[i] > pr[i - 1]: + pr[i - 1] = pr[i] + + recall_inds: npt.NDArray[np.int_] = np.searchsorted( + rc, self.params.rec_thrs, side="left" + ) + recall_inds_list: list[int] = recall_inds.tolist() + for ri, pos_idx_value in enumerate(recall_inds_list): + # Ensure pi is within the range of both arrays + pos_idx_int: int = int(pos_idx_value) + if 0 <= pos_idx_int < len(pr) and 0 <= pos_idx_int < len( + dt_scores_sorted + ): + precision_at_recall[ri] = pr[pos_idx_int] + score_at_recall[ri] = dt_scores_sorted[pos_idx_int] + + # Convert precision to numpy array + precision[iou_thresh_idx, :, cat_idx, area_idx, max_det_idx] = ( + np.array(precision_at_recall, dtype=np.float32) + ) + # Convert scores to numpy array + scores[iou_thresh_idx, :, cat_idx, area_idx, max_det_idx] = ( + np.array(score_at_recall, dtype=np.float32) + ) + + self.results = { + "params": self.params, + "counts": [ + num_iou_thresholds, + num_recall_thresholds, + num_categories, + num_area_ranges, + num_max_detections, + ], + "date": datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S"), + "precision": precision, + "recall": recall, + "scores": scores, + } + + # Helper function to compute average precision while handling -1 sentinel values + def compute_average_precision( + precision_slice: npt.NDArray[np.float32], + ) -> tuple[npt.NDArray[np.float64], npt.NDArray[np.float64]]: + """Compute average precision while handling -1 sentinel values.""" + valid_mask = precision_slice != -1 + valid_precision = np.where(valid_mask, precision_slice, np.float32(0.0)) + + def mean_with_mask( + axis: int | tuple[int, ...], + ) -> npt.NDArray[np.float64]: + sums = valid_precision.sum(axis=axis, dtype=np.float64) + counts = valid_mask.sum(axis=axis) + means: npt.NDArray[np.float64] = np.divide( + sums, + counts, + out=np.full(sums.shape, -1.0, dtype=np.float64), + where=counts > 0, + ) + return means + + mAP_scores = mean_with_mask((1, 2)) + ap_per_class = mean_with_mask(1).transpose(1, 0) + return mAP_scores, ap_per_class + + # Average precision over all sizes, 100 max detections + area_range_idx = list(ObjectSize).index(ObjectSize.ALL) + max_100_dets_idx = self.params.max_dets.index(100) + # Average precision [threshold, recall, classes] + average_precision_all_sizes = precision[ + :, :, :, area_range_idx, max_100_dets_idx + ] + # mAP over thresholds (dimension=num_thresholds) + # Exclude -1 sentinel values when computing mean + mAP_scores_all_sizes, ap_per_class_all_sizes = compute_average_precision( + average_precision_all_sizes + ) + + # Average precision for SMALL objects and 100 max detections + small_area_range_idx = list(ObjectSize).index(ObjectSize.SMALL) + average_precision_small = precision[ + :, :, :, small_area_range_idx, max_100_dets_idx + ] + mAP_scores_small, ap_per_class_small = compute_average_precision( + average_precision_small + ) + + # Average precision for MEDIUM objects and 100 max detections + medium_area_range_idx = list(ObjectSize).index(ObjectSize.MEDIUM) + average_precision_medium = precision[ + :, :, :, medium_area_range_idx, max_100_dets_idx + ] + mAP_scores_medium, ap_per_class_medium = compute_average_precision( + average_precision_medium + ) + + # Average precision for LARGE objects and 100 max detections + large_area_range_idx = list(ObjectSize).index(ObjectSize.LARGE) + average_precision_large = precision[ + :, :, :, large_area_range_idx, max_100_dets_idx + ] + mAP_scores_large, ap_per_class_large = compute_average_precision( + average_precision_large + ) + + self.results = { + "params": self.params, + "counts": [ + num_iou_thresholds, + num_recall_thresholds, + num_categories, + num_area_ranges, + num_max_detections, + ], + "date": datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S"), + "precision": precision, + "recall": recall, + "scores": scores, + "mAP_scores_all_sizes": mAP_scores_all_sizes, + "ap_per_class_all_sizes": ap_per_class_all_sizes, + "mAP_scores_small": mAP_scores_small, + "ap_per_class_small": ap_per_class_small, + "mAP_scores_medium": mAP_scores_medium, + "ap_per_class_medium": ap_per_class_medium, + "mAP_scores_large": mAP_scores_large, + "ap_per_class_large": ap_per_class_large, + } + + def _pycocotools_summarize(self) -> None: + """ + Compute and display summary metrics for evaluation results. + """ + + def _summarize( + use_ap: bool = True, + iou_thr: float | None = None, + area_range: ObjectSize = ObjectSize.ALL, + max_dets: int = 100, + ) -> float: + iStr = " {:<18} {} @[ IoU={:<9} | area={:>6s} | maxDets={:>3d} ] = {:0.10f}" + titleStr = "Average Precision" if use_ap else "Average Recall" + typeStr = "(AP)" if use_ap else "(AR)" + iou_str = ( + f"{self.params.iou_thrs[0]:0.2f}:{self.params.iou_thrs[-1]:0.2f}" + if iou_thr is None + else f"{iou_thr:0.2f}" + ) + all_object_sizes = list(ObjectSize) + area_range_idx = all_object_sizes.index(area_range) + max_detections_idx = self.params.max_dets.index(max_dets) + if use_ap: + # Dimension of precision: + # threshold x recall x classes x areas x max detections + s: npt.NDArray[np.float32] = np.asarray( + self.results["precision"], dtype=np.float32 + ) + # IOU + if iou_thr is not None: + t = np.where(iou_thr == self.params.iou_thrs)[0] + s = s[t] + s = s[:, :, :, area_range_idx, max_detections_idx] + else: + # Dimension of recall: + # threshold x classes x areas x max detections + s = np.asarray(self.results["recall"], dtype=np.float32) + if iou_thr is not None: + t = np.where(iou_thr == self.params.iou_thrs)[0] + s = s[t] + s = s[:, :, area_range_idx, max_detections_idx] + if len(s[s > -1]) == 0: + mean_s = -1.0 + else: + mean_s = float(np.mean(s[s > -1])) + logger.info( + iStr.format(titleStr, typeStr, iou_str, area_range, max_dets, mean_s) + ) + return mean_s + + def _summarize_predictions() -> npt.NDArray[np.float32]: + stats: npt.NDArray[np.float32] = np.zeros((12,), dtype=np.float32) + stats[0] = _summarize(use_ap=True) + stats[1] = _summarize( + use_ap=True, iou_thr=0.5, max_dets=self.params.max_dets[2] + ) + stats[2] = _summarize( + use_ap=True, iou_thr=0.75, max_dets=self.params.max_dets[2] + ) + stats[3] = _summarize( + use_ap=True, + area_range=ObjectSize.SMALL, + max_dets=self.params.max_dets[2], + ) + stats[4] = _summarize( + use_ap=True, + area_range=ObjectSize.MEDIUM, + max_dets=self.params.max_dets[2], + ) + stats[5] = _summarize( + use_ap=True, + area_range=ObjectSize.LARGE, + max_dets=self.params.max_dets[2], + ) + stats[6] = _summarize(use_ap=False, max_dets=self.params.max_dets[0]) + stats[7] = _summarize(use_ap=False, max_dets=self.params.max_dets[1]) + stats[8] = _summarize(use_ap=False, max_dets=self.params.max_dets[2]) + stats[9] = _summarize( + use_ap=False, + area_range=ObjectSize.SMALL, + max_dets=self.params.max_dets[2], + ) + stats[10] = _summarize( + use_ap=False, + area_range=ObjectSize.MEDIUM, + max_dets=self.params.max_dets[2], + ) + stats[11] = _summarize( + use_ap=False, + area_range=ObjectSize.LARGE, + max_dets=self.params.max_dets[2], + ) + return stats + + if len(self.results) != 0: + self.stats = _summarize_predictions().tolist() + + def evaluate(self) -> None: + """ + Start the per image evaluation on all images and keeep results in + self.eval_imgs (a list of dictionaries). + """ + # Select all parameters to evaluate + self.params.img_ids = list(np.unique(self.params.img_ids)) + self.params.cat_ids = list(np.unique(self.params.cat_ids)) + self.params.max_dets = sorted(self.params.max_dets) + + self._prepare_targets_and_predictions() + + # Compute IOUs between all targets and predictions for all images and categories + self.ious = { + (img_id, cat_id): self._compute_iou(img_id, cat_id) + for img_id in self.params.img_ids + for cat_id in self.params.cat_ids + } + + # Select the largest max area (the last element containing 100 dets + max_det = self.params.max_dets[-1] + + # Evaluate each image with all categories, area range and max detections + self.eval_imgs = [ + self._evaluate_image(img_id, cat_id, area_range, max_det) + for cat_id in self.params.cat_ids + for area_range in self.params.area_range + for img_id in self.params.img_ids + ] + + # Accumulate results + self._accumulate() + + +class MeanAveragePrecision(Metric[MeanAveragePrecisionResult]): + """ + Mean Average Precision (mAP) is a metric used to evaluate object detection models. + It is the average of the precision-recall curves at different IoU thresholds. + + Examples: + ```pycon + >>> import numpy as np + >>> import supervision as sv + >>> from supervision.metrics import MeanAveragePrecision + >>> predictions = sv.Detections( + ... xyxy=np.array([[0, 0, 10, 10]]), + ... class_id=np.array([0]), + ... confidence=np.array([0.9]) + ... ) + >>> targets = sv.Detections( + ... xyxy=np.array([[0, 0, 10, 10]]), + ... class_id=np.array([0]) + ... ) + >>> map_metric = MeanAveragePrecision() + >>> map_result = map_metric.update(predictions, targets).compute() + >>> round(float(map_result.map50), 2) + 1.0 + >>> print(map_result) + Average Precision (AP) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 1.000 + Average Precision (AP) @[ IoU=0.50 | area= all | maxDets=100 ] = 1.000 + Average Precision (AP) @[ IoU=0.75 | area= all | maxDets=100 ] = 1.000 + Average Precision (AP) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 1.000 + Average Precision (AP) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = -1.000 + Average Precision (AP) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = -1.000 + + ``` + + ![example_plot]( + https://media.roboflow.com/supervision-docs/metrics/mAP_plot_example.png + ){ align=center width="800" } + """ + + def __init__( + self, + metric_target: MetricTarget = MetricTarget.BOXES, + class_agnostic: bool = False, + class_mapping: dict[int, int] | None = None, + image_indices: list[int] | None = None, + ) -> None: + """ + Initialize the Mean Average Precision metric. + + Args: + metric_target: The type of detection data to use. + class_agnostic: Whether to treat all data as a single class. + class_mapping: A dictionary to map class IDs to new IDs. + image_indices: The indices of the images to use. + """ + self._metric_target = metric_target + self._class_agnostic = class_agnostic + + self._predictions_list: list[Detections] = [] + self._targets_list: list[Detections] = [] + self._class_mapping = class_mapping + self._image_indices = image_indices + + def reset(self) -> None: + """ + Reset the metric to its initial state, clearing all stored data. + """ + self._predictions_list = [] + self._targets_list = [] + + def update( + self, + predictions: Detections | list[Detections], + targets: Detections | list[Detections], + ) -> MeanAveragePrecision: + """ + Add new predictions and targets to the metric, but do not compute the result. + + Args: + predictions: The predicted detections. + targets: The ground-truth detections. + + Returns: + The updated metric instance. + """ + if not isinstance(predictions, list): + predictions = [predictions] + if not isinstance(targets, list): + targets = [targets] + + if len(predictions) != len(targets): + raise ValueError( + f"The number of predictions ({len(predictions)}) and" + f" targets ({len(targets)}) during the update must be the same." + ) + + if self._class_agnostic: + predictions = deepcopy(predictions) + targets = deepcopy(targets) + + for prediction in predictions: + if prediction.class_id is not None: + prediction.class_id[:] = -1 + for target in targets: + if target.class_id is not None: + target.class_id[:] = -1 + + self._predictions_list.extend(predictions) + self._targets_list.extend(targets) + + return self + + def _detections_content(self, detections: Detections) -> npt.NDArray[Any] | None: + """Return per-detection masks or oriented boxes for the metric target, + or `None` for the box target and for empty detections.""" + if self._metric_target == MetricTarget.BOXES or len(detections) == 0: + return None + if self._metric_target == MetricTarget.MASKS: + if detections.mask is None: + raise ValueError( + "MeanAveragePrecision with `MetricTarget.MASKS` requires" + " masks on both predictions and targets." + ) + return np.asarray(detections.mask).astype(bool) + if self._metric_target == MetricTarget.ORIENTED_BOUNDING_BOXES: + obb = detections.data.get(ORIENTED_BOX_COORDINATES) + if obb is None: + raise ValueError( + "MeanAveragePrecision with" + " `MetricTarget.ORIENTED_BOUNDING_BOXES` requires" + f" `{ORIENTED_BOX_COORDINATES}` in `data` on both" + " predictions and targets." + ) + return np.asarray(obb, dtype=np.float32).reshape(-1, 4, 2) + raise ValueError(f"Invalid metric target: {self._metric_target}") + + def _content_area( + self, xywh: list[float], content: npt.NDArray[Any] | None, idx: int + ) -> float: + """Compute the default annotation area for the metric target: bbox area + for boxes, pixel count for masks, polygon area for oriented boxes.""" + if content is None: + return float(xywh[2] * xywh[3]) + if self._metric_target == MetricTarget.MASKS: + return float(np.count_nonzero(content[idx])) + x, y = content[idx, :, 0], content[idx, :, 1] + # Shoelace formula + return float(0.5 * abs(np.sum(x * np.roll(y, -1) - np.roll(x, -1) * y))) + + def _prepare_targets( + self, targets: list[Detections] + ) -> dict[str, list[_TypeCocoDict]]: + """Transform targets into a dictionary that can be used by the COCO evaluator""" + images: list[_TypeCocoDict] = [{"id": img_id} for img_id in range(len(targets))] + if self._image_indices is not None: + images = [{"id": self._image_indices[img["id"]]} for img in images] + # Annotations list + annotations: list[_TypeCocoDict] = [] + for image_id, image_targets in enumerate(targets): + if self._image_indices is not None: + image_id = self._image_indices[image_id] + + # Ensure xyxy is not None + if image_targets.xyxy is None: + continue + + content = self._detections_content(image_targets) + for target_idx, xyxy in enumerate(image_targets.xyxy): + xywh = [xyxy[0], xyxy[1], xyxy[2] - xyxy[0], xyxy[3] - xyxy[1]] + + # Default values + category_id = 0 + + if image_targets.class_id is not None: + cls_id = image_targets.class_id[target_idx] + if self._class_mapping is not None: + category_id = self._class_mapping[int(cls_id)] + else: + category_id = int(cls_id) + + # Use area from data if available, otherwise calculate from the + # metric target content (bbox, mask or oriented box) + area = None + if image_targets.data is not None and "area" in image_targets.data: + area_data: npt.NDArray[np.float32] = np.asarray( + image_targets.data["area"], dtype=np.float32 + ) + area = float(area_data[target_idx]) + + if area is None: + area = self._content_area(xywh, content, target_idx) + + iscrowd = 0 + if image_targets.data is not None and "iscrowd" in image_targets.data: + iscrowd_data: npt.NDArray[np.int64] = np.asarray( + image_targets.data["iscrowd"], dtype=np.int64 + ) + iscrowd = int(iscrowd_data[target_idx]) + + ignore = 0 + if image_targets.data is not None and "ignore" in image_targets.data: + ignore_data: npt.NDArray[np.int64] = np.asarray( + image_targets.data["ignore"], dtype=np.int64 + ) + ignore = int(ignore_data[target_idx]) + + dict_annotation: _TypeCocoDict = { + "area": area, + "iscrowd": iscrowd, + "image_id": image_id, + "bbox": xywh, + "category_id": category_id, + "id": len(annotations) + 1, # Start IDs from 1 (0 means no match) + "ignore": ignore, + } + if content is not None: + dict_annotation["content"] = content[target_idx] + annotations.append(dict_annotation) + # Category list + all_cat_ids = {annotation["category_id"] for annotation in annotations} + categories: list[_TypeCocoDict] = [{"id": cat_id} for cat_id in all_cat_ids] + # Create coco dictionary + return { + "images": images, + "annotations": annotations, + "categories": categories, + } + + def _prepare_predictions( + self, predictions: list[Detections] + ) -> list[_TypeCocoDict]: + """Transform predictions into a list of predictions that can be used by the COCO + evaluator.""" + coco_predictions: list[_TypeCocoDict] = [] + for image_id, image_predictions in enumerate(predictions): + if self._image_indices is not None: + image_id = self._image_indices[image_id] + + if image_predictions.xyxy is None: + continue + + content = self._detections_content(image_predictions) + for pred_idx, xyxy in enumerate(image_predictions.xyxy): + xywh = [xyxy[0], xyxy[1], xyxy[2] - xyxy[0], xyxy[3] - xyxy[1]] + + category_id = 0 + score = 0.0 + + if image_predictions.class_id is not None: + cls_id = image_predictions.class_id[pred_idx] + if self._class_mapping is not None: + category_id = self._class_mapping[int(cls_id)] + else: + category_id = int(cls_id) + + if image_predictions.confidence is not None: + score = float(image_predictions.confidence[pred_idx]) + + # Use area from data if available, otherwise calculate from the + # metric target content (bbox, mask or oriented box) + area = None + if ( + image_predictions.data is not None + and "area" in image_predictions.data + ): + area_data: npt.NDArray[np.float32] = np.asarray( + image_predictions.data["area"], dtype=np.float32 + ) + area = float(area_data[pred_idx]) + + if area is None: + area = self._content_area(xywh, content, pred_idx) + + dict_prediction: _TypeCocoDict = { + "image_id": image_id, + "bbox": xywh, + "score": score, + "category_id": category_id, + "area": area, + "id": len(coco_predictions) + 1, + } + if content is not None: + dict_prediction["content"] = content[pred_idx] + coco_predictions.append(dict_prediction) + return coco_predictions + + def compute(self) -> MeanAveragePrecisionResult: + """ + Calculate Mean Average Precision based on predicted and ground-truth + detections at different thresholds using the COCO evaluation metrics. + Source: https://github.com/rafaelpadilla/review_object_detection_metrics + + Returns: + The Mean Average Precision result. + """ + total_images_predictions = len(self._predictions_list) + total_images_targets = len(self._targets_list) + + if total_images_predictions != total_images_targets: + raise ValueError( + f"The number of predictions ({total_images_predictions}) and" + f" targets ({total_images_targets}) during the evaluation must be" + " the same." + ) + dict_targets = self._prepare_targets(self._targets_list) + lst_predictions = self._prepare_predictions(self._predictions_list) + # Create a coco object with the targets + coco_gt = EvaluationDataset(targets=dict_targets) + # Include the predictions to coco object + coco_det = coco_gt.load_predictions(lst_predictions) + # Create a coco evaluator with the predictions + cocoEval = COCOEvaluator(coco_gt, coco_det, metric_target=self._metric_target) + + # Evaluate on all images + cocoEval.evaluate() + + # Create MeanAveragePrecisionResult object for small objects + mAP_small = MeanAveragePrecisionResult( + metric_target=self._metric_target, + is_class_agnostic=self._class_agnostic, + mAP_scores=np.asarray( + cocoEval.results["mAP_scores_small"], dtype=np.float64 + ), + ap_per_class=np.asarray( + cocoEval.results["ap_per_class_small"], dtype=np.float64 + ), + iou_thresholds=np.asarray(cocoEval.params.iou_thrs, dtype=np.float64), + matched_classes=np.asarray(cocoEval.params.cat_ids, dtype=np.int32), + ) + # Create MeanAveragePrecisionResult object for medium objects + mAP_medium = MeanAveragePrecisionResult( + metric_target=self._metric_target, + is_class_agnostic=self._class_agnostic, + mAP_scores=np.asarray( + cocoEval.results["mAP_scores_medium"], dtype=np.float64 + ), + ap_per_class=np.asarray( + cocoEval.results["ap_per_class_medium"], dtype=np.float64 + ), + iou_thresholds=np.asarray(cocoEval.params.iou_thrs, dtype=np.float64), + matched_classes=np.asarray(cocoEval.params.cat_ids, dtype=np.int32), + ) + # Create MeanAveragePrecisionResult object for large objects + mAP_large = MeanAveragePrecisionResult( + metric_target=self._metric_target, + is_class_agnostic=self._class_agnostic, + mAP_scores=np.asarray( + cocoEval.results["mAP_scores_large"], dtype=np.float64 + ), + ap_per_class=np.asarray( + cocoEval.results["ap_per_class_large"], dtype=np.float64 + ), + iou_thresholds=np.asarray(cocoEval.params.iou_thrs, dtype=np.float64), + matched_classes=np.asarray(cocoEval.params.cat_ids, dtype=np.int32), + ) + + # Create the final MeanAveragePrecisionResult object + mAP_result = MeanAveragePrecisionResult( + metric_target=self._metric_target, + is_class_agnostic=self._class_agnostic, + mAP_scores=np.asarray( + cocoEval.results["mAP_scores_all_sizes"], dtype=np.float64 + ), + ap_per_class=np.asarray( + cocoEval.results["ap_per_class_all_sizes"], dtype=np.float64 + ), + iou_thresholds=np.asarray(cocoEval.params.iou_thrs, dtype=np.float64), + matched_classes=np.asarray(cocoEval.params.cat_ids, dtype=np.int32), + small_objects=mAP_small, + medium_objects=mAP_medium, + large_objects=mAP_large, + ) + return mAP_result diff --git a/src/supervision/metrics/mean_average_recall.py b/src/supervision/metrics/mean_average_recall.py new file mode 100644 index 0000000..e540d78 --- /dev/null +++ b/src/supervision/metrics/mean_average_recall.py @@ -0,0 +1,734 @@ +from __future__ import annotations + +from copy import deepcopy +from dataclasses import dataclass +from typing import TYPE_CHECKING, Any, cast + +import numpy as np +import numpy.typing as npt + +from supervision.config import ORIENTED_BOX_COORDINATES +from supervision.detection.compact_mask import CompactMask +from supervision.detection.core import Detections +from supervision.detection.utils.iou_and_nms import ( + box_iou_batch, + mask_iou_batch, + oriented_box_iou_batch, +) +from supervision.draw.color import LEGACY_COLOR_PALETTE +from supervision.metrics.core import Metric, MetricTarget +from supervision.metrics.utils.matching import ( + _match_detection_batch_with_target_indices, +) +from supervision.metrics.utils.object_size import ( + ObjectSizeCategory, + get_detection_size_category, +) +from supervision.metrics.utils.utils import ensure_pandas_installed + +if TYPE_CHECKING: + import pandas as pd + + +@dataclass +class MeanAverageRecallResult: + """ + The results of the Mean Average Recall metric calculation. + + Defaults to `0` if no detections or targets were provided. + + Attributes: + metric_target: the type of data used for the metric - + boxes, masks or oriented bounding boxes. + mAR_at_1: the Mean Average Recall, when considering only the top + highest confidence detection for each image. + mAR_at_10: the Mean Average Recall, when considering top 10 + highest confidence detections for each image. + mAR_at_100: the Mean Average Recall, when considering top 100 + highest confidence detections for each image. + recall_per_class: the recall scores per max detection count, class and + IoU threshold. Shape: + `(num_max_detections, num_target_classes, num_iou_thresholds)`. + max_detections: the array with maximum number of detections + considered. + iou_thresholds: the IoU thresholds used in the calculations. + matched_classes: the class IDs of all matched classes. + Corresponds to the class axis of `recall_per_class`. + small_objects: the Mean Average Recall + metric results for small objects (area < 32ยฒ). + medium_objects: the Mean Average Recall + metric results for medium objects (32ยฒ โ‰ค area < 96ยฒ). + large_objects: the Mean Average Recall + metric results for large objects (area โ‰ฅ 96ยฒ). + """ + + metric_target: MetricTarget + + @property + def mAR_at_1(self) -> float: + return float(self.recall_scores[0]) + + @property + def mAR_at_10(self) -> float: + return float(self.recall_scores[1]) + + @property + def mAR_at_100(self) -> float: + return float(self.recall_scores[2]) + + recall_scores: npt.NDArray[np.float64] + recall_per_class: npt.NDArray[np.float64] + max_detections: npt.NDArray[np.int32] + iou_thresholds: npt.NDArray[np.float32] + matched_classes: npt.NDArray[np.int32] + + small_objects: MeanAverageRecallResult | None + medium_objects: MeanAverageRecallResult | None + large_objects: MeanAverageRecallResult | None + + def __str__(self) -> str: + """ + Format as a pretty string. + + Example: + ```pycon + >>> import numpy as np + >>> import supervision as sv + >>> from supervision.metrics import MeanAverageRecall + >>> predictions = sv.Detections( + ... xyxy=np.array([[0, 0, 10, 10]]), + ... class_id=np.array([0]), + ... confidence=np.array([0.9]) + ... ) + >>> targets = sv.Detections( + ... xyxy=np.array([[0, 0, 10, 10]]), + ... class_id=np.array([0]) + ... ) + >>> mar_metric = MeanAverageRecall() + >>> mar_result = mar_metric.update(predictions, targets).compute() + >>> print(mar_result) # doctest: +ELLIPSIS + MeanAverageRecallResult: + Metric target: MetricTarget.BOXES + mAR @ 1: 1.0000 + mAR @ 10: 1.0000 + mAR @ 100: 1.0000 + max detections: [ 1 10 100] + IoU thresh: [0.5 0.55 ... 0.95] + mAR per class: + @1: + 0: [1. ... 1.] + @10: + 0: [1. ... 1.] + @100: + 0: [1. ... 1.] + ... + Medium objects: + MeanAverageRecallResult: + Metric target: MetricTarget.BOXES + mAR @ 1: 0.0000 + ... + + ``` + """ + out_str = ( + f"{self.__class__.__name__}:\n" + f"Metric target: {self.metric_target}\n" + f"mAR @ 1: {self.mAR_at_1:.4f}\n" + f"mAR @ 10: {self.mAR_at_10:.4f}\n" + f"mAR @ 100: {self.mAR_at_100:.4f}\n" + f"max detections: {self.max_detections}\n" + f"IoU thresh: {self.iou_thresholds}\n" + f"mAR per class:\n" + ) + if self.recall_per_class.size == 0: + out_str += " No results\n" + for max_detections, recalls_at_k in zip( + self.max_detections, self.recall_per_class + ): + out_str += f" @{max_detections}:\n" + for class_id, recall_of_class in zip(self.matched_classes, recalls_at_k): + out_str += f" {class_id}: {recall_of_class}\n" + + indent = " " + if self.small_objects is not None: + indented = indent + str(self.small_objects).replace("\n", f"\n{indent}") + out_str += f"\nSmall objects:\n{indented}" + if self.medium_objects is not None: + indented = indent + str(self.medium_objects).replace("\n", f"\n{indent}") + out_str += f"\nMedium objects:\n{indented}" + if self.large_objects is not None: + indented = indent + str(self.large_objects).replace("\n", f"\n{indent}") + out_str += f"\nLarge objects:\n{indented}" + + return out_str + + def to_pandas(self) -> pd.DataFrame: + """ + Convert the result to a pandas DataFrame. + + Returns: + The result as a DataFrame. + """ + ensure_pandas_installed() + import pandas as pd + + pandas_data: dict[str, Any] = { + "mAR @ 1": self.mAR_at_1, + "mAR @ 10": self.mAR_at_10, + "mAR @ 100": self.mAR_at_100, + } + + if self.small_objects is not None: + small_objects_df = self.small_objects.to_pandas() + for key, value in small_objects_df.items(): + pandas_data[f"small_objects_{key}"] = value + if self.medium_objects is not None: + medium_objects_df = self.medium_objects.to_pandas() + for key, value in medium_objects_df.items(): + pandas_data[f"medium_objects_{key}"] = value + if self.large_objects is not None: + large_objects_df = self.large_objects.to_pandas() + for key, value in large_objects_df.items(): + pandas_data[f"large_objects_{key}"] = value + + return pd.DataFrame(pandas_data, index=[0]) + + def plot(self) -> None: + """ + Plot the Mean Average Recall results. + + ![example_plot](\ + https://media.roboflow.com/supervision-docs/metrics/mAR_plot_example.png\ + ){ align=center width="800" } + """ + from matplotlib import pyplot as plt + + labels = ["mAR @ 1", "mAR @ 10", "mAR @ 100"] + values = [self.mAR_at_1, self.mAR_at_10, self.mAR_at_100] + colors = [LEGACY_COLOR_PALETTE[0]] * 3 + + if self.small_objects is not None: + small_objects = self.small_objects + labels += ["Small: mAR @ 1", "Small: mAR @ 10", "Small: mAR @ 100"] + values += [ + small_objects.mAR_at_1, + small_objects.mAR_at_10, + small_objects.mAR_at_100, + ] + colors += [LEGACY_COLOR_PALETTE[3]] * 3 + + if self.medium_objects is not None: + medium_objects = self.medium_objects + labels += ["Medium: mAR @ 1", "Medium: mAR @ 10", "Medium: mAR @ 100"] + values += [ + medium_objects.mAR_at_1, + medium_objects.mAR_at_10, + medium_objects.mAR_at_100, + ] + colors += [LEGACY_COLOR_PALETTE[2]] * 3 + + if self.large_objects is not None: + large_objects = self.large_objects + labels += ["Large: mAR @ 1", "Large: mAR @ 10", "Large: mAR @ 100"] + values += [ + large_objects.mAR_at_1, + large_objects.mAR_at_10, + large_objects.mAR_at_100, + ] + colors += [LEGACY_COLOR_PALETTE[4]] * 3 + + plt.rcParams["font.family"] = "monospace" + + _, ax = plt.subplots(figsize=(10, 6)) + ax.set_ylim(0, 1) + ax.set_ylabel("Value", fontweight="bold") + title = ( + f"Mean Average Recall, by Object Size\n(target: {self.metric_target.value})" + ) + ax.set_title(title, fontweight="bold") + + x_positions = range(len(labels)) + bars = ax.bar(x_positions, values, color=colors, align="center") + + ax.set_xticks(x_positions) + ax.set_xticklabels(labels, rotation=45, ha="right") + + for bar in bars: + y_value = bar.get_height() + ax.text( + bar.get_x() + bar.get_width() / 2, + y_value + 0.02, + f"{y_value:.2f}", + ha="center", + va="bottom", + ) + + plt.rcParams["font.family"] = "sans-serif" + + plt.tight_layout() + plt.show() + + +class MeanAverageRecall(Metric["MeanAverageRecallResult"]): + """ + Mean Average Recall (mAR) measures how well the model detects + and retrieves relevant objects by averaging recall over multiple + IoU thresholds, classes and detection limits. + + Intuitively, while Recall measures the ability to find all relevant + objects, mAR narrows down how many detections are considered for each + image. For example, mAR @ 100 considers the top 100 highest confidence + detections for each image. mAR @ 1 considers only the highest + confidence detection for each image. + + Examples: + ```pycon + >>> import numpy as np + >>> import supervision as sv + >>> from supervision.metrics import MeanAverageRecall + >>> predictions = sv.Detections( + ... xyxy=np.array([[0, 0, 10, 10]]), + ... class_id=np.array([0]), + ... confidence=np.array([0.9]) + ... ) + >>> targets = sv.Detections( + ... xyxy=np.array([[0, 0, 10, 10]]), + ... class_id=np.array([0]) + ... ) + >>> mar_metric = MeanAverageRecall() + >>> mar_result = mar_metric.update(predictions, targets).compute() + >>> round(float(mar_result.mAR_at_100), 2) + 1.0 + + ``` + + ![example_plot]( + https://media.roboflow.com/supervision-docs/metrics/mAR_plot_example.png + ){ align=center width="800" } + """ + + def __init__( + self, + metric_target: MetricTarget = MetricTarget.BOXES, + ): + """ + Initialize the Mean Average Recall metric. + + Args: + metric_target: The type of detection data to use. + """ + self._metric_target = metric_target + + self._predictions_list: list[Detections] = [] + self._targets_list: list[Detections] = [] + + self.max_detections = np.array([1, 10, 100]) + + def reset(self) -> None: + """ + Reset the metric to its initial state, clearing all stored data. + """ + self._predictions_list = [] + self._targets_list = [] + + def update( + self, + predictions: Detections | list[Detections], + targets: Detections | list[Detections], + ) -> MeanAverageRecall: + """ + Add new predictions and targets to the metric, but do not compute the result. + + Args: + predictions: The predicted detections. + targets: The target detections. + + Returns: + The updated metric instance. + """ + if not isinstance(predictions, list): + predictions = [predictions] + if not isinstance(targets, list): + targets = [targets] + + if len(predictions) != len(targets): + raise ValueError( + f"The number of predictions ({len(predictions)}) and" + f" targets ({len(targets)}) during the update must be the same." + ) + + self._predictions_list.extend(predictions) + self._targets_list.extend(targets) + + return self + + def compute(self) -> MeanAverageRecallResult: + """ + Calculate the Mean Average Recall metric based on the stored predictions + and ground-truth, at different IoU thresholds and maximum detection counts. + + Returns: + The Mean Average Recall metric result. + """ + result = self._compute(self._predictions_list, self._targets_list) + result.small_objects = self._compute( + self._predictions_list, self._targets_list, ObjectSizeCategory.SMALL + ) + result.medium_objects = self._compute( + self._predictions_list, self._targets_list, ObjectSizeCategory.MEDIUM + ) + result.large_objects = self._compute( + self._predictions_list, self._targets_list, ObjectSizeCategory.LARGE + ) + + return result + + def _compute( + self, + predictions_list: list[Detections], + targets_list: list[Detections], + size_category: ObjectSizeCategory = ObjectSizeCategory.ANY, + ) -> MeanAverageRecallResult: + if size_category != ObjectSizeCategory.ANY: + # Score the requested bucket on bucket-filtered targets so detections + # outside the bucket cannot consume the only available target. + targets_list = [ + self._filter_detections_by_size(targets, size_category) + for targets in targets_list + ] + size_category = ObjectSizeCategory.ANY + + iou_thresholds = np.linspace(0.5, 0.95, 10, dtype=np.float32) + stats: list[Any] = [] + + for predictions, targets in zip(predictions_list, targets_list): + prediction_contents = self._detections_content(predictions) + target_contents = self._detections_content(targets) + if len(targets) > 0: + if predictions.class_id is None or targets.class_id is None: + raise ValueError( + "MeanAverageRecall metric requires `class_id` on both " + "predictions and targets." + ) + if len(predictions) == 0: + target_class_ids = np.asarray(targets.class_id, dtype=np.int32) + if len(target_class_ids) == 0: + continue + stats.append( + ( + np.zeros((0, iou_thresholds.size), dtype=bool), + np.zeros((0, iou_thresholds.size), dtype=bool), + np.zeros((0,), dtype=int), + np.zeros((0,), dtype=int), + target_class_ids, + ) + ) + + else: + if predictions.confidence is None: + raise ValueError( + "MeanAverageRecall metric requires `confidence` on " + "predictions." + ) + prediction_class_ids = np.asarray( + predictions.class_id, dtype=np.int32 + ) + target_class_ids = np.asarray(targets.class_id, dtype=np.int32) + prediction_confidence = np.asarray( + predictions.confidence, dtype=np.float32 + ) + if self._metric_target == MetricTarget.BOXES: + # BOXES target never yields CompactMask; narrow for mypy. + iou = box_iou_batch( + cast(npt.NDArray[np.number], target_contents), + cast(npt.NDArray[np.number], prediction_contents), + ) + elif self._metric_target == MetricTarget.MASKS: + iou = mask_iou_batch(target_contents, prediction_contents) + elif self._metric_target == MetricTarget.ORIENTED_BOUNDING_BOXES: + # OBB target never yields CompactMask; narrow for mypy. + iou = oriented_box_iou_batch( + cast(npt.NDArray[np.number], target_contents), + cast(npt.NDArray[np.number], prediction_contents), + ) + else: + raise ValueError( + "Unsupported metric target for IoU calculation" + ) + + matches, _ = _match_detection_batch_with_target_indices( + prediction_class_ids, + target_class_ids, + iou, + iou_thresholds, + ) + ignored_matches = np.zeros_like(matches, dtype=bool) + + sorted_indices = np.argsort(-prediction_confidence) + stats.append( + ( + matches[sorted_indices], + ignored_matches[sorted_indices], + np.arange(len(prediction_confidence)), + prediction_class_ids[sorted_indices], + target_class_ids, + ) + ) + + if not stats: + max_detection_count = self.max_detections.shape[0] + return MeanAverageRecallResult( + metric_target=self._metric_target, + recall_scores=np.zeros(max_detection_count), + recall_per_class=np.zeros( + (max_detection_count, 0, iou_thresholds.shape[0]) + ), + max_detections=self.max_detections, + iou_thresholds=iou_thresholds, + matched_classes=np.array([], dtype=int), + small_objects=None, + medium_objects=None, + large_objects=None, + ) + + concatenated_stats = [np.concatenate(items, 0) for items in zip(*stats)] + recall_scores_per_k, recall_per_class_at_k, unique_classes = ( + self._compute_average_recall_for_classes(*concatenated_stats) + ) + + return MeanAverageRecallResult( + metric_target=self._metric_target, + recall_scores=recall_scores_per_k, + recall_per_class=recall_per_class_at_k, + max_detections=self.max_detections, + iou_thresholds=iou_thresholds, + matched_classes=unique_classes, + small_objects=None, + medium_objects=None, + large_objects=None, + ) + + def _compute_average_recall_for_classes( + self, + matches: npt.NDArray[np.bool_], + ignored_matches: npt.NDArray[np.bool_], + prediction_indices: npt.NDArray[np.int32], + prediction_class_ids: npt.NDArray[np.int32], + true_class_ids: npt.NDArray[np.int32], + ) -> tuple[ + npt.NDArray[np.float64], + npt.NDArray[np.float64], + npt.NDArray[np.int32], + ]: + unique_classes, class_counts = np.unique(true_class_ids, return_counts=True) + + if unique_classes.size == 0: + max_detection_count = self.max_detections.shape[0] + num_thresholds = matches.shape[1] + return ( + np.zeros(max_detection_count, dtype=np.float64), + np.zeros((max_detection_count, 0, num_thresholds), dtype=np.float64), + unique_classes, + ) + + recalls_at_k: list[npt.NDArray[np.float64]] = [] + for max_detections in self.max_detections: + # Shape: PxTh,P,C,C -> CxThx3 + is_within_limit = prediction_indices < max_detections + confusion_matrix = self._compute_confusion_matrix( + matches[is_within_limit], + ignored_matches[is_within_limit], + prediction_class_ids[is_within_limit], + unique_classes, + class_counts, + ) + + # Shape: CxThx3 -> CxTh + recall_per_class = self._compute_recall(confusion_matrix) + recalls_at_k.append(recall_per_class) + + # Shape: KxCxTh -> KxC + recall_per_class_at_k = np.array(recalls_at_k) + average_recall_per_class = np.mean(recall_per_class_at_k, axis=2) + + # Shape: KxC -> K + recall_scores = np.mean(average_recall_per_class, axis=1) + + return recall_scores, recall_per_class_at_k, unique_classes + + @staticmethod + def _match_detection_batch( + predictions_classes: npt.NDArray[np.int32], + target_classes: npt.NDArray[np.int32], + iou: npt.NDArray[np.float32], + iou_thresholds: npt.NDArray[np.float32], + ) -> npt.NDArray[np.bool_]: + result_correct, _ = _match_detection_batch_with_target_indices( + predictions_classes, target_classes, iou, iou_thresholds + ) + return result_correct + + @staticmethod + def _compute_confusion_matrix( + sorted_matches: npt.NDArray[np.bool_], + sorted_ignored_matches: npt.NDArray[np.bool_], + sorted_prediction_class_ids: npt.NDArray[np.int32], + unique_classes: npt.NDArray[np.integer], + class_counts: npt.NDArray[np.integer], + ) -> npt.NDArray[np.float64]: + """ + Compute the confusion matrix for each class and IoU threshold. + + Assumes the matches and prediction_class_ids are sorted by confidence + in descending order. + + Args: + sorted_matches: shape (P, Th), that is True + if the prediction is a true positive at the given IoU threshold. + sorted_ignored_matches: shape (P, Th), that is True + if the prediction should not affect the given IoU threshold. + sorted_prediction_class_ids: shape (P,), containing + the class id for each prediction. + unique_classes: shape (C,), containing the unique + class ids. + class_counts: shape (C,), containing the number + of true instances for each class. + max_detections: The maximum number of detections to + consider for each class. Extra detections are considered false + positives. By default, all detections are considered. + + Returns: + shape (C, Th, 3), containing the true positives, false + positives, and false negatives for each class and IoU threshold. + """ + num_thresholds = sorted_matches.shape[1] + num_classes = unique_classes.shape[0] + + confusion_matrix: npt.NDArray[np.float64] = np.zeros( + (num_classes, num_thresholds, 3), dtype=np.float64 + ) + for class_idx, class_id in enumerate(unique_classes): + is_class = sorted_prediction_class_ids == class_id + num_true = class_counts[class_idx] + num_predictions = is_class.sum() + + if num_predictions == 0: + true_positives = np.zeros(num_thresholds) + false_positives = np.zeros(num_thresholds) + false_negatives = np.full(num_thresholds, num_true) + elif num_true == 0: + true_positives = np.zeros(num_thresholds) + false_positives = (~sorted_ignored_matches[is_class]).sum(0) + false_negatives = np.zeros(num_thresholds) + else: + limited_matches = sorted_matches[is_class] + limited_ignored_matches = sorted_ignored_matches[is_class] + true_positives = limited_matches.sum(0) + + false_positives = (~limited_matches & ~limited_ignored_matches).sum(0) + false_negatives = num_true - true_positives + + confusion_matrix[class_idx] = np.stack( + [true_positives, false_positives, false_negatives], axis=1 + ) + + result_confusion_matrix: npt.NDArray[np.float64] = confusion_matrix + return result_confusion_matrix + + @staticmethod + def _compute_recall( + confusion_matrix: npt.NDArray[np.float64], + ) -> npt.NDArray[np.float64]: + """ + Broadcastable function, computing the recall from the confusion matrix. + + Args: + confusion_matrix: shape (N, ..., 3), where the last dimension + contains the true positives, false positives, and false negatives. + + Returns: + shape (N, ...), containing the recall for each element. + """ + if not confusion_matrix.shape[-1] == 3: + raise ValueError( + f"Confusion matrix must have shape (..., 3), got " + f"{confusion_matrix.shape}" + ) + true_positives = confusion_matrix[..., 0] + false_negatives = confusion_matrix[..., 2] + + denominator = true_positives + false_negatives + recall = np.where(denominator == 0, 0, true_positives / denominator) + + result_recall: npt.NDArray[np.float64] = recall + return result_recall + + def _detections_content( + self, detections: Detections + ) -> npt.NDArray[Any] | CompactMask: + """Return boxes, masks or oriented bounding boxes from detections. + + For the mask target this may return a + :class:`~supervision.detection.compact_mask.CompactMask` rather than a + dense boolean array when the detections carry compact masks. + """ + if self._metric_target == MetricTarget.BOXES: + return cast(npt.NDArray[Any], detections.xyxy) + if self._metric_target == MetricTarget.MASKS: + if detections.mask is not None: + # detections.mask is NDArray[bool] | CompactMask; return as-is. + return detections.mask + if len(detections) > 0: + raise ValueError( + "MeanAverageRecall with `MetricTarget.MASKS` requires " + "detections to include masks." + ) + return self._make_empty_content() + if self._metric_target == MetricTarget.ORIENTED_BOUNDING_BOXES: + obb = detections.data.get(ORIENTED_BOX_COORDINATES) + if obb is not None and len(obb) > 0: + result_obb: npt.NDArray[np.float32] = np.array(obb, dtype=np.float32) + return result_obb + return self._make_empty_content() + raise ValueError(f"Invalid metric target: {self._metric_target}") + + def _make_empty_content(self) -> npt.NDArray[Any]: + if self._metric_target == MetricTarget.BOXES: + empty_boxes: npt.NDArray[np.float32] = np.empty((0, 4), dtype=np.float32) + return empty_boxes + + if self._metric_target == MetricTarget.MASKS: + empty_masks: npt.NDArray[np.bool_] = np.empty((0, 0, 0), dtype=bool) + return empty_masks + + if self._metric_target == MetricTarget.ORIENTED_BOUNDING_BOXES: + empty_obb: npt.NDArray[np.float32] = np.empty((0, 4, 2), dtype=np.float32) + return empty_obb + + raise ValueError(f"Invalid metric target: {self._metric_target}") + + def _filter_detections_by_size( + self, detections: Detections, size_category: ObjectSizeCategory + ) -> Detections: + """Return a copy of detections with contents filtered by object size.""" + new_detections = deepcopy(detections) + if detections.is_empty() or size_category == ObjectSizeCategory.ANY: + return new_detections + + sizes = get_detection_size_category(new_detections, self._metric_target) + size_mask = sizes == size_category.value + + new_detections.xyxy = new_detections.xyxy[size_mask] + if new_detections.mask is not None: + new_detections.mask = new_detections.mask[size_mask] + if new_detections.class_id is not None: + new_detections.class_id = new_detections.class_id[size_mask] + if new_detections.confidence is not None: + new_detections.confidence = new_detections.confidence[size_mask] + if new_detections.tracker_id is not None: + new_detections.tracker_id = new_detections.tracker_id[size_mask] + if new_detections.data is not None: + for key, value in new_detections.data.items(): + new_detections.data[key] = np.array(value)[size_mask] + + return new_detections diff --git a/src/supervision/metrics/precision.py b/src/supervision/metrics/precision.py new file mode 100644 index 0000000..e3f64fe --- /dev/null +++ b/src/supervision/metrics/precision.py @@ -0,0 +1,815 @@ +from __future__ import annotations + +from copy import deepcopy +from dataclasses import dataclass +from typing import TYPE_CHECKING, Any, cast + +import numpy as np +import numpy.typing as npt + +from supervision.config import ORIENTED_BOX_COORDINATES +from supervision.detection.core import Detections +from supervision.detection.utils.iou_and_nms import ( + box_iou_batch, + mask_iou_batch, + oriented_box_iou_batch, +) +from supervision.draw.color import LEGACY_COLOR_PALETTE +from supervision.metrics.core import AveragingMethod, Metric, MetricTarget +from supervision.metrics.utils.matching import ( + _match_detection_batch_with_target_indices, +) +from supervision.metrics.utils.object_size import ( + ObjectSizeCategory, + get_detection_size_category, +) +from supervision.metrics.utils.utils import ensure_pandas_installed + +if TYPE_CHECKING: + import pandas as pd + + +class Precision(Metric["PrecisionResult"]): + """ + Precision is a metric used to evaluate object detection models. It is the ratio of + true positive detections to the total number of predicted detections. We calculate + it at different IoU thresholds. + + In simple terms, Precision is a measure of a model's accuracy, calculated as: + + `Precision = TP / (TP + FP)` + + Here, `TP` is the number of true positives (correct detections), and `FP` is the + number of false positive detections (detected, but incorrectly). + + Examples: + ```pycon + >>> import numpy as np + >>> import supervision as sv + >>> from supervision.metrics import Precision + >>> predictions = sv.Detections( + ... xyxy=np.array([[0, 0, 10, 10]]), + ... class_id=np.array([0]), + ... confidence=np.array([0.9]) + ... ) + >>> targets = sv.Detections( + ... xyxy=np.array([[0, 0, 10, 10]]), + ... class_id=np.array([0]) + ... ) + >>> precision_metric = Precision() + >>> precision_result = precision_metric.update(predictions, targets).compute() + >>> round(float(precision_result.precision_at_50), 2) + 1.0 + + ``` + + ![example_plot]( + https://media.roboflow.com/supervision-docs/metrics/precision_plot_example.png + ){ align=center width="800" } + """ + + def __init__( + self, + metric_target: MetricTarget = MetricTarget.BOXES, + averaging_method: AveragingMethod = AveragingMethod.WEIGHTED, + ): + """ + Initialize the Precision metric. + + Args: + metric_target: The type of detection data to use. + averaging_method: The averaging method used to compute the + precision. Determines how the precision is aggregated across classes. + """ + self._metric_target = metric_target + self.averaging_method = averaging_method + + self._predictions_list: list[Detections] = [] + self._targets_list: list[Detections] = [] + + def reset(self) -> None: + """ + Reset the metric to its initial state, clearing all stored data. + """ + self._predictions_list = [] + self._targets_list = [] + + def update( + self, + predictions: Detections | list[Detections], + targets: Detections | list[Detections], + ) -> Precision: + """ + Add new predictions and targets to the metric, but do not compute the result. + + Args: + predictions: The predicted detections. + targets: The target detections. + + Returns: + The updated metric instance. + """ + if not isinstance(predictions, list): + predictions = [predictions] + if not isinstance(targets, list): + targets = [targets] + + if len(predictions) != len(targets): + raise ValueError( + f"The number of predictions ({len(predictions)}) and" + f" targets ({len(targets)}) during the update must be the same." + ) + + self._predictions_list.extend(predictions) + self._targets_list.extend(targets) + + return self + + def compute(self) -> PrecisionResult: + """ + Calculate the precision metric based on the stored predictions and ground-truth + data, at different IoU thresholds. + + Returns: + The precision metric result. + """ + result = self._compute(self._predictions_list, self._targets_list) + result.small_objects = self._compute( + self._predictions_list, self._targets_list, ObjectSizeCategory.SMALL + ) + result.medium_objects = self._compute( + self._predictions_list, self._targets_list, ObjectSizeCategory.MEDIUM + ) + result.large_objects = self._compute( + self._predictions_list, self._targets_list, ObjectSizeCategory.LARGE + ) + + return result + + def _compute( + self, + predictions_list: list[Detections], + targets_list: list[Detections], + size_category: ObjectSizeCategory = ObjectSizeCategory.ANY, + ) -> PrecisionResult: + """Build per-image stats tuples and delegate to class-level computation. + + Each stats tuple is + ``(matches, ignored_matches, confidence, class_ids, true_class_ids)``: + - Both empty: skip (no information). + - Targets empty, predictions present: all predictions are FPs; true_class_ids + is ``zeros((0,))``. + - Targets present: IoU matching produces ``matches`` array. + """ + if size_category != ObjectSizeCategory.ANY: + # Score the requested bucket on bucket-filtered targets so detections + # outside the bucket cannot consume the only available target. + targets_list = [ + self._filter_detections_by_size(targets, size_category) + for targets in targets_list + ] + size_category = ObjectSizeCategory.ANY + + iou_thresholds = np.linspace(0.5, 0.95, 10, dtype=np.float32) + stats: list[Any] = [] + + for predictions, targets in zip(predictions_list, targets_list): + prediction_contents = self._detections_content(predictions) + target_contents = self._detections_content(targets) + prediction_size_mask = np.ones(len(predictions), dtype=bool) + target_size_mask = np.ones(len(targets), dtype=bool) + if size_category != ObjectSizeCategory.ANY: + if len(predictions) > 0: + prediction_size_mask = ( + get_detection_size_category(predictions, self._metric_target) + == size_category.value + ) + if len(targets) > 0: + target_size_mask = ( + get_detection_size_category(targets, self._metric_target) + == size_category.value + ) + + if len(targets) == 0 and len(predictions) > 0: + # Only predictions are present (e.g. a background image); every + # prediction is a false positive. + if predictions.class_id is None or predictions.confidence is None: + raise ValueError( + "Precision metric requires `class_id` and `confidence` " + "on predictions." + ) + prediction_class_ids = np.asarray(predictions.class_id, dtype=np.int32)[ + prediction_size_mask + ] + prediction_confidence = np.asarray( + predictions.confidence, dtype=np.float32 + )[prediction_size_mask] + if len(prediction_class_ids) == 0: + continue + stats.append( + ( + np.zeros( + (len(prediction_class_ids), iou_thresholds.size), + dtype=np.bool_, + ), + np.zeros( + (len(prediction_class_ids), iou_thresholds.size), + dtype=np.bool_, + ), + prediction_confidence, + prediction_class_ids, + np.zeros((0,), dtype=np.int32), + ) + ) + elif len(targets) > 0: + if predictions.class_id is None or targets.class_id is None: + raise ValueError( + "Precision metric requires `class_id` on both predictions " + "and targets." + ) + if len(predictions) == 0: + target_class_ids = np.asarray(targets.class_id, dtype=np.int32)[ + target_size_mask + ] + if len(target_class_ids) == 0: + continue + stats.append( + ( + np.zeros((0, iou_thresholds.size), dtype=bool), + np.zeros((0, iou_thresholds.size), dtype=bool), + np.zeros((0,), dtype=np.float32), + np.zeros((0,), dtype=int), + target_class_ids, + ) + ) + + else: + if predictions.confidence is None: + raise ValueError( + "Precision metric requires `confidence` on predictions." + ) + prediction_class_ids = np.asarray( + predictions.class_id, dtype=np.int32 + ) + target_class_ids = np.asarray(targets.class_id, dtype=np.int32) + prediction_confidence = np.asarray( + predictions.confidence, dtype=np.float32 + ) + if self._metric_target == MetricTarget.BOXES: + iou = box_iou_batch(target_contents, prediction_contents) + elif self._metric_target == MetricTarget.MASKS: + iou = mask_iou_batch(target_contents, prediction_contents) + elif self._metric_target == MetricTarget.ORIENTED_BOUNDING_BOXES: + iou = oriented_box_iou_batch( + target_contents, prediction_contents + ) + else: + raise ValueError( + "Unsupported metric target for IoU calculation" + ) + + matches, matched_target_indices = ( + _match_detection_batch_with_target_indices( + prediction_class_ids, + target_class_ids, + iou, + iou_thresholds, + ) + ) + ignored_matches = np.zeros_like(matches, dtype=bool) + if size_category != ObjectSizeCategory.ANY: + valid_target_match = matched_target_indices >= 0 + matched_scored_target = np.zeros_like(matches, dtype=bool) + if np.any(valid_target_match): + matched_scored_target[valid_target_match] = ( + target_size_mask[ + matched_target_indices[valid_target_match] + ] + ) + prediction_scored = ( + prediction_size_mask[:, None] | matched_scored_target + ) + ignored_matches = ~prediction_scored | ( + valid_target_match & ~matched_scored_target + ) + prediction_keep = np.any(~ignored_matches, axis=1) + matches = ( + matches[prediction_keep] + & matched_scored_target[prediction_keep] + ) + ignored_matches = ignored_matches[prediction_keep] + prediction_confidence = prediction_confidence[prediction_keep] + prediction_class_ids = prediction_class_ids[prediction_keep] + target_class_ids = target_class_ids[target_size_mask] + if ( + len(prediction_class_ids) == 0 + and len(target_class_ids) == 0 + ): + continue + stats.append( + ( + matches, + ignored_matches, + prediction_confidence, + prediction_class_ids, + target_class_ids, + ) + ) + + if not stats: + return PrecisionResult( + metric_target=self._metric_target, + averaging_method=self.averaging_method, + precision_scores=np.zeros(iou_thresholds.shape[0]), + precision_per_class=np.zeros((0, iou_thresholds.shape[0])), + iou_thresholds=iou_thresholds, + matched_classes=np.array([], dtype=int), + small_objects=None, + medium_objects=None, + large_objects=None, + ) + + concatenated_stats = [np.concatenate(items, 0) for items in zip(*stats)] + precision_scores, precision_per_class, unique_classes = ( + self._compute_precision_for_classes(*concatenated_stats) + ) + + return PrecisionResult( + metric_target=self._metric_target, + averaging_method=self.averaging_method, + precision_scores=precision_scores, + precision_per_class=precision_per_class, + iou_thresholds=iou_thresholds, + matched_classes=unique_classes, + small_objects=None, + medium_objects=None, + large_objects=None, + ) + + def _compute_precision_for_classes( + self, + matches: npt.NDArray[np.bool_], + ignored_matches: npt.NDArray[np.bool_], + prediction_confidence: npt.NDArray[np.float32], + prediction_class_ids: npt.NDArray[np.int32], + true_class_ids: npt.NDArray[np.int32], + ) -> tuple[ + npt.NDArray[np.float64], + npt.NDArray[np.float64], + npt.NDArray[np.int32], + ]: + """Compute precision scores from concatenated stats across all images. + + ``unique_classes`` is the union of GT and predicted classes so that + predictions of classes absent from GT still count as false positives. + """ + sorted_indices = np.argsort(-prediction_confidence) + matches = matches[sorted_indices] + ignored_matches = ignored_matches[sorted_indices] + prediction_class_ids = prediction_class_ids[sorted_indices] + # Predictions whose class never appears in the ground truth are still + # false positives, so include those classes in the confusion matrix + # (their true-instance count is zero). + unique_classes = np.unique( + np.concatenate((true_class_ids, prediction_class_ids)) + ) + true_classes, true_counts = np.unique(true_class_ids, return_counts=True) + class_counts = np.zeros(unique_classes.shape[0], dtype=int) + class_counts[np.searchsorted(unique_classes, true_classes)] = true_counts + + # Shape: PxTh,P,C,C -> CxThx3 + confusion_matrix = self._compute_confusion_matrix( + matches, ignored_matches, prediction_class_ids, unique_classes, class_counts + ) + + # Shape: CxThx3 -> CxTh + precision_per_class = self._compute_precision(confusion_matrix) + + # Shape: CxTh -> Th + if self.averaging_method == AveragingMethod.MACRO: + precision_scores = np.mean(precision_per_class, axis=0) + elif self.averaging_method == AveragingMethod.MICRO: + confusion_matrix_merged = confusion_matrix.sum(0) + precision_scores = self._compute_precision(confusion_matrix_merged) + elif self.averaging_method == AveragingMethod.WEIGHTED: + class_counts = class_counts.astype(np.float32) + if class_counts.sum() == 0: + # No ground-truth support (e.g. only false-positive classes, or a + # size bucket with predictions but no targets): weighting is + # undefined, so report 0 as the empty case did before. + precision_scores = np.zeros(precision_per_class.shape[1]) + else: + precision_scores = np.average( + precision_per_class, axis=0, weights=class_counts + ) + + return precision_scores, precision_per_class, unique_classes + + @staticmethod + def _match_detection_batch( + predictions_classes: npt.NDArray[np.int32], + target_classes: npt.NDArray[np.int32], + iou: npt.NDArray[np.float32], + iou_thresholds: npt.NDArray[np.float32], + ) -> npt.NDArray[np.bool_]: + result_correct, _ = _match_detection_batch_with_target_indices( + predictions_classes, target_classes, iou, iou_thresholds + ) + return result_correct + + @staticmethod + def _compute_confusion_matrix( + sorted_matches: npt.NDArray[np.bool_], + sorted_ignored_matches: npt.NDArray[np.bool_], + sorted_prediction_class_ids: npt.NDArray[np.int32], + unique_classes: npt.NDArray[np.int32], + class_counts: npt.NDArray[np.int32], + ) -> npt.NDArray[np.float64]: + """ + Compute the confusion matrix for each class and IoU threshold. + + Assumes the matches and prediction_class_ids are sorted by confidence + in descending order. + + Args: + sorted_matches: shape (P, Th), that is True + if the prediction is a true positive at the given IoU threshold. + sorted_ignored_matches: shape (P, Th), that is True + if the prediction should not affect the given IoU threshold. + sorted_prediction_class_ids: shape (P,), containing + the class id for each prediction. + unique_classes: shape (C,), containing the unique + class ids. + class_counts: shape (C,), containing the number + of true instances for each class. + + Returns: + shape (C, Th, 3), containing the true positives, false + positives, and false negatives for each class and IoU threshold. + """ + + num_thresholds = sorted_matches.shape[1] + num_classes = unique_classes.shape[0] + + confusion_matrix: npt.NDArray[np.float64] = np.zeros( + (num_classes, num_thresholds, 3), dtype=np.float64 + ) + for class_idx, class_id in enumerate(unique_classes): + is_class = sorted_prediction_class_ids == class_id + num_true = class_counts[class_idx] + num_predictions = is_class.sum() + + if num_predictions == 0: + true_positives = np.zeros(num_thresholds) + false_positives = np.zeros(num_thresholds) + false_negatives = np.full(num_thresholds, num_true) + elif num_true == 0: + true_positives = np.zeros(num_thresholds) + false_positives = (~sorted_ignored_matches[is_class]).sum(0) + false_negatives = np.zeros(num_thresholds) + else: + true_positives = sorted_matches[is_class].sum(0) + false_positives = ( + ~sorted_matches[is_class] & ~sorted_ignored_matches[is_class] + ).sum(0) + false_negatives = num_true - true_positives + confusion_matrix[class_idx] = np.stack( + [true_positives, false_positives, false_negatives], axis=1 + ) + result_matrix: npt.NDArray[np.float64] = confusion_matrix + return result_matrix + + @staticmethod + def _compute_precision( + confusion_matrix: npt.NDArray[np.float64], + ) -> npt.NDArray[np.float64]: + """ + Broadcastable function, computing the precision from the confusion matrix. + + Args: + confusion_matrix: shape (N, ..., 3), where the last dimension + contains the true positives, false positives, and false negatives. + + Returns: + shape (N, ...), containing the precision for each element. + """ + if not confusion_matrix.shape[-1] == 3: + raise ValueError( + f"Confusion matrix must have shape (..., 3), got " + f"{confusion_matrix.shape}" + ) + true_positives = confusion_matrix[..., 0] + false_positives = confusion_matrix[..., 1] + + denominator = true_positives + false_positives + precision = np.divide( + true_positives, + denominator, + out=np.zeros_like(true_positives), + where=denominator != 0, + ) + + result_precision: npt.NDArray[np.float64] = precision + return result_precision + + def _detections_content(self, detections: Detections) -> npt.NDArray[Any]: + """Return boxes, masks or oriented bounding boxes from detections.""" + if self._metric_target == MetricTarget.BOXES: + return cast(npt.NDArray[Any], detections.xyxy) + if self._metric_target == MetricTarget.MASKS: + if detections.mask is not None: + return cast(npt.NDArray[Any], detections.mask) + if len(detections) > 0: + raise ValueError( + "Precision with `MetricTarget.MASKS` requires detections to " + "include masks." + ) + return self._make_empty_content() + if self._metric_target == MetricTarget.ORIENTED_BOUNDING_BOXES: + obb = detections.data.get(ORIENTED_BOX_COORDINATES) + if obb is not None and len(obb) > 0: + result_obb: npt.NDArray[np.float32] = np.array(obb, dtype=np.float32) + return result_obb + return self._make_empty_content() + raise ValueError(f"Invalid metric target: {self._metric_target}") + + def _make_empty_content(self) -> npt.NDArray[Any]: + if self._metric_target == MetricTarget.BOXES: + empty_boxes: npt.NDArray[np.float32] = np.empty((0, 4), dtype=np.float32) + return empty_boxes + + if self._metric_target == MetricTarget.MASKS: + empty_masks: npt.NDArray[np.bool_] = np.empty((0, 0, 0), dtype=bool) + return empty_masks + + if self._metric_target == MetricTarget.ORIENTED_BOUNDING_BOXES: + empty_obb: npt.NDArray[np.float32] = np.empty((0, 4, 2), dtype=np.float32) + return empty_obb + + raise ValueError(f"Invalid metric target: {self._metric_target}") + + def _filter_detections_by_size( + self, detections: Detections, size_category: ObjectSizeCategory + ) -> Detections: + """Return a copy of detections with contents filtered by object size.""" + new_detections = deepcopy(detections) + if detections.is_empty() or size_category == ObjectSizeCategory.ANY: + return new_detections + + sizes = get_detection_size_category(new_detections, self._metric_target) + size_mask = sizes == size_category.value + + new_detections.xyxy = new_detections.xyxy[size_mask] + if new_detections.mask is not None: + new_detections.mask = new_detections.mask[size_mask] + if new_detections.class_id is not None: + new_detections.class_id = new_detections.class_id[size_mask] + if new_detections.confidence is not None: + new_detections.confidence = new_detections.confidence[size_mask] + if new_detections.tracker_id is not None: + new_detections.tracker_id = new_detections.tracker_id[size_mask] + if new_detections.data is not None: + for key, value in new_detections.data.items(): + new_detections.data[key] = np.array(value)[size_mask] + + return new_detections + + def _filter_predictions_and_targets_by_size( + self, + predictions_list: list[Detections], + targets_list: list[Detections], + size_category: ObjectSizeCategory, + ) -> tuple[list[Detections], list[Detections]]: + """ + Filter predictions and targets by object size category. + """ + new_predictions_list = [] + new_targets_list = [] + for predictions, targets in zip(predictions_list, targets_list): + new_predictions_list.append( + self._filter_detections_by_size(predictions, size_category) + ) + new_targets_list.append( + self._filter_detections_by_size(targets, size_category) + ) + return new_predictions_list, new_targets_list + + +@dataclass +class PrecisionResult: + """ + The results of the precision metric calculation. + + Defaults to `0` if no detections or targets were provided. + + Attributes: + metric_target: the type of data used for the metric - + boxes, masks or oriented bounding boxes. + averaging_method: the averaging method used to compute the + precision. Determines how the precision is aggregated across classes. + precision_at_50: the precision at IoU threshold of `0.5`. + precision_at_75: the precision at IoU threshold of `0.75`. + precision_scores: the precision scores at each IoU threshold. + Shape: `(num_iou_thresholds,)` + precision_per_class: the precision scores per class and + IoU threshold. Shape: `(num_classes, num_iou_thresholds)` + iou_thresholds: the IoU thresholds used in the calculations. + matched_classes: the class IDs present in either predictions or ground + truth. Corresponds to the rows of `precision_per_class`. Classes + that appear only in predictions (no ground-truth instances) are + included; their per-threshold precision values will be `0.0`. + small_objects: the Precision metric results + for small objects (area < 32ยฒ). + medium_objects: the Precision metric results + for medium objects (32ยฒ โ‰ค area < 96ยฒ). + large_objects: the Precision metric results + for large objects (area โ‰ฅ 96ยฒ). + """ + + metric_target: MetricTarget + averaging_method: AveragingMethod + + @property + def precision_at_50(self) -> float: + return float(self.precision_scores[0]) + + @property + def precision_at_75(self) -> float: + return float(self.precision_scores[5]) + + precision_scores: npt.NDArray[np.float64] + precision_per_class: npt.NDArray[np.float64] + iou_thresholds: npt.NDArray[np.float32] + matched_classes: npt.NDArray[np.int32] + + small_objects: PrecisionResult | None + medium_objects: PrecisionResult | None + large_objects: PrecisionResult | None + + def __str__(self) -> str: + """ + Format as a pretty string. + + Example: + ```pycon + >>> import numpy as np + >>> import supervision as sv + >>> from supervision.metrics import Precision + >>> predictions = sv.Detections( + ... xyxy=np.array([[0, 0, 10, 10]]), + ... class_id=np.array([0]), + ... confidence=np.array([0.9]) + ... ) + >>> targets = sv.Detections( + ... xyxy=np.array([[0, 0, 10, 10]]), + ... class_id=np.array([0]) + ... ) + >>> precision_metric = Precision() + >>> precision_result = precision_metric.update( + ... predictions, targets + ... ).compute() + >>> print(precision_result) # doctest: +ELLIPSIS + PrecisionResult: + Metric target: MetricTarget.BOXES + Averaging method: AveragingMethod.WEIGHTED + P @ 50: 1.0000 + P @ 75: 1.0000 + P @ thresh: [1. ... 1.] + IoU thresh: [0.5 0.55 ... 0.95] + Precision per class: + 0: [1. ... 1.] + ... + Medium objects: + PrecisionResult: + Metric target: MetricTarget.BOXES + Averaging method: AveragingMethod.WEIGHTED + P @ 50: 0.0000 + ... + + ``` + """ + out_str = ( + f"{self.__class__.__name__}:\n" + f"Metric target: {self.metric_target}\n" + f"Averaging method: {self.averaging_method}\n" + f"P @ 50: {self.precision_at_50:.4f}\n" + f"P @ 75: {self.precision_at_75:.4f}\n" + f"P @ thresh: {self.precision_scores}\n" + f"IoU thresh: {self.iou_thresholds}\n" + f"Precision per class:\n" + ) + if self.precision_per_class.size == 0: + out_str += " No results\n" + for class_id, precision_of_class in zip( + self.matched_classes, self.precision_per_class + ): + out_str += f" {class_id}: {precision_of_class}\n" + + indent = " " + if self.small_objects is not None: + indented = indent + str(self.small_objects).replace("\n", f"\n{indent}") + out_str += f"\nSmall objects:\n{indented}" + if self.medium_objects is not None: + indented = indent + str(self.medium_objects).replace("\n", f"\n{indent}") + out_str += f"\nMedium objects:\n{indented}" + if self.large_objects is not None: + indented = indent + str(self.large_objects).replace("\n", f"\n{indent}") + out_str += f"\nLarge objects:\n{indented}" + + return out_str + + def to_pandas(self) -> pd.DataFrame: + """ + Convert the result to a pandas DataFrame. + + Returns: + The result as a DataFrame. + """ + ensure_pandas_installed() + import pandas as pd + + pandas_data = { + "P@50": self.precision_at_50, + "P@75": self.precision_at_75, + } + + if self.small_objects is not None: + small_objects_df = self.small_objects.to_pandas() + for key, value in small_objects_df.items(): + pandas_data[f"small_objects_{key}"] = value + if self.medium_objects is not None: + medium_objects_df = self.medium_objects.to_pandas() + for key, value in medium_objects_df.items(): + pandas_data[f"medium_objects_{key}"] = value + if self.large_objects is not None: + large_objects_df = self.large_objects.to_pandas() + for key, value in large_objects_df.items(): + pandas_data[f"large_objects_{key}"] = value + + return pd.DataFrame(pandas_data, index=[0]) + + def plot(self) -> None: + """ + Plot the precision results. + + ![example_plot]( + https://media.roboflow.com/supervision-docs/metrics/precision_plot_example.png + ){ align=center width="800" } + """ + + from matplotlib import pyplot as plt + + labels = ["Precision@50", "Precision@75"] + values = [self.precision_at_50, self.precision_at_75] + colors = [LEGACY_COLOR_PALETTE[0]] * 2 + + if self.small_objects is not None: + small_objects = self.small_objects + labels += ["Small: P@50", "Small: P@75"] + values += [small_objects.precision_at_50, small_objects.precision_at_75] + colors += [LEGACY_COLOR_PALETTE[3]] * 2 + + if self.medium_objects is not None: + medium_objects = self.medium_objects + labels += ["Medium: P@50", "Medium: P@75"] + values += [medium_objects.precision_at_50, medium_objects.precision_at_75] + colors += [LEGACY_COLOR_PALETTE[2]] * 2 + + if self.large_objects is not None: + large_objects = self.large_objects + labels += ["Large: P@50", "Large: P@75"] + values += [large_objects.precision_at_50, large_objects.precision_at_75] + colors += [LEGACY_COLOR_PALETTE[4]] * 2 + + plt.rcParams["font.family"] = "monospace" + + _, ax = plt.subplots(figsize=(10, 6)) + ax.set_ylim(0, 1) + ax.set_ylabel("Value", fontweight="bold") + title = ( + f"Precision, by Object Size" + f"\n(target: {self.metric_target.value}," + f" averaging: {self.averaging_method.value})" + ) + ax.set_title(title, fontweight="bold") + + x_positions = range(len(labels)) + bars = ax.bar(x_positions, values, color=colors, align="center") + + ax.set_xticks(x_positions) + ax.set_xticklabels(labels, rotation=45, ha="right") + + for bar in bars: + y_value = bar.get_height() + ax.text( + bar.get_x() + bar.get_width() / 2, + y_value + 0.02, + f"{y_value:.2f}", + ha="center", + va="bottom", + ) + + plt.rcParams["font.family"] = "sans-serif" + + plt.tight_layout() + plt.show() diff --git a/src/supervision/metrics/recall.py b/src/supervision/metrics/recall.py new file mode 100644 index 0000000..dba16e1 --- /dev/null +++ b/src/supervision/metrics/recall.py @@ -0,0 +1,774 @@ +from __future__ import annotations + +from copy import deepcopy +from dataclasses import dataclass +from typing import TYPE_CHECKING, Any, cast + +import numpy as np +import numpy.typing as npt + +from supervision.config import ORIENTED_BOX_COORDINATES +from supervision.detection.compact_mask import CompactMask +from supervision.detection.core import Detections +from supervision.detection.utils.iou_and_nms import ( + box_iou_batch, + mask_iou_batch, + oriented_box_iou_batch, +) +from supervision.draw.color import LEGACY_COLOR_PALETTE +from supervision.metrics.core import AveragingMethod, Metric, MetricTarget +from supervision.metrics.utils.matching import ( + _match_detection_batch_with_target_indices, +) +from supervision.metrics.utils.object_size import ( + ObjectSizeCategory, + get_detection_size_category, +) +from supervision.metrics.utils.utils import ensure_pandas_installed + +if TYPE_CHECKING: + import pandas as pd + + +class Recall(Metric["RecallResult"]): + """ + Recall is a metric used to evaluate object detection models. It is the ratio of + true positive detections to the total number of ground truth instances. We calculate + it at different IoU thresholds. + + In simple terms, Recall is a measure of a model's completeness, calculated as: + + `Recall = TP / (TP + FN)` + + Here, `TP` is the number of true positives (correct detections), and `FN` is the + number of false negatives (missed detections). + + Examples: + ```pycon + >>> import numpy as np + >>> import supervision as sv + >>> from supervision.metrics import Recall + >>> predictions = sv.Detections( + ... xyxy=np.array([[0, 0, 10, 10]]), + ... class_id=np.array([0]), + ... confidence=np.array([0.9]) + ... ) + >>> targets = sv.Detections( + ... xyxy=np.array([[0, 0, 10, 10]]), + ... class_id=np.array([0]) + ... ) + >>> recall_metric = Recall() + >>> recall_result = recall_metric.update(predictions, targets).compute() + >>> round(float(recall_result.recall_at_50), 2) + 1.0 + + ``` + + ![example_plot]( + https://media.roboflow.com/supervision-docs/metrics/recall_plot_example.png + ){ align=center width="800" } + """ + + def __init__( + self, + metric_target: MetricTarget = MetricTarget.BOXES, + averaging_method: AveragingMethod = AveragingMethod.WEIGHTED, + ): + """ + Initialize the Recall metric. + + Args: + metric_target: The type of detection data to use. + averaging_method: The averaging method used to compute the + recall. Determines how the recall is aggregated across classes. + """ + self._metric_target = metric_target + self.averaging_method = averaging_method + + self._predictions_list: list[Detections] = [] + self._targets_list: list[Detections] = [] + + def reset(self) -> None: + """ + Reset the metric to its initial state, clearing all stored data. + """ + self._predictions_list = [] + self._targets_list = [] + + def update( + self, + predictions: Detections | list[Detections], + targets: Detections | list[Detections], + ) -> Recall: + """ + Add new predictions and targets to the metric, but do not compute the result. + + Args: + predictions: The predicted detections. + targets: The target detections. + + Returns: + The updated metric instance. + """ + if not isinstance(predictions, list): + predictions = [predictions] + if not isinstance(targets, list): + targets = [targets] + + if len(predictions) != len(targets): + raise ValueError( + f"The number of predictions ({len(predictions)}) and" + f" targets ({len(targets)}) during the update must be the same." + ) + + self._predictions_list.extend(predictions) + self._targets_list.extend(targets) + + return self + + def compute(self) -> RecallResult: + """ + Calculate the recall metric based on the stored predictions and ground-truth + data, at different IoU thresholds. + + Returns: + The recall metric result. + """ + result = self._compute(self._predictions_list, self._targets_list) + result.small_objects = self._compute( + self._predictions_list, self._targets_list, ObjectSizeCategory.SMALL + ) + result.medium_objects = self._compute( + self._predictions_list, self._targets_list, ObjectSizeCategory.MEDIUM + ) + result.large_objects = self._compute( + self._predictions_list, self._targets_list, ObjectSizeCategory.LARGE + ) + + return result + + def _compute( + self, + predictions_list: list[Detections], + targets_list: list[Detections], + size_category: ObjectSizeCategory = ObjectSizeCategory.ANY, + ) -> RecallResult: + if size_category != ObjectSizeCategory.ANY: + # Score the requested bucket on bucket-filtered targets so detections + # outside the bucket cannot consume the only available target. + targets_list = [ + self._filter_detections_by_size(targets, size_category) + for targets in targets_list + ] + size_category = ObjectSizeCategory.ANY + + iou_thresholds = np.linspace(0.5, 0.95, 10, dtype=np.float32) + stats: list[Any] = [] + + for predictions, targets in zip(predictions_list, targets_list): + prediction_contents = self._detections_content(predictions) + target_contents = self._detections_content(targets) + prediction_size_mask = np.ones(len(predictions), dtype=bool) + target_size_mask = np.ones(len(targets), dtype=bool) + if size_category != ObjectSizeCategory.ANY: + if len(predictions) > 0: + prediction_size_mask = ( + get_detection_size_category(predictions, self._metric_target) + == size_category.value + ) + if len(targets) > 0: + target_size_mask = ( + get_detection_size_category(targets, self._metric_target) + == size_category.value + ) + + if len(targets) > 0: + if predictions.class_id is None or targets.class_id is None: + raise ValueError( + "Recall metric requires `class_id` on both predictions " + "and targets." + ) + if len(predictions) == 0: + target_class_ids = np.asarray(targets.class_id, dtype=np.int32)[ + target_size_mask + ] + if len(target_class_ids) == 0: + continue + stats.append( + ( + np.zeros((0, iou_thresholds.size), dtype=bool), + np.zeros((0, iou_thresholds.size), dtype=bool), + np.zeros((0,), dtype=np.float32), + np.zeros((0,), dtype=int), + target_class_ids, + ) + ) + + else: + if predictions.confidence is None: + raise ValueError( + "Recall metric requires `confidence` on predictions." + ) + prediction_class_ids = np.asarray( + predictions.class_id, dtype=np.int32 + ) + target_class_ids = np.asarray(targets.class_id, dtype=np.int32) + prediction_confidence = np.asarray( + predictions.confidence, dtype=np.float32 + ) + if self._metric_target == MetricTarget.BOXES: + # BOXES target never yields CompactMask; narrow for mypy. + iou = box_iou_batch( + cast(npt.NDArray[np.number], target_contents), + cast(npt.NDArray[np.number], prediction_contents), + ) + elif self._metric_target == MetricTarget.MASKS: + iou = mask_iou_batch(target_contents, prediction_contents) + elif self._metric_target == MetricTarget.ORIENTED_BOUNDING_BOXES: + # OBB target never yields CompactMask; narrow for mypy. + iou = oriented_box_iou_batch( + cast(npt.NDArray[np.number], target_contents), + cast(npt.NDArray[np.number], prediction_contents), + ) + else: + raise ValueError( + "Unsupported metric target for IoU calculation" + ) + + matches, matched_target_indices = ( + _match_detection_batch_with_target_indices( + prediction_class_ids, + target_class_ids, + iou, + iou_thresholds, + ) + ) + ignored_matches = np.zeros_like(matches, dtype=bool) + if size_category != ObjectSizeCategory.ANY: + valid_target_match = matched_target_indices >= 0 + matched_scored_target = np.zeros_like(matches, dtype=bool) + if np.any(valid_target_match): + matched_scored_target[valid_target_match] = ( + target_size_mask[ + matched_target_indices[valid_target_match] + ] + ) + prediction_scored = ( + prediction_size_mask[:, None] | matched_scored_target + ) + ignored_matches = ~prediction_scored | ( + valid_target_match & ~matched_scored_target + ) + prediction_keep = np.any(~ignored_matches, axis=1) + matches = ( + matches[prediction_keep] + & matched_scored_target[prediction_keep] + ) + ignored_matches = ignored_matches[prediction_keep] + prediction_confidence = prediction_confidence[prediction_keep] + prediction_class_ids = prediction_class_ids[prediction_keep] + target_class_ids = target_class_ids[target_size_mask] + if ( + len(prediction_class_ids) == 0 + and len(target_class_ids) == 0 + ): + continue + stats.append( + ( + matches, + ignored_matches, + prediction_confidence, + prediction_class_ids, + target_class_ids, + ) + ) + + if not stats: + return RecallResult( + metric_target=self._metric_target, + averaging_method=self.averaging_method, + recall_scores=np.zeros(iou_thresholds.shape[0]), + recall_per_class=np.zeros((0, iou_thresholds.shape[0])), + iou_thresholds=iou_thresholds, + matched_classes=np.array([], dtype=int), + small_objects=None, + medium_objects=None, + large_objects=None, + ) + + concatenated_stats = [np.concatenate(items, 0) for items in zip(*stats)] + recall_scores, recall_per_class, unique_classes = ( + self._compute_recall_for_classes(*concatenated_stats) + ) + + return RecallResult( + metric_target=self._metric_target, + averaging_method=self.averaging_method, + recall_scores=recall_scores, + recall_per_class=recall_per_class, + iou_thresholds=iou_thresholds, + matched_classes=unique_classes, + small_objects=None, + medium_objects=None, + large_objects=None, + ) + + def _compute_recall_for_classes( + self, + matches: npt.NDArray[np.bool_], + ignored_matches: npt.NDArray[np.bool_], + prediction_confidence: npt.NDArray[np.float32], + prediction_class_ids: npt.NDArray[np.int32], + true_class_ids: npt.NDArray[np.int32], + ) -> tuple[ + npt.NDArray[np.float64], + npt.NDArray[np.float64], + npt.NDArray[np.int32], + ]: + sorted_indices = np.argsort(-prediction_confidence) + matches = matches[sorted_indices] + ignored_matches = ignored_matches[sorted_indices] + prediction_class_ids = prediction_class_ids[sorted_indices] + unique_classes, class_counts = np.unique(true_class_ids, return_counts=True) + + # Shape: PxTh,P,C,C -> CxThx3 + confusion_matrix = self._compute_confusion_matrix( + matches, ignored_matches, prediction_class_ids, unique_classes, class_counts + ) + + # Shape: CxThx3 -> CxTh + recall_per_class = self._compute_recall(confusion_matrix) + + # Shape: CxTh -> Th + if self.averaging_method == AveragingMethod.MACRO: + recall_scores = np.mean(recall_per_class, axis=0) + elif self.averaging_method == AveragingMethod.MICRO: + confusion_matrix_merged = confusion_matrix.sum(0) + recall_scores = self._compute_recall(confusion_matrix_merged) + elif self.averaging_method == AveragingMethod.WEIGHTED: + class_counts = class_counts.astype(np.float32) + if class_counts.sum() == 0: + # No ground-truth support (e.g. only false-positive classes, or a + # size bucket with predictions but no targets): weighting is + # undefined, so report 0 as the empty case did before. + recall_scores = np.zeros(recall_per_class.shape[1]) + else: + recall_scores = np.average( + recall_per_class, axis=0, weights=class_counts + ) + + return recall_scores, recall_per_class, unique_classes + + @staticmethod + def _match_detection_batch( + predictions_classes: npt.NDArray[np.int32], + target_classes: npt.NDArray[np.int32], + iou: npt.NDArray[np.float32], + iou_thresholds: npt.NDArray[np.float32], + ) -> npt.NDArray[np.bool_]: + result_correct, _ = _match_detection_batch_with_target_indices( + predictions_classes, target_classes, iou, iou_thresholds + ) + return result_correct + + @staticmethod + def _compute_confusion_matrix( + sorted_matches: npt.NDArray[np.bool_], + sorted_ignored_matches: npt.NDArray[np.bool_], + sorted_prediction_class_ids: npt.NDArray[np.int32], + unique_classes: npt.NDArray[np.integer], + class_counts: npt.NDArray[np.integer], + ) -> npt.NDArray[np.float64]: + """ + Compute the confusion matrix for each class and IoU threshold. + + Assumes the matches and prediction_class_ids are sorted by confidence + in descending order. + + Args: + sorted_matches: shape (P, Th), that is True + if the prediction is a true positive at the given IoU threshold. + sorted_ignored_matches: shape (P, Th), that is True + if the prediction should not affect the given IoU threshold. + sorted_prediction_class_ids: shape (P,), containing + the class id for each prediction. + unique_classes: shape (C,), containing the unique + class ids. + class_counts: shape (C,), containing the number + of true instances for each class. + + Returns: + shape (C, Th, 3), containing the true positives, false + positives, and false negatives for each class and IoU threshold. + """ + + num_thresholds = sorted_matches.shape[1] + num_classes = unique_classes.shape[0] + + confusion_matrix: npt.NDArray[np.float64] = np.zeros( + (num_classes, num_thresholds, 3), dtype=np.float64 + ) + for class_idx, class_id in enumerate(unique_classes): + is_class = sorted_prediction_class_ids == class_id + num_true = class_counts[class_idx] + num_predictions = is_class.sum() + + if num_predictions == 0: + true_positives = np.zeros(num_thresholds) + false_positives = np.zeros(num_thresholds) + false_negatives = np.full(num_thresholds, num_true) + elif num_true == 0: + true_positives = np.zeros(num_thresholds) + false_positives = (~sorted_ignored_matches[is_class]).sum(0) + false_negatives = np.zeros(num_thresholds) + else: + true_positives = sorted_matches[is_class].sum(0) + false_positives = ( + ~sorted_matches[is_class] & ~sorted_ignored_matches[is_class] + ).sum(0) + false_negatives = num_true - true_positives + confusion_matrix[class_idx] = np.stack( + [true_positives, false_positives, false_negatives], axis=1 + ) + result: npt.NDArray[np.float64] = confusion_matrix + return result + + @staticmethod + def _compute_recall( + confusion_matrix: npt.NDArray[np.float64], + ) -> npt.NDArray[np.float64]: + """ + Broadcastable function, computing the recall from the confusion matrix. + + Args: + confusion_matrix: shape (N, ..., 3), where the last dimension + contains the true positives, false positives, and false negatives. + + Returns: + shape (N, ...), containing the recall for each element. + """ + if not confusion_matrix.shape[-1] == 3: + raise ValueError( + f"Confusion matrix must have shape (..., 3), got " + f"{confusion_matrix.shape}" + ) + true_positives = confusion_matrix[..., 0] + false_negatives = confusion_matrix[..., 2] + + denominator = true_positives + false_negatives + recall = np.divide( + true_positives, + denominator, + out=np.zeros_like(true_positives), + where=denominator != 0, + ) + + result_recall: npt.NDArray[np.float64] = recall + return result_recall + + def _detections_content( + self, detections: Detections + ) -> npt.NDArray[Any] | CompactMask: + """Return boxes, masks or oriented bounding boxes from detections. + + For the mask target this may return a + :class:`~supervision.detection.compact_mask.CompactMask` rather than a + dense boolean array when the detections carry compact masks. + """ + if self._metric_target == MetricTarget.BOXES: + return cast(npt.NDArray[Any], detections.xyxy) + if self._metric_target == MetricTarget.MASKS: + if detections.mask is not None: + # detections.mask is NDArray[bool] | CompactMask; return as-is. + return detections.mask + if len(detections) > 0: + raise ValueError( + "Recall with `MetricTarget.MASKS` requires detections to " + "include masks." + ) + return self._make_empty_content() + if self._metric_target == MetricTarget.ORIENTED_BOUNDING_BOXES: + obb = detections.data.get(ORIENTED_BOX_COORDINATES) + if obb is not None and len(obb) > 0: + result_obb: npt.NDArray[np.float32] = np.array(obb, dtype=np.float32) + return result_obb + return self._make_empty_content() + raise ValueError(f"Invalid metric target: {self._metric_target}") + + def _make_empty_content(self) -> npt.NDArray[Any]: + if self._metric_target == MetricTarget.BOXES: + empty_boxes: npt.NDArray[np.float32] = np.empty((0, 4), dtype=np.float32) + return empty_boxes + + if self._metric_target == MetricTarget.MASKS: + empty_masks: npt.NDArray[np.bool_] = np.empty((0, 0, 0), dtype=bool) + return empty_masks + + if self._metric_target == MetricTarget.ORIENTED_BOUNDING_BOXES: + empty_obb: npt.NDArray[np.float32] = np.empty((0, 4, 2), dtype=np.float32) + return empty_obb + + raise ValueError(f"Invalid metric target: {self._metric_target}") + + raise ValueError(f"Invalid metric target: {self._metric_target}") + + def _filter_detections_by_size( + self, detections: Detections, size_category: ObjectSizeCategory + ) -> Detections: + """Return a copy of detections with contents filtered by object size.""" + new_detections = deepcopy(detections) + if detections.is_empty() or size_category == ObjectSizeCategory.ANY: + return new_detections + + sizes = get_detection_size_category(new_detections, self._metric_target) + size_mask = sizes == size_category.value + + new_detections.xyxy = new_detections.xyxy[size_mask] + if new_detections.mask is not None: + new_detections.mask = new_detections.mask[size_mask] + if new_detections.class_id is not None: + new_detections.class_id = new_detections.class_id[size_mask] + if new_detections.confidence is not None: + new_detections.confidence = new_detections.confidence[size_mask] + if new_detections.tracker_id is not None: + new_detections.tracker_id = new_detections.tracker_id[size_mask] + if new_detections.data is not None: + for key, value in new_detections.data.items(): + new_detections.data[key] = np.array(value)[size_mask] + + return new_detections + + def _filter_predictions_and_targets_by_size( + self, + predictions_list: list[Detections], + targets_list: list[Detections], + size_category: ObjectSizeCategory, + ) -> tuple[list[Detections], list[Detections]]: + """ + Filter predictions and targets by object size category. + """ + new_predictions_list = [] + new_targets_list = [] + for predictions, targets in zip(predictions_list, targets_list): + new_predictions_list.append( + self._filter_detections_by_size(predictions, size_category) + ) + new_targets_list.append( + self._filter_detections_by_size(targets, size_category) + ) + return new_predictions_list, new_targets_list + + +@dataclass +class RecallResult: + """ + The results of the recall metric calculation. + + Defaults to `0` if no detections or targets were provided. + + Attributes: + metric_target: the type of data used for the metric - + boxes, masks or oriented bounding boxes. + averaging_method: the averaging method used to compute the + recall. Determines how the recall is aggregated across classes. + recall_at_50: the recall at IoU threshold of `0.5`. + recall_at_75: the recall at IoU threshold of `0.75`. + recall_scores: the recall scores at each IoU threshold. + Shape: `(num_iou_thresholds,)` + recall_per_class: the recall scores per class and IoU threshold. + Shape: `(num_target_classes, num_iou_thresholds)` + iou_thresholds: the IoU thresholds used in the calculations. + matched_classes: the class IDs of all matched classes. + Corresponds to the rows of `recall_per_class`. + small_objects: the Recall metric results + for small objects (area < 32ยฒ). + medium_objects: the Recall metric results + for medium objects (32ยฒ โ‰ค area < 96ยฒ). + large_objects: the Recall metric results + for large objects (area โ‰ฅ 96ยฒ). + """ + + metric_target: MetricTarget + averaging_method: AveragingMethod + + @property + def recall_at_50(self) -> float: + return float(self.recall_scores[0]) + + @property + def recall_at_75(self) -> float: + return float(self.recall_scores[5]) + + recall_scores: npt.NDArray[np.float64] + recall_per_class: npt.NDArray[np.float64] + iou_thresholds: npt.NDArray[np.float32] + matched_classes: npt.NDArray[np.int32] + + small_objects: RecallResult | None + medium_objects: RecallResult | None + large_objects: RecallResult | None + + def __str__(self) -> str: + """ + Format as a pretty string. + + Example: + ```pycon + >>> import numpy as np + >>> import supervision as sv + >>> from supervision.metrics import Recall + >>> predictions = sv.Detections( + ... xyxy=np.array([[0, 0, 10, 10]]), + ... class_id=np.array([0]), + ... confidence=np.array([0.9]) + ... ) + >>> targets = sv.Detections( + ... xyxy=np.array([[0, 0, 10, 10]]), + ... class_id=np.array([0]) + ... ) + >>> recall_metric = Recall() + >>> recall_result = recall_metric.update(predictions, targets).compute() + >>> print(recall_result) # doctest: +ELLIPSIS + RecallResult: + Metric target: MetricTarget.BOXES + Averaging method: AveragingMethod.WEIGHTED + R @ 50: 1.0000 + R @ 75: 1.0000 + R @ thresh: [1. ... 1.] + IoU thresh: [0.5 0.55 ... 0.95] + Recall per class: + 0: [1. ... 1.] + ... + Medium objects: + RecallResult: + Metric target: MetricTarget.BOXES + Averaging method: AveragingMethod.WEIGHTED + R @ 50: 0.0000 + ... + + ``` + """ + out_str = ( + f"{self.__class__.__name__}:\n" + f"Metric target: {self.metric_target}\n" + f"Averaging method: {self.averaging_method}\n" + f"R @ 50: {self.recall_at_50:.4f}\n" + f"R @ 75: {self.recall_at_75:.4f}\n" + f"R @ thresh: {self.recall_scores}\n" + f"IoU thresh: {self.iou_thresholds}\n" + f"Recall per class:\n" + ) + if self.recall_per_class.size == 0: + out_str += " No results\n" + for class_id, recall_of_class in zip( + self.matched_classes, self.recall_per_class + ): + out_str += f" {class_id}: {recall_of_class}\n" + + indent = " " + if self.small_objects is not None: + indented = indent + str(self.small_objects).replace("\n", f"\n{indent}") + out_str += f"\nSmall objects:\n{indented}" + if self.medium_objects is not None: + indented = indent + str(self.medium_objects).replace("\n", f"\n{indent}") + out_str += f"\nMedium objects:\n{indented}" + if self.large_objects is not None: + indented = indent + str(self.large_objects).replace("\n", f"\n{indent}") + out_str += f"\nLarge objects:\n{indented}" + + return out_str + + def to_pandas(self) -> pd.DataFrame: + """ + Convert the result to a pandas DataFrame. + + Returns: + The result as a DataFrame. + """ + ensure_pandas_installed() + import pandas as pd + + pandas_data: dict[str, Any] = { + "R@50": self.recall_at_50, + "R@75": self.recall_at_75, + } + + if self.small_objects is not None: + small_objects_df = self.small_objects.to_pandas() + for key, value in small_objects_df.items(): + pandas_data[f"small_objects_{key}"] = value + if self.medium_objects is not None: + medium_objects_df = self.medium_objects.to_pandas() + for key, value in medium_objects_df.items(): + pandas_data[f"medium_objects_{key}"] = value + if self.large_objects is not None: + large_objects_df = self.large_objects.to_pandas() + for key, value in large_objects_df.items(): + pandas_data[f"large_objects_{key}"] = value + + return pd.DataFrame(pandas_data, index=[0]) + + def plot(self) -> None: + """ + Plot the recall results. + + ![example_plot]( + https://media.roboflow.com/supervision-docs/metrics/recall_plot_example.png + ){ align=center width="800" } + """ + from matplotlib import pyplot as plt + + labels = ["Recall@50", "Recall@75"] + values = [self.recall_at_50, self.recall_at_75] + colors = [LEGACY_COLOR_PALETTE[0]] * 2 + + if self.small_objects is not None: + small_objects = self.small_objects + labels += ["Small: R@50", "Small: R@75"] + values += [small_objects.recall_at_50, small_objects.recall_at_75] + colors += [LEGACY_COLOR_PALETTE[3]] * 2 + + if self.medium_objects is not None: + medium_objects = self.medium_objects + labels += ["Medium: R@50", "Medium: R@75"] + values += [medium_objects.recall_at_50, medium_objects.recall_at_75] + colors += [LEGACY_COLOR_PALETTE[2]] * 2 + + if self.large_objects is not None: + large_objects = self.large_objects + labels += ["Large: R@50", "Large: R@75"] + values += [large_objects.recall_at_50, large_objects.recall_at_75] + colors += [LEGACY_COLOR_PALETTE[4]] * 2 + + plt.rcParams["font.family"] = "monospace" + + _, ax = plt.subplots(figsize=(10, 6)) + ax.set_ylim(0, 1) + ax.set_ylabel("Value", fontweight="bold") + title = ( + f"Recall, by Object Size" + f"\n(target: {self.metric_target.value}," + f" averaging: {self.averaging_method.value})" + ) + ax.set_title(title, fontweight="bold") + + x_positions = range(len(labels)) + bars = ax.bar(x_positions, values, color=colors, align="center") + + ax.set_xticks(x_positions) + ax.set_xticklabels(labels, rotation=45, ha="right") + + for bar in bars: + y_value = bar.get_height() + ax.text( + bar.get_x() + bar.get_width() / 2, + y_value + 0.02, + f"{y_value:.2f}", + ha="center", + va="bottom", + ) + + plt.rcParams["font.family"] = "sans-serif" + + plt.tight_layout() + plt.show() diff --git a/src/supervision/metrics/utils/__init__.py b/src/supervision/metrics/utils/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/src/supervision/metrics/utils/matching.py b/src/supervision/metrics/utils/matching.py new file mode 100644 index 0000000..dc72234 --- /dev/null +++ b/src/supervision/metrics/utils/matching.py @@ -0,0 +1,56 @@ +from collections.abc import Iterator + +import numpy as np +import numpy.typing as npt + + +def _greedy_match( + iou: npt.NDArray[np.float32], + matched_indices: tuple[npt.NDArray[np.intp], ...], +) -> Iterator[tuple[int, int]]: + """Yield (target_idx, pred_idx) pairs in greedy highest-IoU-first one-to-one order. + + Candidate pairs are sorted by descending IoU and assigned one-to-one: a pair + is accepted only when neither the target nor the prediction has been matched. + + Examples: + >>> import numpy as np + >>> iou = np.array([[1.0, 0.667], [0.333, 0.538]], dtype=np.float32) + >>> matched_indices = np.where(iou >= 0.5) + >>> list(_greedy_match(iou, matched_indices)) + [(0, 0), (1, 1)] + """ + target_idx = matched_indices[0] + pred_idx = matched_indices[1] + iou_values = iou[matched_indices] + order = np.argsort(-iou_values, kind="stable") + matched_targets: set[int] = set() + matched_preds: set[int] = set() + for t, p in zip(target_idx[order].tolist(), pred_idx[order].tolist()): + if t not in matched_targets and p not in matched_preds: + matched_targets.add(t) + matched_preds.add(p) + yield t, p + + +def _match_detection_batch_with_target_indices( + predictions_classes: npt.NDArray[np.int32], + target_classes: npt.NDArray[np.int32], + iou: npt.NDArray[np.float32], + iou_thresholds: npt.NDArray[np.float32], +) -> tuple[npt.NDArray[np.bool_], npt.NDArray[np.int32]]: + """Match predictions to targets and retain target indices per IoU threshold.""" + num_predictions = predictions_classes.shape[0] + num_iou_levels = iou_thresholds.shape[0] + correct = np.zeros((num_predictions, num_iou_levels), dtype=bool) + matched_targets = np.full((num_predictions, num_iou_levels), -1, dtype=np.int32) + correct_class = target_classes[:, None] == predictions_classes + + for i, iou_level in enumerate(iou_thresholds): + matched_indices = np.where((iou >= iou_level) & correct_class) + + for target_idx, prediction_idx in _greedy_match(iou, matched_indices): + correct[prediction_idx, i] = True + matched_targets[prediction_idx, i] = target_idx + + return correct, matched_targets diff --git a/src/supervision/metrics/utils/object_size.py b/src/supervision/metrics/utils/object_size.py new file mode 100644 index 0000000..2ed706d --- /dev/null +++ b/src/supervision/metrics/utils/object_size.py @@ -0,0 +1,256 @@ +from __future__ import annotations + +from enum import Enum +from typing import TYPE_CHECKING, cast + +import numpy as np +import numpy.typing as npt + +from supervision.config import ORIENTED_BOX_COORDINATES +from supervision.detection.compact_mask import CompactMask +from supervision.detection.utils.masks import count_mask_pixels +from supervision.metrics.core import MetricTarget + +if TYPE_CHECKING: + from supervision.detection.core import Detections + +SIZE_THRESHOLDS = (32**2, 96**2) + + +class ObjectSizeCategory(Enum): + """ + Enum for object size categories based on area in pixels. + + Small: area < 32^2 + Medium: 32^2 <= area < 96^2 + Large: area >= 96^2 + + Example: + ```pycon + >>> from supervision.metrics.utils.object_size import ObjectSizeCategory + >>> ObjectSizeCategory.SMALL.value + 1 + >>> ObjectSizeCategory.MEDIUM.value + 2 + >>> ObjectSizeCategory.LARGE.value + 3 + + ``` + """ + + ANY = -1 + SMALL = 1 + MEDIUM = 2 + LARGE = 3 + + +def get_object_size_category( + data: npt.NDArray[np.number] | npt.NDArray[np.bool_], + metric_target: MetricTarget, +) -> npt.NDArray[np.int_]: + """ + Get the size category of an object. Distinguish based on the metric target. + + Args: + data: The object data, shaped (N, ...). + metric_target: Determines whether boxes, masks or + oriented bounding boxes are used. + + Returns: + The size category of each object, matching + the enum values of ObjectSizeCategory. Shaped (N,). + + Example: + ```pycon + >>> import numpy as np + >>> from supervision.metrics.core import MetricTarget + >>> from supervision.metrics.utils.object_size import get_object_size_category + >>> xyxy = np.array([ + ... [0, 0, 10, 10], # 100 (Small) + ... [0, 0, 50, 50], # 2500 (Medium) + ... [0, 0, 100, 100] # 10000 (Large) + ... ]) + >>> get_object_size_category(xyxy, MetricTarget.BOXES) + array([1, 2, 3]) + + ``` + """ + if metric_target == MetricTarget.BOXES: + bbox_data = cast(npt.NDArray[np.number], data) + return get_bbox_size_category(bbox_data) + if metric_target == MetricTarget.MASKS: + mask_data = cast(npt.NDArray[np.bool_], data) + return get_mask_size_category(mask_data) + if metric_target == MetricTarget.ORIENTED_BOUNDING_BOXES: + obb_data = cast(npt.NDArray[np.number], data) + return get_obb_size_category(obb_data) + raise ValueError("Invalid metric type") + + +def get_bbox_size_category(xyxy: npt.NDArray[np.number]) -> npt.NDArray[np.int_]: + """ + Get the size category of a bounding boxes array. + + Args: + xyxy: The bounding boxes array shaped (N, 4). + + Returns: + The size category of each bounding box, matching + the enum values of ObjectSizeCategory. Shaped (N,). + + Example: + ```pycon + >>> import numpy as np + >>> from supervision.metrics.utils.object_size import get_bbox_size_category + >>> xyxy = np.array([ + ... [0, 0, 31, 31], # 961 (Small) + ... [0, 0, 32, 32], # 1024 (Medium) + ... [0, 0, 95, 95], # 9025 (Medium) + ... [0, 0, 96, 96] # 9216 (Large) + ... ]) + >>> get_bbox_size_category(xyxy) + array([1, 2, 2, 3]) + + ``` + """ + if len(xyxy.shape) != 2 or xyxy.shape[1] != 4: + raise ValueError("Bounding boxes must be shaped (N, 4)") + + width = xyxy[:, 2] - xyxy[:, 0] + height = xyxy[:, 3] - xyxy[:, 1] + areas = width * height + + result = np.full(areas.shape, ObjectSizeCategory.ANY.value) + SM, LG = SIZE_THRESHOLDS + result[areas < SM] = ObjectSizeCategory.SMALL.value + result[(areas >= SM) & (areas < LG)] = ObjectSizeCategory.MEDIUM.value + result[areas >= LG] = ObjectSizeCategory.LARGE.value + return result + + +def get_mask_size_category( + mask: npt.NDArray[np.bool_] | CompactMask, +) -> npt.NDArray[np.int_]: + """ + Get the size category of detection masks. + + Args: + mask: The mask array shaped (N, H, W), or a + :class:`~supervision.detection.compact_mask.CompactMask`. + + Returns: + The size category of each mask, matching + the enum values of ObjectSizeCategory. Shaped (N,). + + Example: + ```pycon + >>> import numpy as np + >>> from supervision.metrics.utils.object_size import get_mask_size_category + >>> mask = np.zeros((3, 100, 100), dtype=bool) + >>> mask[0, 0:10, 0:10] = True # 100 (Small) + >>> mask[1, 0:50, 0:50] = True # 2500 (Medium) + >>> mask[2, 0:100, 0:100] = True # 10000 (Large) + >>> get_mask_size_category(mask) + array([1, 2, 3]) + + ``` + """ + if isinstance(mask, CompactMask): + areas = mask.area + else: + if len(mask.shape) != 3: + raise ValueError("Masks must be shaped (N, H, W)") + # count_mask_pixels uses np.count_nonzero (no axis), which dispatches + # to SIMD popcount over the bool buffer and is ~6x faster than the + # vectorized np.sum(mask, axis=(1, 2)). Do not "simplify" back to + # np.sum(axis=(1,2)); benchmark before reverting. dtype=np.int64 keeps + # areas consistent across platforms (Windows NumPy defaults to int32). + areas = count_mask_pixels(mask) + + result = np.full(areas.shape, ObjectSizeCategory.ANY.value) + SM, LG = SIZE_THRESHOLDS + result[areas < SM] = ObjectSizeCategory.SMALL.value + result[(areas >= SM) & (areas < LG)] = ObjectSizeCategory.MEDIUM.value + result[areas >= LG] = ObjectSizeCategory.LARGE.value + return result + + +def get_obb_size_category(xyxyxyxy: npt.NDArray[np.number]) -> npt.NDArray[np.int_]: + """ + Get the size category of a oriented bounding boxes array. + + Args: + xyxyxyxy: The bounding boxes array shaped (N, 4, 2). + + Returns: + The size category of each bounding box, matching + the enum values of ObjectSizeCategory. Shaped (N,). + + Example: + ```pycon + >>> import numpy as np + >>> from supervision.metrics.utils.object_size import get_obb_size_category + >>> obb = np.array([ + ... [[0, 0], [10, 0], [10, 10], [0, 10]], # 100 (Small) + ... [[0, 0], [50, 0], [50, 50], [0, 50]], # 2500 (Medium) + ... [[0, 0], [100, 0], [100, 100], [0, 100]] # 10000 (Large) + ... ]) + >>> get_obb_size_category(obb) + array([1, 2, 3]) + + ``` + """ + if len(xyxyxyxy.shape) != 3 or xyxyxyxy.shape[1] != 4 or xyxyxyxy.shape[2] != 2: + raise ValueError("Oriented bounding boxes must be shaped (N, 4, 2)") + + # Shoelace formula + x = xyxyxyxy[:, :, 0] + y = xyxyxyxy[:, :, 1] + x1, x2, x3, x4 = x.T + y1, y2, y3, y4 = y.T + areas = 0.5 * np.abs( + (x1 * y2 + x2 * y3 + x3 * y4 + x4 * y1) + - (x2 * y1 + x3 * y2 + x4 * y3 + x1 * y4) + ) + + result = np.full(areas.shape, ObjectSizeCategory.ANY.value) + SM, LG = SIZE_THRESHOLDS + result[areas < SM] = ObjectSizeCategory.SMALL.value + result[(areas >= SM) & (areas < LG)] = ObjectSizeCategory.MEDIUM.value + result[areas >= LG] = ObjectSizeCategory.LARGE.value + return result + + +def get_detection_size_category( + detections: Detections, metric_target: MetricTarget = MetricTarget.BOXES +) -> npt.NDArray[np.int_]: + """ + Get the size category of a detections object. + + Args: + detections: The detections object. + metric_target: Determines whether boxes, masks or + oriented bounding boxes are used. + + Returns: + The size category of each bounding box, matching + the enum values of ObjectSizeCategory. Shaped (N,). + """ + if metric_target == MetricTarget.BOXES: + return get_bbox_size_category(detections.xyxy) + if metric_target == MetricTarget.MASKS: + mask = detections.mask + if mask is None: + raise ValueError("Detections mask is not available") + return get_mask_size_category(mask) + if metric_target == MetricTarget.ORIENTED_BOUNDING_BOXES: + oriented_box_coordinates = detections.data.get(ORIENTED_BOX_COORDINATES) + if oriented_box_coordinates is None: + raise ValueError("Detections oriented bounding boxes are not available") + return get_obb_size_category( + cast( + npt.NDArray[np.number], + np.asarray(oriented_box_coordinates, dtype=np.float32), + ) + ) + raise ValueError("Invalid metric type") diff --git a/src/supervision/metrics/utils/utils.py b/src/supervision/metrics/utils/utils.py new file mode 100644 index 0000000..a108279 --- /dev/null +++ b/src/supervision/metrics/utils/utils.py @@ -0,0 +1,9 @@ +def ensure_pandas_installed() -> None: + try: + import pandas # noqa + except ImportError: + raise ImportError( + "`metrics` extra is required to run the function." + " Run `uv pip install 'supervision[metrics]'` or" + " `uv add supervision --extra metrics`." + ) diff --git a/src/supervision/py.typed b/src/supervision/py.typed new file mode 100644 index 0000000..e69de29 diff --git a/src/supervision/tracker/__init__.py b/src/supervision/tracker/__init__.py new file mode 100644 index 0000000..3aa57aa --- /dev/null +++ b/src/supervision/tracker/__init__.py @@ -0,0 +1,5 @@ +"""Deprecated tracker compatibility exports.""" + +from supervision.tracker.byte_tracker.core import ByteTrack + +__all__ = ["ByteTrack"] diff --git a/src/supervision/tracker/byte_tracker/__init__.py b/src/supervision/tracker/byte_tracker/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/src/supervision/tracker/byte_tracker/core.py b/src/supervision/tracker/byte_tracker/core.py new file mode 100644 index 0000000..afb594b --- /dev/null +++ b/src/supervision/tracker/byte_tracker/core.py @@ -0,0 +1,418 @@ +import numpy as np +import numpy.typing as npt +from deprecate import ( # type: ignore[import-untyped,unused-ignore] + TargetMode, + deprecated_class, +) + +from supervision.detection.core import Detections +from supervision.detection.utils.iou_and_nms import box_iou_batch +from supervision.tracker.byte_tracker import matching +from supervision.tracker.byte_tracker.kalman_filter import KalmanFilter +from supervision.tracker.byte_tracker.single_object_track import STrack, TrackState +from supervision.tracker.byte_tracker.utils import IdCounter + + +def _valid_tracking_tensors( + tensors: npt.NDArray[np.float32], +) -> npt.NDArray[np.bool_]: + """Identify finite tensors with positive-width and positive-height boxes.""" + bboxes = tensors[:, :4] + widths = bboxes[:, 2] - bboxes[:, 0] + heights = bboxes[:, 3] - bboxes[:, 1] + return np.isfinite(tensors).all(axis=1) & (widths > 0) & (heights > 0) + + +@deprecated_class( + target=TargetMode.NOTIFY, + deprecated_in="0.28.0", + remove_in="0.31.0", +) +class ByteTrack: + """ + Initialize the ByteTrack object. + + !!! deprecated "Deprecated" + + `ByteTrack` is deprecated since `supervision-0.28.0` and will be removed in + `supervision-0.31.0`. Use `ByteTrackTracker` from the `trackers` package + instead (`pip install trackers`). Note: the update method is renamed from + `update_with_detections()` to `update()`. + + + + Args: + track_activation_threshold: Detection confidence threshold + for track activation. Increasing track_activation_threshold improves accuracy + and stability but might miss true detections. Decreasing it increases + completeness but risks introducing noise and instability. + lost_track_buffer: Number of frames to buffer when a track is lost. + Increasing lost_track_buffer enhances occlusion handling, significantly + reducing the likelihood of track fragmentation or disappearance caused + by brief detection gaps. + minimum_matching_threshold: Threshold for matching tracks with detections. + Decreasing minimum_matching_threshold improves accuracy but risks fragmentation. + Increasing it improves completeness but risks false positives and drift. + frame_rate: The frame rate of the video. Accepts float values (e.g. 23.976, + 29.97) for accurate lost-track-buffer calculation. + minimum_consecutive_frames: Number of consecutive frames that an object must + be tracked before it is considered a 'valid' track. + Increasing minimum_consecutive_frames prevents the creation of accidental tracks from + false detection or double detection, but risks missing shorter tracks. + """ # noqa: E501 // docs + + def __init__( + self, + track_activation_threshold: float = 0.25, + lost_track_buffer: int = 30, + minimum_matching_threshold: float = 0.8, + frame_rate: float = 30, + minimum_consecutive_frames: int = 1, + ) -> None: + self.track_activation_threshold = track_activation_threshold + self.minimum_matching_threshold = minimum_matching_threshold + + self.frame_id = 0 + self.det_thresh = self.track_activation_threshold + 0.1 + if self.det_thresh > 1.0: + self.det_thresh = self.track_activation_threshold + self.max_time_lost = int(frame_rate / 30.0 * lost_track_buffer) + self.minimum_consecutive_frames = minimum_consecutive_frames + self.kalman_filter = KalmanFilter() + self.shared_kalman = KalmanFilter() + + self.tracked_tracks: list[STrack] = [] + self.lost_tracks: list[STrack] = [] + self.removed_tracks: list[STrack] = [] + + # Warning, possible bug: If you also set internal_id to start at 1, + # all traces will be connected across objects. + self.internal_id_counter = IdCounter() + self.external_id_counter = IdCounter(start_id=1) + + def update_with_detections(self, detections: Detections) -> Detections: + """ + Updates the tracker with the provided detections and returns the updated + detection results. + + Args: + detections: The detections to pass through the tracker. + + Example: + ```python + import supervision as sv + from ultralytics import YOLO + + model = YOLO("") + tracker = sv.ByteTrack() + + box_annotator = sv.BoxAnnotator() + label_annotator = sv.LabelAnnotator() + + def callback(frame: np.ndarray, index: int) -> np.ndarray: + results = model(frame)[0] + detections = sv.Detections.from_ultralytics(results) + detections = tracker.update_with_detections(detections) + + labels = [f"#{tracker_id}" for tracker_id in detections.tracker_id] + + annotated_frame = box_annotator.annotate( + scene=frame.copy(), detections=detections) + annotated_frame = label_annotator.annotate( + scene=annotated_frame, detections=detections, labels=labels) + return annotated_frame + + sv.process_video( + source_path="", + target_path="", + callback=callback + ) + ``` + """ + if detections.confidence is None: + raise ValueError("Detections confidence must be provided for tracking.") + + tensors = np.hstack( + ( + detections.xyxy, + detections.confidence[:, np.newaxis], + ) + ) + tracks = self.update_with_tensors(tensors=tensors) + + if len(tracks) > 0: + detection_bounding_boxes = np.asarray([det[:4] for det in tensors]) + track_bounding_boxes = np.asarray([track.tlbr for track in tracks]) + + ious = box_iou_batch(detection_bounding_boxes, track_bounding_boxes) + + iou_costs: npt.NDArray[np.float32] = 1 - ious + + matches, _, _ = matching.linear_assignment(iou_costs, 0.5) + tracked_detections = detections.select(slice(None)) + tracked_detections.tracker_id = np.full(len(detections), -1, dtype=int) + for i_detection, i_track in matches: + tracked_detections.tracker_id[i_detection] = int( + tracks[i_track].external_track_id + ) + + return tracked_detections.select(tracked_detections.tracker_id != -1) + + else: + detections = Detections.empty() + detections.tracker_id = np.array([], dtype=int) + + return detections + + def reset(self) -> None: + """ + Resets the internal state of the ByteTrack tracker. + + This method clears the tracking data, including tracked, lost, + and removed tracks, as well as resetting the frame counter. It's + particularly useful when processing multiple videos sequentially, + ensuring the tracker starts with a clean state for each new video. + """ + self.frame_id = 0 + self.internal_id_counter.reset() + self.external_id_counter.reset() + self.tracked_tracks = [] + self.lost_tracks = [] + self.removed_tracks = [] + + def update_with_tensors(self, tensors: npt.NDArray[np.float32]) -> list[STrack]: + """ + Updates the tracker with the provided tensors and returns the updated tracks. + + Args: + tensors: The new tensors to update with. + + Returns: + Updated tracks. + """ + self.frame_id += 1 + activated_starcks = [] + refind_stracks = [] + lost_stracks = [] + removed_stracks = [] + + tensors = tensors[_valid_tracking_tensors(tensors)] + scores = tensors[:, 4] + bboxes = tensors[:, :4] + + remain_inds = scores >= self.track_activation_threshold + inds_low = scores > 0.1 + inds_high = scores < self.track_activation_threshold + + inds_second = np.logical_and(inds_low, inds_high) + dets_second = bboxes[inds_second] + dets = bboxes[remain_inds] + scores_keep = scores[remain_inds] + scores_second = scores[inds_second] + + if len(dets) > 0: + """Detections""" + detections = [ + STrack( + STrack.tlbr_to_tlwh(tlbr), + score_keep, + self.minimum_consecutive_frames, + self.shared_kalman, + self.internal_id_counter, + self.external_id_counter, + ) + for (tlbr, score_keep) in zip(dets, scores_keep) + ] + else: + detections = [] + + """ Add newly detected tracklets to tracked_stracks""" + unconfirmed = [] + tracked_stracks: list[STrack] = [] + + for track in self.tracked_tracks: + if not track.is_activated: + unconfirmed.append(track) + else: + tracked_stracks.append(track) + + """ Step 2: First association, with high score detection boxes""" + strack_pool = joint_tracks(tracked_stracks, self.lost_tracks) + # Predict the current location with KF + STrack.multi_predict(strack_pool, self.shared_kalman) + dists = matching.iou_distance(strack_pool, detections) + + dists = matching.fuse_score(dists, detections) + matches, u_track, u_detection = matching.linear_assignment( + dists, thresh=self.minimum_matching_threshold + ) + + for itracked, idet in matches: + track = strack_pool[itracked] + det = detections[idet] + if track.state == TrackState.Tracked: + track.update(detections[idet], self.frame_id) + activated_starcks.append(track) + else: + track.re_activate(det, self.frame_id) + refind_stracks.append(track) + + """ Step 3: Second association, with low score detection boxes""" + # association the untrack to the low score detections + if len(dets_second) > 0: + """Detections""" + detections_second = [ + STrack( + STrack.tlbr_to_tlwh(tlbr), + score_second, + self.minimum_consecutive_frames, + self.shared_kalman, + self.internal_id_counter, + self.external_id_counter, + ) + for (tlbr, score_second) in zip(dets_second, scores_second) + ] + else: + detections_second = [] + r_tracked_stracks = [ + strack_pool[i] + for i in u_track + if strack_pool[i].state == TrackState.Tracked + ] + dists = matching.iou_distance(r_tracked_stracks, detections_second) + matches, u_track, _u_detection_second = matching.linear_assignment( + dists, thresh=0.5 + ) + for itracked, idet in matches: + track = r_tracked_stracks[itracked] + det = detections_second[idet] + if track.state == TrackState.Tracked: + track.update(det, self.frame_id) + activated_starcks.append(track) + else: + track.re_activate(det, self.frame_id) + refind_stracks.append(track) + + for it in u_track: + track = r_tracked_stracks[it] + if not track.state == TrackState.Lost: + track.state = TrackState.Lost + lost_stracks.append(track) + + """Deal with unconfirmed tracks, usually tracks with only one beginning frame""" + detections = [detections[i] for i in u_detection] + dists = matching.iou_distance(unconfirmed, detections) + + dists = matching.fuse_score(dists, detections) + matches, u_unconfirmed, u_detection = matching.linear_assignment( + dists, thresh=0.7 + ) + for itracked, idet in matches: + unconfirmed[itracked].update(detections[idet], self.frame_id) + activated_starcks.append(unconfirmed[itracked]) + for it in u_unconfirmed: + track = unconfirmed[it] + track.state = TrackState.Removed + removed_stracks.append(track) + + """ Step 4: Init new stracks""" + for inew in u_detection: + track = detections[inew] + if track.score < self.det_thresh: + continue + track.activate(self.kalman_filter, self.frame_id) + activated_starcks.append(track) + """ Step 5: Update state""" + for track in self.lost_tracks: + if self.frame_id - track.frame_id > self.max_time_lost: + track.state = TrackState.Removed + removed_stracks.append(track) + + self.tracked_tracks = [ + t for t in self.tracked_tracks if t.state == TrackState.Tracked + ] + self.tracked_tracks = joint_tracks(self.tracked_tracks, activated_starcks) + self.tracked_tracks = joint_tracks(self.tracked_tracks, refind_stracks) + self.lost_tracks = sub_tracks(self.lost_tracks, self.tracked_tracks) + self.lost_tracks.extend(lost_stracks) + self.lost_tracks = sub_tracks(self.lost_tracks, self.removed_tracks) + self.removed_tracks = removed_stracks + self.tracked_tracks, self.lost_tracks = remove_duplicate_tracks( + self.tracked_tracks, self.lost_tracks + ) + output_stracks = [track for track in self.tracked_tracks if track.is_activated] + + return output_stracks + + +def joint_tracks( + track_list_a: list[STrack], track_list_b: list[STrack] +) -> list[STrack]: + """ + Joins two lists of tracks, ensuring that the resulting list does not + contain tracks with duplicate internal_track_id values. + + Args: + track_list_a: First list of tracks. + track_list_b: Second list of tracks. + + Returns: + Combined list of tracks from track_list_a and track_list_b + without duplicate internal_track_id values. + """ + seen_track_ids = set() + result = [] + + for track in track_list_a + track_list_b: + if track.internal_track_id not in seen_track_ids: + seen_track_ids.add(track.internal_track_id) + result.append(track) + + return result + + +def sub_tracks(track_list_a: list[STrack], track_list_b: list[STrack]) -> list[STrack]: + """ + Returns a list of tracks from track_list_a after removing any tracks + that share the same internal_track_id with tracks in track_list_b. + + Args: + track_list_a: List of tracks. + track_list_b: List of tracks to be subtracted from track_list_a. + Returns: + List of remaining tracks from track_list_a after subtraction. + """ + tracks = {track.internal_track_id: track for track in track_list_a} + track_ids_b = {track.internal_track_id for track in track_list_b} + + for track_id in track_ids_b: + tracks.pop(track_id, None) + + return list(tracks.values()) + + +def remove_duplicate_tracks( + tracks_a: list[STrack], tracks_b: list[STrack] +) -> tuple[list[STrack], list[STrack]]: + pairwise_distance = matching.iou_distance(tracks_a, tracks_b) + matching_pairs = np.where(pairwise_distance < 0.05) + + duplicates_a, duplicates_b = set(), set() + for track_index_a, track_index_b in zip(*matching_pairs): + time_a = tracks_a[track_index_a].frame_id - tracks_a[track_index_a].start_frame + time_b = tracks_b[track_index_b].frame_id - tracks_b[track_index_b].start_frame + if time_a > time_b: + duplicates_b.add(track_index_b) + else: + duplicates_a.add(track_index_a) + + result_a = [ + track for index, track in enumerate(tracks_a) if index not in duplicates_a + ] + result_b = [ + track for index, track in enumerate(tracks_b) if index not in duplicates_b + ] + + return result_a, result_b diff --git a/src/supervision/tracker/byte_tracker/kalman_filter.py b/src/supervision/tracker/byte_tracker/kalman_filter.py new file mode 100644 index 0000000..0d5cbeb --- /dev/null +++ b/src/supervision/tracker/byte_tracker/kalman_filter.py @@ -0,0 +1,191 @@ +import numpy as np +import numpy.typing as npt +import scipy.linalg + + +class KalmanFilter: + """ + A simple Kalman filter for tracking bounding boxes in image space. + + The 8-dimensional state space is (x, y, a, h, vx, vy, va, vh), where + (x, y) is the bounding box center, a is the aspect ratio (w/h), h is + the height, and their respective velocities. + + Object motion follows a constant velocity model. The bounding box location + (x, y, a, h) is taken as direct observation of the state space (linear + observation model). + """ + + def __init__(self) -> None: + ndim, dt = 4, 1.0 + + self._motion_mat: npt.NDArray[np.float64] = np.eye(2 * ndim, 2 * ndim) + for i in range(ndim): + self._motion_mat[i, ndim + i] = dt + self._update_mat: npt.NDArray[np.float64] = np.eye(ndim, 2 * ndim) + + self._std_weight_position: float = 1.0 / 20 + self._std_weight_velocity: float = 1.0 / 160 + + def initiate( + self, measurement: npt.NDArray[np.float32] + ) -> tuple[npt.NDArray[np.float32], npt.NDArray[np.float32]]: + """ + Create track from unassociated measurement. + + Args: + measurement: The initial measurement vector. + + Returns: + The mean vector and covariance matrix of the new track. + """ + mean_pos = measurement + mean_vel = np.zeros_like(mean_pos) + mean = np.r_[mean_pos, mean_vel] + + std = [ + 2 * self._std_weight_position * measurement[3], + 2 * self._std_weight_position * measurement[3], + 1e-2, + 2 * self._std_weight_position * measurement[3], + 10 * self._std_weight_velocity * measurement[3], + 10 * self._std_weight_velocity * measurement[3], + 1e-5, + 10 * self._std_weight_velocity * measurement[3], + ] + covariance = np.diag(np.square(std)) + return mean, covariance + + def predict( + self, mean: npt.NDArray[np.float32], covariance: npt.NDArray[np.float32] + ) -> tuple[npt.NDArray[np.float32], npt.NDArray[np.float32]]: + """ + Run Kalman filter prediction step. + + Args: + mean: The object state mean at the previous time step. + covariance: The object state covariance at the previous time step. + + Returns: + The mean vector and covariance matrix of the predicted state. + """ + std_pos = [ + self._std_weight_position * mean[3], + self._std_weight_position * mean[3], + 1e-2, + self._std_weight_position * mean[3], + ] + std_vel = [ + self._std_weight_velocity * mean[3], + self._std_weight_velocity * mean[3], + 1e-5, + self._std_weight_velocity * mean[3], + ] + motion_cov = np.diag(np.square(np.r_[std_pos, std_vel])) + + mean = np.dot(mean, self._motion_mat.T) + covariance = ( + np.linalg.multi_dot((self._motion_mat, covariance, self._motion_mat.T)) + + motion_cov + ) + + return mean, covariance + + def project( + self, mean: npt.NDArray[np.float32], covariance: npt.NDArray[np.float32] + ) -> tuple[npt.NDArray[np.float32], npt.NDArray[np.float32]]: + """ + Project state distribution to measurement space. + + Args: + mean: The state's mean vector. + covariance: The state's covariance matrix. + + Returns: + The projected mean and covariance matrix of the given state estimate. + """ + std = [ + self._std_weight_position * mean[3], + self._std_weight_position * mean[3], + 1e-1, + self._std_weight_position * mean[3], + ] + innovation_cov = np.diag(np.square(std)) + + mean = np.dot(self._update_mat, mean) + covariance = np.linalg.multi_dot( + (self._update_mat, covariance, self._update_mat.T) + ) + return mean, covariance + innovation_cov + + def multi_predict( + self, mean: npt.NDArray[np.float32], covariance: npt.NDArray[np.float32] + ) -> tuple[npt.NDArray[np.float32], npt.NDArray[np.float32]]: + """ + Run Kalman filter prediction step (Vectorized version). + Args: + mean: The object state means at the previous time step. + covariance: The object state covariances at the previous time step. + + Returns: + The mean vector and covariance matrix of the predicted state. + """ + std_pos = [ + self._std_weight_position * mean[:, 3], + self._std_weight_position * mean[:, 3], + 1e-2 * np.ones_like(mean[:, 3]), + self._std_weight_position * mean[:, 3], + ] + std_vel = [ + self._std_weight_velocity * mean[:, 3], + self._std_weight_velocity * mean[:, 3], + 1e-5 * np.ones_like(mean[:, 3]), + self._std_weight_velocity * mean[:, 3], + ] + sqr = np.square(np.r_[std_pos, std_vel]).T + + motion_cov_list: list[npt.NDArray[np.float32]] = [] + for i in range(len(mean)): + motion_cov_list.append(np.diag(sqr[i])) + motion_cov = np.asarray(motion_cov_list) + + mean = np.dot(mean, self._motion_mat.T) + left = np.dot(self._motion_mat, covariance).transpose((1, 0, 2)) + covariance = np.dot(left, self._motion_mat.T) + motion_cov + + return mean, covariance + + def update( + self, + mean: npt.NDArray[np.float32], + covariance: npt.NDArray[np.float32], + measurement: npt.NDArray[np.float32], + ) -> tuple[npt.NDArray[np.float32], npt.NDArray[np.float32]]: + """ + Run Kalman filter correction step. + + Args: + mean: The predicted state's mean vector. + covariance: The state's covariance matrix. + measurement: The measurement vector. + + Returns: + The measurement-corrected state distribution. + """ + projected_mean, projected_cov = self.project(mean, covariance) + + chol_factor, lower = scipy.linalg.cho_factor( + projected_cov, lower=True, check_finite=False + ) + kalman_gain = scipy.linalg.cho_solve( + (chol_factor, lower), + np.dot(covariance, self._update_mat.T).T, + check_finite=False, + ).T + innovation = measurement - projected_mean + + new_mean = mean + np.dot(innovation, kalman_gain.T) + new_covariance = covariance - np.linalg.multi_dot( + (kalman_gain, projected_cov, kalman_gain.T) + ) + return new_mean, new_covariance diff --git a/src/supervision/tracker/byte_tracker/matching.py b/src/supervision/tracker/byte_tracker/matching.py new file mode 100644 index 0000000..b32871b --- /dev/null +++ b/src/supervision/tracker/byte_tracker/matching.py @@ -0,0 +1,79 @@ +from typing import cast + +import numpy as np +import numpy.typing as npt +from scipy.optimize import linear_sum_assignment + +from supervision.detection.utils.iou_and_nms import box_iou_batch +from supervision.tracker.byte_tracker.single_object_track import STrack + + +def indices_to_matches( + cost_matrix: npt.NDArray[np.float32], indices: npt.NDArray[np.int_], thresh: float +) -> tuple[npt.NDArray[np.int_], tuple[int, ...], tuple[int, ...]]: + matched_cost = cost_matrix[tuple(zip(*indices))] + matched_mask = matched_cost <= thresh + + matches = indices[matched_mask] + unmatched_a = tuple(set(range(cost_matrix.shape[0])) - set(matches[:, 0])) + unmatched_b = tuple(set(range(cost_matrix.shape[1])) - set(matches[:, 1])) + return matches, unmatched_a, unmatched_b + + +def linear_assignment( + cost_matrix: npt.NDArray[np.float32], thresh: float +) -> tuple[npt.NDArray[np.int_], tuple[int, ...], tuple[int, ...]]: + """Match rows and columns without mutating the caller-owned cost matrix.""" + if cost_matrix.size == 0: + return ( + np.empty((0, 2), dtype=int), + tuple(range(cost_matrix.shape[0])), + tuple(range(cost_matrix.shape[1])), + ) + + assignment_cost_matrix = cost_matrix.copy() + assignment_cost_matrix[assignment_cost_matrix > thresh] = thresh + 1e-4 + row_ind, col_ind = linear_sum_assignment(assignment_cost_matrix) + indices = np.column_stack((row_ind, col_ind)) + + return indices_to_matches(cost_matrix, indices, thresh) + + +def iou_distance( + atracks: list[STrack] | list[npt.NDArray[np.float32]], + btracks: list[STrack] | list[npt.NDArray[np.float32]], +) -> npt.NDArray[np.float32]: + if (len(atracks) > 0 and isinstance(atracks[0], np.ndarray)) or ( + len(btracks) > 0 and isinstance(btracks[0], np.ndarray) + ): + atlbrs = cast(list[npt.NDArray[np.float32]], atracks) + btlbrs = cast(list[npt.NDArray[np.float32]], btracks) + else: + atlbrs = [track.tlbr for track in cast(list[STrack], atracks)] + btlbrs = [track.tlbr for track in cast(list[STrack], btracks)] + + if len(atlbrs) == 0 or len(btlbrs) == 0: + return cast( + npt.NDArray[np.float32], + np.empty((len(atlbrs), len(btlbrs)), dtype=np.float32), + ) + + ious = box_iou_batch( + np.asarray(atlbrs, dtype=np.float32), + np.asarray(btlbrs, dtype=np.float32), + ) + cost_matrix = np.asarray(1 - ious, dtype=np.float32) + return cost_matrix + + +def fuse_score( + cost_matrix: npt.NDArray[np.float32], stracks: list[STrack] +) -> npt.NDArray[np.float32]: + if cost_matrix.size == 0: + return cost_matrix + iou_sim = 1 - cost_matrix + det_scores = np.array([strack.score for strack in stracks], dtype=np.float32) + det_scores = np.expand_dims(det_scores, axis=0).repeat(cost_matrix.shape[0], axis=0) + fuse_sim = iou_sim * det_scores + fuse_cost = np.asarray(1 - fuse_sim, dtype=np.float32) + return fuse_cost diff --git a/src/supervision/tracker/byte_tracker/single_object_track.py b/src/supervision/tracker/byte_tracker/single_object_track.py new file mode 100644 index 0000000..5d540db --- /dev/null +++ b/src/supervision/tracker/byte_tracker/single_object_track.py @@ -0,0 +1,186 @@ +from __future__ import annotations + +from enum import Enum +from typing import cast + +import numpy as np +import numpy.typing as npt + +from supervision.tracker.byte_tracker.kalman_filter import KalmanFilter +from supervision.tracker.byte_tracker.utils import IdCounter + + +class TrackState(Enum): + New = 0 + Tracked = 1 + Lost = 2 + Removed = 3 + + +class STrack: + def __init__( + self, + tlwh: npt.NDArray[np.float32], + score: float, + minimum_consecutive_frames: int, + shared_kalman: KalmanFilter, + internal_id_counter: IdCounter, + external_id_counter: IdCounter, + ): + self.state = TrackState.New + self.is_activated = False + self.start_frame = 0 + self.frame_id = 0 + + self._tlwh = np.asarray(tlwh, dtype=np.float32) + self.kalman_filter: KalmanFilter | None = None + self.shared_kalman = shared_kalman + self.mean: npt.NDArray[np.float32] | None = None + self.covariance: npt.NDArray[np.float32] | None = None + self.is_activated = False + + self.score: float = score + self.tracklet_len = 0 + + self.minimum_consecutive_frames = minimum_consecutive_frames + + self.internal_id_counter = internal_id_counter + self.external_id_counter = external_id_counter + self.internal_track_id = self.internal_id_counter.NO_ID + self.external_track_id = self.external_id_counter.NO_ID + + def predict(self) -> None: + assert self.mean is not None + assert self.covariance is not None + assert self.kalman_filter is not None + mean_state = self.mean.copy() + if self.state != TrackState.Tracked: + mean_state[7] = 0 + self.mean, self.covariance = self.kalman_filter.predict( + mean_state, self.covariance + ) + + @staticmethod + def multi_predict(stracks: list[STrack], shared_kalman: KalmanFilter) -> None: + if len(stracks) > 0: + multi_mean_states = [] + multi_covariance = [] + for i, st in enumerate(stracks): + assert st.mean is not None + assert st.covariance is not None + multi_mean_states.append(st.mean.copy()) + multi_covariance.append(st.covariance) + if st.state != TrackState.Tracked: + multi_mean_states[i][7] = 0 + + predicted_mean, predicted_covariance = shared_kalman.multi_predict( + np.asarray(multi_mean_states), np.asarray(multi_covariance) + ) + for i, (mean, cov) in enumerate(zip(predicted_mean, predicted_covariance)): + stracks[i].mean = mean + stracks[i].covariance = cov + + def activate(self, kalman_filter: KalmanFilter, frame_id: int) -> None: + """Start a new tracklet after its first detection.""" + self.kalman_filter = kalman_filter + self.internal_track_id = self.internal_id_counter.new_id() + self.mean, self.covariance = self.kalman_filter.initiate( + self.tlwh_to_xyah(self._tlwh) + ) + + self.tracklet_len = 1 + self.state = TrackState.Tracked + if frame_id == 1 and self.tracklet_len >= self.minimum_consecutive_frames: + self.is_activated = True + self.external_track_id = self.external_id_counter.new_id() + + self.frame_id = frame_id + self.start_frame = frame_id + + def re_activate(self, new_track: STrack, frame_id: int) -> None: + assert self.kalman_filter is not None + assert self.mean is not None + assert self.covariance is not None + self.mean, self.covariance = self.kalman_filter.update( + self.mean, self.covariance, self.tlwh_to_xyah(new_track.tlwh) + ) + self.tracklet_len = 0 + self.state = TrackState.Tracked + + self.frame_id = frame_id + self.score = new_track.score + + def update(self, new_track: STrack, frame_id: int) -> None: + """ + Update a matched track. + + Args: + new_track: The new track data. + frame_id: The current frame ID. + """ + assert self.kalman_filter is not None + assert self.mean is not None + assert self.covariance is not None + self.frame_id = frame_id + self.tracklet_len += 1 + + new_tlwh = new_track.tlwh + self.mean, self.covariance = self.kalman_filter.update( + self.mean, self.covariance, self.tlwh_to_xyah(new_tlwh) + ) + self.state = TrackState.Tracked + if self.tracklet_len >= self.minimum_consecutive_frames: + self.is_activated = True + if self.external_track_id == self.external_id_counter.NO_ID: + self.external_track_id = self.external_id_counter.new_id() + + self.score = new_track.score + + @property + def tlwh(self) -> npt.NDArray[np.float32]: + """Get current position in bounding box format `(top left x, top left y, + width, height)`. + """ + if self.mean is None: + return cast(npt.NDArray[np.float32], self._tlwh.copy()) + ret = self.mean[:4].copy() + ret[2] *= ret[3] + ret[:2] -= ret[2:] / 2 + return cast(npt.NDArray[np.float32], ret) + + @property + def tlbr(self) -> npt.NDArray[np.float32]: + """Convert bounding box to format `(min x, min y, max x, max y)`, i.e., + `(top left, bottom right)`. + """ + ret = self.tlwh.copy() + ret[2:] += ret[:2] + return cast(npt.NDArray[np.float32], ret) + + @staticmethod + def tlwh_to_xyah(tlwh: npt.NDArray[np.float32]) -> npt.NDArray[np.float32]: + """Convert bounding box to format `(center x, center y, aspect ratio, + height)`, where the aspect ratio is `width / height`. + """ + ret = np.asarray(tlwh).copy() + ret[:2] += ret[2:] / 2 + ret[2] /= ret[3] + return cast(npt.NDArray[np.float32], ret) + + def to_xyah(self) -> npt.NDArray[np.float32]: + return self.tlwh_to_xyah(self.tlwh) + + @staticmethod + def tlbr_to_tlwh(tlbr: npt.NDArray[np.float32]) -> npt.NDArray[np.float32]: + ret = np.asarray(tlbr).copy() + ret[2:] -= ret[:2] + return cast(npt.NDArray[np.float32], ret) + + @staticmethod + def tlwh_to_tlbr(tlwh: npt.NDArray[np.float32]) -> npt.NDArray[np.float32]: + ret = np.asarray(tlwh).copy() + ret[2:] += ret[:2] + return cast(npt.NDArray[np.float32], ret) + + def __repr__(self) -> str: + return f"OT_{self.internal_track_id}_({self.start_frame}-{self.frame_id})" diff --git a/src/supervision/tracker/byte_tracker/utils.py b/src/supervision/tracker/byte_tracker/utils.py new file mode 100644 index 0000000..4e1c1c2 --- /dev/null +++ b/src/supervision/tracker/byte_tracker/utils.py @@ -0,0 +1,34 @@ +class IdCounter: + def __init__(self, start_id: int = 0) -> None: + """ + Initialize the ID counter. + + Args: + start_id: The starting integer for the counter. + + Raises: + ValueError: If start_id is less than or equal to -1. + """ + self.start_id = start_id + if self.start_id <= self.NO_ID: + raise ValueError(f"start_id must be greater than {self.NO_ID}") + self.reset() + + def reset(self) -> None: + """Reset the counter to the initial start_id.""" + self._id = self.start_id + + def new_id(self) -> int: + """ + Get the current ID and increment the counter. + + Returns: + The newly assigned ID. + """ + returned_id = self._id + self._id += 1 + return returned_id + + @property + def NO_ID(self) -> int: + return -1 diff --git a/src/supervision/utils/__init__.py b/src/supervision/utils/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/src/supervision/utils/conversion.py b/src/supervision/utils/conversion.py new file mode 100644 index 0000000..b16d92e --- /dev/null +++ b/src/supervision/utils/conversion.py @@ -0,0 +1,223 @@ +import functools +from collections.abc import Callable +from typing import Any, TypeVar, cast + +import cv2 +import numpy as np +import numpy.typing as npt +from deprecate import deprecated, void # type: ignore[import-untyped,unused-ignore] +from PIL import Image + +from supervision.draw.base import ImageType + +F = TypeVar("F", bound=Callable[..., Any]) + + +def ensure_cv2_image_for_class_method( + annotate_func: F, +) -> F: + """ + Decorates `BaseAnnotator.annotate` implementations, converts scene to + an image type used internally by the annotators, converts back when annotation + is complete. + + Assumes the annotators modify the scene in-place. + + Raises: + TypeError: If `scene` is not a `numpy.ndarray` or `PIL.Image.Image`. + """ + + @functools.wraps(annotate_func) + def wrapper(self: Any, scene: ImageType, *args: Any, **kwargs: Any) -> Any: + if isinstance(scene, np.ndarray): + return annotate_func(self, scene, *args, **kwargs) + + if isinstance(scene, Image.Image): + scene_np = pillow_to_cv2(scene) + annotated_np = annotate_func(self, scene_np, *args, **kwargs) + scene.paste(cv2_to_pillow(annotated_np)) + return scene + + raise TypeError(f"Unsupported image type: {type(scene)}") + + return cast(F, wrapper) + + +@deprecated( # type: ignore[untyped-decorator] + target=ensure_cv2_image_for_class_method, + deprecated_in="0.27.0", + remove_in="0.31.0", +) +def ensure_cv2_image_for_annotation( + annotate_func: F, +) -> F: + return cast(F, void(annotate_func)) + + +def ensure_cv2_image_for_standalone_function( + image_processing_fun: F, +) -> F: + """ + Decorates image processing functions that accept np.ndarray, converting `image` to + np.ndarray, converts back when processing is complete. + + Assumes the annotators do NOT modify the scene in-place. + + Raises: + TypeError: If `image` is not a `numpy.ndarray` or `PIL.Image.Image`. + """ + + @functools.wraps(image_processing_fun) + def wrapper(image: ImageType, *args: Any, **kwargs: Any) -> Any: + if isinstance(image, np.ndarray): + return image_processing_fun(image, *args, **kwargs) + + if isinstance(image, Image.Image): + scene = pillow_to_cv2(image) + annotated = image_processing_fun(scene, *args, **kwargs) + return cv2_to_pillow(annotated) + + raise TypeError(f"Unsupported image type: {type(image)}") + + return cast(F, wrapper) + + +def ensure_pil_image_for_class_method( + annotate_func: F, +) -> F: + """ + Decorates image processing functions that accept np.ndarray, converting `image` to + PIL image, converts back when processing is complete. + + Assumes the annotators modify the scene in-place. + + Raises: + TypeError: If `scene` is not a `numpy.ndarray` or `PIL.Image.Image`. + """ + + @functools.wraps(annotate_func) + def wrapper(self: Any, scene: ImageType, *args: Any, **kwargs: Any) -> Any: + if isinstance(scene, np.ndarray): + scene_pil = cv2_to_pillow(scene) + annotated_pil = annotate_func(self, scene_pil, *args, **kwargs) + np.copyto(scene, pillow_to_cv2(annotated_pil)) + return scene + + if isinstance(scene, Image.Image): + return cast(ImageType, annotate_func(self, scene, *args, **kwargs)) + + raise TypeError(f"Unsupported image type: {type(scene)}") + + return cast(F, wrapper) + + +@deprecated( # type: ignore[untyped-decorator] + target=ensure_pil_image_for_class_method, + deprecated_in="0.27.0", + remove_in="0.31.0", +) +def ensure_pil_image_for_annotation( + annotate_func: F, +) -> F: + return cast(F, void(annotate_func)) + + +@deprecated( # type: ignore[untyped-decorator] + target=ensure_cv2_image_for_standalone_function, + deprecated_in="0.27.0", + remove_in="0.31.0", +) +def ensure_cv2_image_for_processing( + image_processing_fun: F, +) -> F: + return cast(F, void(image_processing_fun)) + + +def images_to_cv2( + images: list[npt.NDArray[np.uint8] | Image.Image], +) -> list[npt.NDArray[np.uint8]]: + """ + Converts images provided either as Pillow images or OpenCV + images into OpenCV format. + + Args: + images: Images to be converted + + Returns: + List of input images in OpenCV format + (with order preserved). + + """ + result: list[npt.NDArray[np.uint8]] = [] + for image in images: + if isinstance(image, Image.Image): + result.append(pillow_to_cv2(image)) + else: + result.append(image) + return result + + +def pillow_to_cv2(image: Image.Image) -> npt.NDArray[np.uint8]: + """ + Converts Pillow image into OpenCV image, handling RGB -> BGR + conversion. Palette images are first expanded to RGB so palette indices are + resolved to their actual colors. + + Args: + image: Pillow image in RGB, grayscale, or palette mode. + + Returns: + Input image converted to OpenCV format. + + Examples: + ```pycon + >>> from PIL import Image + >>> from supervision.utils.conversion import pillow_to_cv2 + >>> image = Image.new("RGB", (10, 10), color=(255, 0, 0)) + >>> scene = pillow_to_cv2(image) + >>> scene.shape + (10, 10, 3) + >>> scene[0, 0].tolist() + [0, 0, 255] + + ``` + """ + if image.mode == "P": + image = image.convert("RGB") + + scene = np.array(image) + if scene.ndim == 2: + return cast(npt.NDArray[np.uint8], scene.astype(np.uint8, copy=False)) + scene = cv2.cvtColor(scene, cv2.COLOR_RGB2BGR) + # cvtColor already returns uint8 here, so astype is a no-op other than the + # full-image copy it forces; copy=False keeps the dtype guard without it. + return cast(npt.NDArray[np.uint8], scene.astype(np.uint8, copy=False)) + + +def cv2_to_pillow(image: npt.NDArray[np.uint8]) -> Image.Image: + """ + Converts OpenCV image into Pillow image, handling BGR -> RGB + conversion. + + Args: + image: OpenCV image (in BGR format). + + Returns: + Input image converted to Pillow format. + + Examples: + ```pycon + >>> import numpy as np + >>> from supervision.utils.conversion import cv2_to_pillow + >>> scene = np.zeros((10, 10, 3), dtype=np.uint8) + >>> scene[:, :, 2] = 255 + >>> image = cv2_to_pillow(scene) + >>> image.size + (10, 10) + >>> image.getpixel((0, 0)) + (255, 0, 0) + + ``` + """ + rgb_image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB) + return Image.fromarray(rgb_image) diff --git a/src/supervision/utils/file.py b/src/supervision/utils/file.py new file mode 100644 index 0000000..00466e5 --- /dev/null +++ b/src/supervision/utils/file.py @@ -0,0 +1,209 @@ +import json +from pathlib import Path +from typing import Any + +import numpy as np +import yaml + + +class NumpyJsonEncoder(json.JSONEncoder): + def default(self, obj: Any) -> Any: + if isinstance(obj, np.integer): + return int(obj) + if isinstance(obj, np.floating): + return float(obj) + if isinstance(obj, np.ndarray): + return obj.tolist() + return super().default(obj) + + +def list_files_with_extensions( + directory: str | Path, extensions: list[str] | None = None +) -> list[Path]: + """ + List files in a directory with specified extensions or + all files if no extensions are provided. + + Args: + directory: The directory path as a string or Path object. + extensions: A list of file extensions to filter. Extensions may be + supplied with or without a leading dot (e.g. ``'jpg'`` and + ``'.jpg'`` are equivalent). Matching is case-insensitive. + Multi-part extensions are supported (e.g. ``'tar.gz'``). Pass + ``None`` (default) to list all files; pass an empty list to + return no files. + + Returns: + A list of Path objects for the matching files. + + Examples: + ```pycon + >>> import supervision as sv + >>> from pathlib import Path + >>> import tempfile + >>> # Keep a reference to the directory object + >>> tmp_dir_obj = tempfile.TemporaryDirectory() + >>> tmpdir = tmp_dir_obj.name + >>> # Create test files + >>> (Path(tmpdir) / "test1.txt").touch() + >>> (Path(tmpdir) / "test2.md").touch() + >>> (Path(tmpdir) / "test3.py").touch() + >>> # List all files in the directory + >>> files = sv.list_files_with_extensions(directory=tmpdir) + >>> len(files) + 3 + >>> # Leading dot accepted; matching is case-insensitive + >>> files = sv.list_files_with_extensions( + ... directory=tmpdir, extensions=['.txt', 'md']) + >>> len(files) + 2 + + ``` + """ + + directory = Path(directory) + files_with_extensions: list[Path] = [] + + if extensions is not None: + candidates = [p for p in directory.glob("*") if p.is_file()] + path_index: dict[Path, set[str]] = {} + for path in candidates: + suffixes = [suffix.lower().lstrip(".") for suffix in path.suffixes] + path_index[path] = { + ".".join(suffixes[index:]) for index in range(len(suffixes)) + } + seen_paths: set[Path] = set() + for ext in extensions: + normalized_extension = ext.lower().lstrip(".") + if not normalized_extension: + continue + for path, path_extensions in path_index.items(): + if path not in seen_paths and normalized_extension in path_extensions: + files_with_extensions.append(path) + seen_paths.add(path) + else: + files_with_extensions.extend(directory.glob("*")) + + return files_with_extensions + + +def read_txt_file(file_path: str | Path, skip_empty: bool = False) -> list[str]: + """ + Read a text file and return a list of strings without newline characters. + Optionally skip empty lines. + + Args: + file_path: The file path as a string or Path object. + skip_empty: If True, skip lines that are empty or contain only + whitespace. Default is False. + + Returns: + A list of strings representing the lines in the text file. + + Examples: + ```pycon + >>> import tempfile + >>> from pathlib import Path + >>> from supervision.utils.file import read_txt_file, save_text_file + >>> with tempfile.TemporaryDirectory() as tmpdir: + ... file_path = Path(tmpdir) / "test.txt" + ... save_text_file(["line1", " ", "line3"], file_path) + ... print(read_txt_file(file_path)) + ... print(read_txt_file(file_path, skip_empty=True)) + ['line1', ' ', 'line3'] + ['line1', 'line3'] + + ``` + """ + with open(str(file_path)) as file: + if skip_empty: + lines = [line.rstrip("\n") for line in file if line.strip()] + else: + lines = [line.rstrip("\n") for line in file] + + return lines + + +def save_text_file(lines: list[str], file_path: str | Path) -> None: + """ + Write a list of strings to a text file, each string on a new line. + + Args: + lines: The list of strings to be written to the file. + file_path: The file path as a string or Path object. + """ + with open(str(file_path), "w") as file: + for line in lines: + file.write(line + "\n") + + +def read_json_file(file_path: str | Path) -> dict[str, Any]: + """ + Read a json file and return a dict. + + Args: + file_path: The file path as a string or Path object. + + Returns: + A dict of annotations information + + Examples: + ```pycon + >>> import tempfile + >>> from pathlib import Path + >>> from supervision.utils.file import read_json_file, save_json_file + >>> data = {"key": "value", "list": [1, 2, 3]} + >>> with tempfile.TemporaryDirectory() as tmpdir: + ... file_path = Path(tmpdir) / "test.json" + ... save_json_file(data, file_path) + ... print(read_json_file(file_path)) + {'key': 'value', 'list': [1, 2, 3]} + + ``` + """ + with open(str(file_path)) as file: + data = json.load(file) + return data # type: ignore + + +def save_json_file( + data: dict[str, Any], file_path: str | Path, indent: int = 3 +) -> None: + """ + Write a dict to a json file. + + Args: + data: dict with unique keys and value as pair. + file_path: The file path as a string or Path object. + indent: + """ + with open(str(file_path), "w") as fp: + json.dump(data, fp, cls=NumpyJsonEncoder, indent=indent) + + +def read_yaml_file(file_path: str | Path) -> dict[str, Any]: + """ + Read a yaml file and return a dict. + + Args: + file_path: The file path as a string or Path object. + + Returns: + A dict of content information + """ + with open(str(file_path)) as file: + data = yaml.safe_load(file) + return data # type: ignore + + +def save_yaml_file(data: dict[str, Any], file_path: str | Path) -> None: + """ + Save a dict to a yaml file. + + Args: + data: dict with unique keys and value as pair. + file_path: The file path as a string or Path object. + """ + + with open(str(file_path), "w") as outfile: + yaml.dump(data, outfile, sort_keys=False, default_flow_style=None) diff --git a/src/supervision/utils/image.py b/src/supervision/utils/image.py new file mode 100644 index 0000000..2fa1372 --- /dev/null +++ b/src/supervision/utils/image.py @@ -0,0 +1,988 @@ +from __future__ import annotations + +import itertools +import math +import os +import shutil +from collections.abc import Callable +from functools import partial +from types import TracebackType +from typing import Literal, cast + +import cv2 +import numpy as np +import numpy.typing as npt +from deprecate import ( # type: ignore[import-untyped,unused-ignore] + TargetMode, + deprecated, +) +from PIL import Image + +from supervision.draw.base import ImageType +from supervision.draw.color import Color, unify_to_bgr +from supervision.draw.utils import calculate_optimal_text_scale, draw_text +from supervision.geometry.core import Point +from supervision.utils.conversion import ( + cv2_to_pillow, + ensure_cv2_image_for_standalone_function, + images_to_cv2, +) +from supervision.utils.iterables import create_batches, fill + +RelativePosition = Literal["top", "bottom"] + +MAX_COLUMNS_FOR_SINGLE_ROW_GRID = 3 + + +@ensure_cv2_image_for_standalone_function +def crop_image( + image: ImageType, + xyxy: npt.NDArray[np.number] | list[int] | tuple[int, int, int, int], +) -> ImageType: + """ + Crop image based on bounding box coordinates. + + Args: + image: The image to crop. + xyxy: + Bounding box coordinates in `(x_min, y_min, x_max, y_max)` format. + + Returns: + Cropped image matching input + type. + + Note: + Coordinates are rounded to integers and clipped to the image bounds + before slicing. This keeps NumPy and Pillow inputs aligned and avoids + negative-index wrap-around on NumPy arrays. + + Examples: + ```pycon + >>> import numpy as np + >>> import supervision as sv + >>> image = np.zeros((1080, 1920, 3), dtype=np.uint8) + >>> image.shape + (1080, 1920, 3) + >>> xyxy = (400, 400, 800, 800) + >>> cropped_image = sv.crop_image(image=image, xyxy=xyxy) + >>> cropped_image.shape + (400, 400, 3) + + ``` + + ```pycon + >>> image = np.zeros((1920, 1080), dtype=np.uint8) + >>> image.shape + (1920, 1080) + >>> xyxy = (400, 400, 800, 800) + >>> cropped_image = sv.crop_image(image=image, xyxy=xyxy) + >>> cropped_image.shape + (400, 400) + + ``` + + ![crop-image](https://media.roboflow.com/supervision-docs/supervision-docs-crop-image-2.png){ align=center width="1000" } + """ # noqa E501 // docs + xyxy_arr = np.asarray(xyxy, dtype=np.float64).round().astype(np.int32) + x_min, y_min, x_max, y_max = xyxy_arr.flatten() + + if isinstance(image, np.ndarray): + height, width = image.shape[:2] + x_min = int(np.clip(x_min, 0, width)) + y_min = int(np.clip(y_min, 0, height)) + x_max = int(np.clip(x_max, 0, width)) + y_max = int(np.clip(y_max, 0, height)) + return image[y_min:y_max, x_min:x_max] + + if isinstance(image, Image.Image): + width, height = image.size + x_min = int(np.clip(x_min, 0, width)) + y_min = int(np.clip(y_min, 0, height)) + x_max = int(np.clip(x_max, 0, width)) + y_max = int(np.clip(y_max, 0, height)) + return image.crop((float(x_min), float(y_min), float(x_max), float(y_max))) + + raise TypeError( + f"`image` must be a numpy.ndarray or PIL.Image.Image. Received {type(image)}" + ) + + +@ensure_cv2_image_for_standalone_function +def scale_image(image: ImageType, scale_factor: float) -> ImageType: + """ + Scale image by given factor. Scale factor > 1.0 zooms in, < 1.0 zooms out. + + Args: + image: The image to scale. + scale_factor: Factor by which to scale the image. + + Returns: + Scaled image matching input + type. + + Raises: + TypeError: If `image` is not a `numpy.ndarray` or `PIL.Image.Image`. + ValueError: If scale factor is non-positive. + + Examples: + ```pycon + >>> import numpy as np + >>> import supervision as sv + >>> image = np.zeros((1080, 1920, 3), dtype=np.uint8) + >>> image.shape + (1080, 1920, 3) + >>> scaled_image = sv.scale_image(image=image, scale_factor=0.5) + >>> scaled_image.shape + (540, 960, 3) + + ``` + + ```pycon + >>> image = np.zeros((1920, 1080), dtype=np.uint8) + >>> image.shape + (1920, 1080) + >>> scaled_image = sv.scale_image(image=image, scale_factor=0.5) + >>> scaled_image.shape + (960, 540) + + ``` + + ![scale-image](https://media.roboflow.com/supervision-docs/supervision-docs-scale-image-2.png){ align=center width="1000" } + """ # noqa E501 // docs + if scale_factor <= 0: + raise ValueError("Scale factor must be positive.") + + width_old, height_old = image.shape[1], image.shape[0] + width_new = int(width_old * scale_factor) + height_new = int(height_old * scale_factor) + return cast( + npt.NDArray[np.uint8], + cv2.resize(image, (width_new, height_new), interpolation=cv2.INTER_LINEAR), + ) + + +@ensure_cv2_image_for_standalone_function +def resize_image( + image: ImageType, + resolution_wh: tuple[int, int], + keep_aspect_ratio: bool = False, +) -> ImageType: + """ + Resize image to specified resolution. Can optionally maintain aspect ratio. + + Args: + image: The image to resize. + resolution_wh: Target resolution as `(width, height)`. + keep_aspect_ratio: Flag to maintain original aspect ratio. + Defaults to `False`. + + Returns: + Resized image matching input + type. + + Raises: + TypeError: If `image` is not a `numpy.ndarray` or `PIL.Image.Image`. + + Examples: + ```pycon + >>> import numpy as np + >>> import supervision as sv + >>> image = np.zeros((1080, 1920, 3), dtype=np.uint8) + >>> image.shape + (1080, 1920, 3) + >>> resized_image = sv.resize_image( + ... image=image, resolution_wh=(1000, 1000), keep_aspect_ratio=True + ... ) + >>> resized_image.shape + (562, 1000, 3) + + ``` + + ```pycon + >>> image = np.zeros((1920, 1080), dtype=np.uint8) + >>> image.shape + (1920, 1080) + >>> resized_image = sv.resize_image( + ... image=image, resolution_wh=(1000, 1000), keep_aspect_ratio=True + ... ) + >>> resized_image.shape + (1000, 562) + + ``` + + ![resize-image](https://media.roboflow.com/supervision-docs/supervision-docs-resize-image-2.png){ align=center width="1000" } + """ # noqa E501 // docs + if keep_aspect_ratio: + image_ratio = image.shape[1] / image.shape[0] + target_ratio = resolution_wh[0] / resolution_wh[1] + if image_ratio >= target_ratio: + width_new = resolution_wh[0] + height_new = int(resolution_wh[0] / image_ratio) + else: + height_new = resolution_wh[1] + width_new = int(resolution_wh[1] * image_ratio) + else: + width_new, height_new = resolution_wh + + return cast( + npt.NDArray[np.uint8], + cv2.resize(image, (width_new, height_new), interpolation=cv2.INTER_LINEAR), + ) + + +@ensure_cv2_image_for_standalone_function +def letterbox_image( + image: ImageType, + resolution_wh: tuple[int, int], + color: tuple[int, int, int] | Color = Color.BLACK, +) -> ImageType: + """ + Resize image and pad with color to achieve desired resolution while + maintaining aspect ratio. + + Args: + image: The image to resize and pad. Accepts BGR arrays of shape + ``(H, W, 3)``, BGRA arrays of shape ``(H, W, 4)``, grayscale + arrays of shape ``(H, W)``, or a PIL ``Image``. + resolution_wh: Target resolution as `(width, height)`. + color: Padding color. If tuple, should be in BGR format. + Defaults to `Color.BLACK`. + + Returns: + Letterboxed image matching input type. + + Raises: + TypeError: If `image` is not a `numpy.ndarray` or `PIL.Image.Image`. + + Note: + For BGRA inputs, the alpha channel in the padding region is set to + 0 (fully transparent). Grayscale inputs receive scalar padding + from ``color[0]``. + + Examples: + ```pycon + >>> import numpy as np + >>> import supervision as sv + >>> image = np.zeros((1080, 1920, 3), dtype=np.uint8) + >>> image.shape + (1080, 1920, 3) + >>> letterboxed_image = sv.letterbox_image( + ... image=image, resolution_wh=(1000, 1000) + ... ) + >>> letterboxed_image.shape + (1000, 1000, 3) + >>> gray = np.zeros((4, 6), dtype=np.uint8) + >>> sv.letterbox_image(image=gray, resolution_wh=(10, 10)).shape + (10, 10) + + ``` + + ![letterbox-image](https://media.roboflow.com/supervision-docs/supervision-docs-letterbox-image-2.png){ align=center width="1000" } + """ # noqa E501 // docs + color = unify_to_bgr(color=color) + resized_image = resize_image( + image=image, resolution_wh=resolution_wh, keep_aspect_ratio=True + ) + height_new, width_new = resized_image.shape[:2] + padding_top = (resolution_wh[1] - height_new) // 2 + padding_bottom = resolution_wh[1] - height_new - padding_top + padding_left = (resolution_wh[0] - width_new) // 2 + padding_right = resolution_wh[0] - width_new - padding_left + image_with_borders = cast( + npt.NDArray[np.uint8], + cv2.copyMakeBorder( + resized_image, + padding_top, + padding_bottom, + padding_left, + padding_right, + cv2.BORDER_CONSTANT, + value=color, + ), + ) + + return image_with_borders + + +@deprecated( # type: ignore[untyped-decorator] + target=TargetMode.NOTIFY, + deprecated_in="0.27.0", + remove_in="0.31.0", +) +def overlay_image( + image: npt.NDArray[np.uint8], + overlay: npt.NDArray[np.uint8], + anchor: tuple[int, int], +) -> npt.NDArray[np.uint8]: + """ + Deprecated since 0.27.0; removal in 0.31.0. Use `_overlay_image` for + internal callers, or avoid calling `overlay_image` directly in external code. + + Overlay image onto scene at specified anchor point. Handles cases where + overlay position is partially or completely outside scene bounds. + + Args: + image: Background scene with shape `(height, width, 3)`. + overlay: Image to overlay with shape + `(height, width, 3)` or `(height, width, 4)`. + anchor: Coordinates `(x, y)` where top-left corner + of overlay will be placed. + + Returns: + Scene with overlay applied, shape `(height, width, 3)`. + + Examples: + ```pycon + >>> import numpy as np + >>> import supervision as sv + >>> image = np.zeros((1000, 1000, 3), dtype=np.uint8) + >>> overlay = np.zeros((400, 400, 3), dtype=np.uint8) + >>> overlay[:] = (0, 255, 0) # Green overlay + >>> result_image = sv.overlay_image( + ... image=image, overlay=overlay, anchor=(200, 400) + ... ) + >>> result_image.shape + (1000, 1000, 3) + + ``` + """ + return _overlay_image(image=image, overlay=overlay, anchor=anchor) + + +def _overlay_image( + image: npt.NDArray[np.uint8], + overlay: npt.NDArray[np.uint8], + anchor: tuple[int, int], +) -> npt.NDArray[np.uint8]: + """Overlay `overlay` onto `image` at `anchor`, clipping to scene bounds. + + Non-deprecated internal implementation backing the public `overlay_image`. + Kept separate so library-internal callers do not emit a deprecation warning. + + Args: + image: Background BGR array of shape ``(H, W, 3)``. Modified in place + and returned. + overlay: Overlay array of shape ``(H, W, 3)`` or ``(H, W, 4)``; channel + 4, when present, is treated as alpha. + anchor: ``(x, y)`` pixel position of the overlay top-left corner. May + be negative (partial off-screen placement is clipped). + + Returns: + The ``image`` array with the overlay applied. + """ + scene_height, scene_width = image.shape[:2] + image_height, image_width = overlay.shape[:2] + anchor_x, anchor_y = anchor + + is_out_horizontally = anchor_x + image_width <= 0 or anchor_x >= scene_width + is_out_vertically = anchor_y + image_height <= 0 or anchor_y >= scene_height + + if is_out_horizontally or is_out_vertically: + return image + + x_min = max(anchor_x, 0) + y_min = max(anchor_y, 0) + x_max = min(scene_width, anchor_x + image_width) + y_max = min(scene_height, anchor_y + image_height) + + crop_x_min = max(-anchor_x, 0) + crop_y_min = max(-anchor_y, 0) + crop_x_max = image_width - max((anchor_x + image_width) - scene_width, 0) + crop_y_max = image_height - max((anchor_y + image_height) - scene_height, 0) + + if overlay.shape[2] == 4: + b, g, r, alpha = cv2.split( + overlay[crop_y_min:crop_y_max, crop_x_min:crop_x_max] + ) + alpha_f32 = alpha[:, :, None].astype(np.float32) / 255.0 + overlay_color = cv2.merge((b, g, r)).astype(np.float32) + + roi = image[y_min:y_max, x_min:x_max].astype(np.float32) + blended = roi * (1 - alpha_f32) + overlay_color * alpha_f32 + image[y_min:y_max, x_min:x_max] = np.clip(blended, 0, 255).astype(np.uint8) + else: + image[y_min:y_max, x_min:x_max] = overlay[ + crop_y_min:crop_y_max, crop_x_min:crop_x_max + ] + + return image + + +@ensure_cv2_image_for_standalone_function +def tint_image( + image: ImageType, + color: Color = Color.BLACK, + opacity: float = 0.5, +) -> ImageType: + """ + Tint image with solid color overlay at specified opacity. + + Args: + image: The image to tint. + color: Overlay tint color. Defaults to `Color.BLACK`. + opacity: Blend ratio between overlay and image (0.0-1.0). + Defaults to `0.5`. + + Returns: + Tinted image matching input + type. + + Raises: + TypeError: If `image` is not a `numpy.ndarray` or `PIL.Image.Image`. + ValueError: If opacity is outside range [0.0, 1.0]. + + Examples: + ```pycon + >>> import numpy as np + >>> import supervision as sv + >>> image = np.zeros((100, 100, 3), dtype=np.uint8) + >>> tinted_image = sv.tint_image( + ... image=image, color=sv.Color.ROBOFLOW, opacity=0.5 + ... ) + >>> tinted_image.shape + (100, 100, 3) + + ``` + + ![tint-image](https://media.roboflow.com/supervision-docs/supervision-docs-tint-image-2.png){ align=center width="1000" } + """ # noqa E501 // docs + if not 0.0 <= opacity <= 1.0: + raise ValueError("opacity must be between 0.0 and 1.0") + + overlay = np.full_like(image, fill_value=color.as_bgr(), dtype=image.dtype) + cv2.addWeighted( + src1=overlay, alpha=opacity, src2=image, beta=1 - opacity, gamma=0, dst=image + ) + return image + + +@ensure_cv2_image_for_standalone_function +def grayscale_image(image: ImageType) -> ImageType: + """ + Convert image to 3-channel grayscale. Luminance channel is broadcast to + all three channels for compatibility with color-based drawing helpers. + + Args: + image: The image to convert to + grayscale. + + Returns: + 3-channel grayscale image + matching input type. + + Examples: + ```pycon + >>> import numpy as np + >>> import supervision as sv + >>> image = np.ones((100, 100, 3), dtype=np.uint8) * 128 + >>> grayscale_image = sv.grayscale_image(image=image) + >>> grayscale_image.shape + (100, 100, 3) + + ``` + + ![grayscale-image](https://media.roboflow.com/supervision-docs/supervision-docs-grayscale-image-2.png){ align=center width="1000" } + """ # noqa E501 // docs + assert isinstance(image, np.ndarray) + grayscaled = cast(npt.NDArray[np.uint8], cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)) + return cast(npt.NDArray[np.uint8], cv2.cvtColor(grayscaled, cv2.COLOR_GRAY2BGR)) + + +def get_image_resolution_wh(image: ImageType) -> tuple[int, int]: + """ + Get image width and height as a tuple `(width, height)` for various image formats. + + Supports both `numpy.ndarray` images (with shape `(H, W, ...)`) and + `PIL.Image.Image` inputs. + + Args: + image: Input image. + + Returns: + Image resolution as `(width, height)`. + + Raises: + ValueError: If a `numpy.ndarray` image has fewer than 2 dimensions. + TypeError: If `image` is not a supported type (`numpy.ndarray` or + `PIL.Image.Image`). + + Examples: + ```pycon + >>> import numpy as np + >>> import supervision as sv + >>> image = np.zeros((1080, 1920, 3), dtype=np.uint8) + >>> sv.get_image_resolution_wh(image) + (1920, 1080) + + ``` + """ + if isinstance(image, np.ndarray): + if image.ndim < 2: + raise ValueError( + "NumPy image must have at least 2 dimensions (H, W, ...). " + f"Received shape: {image.shape}" + ) + height, width = image.shape[:2] + return int(width), int(height) + + if isinstance(image, Image.Image): + width, height = image.size + return int(width), int(height) + + raise TypeError( + "`image` must be a numpy.ndarray or PIL.Image.Image. " + f"Received type: {type(image)}" + ) + + +class ImageSink: + """ + Save sequential images into a directory through a context manager. + + `ImageSink` creates the target directory on entry and writes each image + using `save_image`, incrementing the image name pattern after every save. + """ + + def __init__( + self, + target_dir_path: str, + overwrite: bool = False, + image_name_pattern: str = "image_{:05d}.png", + ) -> None: + """ + Initialize context manager for saving images to directory. + + Args: + target_dir_path: Target directory path where images will be + saved. + overwrite: Whether to overwrite existing directory. + Defaults to `False`. + image_name_pattern: File name pattern for saved images. + Defaults to `"image_{:05d}.png"`. + + Examples: + ```pycon + >>> import numpy as np + >>> import supervision as sv + >>> import tempfile + >>> import os + >>> with tempfile.TemporaryDirectory() as tmpdir: + ... image = np.zeros((100, 100, 3), dtype=np.uint8) + ... with sv.ImageSink(target_dir_path=tmpdir, overwrite=True) as sink: + ... sink.save_image(image=image) + ... sink.save_image(image=image) + ... files = sorted(os.listdir(tmpdir)) + ... len(files) + 2 + + ``` + """ + self.target_dir_path = target_dir_path + self.overwrite = overwrite + self.image_name_pattern = image_name_pattern + self.image_count = 0 + + def __enter__(self) -> ImageSink: + if os.path.exists(self.target_dir_path): + if self.overwrite: + shutil.rmtree(self.target_dir_path) + os.makedirs(self.target_dir_path) + else: + os.makedirs(self.target_dir_path) + + return self + + def save_image( + self, image: npt.NDArray[np.uint8], image_name: str | None = None + ) -> None: + """ + Save image to target directory with optional custom filename. + + Args: + image: Image to save with shape `(height, width, 3)` + in BGR format. + image_name: Custom filename for saved image. If + `None`, generates name using `image_name_pattern`. Defaults to + `None`. + + Raises: + OSError: If `cv2.imwrite` cannot write the image to disk. + """ + if image_name is None: + image_name = self.image_name_pattern.format(self.image_count) + + image_path = os.path.join(self.target_dir_path, image_name) + if not cv2.imwrite(image_path, image): + raise OSError(f"Failed to save image to path: {image_path}") + self.image_count += 1 + + def __exit__( + self, + exc_type: type[BaseException] | None, + exc_value: BaseException | None, + exc_traceback: TracebackType | None, + ) -> None: + pass + + +@deprecated( # type: ignore[untyped-decorator] + target=TargetMode.NOTIFY, + deprecated_in="0.27.0", + remove_in="0.31.0", +) +def create_tiles( + images: list[ImageType], + grid_size: tuple[int | None, int | None] | None = None, + single_tile_size: tuple[int, int] | None = None, + tile_scaling: Literal["min", "max", "avg"] = "avg", + tile_padding_color: tuple[int, int, int] | Color = Color.from_hex("#D9D9D9"), + tile_margin: int = 10, + tile_margin_color: tuple[int, int, int] | Color = Color.from_hex("#BFBEBD"), + return_type: Literal["auto", "cv2", "pillow"] = "auto", + titles: list[str | None] | None = None, + titles_anchors: Point | list[Point | None] | None = None, + titles_color: tuple[int, int, int] | Color = Color.from_hex("#262523"), + titles_scale: float | None = None, + titles_thickness: int = 1, + titles_padding: int = 10, + titles_text_font: int = cv2.FONT_HERSHEY_SIMPLEX, + titles_background_color: tuple[int, int, int] | Color = Color.from_hex("#D9D9D9"), + default_title_placement: RelativePosition = "top", +) -> ImageType: + """ + Creates tiles mosaic from input images, automating grid placement and + converting images to common resolution maintaining aspect ratio. It is + also possible to render text titles on tiles, using optional set of + parameters specifying text drawing (see parameters description). + + Automated grid placement will try to maintain square shape of grid + (with size being the nearest integer square root of #images), up to two exceptions: + * if there are up to 3 images - images will be displayed in single row + * if square-grid placement causes last row to be empty - number of rows is trimmed + until last row has at least one image + + Args: + images: Images to create tiles. Elements can be either np.ndarray or + PIL.Image, and a common representation will be agreed by the + function. + grid_size: Expected grid size in format (n_rows, n_cols). If not + given, automated grid placement will be applied. One may also + provide only one out of two elements of the tuple - then grid + will be created with either n_rows or n_cols fixed, leaving the + other dimension to be adjusted by the number of images. + single_tile_size: Size of a single tile element provided in + (width, height) format. If not given, size of tile will be + automatically calculated based on `tile_scaling`. + tile_scaling: Strategy used to calculate tile size when + `single_tile_size` is not given, using the min / max / avg size + of images provided in `images`. + tile_padding_color: Color to be used in the image letterbox procedure + while standardizing tile sizes. If a tuple is provided, it should + be in BGR order. + tile_margin: Size of margin between tiles, in pixels. + tile_margin_color: Color of the tile margin. If a tuple is provided, + it should be in BGR order. + return_type: Format of the returned image. One may choose a specific + format ("cv2" or "pillow") to enforce conversion. "auto" mode + takes a majority vote between types of elements in `images`, + resolving draws in favour of OpenCV format. "auto" can be safely + used when all input images are of the same type. + titles: Optional titles to be added to tiles. Elements of that list + may be empty - then a specific tile, in the order presented in + `images`, will not be filled with a title. It is possible to + provide a list of titles shorter than `images` - then remaining + titles will be assumed empty. + titles_anchors: Anchor points for titles. It is possible to specify + an anchor either globally or for specific tiles, following the + order of `images`. If not given, either globally or for a + specific element of the list, it will be calculated + automatically based on `default_title_placement`. + titles_color: Color of the title text. If a tuple is provided, it + should be in BGR order. + titles_scale: Scale of titles. If not provided, the value will be + calculated using `calculate_optimal_text_scale(...)`. + titles_thickness: Thickness of title text. + titles_padding: Size of title padding. + titles_text_font: Font used to render titles. Must be an integer + constant representing an OpenCV font. + (See docs: https://docs.opencv.org/4.x/d6/d6e/group__imgproc__draw.html) + titles_background_color: Color of the title text padding. + default_title_placement: Title anchor placement used when an explicit + anchor is not provided. + + Returns: + ImageType: Image with all input images located in tiles grid. The output type is + determined by `return_type` parameter. + + Raises: + ValueError: In case when input images list is empty, provided `grid_size` is too + small to fit all images, `tile_scaling` mode is invalid. + """ + if len(images) == 0: + raise ValueError("Could not create image tiles from empty list of images.") + if return_type == "auto": + return_type = _negotiate_tiles_format(images=images) + tile_padding_color = unify_to_bgr(color=tile_padding_color) + tile_margin_color = unify_to_bgr(color=tile_margin_color) + images_cv2 = images_to_cv2(images=images) + if single_tile_size is None: + single_tile_size = _aggregate_images_shape(images=images_cv2, mode=tile_scaling) + resized_images = [ + letterbox_image( + image=i, resolution_wh=single_tile_size, color=tile_padding_color + ) + for i in images_cv2 + ] + grid_size = _establish_grid_size(images=images_cv2, grid_size=grid_size) + if len(images_cv2) > grid_size[0] * grid_size[1]: + raise ValueError( + f"Could not place {len(images_cv2)} in grid with size: {grid_size}." + ) + if titles is not None: + titles = fill(sequence=titles, desired_size=len(images_cv2), content=None) + if isinstance(titles_anchors, list): + titles_anchors_sequence = titles_anchors + else: + titles_anchors_sequence = [titles_anchors] + titles_anchors = fill( + sequence=titles_anchors_sequence, desired_size=len(images_cv2), content=None + ) + titles_color = unify_to_bgr(color=titles_color) + titles_background_color = unify_to_bgr(color=titles_background_color) + tiles_image = _generate_tiles( + images=resized_images, + grid_size=grid_size, + single_tile_size=single_tile_size, + tile_padding_color=tile_padding_color, + tile_margin=tile_margin, + tile_margin_color=tile_margin_color, + titles=titles, + titles_anchors=titles_anchors, + titles_color=titles_color, + titles_scale=titles_scale, + titles_thickness=titles_thickness, + titles_padding=titles_padding, + titles_text_font=titles_text_font, + titles_background_color=titles_background_color, + default_title_placement=default_title_placement, + ) + if return_type == "pillow": + tiles_image_pillow: object = cv2_to_pillow(image=tiles_image) + return cast(ImageType, tiles_image_pillow) + tiles_image_cv2: object = tiles_image + return cast(ImageType, tiles_image_cv2) + + +def _negotiate_tiles_format(images: list[ImageType]) -> Literal["cv2", "pillow"]: + number_of_np_arrays = sum(issubclass(type(i), np.ndarray) for i in images) + if number_of_np_arrays * 2 >= len(images): + return "cv2" + return "pillow" + + +def _calculate_aggregated_images_shape( + images: list[npt.NDArray[np.uint8]], aggregator: Callable[[list[int]], float] +) -> tuple[int, int]: + height = round(aggregator([i.shape[0] for i in images])) + width = round(aggregator([i.shape[1] for i in images])) + return width, height + + +SHAPE_AGGREGATION_FUN = { + "min": partial(_calculate_aggregated_images_shape, aggregator=np.min), + "max": partial(_calculate_aggregated_images_shape, aggregator=np.max), + "avg": partial(_calculate_aggregated_images_shape, aggregator=np.average), +} + + +def _aggregate_images_shape( + images: list[npt.NDArray[np.uint8]], mode: Literal["min", "max", "avg"] +) -> tuple[int, int]: + if mode not in SHAPE_AGGREGATION_FUN: + raise ValueError( + f"Could not aggregate images shape - provided unknown mode: {mode}. " + f"Supported modes: {list(SHAPE_AGGREGATION_FUN.keys())}." + ) + return SHAPE_AGGREGATION_FUN[mode](images) + + +def _establish_grid_size( + images: list[npt.NDArray[np.uint8]], + grid_size: tuple[int | None, int | None] | None, +) -> tuple[int, int]: + if grid_size is None or all(e is None for e in grid_size): + return _negotiate_grid_size(images=images) + if grid_size[0] is None: + columns = grid_size[1] + assert columns is not None + return math.ceil(len(images) / columns), columns + if grid_size[1] is None: + rows = grid_size[0] + assert rows is not None + return rows, math.ceil(len(images) / rows) + return cast(tuple[int, int], grid_size) + + +def _negotiate_grid_size(images: list[npt.NDArray[np.uint8]]) -> tuple[int, int]: + if len(images) <= MAX_COLUMNS_FOR_SINGLE_ROW_GRID: + return 1, len(images) + nearest_sqrt = math.ceil(np.sqrt(len(images))) + proposed_columns = nearest_sqrt + proposed_rows = nearest_sqrt + while proposed_columns * (proposed_rows - 1) >= len(images): + proposed_rows -= 1 + return proposed_rows, proposed_columns + + +def _generate_tiles( + images: list[npt.NDArray[np.uint8]], + grid_size: tuple[int, int], + single_tile_size: tuple[int, int], + tile_padding_color: tuple[int, int, int], + tile_margin: int, + tile_margin_color: tuple[int, int, int], + titles: list[str | None] | None, + titles_anchors: list[Point | None], + titles_color: tuple[int, int, int], + titles_scale: float | None, + titles_thickness: int, + titles_padding: int, + titles_text_font: int, + titles_background_color: tuple[int, int, int], + default_title_placement: RelativePosition, +) -> npt.NDArray[np.uint8]: + images = _draw_texts( + images=images, + titles=titles, + titles_anchors=titles_anchors, + titles_color=titles_color, + titles_scale=titles_scale, + titles_thickness=titles_thickness, + titles_padding=titles_padding, + titles_text_font=titles_text_font, + titles_background_color=titles_background_color, + default_title_placement=default_title_placement, + ) + rows, columns = grid_size + tiles_elements = list(create_batches(sequence=images, batch_size=columns)) + while len(tiles_elements[-1]) < columns: + tiles_elements[-1].append( + _generate_color_image(shape=single_tile_size, color=tile_padding_color) + ) + while len(tiles_elements) < rows: + tiles_elements.append( + [_generate_color_image(shape=single_tile_size, color=tile_padding_color)] + * columns + ) + return _merge_tiles_elements( + tiles_elements=tiles_elements, + grid_size=grid_size, + single_tile_size=single_tile_size, + tile_margin=tile_margin, + tile_margin_color=tile_margin_color, + ) + + +def _draw_texts( + images: list[npt.NDArray[np.uint8]], + titles: list[str | None] | None, + titles_anchors: list[Point | None], + titles_color: tuple[int, int, int], + titles_scale: float | None, + titles_thickness: int, + titles_padding: int, + titles_text_font: int, + titles_background_color: tuple[int, int, int], + default_title_placement: RelativePosition, +) -> list[npt.NDArray[np.uint8]]: + if titles is None: + return images + prepared_titles_anchors = _prepare_default_titles_anchors( + images=images, + titles_anchors=titles_anchors, + default_title_placement=default_title_placement, + ) + if titles_scale is None: + image_height, image_width = images[0].shape[:2] + titles_scale = calculate_optimal_text_scale( + resolution_wh=(image_width, image_height) + ) + result = [] + for image, text, anchor in zip(images, titles, prepared_titles_anchors): + if text is None: + result.append(image) + continue + processed_image = draw_text( + scene=image, + text=text, + text_anchor=anchor, + text_color=Color.from_bgr_tuple(titles_color), + text_scale=titles_scale, + text_thickness=titles_thickness, + text_padding=titles_padding, + text_font=titles_text_font, + background_color=Color.from_bgr_tuple(titles_background_color), + ) + result.append(processed_image) + return result + + +def _prepare_default_titles_anchors( + images: list[npt.NDArray[np.uint8]], + titles_anchors: list[Point | None], + default_title_placement: RelativePosition, +) -> list[Point]: + result = [] + for image, anchor in zip(images, titles_anchors): + if anchor is not None: + result.append(anchor) + continue + image_height, image_width = image.shape[:2] + if default_title_placement == "top": + default_anchor = Point(x=image_width / 2, y=image_height * 0.1) + else: + default_anchor = Point(x=image_width / 2, y=image_height * 0.9) + result.append(default_anchor) + return result + + +def _merge_tiles_elements( + tiles_elements: list[list[npt.NDArray[np.uint8]]], + grid_size: tuple[int, int], + single_tile_size: tuple[int, int], + tile_margin: int, + tile_margin_color: tuple[int, int, int], +) -> npt.NDArray[np.uint8]: + vertical_padding: npt.NDArray[np.uint8] = np.full( + (single_tile_size[1], tile_margin, 3), + tile_margin_color, + dtype=np.uint8, + ) + merged_rows = [ + np.concatenate( + list( + itertools.chain.from_iterable( + zip(row, [vertical_padding] * grid_size[1]) + ) + )[:-1], + axis=1, + ) + for row in tiles_elements + ] + row_width = merged_rows[0].shape[1] + horizontal_padding: npt.NDArray[np.uint8] = np.full( + (tile_margin, row_width, 3), + tile_margin_color, + dtype=np.uint8, + ) + rows_with_paddings: list[npt.NDArray[np.uint8]] = [] + for row in merged_rows: + rows_with_paddings.append(row) + rows_with_paddings.append(horizontal_padding) + return np.concatenate(rows_with_paddings[:-1], axis=0).astype(np.uint8, copy=False) + + +def _generate_color_image( + shape: tuple[int, int], color: tuple[int, int, int] +) -> npt.NDArray[np.uint8]: + return np.full((*shape[::-1], 3), color, dtype=np.uint8) diff --git a/src/supervision/utils/internal.py b/src/supervision/utils/internal.py new file mode 100644 index 0000000..2376324 --- /dev/null +++ b/src/supervision/utils/internal.py @@ -0,0 +1,209 @@ +import functools +import inspect +import os +import warnings +from collections.abc import Callable +from typing import Any, Generic, TypeVar + + +class SupervisionWarnings(Warning): + """Supervision warning category. + Set the deprecation warnings visibility for Supervision library. + You can set the environment variable SUPERVISION_DEPRECATION_WARNING to '0' + to disable the deprecation warnings. The legacy misspelled + SUPERVISON_DEPRECATION_WARNING variable is still accepted. + """ + + pass + + +def format_warning( + message: Warning | str, + category: type[Warning], + filename: str, + lineno: int, + line: str | None = None, +) -> str: + """ + Format a warning the same way as the default formatter, but also include the + category name in the output. + """ + return f"{category.__name__}: {message}\n" + + +deprecation_warning_env = os.getenv( + "SUPERVISION_DEPRECATION_WARNING", + os.getenv("SUPERVISON_DEPRECATION_WARNING"), +) +if deprecation_warning_env == "0": + warnings.simplefilter("ignore", SupervisionWarnings) +else: + warnings.simplefilter("always", SupervisionWarnings) + + +def warn_deprecated(message: str) -> None: + """ + Issue a warning that a function is deprecated. + + Args: + message: The message to display when the function is called. + """ + warnings.warn(message, category=SupervisionWarnings, stacklevel=2) + + +def deprecated_parameter( + old_parameter: str, + new_parameter: str, + map_function: Callable[[Any], Any] = lambda x: x, + warning_message: str = "Warning: '{old_parameter}' in '{function_name}' is " + "deprecated: use '{new_parameter}' instead.", + **message_kwargs: Any, +) -> Callable[[Any], Any]: + """ + A decorator to mark a function's parameter as deprecated and issue a warning when + used. + + Args: + old_parameter: The name of the deprecated parameter. + new_parameter: The name of the parameter that should be used instead. + map_function: A function used to map the value of the old + parameter to the new parameter. Defaults to the identity function. + warning_message: The warning message to be displayed when the + deprecated parameter is used. Defaults to a generic warning message with + placeholders for the old parameter, new parameter, and function name. + **message_kwargs: Additional keyword arguments that can be used to customize + the warning message. + + Returns: + A decorator function that can be applied to mark a function's + parameter as deprecated. + + Examples: + ```pycon + >>> from supervision.utils.internal import deprecated_parameter + >>> import warnings + >>> @deprecated_parameter( + ... old_parameter='old_name', + ... new_parameter='new_name' + ... ) + ... def example_function(new_name=None): + ... return new_name + >>> # Calling with new parameter works normally + >>> example_function(new_name='value') + 'value' + >>> # Calling with old parameter triggers warning but still works + >>> with warnings.catch_warnings(record=True): + ... result = example_function(old_name='deprecated_value') + ... print(result) + deprecated_value + + ``` + """ + + def decorator(func: Callable[..., Any]) -> Callable[..., Any]: + @functools.wraps(func) + def wrapper(*args: Any, **kwargs: Any) -> Any: + if old_parameter in kwargs: + if args and hasattr(args[0], "__class__"): + class_name = args[0].__class__.__name__ + function_name = f"{class_name}.{func.__name__}" + else: + function_name = func.__name__ + + warn_deprecated( + message=warning_message.format( + function_name=function_name, + old_parameter=old_parameter, + new_parameter=new_parameter, + **message_kwargs, + ) + ) + + kwargs[new_parameter] = map_function(kwargs.pop(old_parameter)) + + return func(*args, **kwargs) + + return wrapper + + return decorator + + +T = TypeVar("T") + + +class classproperty(Generic[T]): + """ + A decorator that combines @classmethod and @property. + It allows a method to be accessed as a property of the class, + rather than an instance, similar to a classmethod. + + Usage: + @classproperty + def my_method(cls): + ... + """ + + def __init__(self, fget: Callable[..., T]) -> None: + """ + Args: + The function that is called when the property is accessed. + """ + self.fget = fget + + def __get__(self, owner_self: Any, owner_cls: type | None = None) -> T: + """ + Override the __get__ method to return the result of the function call. + + Args: + owner_self: The instance through which the attribute was accessed, or None. + Irrelevant for class properties. + owner_cls: The class through which the attribute was accessed. + + Returns: + The result of calling the function stored in 'fget' with 'owner_cls'. + """ + if self.fget is None: + raise AttributeError("unreadable attribute") + return self.fget(owner_cls) + + +def get_instance_variables(instance: Any, include_properties: bool = False) -> set[str]: + """ + Get the public variables of a class instance. + + Args: + instance: The instance of a class + include_properties: Whether to include properties in the result + + Usage: + ```pycon + >>> from supervision.utils.internal import get_instance_variables + >>> import numpy as np + >>> from supervision import Detections + >>> detections = Detections(xyxy=np.array([[1, 2, 3, 4]])) + >>> variables = get_instance_variables(detections) + >>> 'xyxy' in variables + True + >>> 'data' in variables + True + + ``` + """ + if isinstance(instance, type): + raise ValueError("Only class instances are supported, not classes.") + + fields = { + name + for name, val in inspect.getmembers(instance) + if not callable(val) and not name.startswith("_") + } + + if not include_properties: + properties = { + name + for name, val in inspect.getmembers(instance.__class__) + if isinstance(val, property) + } + fields -= properties + + return fields diff --git a/src/supervision/utils/iterables.py b/src/supervision/utils/iterables.py new file mode 100644 index 0000000..9b30e6b --- /dev/null +++ b/src/supervision/utils/iterables.py @@ -0,0 +1,103 @@ +from collections.abc import Generator, Iterable +from typing import TypeVar + +V = TypeVar("V") + + +def create_batches( + sequence: Iterable[V], batch_size: int +) -> Generator[list[V], None, None]: + """ + Provides a generator that yields chunks of the input sequence + of the size specified by the `batch_size` parameter. The last + chunk may be a smaller batch. + + Args: + sequence: The sequence to be split into batches. + batch_size: The expected size of a batch. + + Returns: + A generator that yields chunks + of `sequence` of size `batch_size`, up to the length of + the input `sequence`. + + Examples: + ```pycon + >>> from supervision.utils.iterables import create_batches + >>> list(create_batches([1, 2, 3, 4, 5], 2)) + [[1, 2], [3, 4], [5]] + >>> list(create_batches("abcde", 3)) + [['a', 'b', 'c'], ['d', 'e']] + + ``` + """ + batch_size = max(batch_size, 1) + current_batch: list[V] = [] + for element in sequence: + if len(current_batch) == batch_size: + yield current_batch + current_batch = [] + current_batch.append(element) + if current_batch: + yield current_batch + + +def fill(sequence: list[V], desired_size: int, content: V) -> list[V]: + """ + Fill the sequence with padding elements until the sequence reaches + the desired size. + + Args: + sequence: The input sequence. + desired_size: The expected size of the output list. The + difference between this value and the actual length of `sequence` + (if positive) dictates how many elements will be added as padding. + content: The element to be placed at the end of the input + `sequence` as padding. + + Returns: + A padded version of the input `sequence` (if needed). + + Examples: + ```pycon + >>> from supervision.utils.iterables import fill + >>> fill([1, 2], 4, 0) + [1, 2, 0, 0] + >>> fill(['a', 'b'], 3, 'c') + ['a', 'b', 'c'] + + ``` + """ + missing_size = max(0, desired_size - len(sequence)) + sequence.extend([content] * missing_size) + return sequence + + +def find_duplicates(sequence: list[V]) -> list[V]: + """ + Find all duplicate elements in the input sequence. + + Args: + sequence: The input sequence. + + Returns: + A list of duplicate elements found in the sequence. + + Examples: + ```pycon + >>> from supervision.utils.iterables import find_duplicates + >>> sorted(find_duplicates([1, 2, 3, 2, 4, 5, 1])) + [1, 2] + >>> find_duplicates(['a', 'b', 'c']) + [] + + ``` + """ + seen = set() + duplicates = set() + for element in sequence: + if element in seen: + duplicates.add(element) + else: + seen.add(element) + return list(duplicates) diff --git a/src/supervision/utils/logger.py b/src/supervision/utils/logger.py new file mode 100644 index 0000000..2ed8c45 --- /dev/null +++ b/src/supervision/utils/logger.py @@ -0,0 +1,61 @@ +import logging +import os +import sys + + +def _get_logger(name: str = "supervision", level: int | None = None) -> logging.Logger: + """Creates and configures a logger with stdout and stderr handlers. + + This function creates a logger that sends INFO and DEBUG level logs to stdout, + and WARNING, ERROR, and CRITICAL level logs to stderr. If the logger already + has handlers, it returns the existing logger without adding new handlers. + + The log level can be specified directly or through the `LOG_LEVEL` environment + variable. + + Args: + name: The name of the logger. Defaults to `"supervision"`. + level: The logging level to set. If `None`, uses the `LOG_LEVEL` environment + variable, defaulting to `INFO` if not set. + + Returns: + A configured `logging.Logger` instance. + + Example: + ```pycon + >>> from supervision.utils.logger import _get_logger + >>> import logging + >>> logger = _get_logger("test_logger", level=logging.INFO) + >>> logger.name + 'test_logger' + >>> logger.level == logging.INFO + True + + ``` + """ + if level is None: + level = getattr(logging, os.getenv("LOG_LEVEL", "INFO").upper(), logging.INFO) + + logger = logging.getLogger(name) + logger.setLevel(level) + + if not logger.handlers: + formatter = logging.Formatter( + "[%(asctime)s] [%(levelname)s] %(name)s - %(message)s", + datefmt="%Y-%m-%d %H:%M:%S", + ) + + stdout_handler = logging.StreamHandler(sys.stdout) + stdout_handler.setLevel(logging.DEBUG) + stdout_handler.addFilter(lambda r: r.levelno <= logging.INFO) + stdout_handler.setFormatter(formatter) + + stderr_handler = logging.StreamHandler(sys.stderr) + stderr_handler.setLevel(logging.WARNING) + stderr_handler.setFormatter(formatter) + + logger.addHandler(stdout_handler) + logger.addHandler(stderr_handler) + logger.propagate = False + + return logger diff --git a/src/supervision/utils/notebook.py b/src/supervision/utils/notebook.py new file mode 100644 index 0000000..c537be7 --- /dev/null +++ b/src/supervision/utils/notebook.py @@ -0,0 +1,124 @@ +import cv2 +import numpy as np +import numpy.typing as npt +from PIL import Image + +from supervision.draw.base import ImageType +from supervision.utils.conversion import pillow_to_cv2 + + +def plot_image( + image: ImageType, size: tuple[int, int] = (12, 12), cmap: str | None = "gray" +) -> None: + """ + Plots image using matplotlib. + + Args: + image: The frame to be displayed ImageType + is a flexible type, accepting either `numpy.ndarray` or `PIL.Image.Image`. + size: The size of the plot in inches. + cmap: the colormap to use for single channel images. + + Examples: + ```pycon + >>> import cv2 + >>> import numpy as np + >>> import matplotlib + >>> matplotlib.use('Agg') # Prevents the GUI window from popping up + >>> import supervision as sv + >>> image = np.zeros((100, 100, 3), dtype=np.uint8) + >>> sv.plot_image(image=image, size=(16, 16)) + ... + + ``` + """ + if isinstance(image, Image.Image): + image_np = pillow_to_cv2(image) + else: + image_np = image + + # Keep pyplot lazy so importing notebook helpers does not import matplotlib. + import matplotlib.pyplot as plt + + plt.figure(figsize=size) + + if image_np.ndim == 2: + plt.imshow(image_np, cmap=cmap) + else: + plt.imshow(cv2.cvtColor(image_np, cv2.COLOR_BGR2RGB)) + + plt.axis("off") + plt.show() + + +def plot_images_grid( + images: list[ImageType], + grid_size: tuple[int, int], + titles: list[str] | None = None, + size: tuple[int, int] = (12, 12), + cmap: str | None = "gray", +) -> None: + """ + Plots images in a grid using matplotlib. + + Args: + images: A list of images as ImageType + is a flexible type, accepting either `numpy.ndarray` or `PIL.Image.Image`. + grid_size: A tuple specifying the number + of rows and columns for the grid. + titles: A list of titles for each image. + Defaults to None. + size: A tuple specifying the width and + height of the entire plot in inches. + cmap: the colormap to use for single channel images. + + Raises: + ValueError: If the number of images exceeds the grid size. + + Examples: + ```pycon + >>> import cv2 + >>> import numpy as np + >>> import matplotlib + >>> matplotlib.use('Agg') # Prevents the GUI window from popping up + >>> import supervision as sv + >>> from PIL import Image + >>> image1 = np.zeros((100, 100, 3), dtype=np.uint8) + >>> image2 = Image.new('RGB', (100, 100)) + >>> image3 = np.zeros((100, 100, 3), dtype=np.uint8) + >>> images = [image1, image2, image3] + >>> titles = ["Image 1", "Image 2", "Image 3"] + >>> sv.plot_images_grid(images, grid_size=(2, 2), titles=titles, size=(16, 16)) + ... + + ``` + """ + nrows, ncols = grid_size + + images_np: list[npt.NDArray[np.uint8]] = [ + pillow_to_cv2(img) if isinstance(img, Image.Image) else img for img in images + ] + + if len(images_np) > nrows * ncols: + raise ValueError( + "The number of images exceeds the grid size. Please increase the grid size" + " or reduce the number of images." + ) + + # Keep pyplot lazy so importing notebook helpers does not import matplotlib. + import matplotlib.pyplot as plt + + _fig, axes = plt.subplots(nrows=nrows, ncols=ncols, figsize=size) + + for idx, ax in enumerate(axes.flat): + if idx < len(images_np): + if images_np[idx].ndim == 2: + ax.imshow(images_np[idx], cmap=cmap) + else: + ax.imshow(cv2.cvtColor(images_np[idx], cv2.COLOR_BGR2RGB)) + + if titles is not None and idx < len(titles): + ax.set_title(titles[idx]) + + ax.axis("off") + plt.show() diff --git a/src/supervision/utils/video.py b/src/supervision/utils/video.py new file mode 100644 index 0000000..fa76d9d --- /dev/null +++ b/src/supervision/utils/video.py @@ -0,0 +1,533 @@ +from __future__ import annotations + +import os +import shutil +import subprocess +import tempfile +import threading +import time +from collections import deque +from collections.abc import Callable, Generator +from dataclasses import dataclass +from queue import Empty, Full, Queue +from types import TracebackType +from typing import cast + +import cv2 +import numpy as np +import numpy.typing as npt +from tqdm.auto import tqdm + +from supervision.utils.logger import _get_logger + +logger = _get_logger(__name__) + + +@dataclass +class VideoInfo: + """ + A class to store video information, including width, height, fps and + total number of frames. + + Attributes: + width: width of the video in pixels + height: height of the video in pixels + fps: frames per second of the video as a float. Common values include + 23.976, 24.0, 25.0, 29.97, 30.0, 59.94, and 60.0. + total_frames: total number of frames in the video, + default is None + + Examples: + ```python + import supervision as sv + + video_info = sv.VideoInfo.from_video_path(video_path="") + + video_info + # VideoInfo(width=3840, height=2160, fps=25.0, total_frames=538) + + video_info.resolution_wh + # (3840, 2160) + ``` + """ + + width: int + height: int + fps: float + total_frames: int | None = None + + @classmethod + def from_video_path(cls, video_path: str) -> VideoInfo: + video = cv2.VideoCapture(video_path) + if not video.isOpened(): + raise Exception(f"Could not open video at {video_path}") + + width = int(video.get(cv2.CAP_PROP_FRAME_WIDTH)) + height = int(video.get(cv2.CAP_PROP_FRAME_HEIGHT)) + fps = float(video.get(cv2.CAP_PROP_FPS)) + total_frames = int(video.get(cv2.CAP_PROP_FRAME_COUNT)) + video.release() + return VideoInfo(width, height, fps, total_frames) + + @property + def resolution_wh(self) -> tuple[int, int]: + return self.width, self.height + + +class VideoSink: + """ + Context manager that saves video frames to a file using OpenCV. + + Attributes: + target_path: The path to the output file where the video will be saved. + video_info: Information about the video resolution, fps, + and total frame count. + codec: FOURCC code for video format + + Example: + ```python + import supervision as sv + + video_info = sv.VideoInfo.from_video_path("") + frames_generator = sv.get_video_frames_generator("") + + with sv.VideoSink(target_path="", video_info=video_info) as sink: + for frame in frames_generator: + sink.write_frame(frame=frame) + ``` + """ # noqa: E501 // docs + + def __init__( + self, target_path: str, video_info: VideoInfo, codec: str = "mp4v" + ) -> None: + self.target_path = target_path + self.video_info = video_info + self.__codec = codec + self.__fourcc: int = 0 + self.__writer: cv2.VideoWriter | None = None + + def __enter__(self) -> VideoSink: + """Open the underlying video writer for context-managed frame output.""" + fourcc_fn = cast( + Callable[[str, str, str, str], int], getattr(cv2, "VideoWriter_fourcc") + ) + try: + self.__fourcc = int(fourcc_fn(*self.__codec)) + except TypeError as e: + logger.warning("%s. Defaulting to mp4v...", str(e)) + self.__fourcc = int(fourcc_fn(*"mp4v")) + self.__writer = cv2.VideoWriter( + self.target_path, + self.__fourcc, + self.video_info.fps, + self.video_info.resolution_wh, + ) + # OpenCV can construct a writer object that is not usable for the target path. + if not self.__writer.isOpened(): + self.__writer.release() + self.__writer = None + raise RuntimeError(f"Could not open video writer for {self.target_path}") + return self + + def write_frame(self, frame: npt.NDArray[np.uint8]) -> None: + """ + Writes a single video frame to the target video file. + + Args: + frame: The video frame to be written to the file. The frame + must be in BGR color format. + """ + # Preserve the context-manager invariant instead of silently dropping frames. + if self.__writer is None: + raise RuntimeError("write_frame requires an open VideoSink context.") + self.__writer.write(frame) + + def __exit__( + self, + exc_type: type[BaseException] | None, + exc_value: BaseException | None, + exc_traceback: TracebackType | None, + ) -> None: + """Release the underlying video writer when leaving the context.""" + if self.__writer is not None: + self.__writer.release() + self.__writer = None + + +def _mux_audio(source_path: str, video_path: str) -> None: + """Mux audio from `source_path` into `video_path` in-place using ffmpeg. + + Args: + source_path: Path to the original video file containing the audio stream. + video_path: Path to the video-only file to be updated with audio. + """ + ffmpeg_path = shutil.which("ffmpeg") + if ffmpeg_path is None: + logger.warning( + "ffmpeg not found on PATH. Audio will not be preserved. " + "Install ffmpeg to enable audio preservation." + ) + return + + tmp_path = None + try: + tmp_fd, tmp_path = tempfile.mkstemp( + suffix=os.path.splitext(video_path)[1], + dir=os.path.dirname(os.path.abspath(video_path)), + ) + os.close(tmp_fd) + result = subprocess.run( # noqa: S603 + [ + ffmpeg_path, + "-y", + "-loglevel", + "error", + "-nostats", + "-i", + video_path, + "-i", + source_path, + "-c:v", + "copy", + "-c:a", + "copy", + "-map", + "0:v:0", + "-map", + "1:a:0?", + "-shortest", + tmp_path, + ], + stdout=subprocess.DEVNULL, + stderr=subprocess.PIPE, + timeout=300, + ) + if result.returncode != 0: + stderr_msg = result.stderr.decode(errors="replace").strip() + logger.warning( + "ffmpeg failed to mux audio (return code %d)%s. " + "The output video will not have audio.", + result.returncode, + f": {stderr_msg}" if stderr_msg else "", + ) + return + os.replace(tmp_path, video_path) + except Exception as exc: + logger.warning( + "Audio muxing failed: %s. Output video will not have audio.", exc + ) + finally: + if tmp_path is not None and os.path.exists(tmp_path): + os.remove(tmp_path) + + +def _validate_and_setup_video( + source_path: str, start: int, end: int | None, iterative_seek: bool = False +) -> tuple[cv2.VideoCapture, int, int]: + video = cv2.VideoCapture(source_path) + if not video.isOpened(): + raise Exception(f"Could not open video at {source_path}") + total_frames = int(video.get(cv2.CAP_PROP_FRAME_COUNT)) + if end is not None and end > total_frames: + raise Exception("Requested frames are outbound") + start = max(start, 0) + end = min(end, total_frames) if end is not None else total_frames + + if iterative_seek: + while start > 0: + success = video.grab() + if not success: + break + start -= 1 + elif start > 0: + video.set(cv2.CAP_PROP_POS_FRAMES, start) + + return video, start, end + + +def get_video_frames_generator( + source_path: str, + stride: int = 1, + start: int = 0, + end: int | None = None, + iterative_seek: bool = False, +) -> Generator[npt.NDArray[np.uint8], None, None]: + """ + Get a generator that yields the frames of the video. + + Args: + source_path: The path of the video file. + stride: Indicates the interval at which frames are returned, + skipping stride - 1 frames between each. + start: Indicates the starting position from which + video should generate frames + end: Indicates the ending position at which video + should stop generating frames. If None, video will be read to the end. + iterative_seek: If True, the generator will seek to the + `start` frame by grabbing each frame, which is much slower. This is a + workaround for videos that don't open at all when you set the `start` value. + + Returns: + A generator that yields the + frames of the video. + + Note: + The underlying `cv2.VideoCapture` is always released when the generator + is exhausted or closed, even if the consumer breaks out of iteration early. + + Examples: + ```python + import supervision as sv + + for frame in sv.get_video_frames_generator(source_path=""): + ... + ``` + """ + video, start, end = _validate_and_setup_video( + source_path, start, end, iterative_seek + ) + frame_position = start + try: + while True: + success, frame = video.read() + if not success or frame_position >= end: + break + if frame is not None: + yield cast(npt.NDArray[np.uint8], frame) + for _ in range(stride - 1): + success = video.grab() + if not success: + break + frame_position += stride + finally: + video.release() + + +def process_video( + source_path: str, + target_path: str, + callback: Callable[[npt.NDArray[np.uint8], int], npt.NDArray[np.uint8]], + *, + max_frames: int | None = None, + prefetch: int = 32, + writer_buffer: int = 32, + show_progress: bool = False, + progress_message: str = "Processing video", + preserve_audio: bool = False, +) -> None: + """ + Process video frames asynchronously using a threaded pipeline. + + This function orchestrates a three-stage pipeline to optimize video processing + throughput: + + 1. Reader thread: Continuously reads frames from the source video file and + enqueues them into a bounded queue (`frame_read_queue`). The queue size is + limited by the `prefetch` parameter to control memory usage. + 2. Main thread (Processor): Dequeues frames from `frame_read_queue`, applies the + user-defined `callback` function to process each frame, then enqueues the + processed frames into another bounded queue (`frame_write_queue`) for writing. + The processing happens in the main thread, simplifying use of stateful objects + without synchronization. + 3. Writer thread: Dequeues processed frames from `frame_write_queue` and writes + them sequentially to the output video file. + + Args: + source_path: Path to the input video file. + target_path: Path where the processed video will be saved. + callback: Function called for + each frame, accepting the frame as a numpy array and its zero-based index, + returning the processed frame. + max_frames: Optional maximum number of frames to process. + If None, the entire video is processed (default). + prefetch: Maximum number of frames buffered by the reader thread. + Controls memory use; default is 32. + writer_buffer: Maximum number of frames buffered before writing. + Controls output buffer size; default is 32. + show_progress: Whether to display a tqdm progress bar during processing. + Default is False. + progress_message: Description shown in the progress bar. + preserve_audio: If True, copy the audio stream from `source_path` into + `target_path` after frame processing. Requires `ffmpeg` on PATH + (e.g. `apt install ffmpeg`, `brew install ffmpeg`). If ffmpeg is + not found or the mux step fails, a warning is logged and the output + video is saved without audio โ€” no exception is raised. Audio is + truncated to match the processed video duration. Default is False. + + Returns: + None + + Example: + ```python + import supervision as sv + from rfdetr import RFDETRMedium + + model = RFDETRMedium() + + def callback(frame, frame_index): + return model.predict(frame) + + sv.process_video( + source_path="source.mp4", + target_path="target.mp4", + callback=callback, + preserve_audio=True, + ) + ``` + """ + video_info = VideoInfo.from_video_path(video_path=source_path) + total_frames = ( + min(video_info.total_frames or 0, max_frames) + if max_frames is not None + else video_info.total_frames or 0 + ) + + frame_read_queue: Queue[tuple[int, npt.NDArray[np.uint8]] | None] = Queue( + maxsize=prefetch + ) + frame_write_queue: Queue[npt.NDArray[np.uint8] | None] = Queue( + maxsize=writer_buffer + ) + + def reader_thread() -> None: + frame_generator = get_video_frames_generator( + source_path=source_path, + end=max_frames, + ) + for frame_index, frame in enumerate(frame_generator): + frame_read_queue.put((frame_index, frame)) + frame_read_queue.put(None) + + def writer_thread(video_sink: VideoSink) -> None: + while True: + frame = frame_write_queue.get() + if frame is None: + break + video_sink.write_frame(frame=frame) + + reader_worker = threading.Thread(target=reader_thread, daemon=True) + with VideoSink(target_path=target_path, video_info=video_info) as video_sink: + writer_worker = threading.Thread( + target=writer_thread, + args=(video_sink,), + daemon=True, + ) + + reader_worker.start() + writer_worker.start() + + progress_bar = tqdm( + total=total_frames, + disable=not show_progress, + desc=progress_message, + ) + + exception_in_worker: Exception | None = None + read_finished = False + + try: + while True: + read_item = frame_read_queue.get() + if read_item is None: + read_finished = True + break + + frame_index, frame = read_item + try: + processed_frame = callback(frame, frame_index) + frame_write_queue.put(processed_frame) + progress_bar.update(1) + except Exception as exc: + exception_in_worker = exc + break + finally: + try: + frame_write_queue.put(None, timeout=1) + except Full: + # Best effort: if the writer is stuck and the queue never drains, + # do not block shutdown forever trying to enqueue the sentinel. + pass + if not read_finished: + while True: + # Use timeout to prevent indefinite blocking if reader thread fails + try: + read_item = frame_read_queue.get(timeout=1) + if read_item is None: + break + # If we timeout waiting for a frame, only assume failure if reader + # thread is no longer alive. Otherwise, keep waiting as the reader + # may simply be slow (for example, due to a slow source). + except Empty: + if not reader_worker.is_alive(): + break + # Reader is still alive; continue waiting for frames. + continue + reader_worker.join(timeout=10) + writer_worker.join(timeout=10) + progress_bar.close() + if exception_in_worker is not None: + raise exception_in_worker + + if preserve_audio: + if writer_worker.is_alive(): + logger.warning( + "Writer thread did not finish in time; skipping audio mux " + "to avoid reading an incomplete output file." + ) + else: + _mux_audio(source_path=source_path, video_path=target_path) + + +class FPSMonitor: + """ + A class for monitoring frames per second (FPS) to benchmark latency. + """ + + def __init__(self, sample_size: int = 30) -> None: + """ + Args: + sample_size: The maximum number of observations for latency + benchmarking. + + Examples: + ```python + import supervision as sv + + frames_generator = sv.get_video_frames_generator( + source_path="") + fps_monitor = sv.FPSMonitor() + + for frame in frames_generator: + # your processing code here + fps_monitor.tick() + fps = fps_monitor.fps + ``` + """ + self.all_timestamps: deque[float] = deque(maxlen=sample_size) + + @property + def fps(self) -> float: + """ + Computes and returns the average FPS based on the stored time stamps. + + Returns: + The average FPS across the recorded intervals. Returns 0.0 if fewer + than two time stamps are stored. + """ + if len(self.all_timestamps) < 2: + return 0.0 + taken_time = self.all_timestamps[-1] - self.all_timestamps[0] + frame_intervals = len(self.all_timestamps) - 1 + return frame_intervals / taken_time if taken_time != 0 else 0.0 + + def tick(self) -> None: + """ + Adds a new time stamp to the deque for FPS calculation. + """ + self.all_timestamps.append(time.monotonic()) + + def reset(self) -> None: + """ + Clears all the time stamps from the deque. + """ + self.all_timestamps.clear() diff --git a/src/supervision/validators/__init__.py b/src/supervision/validators/__init__.py new file mode 100644 index 0000000..b8cd58d --- /dev/null +++ b/src/supervision/validators/__init__.py @@ -0,0 +1,363 @@ +from typing import Any + +import numpy as np +from deprecate import deprecated, void # type: ignore[import-untyped,unused-ignore] + +from supervision.detection.compact_mask import CompactMask +from supervision.utils.internal import warn_deprecated + + +def _validate_xyxy(xyxy: Any) -> None: + """Validate that xyxy is a 2D np.ndarray with shape (N, 4). + + ```pycon + >>> _validate_xyxy(np.array([[0, 0, 1, 1], [1, 1, 2, 2]])) + + ``` + """ + expected_shape = "(_, 4)" + actual_shape = str(getattr(xyxy, "shape", None)) + is_valid = isinstance(xyxy, np.ndarray) and xyxy.ndim == 2 and xyxy.shape[1] == 4 + if not is_valid: + raise ValueError( + f"xyxy must be a 2D np.ndarray with shape {expected_shape}, but got shape " + f"{actual_shape}" + ) + + +@deprecated( # type: ignore[untyped-decorator] + target=_validate_xyxy, + deprecated_in="0.29.0", + remove_in="0.32.0", +) +def validate_xyxy(xyxy: Any) -> None: + void(xyxy) + + +def _validate_mask(mask: Any, n: int) -> None: + if mask is None: + return + + # Fast path: CompactMask only needs a length check. + + if isinstance(mask, CompactMask): + if len(mask) != n: + raise ValueError(f"mask must contain {n} masks, but got {len(mask)}") + return + + expected_shape = f"({n}, H, W)" + actual_shape = str(getattr(mask, "shape", None)) + actual_dtype = getattr(mask, "dtype", None) + + is_valid_shape = ( + isinstance(mask, np.ndarray) and len(mask.shape) == 3 and mask.shape[0] == n + ) + if not is_valid_shape: + raise ValueError( + "mask must be a 3D np.ndarray with shape " + + f"{expected_shape}, but got shape {actual_shape}" + ) + if not np.issubdtype(actual_dtype, bool): + warn_deprecated( + f"A `Detections` object was created with a mask of type {actual_dtype}." + " Masks of type other than `bool` are deprecated and may produce unexpected" + " behavior. Starting from `supervision-0.28.0`, passing a mask with" + " `dtype` different from `bool` to `Detections` will raise a `ValueError`" + " during validation instead of being accepted with a warning. To migrate," + " please ensure your masks are boolean, for example by using" + " `mask = np.array(..., dtype=bool)` or by converting existing masks with" + " `mask = mask.astype(bool)` before creating the `Detections` object. If" + " you did not create the mask manually, please report the issue to the" + " `supervision` team." + ) + + +@deprecated( # type: ignore[untyped-decorator] + target=_validate_mask, + deprecated_in="0.29.0", + remove_in="0.32.0", +) +def validate_mask(mask: Any, n: int) -> None: + void(mask, n) + + +def _validate_class_id(class_id: Any, n: int) -> None: + expected_shape = f"({n},)" + actual_shape = str(getattr(class_id, "shape", None)) + is_valid = class_id is None or ( + isinstance(class_id, np.ndarray) and class_id.shape == (n,) + ) + if not is_valid: + raise ValueError( + f"class_id must be a 1D np.ndarray with shape {expected_shape}, but got " + f"shape {actual_shape}" + ) + + +@deprecated( # type: ignore[untyped-decorator] + target=_validate_class_id, + deprecated_in="0.29.0", + remove_in="0.32.0", +) +def validate_class_id(class_id: Any, n: int) -> None: + void(class_id, n) + + +def _validate_confidence(confidence: Any, n: int) -> None: + """Validate detection-level confidence: 1D ``np.ndarray`` with shape ``(n,)``.""" + expected_shape = f"({n},)" + actual_shape = str(getattr(confidence, "shape", None)) + is_valid = confidence is None or ( + isinstance(confidence, np.ndarray) and confidence.shape == (n,) + ) + if not is_valid: + raise ValueError( + f"confidence must be a 1D np.ndarray with shape {expected_shape}, but got " + f"shape {actual_shape}" + ) + + +@deprecated( # type: ignore[untyped-decorator] + target=_validate_confidence, + deprecated_in="0.29.0", + remove_in="0.32.0", +) +def validate_confidence(confidence: Any, n: int) -> None: + void(confidence, n) + + +def _validate_keypoint_confidence(confidence: Any, n: int, m: int) -> None: + """Validate per-keypoint confidence: 2D ``np.ndarray`` with shape ``(n, m)``.""" + actual_shape = str(getattr(confidence, "shape", None)) + + if confidence is not None: + if not isinstance(confidence, np.ndarray) or confidence.ndim != 2: + raise ValueError( + f"keypoint_confidence must be a 2D np.ndarray with shape (n, m), but " + f"got shape {actual_shape}" + ) + if confidence.shape[0] != n: + raise ValueError( + f"keypoint_confidence first dimension must be {n}, " + f"but got shape {actual_shape}" + ) + if n > 0 and confidence.shape[1] != m: + raise ValueError( + f"keypoint_confidence second dimension must be {m}, but " + f"got shape {actual_shape}" + ) + + +@deprecated( # type: ignore[untyped-decorator] + target=_validate_keypoint_confidence, + deprecated_in="0.29.0", + remove_in="0.32.0", +) +def validate_key_point_confidence(confidence: Any, n: int, m: int) -> None: + void(confidence, n, m) + + +@deprecated( # type: ignore[untyped-decorator] + target=_validate_keypoint_confidence, + deprecated_in="0.27.0", + remove_in="0.31.0", +) +def validate_keypoint_confidence(confidence: Any, n: int, m: int) -> None: + void(confidence, n, m) + + +def _validate_tracker_id(tracker_id: Any, n: int) -> None: + expected_shape = f"({n},)" + actual_shape = str(getattr(tracker_id, "shape", None)) + is_valid = tracker_id is None or ( + isinstance(tracker_id, np.ndarray) and tracker_id.shape == (n,) + ) + if not is_valid: + raise ValueError( + f"tracker_id must be a 1D np.ndarray with shape {expected_shape}, but got " + f"shape {actual_shape}" + ) + + +@deprecated( # type: ignore[untyped-decorator] + target=_validate_tracker_id, + deprecated_in="0.29.0", + remove_in="0.32.0", +) +def validate_tracker_id(tracker_id: Any, n: int) -> None: + void(tracker_id, n) + + +def _validate_data(data: dict[str, Any], n: int) -> None: + for key, value in data.items(): + if isinstance(value, list): + if len(value) != n: + raise ValueError(f"Length of list for key '{key}' must be {n}") + elif isinstance(value, np.ndarray): + if value.ndim == 1 and value.shape[0] != n: + raise ValueError(f"Shape of np.ndarray for key '{key}' must be ({n},)") + elif value.ndim > 1 and value.shape[0] != n: + raise ValueError( + f"First dimension of np.ndarray for key '{key}' must have size {n}" + ) + else: + raise ValueError(f"Value for key '{key}' must be a list or np.ndarray") + + +@deprecated( # type: ignore[untyped-decorator] + target=_validate_data, + deprecated_in="0.29.0", + remove_in="0.32.0", +) +def validate_data(data: dict[str, Any], n: int) -> None: + void(data, n) + + +def _validate_xy(xy: Any, n: int, m: int) -> None: + expected_shape = f"({n}, {m}, 2) or ({n}, {m}, 3)" + actual_shape = str(getattr(xy, "shape", None)) + + if not isinstance(xy, np.ndarray) or xy.ndim != 3 or xy.shape[2] not in (2, 3): + raise ValueError( + f"xy must be a 3D np.ndarray with shape {expected_shape}, but got shape " + f"{actual_shape}" + ) + + +@deprecated( # type: ignore[untyped-decorator] + target=_validate_xy, + deprecated_in="0.29.0", + remove_in="0.32.0", +) +def validate_xy(xy: Any, n: int, m: int) -> None: + void(xy, n, m) + + +def _validate_visible(visible: Any, n: int, m: int) -> None: + """Validate per-keypoint visibility mask. + + Expects a 2D bool ``np.ndarray`` with shape ``(n, m)``. + """ + if visible is None: + return + actual_shape = str(getattr(visible, "shape", None)) + if not isinstance(visible, np.ndarray) or visible.ndim != 2: + raise ValueError( + "visible must be a 2D np.ndarray with shape (n, m), but " + f"got shape {actual_shape}" + ) + if visible.shape[0] != n: + raise ValueError( + f"visible first dimension must be {n}, but got shape {actual_shape}" + ) + if n > 0 and visible.shape[1] != m: + raise ValueError( + f"visible second dimension must be {m}, but got shape {actual_shape}" + ) + + +def _validate_detections_fields( + xyxy: Any, + mask: Any, + class_id: Any, + confidence: Any, + tracker_id: Any, + data: dict[str, Any], +) -> None: + _validate_xyxy(xyxy) + n = len(xyxy) + _validate_mask(mask, n) + _validate_class_id(class_id, n) + _validate_confidence(confidence, n) + _validate_tracker_id(tracker_id, n) + _validate_data(data, n) + + +@deprecated( # type: ignore[untyped-decorator] + target=_validate_detections_fields, + deprecated_in="0.29.0", + remove_in="0.32.0", +) +def validate_detections_fields( + xyxy: Any, + mask: Any, + class_id: Any, + confidence: Any, + tracker_id: Any, + data: dict[str, Any], +) -> None: + void(xyxy, mask, class_id, confidence, tracker_id, data) + + +def _validate_keypoints_fields( + xy: Any, + class_id: Any, + confidence: Any, + detection_confidence: Any = None, + visible: Any = None, + data: dict[str, Any] | None = None, +) -> None: + n = len(xy) + m = len(xy[0]) if len(xy) > 0 else 0 + _validate_xy(xy, n, m) + _validate_class_id(class_id, n) + _validate_keypoint_confidence(confidence, n, m) + if detection_confidence is not None: + _validate_confidence(detection_confidence, n) + _validate_visible(visible, n, m) + if data is not None: + _validate_data(data, n) + + +@deprecated( # type: ignore[untyped-decorator] + target=_validate_keypoints_fields, + deprecated_in="0.29.0", + remove_in="0.32.0", +) +def validate_key_points_fields( + xy: Any, class_id: Any, confidence: Any, data: dict[str, Any] +) -> None: + void(xy, class_id, confidence, data) + + +@deprecated( # type: ignore[untyped-decorator] + target=_validate_keypoints_fields, + deprecated_in="0.27.0", + remove_in="0.31.0", +) +def validate_keypoints_fields( + xy: Any, class_id: Any, confidence: Any, data: dict[str, Any] +) -> None: + void(xy, class_id, confidence, data) + + +def _validate_resolution(resolution: Any) -> tuple[int, int]: + if not (isinstance(resolution, tuple) and len(resolution) == 2): + raise ValueError( + f""" + resolution must be a tuple of two integers, got + {type(resolution)} with value {resolution} + """ + ) + w, h = resolution + if not (isinstance(w, int) and isinstance(h, int)): + raise ValueError( + f""" + Both elements in resolution must be integers. + Got types ({type(w)}, {type(h)}) + """ + ) + if w <= 0 or h <= 0: + raise ValueError( + f"Both dimensions in resolution must be positive. Got ({w}, {h})." + ) + return w, h + + +@deprecated( # type: ignore[untyped-decorator] + target=_validate_resolution, + deprecated_in="0.29.0", + remove_in="0.32.0", +) +def validate_resolution(resolution: Any) -> tuple[int, int]: + return void(resolution) # type: ignore[no-any-return] diff --git a/tests/__init__.py b/tests/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/tests/annotators/__init__.py b/tests/annotators/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/tests/annotators/test_core.py b/tests/annotators/test_core.py new file mode 100644 index 0000000..2ceb053 --- /dev/null +++ b/tests/annotators/test_core.py @@ -0,0 +1,1959 @@ +""" +Tests for supervision/annotators/core.py +""" + +import warnings +from collections.abc import Iterator +from typing import Any, cast + +import cv2 +import numpy as np +import pytest +from PIL import Image + +import supervision.annotators.core as annotators_core +from supervision.annotators.base import BaseAnnotator +from supervision.annotators.core import ( + BackgroundOverlayAnnotator, + BlurAnnotator, + BoxAnnotator, + BoxCornerAnnotator, + CircleAnnotator, + ColorAnnotator, + ComparisonAnnotator, + CropAnnotator, + DotAnnotator, + EllipseAnnotator, + HaloAnnotator, + HeatMapAnnotator, + IconAnnotator, + LabelAnnotator, + MaskAnnotator, + OrientedBoxAnnotator, + PercentageBarAnnotator, + PixelateAnnotator, + PolygonAnnotator, + RichLabelAnnotator, + RoundBoxAnnotator, + TraceAnnotator, + TriangleAnnotator, + _paint_masks_by_area, +) +from supervision.annotators.utils import ColorLookup +from supervision.detection.compact_mask import CompactMask +from supervision.detection.core import Detections +from supervision.draw.color import Color +from supervision.geometry.core import Position +from tests.helpers import _create_detections, assert_image_mostly_same + + +def _get_concrete_annotator_subclasses( + cls: type[BaseAnnotator], +) -> Iterator[type[BaseAnnotator]]: + """Recursively yield non-abstract BaseAnnotator subclasses.""" + for sub in cls.__subclasses__(): + if not getattr(sub, "__abstractmethods__", None): + yield sub + yield from _get_concrete_annotator_subclasses(sub) + + +class TestAnnotatorMaskPolicy: + """Tests for annotator mask materialization policy metadata.""" + + @pytest.mark.parametrize( + "annotator", + [ + pytest.param(MaskAnnotator(), id="mask"), + pytest.param(PolygonAnnotator(), id="polygon"), + pytest.param(HaloAnnotator(), id="halo"), + ], + ) + def test_mask_required_annotators_declare_mask_requirement(self, annotator): + """Annotators that require detections.mask expose the requirement.""" + assert type(annotator).requires_mask is True + + @pytest.mark.parametrize( + "annotator", + [ + pytest.param(BoxAnnotator(), id="box"), + pytest.param(LabelAnnotator(), id="label"), + pytest.param(CircleAnnotator(), id="circle"), + pytest.param(EllipseAnnotator(), id="ellipse"), + pytest.param(IconAnnotator(), id="icon"), + pytest.param(TraceAnnotator(), id="trace"), + pytest.param(BackgroundOverlayAnnotator(), id="overlay"), + pytest.param(BackgroundOverlayAnnotator(force_box=True), id="overlay-box"), + pytest.param(ComparisonAnnotator(), id="comparison"), + ], + ) + def test_mask_optional_annotators_declare_no_mask_requirement(self, annotator): + """Mask-optional annotators do not require mask materialization.""" + assert type(annotator).requires_mask is False + + @pytest.mark.parametrize( + "annotator_class", + [ + pytest.param(cls, id=cls.__name__) + for cls in _get_concrete_annotator_subclasses(BaseAnnotator) + ], + ) + def test_all_subclasses_have_bool_requires_mask(self, annotator_class): + """Every concrete BaseAnnotator subclass declares requires_mask as a bool.""" + assert isinstance(annotator_class.requires_mask, bool) + + def test_exact_mask_requiring_annotator_set(self): + """Only MaskAnnotator, PolygonAnnotator, HaloAnnotator require masks.""" + mask_true = { + cls + for cls in _get_concrete_annotator_subclasses(BaseAnnotator) + if cls.requires_mask is True + } + assert mask_true == {MaskAnnotator, PolygonAnnotator, HaloAnnotator} + + +@pytest.fixture +def test_image() -> np.ndarray: + """Create a simple blank test image fixture""" + return np.zeros((100, 100, 3), dtype=np.uint8) + + +@pytest.fixture +def test_mask() -> np.ndarray: + """Create a simple rectangular mask fixture""" + mask = np.zeros((100, 100), dtype=bool) + mask[20:80, 20:80] = True + return mask + + +@pytest.fixture +def gradient_image() -> np.ndarray: + """Create a gradient test image fixture""" + image = np.zeros((100, 100, 3), dtype=np.uint8) + for i in range(100): + for j in range(100): + image[i, j] = [i, j, (i + j) // 2] + return image + + +@pytest.mark.parametrize( + ("factory", "expected_colors"), + [ + (lambda: BoxAnnotator(color="#010203"), {"color": (1, 2, 3)}), + (lambda: OrientedBoxAnnotator(color="#010203"), {"color": (1, 2, 3)}), + (lambda: MaskAnnotator(color="#010203"), {"color": (1, 2, 3)}), + (lambda: PolygonAnnotator(color="#010203"), {"color": (1, 2, 3)}), + (lambda: ColorAnnotator(color="#010203"), {"color": (1, 2, 3)}), + (lambda: HaloAnnotator(color="#010203"), {"color": (1, 2, 3)}), + (lambda: EllipseAnnotator(color="#010203"), {"color": (1, 2, 3)}), + (lambda: BoxCornerAnnotator(color="#010203"), {"color": (1, 2, 3)}), + (lambda: CircleAnnotator(color="#010203"), {"color": (1, 2, 3)}), + ( + lambda: DotAnnotator(color="#010203", outline_color="#040506"), + {"color": (1, 2, 3), "outline_color": (4, 5, 6)}, + ), + ( + lambda: LabelAnnotator(color="#010203", text_color="#040506"), + {"color": (1, 2, 3), "text_color": (4, 5, 6)}, + ), + ( + lambda: RichLabelAnnotator(color="#010203", text_color="#040506"), + {"color": (1, 2, 3), "text_color": (4, 5, 6)}, + ), + (lambda: TraceAnnotator(color="#010203"), {"color": (1, 2, 3)}), + ( + lambda: TriangleAnnotator(color="#010203", outline_color="#040506"), + {"color": (1, 2, 3), "outline_color": (4, 5, 6)}, + ), + (lambda: RoundBoxAnnotator(color="#010203"), {"color": (1, 2, 3)}), + ( + lambda: PercentageBarAnnotator(color="#010203", border_color="#040506"), + {"color": (1, 2, 3), "border_color": (4, 5, 6)}, + ), + (lambda: CropAnnotator(border_color="#010203"), {"border_color": (1, 2, 3)}), + ], +) +def test_hex_color_support_across_annotators( + factory, expected_colors: dict[str, tuple[int, int, int]] +) -> None: + annotator = factory() + for attribute_name, expected_rgb in expected_colors.items(): + color = getattr(annotator, attribute_name) + assert isinstance(color, Color) + assert color.as_rgb() == expected_rgb + + +class TestBoxAnnotator: + """ + Verify that BoxAnnotator correctly draws bounding boxes on an image. + + Ensures that `BoxAnnotator` correctly draws bounding boxes on an image, which is + essential for users to visualize detection results. + """ + + def test_annotate_with_no_detections(self, test_image: np.ndarray) -> None: + """ + Verify that annotation with no detections does not change the image. + + Scenario: Annotating an image with an empty set of detections. + Expected: The scene remains unchanged, ensuring no ghost boxes are drawn. + """ + detections = Detections.empty() + annotator = BoxAnnotator() + result = annotator.annotate(scene=test_image.copy(), detections=detections) + assert np.array_equal(test_image, result) + + def test_annotate_with_single_detection(self, test_image: np.ndarray) -> None: + """ + Verify that annotation with a single detection draws a bounding box. + + Scenario: Annotating an image with a single bounding box. + Expected: The scene is modified by drawing a box, allowing users to identify + a single detected object. + """ + detections = _create_detections(xyxy=[[10, 10, 90, 90]], class_id=[0]) + annotator = BoxAnnotator( + color=Color.WHITE, thickness=2, color_lookup=ColorLookup.INDEX + ) + result = annotator.annotate(scene=test_image.copy(), detections=detections) + assert_image_mostly_same(test_image, result, similarity_threshold=0.85) + + def test_annotate_with_multiple_detections(self, test_image: np.ndarray) -> None: + """ + Verify that annotation with multiple detections draws all bounding boxes. + + Scenario: Annotating an image with multiple bounding boxes of different classes. + Expected: All boxes are drawn, enabling visualization of complex scenes with + multiple objects. + """ + detections = _create_detections( + xyxy=[[10, 10, 40, 40], [60, 60, 90, 90], [10, 60, 40, 90]], + class_id=[0, 1, 2], + ) + annotator = BoxAnnotator( + color=Color.WHITE, thickness=2, color_lookup=ColorLookup.INDEX + ) + result = annotator.annotate(scene=test_image.copy(), detections=detections) + assert_image_mostly_same(test_image, result, similarity_threshold=0.85) + + def test_annotate_with_numpy_color_lookup(self, test_image: np.ndarray) -> None: + """ + Verify that annotation respects custom NumPy color lookup array. + + Scenario: Providing a custom NumPy array for color lookup instead of class IDs. + Expected: Annotator respects the custom mapping, giving users flexible control + over box colors (e.g., coloring by tracking ID or custom criteria). + """ + detections = Detections( + xyxy=np.array([[10, 10, 20, 20], [30, 30, 40, 40]], dtype=np.float32), + confidence=np.array([0.38, 0.21], dtype=np.float32), + class_id=np.array([0, 0], dtype=np.int64), + tracker_id=None, + ) + + lookup = np.array([1, 0], dtype=np.int16) + + annotator = BoxAnnotator( + color=Color.WHITE, thickness=2, color_lookup=ColorLookup.INDEX + ) + + result = annotator.annotate( + scene=test_image.copy(), + detections=detections, + custom_color_lookup=lookup, + ) + assert_image_mostly_same(test_image, result, similarity_threshold=0.85) + + +class TestOrientedBoxAnnotator: + """Tests for OrientedBoxAnnotator class""" + + def test_annotate_with_no_detections(self, test_image): + """Test that annotate method returns unmodified image when no detections""" + detections = Detections.empty() + annotator = OrientedBoxAnnotator() + result = annotator.annotate(scene=test_image.copy(), detections=detections) + assert np.array_equal(test_image, result) + + def test_annotate_without_oriented_boxes(self, test_image): + """Test that annotate method returns unmodified image when no OBB data""" + detections = _create_detections(xyxy=[[10, 10, 90, 90]]) + annotator = OrientedBoxAnnotator() + result = annotator.annotate(scene=test_image.copy(), detections=detections) + assert np.array_equal(test_image, result) + + +class TestMaskAnnotator: + """Tests for MaskAnnotator class""" + + def test_annotate_with_no_detections(self, test_image): + """Test that annotate method returns unmodified image when no detections""" + detections = Detections.empty() + annotator = MaskAnnotator() + result = annotator.annotate(scene=test_image.copy(), detections=detections) + assert np.array_equal(test_image, result) + + def test_annotate_without_masks(self, test_image): + """Test that annotate method returns unmodified image when no masks""" + detections = _create_detections(xyxy=[[10, 10, 90, 90]], class_id=[0]) + annotator = MaskAnnotator(color_lookup=ColorLookup.INDEX) + result = annotator.annotate(scene=test_image.copy(), detections=detections) + assert np.array_equal(test_image, result) + + def test_annotate_with_single_mask(self, test_image, test_mask): + """Test that annotate method correctly draws a single mask""" + detections = _create_detections( + xyxy=[[10, 10, 90, 90]], mask=[test_mask], class_id=[0] + ) + annotator = MaskAnnotator( + color=Color.RED, opacity=1.0, color_lookup=ColorLookup.INDEX + ) + result = annotator.annotate(scene=test_image.copy(), detections=detections) + assert_image_mostly_same(test_image, result, similarity_threshold=0.6) + + def test_annotate_uint8_mask_matches_bool_mask(self, test_image, test_mask): + """Test that uint8 and bool masks produce identical overlays.""" + detections_bool = _create_detections( + xyxy=[[10, 10, 90, 90]], mask=[test_mask], class_id=[0] + ) + detections_uint8 = _create_detections( + xyxy=[[10, 10, 90, 90]], mask=[test_mask], class_id=[0] + ) + detections_uint8.mask = detections_uint8.mask.astype(np.uint8) + + annotator = MaskAnnotator( + color=Color.RED, opacity=1.0, color_lookup=ColorLookup.INDEX + ) + result_bool = annotator.annotate( + scene=test_image.copy(), detections=detections_bool + ) + result_uint8 = annotator.annotate( + scene=test_image.copy(), detections=detections_uint8 + ) + assert np.array_equal(result_bool, result_uint8) + + def test_annotate_blends_only_dense_mask_roi(self, monkeypatch): + """Dense mask annotation should blend only the touched ROI.""" + height, width = 80, 90 + scene = np.random.default_rng(1).integers( + 0, 256, (height, width, 3), dtype=np.uint8 + ) + masks = np.zeros((2, height, width), dtype=bool) + masks[0, 10:20, 15:25] = True + masks[1, 45:55, 60:75] = True + # inclusive xyxy; floor(x2)+1 gives union ROI (15,10,75,55) โ†’ shape (45,60,3) + detections = _create_detections( + xyxy=[[15.0, 10.0, 24.0, 19.0], [60.0, 45.0, 74.0, 54.0]], + mask=masks, + class_id=[0, 1], + ) + original_add_weighted = cv2.addWeighted + blended_shapes = [] + + def add_weighted_spy(src1, alpha, src2, beta, gamma, dst=None, dtype=None): + blended_shapes.append(src1.shape) + return original_add_weighted(src1, alpha, src2, beta, gamma, dst, dtype) + + monkeypatch.setattr(cv2, "addWeighted", add_weighted_spy) + + result = MaskAnnotator( + opacity=0.5, color=Color.RED, color_lookup=ColorLookup.INDEX + ).annotate(scene=scene.copy(), detections=detections) + + assert not np.array_equal(result, scene) + assert blended_shapes == [(45, 60, 3)] + + def test_annotate_blends_only_compact_mask_roi(self, monkeypatch): + """CompactMask annotation should blend only the touched ROI.""" + height, width = 80, 90 + scene = np.random.default_rng(2).integers( + 0, 256, (height, width, 3), dtype=np.uint8 + ) + masks = np.zeros((2, height, width), dtype=bool) + masks[0, 10:20, 15:25] = True + masks[1, 45:55, 60:75] = True + xyxy = np.array([[15.0, 10.0, 24.0, 19.0], [60.0, 45.0, 74.0, 54.0]]) + detections = _create_detections(xyxy=xyxy.tolist(), mask=masks, class_id=[0, 1]) + detections.mask = CompactMask.from_dense( + masks, detections.xyxy, (height, width) + ) + original_add_weighted = cv2.addWeighted + blended_shapes = [] + + def add_weighted_spy(src1, alpha, src2, beta, gamma, dst=None, dtype=None): + blended_shapes.append(src1.shape) + return original_add_weighted(src1, alpha, src2, beta, gamma, dst, dtype) + + monkeypatch.setattr(cv2, "addWeighted", add_weighted_spy) + + result = MaskAnnotator(opacity=0.5, color_lookup=ColorLookup.INDEX).annotate( + scene=scene.copy(), detections=detections + ) + + assert not np.array_equal(result, scene) + assert blended_shapes == [(45, 60, 3)] + + def test_annotate_skips_all_false_mask_blend(self, monkeypatch): + """All-false masks must skip blending โ€” addWeighted must not be called.""" + height, width = 30, 40 + scene = np.random.default_rng(3).integers( + 0, 256, (height, width, 3), dtype=np.uint8 + ) + mask = np.zeros((height, width), dtype=bool) + detections = _create_detections( + xyxy=[[5.0, 5.0, 20.0, 20.0]], mask=[mask], class_id=[0] + ) + + call_count = [] + + def add_weighted_spy(src1, alpha, src2, beta, gamma, dst=None, dtype=None): + call_count.append(1) + return src2 + + monkeypatch.setattr(cv2, "addWeighted", add_weighted_spy) + + result = MaskAnnotator( + opacity=0.5, color=Color.RED, color_lookup=ColorLookup.INDEX + ).annotate(scene=scene.copy(), detections=detections) + + assert np.array_equal(result, scene) + assert len(call_count) == 0, "addWeighted called for all-false masks" + + def test_annotate_pixels_outside_roi_unchanged(self): + """Pixels outside the blended ROI must be unchanged from the original scene.""" + height, width = 80, 90 + rng = np.random.default_rng(42) + scene = rng.integers(0, 256, (height, width, 3), dtype=np.uint8) + # Two masks in the top-left region โ€” ROI should be [10:55, 15:75] + masks = np.zeros((2, height, width), dtype=bool) + masks[0, 10:20, 15:25] = True + masks[1, 45:55, 60:75] = True + # inclusive xyxy; floor(x2)+1 gives ROI (15,10,75,55) + xyxy = np.array([[15.0, 10.0, 24.0, 19.0], [60.0, 45.0, 74.0, 54.0]]) + detections = _create_detections(xyxy=xyxy.tolist(), mask=masks, class_id=[0, 1]) + result = MaskAnnotator(opacity=0.5, color_lookup=ColorLookup.INDEX).annotate( + scene=scene.copy(), detections=detections + ) + # Pixels strictly below ROI row-bound (y2=55) must be unchanged + assert np.array_equal(result[55:, :], scene[55:, :]) + # Pixels strictly right of ROI col-bound (x2=75) must be unchanged + assert np.array_equal(result[:, 75:], scene[:, 75:]) + + def test_annotate_roi_parity_with_full_frame_blend(self): + """ROI blend must match reference blend within ยฑ1 (uint8 rounding).""" + height, width = 60, 80 + rng = np.random.default_rng(99) + scene = rng.integers(0, 256, (height, width, 3), dtype=np.uint8) + opacity = 0.5 + # Single mask in bottom-right quadrant + masks = np.zeros((1, height, width), dtype=bool) + masks[0, 40:55, 50:70] = True + # inclusive xyxy; floor(x2)+1 gives ROI scene[40:55, 50:70] + xyxy = np.array([[50.0, 40.0, 69.0, 54.0]]) + detections = _create_detections(xyxy=xyxy.tolist(), mask=masks, class_id=[0]) + + # ROI-only result (new optimized behavior) + result_roi = MaskAnnotator( + opacity=opacity, color=Color.RED, color_lookup=ColorLookup.INDEX + ).annotate(scene=scene.copy(), detections=detections) + + # Reference: manually compute expected blend for masked pixels only + # RED in BGR = (0, 0, 255); blend = opacity*color + (1-opacity)*scene + roi_mask = masks[0] + colored = scene.copy() + colored[roi_mask] = (0, 0, 255) # BGR RED + ref_blend = np.clip( + opacity * colored.astype(np.float32) + + (1 - opacity) * scene.astype(np.float32), + 0, + 255, + ).astype(np.uint8) + + # Masked pixels must match reference within ยฑ1 (uint8 rounding) + diff = np.abs( + result_roi[roi_mask].astype(np.int16) - ref_blend[roi_mask].astype(np.int16) + ) + assert np.all(diff <= 1), f"Max pixel diff: {diff.max()}" + + +class TestPolygonAnnotator: + """Tests for PolygonAnnotator class""" + + def test_annotate_with_no_detections(self, test_image): + """Test that annotate method returns unmodified image when no detections""" + detections = Detections.empty() + annotator = PolygonAnnotator() + result = annotator.annotate(scene=test_image.copy(), detections=detections) + assert np.array_equal(test_image, result) + + def test_annotate_without_masks(self, test_image): + """Test that annotate method returns unmodified image when no masks""" + detections = _create_detections(xyxy=[[10, 10, 90, 90]], class_id=[0]) + annotator = PolygonAnnotator(color_lookup=ColorLookup.INDEX) + result = annotator.annotate(scene=test_image.copy(), detections=detections) + assert np.array_equal(test_image, result) + + def test_annotate_with_single_mask(self, test_image, test_mask): + """Test that annotate method correctly draws a single polygon from mask""" + detections = _create_detections( + xyxy=[[10, 10, 90, 90]], mask=[test_mask], class_id=[0] + ) + annotator = PolygonAnnotator( + color=Color.WHITE, thickness=2, color_lookup=ColorLookup.INDEX + ) + result = annotator.annotate(scene=test_image.copy(), detections=detections) + assert_image_mostly_same(test_image, result, similarity_threshold=0.85) + + def test_compact_mask_uses_crops_and_matches_dense_mask(self, monkeypatch): + """CompactMask polygons use crops without full-frame mask indexing.""" + height, width = 80, 90 + scene = np.zeros((height, width, 3), dtype=np.uint8) + masks = np.zeros((3, height, width), dtype=bool) + masks[0, 10:20, 15:30] = True + masks[0, 32:45, 40:55] = True + masks[1] = False + masks[2, 50:70, 5:25] = True + xyxy = np.array( + [[15, 10, 54, 44], [60, 5, 70, 15], [5, 50, 24, 69]], + dtype=np.float32, + ) + dense = Detections(xyxy=xyxy, mask=masks, class_id=np.array([0, 1, 2])) + compact = Detections( + xyxy=xyxy, + mask=CompactMask.from_dense(masks, xyxy, (height, width)), + class_id=np.array([0, 1, 2]), + ) + annotator = PolygonAnnotator( + color=Color.WHITE, thickness=1, color_lookup=ColorLookup.INDEX + ) + expected = annotator.annotate(scene=scene.copy(), detections=dense) + + original_getitem = CompactMask.__getitem__ + + def fail_int_index(self, index): + if isinstance(index, (int, np.integer)): + raise AssertionError("PolygonAnnotator must use CompactMask.crop") + return original_getitem(self, index) + + def fail_to_dense(self): + raise AssertionError("PolygonAnnotator must not call CompactMask.to_dense") + + monkeypatch.setattr(CompactMask, "__getitem__", fail_int_index) + monkeypatch.setattr(CompactMask, "to_dense", fail_to_dense) + result = annotator.annotate(scene=scene.copy(), detections=compact) + + assert not np.array_equal(result, scene), "annotator painted nothing" + np.testing.assert_array_equal(result, expected) + + def test_annotate_with_empty_compact_mask(self): + """N=0 CompactMask returns scene unchanged without error.""" + height, width = 60, 80 + scene = np.zeros((height, width, 3), dtype=np.uint8) + empty_masks = np.zeros((0, height, width), dtype=bool) + xyxy = np.zeros((0, 4), dtype=np.float32) + detections = Detections( + xyxy=xyxy, + mask=CompactMask.from_dense(empty_masks, xyxy, (height, width)), + class_id=np.array([], dtype=int), + ) + annotator = PolygonAnnotator(color=Color.WHITE, color_lookup=ColorLookup.INDEX) + result = annotator.annotate(scene=scene.copy(), detections=detections) + np.testing.assert_array_equal(result, scene) + + def test_annotate_with_all_false_compact_mask_unchanged(self): + """All-False CompactMask crop (no contours) leaves scene pixels unchanged. + + A detection whose mask is entirely False produces no polygons; the + annotator must not paint any pixels for that detection. + """ + height, width = 60, 80 + scene = np.zeros((height, width, 3), dtype=np.uint8) + masks = np.zeros((1, height, width), dtype=bool) + xyxy = np.array([[10.0, 10.0, 50.0, 50.0]], dtype=np.float32) + detections = Detections( + xyxy=xyxy, + mask=CompactMask.from_dense(masks, xyxy, (height, width)), + class_id=np.array([0]), + ) + annotator = PolygonAnnotator(color=Color.WHITE, color_lookup=ColorLookup.INDEX) + result = annotator.annotate(scene=scene.copy(), detections=detections) + np.testing.assert_array_equal(result, scene) + + def test_annotate_with_single_compact_mask_detection(self): + """N=1 CompactMask detection annotates the same as dense mask.""" + height, width = 60, 80 + scene = np.zeros((height, width, 3), dtype=np.uint8) + mask = np.zeros((height, width), dtype=bool) + mask[20:40, 15:55] = True + xyxy = np.array([[15.0, 20.0, 54.0, 39.0]], dtype=np.float32) + dense = Detections(xyxy=xyxy, mask=np.array([mask]), class_id=np.array([0])) + compact = Detections( + xyxy=xyxy, + mask=CompactMask.from_dense(np.array([mask]), xyxy, (height, width)), + class_id=np.array([0]), + ) + annotator = PolygonAnnotator( + color=Color.WHITE, thickness=1, color_lookup=ColorLookup.INDEX + ) + expected = annotator.annotate(scene=scene.copy(), detections=dense) + result = annotator.annotate(scene=scene.copy(), detections=compact) + np.testing.assert_array_equal(result, expected) + + def test_annotate_compact_mask_float_xyxy_truncation(self): + """Float xyxy with sub-pixel values are truncated to int before crop decode. + + CompactMask stores bbox origins as int32 (via truncation); PolygonAnnotator + must produce the same output whether xyxy is integral or has fractional parts. + """ + height, width = 60, 80 + scene = np.zeros((height, width, 3), dtype=np.uint8) + mask = np.zeros((height, width), dtype=bool) + mask[10:30, 5:45] = True + xyxy_int = np.array([[5.0, 10.0, 44.0, 29.0]], dtype=np.float32) + xyxy_float = np.array([[5.7, 10.9, 44.3, 29.1]], dtype=np.float32) + compact_int = Detections( + xyxy=xyxy_int, + mask=CompactMask.from_dense(np.array([mask]), xyxy_int, (height, width)), + class_id=np.array([0]), + ) + compact_float = Detections( + xyxy=xyxy_float, + mask=CompactMask.from_dense(np.array([mask]), xyxy_float, (height, width)), + class_id=np.array([0]), + ) + annotator = PolygonAnnotator( + color=Color.WHITE, thickness=1, color_lookup=ColorLookup.INDEX + ) + result_int = annotator.annotate(scene=scene.copy(), detections=compact_int) + result_float = annotator.annotate(scene=scene.copy(), detections=compact_float) + np.testing.assert_array_equal(result_int, result_float) + + def test_compact_mask_disjoint_contours_offset_correct(self): + """Disjoint-contour mask: both polygon blobs translate to correct image coords. + + Verifies coordinate-level correctness of cropโ†’image offset for a mask + with two separate blobs. After annotation, boundary pixels of each blob + must be painted; pixels between the blobs must remain unpainted. + """ + height, width = 80, 90 + scene = np.zeros((height, width, 3), dtype=np.uint8) + mask = np.zeros((height, width), dtype=bool) + mask[10:20, 15:30] = True + mask[32:45, 40:55] = True + xyxy = np.array([[15.0, 10.0, 54.0, 44.0]], dtype=np.float32) + detections = Detections( + xyxy=xyxy, + mask=CompactMask.from_dense(np.array([mask]), xyxy, (height, width)), + class_id=np.array([0]), + ) + annotator = PolygonAnnotator( + color=Color.WHITE, thickness=1, color_lookup=ColorLookup.INDEX + ) + result = annotator.annotate(scene=scene.copy(), detections=detections) + + # Boundary of blob 1 in image space โ€” must be painted + assert np.any(result[10:20, 15:30] != 0), "blob 1 boundary not painted" + # Boundary of blob 2 in image space โ€” must be painted + assert np.any(result[32:45, 40:55] != 0), "blob 2 boundary not painted" + # Gap between blobs โ€” no polygon pixels expected here + assert np.all(result[21:31, :] == 0), "gap between blobs has stray pixels" + + +class TestColorAnnotator: + """Tests for ColorAnnotator class""" + + def test_annotate_with_no_detections(self, test_image): + """Test that annotate method returns unmodified image when no detections""" + detections = Detections.empty() + annotator = ColorAnnotator() + result = annotator.annotate(scene=test_image.copy(), detections=detections) + assert np.array_equal(test_image, result) + + def test_annotate_with_single_detection(self, test_image): + """Test that annotate method correctly draws a single color box""" + detections = _create_detections(xyxy=[[10, 10, 90, 90]], class_id=[0]) + annotator = ColorAnnotator( + color=Color.RED, opacity=1.0, color_lookup=ColorLookup.INDEX + ) + result = annotator.annotate(scene=test_image.copy(), detections=detections) + assert_image_mostly_same(test_image, result, similarity_threshold=0.3) + + +class TestHaloAnnotator: + """Tests for HaloAnnotator class""" + + def test_annotate_with_no_detections(self, test_image): + """Test that annotate method returns unmodified image when no detections""" + detections = Detections.empty() + annotator = HaloAnnotator() + result = annotator.annotate(scene=test_image.copy(), detections=detections) + assert np.array_equal(test_image, result) + + def test_annotate_without_masks(self, test_image): + """Test that annotate method returns unmodified image when no masks""" + detections = _create_detections(xyxy=[[10, 10, 90, 90]], class_id=[0]) + annotator = HaloAnnotator(color_lookup=ColorLookup.INDEX) + result = annotator.annotate(scene=test_image.copy(), detections=detections) + assert np.array_equal(test_image, result) + + def test_annotate_with_single_mask(self, test_image, test_mask): + """Test that annotate method correctly draws a single halo""" + detections = _create_detections( + xyxy=[[10, 10, 90, 90]], mask=[test_mask], class_id=[0] + ) + annotator = HaloAnnotator( + color=Color.BLUE, + opacity=0.8, + kernel_size=10, + color_lookup=ColorLookup.INDEX, + ) + result = annotator.annotate(scene=test_image.copy(), detections=detections) + assert_image_mostly_same(test_image, result, similarity_threshold=0.85) + + def test_annotate_uint8_mask_matches_bool_mask(self, test_image, test_mask): + """Test that uint8 and bool masks produce identical halos.""" + detections_bool = _create_detections( + xyxy=[[10, 10, 90, 90]], mask=[test_mask], class_id=[0] + ) + detections_uint8 = _create_detections( + xyxy=[[10, 10, 90, 90]], mask=[test_mask], class_id=[0] + ) + detections_uint8.mask = detections_uint8.mask.astype(np.uint8) + + annotator = HaloAnnotator( + color=Color.BLUE, + opacity=0.8, + kernel_size=10, + color_lookup=ColorLookup.INDEX, + ) + result_bool = annotator.annotate( + scene=test_image.copy(), detections=detections_bool + ) + result_uint8 = annotator.annotate( + scene=test_image.copy(), detections=detections_uint8 + ) + assert np.array_equal(result_bool, result_uint8) + + def test_annotate_with_all_false_mask_preserves_scene(self): + """Test that an all-False mask leaves the scene unchanged, not corrupted.""" + scene = np.full((100, 100, 3), 127, dtype=np.uint8) + masks = [np.zeros((100, 100), dtype=bool)] + detections = _create_detections( + xyxy=[[10, 10, 90, 90]], mask=masks, class_id=[0] + ) + result = HaloAnnotator().annotate(scene=scene.copy(), detections=detections) + assert np.array_equal(result, scene) + + +class TestPaintMasksByArea: + """Tests for the _paint_masks_by_area helper function.""" + + def test_paint_masks_by_area_is_noop_without_masks(self): + """_paint_masks_by_area is a no-op when detections carry no mask.""" + canvas = np.full((10, 10, 3), 7, dtype=np.uint8) + detections = _create_detections(xyxy=[[1, 1, 8, 8]], class_id=[0]) + _paint_masks_by_area(canvas, detections, Color.RED, ColorLookup.INDEX) + assert np.array_equal(canvas, np.full((10, 10, 3), 7, dtype=np.uint8)) + + def test_union_accumulation_dense(self): + """Dense path: collect_union=True returns array covering all painted pixels.""" + height, width = 50, 60 + canvas = np.zeros((height, width, 3), dtype=np.uint8) + masks = [np.zeros((height, width), dtype=bool)] + masks[0][5:20, 10:40] = True + detections = _create_detections( + xyxy=[[10.0, 5.0, 40.0, 20.0]], mask=masks, class_id=[0] + ) + result_union = _paint_masks_by_area( + canvas, detections, Color.RED, ColorLookup.INDEX, collect_union=True + ) + assert result_union is not None + # every painted pixel must be in the union (RED is BGR (0, 0, 255), + # so detect painted pixels via any non-zero channel) + painted = canvas.any(axis=-1) + assert np.array_equal(painted, result_union) + + def test_union_accumulation_compact(self): + """CompactMask path: collect_union=True returns array matching dense.""" + height, width = 50, 60 + mask = np.zeros((height, width), dtype=bool) + mask[5:20, 10:40] = True + xyxy = np.array([[10.0, 5.0, 40.0, 20.0]]) + + canvas_dense = np.zeros((height, width, 3), dtype=np.uint8) + dense = _create_detections(xyxy=xyxy.tolist(), mask=[mask], class_id=[0]) + union_dense = _paint_masks_by_area( + canvas_dense, dense, Color.RED, ColorLookup.INDEX, collect_union=True + ) + + canvas_compact = np.zeros((height, width, 3), dtype=np.uint8) + compact = _create_detections(xyxy=xyxy.tolist(), mask=[mask], class_id=[0]) + compact.mask = CompactMask.from_dense( + np.array([mask]), compact.xyxy, (height, width) + ) + union_compact = _paint_masks_by_area( + canvas_compact, compact, Color.RED, ColorLookup.INDEX, collect_union=True + ) + + assert union_dense is not None + assert union_compact is not None + # compact union must cover exactly the same pixels as dense union + assert np.array_equal(union_dense, union_compact) + + def test_compact_mask_drops_pixels_outside_bbox(self): + """CompactMask is lossy: True pixels outside xyxy bbox are silently dropped. + + This test documents that compact and dense paths diverge when a mask has + True pixels outside its bounding box โ€” the 'bit-identical' claim holds + only for bbox-contained masks. + """ + height, width = 50, 60 + mask = np.zeros((height, width), dtype=bool) + mask[5:25, 10:40] = True # mask extends 5 rows beyond bbox bottom + + bbox = [[10.0, 5.0, 40.0, 20.0]] # y2=20 clips the mask at row 20 + + canvas_dense = np.zeros((height, width, 3), dtype=np.uint8) + dense = _create_detections(xyxy=bbox, mask=[mask], class_id=[0]) + _paint_masks_by_area(canvas_dense, dense, Color.RED, ColorLookup.INDEX) + + canvas_compact = np.zeros((height, width, 3), dtype=np.uint8) + compact = _create_detections(xyxy=bbox, mask=[mask], class_id=[0]) + compact.mask = CompactMask.from_dense( + np.array([mask]), compact.xyxy, (height, width) + ) + _paint_masks_by_area(canvas_compact, compact, Color.RED, ColorLookup.INDEX) + + # Dense paints all True pixels incl. rows 21-24; compact only within bbox. + assert not np.array_equal(canvas_dense, canvas_compact), ( + "Expected divergence: compact mask drops True pixels outside bbox" + ) + # Compact subset: every pixel painted by compact is also painted by dense. + compact_painted = canvas_compact.any(axis=-1) + dense_painted = canvas_dense.any(axis=-1) + assert np.all(dense_painted[compact_painted]) + + def test_canvas_origin_nonzero_paints_at_correct_position(self): + """Non-zero canvas_origin should offset mask coordinates into canvas.""" + height, width = 30, 40 + # Subcanvas covering region [10:25, 15:30] of the full image (15x15 px). + canvas = np.zeros((15, 15, 3), dtype=np.uint8) + # Mask in full-image coords: True at rows 12:18, cols 17:22. + # In canvas coords (origin=(15, 10)): rows 2:8, cols 2:7. + full_mask = np.zeros((height, width), dtype=bool) + full_mask[12:18, 17:22] = True + detections = Detections( + xyxy=np.array([[17.0, 12.0, 21.0, 17.0]]), + mask=full_mask[np.newaxis], + class_id=np.array([0]), + ) + _paint_masks_by_area( + canvas, + detections, + Color.RED, + ColorLookup.INDEX, + canvas_origin=(15, 10), + ) + # Pixels inside the mapped region should be BGR red (0, 0, 255) + assert np.all(canvas[2:8, 2:7] == (0, 0, 255)) + # Pixels outside the painted region must remain zero + assert canvas[0, 0].tolist() == [0, 0, 0] + + +class TestCompactMaskParity: + """Tests that CompactMask and dense mask produce identical annotator output.""" + + @pytest.mark.parametrize( + "annotator_factory", + [ + pytest.param( + lambda: MaskAnnotator(opacity=1.0, color_lookup=ColorLookup.INDEX), + id="mask", + ), + pytest.param( + lambda: PolygonAnnotator( + color=Color.WHITE, thickness=1, color_lookup=ColorLookup.INDEX + ), + id="polygon", + ), + pytest.param( + lambda: HaloAnnotator(kernel_size=15, color_lookup=ColorLookup.INDEX), + id="halo", + ), + ], + ) + def test_annotator_compact_mask_matches_dense_mask(self, annotator_factory): + """CompactMask detections annotate identically to dense bool masks.""" + height, width = 120, 160 + rng = np.random.default_rng(0) + scene = rng.integers(0, 256, (height, width, 3), dtype=np.uint8) + boxes = [[10, 10, 70, 60], [40, 30, 150, 110], [90, 70, 140, 115]] + masks = [] + for x1, y1, x2, y2 in boxes: + mask = np.zeros((height, width), dtype=bool) + mask[y1 : y2 + 1, x1 : x2 + 1] = True + masks.append(mask) + class_id = [0, 1, 2] + xyxy = [[float(value) for value in box] for box in boxes] + + dense = _create_detections(xyxy=xyxy, mask=masks, class_id=class_id) + compact = _create_detections(xyxy=xyxy, mask=masks, class_id=class_id) + compact.mask = CompactMask.from_dense( + np.array(masks), compact.xyxy, (height, width) + ) + + result_dense = annotator_factory().annotate( + scene=scene.copy(), detections=dense + ) + result_compact = annotator_factory().annotate( + scene=scene.copy(), detections=compact + ) + + assert not np.array_equal(result_dense, scene), "annotator painted nothing" + assert np.array_equal(result_dense, result_compact) + + def test_annotator_compact_mask_handles_edge_clipping(self): + """CompactMask detection straddling image edge paints via NumPy clip.""" + height, width = 50, 60 + rng = np.random.default_rng(42) + scene = rng.integers(0, 256, (height, width, 3), dtype=np.uint8) + + # Box extends 10 pixels beyond right/bottom edges + mask = np.zeros((height, width), dtype=bool) + mask[40:height, 50:width] = True + bbox = [[50.0, 40.0, width + 10.0, height + 10.0]] + + detections = _create_detections(xyxy=bbox, mask=[mask], class_id=[0]) + detections.mask = CompactMask.from_dense( + np.array([mask]), detections.xyxy, (height, width) + ) + + annotator = MaskAnnotator(opacity=1.0, color_lookup=ColorLookup.INDEX) + result = annotator.annotate(scene=scene.copy(), detections=detections) + # Result must differ from scene (something was painted) and must not raise + assert not np.array_equal(result, scene), "Expected pixels to be painted" + + +class TestHeatMapAnnotator: + """Tests for HeatMapAnnotator class""" + + def test_annotate_with_no_detections_does_not_warn( + self, test_image: np.ndarray + ) -> None: + """Empty detections must not trigger a divide-by-zero RuntimeWarning.""" + detections = Detections.empty() + annotator = HeatMapAnnotator() + with warnings.catch_warnings(): + warnings.simplefilter("error", RuntimeWarning) + result = annotator.annotate(scene=test_image.copy(), detections=detections) + assert np.array_equal(test_image, result) + + def test_annotate_with_single_detection(self, test_image: np.ndarray) -> None: + """Single detection must produce visible heat โ€” result differs from input.""" + annotator = HeatMapAnnotator() + detections = _create_detections(xyxy=[[20, 20, 60, 60]]) + result = annotator.annotate(scene=test_image.copy(), detections=detections) + assert not np.array_equal(test_image, result) + + def test_annotate_state_preserved_after_empty_call( + self, test_image: np.ndarray + ) -> None: + """Empty call must not poison accumulated heat.""" + annotator = HeatMapAnnotator() + detections = _create_detections(xyxy=[[20, 20, 60, 60]]) + annotator.annotate(scene=test_image.copy(), detections=Detections.empty()) + result = annotator.annotate(scene=test_image.copy(), detections=detections) + assert not np.array_equal(test_image, result) + + def test_annotate_empty_after_real_does_not_warn( + self, test_image: np.ndarray + ) -> None: + """Empty call after heat accumulated must not trigger RuntimeWarning.""" + annotator = HeatMapAnnotator() + detections = _create_detections(xyxy=[[20, 20, 60, 60]]) + annotator.annotate(scene=test_image.copy(), detections=detections) + with warnings.catch_warnings(): + warnings.simplefilter("error", RuntimeWarning) + annotator.annotate(scene=test_image.copy(), detections=Detections.empty()) + + def test_annotate_resets_when_resolution_changes(self) -> None: + """Changing frame resolution must reset heat state instead of crashing.""" + annotator = HeatMapAnnotator() + detections = _create_detections(xyxy=[[20, 20, 60, 60]]) + first_scene = np.zeros((100, 100, 3), dtype=np.uint8) + second_scene = np.zeros((120, 80, 3), dtype=np.uint8) + + annotator.annotate(scene=first_scene.copy(), detections=detections) + result = annotator.annotate(scene=second_scene.copy(), detections=detections) + + assert result.shape == second_scene.shape + assert annotator.heat_mask is not None + assert annotator.heat_mask.shape == second_scene.shape[:2] + + def test_annotate_hottest_region_survives_uint8_wrap( + self, test_image: np.ndarray + ) -> None: + """Heat count at 2^8=256 must not wrap uint8 to zero and blank the region.""" + annotator = HeatMapAnnotator() + detections = _create_detections(xyxy=[[20, 20, 60, 60]]) + for _ in range(256): + result = annotator.annotate(scene=test_image.copy(), detections=detections) + region_painted = np.count_nonzero( + np.any(result[20:60, 20:60] != test_image[20:60, 20:60], axis=2) + ) + assert region_painted > 100 + + def test_reset_clears_accumulated_heat(self, test_image: np.ndarray) -> None: + """reset() must zero accumulation so a reused annotator matches a fresh one. + + The heatmap colours each pixel by its heat *relative to the current + maximum*, so a single uniformly-painted region always renders identically + regardless of its absolute count. To make the assertion actually depend on + reset having zeroed the buffer, heat is first built up on region A alone, + then after reset both region A and a fresh region B are annotated together. + If reset truly zeroed the buffer, A and B carry equal heat and the frame + matches a never-used annotator; if reset were a no-op, A's carried-over + count would dominate the max-normalisation and B would render a different + hue โ€” so byte-equality with the fresh annotator can only hold when the + accumulation was genuinely discarded. + """ + region_a = _create_detections(xyxy=[[10, 10, 30, 30]]) + region_a_and_b = _create_detections(xyxy=[[10, 10, 30, 30], [60, 60, 90, 90]]) + reused = HeatMapAnnotator() + for _ in range(5): + reused.annotate(scene=test_image.copy(), detections=region_a) + reused.reset() + reused_result = reused.annotate( + scene=test_image.copy(), detections=region_a_and_b + ) + + fresh = HeatMapAnnotator() + fresh_result = fresh.annotate( + scene=test_image.copy(), detections=region_a_and_b + ) + + assert np.array_equal(reused_result, fresh_result) + + +class TestEllipseAnnotator: + """Tests for EllipseAnnotator class""" + + def test_annotate_with_no_detections(self, test_image): + """Test that annotate method returns unmodified image when no detections""" + detections = Detections.empty() + annotator = EllipseAnnotator() + result = annotator.annotate(scene=test_image.copy(), detections=detections) + assert np.array_equal(test_image, result) + + def test_annotate_with_single_detection(self, test_image): + """Test that annotate method correctly draws a single ellipse""" + detections = _create_detections(xyxy=[[10, 10, 90, 90]], class_id=[0]) + annotator = EllipseAnnotator( + color=Color.YELLOW, thickness=2, color_lookup=ColorLookup.INDEX + ) + result = annotator.annotate(scene=test_image.copy(), detections=detections) + assert_image_mostly_same(test_image, result, similarity_threshold=0.95) + + +class TestBoxCornerAnnotator: + """Tests for BoxCornerAnnotator class""" + + def test_annotate_with_no_detections(self, test_image): + """Test that annotate method returns unmodified image when no detections""" + detections = Detections.empty() + annotator = BoxCornerAnnotator() + result = annotator.annotate(scene=test_image.copy(), detections=detections) + assert np.array_equal(test_image, result) + + def test_annotate_with_single_detection(self, test_image): + """Test that annotate method correctly draws box corners""" + detections = _create_detections(xyxy=[[10, 10, 90, 90]], class_id=[0]) + annotator = BoxCornerAnnotator( + color=Color.WHITE, + thickness=3, + corner_length=10, + color_lookup=ColorLookup.INDEX, + ) + result = annotator.annotate(scene=test_image.copy(), detections=detections) + assert_image_mostly_same(test_image, result, similarity_threshold=0.95) + + +class TestCircleAnnotator: + """Tests for CircleAnnotator class""" + + def test_annotate_with_no_detections(self, test_image): + """Test that annotate method returns unmodified image when no detections""" + detections = Detections.empty() + annotator = CircleAnnotator() + result = annotator.annotate(scene=test_image.copy(), detections=detections) + assert np.array_equal(test_image, result) + + def test_annotate_with_single_detection(self, test_image): + """Test that annotate method correctly draws a circle""" + detections = _create_detections(xyxy=[[10, 10, 90, 90]], class_id=[0]) + annotator = CircleAnnotator( + color=Color.GREEN, thickness=2, color_lookup=ColorLookup.INDEX + ) + result = annotator.annotate(scene=test_image.copy(), detections=detections) + assert_image_mostly_same(test_image, result, similarity_threshold=0.95) + + +class TestDotAnnotator: + """Tests for DotAnnotator class""" + + def test_annotate_with_no_detections(self, test_image): + """Test that annotate method returns unmodified image when no detections""" + detections = Detections.empty() + annotator = DotAnnotator() + result = annotator.annotate(scene=test_image.copy(), detections=detections) + assert np.array_equal(test_image, result) + + def test_annotate_with_single_detection(self, test_image): + """Test that annotate method correctly draws a dot""" + detections = _create_detections(xyxy=[[10, 10, 90, 90]], class_id=[0]) + annotator = DotAnnotator( + color=Color.RED, + radius=5, + position=Position.CENTER, + color_lookup=ColorLookup.INDEX, + ) + result = annotator.annotate(scene=test_image.copy(), detections=detections) + assert_image_mostly_same(test_image, result, similarity_threshold=0.95) + + +class TestLabelAnnotator: + """Tests for LabelAnnotator class""" + + @pytest.mark.parametrize( + "border_radius", + [ + pytest.param(0, id="radius-zero"), + pytest.param(-3, id="radius-negative"), + ], + ) + def test_draw_rounded_rectangle_square_matches_plain_rectangle( + self, border_radius: int + ) -> None: + """Non-positive radius fills the same pixels as a plain rectangle. + + For border_radius < 0: previously raised cv2.error: radius >= 0 in + function 'circle'; fast path now silently draws square corners instead. + """ + scene = np.full((100, 120, 3), 9, dtype=np.uint8) + + result = LabelAnnotator.draw_rounded_rectangle( + scene=scene.copy(), + xyxy=(10, 20, 90, 70), + color=(0, 0, 255), + border_radius=border_radius, + ) + + expected = scene.copy() + expected[20:71, 10:91] = (0, 0, 255) + assert np.array_equal(result, expected) + + def test_draw_rounded_rectangle_clamped_to_zero_acts_as_square(self) -> None: + """Positive border_radius clamped to 0 by a degenerate box draws square corners. + + 1px-wide box: min(10, 1 // 2) = min(10, 0) = 0 โ†’ fast path fires even + though the caller passed a positive radius. + """ + scene = np.full((100, 120, 3), 9, dtype=np.uint8) + + result = LabelAnnotator.draw_rounded_rectangle( + scene=scene.copy(), + xyxy=(10, 20, 11, 70), + color=(0, 0, 255), + border_radius=10, + ) + + expected = scene.copy() + expected[20:71, 10:12] = (0, 0, 255) + assert np.array_equal(result, expected) + + def test_annotate_with_no_detections(self, test_image): + """Test that annotate method returns unmodified image when no detections""" + detections = Detections.empty() + annotator = LabelAnnotator() + result = annotator.annotate(scene=test_image.copy(), detections=detections) + assert np.array_equal(test_image, result) + + def test_annotate_with_single_detection(self, test_image): + """Test that annotate method correctly draws a label""" + detections = _create_detections(xyxy=[[10, 10, 90, 90]], class_id=[0]) + annotator = LabelAnnotator(color_lookup=ColorLookup.INDEX) + result = annotator.annotate( + scene=test_image.copy(), detections=detections, labels=["test"] + ) + assert_image_mostly_same(test_image, result, similarity_threshold=0.93) + + def test_smart_position_spreads_boxes_once( + self, monkeypatch: pytest.MonkeyPatch, test_image: np.ndarray + ) -> None: + """smart_position should spread labels once per annotate call.""" + calls = 0 + original_spread_out_boxes = annotators_core.spread_out_boxes + + def counting_spread_out_boxes( + boxes: np.ndarray, *args: object, **kwargs: object + ) -> np.ndarray: + nonlocal calls + calls += 1 + return original_spread_out_boxes(boxes, *args, **kwargs) + + monkeypatch.setattr( + annotators_core, "spread_out_boxes", counting_spread_out_boxes + ) + + detections = _create_detections( + xyxy=[[10, 10, 90, 90], [15, 15, 85, 85]], class_id=[0, 1] + ) + annotator = LabelAnnotator(color_lookup=ColorLookup.INDEX, smart_position=True) + + annotator.annotate( + scene=test_image.copy(), detections=detections, labels=["one", "two"] + ) + + assert calls == 1 + + +class TestRichLabelAnnotator: + """Tests for RichLabelAnnotator class""" + + def test_annotate_with_no_detections(self, test_image): + """Test that annotate method returns unmodified image when no detections""" + detections = Detections.empty() + annotator = RichLabelAnnotator() + result = annotator.annotate(scene=test_image.copy(), detections=detections) + assert np.array_equal(test_image, result) + + def test_annotate_with_single_detection(self, test_image): + """Test that annotate method correctly draws a rich label""" + detections = _create_detections(xyxy=[[10, 10, 90, 90]], class_id=[0]) + annotator = RichLabelAnnotator(color_lookup=ColorLookup.INDEX) + result = annotator.annotate( + scene=test_image.copy(), detections=detections, labels=["test"] + ) + assert_image_mostly_same(test_image, result, similarity_threshold=0.95) + + def test_smart_position_spreads_boxes_once( + self, monkeypatch: pytest.MonkeyPatch, test_image: np.ndarray + ) -> None: + """smart_position should spread rich labels once per annotate call.""" + calls = 0 + original_spread_out_boxes = annotators_core.spread_out_boxes + + def counting_spread_out_boxes( + boxes: np.ndarray, *args: object, **kwargs: object + ) -> np.ndarray: + nonlocal calls + calls += 1 + return original_spread_out_boxes(boxes, *args, **kwargs) + + monkeypatch.setattr( + annotators_core, "spread_out_boxes", counting_spread_out_boxes + ) + + detections = _create_detections( + xyxy=[[10, 10, 90, 90], [15, 15, 85, 85]], class_id=[0, 1] + ) + annotator = RichLabelAnnotator( + color_lookup=ColorLookup.INDEX, smart_position=True + ) + + annotator.annotate( + scene=Image.fromarray(test_image.copy()), + detections=detections, + labels=["one", "two"], + ) + + assert calls == 1 + + +class TestBlurAnnotator: + """Tests for BlurAnnotator class""" + + def test_annotate_with_no_detections(self, test_image): + """Test that annotate method returns unmodified image when no detections""" + detections = Detections.empty() + annotator = BlurAnnotator() + result = annotator.annotate(scene=test_image.copy(), detections=detections) + assert np.array_equal(test_image, result) + + def test_annotate_with_single_detection(self, gradient_image): + """Test that annotate method correctly blurs a region""" + detections = _create_detections(xyxy=[[10, 10, 90, 90]], class_id=[0]) + annotator = BlurAnnotator(kernel_size=15) + result = annotator.annotate(scene=gradient_image.copy(), detections=detections) + assert not np.array_equal(gradient_image, result) + + @pytest.mark.parametrize("bad_size", [0, -1, -10]) + def test_invalid_kernel_size_raises(self, bad_size): + """BlurAnnotator must reject kernel_size < 1 at construction time.""" + with pytest.raises(ValueError, match="kernel_size must be >= 1"): + BlurAnnotator(kernel_size=bad_size) + + def test_annotate_zero_area_bbox_is_skipped(self, test_image): + """Zero-area bounding boxes must be silently skipped, not crash.""" + detections = _create_detections(xyxy=[[10, 10, 10, 50]], class_id=[0]) + annotator = BlurAnnotator(kernel_size=5) + result = annotator.annotate(scene=test_image.copy(), detections=detections) + assert np.array_equal(test_image, result) + + +class TestPixelateAnnotator: + """Tests for PixelateAnnotator class""" + + def test_annotate_with_no_detections(self, test_image): + """Test that annotate method returns unmodified image when no detections""" + detections = Detections.empty() + annotator = PixelateAnnotator() + result = annotator.annotate(scene=test_image.copy(), detections=detections) + assert np.array_equal(test_image, result) + + def test_annotate_with_single_detection(self, gradient_image): + """Test that annotate method correctly pixelates a region""" + detections = _create_detections(xyxy=[[10, 10, 90, 90]], class_id=[0]) + annotator = PixelateAnnotator(pixel_size=10) + result = annotator.annotate(scene=gradient_image.copy(), detections=detections) + assert not np.array_equal(gradient_image, result) + + def test_annotate_bbox_smaller_than_pixel_size_does_not_raise(self): + """PixelateAnnotator must not crash when the bbox is smaller than pixel_size. + + Regression test for https://github.com/roboflow/supervision/issues/703: + a fixed pixel_size larger than the detection dimensions previously caused + an OpenCV assertion error in cv2.resize. + """ + image = np.random.randint(0, 255, (100, 100, 3), dtype=np.uint8) + # bbox is 5x5; pixel_size=50 is much larger, triggers the avg-fill fallback + detections = _create_detections(xyxy=[[10, 10, 15, 15]], class_id=[0]) + annotator = PixelateAnnotator(pixel_size=50) + result = annotator.annotate(scene=image.copy(), detections=detections) + assert result.shape == image.shape + + def test_annotate_grayscale_image_does_not_raise(self): + """PixelateAnnotator must work on single-channel (grayscale) images. + + The small-ROI avg-fill branch previously sliced cv2.mean()[:3] into a + 2-D array, causing a NumPy broadcast error on grayscale frames. + """ + gray = np.random.randint(0, 255, (100, 100), dtype=np.uint8) + # Normal-size detection โ€” exercises the resize path on a grayscale frame + detections = _create_detections(xyxy=[[10, 10, 90, 90]], class_id=[0]) + annotator = PixelateAnnotator(pixel_size=10) + result = annotator.annotate(scene=gray.copy(), detections=detections) + assert result.shape == gray.shape + + def test_annotate_grayscale_image_small_roi_does_not_raise(self): + """Grayscale image with bbox smaller than pixel_size uses scalar avg fill. + + Exercises the ndim-aware branch added to the small-ROI fallback. + """ + gray = np.random.randint(0, 255, (100, 100), dtype=np.uint8) + detections = _create_detections(xyxy=[[10, 10, 15, 15]], class_id=[0]) + annotator = PixelateAnnotator(pixel_size=50) + result = annotator.annotate(scene=gray.copy(), detections=detections) + assert result.shape == gray.shape + + @pytest.mark.parametrize("bad_size", [0, -1, -10]) + def test_invalid_pixel_size_raises(self, bad_size): + """PixelateAnnotator must reject pixel_size < 1 at construction time.""" + with pytest.raises(ValueError, match="pixel_size must be >= 1"): + PixelateAnnotator(pixel_size=bad_size) + + def test_annotate_zero_area_bbox_is_skipped(self, test_image): + """Zero-area bounding boxes must be silently skipped, not crash.""" + detections = _create_detections(xyxy=[[10, 10, 10, 50]], class_id=[0]) + annotator = PixelateAnnotator(pixel_size=5) + result = annotator.annotate(scene=test_image.copy(), detections=detections) + assert np.array_equal(test_image, result) + + +class TestTriangleAnnotator: + """Tests for TriangleAnnotator class""" + + def test_annotate_with_no_detections(self, test_image): + """Test that annotate method returns unmodified image when no detections""" + detections = Detections.empty() + annotator = TriangleAnnotator() + result = annotator.annotate(scene=test_image.copy(), detections=detections) + assert np.array_equal(test_image, result) + + def test_annotate_with_single_detection(self, test_image): + """Test that annotate method correctly draws a triangle""" + detections = _create_detections(xyxy=[[10, 10, 90, 90]], class_id=[0]) + annotator = TriangleAnnotator( + color=Color.RED, base=20, height=20, color_lookup=ColorLookup.INDEX + ) + result = annotator.annotate(scene=test_image.copy(), detections=detections) + assert_image_mostly_same(test_image, result, similarity_threshold=0.95) + + +class TestRoundBoxAnnotator: + """Tests for RoundBoxAnnotator class""" + + def test_annotate_with_no_detections(self, test_image): + """Test that annotate method returns unmodified image when no detections""" + detections = Detections.empty() + annotator = RoundBoxAnnotator() + result = annotator.annotate(scene=test_image.copy(), detections=detections) + assert np.array_equal(test_image, result) + + def test_annotate_with_single_detection(self, test_image): + """Test that annotate method correctly draws a round box""" + detections = _create_detections(xyxy=[[10, 10, 90, 90]], class_id=[0]) + annotator = RoundBoxAnnotator( + color=Color.BLUE, thickness=2, roundness=0.5, color_lookup=ColorLookup.INDEX + ) + result = annotator.annotate(scene=test_image.copy(), detections=detections) + assert_image_mostly_same(test_image, result, similarity_threshold=0.9) + + +class TestPercentageBarAnnotator: + """Tests for PercentageBarAnnotator class""" + + def test_annotate_with_no_detections(self, test_image): + """Test that annotate method returns unmodified image when no detections""" + detections = Detections.empty() + annotator = PercentageBarAnnotator() + result = annotator.annotate(scene=test_image.copy(), detections=detections) + assert np.array_equal(test_image, result) + + def test_annotate_with_single_detection(self, test_image): + """Test that annotate method correctly draws a percentage bar""" + detections = _create_detections( + xyxy=[[10, 10, 90, 90]], confidence=[0.75], class_id=[0] + ) + annotator = PercentageBarAnnotator(color_lookup=ColorLookup.INDEX) + result = annotator.annotate(scene=test_image.copy(), detections=detections) + assert_image_mostly_same(test_image, result, similarity_threshold=0.93) + + +class TestPositionHelpers: + """Tests for helper methods that map `Position` to coordinates.""" + + @pytest.mark.parametrize( + ("helper", "args"), + [ + pytest.param( + PercentageBarAnnotator.calculate_border_coordinates, + ((10, 10), (4, 4), cast(Position, "invalid")), + id="percentage-bar", + ), + pytest.param( + CropAnnotator.calculate_crop_coordinates, + ((10, 10), (4, 4), cast(Position, "invalid")), + id="crop", + ), + ], + ) + def test_unknown_position_raises( + self, helper: Any, args: tuple[Any, Any, Any] + ) -> None: + """Unsupported positions must raise instead of returning None.""" + with pytest.raises(ValueError, match="Unsupported position"): + helper(*args) + + +class TestCropAnnotator: + """Tests for CropAnnotator class""" + + def test_annotate_with_no_detections(self, test_image): + """Test that annotate method returns unmodified image when no detections""" + detections = Detections.empty() + annotator = CropAnnotator() + result = annotator.annotate(scene=test_image.copy(), detections=detections) + assert np.array_equal(test_image, result) + + def test_annotate_with_single_detection(self, gradient_image): + """Test that annotate method correctly draws a crop""" + detections = _create_detections(xyxy=[[10, 10, 90, 90]], class_id=[0]) + annotator = CropAnnotator(border_color_lookup=ColorLookup.INDEX) + result = annotator.annotate(scene=gradient_image.copy(), detections=detections) + assert not np.array_equal(gradient_image, result) + + def test_annotate_emits_no_deprecation_warning(self, gradient_image): + """Internal overlay must not surface the deprecated `overlay_image` warning.""" + detections = _create_detections(xyxy=[[10, 10, 90, 90]], class_id=[0]) + annotator = CropAnnotator(border_color_lookup=ColorLookup.INDEX) + with warnings.catch_warnings(record=True) as caught: + warnings.simplefilter("always") + annotator.annotate(scene=gradient_image.copy(), detections=detections) + deprecations = [ + w + for w in caught + if issubclass(w.category, (DeprecationWarning, FutureWarning)) + ] + assert deprecations == [] + + def test_annotate_with_partially_out_of_bounds_detection(self, gradient_image): + """Partially-OOB box is clipped and rendered; scene must change.""" + detections = _create_detections(xyxy=[[-10, -10, 30, 30]], class_id=[0]) + annotator = CropAnnotator( + position=Position.CENTER, border_color_lookup=ColorLookup.INDEX + ) + result = annotator.annotate(scene=gradient_image.copy(), detections=detections) + assert result.shape == gradient_image.shape + assert not np.array_equal(gradient_image, result) + + def test_annotate_with_fully_out_of_bounds_detection(self, gradient_image): + """A box fully outside the scene collapses to zero area and is skipped.""" + detections = _create_detections(xyxy=[[-50, -50, -10, -10]], class_id=[0]) + annotator = CropAnnotator(border_color_lookup=ColorLookup.INDEX) + result = annotator.annotate(scene=gradient_image.copy(), detections=detections) + assert np.array_equal(gradient_image, result) + + @pytest.mark.parametrize( + "xyxy", + [ + pytest.param([-5, 20, 40, 60], id="negative-x-min"), + pytest.param([20, -5, 60, 40], id="negative-y-min"), + pytest.param([-10, -10, 30, 30], id="negative-x-and-y-min"), + pytest.param([60, 20, 140, 60], id="past-right-edge"), + pytest.param([-20, -20, 140, 140], id="larger-than-scene"), + ], + ) + def test_annotate_with_box_crossing_scene_border( + self, gradient_image, xyxy: list[int] + ) -> None: + """Boxes extending past the scene border are clipped instead of raising""" + detections = _create_detections(xyxy=[xyxy], class_id=[0]) + annotator = CropAnnotator() + + result = annotator.annotate(scene=gradient_image.copy(), detections=detections) + + assert result.shape == gradient_image.shape + + @pytest.mark.parametrize( + "xyxy", + [ + pytest.param([150, 150, 200, 200], id="fully-outside"), + pytest.param([-50, -50, -10, -10], id="fully-negative"), + pytest.param([30, 20, 30, 60], id="zero-width"), + pytest.param([30, 30, 30, 30], id="zero-area"), + ], + ) + def test_annotate_skips_boxes_empty_after_clipping( + self, gradient_image, xyxy: list[int] + ) -> None: + """Boxes with no visible area are skipped instead of raising cv2.error""" + detections = _create_detections(xyxy=[xyxy], class_id=[0]) + annotator = CropAnnotator() + + result = annotator.annotate(scene=gradient_image.copy(), detections=detections) + + assert np.array_equal(gradient_image, result) + + def test_annotate_mixed_valid_and_degenerate_boxes(self, gradient_image) -> None: + """A degenerate box does not prevent valid boxes from being drawn""" + detections = _create_detections( + xyxy=[[150, 150, 200, 200], [10, 10, 90, 90]], class_id=[0, 1] + ) + annotator = CropAnnotator() + + result = annotator.annotate(scene=gradient_image.copy(), detections=detections) + + assert not np.array_equal(gradient_image, result) + + def test_annotate_overlapping_crops_sample_from_original_scene(self) -> None: + """Later crops must sample the original un-annotated scene. + + box1 is pasted into the region that box2 crops from. Without the + source_scene = scene.copy() fix, box2 reads box1's paste value + instead of the original pixel โ€” the aliasing regression. + """ + # Arrange: two distinct pixel bands; box1's paste region overlaps box2's crop + scene = np.full((80, 80, 3), 50, dtype=np.uint8) + scene[0:20, 0:20] = 10 # band A โ€” box1 crops here (value 10) + scene[20:40, 20:40] = 200 # band B โ€” box2 crops here; box1 pastes here + + detections = _create_detections( + xyxy=[[0, 0, 20, 20], [20, 20, 40, 40]], class_id=[0, 1] + ) + # BOTTOM_RIGHT: each crop is pasted at its (x2, y2) corner. + # box1 pastes band A (value 10) at rows 20-39, cols 20-39 โ€” exactly + # where box2 will crop. + annotator = CropAnnotator( + position=Position.BOTTOM_RIGHT, + scale_factor=1.0, + ) + + # Act + result = annotator.annotate(scene=scene.copy(), detections=detections) + + # Assert: box2's crop is pasted at rows 40-59, cols 40-59. + # Interior (rows 42-57, cols 42-57) avoids the 2-pixel default border + # and must equal 200 โ€” the original band B value. Without the fix, + # box2 samples 10 from the painted scene instead of 200 from original. + interior = result[42:58, 42:58] + assert np.all(interior == 200), ( + f"box2 crop paste region should contain original pixel 200, " + f"got {np.unique(interior).tolist()!r}. " + "Regression: source_scene must be scene.copy(), not an alias." + ) + + +class TestIconAnnotator: + """Tests for IconAnnotator class""" + + def test_annotate_emits_no_deprecation_warning(self, test_image, tmp_path): + """Internal overlay must not surface the deprecated `overlay_image` warning.""" + icon_path = str(tmp_path / "icon.png") + icon = np.full((20, 20, 4), (0, 255, 0, 255), dtype=np.uint8) + cv2.imwrite(icon_path, icon) + detections = _create_detections(xyxy=[[20, 20, 60, 60]], class_id=[0]) + annotator = IconAnnotator() + with warnings.catch_warnings(record=True) as caught: + warnings.simplefilter("always") + annotator.annotate( + scene=test_image.copy(), detections=detections, icon_path=icon_path + ) + deprecations = [ + w + for w in caught + if issubclass(w.category, (DeprecationWarning, FutureWarning)) + ] + assert deprecations == [] + + def test_icon_cache_is_shared_by_path_and_resolution( + self, monkeypatch, test_image, tmp_path + ): + """Equal path/resolution icon loads are cached across annotator instances.""" + icon_path = str(tmp_path / "icon.png") + icon = np.full((20, 20, 4), (0, 255, 0, 255), dtype=np.uint8) + cv2.imwrite(icon_path, icon) + detections = _create_detections(xyxy=[[20, 20, 60, 60]], class_id=[0]) + imread_calls = 0 + original_imread = cv2.imread + + def count_imread(path, flags): + nonlocal imread_calls + imread_calls += 1 + return original_imread(path, flags) + + monkeypatch.setattr(cv2, "imread", count_imread) + + for _ in range(2): + IconAnnotator(icon_resolution_wh=(16, 16)).annotate( + scene=test_image.copy(), detections=detections, icon_path=icon_path + ) + + assert imread_calls == 1 + + +class TestBackgroundOverlayAnnotator: + """Tests for BackgroundOverlayAnnotator class""" + + def test_annotate_with_no_detections(self, test_image): + """Test that annotate method returns unmodified image when no detections""" + detections = Detections.empty() + annotator = BackgroundOverlayAnnotator() + result = annotator.annotate(scene=test_image.copy(), detections=detections) + assert np.array_equal(test_image, result) + + def test_annotate_with_single_detection(self): + """Test that annotate method correctly draws background overlay""" + image = np.ones((100, 100, 3), dtype=np.uint8) * 255 + detections = _create_detections(xyxy=[[10, 10, 90, 90]]) + annotator = BackgroundOverlayAnnotator(color=Color.BLACK, opacity=0.5) + result = annotator.annotate(scene=image.copy(), detections=detections) + assert not np.array_equal(image, result) + + @pytest.mark.parametrize( + ("xyxy", "inside_xy", "outside_xy"), + [ + pytest.param([-5, 20, 40, 60], (20, 30), (60, 80), id="crosses-left-edge"), + pytest.param([20, -5, 60, 40], (30, 20), (80, 60), id="crosses-top-edge"), + pytest.param( + [-10, -10, 40, 40], (20, 20), (70, 70), id="crosses-both-edges" + ), + ], + ) + def test_annotate_preserves_detection_crossing_scene_border( + self, xyxy: list[int], inside_xy: tuple[int, int], outside_xy: tuple[int, int] + ) -> None: + """The visible part of a box crossing the border keeps original pixels""" + image = np.full((100, 100, 3), 200, dtype=np.uint8) + detections = _create_detections(xyxy=[xyxy]) + annotator = BackgroundOverlayAnnotator(color=Color.BLACK, opacity=0.5) + + result = annotator.annotate(scene=image.copy(), detections=detections) + + x_in, y_in = inside_xy + x_out, y_out = outside_xy + assert np.array_equal(result[y_in, x_in], np.array([200, 200, 200])) + assert np.array_equal(result[y_out, x_out], np.array([100, 100, 100])) + + def test_annotate_fully_out_negative_box_does_not_corrupt(self) -> None: + """Both-negative OOB box must not restore an in-bounds region via wrap-around""" + image = np.full((100, 100, 3), 200, dtype=np.uint8) + detections = _create_detections(xyxy=[[-30, -30, -5, -5]]) + annotator = BackgroundOverlayAnnotator(color=Color.BLACK, opacity=0.5) + + result = annotator.annotate(scene=image.copy(), detections=detections) + + assert np.array_equal(result[80, 80], np.array([100, 100, 100])) + + def test_annotate_force_box_preserves_detection_crossing_scene_border(self): + """force_box with a border-crossing box keeps the visible detection region""" + image = np.full((100, 100, 3), 200, dtype=np.uint8) + mask = np.zeros((100, 100), dtype=bool) + mask[20:60, 0:40] = True + detections = _create_detections(xyxy=[[-5, 20, 40, 60]], mask=[mask]) + annotator = BackgroundOverlayAnnotator( + color=Color.BLACK, opacity=0.5, force_box=True + ) + + result = annotator.annotate(scene=image.copy(), detections=detections) + + assert np.array_equal(result[30, 20], np.array([200, 200, 200])) + assert np.array_equal(result[80, 60], np.array([100, 100, 100])) + + def test_annotate_with_fully_out_of_bounds_detection(self): + """A box fully outside the scene leaves the whole scene tinted""" + image = np.full((100, 100, 3), 200, dtype=np.uint8) + detections = _create_detections(xyxy=[[150, 150, 200, 200]]) + annotator = BackgroundOverlayAnnotator(color=Color.BLACK, opacity=0.5) + + result = annotator.annotate(scene=image.copy(), detections=detections) + + assert np.all(result == 100) + + def test_annotate_uint8_mask_matches_bool_mask(self): + """Test that uint8 and bool masks produce identical overlays.""" + image = np.ones((100, 100, 3), dtype=np.uint8) * 255 + mask = np.zeros((100, 100), dtype=bool) + mask[10:90, 10:90] = True + + detections_bool = _create_detections(xyxy=[[10, 10, 90, 90]], mask=[mask]) + detections_uint8 = _create_detections(xyxy=[[10, 10, 90, 90]], mask=[mask]) + detections_uint8.mask = detections_uint8.mask.astype(np.uint8) + + annotator = BackgroundOverlayAnnotator(color=Color.BLACK, opacity=0.5) + result_bool = annotator.annotate(scene=image.copy(), detections=detections_bool) + result_uint8 = annotator.annotate( + scene=image.copy(), detections=detections_uint8 + ) + assert np.array_equal(result_bool, result_uint8) + + +class TestComparisonAnnotator: + """Tests for ComparisonAnnotator class""" + + def test_annotate_with_no_detections(self, test_image): + """Test that annotate method returns unmodified image when no detections""" + detections1 = Detections.empty() + detections2 = Detections.empty() + annotator = ComparisonAnnotator() + result = annotator.annotate( + scene=test_image.copy(), detections_1=detections1, detections_2=detections2 + ) + assert np.array_equal(test_image, result) + + def test_annotate_with_single_detection_each(self): + """Test that annotate method correctly compares two detections""" + image = np.ones((100, 100, 3), dtype=np.uint8) * 255 + detections1 = _create_detections(xyxy=[[10, 10, 50, 50]]) + detections2 = _create_detections(xyxy=[[30, 30, 70, 70]]) + annotator = ComparisonAnnotator() + result = annotator.annotate( + scene=image.copy(), detections_1=detections1, detections_2=detections2 + ) + assert not np.array_equal(image, result) + + +class TestTraceAnnotatorReset: + """Tests for TraceAnnotator.reset() clearing accumulated trace history.""" + + def test_reset_empties_trace_buffers(self, test_image: np.ndarray) -> None: + """reset() must clear the underlying Trace buffers to their empty state.""" + annotator = TraceAnnotator(trace_length=10) + detections = _create_detections( + xyxy=[[10, 10, 30, 30]], class_id=[1], tracker_id=[7] + ) + annotator.annotate(scene=test_image.copy(), detections=detections) + + annotator.reset() + + assert annotator.trace.frame_id.shape == (0,) + assert annotator.trace.xy.shape == (0, 2) + assert annotator.trace.tracker_id.shape == (0,) + assert annotator.trace.current_frame_id == 0 + + def test_reset_matches_fresh_annotator(self, test_image: np.ndarray) -> None: + """After reset() a reused annotator must render identically to a fresh one. + + The two streams reuse the same ``tracker_id`` but follow spatially + distinct paths. If reset were a no-op, ``Trace.get`` would return the + first stream's points concatenated with the second's and draw a spurious + polyline bridging the two paths; only a genuine reset leaves solely the + second stream's points, so byte-equality with a never-used annotator can + hold only when the prior history was actually discarded. ``trace_length`` + is large enough that no windowing prunes away the stale points that a + broken reset would leave behind. + """ + first_stream = [ + _create_detections( + xyxy=[[10 + step * 6, 10 + step * 6, 20 + step * 6, 20 + step * 6]], + class_id=[1], + tracker_id=[7], + ) + for step in range(5) + ] + second_stream = [ + _create_detections( + xyxy=[[80 - step * 6, 10 + step * 6, 90 - step * 6, 20 + step * 6]], + class_id=[1], + tracker_id=[7], + ) + for step in range(5) + ] + reused = TraceAnnotator(trace_length=30) + reused_scene = test_image.copy() + for detections in first_stream: + reused_scene = reused.annotate(scene=reused_scene, detections=detections) + reused.reset() + reused_scene = test_image.copy() + for detections in second_stream: + reused_scene = reused.annotate(scene=reused_scene, detections=detections) + + fresh = TraceAnnotator(trace_length=30) + fresh_scene = test_image.copy() + for detections in second_stream: + fresh_scene = fresh.annotate(scene=fresh_scene, detections=detections) + + assert np.array_equal(reused_scene, fresh_scene) + + +class TestTraceAnnotatorSmoothStationary: + """Regression tests for TraceAnnotator(smooth=True) on stationary tracker ids.""" + + def test_stationary_tracker_does_not_crash_spline_fit(self, test_image): + """ + When the same tracker stays at an identical anchor point for several + frames the trace buffer accumulates duplicate points. `scipy.splprep` + rejects a zero-length input curve with `ValueError: Invalid inputs.`, + so the annotator must survive this input without raising. + """ + detections = _create_detections( + xyxy=[[100, 100, 120, 120]], + class_id=[1], + tracker_id=[42], + ) + annotator = TraceAnnotator(smooth=True, trace_length=10) + scene = test_image.copy() + for _ in range(6): + scene = annotator.annotate(scene=scene, detections=detections) + assert scene.shape == test_image.shape + + def test_smooth_trace_still_renders_for_moving_tracker(self, test_image): + """Moving tracker must produce a spline trace distinct from the raw polyline. + + Compares smooth=True output against smooth=False for the same movement + path to confirm the smoothing path is actually exercised (not just that + some pixels changed). + """ + smooth_annotator = TraceAnnotator(smooth=True, trace_length=10, thickness=2) + raw_annotator = TraceAnnotator(smooth=False, trace_length=10, thickness=2) + scene_smooth = test_image.copy() + scene_raw = test_image.copy() + for offset in range(6): + detections = _create_detections( + xyxy=[ + [10 + offset * 5, 10 + offset * 5, 30 + offset * 5, 30 + offset * 5] + ], + class_id=[1], + tracker_id=[7], + ) + scene_smooth = smooth_annotator.annotate( + scene=scene_smooth, detections=detections + ) + scene_raw = raw_annotator.annotate(scene=scene_raw, detections=detections) + # After 4+ unique anchor positions the spline path fires and diverges from the + # raw polyline โ€” the two output images must differ. + assert not np.array_equal(scene_smooth, scene_raw) + + @pytest.mark.parametrize( + "unique_positions", + [1, 2, 3, 4], + ids=["1_unique", "2_unique", "3_unique", "4_unique"], + ) + def test_smooth_does_not_crash_for_unique_point_counts( + self, test_image, unique_positions + ): + """smooth=True must not crash for any unique-position count from 1 to 4. + + Each position is repeated twice to simulate brief holds between moves. + Covers the boundary at len(unique_xy) == 4 where splprep first fires. + """ + annotator = TraceAnnotator(smooth=True, trace_length=10, thickness=2) + scene = test_image.copy() + for pos_idx in range(unique_positions): + for _ in range(2): + x = 10 + pos_idx * 15 + detections = _create_detections( + xyxy=[[x, x, x + 15, x + 15]], + class_id=[1], + tracker_id=[99], + ) + scene = annotator.annotate(scene=scene, detections=detections) + assert scene.shape == test_image.shape + + def test_smooth_fallback_matches_raw_when_fewer_than_four_unique_points( + self, test_image + ): + """With <4 unique positions smooth=True output must match smooth=False. + + Verifies the dedup-then-fallback path: when unique_xy has โ‰ค3 points, + both branches use the same raw-polyline draw. + """ + annotator_smooth = TraceAnnotator(smooth=True, trace_length=10, thickness=2) + annotator_raw = TraceAnnotator(smooth=False, trace_length=10, thickness=2) + scene_smooth = test_image.copy() + scene_raw = test_image.copy() + for pos_idx in range(3): + for _ in range(2): + x = 10 + pos_idx * 15 + detections = _create_detections( + xyxy=[[x, x, x + 15, x + 15]], + class_id=[1], + tracker_id=[99], + ) + scene_smooth = annotator_smooth.annotate( + scene=scene_smooth, detections=detections + ) + scene_raw = annotator_raw.annotate( + scene=scene_raw, detections=detections + ) + assert np.array_equal(scene_smooth, scene_raw) + + def test_smooth_true_single_frame_does_not_crash(self, test_image): + """A single annotate() call with smooth=True must not crash. + + When len(xy) == 1 the drawing guard skips cv2.polylines entirely; + the dedup path runs safely on an empty np.diff result. + """ + detections = _create_detections( + xyxy=[[50, 50, 70, 70]], + class_id=[1], + tracker_id=[1], + ) + annotator = TraceAnnotator(smooth=True, trace_length=10) + scene = annotator.annotate(scene=test_image.copy(), detections=detections) + assert scene.shape == test_image.shape + + def test_smooth_false_stationary_tracker_does_not_crash(self, test_image): + """smooth=False with a stationary tracker must not crash (regression guard). + + Ensures the refactor did not accidentally alter the smooth=False code path. + """ + detections = _create_detections( + xyxy=[[100, 100, 120, 120]], + class_id=[1], + tracker_id=[42], + ) + annotator = TraceAnnotator(smooth=False, trace_length=10) + scene = test_image.copy() + for _ in range(6): + scene = annotator.annotate(scene=scene, detections=detections) + assert scene.shape == test_image.shape diff --git a/tests/annotators/test_docs.py b/tests/annotators/test_docs.py new file mode 100644 index 0000000..f9def6c --- /dev/null +++ b/tests/annotators/test_docs.py @@ -0,0 +1,148 @@ +"""Regression tests for docs/detection/annotators.md tab structure.""" + +import ast +import re +from pathlib import Path + +import pytest + +_REPO_ROOT = Path(__file__).resolve().parent +while not (_REPO_ROOT / "pyproject.toml").exists(): + _REPO_ROOT = _REPO_ROOT.parent + +REPO_ROOT = _REPO_ROOT + +EXPECTED_ANNOTATOR_TAB_GROUPS: dict[str, list[str]] = { + "Outlines": [ + "Box", + "RoundBox", + "BoxCorner", + "Circle", + "Ellipse", + "Polygon", + ], + "Shading": ["Color", "Halo", "Mask"], + "Markers": ["Dot", "Triangle"], + "Labels": ["Label", "RichLabel"], + "Transformative": ["Blur", "Pixelate"], + "Tracking & Aggregation": ["Trace", "HeatMap"], + "Others": [ + "PercentageBar", + "Icon", + "Background Color", + "Comparison", + ], +} + + +def _extract_annotator_tab_groups() -> dict[str, list[str]]: + """Parse annotator tab structure from docs/detection/annotators.md. + + Returns: + Mapping of category name to list of annotator tab labels within that + category. + """ + docs_path = REPO_ROOT / "docs" / "detection" / "annotators.md" + content = docs_path.read_text(encoding="utf-8") + + start_marker = '=== "Outlines"' + end_marker = "Try Supervision Annotators on your own image" + + start = content.find(start_marker) + if start == -1: + pytest.fail( + f"Could not find start marker {start_marker!r} in {docs_path} while " + "parsing annotator example tab groups." + ) + + end = content.find(end_marker, start) + if end == -1: + pytest.fail( + f"Could not find end marker {end_marker!r} in {docs_path} while " + "parsing annotator example tab groups." + ) + if end <= start: + pytest.fail( + f"End marker {end_marker!r} must appear after start marker " + f"{start_marker!r} in {docs_path}." + ) + + example_section = content[start:end] + + groups: dict[str, list[str]] = {} + current_group = None + + for line in example_section.splitlines(): + if match := re.match(r'^(?P\s*)=== "(?P