machinevision-toolbox-python 2.4.0__py3-none-any.whl → 2.4.1__py3-none-any.whl

machinevisiontoolbox/ImageFiducials.py

@@ -429,14 +429,22 @@ class FiducialCollection:
         # -------------------------------------------------------------------
         ids = ids.reshape(-1) if ids is not None else ids
 
-        # filter tags by ID
-        cornerss = [
-            corners.T.squeeze()
-            for corners, id in zip(cornerss, ids)
-            if id in self._ids
-        ]
-        ids = [id for corners, id in zip(cornerss, ids) if id in self._ids]
-        # ids = np.reshape(ids, (-1, 1))
+        # filter tags by ID, keeping each marker's corners and id together in
+        # a single pass so the two lists cannot get out of step (detectMarkers
+        # returns ids=None when it finds nothing)
+        matches = (
+            []
+            if ids is None
+            else [
+                (corners.T.squeeze(), id)
+                for corners, id in zip(cornerss, ids)
+                if id in self._ids
+            ]
+        )
+        if not matches:
+            raise ValueError("no markers belonging to this board were detected")
+        cornerss = [corners for corners, _ in matches]
+        ids = [id for _, id in matches]
 
         # match the markers to the board
         # print(f"{len(ids)} markers found")

machinevisiontoolbox/Sources.py

@@ -602,7 +602,8 @@ class VideoCamera(ImageSource):
         attached video camera.  On a Mac running 13.0 (Ventura) or later and
         an iPhone with iOS 16 or later, the Continuity Camera feature allows
         the phone camera to be used as a local video camera, and it will
-        appear as a separate camera with its own ID.
+        appear as a separate camera with its own ID.  Other phones, and cameras
+        on the network, can be used through :class:`WebCam`.
 
         OpenCV does not expose a portable API for mapping integer ``id``
         values to human-readable camera names.  Use :meth:`list` to
@@ -612,7 +613,7 @@ class VideoCamera(ImageSource):
     :references:
         - |RVC3|, Section 11.1.3.
 
-    :seealso: :meth:`list` :func:`~machinevisiontoolbox.base.imageio.convert`
+    :seealso: :meth:`list` :class:`WebCam` :func:`~machinevisiontoolbox.base.imageio.convert`
         `cv2.VideoCapture <https://docs.opencv.org/4.x/d8/dfe/classcv_1_1VideoCapture.html#a57c0e81e83e60f36c83027dc2a188e80>`_
     """
 
@@ -1729,15 +1730,24 @@ class WebCam(ImageSource):
                     pass
 
 
-    .. note:: Manu webcameras accept a query string in the URL to specify
+    .. note:: Many webcameras accept a query string in the URL to specify
         image resolution, image format, codec and other parameters. There
         is no common standard for this, see the manufacturer's datasheet
         for details.
 
+    .. note:: The ``url`` is passed to ``cv2.VideoCapture``, so it can be
+        anything that OpenCV can open, for example a still-image URL, a
+        live HTTP (MJPEG) stream or an RTSP stream.  A phone can be used as a
+        networked camera in this way: many IP-camera apps for iOS and Android
+        publish a live stream at a URL.  Which stream types and URL formats are
+        supported depends on the app and on how your OpenCV was built.  On a Mac
+        with an iPhone, Continuity Camera makes the phone appear as a local
+        camera instead, see :class:`VideoCamera`.
+
     :references:
         - |RVC3|, Section 11.1.5.
 
-    :seealso: :func:`~machinevisiontoolbox.base.imageio.convert`
+    :seealso: :class:`VideoCamera` :func:`~machinevisiontoolbox.base.imageio.convert`
         `cv2.VideoCapture <https://docs.opencv.org/4.x/d8/dfe/classcv_1_1VideoCapture.html#a57c0e81e83e60f36c83027dc2a188e80>`_
     """
 

machinevisiontoolbox/blocks/Icons/README.md

