machinevision-toolbox-python 1.0.3__tar.gz → 2.0.0__tar.gz

{machinevision_toolbox_python-1.0.3 → machinevision_toolbox_python-2.0.0}/.gitignore

@@ -1,4 +1,18 @@
 
+### MacOS ###
+.DS_Store
+
+dependencies*
+*.log
+
+# ROS bag files
+*.bag
+# but keep test fixtures
+!mvtb-data/mvtbdata/data/*.bag
+
+# old notebooks
+notebooks/old/*
+
 ### Python ###
 # Byte-compiled / optimized / DLL files
 __pycache__/
@@ -64,6 +78,11 @@ target/
 .ipynb_checkpoints/
 
 ### Figures generated by Python notebooks ###
+
+# old notebooks
+notebooks/old/*
+
+*.inc
 *.eps
 
 *.zip
@@ -72,3 +91,6 @@ docs/source/stubs/*
 # latex products
 .log
 .aux
+
+# LLVM profiling data
+*.profraw

machinevision_toolbox_python-2.0.0/CHANGELOG.md

@@ -0,0 +1,241 @@
+2.0.0 May 2026
+
+* Added
+  - image sources
+    - `ROSBag` reads images and point clouds from ROS 1/2 bag files
+    - `ROSTopic` reads images and point clouds from live ROS 1/2 systems via `rosbridge`
+    - `ImageSequence`: a sequence of image objects
+    - `PointCloudSequence`: a sequence of point cloud objects
+    - `TensorStack`: reads images from a batch tensor
+    - `LabelMeReader`: returns image and shape data from a LabelMe JSON file
+  - CLI tools
+    - `bagtool`: animate images or point clouds from a ROS 1/2 bag file
+    - `ocrtool`: write OCR text to stdout or JSON
+  - documentation
+    - ecosystem diagram
+    - new Sphinx sections for ROS, PyTorch, NumPy integration, and Jupyter
+    - code copy button for examples (strips `>>>` prompts)
+    - top-level of reST documentation now uses sphinx-design and a card-based TOC
+
+* Changed
+  - CI and packaging
+    - changed `master` branch to `main`
+    - reworked and renamed CI files
+    - replaced `flake8` with `ruff`
+    - added extras: `jupyter`, `pytorch`, `ros`, `ocr`
+    - added `all` extra to install all optional extras
+    - consolidated documentation and notebooks into `docs`
+  - code quality
+    - tested with Python 3.13
+    - improved behaviour when Open3D is unavailable
+    - many more unit tests, with average coverage now > 50%
+    - consistent and PEP-conformant `repr()` and `str()` formatting
+    - more consistent handling of lazy imports
+    - systematic use of `import cv2`
+    - consistent naming of test files
+    - PEP 8/257-compliant import grouping and module docstrings
+    - revisited suppression comment tags for validity and currency
+    - normalized deprecation/warning/docstring language with explicit version tagging
+  - image I/O and display
+    - `iread` now uses `cv2.imdecode` instead of PIL, with internal refactor for corner cases
+    - `iread_iter` is an efficient lazy wildcard iterator
+    - `idisp` now includes keyboard display and animation controls when `fps` or `animate` is specified
+    - fixed `idisp` issues with Jupyter Matplotlib backend selection (for example `%matplotlib widget`)
+    - `idisp` can now put text labels on colorbar ticks
+  - `Image` class and core API
+    - image NumPy array for pixel data
+      - deprecate `.A` property, setting `.A` now raises an exception
+      - systematic internal use of `._A` for  array access
+      - `.array` for user use, provide a read-only view of the pixel data
+    - uses `_image_typing.py` protocol to resolve `Image` type across mixins
+    - improved color order and type logic
+    - `Image(..., dtype=True)` forces image dtype to match the ndarray; otherwise the smallest fitting dtype is selected
+    - `size` option supports turning pixel row/column data into 2D or 3D images
+    - `Image.Tensor()` and `img.tensor()` for PyTorch import/export
+    - statistics improvements:
+      - `sum`, `min`, `max`, `mean`, `std`, `median` forward arguments to NumPy (for example `axis`)
+      - `img.stats` is now a property returning per-plane statistics
+      - `img.printstats()` prints formatted per-plane statistics
+      - all are computed lazily
+    - thresholding improvements:
+      - native NumPy implementations for `otsu` and `triangle` threshold estimators
+      - `threshold_interactive` reworked for Jupyter support
+    - NaN/Inf handling:
+      - `img.numnan` and `img.numinf` properties
+      - `fixbad()` for remediation
+      - reporting in `repr()` and `str()`
+    - NumPy ufunc integration (for example `np.ceil(img)` returns an `Image`)
+    - `%` operator stacks images plane-wise (for example `img1 % img2`, `img1 % 0`)
+    - `Image.Random()`
+      - supports multi-channel images
+      - now has a `pdf` arugment to create an image with arbitary pixel-value distribution.
+    - `img1.sameas(img2)` performs scalar equality checks across datatype/planes/pixels (`img1 == img2` remains element-wise)
+    - image histogram properties `h`, `pdf`, `cf`, `cdf` are now computed lazily, and each returns a 2-tuple of ndarays (statistic, x).  These property names match those of the `Histogram` class. They were formally called `h`, `cdf`, and `ncdf` and return just a single ndarray.
+    - `__str__` now includes image statistics like mean, std, median.
+    - all "constant constructors" like `Zeros`, `Constant`, `Random` etc. now have a consistent API with 
+      keyword arguments `size`, `dtype`, `colororder`, `like`.
+    - `Kernel.Gauss` and `smooth` with a half-width but `sigma=0` will use a rule-of-thumb to estimate a good `sigma` value
+    - `showpixels` has a major improvement in visual appearance, some parameters now gone.  The animation window has been refactored into `showwindow`. `examples/morphdemo` shows this in action.
+    - `rprint` is a variant of `print` that returns the image object, so `img = Image.Random(size=5).rprint()` does an assignment to `img` and displays the pixel values to stdout in one line.
+  - `Histogram` class
+    - now has a `pdf` property for an estimated/empirical probability density function
+    - cumulative frequency is renamed from `cdf` to `cf`; `ncdf` renamed to `cdf`
+    - now implemented using NumPy rather than OpenCV for wider dtype support
+    - works properly in Jupyter
+    - histogram computation moved to constructor
+    - `clip` controls bin range behaviour
+    - plotting options for `span`, `log`, `cursor`, and `stats` markers
+  - `Blobs` class
+    - major internal refactor; `Blob` is now a dataclass
+    - improved handling of runt (single-pixel) blobs
+    - added `id` method
+    - new attributes/methods: `MER()`/`plot_MER()`, `MEC()`/`plot_MEC()`
+    - added default color and linestyle to all plot functions.  These all accept Matplotlib format string or keyword arguments for line styling
+  - Image sources
+    - all sources are iterators and context managers, reworked the common abstract base class
+    - all sources inherit display/animation (`.disp()`) and batch tensor (`.tensor()`) methods
+    - all sources accept keyword arguments forwarded to `convert`
+    - `VideoCamera` has a new `list` method showing camera name/id mapping
+    - `VideoFile`, `WebCam`, and `EarthView` are unchanged
+  - CLI
+    - improved `--help` strings and option ordering
+    - `mvtbtool` supports image preloading into the IPython namespace, autoreload, optional PyTorch import, and `MVTB_OPTIONS` environment variable
+    - `tagtool` reports ArUco/April tags to stdout or JSON
+  - notebook support
+    - notebooks revamped and extended
+    - `threshold_interactive` works in Jupyter
+    - notebook workflows are unit-testable
+    - distributed as a ZIP built by GitHub Actions
+    - distributed in a zero-install JupyterLite environment (WASM + Emscripten)
+
+* Deprecated
+  - `iread(..., grey=...)` and `iread(..., gray=...)`; use `mono=` instead
+  - `img.image` and `img.A`; use `img.array`
+  - `img.to_int()` and `img.to_float()`; use `img.array_as()`
+  - `column`; use `view1d`
+  - `thresh()`; use `threshold()`
+  - threshold keyword `t`; use `threshold`
+  - threshold keyword `opt`; use `method`
+  - `ithresh`; use `threshold_interactive`
+  - `adaptive_threshold`; use `threshold_adaptive`
+  - legacy `Image.Constant` positional size form (for example migrate from `Image.Constant(10, 20, 30)` to `Image.Constant(30, size=(10, 20))`)
+  - `ImageCollection`; use `FileCollection`
+  - `ZipArchive`; use `FileArchive`
+  - `rank`; use `rankfilter`
+  - `Image.Zeros(10)` is now `Image.Zeros(size=10)`
+  - `Image.Constant(3,4,5)` is now `Image.Constant(5, size=(3,4))`
+  - `Image.Random(10)` is now `Image.Random(size=10)`
+
+* Fixed
+  - resolved many Sphinx warnings
+  - resolved issues in plot/runblock examples
+  - improved OpenCV documentation link consistency where intersphinx is not effective
+  - fixed issues in `idisp` that confused Jupyter Matplotlib backend selection
+
+* Miscellaneous
+  - generated OpenCV guard functions from OpenCV documentation for input validation
+  - `Kernel` class refactored to its own file
+  - ROS synchronization support via `SyncROSStreams`
+
+1.0.2 January 2026
+
+* `Image` class
+
+  - `warp_affine` can now warp an image into a given output image
+  - graphic primitives
+  - create an ArUco marker
+  - save as PDF
+
+  - all the draw_xxx() functions in base now have wrappers as methods of `Image`
+  - draw_xxx() now handle floating point arguments, rounding them to the neares int
+  - improvements in name2color to handle image datatypes and colororder
+
+* FiducialCollection class, represent a generalized calibration board with AR tags
+
+* ArUcoBoard class, represent a generalized ArUco calibration board
+
+* changed to src folder layout, code is in src/machinevisiontoolbox
+* changed from setuptools to hatch
+* works if Open3D is not installed, it's always well behind in Python version support
+* removed numpy < 2.0 constraint, OpenCV now suppports numpy 2.x
+* working with Python 3.12 (except for Open3D)
+* added command line tools:
+  - `imtool` for displaying images, exploring pixels, picking points, showing metadata etc.  Works with your own images or those provided with MVTB 
+  - `tagtool` for highlighting AR tags in images
+
+1.0.1 March 2025
+
+* `Image` class
+  - `.dice` method, chops an image up into tiles, can be overlapping
+  - `.Tile(columns=0)` will arrange the tiles into a roughly square layout
+  - Constant images, previously many of these could only generate square images, this is now generalized
+  - `.Chequerboard` creates a chequerboard pattern
+  - set background color for image warp undefined pixels
+  - single plane images can have a colorplane name
+  - deprecate `colordict()`, use `colororder2dict()` instead
+  - `String` now supports two string formats, can create color images
+  - fixed bug with gamma="sRGB" which always returned a float image, type is now the same as passed
+
+* Blobs
+
+  - new methods for blob aligned box, plot_aligned_box, 
+  - `plot_perimeter` options
+  - `perimeter_hull` convex hull
+  - fixed bug with runt blobs
+
+* Kernels
+
+  - added `Kernel.HGauss` for Hessian of Gaussian
+  - added `Kernel` repr method, `disp` method
+ArUcoBoard class
+
+* Camera models
+  - Fixed errors in some camera projection models
+
+* Point clouds
+
+  - `PointCloud` now has a "constructor" for depth images, `PointCloud.DepthImage()`
+
+* Miscellaneous
+
+  - Lots more code examples and plots
+  - Move decoratores scalar_result and array_result to machinevisiontoolbox.decorators.py
+  - improved unit testing
+
+
+
+1.0.0 January 2025
+
+* `Kernel` methods now return `Kernel` instances rather than NumPy arrays. Methods that
+accept a kernel can accept a `Kernel` instance or a NumPy array.  Methods exist to 
+stringify or print a kernel.
+
+* The indexing order of an `Image` object (using square bracket `__getitem__` access) has
+  changed and is now `img[u,v]` where `u` is the column coordinate and `v` is the row
+  coordinate.  This is consistent with the column-first convention used across the
+  Toolbox and is consistent with the $(u,v)$ coordinate system for images. But, this
+  is the __opposite__ order to that used for NumPy index on the underlying array, and
+  to earlier versions of the Toolbox. 
+
+    - a 2-tuple of integers, select this pixel.  If the image has multiple planes, the
+      result is a vector over planes.
+    - a 3-tuple of integers, for a multiplane image select this pixel from the specified
+      plane.
+    - a 2-tuple of slice objects, select this region. If the image has multiple planes,
+      the result is a 3D array.
+    - a 3-tuple of slice objects, select this region of uv and planes
+    - an int, select this plane
+    - a string, select this named plane or planes
+
+* added `pixel(u,v)` method for faster access to a single pixel value, scalar or vector.
+
+* the children of a `Blob` is now given as a list of `Blob` objects, not their indices
+within the overall list of blobs.  This simplies traversing the blob hierarchy tree.
+Similarly, the parent is a reference to the parent `Blob` object rather than an index,
+and is `None` if the blob has no parent (its parent is the background).
+
+* Documentation overhaul, both in-code docstrings, and the organization of the overall Sphinx document.
+
+* Additional unit tests
+
+* Myriad minor bug fixes, see commit history.

machinevision_toolbox_python-2.0.0/CODEAUTOLINK_FORK_PLAN.md

@@ -0,0 +1,186 @@
+# sphinx-codeautolink: current assessment and fork plan
+
+## Current state
+
+The repository is currently building Sphinx successfully, but the docs still emit a substantial number of `sphinx-codeautolink` warnings, mostly of these forms:
+
+- `codeautolink.match_name`
+- `codeautolink.match_block`
+
+Recent local improvements already made in MVTB:
+
+- repaired several malformed code examples in `Sources.py` so they parse cleanly
+- configured custom cleaners for `pycon`, `ipython`, and `ipython3` blocks in `docs/source/conf.py`
+- confirmed that the remaining warnings are now mostly extension limitations or source-to-HTML matching issues, not obvious broken examples
+
+## What the extension is actually doing
+
+`sphinx-codeautolink` does use Python AST-based static analysis.
+
+What it appears to do upstream:
+
+- parses code blocks with `ast.parse(...)`
+- walks the tree with an `ast.NodeVisitor`-style tracker
+- records imports, names, attribute chains, some assignments, and scope information
+- resolves names against imports, type hints, and the Sphinx inventory/intersphinx objects
+- does not execute code
+
+Important limitation:
+
+It is not a full static type checker. Its own documentation indicates that parsing and type-hint resolution are incomplete, which matches the warning patterns seen in this repository.
+
+## Updated direction
+
+There is now a stronger implementation direction based on local fork work:
+
+- the `runblock` path has already been forked and made substantially faster
+- that execution-based path provides real runtime objects and types, which is often a better source of truth than AST inference for documentation examples
+
+This changes the most useful fork strategy.
+
+The goal should probably not be two mostly separate systems, one static and one executed. Instead, the better design is a shared pipeline with two analysis modes.
+
+The shared front end should:
+
+1. normalise the source block once
+2. clean prompts and console syntax once
+3. produce one internal representation of the block
+
+From there, resolution can happen in two ways:
+
+1. runtime-assisted resolution when execution is enabled and succeeds
+2. static fallback resolution when execution is disabled, unsafe, slow, or incomplete
+
+That means the two functions are "smooshed together" architecturally, but not collapsed into one unconditional execution path.
+
+## Why the merged architecture is better
+
+For MVTB-style docs examples, execution often gives better answers for names such as `im`, `f`, `camera`, `bag`, and similar local variables, because the resolver can inspect the actual runtime object rather than infer it from assignments.
+
+The likely priority order for name resolution should be:
+
+1. runtime object identity and type, when available
+2. static AST/import/type-hint inference
+3. existing inventory/name heuristics
+
+This preserves the advantages of static analysis:
+
+- works for non-runnable snippets
+- works for deliberately partial snippets
+- avoids executing unsafe or expensive blocks
+
+while using execution where it gives a clear accuracy improvement.
+
+## Fork feasibility
+
+Yes, this looks forkable.
+
+The likely intervention areas are:
+
+1. parser logic
+2. name/type resolution logic
+3. block-to-generated-HTML matching logic
+
+The practical goal should be:
+
+Make it materially better for real documentation examples.
+
+The practical goal should not be:
+
+Turn it into a full general-purpose Python semantic analyser.
+
+## Problems worth targeting first
+
+These are the highest-value issues for MVTB-style documentation examples:
+
+1. False warnings on multiline interactive examples.
+2. Weak handling of simple value flow such as `im = ...` followed by attribute/method access.
+3. Weak handling of documented objects referenced through short local names.
+4. HTML/block matching failures where the code is reasonable but the generated page structure does not line up with the extension's expectations.
+5. Noisy warnings on autosummary-generated stub pages where the signal is low.
+
+## Concrete plan
+
+### Phase 0: define the merged architecture
+
+1. Identify the current overlap between block cleaning, parsing, and name extraction in the static and runblock paths.
+2. Extract a shared block-normalisation layer.
+3. Define one common intermediate result structure consumed by both runtime-assisted and static resolvers.
+
+Success criterion:
+
+There is one canonical representation of a documentation block, not two competing preprocessors.
+
+### Phase 1: build a reproducible warning corpus
+
+1. Save a representative Sphinx warning log from this repository.
+2. Group warnings by pattern and by source file.
+3. Select a small set of stable regression cases from MVTB docs, especially:
+   - `docs/source/intro.rst`
+   - `docs/source/sources.rst`
+   - camera/property stub pages
+   - autosummary pages that currently trigger `match_block`
+
+Success criterion:
+
+We have 5-10 concrete examples that fail consistently and represent the real pain points.
+
+### Phase 2: inspect upstream code paths against those cases
+
+1. Trace each chosen failure through the upstream parser and resolver.
+2. Trace the same cases through the forked runblock execution path.
+2. Determine whether each warning comes from:
+   - AST parsing limitations
+   - missing runtime-to-symbol mapping
+   - incomplete assignment/type propagation
+   - inventory resolution gaps
+   - HTML matching logic
+3. Separate true unsupported constructs from fixable bugs.
+
+Success criterion:
+
+Each regression case is mapped to a specific upstream subsystem and failure mode.
+
+### Phase 3: implement narrow fixes
+
+Prefer small, doc-example-oriented fixes first:
+
+1. Add runtime-assisted resolution for executed examples, using real objects/types from the fast runblock path.
+2. Improve handling of simple assignment chains in the static fallback.
+3. Improve propagation for obvious constructor-returned objects used in subsequent lines.
+4. Relax or improve block/HTML matching where structurally valid examples are being missed.
+5. Suppress or downgrade warnings in known low-value contexts such as some autosummary stubs if linking cannot be made reliable.
+
+Success criterion:
+
+The selected regression cases produce fewer warnings without introducing obvious bad links.
+
+### Phase 4: validate against MVTB docs
+
+1. Run the docs build before and after the fork changes.
+2. Compare warning counts by category, not just total count.
+3. Manually inspect a sample of generated links in HTML.
+
+Success criterion:
+
+Fewer warnings and acceptable link quality on real MVTB pages.
+
+### Phase 5: decide maintenance strategy
+
+Options:
+
+1. Keep a private fork and pin to it.
+2. Upstream small fixes and keep only local patches if needed.
+3. If only warning noise improves, keep local config/workarounds and do not maintain a long-lived fork.
+
+## Recommended first move
+
+If this is resumed later, the most efficient next step is:
+
+Create a small regression set from the current MVTB warning log, then map each case to whether it should be solved by runtime-assisted resolution or by static fallback.
+
+Without that, the fork risks becoming speculative rather than driven by concrete documentation failures.
+
+## Why this is worth doing
+
+If upstream continues improving, MVTB can inherit those improvements. A fork only makes sense if we can identify a small number of high-value fixes that materially improve real documentation pages with manageable maintenance cost.

machinevision_toolbox_python-2.0.0/MIGRATION.md

@@ -0,0 +1,91 @@
+# Migration to MVTB 2
+
+
+## Image object
+
+### Access to encapsulated pixel data
+
+The `Image` object keeps a private reference to the numpy array that holds the pixel data.  This array should not be
+changed directly since it may invalidate the metadata in the object itself.
+
+The private reference was previously either `.A` or `.image`.  The former is too cryptic and the latter 
+confusing since it returns an ndarray not an `Image`.
+
+For v2 this is now `.array`. It's a read-only property.  You can use the referenced array but do not mutate it.
+
+To get an ndarray of a particular type use `.array_as(dtype)` where `dtype` is a string or a np datatype.
+
+
+### Dtype change
+
+
+## Reprs
+
+In v1 the __str__ methods were often quite verbose, nicely formatted multiline displays.  Some even 
+displayed tables using `ansitable`.  Most __repr__ methods just called __str__ which is poor practice,
+a __repr__ should be concise and single line and ideally be sufficient to recreate the object.
+
+In v2, __repr__s now conform to that model.  This means that the old workflow
+
+```
+>>> mvtb_method(...)
+```
+
+would display a verbose response.  Now you just get the cryptic version.
+
+## Image.threshold()
+
+`Image.threshold(t, opt)` where `t` is the threshold that could be a numeric threshold or a string specifying 
+an algorithm for choosing the threshold.  This is modeled on cv.threshold which returns an image the same
+type as the source.  A bug meant that for floating point images the result would comprise 0 and inf values.
+The algorithms for choosing a threshold, otsu and triangle, are limited to uint8/16 and uint8 pixels respectively.
+
+A binary threshold of a floating image should be a boolean image not a float.  However boolean images are
+not well received by OpenCV, so the decision was made to return uint8 image with pixels as 0 (false) and 
+255 (true) for the binary threshold case.
+
+Changes:
+
+* for binary and binary_inv case the return value will always be uint8
+* the as_bool option will return a bool image
+* Otsu and triangle have been implemented from scratch using numpy and handle int or float images
+* a new 'percentile' option has been added
+
+            >>> img.threshold(5).print()
+            >>> img.threshold('otsu')
+            >>> img.threshold('percentile', p=90)
+
+## Image constants
+
+`Image.Constant(10, 10, 3)` would create a 10x10 image containing pixel values of 3.  It is not particularly 
+informative when read.  It could also be written as `Image.Constant(w=10, h=10, value=3)` which is not much better.
+Worse it could be written as `Image.Constant((10,10), 3)` or `Image.Constant(w=(10,10), value=3)`.
+Too many options, and arguably the constant value should come first.
+
+Shape functions like `Image.Squares(2, 10, 10)` would create...
+
+All these functions now have the following keyword arguments, they cannot be positional.
+
+* `size: tuple` a tuple either (W,H) or (W,H,C)
+* `dtype: str | Dtype`  a datatype specifier as either a string or an np.dtype
+* `colororder: str` specifying the color order of a multi-channel image
+* `like: Image` where the image sets the defaults for size, dtype and colororder, the options above will override those 
+
+The only positional arguments would the ones specific to the method.
+
+
+
+# Other
+
+Image.stats
+
+`Image.stats` is now a property (dictionary-valued), not a method.
+
+* v1: `img.stats()`
+* v2: `img.stats`
+* formatted console output: `img.printstats()`
+
+Whole-image scalar statistics are now properties as well:
+
+* v1: `img.sum()`, `img.min()`, `img.max()`, `img.mean()`, `img.std()`, `img.var()`, `img.median()`
+* v2: `img.sum`, `img.min`, `img.max`, `img.mean`, `img.std`, `img.var`, `img.median`

machinevision_toolbox_python-2.0.0/Makefile

@@ -0,0 +1,77 @@
+.FORCE:
+
+BLUE=\033[0;34m
+BLACK=\033[0;30m
+
+help:
+	@echo "$(BLUE) make test - run all unit tests"
+	@echo " make test-log - run all unit tests and write log to pytest.log"
+	@echo " make test-nb - run nbmake tests on RVC3 vision chapter notebooks"
+	@echo " make coverage - run unit tests and coverage report"
+	@echo " make typehints - run mypy type-hint coverage report and open HTML"
+	@echo " make docs - build Sphinx documentation"
+	@echo " make docs-nitpicky - build Sphinx docs with nitpicky cross-reference checks"
+	@echo " make docs-strict - nitpicky Sphinx build with warnings treated as errors"
+	@echo " make view - open Sphinx doco build (uses open for MacOS)"
+	@echo " make dist - preview dist build"
+	@echo " make pypi - build the dist, upload to PyPI, tag the release and push the tag to origin"
+	@echo " make clean - remove dist and docs build files"
+	@echo " make help - this message$(BLACK)"
+
+test:
+	validate-pyproject pyproject.toml
+	python -m pytest
+
+test-log:
+	python -m pytest -W all --tb=short 2>&1 | tee pytest.log
+	@echo "pytest log --> pytest.log"
+
+test-nb:
+	python -m pytest --nbmake notebooks
+
+test-rvc:
+	MVTB_TEST_MODE=True python -m pytest --nbmake tests/RVC
+
+coverage:
+	coverage run --source='src/machinevisiontoolbox' -m pytest
+	coverage report
+	coverage html
+	open -a Safari htmlcov/index.html
+
+typehints:
+	-mypy src/machinevisiontoolbox --ignore-missing-imports --html-report /tmp/mypy-typehints
+	open -a Safari /tmp/mypy-typehints/index.html
+
+docs: .FORCE
+	(cd docs; make html O="-w warnings.txt")
+
+docs-nitpicky: .FORCE
+	conda run --no-capture-output -n dev sphinx-build -n -b html docs/source docs/build/html
+
+docs-strict: .FORCE
+	conda run --no-capture-output -n dev sphinx-build -n -W -b html docs/source docs/build/html
+
+view: .FORCE
+	open -a Safari docs/build/html/index.html
+
+dist: .FORCE
+	# $(MAKE) test
+	python -m build
+	ls -lh dist/*
+
+pypi: .FORCE
+	@if ! git diff --quiet || ! git diff --cached --quiet; then \
+		echo "Error: uncommitted changes present, aborting upload"; exit 1; \
+	fi
+	python -m build
+	$(eval VERSION := $(shell grep '^version' pyproject.toml | sed 's/version = "\(.*\)"/\1/'))
+	@echo "Uploading version $(VERSION) to PyPI"
+	twine upload dist/*
+	git tag v$(VERSION)
+	git push origin v$(VERSION)
+
+clean: .FORCE
+	(cd docs; make clean)
+	-rm -r *.egg-info
+	-rm -r dist build
+