@@ -0,0 +1,28 @@
+# Block icons
+
+Icons for the bdsim blocks in this toolbox. They follow the conventions of
+[bdsim's `Icons` folder](https://github.com/petercorke/bdsim/blob/main/src/bdsim/blocks/Icons/README.md):
+250x250 RGBA PNG, black "ink" on a transparent background, named as the
+lower-case version of the block's class name.
+
+| Icon | How it is made |
+|---|---|
+| `visjac_p.png`, `estpose_p.png` | TeX math, rendered by `make_icons.py` (below). The files in git were made with `bdtex2icon` from bdsim, which needs LaTeX; `make_icons.py` makes the same glyphs, with slightly different size and placement. |
+| `camera.png`, `imageplane.png` | not made by `make_icons.py` |
+
+## Creating icons from TeX
+
+```
+python make_icons.py                # all icons in the table at the top of the script
+python make_icons.py visjac_p       # one icon
+python make_icons.py --outdir /tmp  # write somewhere else, e.g. to compare
+```
+
+This needs only matplotlib and Pillow, which this toolbox already depends on,
+and no LaTeX installation. To add an icon, add a line to the `ICONS` table in
+`make_icons.py`. The math is rendered by matplotlib's `mathtext`, which
+implements a subset of TeX and does not know the custom macros of the RVC
+notation file (`\mat`, `\pose`, ...), so write those expanded, for example
+`\mathbf{J}_p` rather than `\mat{J}_p`.
+
+Running the script overwrites the icons of the same name in this folder.

machinevisiontoolbox/blocks/Icons/make_icons.py

@@ -0,0 +1,111 @@
+#!/usr/bin/env python
+"""
+Create block icons from TeX math, using only matplotlib and Pillow.
+
+Run it from anywhere to (re)create the icons listed in :data:`ICONS`::
+
+    $ python make_icons.py                     # all icons, written next to this script
+    $ python make_icons.py visjac_p            # just one
+    $ python make_icons.py --outdir /tmp/icons # somewhere else
+
+Each icon is a 250x250 RGBA PNG: black "ink" on a transparent background, the
+size and style used by the bdsim block icons (see the README in this folder).
+
+The math is rendered by matplotlib's ``mathtext`` engine with the Computer
+Modern font set, so no LaTeX installation is needed.  ``mathtext`` implements a
+subset of TeX, and not the custom macros (``\\mat``, ``\\pose``, ...) from the
+``rvc-notation`` file that ``bdtex2icon`` (part of bdsim) uses, so the entries
+in :data:`ICONS` are written with those macros expanded.
+"""
+
+import argparse
+import io
+from pathlib import Path
+
+import matplotlib
+
+matplotlib.use("Agg")
+
+import numpy as np
+from matplotlib import mathtext, rc_context
+from PIL import Image
+
+IMSIZE = 250
+
+#: icon file stem -> TeX math (without the surrounding ``$``)
+ICONS: dict[str, str] = {
+    "visjac_p": r"\mathbf{J}_p",
+    "estpose_p": r"\xi(p, P)",
+}
+
+
+def tex_icon(
+    tex: str, path: Path, size: int = IMSIZE, margin: float = 0.08, dpi: int = 600
+) -> None:
+    """Render TeX math to a square, transparent, black-ink PNG icon.
+
+    :param tex: TeX math expression, without the surrounding ``$``
+    :param path: output file
+    :param size: width and height of the icon in pixels, defaults to 250
+    :param margin: blank border as a fraction of ``size``, on each side,
+        defaults to 0.08
+    :param dpi: resolution of the intermediate rendering, defaults to 600
+
+    The expression is rendered, cropped to its ink, scaled to fit inside the
+    margin, and centered on a transparent canvas.
+    """
+    buf = io.BytesIO()
+    with rc_context({"mathtext.fontset": "cm"}):  # Computer Modern, as LaTeX
+        mathtext.math_to_image(f"${tex}$", buf, dpi=dpi, format="png", color="black")
+
+    # math_to_image saves a figure, so it is black ink on an *opaque white*
+    # background.  The ink is black, so how dark a pixel is gives its coverage,
+    # and that is all the icon needs: black everywhere, with this as the alpha.
+    # Working on one channel also avoids mixing colors into anti-aliased edges.
+    alpha = 255 - np.asarray(Image.open(buf).convert("L"))
+    ys, xs = np.nonzero(alpha)
+    ink = Image.fromarray(alpha[ys.min() : ys.max() + 1, xs.min() : xs.max() + 1])
+
+    scale = size * (1 - 2 * margin) / max(ink.size)
+    ink = ink.resize(
+        (max(1, round(ink.width * scale)), max(1, round(ink.height * scale))),
+        Image.LANCZOS,
+    )
+
+    canvas = Image.new("L", (size, size), 0)
+    canvas.paste(ink, ((size - ink.width) // 2, (size - ink.height) // 2))
+
+    icon = Image.new("RGBA", (size, size), (0, 0, 0, 0))
+    icon.putalpha(canvas)
+    icon.save(path)
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description=__doc__.strip().splitlines()[0])
+    parser.add_argument(
+        "names",
+        nargs="*",
+        metavar="name",
+        help=f"icons to create, one or more of {', '.join(ICONS)}; default is all",
+    )
+    parser.add_argument(
+        "--outdir",
+        type=Path,
+        default=Path(__file__).resolve().parent,
+        help="output directory, defaults to the directory containing this script",
+    )
+    args = parser.parse_args()
+
+    unknown = [n for n in args.names if n not in ICONS]
+    if unknown:
+        parser.error(f"unknown icon(s) {unknown}, choose from {list(ICONS)}")
+
+    args.outdir.mkdir(parents=True, exist_ok=True)
+    for name in args.names or ICONS:
+        path = args.outdir / f"{name}.png"
+        tex_icon(ICONS[name], path)
+        print(f"Written: {path}")
+
+
+if __name__ == "__main__":
+    main()