added lapsrn an macbeth onnx

human_parsing_jppnet/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2016 Vladimir Nekrasov
+
+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.

human_parsing_jppnet/README.md

@@ -0,0 +1,127 @@
+# Human Parsing (JPPNet)
+
+Single-person human parsing with JPPNet — it labels every pixel of a person as one of
+20 LIP classes (hair, face, upper clothes, pants, left/right arm, left/right shoe, and
+so on). The model was originally distributed as a frozen TensorFlow graph
+(`lip_jppnet_384.pb`, the one referenced by OpenCV's `samples/dnn/human_parsing.py`)
+and converted to ONNX for use with OpenCV's DNN module.
+
+## Model Details
+- **Architecture**: JPPNet — a ResNet-101 backbone with atrous convolutions, three
+  parsing heads (`fc1_human`, `fc2_parsing`, `fc3_parsing`) built from four-branch ASPP
+  modules, run at three input scales (0.75x, 1.0x, 1.25x) whose predictions are averaged
+- **Input**: BGR image, 384×384, raw 0–255 float, mean `(104.00698793, 116.66876762,
+  122.67891434)`, no scaling, no swapRB, NCHW layout (`input:0`, shape `[2, 3, 384, 384]`)
+- **Output**: `Mean_3:0` — class scores, shape `[2, 20, 384, 384]`
+- **Framework**: ONNX opset 15 (converted from the TensorFlow frozen graph via tf2onnx)
+- **Original weights**: https://github.com/Engineering-Course/LIP_JPPNet
+- **Paper**: Liang, Gong, Shen and Lin, *Look into Person: Joint Body Parsing & Pose
+  Estimation Network and a New Benchmark*, T-PAMI 2018
+
+The batch dimension is fixed at **2** and is not a batch of two different pictures. The
+network expects the image *and its horizontal mirror*: the two predictions get averaged,
+which is what the original evaluation script does to stabilise the result. Before
+averaging, the mirrored half has its left/right channel pairs swapped back
+(LeftArm↔RightArm, LeftLeg↔RightLeg, LeftShoe↔RightShoe) and is flipped horizontally.
+`demo.py` and `demo.cpp` both do this; skipping it costs accuracy on the limbs.
+
+The 20 classes, in channel order:
+
+| | | | |
+|---|---|---|---|
+| 0 Background | 5 UpperClothes | 10 Jumpsuits | 15 RightArm |
+| 1 Hat | 6 Dress | 11 Scarf | 16 LeftLeg |
+| 2 Hair | 7 Coat | 12 Skirt | 17 RightLeg |
+| 3 Glove | 8 Socks | 13 Face | 18 LeftShoe |
+| 4 Sunglasses | 9 Pants | 14 LeftArm | 19 RightShoe |
+
+The spatial size is frozen at 384×384 — the graph resizes its own heads back to that
+resolution with hardcoded constants, so it always predicts at 384×384 no matter what it
+is fed. The demos resize the picture to 384×384 on the way in and scale the score maps
+back to the original resolution before taking the argmax.
+
+## Usage
+
+### Python
+```bash
+python demo.py --model human_parsing_jppnet_2026sep.onnx \
+               --image example_outputs/input_image.png \
+               --output example_outputs/output_image.png
+```
+
+Or import directly:
+```python
+import cv2
+
+net = cv2.dnn.readNetFromONNX("human_parsing_jppnet_2026sep.onnx")
+# see demo.py for preprocessing, the mirror merge and the LIP palette
+```
+
+### C++
+The C++ demo runs inference with OpenCV's DNN module (default engine — no ONNX Runtime
+needed). Adjust the OpenCV paths to your setup:
+```bash
+OCV=/path/to/opencv                          # OpenCV source tree
+OCVBUILD=/path/to/opencv/build               # OpenCV build directory (generated headers + libs)
+g++ -std=c++17 demo.cpp -o demo \
+  -I$OCV/include \
+  -I$OCV/modules/core/include \
+  -I$OCV/modules/dnn/include \
+  -I$OCV/modules/imgproc/include \
+  -I$OCV/modules/imgcodecs/include \
+  -I$OCVBUILD \
+  -L$OCVBUILD/lib -Wl,-rpath,$OCVBUILD/lib -lopencv_dnn -lopencv_imgcodecs -lopencv_imgproc -lopencv_core
+./demo --model human_parsing_jppnet_2026sep.onnx --image example_outputs/input_image.png
+```
+
+Both demos produce the same label map, pixel for pixel.
+
+## Conversion
+The ONNX model was exported from the frozen TensorFlow graph with tf2onnx (opset 15) via
+[convert_to_onnx.py](./convert_to_onnx.py) — input `input:0`, output `Mean_3:0`, both
+forced to NCHW (`inputs_as_nchw` / `outputs_as_nchw`) so the tensors match OpenCV's
+layout, with the input shape overridden to `[2, 384, 384, 3]`. Requires `tensorflow`,
+`tf2onnx`, `onnx` and `opencv-python` (the last only for `--verify`).
+
+```bash
+python convert_to_onnx.py --pb ../pb/lip_jppnet_384.pb --verify example_outputs/input_image.png
+```
+
+Fixing the input shape lets tf2onnx fold the whole graph down to nine op types — `Conv`,
+`Relu`, `Sum`, `Add`, `Concat`, `Resize`, `Unsqueeze`, `ReduceMean` and `MaxPool`. The
+batch-norms fuse into the convolutions, and the `SpaceToBatchND`/`BatchToSpaceND` pairs
+that implement atrous convolution collapse into plain `Conv` nodes with `dilations`.
+
+One post-processing step is applied to the exported graph. The three ASPP heads sum four
+branches each, which tf2onnx emits as nine `Sum` nodes with four inputs; OpenCV 4.x's
+ONNX importer mis-computes those (about 14% of the pixels came out with the wrong label).
+`split_multi_input_sums` rewrites them as chains of two-input `Add`, which is numerically
+identical and imports correctly everywhere.
+
+The 412 MB file size is expected: the weights are shared across the three scale branches,
+so it is close to a single ResNet-101 plus the parsing heads at float32.
+
+### Verification
+The exported model was checked against the original TensorFlow graph on the example
+image, over all 2 × 20 × 384 × 384 output values:
+
+| runtime | max abs diff | mean abs diff | pixels with the same label |
+|---|---|---|---|
+| ONNX Runtime 1.23 | 3.05e-05 | 2.33e-06 | 100.0000% |
+| OpenCV 4.11 DNN | 3.34e-05 | 2.60e-06 | 100.0000% |
+| OpenCV 5.0 DNN | 3.62e-05 | 2.58e-06 | 100.0000% |
+
+## Example
+`example_outputs/input_image.png` is the standing-person image from OpenCV's own test
+data (`opencv_extra/testdata/dnn/pose.png`); `example_outputs/output_image.png` is the
+parsing result painted with the LIP palette.
+
+## License
+See [LICENSE](./LICENSE) — the MIT license file shipped in
+[Engineering-Course/LIP_JPPNet](https://github.com/Engineering-Course/LIP_JPPNet),
+carried over from the DeepLab-ResNet TensorFlow implementation the code is built on
+(hence the `Copyright (c) 2016 Vladimir Nekrasov` line).
+
+Note that the license covers the code. The released weights are trained on the
+[LIP dataset](https://lip.sysuhcp.com/), which the authors distribute for non-commercial
+research use; check the dataset's own terms before using the model in a product.

human_parsing_jppnet/convert_to_onnx.py

@@ -0,0 +1,131 @@
+import argparse
+import datetime
+
+import numpy as np
+import onnx
+from onnx import helper
+import tensorflow as tf
+import tf2onnx
+
+# The frozen graph takes a batch of exactly two images (the picture and its
+# horizontal mirror) and always emits a 384x384 label map, so the spatial size
+# is the only thing worth parameterising.
+INPUT_NAME = "input:0"
+OUTPUT_NAME = "Mean_3:0"
+BATCH = 2
+MEAN = (104.00698793, 116.66876762, 122.67891434)
+
+
+def load_graph_def(pb_path):
+    with tf.io.gfile.GFile(pb_path, "rb") as f:
+        graph_def = tf.compat.v1.GraphDef()
+        graph_def.ParseFromString(f.read())
+    return graph_def
+
+
+def split_multi_input_sums(model):
+    """Rewrite Sum nodes that take more than two inputs into chains of Add.
+
+    The three ASPP heads are exported as four-input Sum nodes. OpenCV 4.x's
+    ONNX importer gets those wrong (roughly 14% of the pixels end up with the
+    wrong label) while two-input adds import correctly on every version we
+    tested, and the rewrite is numerically identical.
+    """
+    graph = model.graph
+    rewritten = []
+    count = 0
+    for node in graph.node:
+        if node.op_type != "Sum" or len(node.input) <= 2:
+            rewritten.append(node)
+            continue
+        count += 1
+        acc = node.input[0]
+        for i, operand in enumerate(node.input[1:]):
+            name = "%s__add%d" % (node.name, i)
+            last = i == len(node.input) - 2
+            out = node.output[0] if last else name
+            rewritten.append(helper.make_node("Add", [acc, operand], [out], name=name))
+            acc = out
+    del graph.node[:]
+    graph.node.extend(rewritten)
+    return count
+
+
+def make_input(image_path, size):
+    """Build the [2, 3, size, size] NCHW blob the exported model expects."""
+    import cv2
+
+    image = cv2.imread(image_path)
+    if image is None:
+        raise OSError("cannot read %s" % image_path)
+    image = cv2.resize(image, (size, size))
+    mirror = np.flip(image, axis=1)
+    return cv2.dnn.blobFromImages([image, mirror], mean=MEAN)
+
+
+def verify(graph_def, onnx_path, blob, size):
+    """Compare the exported model against the original TensorFlow graph."""
+    import cv2
+
+    graph = tf.Graph()
+    with graph.as_default():
+        tf.import_graph_def(graph_def, name="")
+    with tf.compat.v1.Session(graph=graph) as sess:
+        nhwc = blob.transpose(0, 2, 3, 1).copy()
+        tf_out = sess.run(OUTPUT_NAME, feed_dict={INPUT_NAME: nhwc})
+    tf_out = tf_out.transpose(0, 3, 1, 2)
+
+    net = cv2.dnn.readNetFromONNX(onnx_path)
+    net.setInput(blob)
+    onnx_out = net.forward()
+
+    diff = np.abs(tf_out.astype(np.float64) - onnx_out.astype(np.float64))
+    agree = 100.0 * (tf_out.argmax(1) == onnx_out.argmax(1)).mean()
+    print("verify: tensorflow %s vs opencv %s" % (tf_out.shape, onnx_out.shape))
+    print("verify: max abs diff %.3e, mean abs diff %.3e" % (diff.max(), diff.mean()))
+    print("verify: identical labels on %.4f%% of the pixels" % agree)
+    return diff.max()
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Export the frozen LIP_JPPNet human parsing graph to ONNX")
+    parser.add_argument("--pb", default="../pb/lip_jppnet_384.pb",
+                        help="frozen TensorFlow graph (lip_jppnet_384.pb)")
+    parser.add_argument("--size", type=int, default=384, help="input resolution")
+    parser.add_argument("--opset", type=int, default=15)
+    parser.add_argument("--output", default=None, help="output .onnx path")
+    parser.add_argument("--verify", metavar="IMAGE", default=None,
+                        help="after exporting, compare the ONNX model against "
+                             "the TensorFlow graph on this image")
+    args = parser.parse_args()
+
+    graph_def = load_graph_def(args.pb)
+
+    model_proto, _ = tf2onnx.convert.from_graph_def(
+        graph_def,
+        input_names=[INPUT_NAME],
+        output_names=[OUTPUT_NAME],
+        inputs_as_nchw=[INPUT_NAME],
+        outputs_as_nchw=[OUTPUT_NAME],
+        opset=args.opset,
+        shape_override={INPUT_NAME: [BATCH, args.size, args.size, 3]},
+    )
+    n = split_multi_input_sums(model_proto)
+    print("rewrote %d multi-input Sum nodes as Add chains" % n)
+    onnx.checker.check_model(model_proto)
+
+    onnx_path = args.output
+    if onnx_path is None:
+        stamp = datetime.datetime.now().strftime("%Y%b").lower()
+        onnx_path = "human_parsing_jppnet_%s.onnx" % stamp
+    with open(onnx_path, "wb") as f:
+        f.write(model_proto.SerializeToString())
+    print("wrote", onnx_path)
+
+    if args.verify:
+        verify(graph_def, onnx_path, make_input(args.verify, args.size), args.size)
+
+
+if __name__ == "__main__":
+    main()

human_parsing_jppnet/demo.cpp

@@ -0,0 +1,143 @@
+#include <opencv2/dnn.hpp>
+#include <opencv2/imgproc.hpp>
+#include <opencv2/imgcodecs.hpp>
+#include <iostream>
+#include <string>
+#include <vector>
+
+// The exported graph is frozen at 384x384 and always takes two images: the
+// picture and its horizontal mirror.
+static const int INPUT_SIZE = 384;
+static const cv::Scalar MEAN(104.00698793, 116.66876762, 122.67891434);
+
+// The 20 LIP classes, in channel order.
+static const char* CLASSES[] = {
+    "Background", "Hat", "Hair", "Glove", "Sunglasses", "UpperClothes",
+    "Dress", "Coat", "Socks", "Pants", "Jumpsuits", "Scarf", "Skirt",
+    "Face", "LeftArm", "RightArm", "LeftLeg", "RightLeg", "LeftShoe",
+    "RightShoe"
+};
+static const int NUM_CLASSES = 20;
+
+// LIP palette, RGB.
+static const unsigned char COLORS[NUM_CLASSES][3] = {
+    {0, 0, 0}, {128, 0, 0}, {255, 0, 0}, {0, 85, 0}, {170, 0, 51},
+    {255, 85, 0}, {0, 0, 85}, {0, 119, 221}, {85, 85, 0}, {0, 85, 85},
+    {85, 51, 0}, {52, 86, 128}, {0, 128, 0}, {0, 0, 255}, {51, 170, 221},
+    {0, 255, 255}, {85, 255, 170}, {170, 255, 85}, {255, 255, 0}, {255, 170, 0}
+};
+
+static std::string argVal(int argc, char** argv, const std::string& key, const std::string& def)
+{
+    for (int i = 1; i + 1 < argc; ++i)
+        if (key == argv[i]) return argv[i + 1];
+    return def;
+}
+
+// Mirroring an image swaps the left and right body parts, so the channels of
+// the mirrored prediction have to be swapped back before the two are averaged.
+static int mirrorChannel(int c)
+{
+    switch (c)
+    {
+        case 14: return 15;  // LeftArm  <-> RightArm
+        case 15: return 14;
+        case 16: return 17;  // LeftLeg  <-> RightLeg
+        case 17: return 16;
+        case 18: return 19;  // LeftShoe <-> RightShoe
+        case 19: return 18;
+        default: return c;
+    }
+}
+
+// Build the [2, 3, 384, 384] blob: the image and its mirror, mean-subtracted.
+static cv::Mat preprocess(const cv::Mat& image)
+{
+    cv::Mat resized, mirror;
+    cv::resize(image, resized, cv::Size(INPUT_SIZE, INPUT_SIZE));
+    cv::flip(resized, mirror, 1);
+
+    std::vector<cv::Mat> images;
+    images.push_back(resized);
+    images.push_back(mirror);
+
+    return cv::dnn::blobFromImages(images, 1.0, cv::Size(), MEAN);
+}
+
+// Average the two predictions and turn them into a label map of `size`.
+// `out` is [2, 20, 384, 384].
+static cv::Mat postprocess(const cv::Mat& out, const cv::Size& size)
+{
+    cv::Mat labels(size, CV_8U, cv::Scalar(0));
+    cv::Mat best(size, CV_32F, cv::Scalar(-FLT_MAX));
+
+    for (int c = 0; c < NUM_CLASSES; ++c)
+    {
+        cv::Mat direct(INPUT_SIZE, INPUT_SIZE, CV_32F,
+                       const_cast<float*>(out.ptr<float>(0, c)));
+        cv::Mat mirrored(INPUT_SIZE, INPUT_SIZE, CV_32F,
+                         const_cast<float*>(out.ptr<float>(1, mirrorChannel(c))));
+
+        cv::Mat unmirrored;
+        cv::flip(mirrored, unmirrored, 1);
+
+        cv::Mat score = 0.5f * (direct + unmirrored);
+        cv::resize(score, score, size, 0, 0, cv::INTER_LINEAR);
+
+        cv::Mat better = score > best;
+        score.copyTo(best, better);
+        labels.setTo(c, better);
+    }
+    return labels;
+}
+
+// Paint a label map with the LIP palette, as a BGR image.
+static cv::Mat colorize(const cv::Mat& labels)
+{
+    cv::Mat lut(1, NUM_CLASSES, CV_8UC3);
+    for (int i = 0; i < NUM_CLASSES; ++i)
+        lut.at<cv::Vec3b>(0, i) = cv::Vec3b(COLORS[i][2], COLORS[i][1], COLORS[i][0]);
+
+    cv::Mat segmentation(labels.size(), CV_8UC3);
+    for (int y = 0; y < labels.rows; ++y)
+    {
+        const unsigned char* src = labels.ptr<unsigned char>(y);
+        cv::Vec3b* dst = segmentation.ptr<cv::Vec3b>(y);
+        for (int x = 0; x < labels.cols; ++x)
+            dst[x] = lut.at<cv::Vec3b>(0, src[x]);
+    }
+    return segmentation;
+}
+
+int main(int argc, char** argv)
+{
+    std::string model  = argVal(argc, argv, "--model",  "human_parsing_jppnet_2026sep.onnx");
+    std::string image  = argVal(argc, argv, "--image",  "example_outputs/input_image.png");
+    std::string output = argVal(argc, argv, "--output", "example_outputs/output_image.png");
+
+    cv::Mat img = cv::imread(image);
+    if (img.empty())
+    {
+        std::cerr << "could not read image: " << image << std::endl;
+        return 1;
+    }
+
+    cv::dnn::Net net = cv::dnn::readNetFromONNX(model);
+    net.setInput(preprocess(img));
+    cv::Mat out = net.forward();
+
+    cv::Mat labels = postprocess(out, img.size());
+    cv::Mat segmentation = colorize(labels);
+
+    std::cout << "human_parsing_jppnet input " << img.cols << "x" << img.rows << std::endl;
+    for (int c = 0; c < NUM_CLASSES; ++c)
+    {
+        int pixels = cv::countNonZero(labels == c);
+        if (pixels > 0)
+            std::cout << "  " << CLASSES[c] << " " << pixels << " px" << std::endl;
+    }
+
+    cv::imwrite(output, segmentation);
+    std::cout << "wrote " << output << std::endl;
+    return 0;
+}

human_parsing_jppnet/demo.py

@@ -0,0 +1,99 @@
+import argparse
+import os
+
+import cv2 as cv
+import numpy as np
+
+here = os.path.dirname(os.path.abspath(__file__))
+
+# The exported graph is frozen at 384x384 and always takes two images: the
+# picture and its horizontal mirror.
+INPUT_SIZE = 384
+MEAN = (104.00698793, 116.66876762, 122.67891434)
+
+# The 20 LIP classes, in channel order.
+CLASSES = ["Background", "Hat", "Hair", "Glove", "Sunglasses", "UpperClothes",
+           "Dress", "Coat", "Socks", "Pants", "Jumpsuits", "Scarf", "Skirt",
+           "Face", "LeftArm", "RightArm", "LeftLeg", "RightLeg", "LeftShoe",
+           "RightShoe"]
+
+# LIP palette, RGB.
+COLORS = [(0, 0, 0), (128, 0, 0), (255, 0, 0), (0, 85, 0), (170, 0, 51),
+          (255, 85, 0), (0, 0, 85), (0, 119, 221), (85, 85, 0), (0, 85, 85),
+          (85, 51, 0), (52, 86, 128), (0, 128, 0), (0, 0, 255), (51, 170, 221),
+          (0, 255, 255), (85, 255, 170), (170, 255, 85), (255, 255, 0),
+          (255, 170, 0)]
+
+# Mirroring an image swaps the left and right body parts, so the channels of
+# the mirrored prediction have to be swapped back before the two are averaged.
+FLIP_PAIRS = [(14, 15), (16, 17), (18, 19)]
+
+
+def preprocess(image):
+    """Build the [2, 3, 384, 384] blob: the image and its mirror, mean-subtracted."""
+    resized = cv.resize(image, (INPUT_SIZE, INPUT_SIZE))
+    mirror = np.flip(resized, axis=1)
+    return cv.dnn.blobFromImages([resized, mirror], mean=MEAN)
+
+
+def postprocess(out, size):
+    """Average the two predictions and turn them into a label map of `size`.
+
+    `out` is [2, 20, 384, 384]; `size` is the (width, height) to scale back to.
+    """
+    direct, mirrored = out[0], out[1]
+
+    order = list(range(len(CLASSES)))
+    for left, right in FLIP_PAIRS:
+        order[left], order[right] = right, left
+    mirrored = np.flip(mirrored[order], axis=2)
+
+    scores = 0.5 * (direct + mirrored)
+    scores = np.stack([cv.resize(c, size, interpolation=cv.INTER_LINEAR) for c in scores])
+    return scores.argmax(axis=0).astype(np.uint8)
+
+
+def colorize(labels):
+    """Paint a label map with the LIP palette, as a BGR image."""
+    palette = np.array(COLORS, dtype=np.uint8)[:, ::-1]  # RGB -> BGR
+    return palette[labels]
+
+
+def parse_human(net, image):
+    """Run the network on one image and return its label map."""
+    net.setInput(preprocess(image))
+    out = net.forward()
+    return postprocess(out, (image.shape[1], image.shape[0]))
+
+
+def main():
+    parser = argparse.ArgumentParser(description="JPPNet human parsing (ONNX) demo")
+    parser.add_argument("--model", default=os.path.join(here, "human_parsing_jppnet_2026sep.onnx"))
+    parser.add_argument("--image", default=os.path.join(here, "example_outputs", "input_image.png"))
+    parser.add_argument("--output", default=os.path.join(here, "example_outputs", "output_image.png"))
+    parser.add_argument("--show", action="store_true", help="display the result in a window")
+    args = parser.parse_args()
+
+    image = cv.imread(args.image)
+    if image is None:
+        raise SystemExit("could not read image: %s" % args.image)
+
+    net = cv.dnn.readNetFromONNX(args.model)
+    labels = parse_human(net, image)
+    segmentation = colorize(labels)
+
+    present = [(CLASSES[i], int((labels == i).sum())) for i in np.unique(labels)]
+    print("human_parsing_jppnet input %dx%d" % (image.shape[1], image.shape[0]))
+    for name, pixels in sorted(present, key=lambda p: -p[1]):
+        print("  %-14s %7d px" % (name, pixels))
+
+    cv.imwrite(args.output, segmentation)
+    print("wrote", args.output)
+
+    if args.show:
+        cv.imshow("Deep learning human parsing in OpenCV", segmentation)
+        cv.waitKey()
+
+
+if __name__ == "__main__":
+    main()

human_parsing_jppnet/human_parsing_jppnet_2026sep.onnx

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:eeace33fc98ed398bb33a3df3dca20839d9c7bcae8cfd3984409b4ddf8c426b4
+size 431265151

lapsrn/LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

lapsrn/README.md

@@ -0,0 +1,128 @@
+# LapSRN x4
+
+Single-image super-resolution with a Laplacian Pyramid Super-Resolution Network. One forward
+pass produces both a 2x and a 4x image, because the pyramid reconstructs each scale from the
+previous one and both intermediate results are exposed as outputs.
+
+The model was originally distributed as a frozen TensorFlow graph (`LapSRN_x4.pb`, the model
+used by opencv_contrib's `dnn_superres` module) and converted to ONNX for use with OpenCV's
+DNN module.
+
+## Model Details
+- **Architecture**: LapSRN — Laplacian pyramid, progressive upsampling with `DepthToSpace`
+  and recursive residual blocks (24 `Conv`, 4 `DepthToSpace`)
+- **Input**: `IteratorGetNext:0`, **NHWC** `[1, H, W, 1]` — a single **luma (Y)** channel,
+  float32 normalized to `[0, 1]`. `H`/`W` are dynamic; the network is fully convolutional.
+- **Outputs** (both produced in one pass, NCHW):
+  - `NCHW_output_2x` — `[1, 1, H*2, W*2]`
+  - `NCHW_output_4x` — `[1, 1, H*4, W*4]`
+- **Framework**: ONNX (converted from the TensorFlow frozen graph via tf2onnx, opset 13)
+- **Original weights**: https://github.com/fannymonori/TF-LapSRN/tree/master/export
+- **Paper**: Lai, Huang, Ahuja, Yang, *Deep Laplacian Pyramid Networks for Fast and Accurate
+  Super-Resolution*, CVPR 2017 — https://arxiv.org/abs/1704.03915
+
+> **Note on layout.** The input is NHWC while the outputs are NCHW (hence their names). This
+> is not a mistake in the conversion — it is what `dnn_superres` feeds and reads, so the
+> conversion preserves it. Do not use `blobFromImage` here; it would produce NCHW input.
+
+### Colour handling
+
+The network only sees the Y channel. To get a colour image, the demos follow exactly what
+`dnn_superres` does (`preprocess_YCrCb` / `reconstruct_YCrCb`):
+
+1. Convert BGR to YCrCb, scale to float `[0, 1]`.
+2. Feed **only Y**, reshaped to `[1, H, W, 1]`.
+3. Bicubically upscale Cr and Cb by the same factor.
+4. Merge `(Y_hr, Cr_hr, Cb_hr)`, scale back to 8-bit, convert YCrCb to BGR.
+
+## Usage
+
+### Python
+```bash
+python demo.py --model lapsrn_x4_2026sep.onnx --image example_outputs/input_image.png --output-dir example_outputs
+```
+Writes `output_image_2x.png` and `output_image_4x.png`. Pass `--scale 2` or `--scale 4` to
+run just one head.
+
+### C++
+The C++ demo runs inference with OpenCV's DNN module (default engine — no ONNX Runtime
+needed). Adjust the OpenCV paths to your setup:
+```bash
+OCV=/path/to/opencv                          # OpenCV source tree
+OCVBUILD=/path/to/opencv/build               # OpenCV build directory (generated headers + libs)
+g++ -std=c++17 demo.cpp -o demo \
+  -I$OCV/include \
+  -I$OCV/modules/core/include \
+  -I$OCV/modules/dnn/include \
+  -I$OCV/modules/imgproc/include \
+  -I$OCV/modules/imgcodecs/include \
+  -I$OCVBUILD \
+  -L$OCVBUILD/lib -Wl,-rpath,$OCVBUILD/lib -lopencv_dnn -lopencv_imgcodecs -lopencv_imgproc -lopencv_core
+./demo --model lapsrn_x4_2026sep.onnx --image example_outputs/input_image.png --output-dir example_outputs
+```
+
+The Python and C++ demos agree to within 1–2 intensity levels on under 1% of pixels — NumPy
+and OpenCV break rounding ties differently, which the YCrCb to BGR conversion mildly amplifies.
+
+### With the dnn_superres module
+
+This is the same file the module's own test loads, so it also works through the module API:
+
+```cpp
+DnnSuperResImpl sr;
+sr.readModel("lapsrn_x4_2026sep.onnx");
+sr.setModel("lapsrn", 4);
+
+std::vector<Mat> outputs;
+sr.upsampleMultioutput(img, outputs, {2, 4}, {"NCHW_output_2x", "NCHW_output_4x"});
+```
+
+## Conversion
+
+Exported from the frozen TensorFlow graph with tf2onnx (opset 13) via
+[convert_to_onnx.py](./convert_to_onnx.py). Requires `tensorflow`, `tf2onnx` and `onnx`.
+
+```bash
+python convert_to_onnx.py --pb LapSRN_x4.pb
+```
+
+Three details are specific to this model and are handled by the script:
+
+- **The weights are stored quantized and have to be folded back to float.** The frozen graph
+  went through TensorFlow's `quantize_weights` transform, so each of the 20 weight tensors is
+  a `quint8` const plus a min/max pair, reconstituted at runtime by a `Dequantize` node in
+  `MIN_FIRST` mode. tf2onnx has no mapping for `Dequantize`, so the script evaluates those
+  nodes in a TF session and rewrites each one as a plain float32 const. This is why the ONNX
+  (2.7 MB) is about 4x the size of the frozen graph (703 KB).
+- **The graph is pruned to the two heads that are used.** The frozen graph carries a third
+  head, `NCHW_output`, that nothing reads. `extract_sub_graph` on `NCHW_output_2x` /
+  `NCHW_output_4x` drops it — that head and its `perm` const are the only two nodes removed,
+  so no compute changes (329 to 327 nodes).
+- **The output names are stripped of their `:0` suffix.** tf2onnx names ONNX outputs after TF
+  tensors, so the heads come out as `NCHW_output_2x:0`, and
+  `net.forward("NCHW_output_2x")` cannot resolve that. The script renames them after
+  conversion.
+
+Note that `shape_override` uses `None`, not `-1`, for the dynamic H/W dims: the frozen graph's
+placeholder has unknown rank, and tf2onnx's shape inference passes the override straight to
+`set_shape`, which rejects `-1`.
+
+Re-running the script on `LapSRN_x4.pb` reproduces the shipped model: same opset, node count
+and initializers, and **bit-identical inference output**. The only differences are tf2onnx's
+auto-generated constant names (`const_fold_opt__611` and friends), whose numbering depends on
+graph traversal order.
+
+The input is deliberately left NHWC — `--inputs-as-nchw` is *not* used here, unlike the other
+`dnn_superres` conversions.
+
+## Example
+
+| | |
+|---|---|
+| `example_outputs/input_image.png` | 256x256 (`butterfly.png`, the `dnn_superres` test image) |
+| `example_outputs/output_image_2x.png` | 512x512, from `NCHW_output_2x` |
+| `example_outputs/output_image_4x.png` | 1024x1024, from `NCHW_output_4x` |
+
+## License
+See [LICENSE](./LICENSE) — the model is released by the TF-LapSRN author under the
+Apache License 2.0.

lapsrn/convert_to_onnx.py

@@ -0,0 +1,134 @@
+"""Export the dnn_superres LapSRN_x4 TensorFlow frozen graph to ONNX.
+
+Three things make this model different from the other dnn_superres conversions:
+
+1. Its weights are stored quantized. The graph was run through TensorFlow's
+   `quantize_weights` transform, so every weight is a `quint8` const plus a
+   min/max pair, reconstituted at runtime by a `Dequantize` node (MIN_FIRST).
+   tf2onnx has no mapping for `Dequantize`, so the 20 of them are constant-folded
+   back to float32 consts before conversion. This is why the ONNX (2.7 MB) is
+   roughly 4x the size of the frozen graph (703 KB).
+
+2. The graph carries a third output head, `NCHW_output`, that nothing uses.
+   Pruning to the 2x and 4x heads drops it (it and its `perm` const are the only
+   two nodes removed - no compute changes).
+
+3. tf2onnx names ONNX outputs after TF tensors, so the heads come out as
+   `NCHW_output_2x:0`. OpenCV's `net.forward("NCHW_output_2x")` cannot resolve a
+   name with the trailing `:0`, so the graph outputs are renamed afterwards.
+
+The input is deliberately left in NHWC `[1, H, W, 1]` (no `--inputs-as-nchw`):
+that is what dnn_superres feeds, and the outputs are NCHW regardless.
+
+Requires `tensorflow`, `tf2onnx` and `onnx`.
+"""
+
+import argparse
+import datetime
+
+import onnx
+import tensorflow as tf
+import tf2onnx
+from tensorflow.core.framework import attr_value_pb2, graph_pb2, node_def_pb2
+
+INPUT_TENSOR = "IteratorGetNext:0"
+OUTPUT_NODES = ["NCHW_output_2x", "NCHW_output_4x"]
+
+
+def load_graph_def(pb_path):
+    with tf.io.gfile.GFile(pb_path, "rb") as f:
+        graph_def = tf.compat.v1.GraphDef()
+        graph_def.ParseFromString(f.read())
+    return graph_def
+
+
+def fold_dequantize(graph_def):
+    """Replace every Dequantize node with a plain float32 Const of its value.
+
+    The quint8 weight consts and their min/max pairs become unreferenced and are
+    dropped, so the returned graph is one tf2onnx can handle.
+    """
+    names = [n.name for n in graph_def.node if n.op == "Dequantize"]
+    if not names:
+        return graph_def
+
+    graph = tf.Graph()
+    with graph.as_default():
+        tf.import_graph_def(graph_def, name="")
+    with tf.compat.v1.Session(graph=graph) as sess:
+        values = sess.run(["%s:0" % n for n in names])
+    folded = dict(zip(names, values))
+
+    out = graph_pb2.GraphDef()
+    out.versions.CopyFrom(graph_def.versions)
+    for node in graph_def.node:
+        if node.name not in folded:
+            out.node.append(node)
+            continue
+        value = folded[node.name]
+        const = node_def_pb2.NodeDef()
+        const.name = node.name
+        const.op = "Const"
+        const.attr["dtype"].CopyFrom(attr_value_pb2.AttrValue(type=tf.float32.as_datatype_enum))
+        const.attr["value"].CopyFrom(attr_value_pb2.AttrValue(
+            tensor=tf.make_tensor_proto(value, dtype=tf.float32, shape=value.shape)))
+        out.node.append(const)
+
+    # Pruning again drops the now-orphaned *_quantized_const / _min / _max nodes.
+    return tf.compat.v1.graph_util.extract_sub_graph(out, OUTPUT_NODES)
+
+
+def strip_output_suffix(model_proto):
+    """Rename `NCHW_output_2x:0` -> `NCHW_output_2x` so net.forward() can find it."""
+    renames = {o.name: o.name.rsplit(":", 1)[0] for o in model_proto.graph.output if ":" in o.name}
+    if not renames:
+        return
+    for out in model_proto.graph.output:
+        out.name = renames.get(out.name, out.name)
+    for node in model_proto.graph.node:
+        for i, name in enumerate(node.output):
+            if name in renames:
+                node.output[i] = renames[name]
+        for i, name in enumerate(node.input):
+            if name in renames:
+                node.input[i] = renames[name]
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Export LapSRN_x4.pb to ONNX")
+    parser.add_argument("--pb", default="LapSRN_x4.pb")
+    parser.add_argument("--opset", type=int, default=13)
+    args = parser.parse_args()
+
+    graph_def = load_graph_def(args.pb)
+
+    # Drop the unused NCHW_output head, then de-quantize the weights.
+    graph_def = tf.compat.v1.graph_util.extract_sub_graph(graph_def, OUTPUT_NODES)
+    graph_def = fold_dequantize(graph_def)
+
+    left = [n.name for n in graph_def.node if n.op == "Dequantize"]
+    if left:
+        raise SystemExit("Dequantize nodes survived folding: %s" % ", ".join(left))
+
+    model_proto, _ = tf2onnx.convert.from_graph_def(
+        graph_def,
+        input_names=[INPUT_TENSOR],
+        output_names=["%s:0" % n for n in OUTPUT_NODES],
+        opset=args.opset,
+        # Dynamic H/W: the model is fully convolutional, any input size works.
+        shape_override={INPUT_TENSOR: [1, None, None, 1]},
+    )
+
+    strip_output_suffix(model_proto)
+    onnx.checker.check_model(model_proto)
+
+    stamp = datetime.datetime.now().strftime("%Y%b").lower()
+    onnx_path = "lapsrn_x4_%s.onnx" % stamp
+    with open(onnx_path, "wb") as f:
+        f.write(model_proto.SerializeToString())
+    print("wrote", onnx_path)
+    print("outputs", [o.name for o in model_proto.graph.output])
+
+
+if __name__ == "__main__":
+    main()

lapsrn/demo.cpp

@@ -0,0 +1,83 @@
+#include <opencv2/dnn.hpp>
+#include <opencv2/imgproc.hpp>
+#include <opencv2/imgcodecs.hpp>
+#include <iostream>
+#include <string>
+#include <vector>
+
+static std::string argVal(int argc, char** argv, const std::string& key, const std::string& def)
+{
+    for (int i = 1; i + 1 < argc; ++i)
+        if (key == argv[i]) return argv[i + 1];
+    return def;
+}
+
+// Run one pyramid head and rebuild a colour image from its luma output.
+// Mirrors dnn_superres' preprocess_YCrCb / reconstruct_YCrCb: the network only
+// ever sees the Y channel, and Cr/Cb are bicubically upscaled and merged back.
+static cv::Mat upsample(cv::dnn::Net& net, const cv::Mat& img, const std::string& nodeName, int scale)
+{
+    cv::Mat ycrcb;
+    cv::cvtColor(img, ycrcb, cv::COLOR_BGR2YCrCb);
+    ycrcb.convertTo(ycrcb, CV_32F, 1.0 / 255.0);
+
+    cv::Mat ch[3];
+    cv::split(ycrcb, ch);
+    cv::Mat Y = ch[0];
+    if (!Y.isContinuous()) Y = Y.clone();
+
+    // This model takes NHWC [1, H, W, 1] even though its outputs are NCHW.
+    int blobShape[] = {1, Y.rows, Y.cols, 1};
+    cv::Mat blob(4, blobShape, CV_32F, Y.data);
+
+    net.setInput(blob);
+    cv::Mat outBlob = net.forward(nodeName);
+
+    // Output blob is NCHW [1, 1, H*scale, W*scale] -> wrap as a single-channel Mat.
+    cv::Mat yHr(outBlob.size[2], outBlob.size[3], CV_32F, outBlob.ptr<float>());
+
+    cv::Mat crHr, cbHr;
+    cv::resize(ch[1], crHr, cv::Size(), scale, scale);
+    cv::resize(ch[2], cbHr, cv::Size(), scale, scale);
+
+    std::vector<cv::Mat> merged = {yHr, crHr, cbHr};
+    cv::Mat hr;
+    cv::merge(merged, hr);
+    hr.convertTo(hr, CV_8U, 255.0);
+    cv::cvtColor(hr, hr, cv::COLOR_YCrCb2BGR);
+    return hr;
+}
+
+int main(int argc, char** argv)
+{
+    std::string model     = argVal(argc, argv, "--model",      "lapsrn_x4_2026sep.onnx");
+    std::string image     = argVal(argc, argv, "--image",      "example_outputs/input_image.png");
+    std::string outputDir = argVal(argc, argv, "--output-dir", "example_outputs");
+
+    cv::Mat img = cv::imread(image);
+    if (img.empty())
+    {
+        std::cerr << "could not read image: " << image << std::endl;
+        return 1;
+    }
+
+    cv::dnn::Net net = cv::dnn::readNetFromONNX(model);
+
+    // The two heads of the Laplacian pyramid, and the scale each one produces.
+    const std::vector<std::pair<std::string, int> > outputs =
+        {{"NCHW_output_2x", 2}, {"NCHW_output_4x", 4}};
+
+    std::cout << "lapsrn_x4 input " << img.cols << "x" << img.rows << std::endl;
+    for (size_t i = 0; i < outputs.size(); ++i)
+    {
+        const std::string& nodeName = outputs[i].first;
+        int scale = outputs[i].second;
+
+        cv::Mat hr = upsample(net, img, nodeName, scale);
+        std::string path = cv::format("%s/output_image_%dx.png", outputDir.c_str(), scale);
+        cv::imwrite(path, hr);
+        std::cout << "  " << nodeName << " x" << scale
+                  << " -> " << hr.cols << "x" << hr.rows << "  " << path << std::endl;
+    }
+    return 0;
+}

lapsrn/demo.py

@@ -0,0 +1,60 @@
+import argparse
+import os
+
+import cv2 as cv
+import numpy as np
+
+here = os.path.dirname(os.path.abspath(__file__))
+
+# The two heads of the Laplacian pyramid, and the scale each one produces.
+OUTPUTS = [("NCHW_output_2x", 2), ("NCHW_output_4x", 4)]
+
+
+def upsample(net, img, node_name, scale):
+    """Run one pyramid head and rebuild a colour image from its luma output.
+
+    Mirrors dnn_superres' preprocess_YCrCb / reconstruct_YCrCb: the network only
+    ever sees the Y channel, and Cr/Cb are bicubically upscaled and merged back.
+    """
+    ycrcb = cv.cvtColor(img, cv.COLOR_BGR2YCrCb).astype(np.float32) / 255.0
+    y, cr, cb = cv.split(ycrcb)
+
+    # This model takes NHWC [1, H, W, 1] even though its outputs are NCHW.
+    net.setInput(y.reshape(1, y.shape[0], y.shape[1], 1))
+    y_hr = net.forward(node_name)[0, 0]
+
+    cr_hr = cv.resize(cr, None, fx=scale, fy=scale)
+    cb_hr = cv.resize(cb, None, fx=scale, fy=scale)
+
+    merged = cv.merge([y_hr, cr_hr, cb_hr])
+    # np.rint, not a plain cast: convertTo(CV_8U) rounds, and truncating here
+    # would drift from the C++ demo by a few levels after YCrCb -> BGR.
+    merged_8u = np.rint(merged * 255.0).clip(0, 255).astype(np.uint8)
+    return cv.cvtColor(merged_8u, cv.COLOR_YCrCb2BGR)
+
+
+def main():
+    parser = argparse.ArgumentParser(description="LapSRN x4 super-resolution (ONNX) demo")
+    parser.add_argument("--model", default=os.path.join(here, "lapsrn_x4_2026sep.onnx"))
+    parser.add_argument("--image", default=os.path.join(here, "example_outputs", "input_image.png"))
+    parser.add_argument("--output-dir", default=os.path.join(here, "example_outputs"))
+    parser.add_argument("--scale", type=int, choices=[2, 4], help="only run this scale (default: both)")
+    args = parser.parse_args()
+
+    img = cv.imread(args.image)
+    if img is None:
+        raise SystemExit("could not read image: %s" % args.image)
+
+    net = cv.dnn.readNetFromONNX(args.model)
+
+    wanted = [(n, s) for n, s in OUTPUTS if args.scale in (None, s)]
+    print("lapsrn_x4 input %dx%d" % (img.shape[1], img.shape[0]))
+    for node_name, scale in wanted:
+        out = upsample(net, img, node_name, scale)
+        path = os.path.join(args.output_dir, "output_image_%dx.png" % scale)
+        cv.imwrite(path, out)
+        print("  %-16s x%d -> %dx%d  %s" % (node_name, scale, out.shape[1], out.shape[0], path))
+
+
+if __name__ == "__main__":
+    main()

lapsrn/lapsrn_x4_2026sep.onnx

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:70474758dab65ae3f488bed94b11b60fb77578f9de3d45a66d72263dcfefadb7
+size 2708806

macbeth_chart_detector/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

macbeth_chart_detector/README.md

@@ -0,0 +1,97 @@
+# Macbeth Chart Detector
+
+Detects a Macbeth / ColorChecker Classic colour chart in a photograph and returns its bounding
+box. This is the detection model used by OpenCV's `mcc` colour-correction code
+(`objdetect`, `checker_detector.cpp`) to locate a chart before reading its patches.
+
+The model is a Faster R-CNN with an Inception V2 backbone, trained as a single-class detector
+with the TensorFlow Object Detection API. It was originally distributed as a frozen TensorFlow
+graph (`frozen_inference_graph.pb`) and converted to ONNX for use with OpenCV's DNN module.
+
+## Model Details
+- **Architecture**: Faster R-CNN, Inception V2 backbone, one class (the chart)
+- **Input**: `image_tensor:0`, **NHWC** `[1, H, W, 3]`, **raw uint8 RGB** (0-255, no scaling and
+  no mean subtraction). `H`/`W` are dynamic — feed the image at its own resolution. The graph
+  resizes internally (keep aspect ratio, min side 768, max side 1024), so do not pre-resize,
+  and do not use `blobFromImage`: that produces NCHW.
+- **Outputs** (all four must be requested together):
+  - `detection_boxes:0` — `[1, 300, 4]`, normalized, **`[ymin, xmin, ymax, xmax]`** (y first)
+  - `detection_scores:0` — `[1, 300]`, descending
+  - `detection_classes:0` — `[1, 300]`, always `1.0` (single class, so it carries no information)
+  - `num_detections:0` — `[1]`
+- **Framework**: ONNX (converted from the TensorFlow frozen graph via tf2onnx, opset 18)
+- **Original weights**: [gursimarsingh/opencv_zoo @ `mcc_model`](https://github.com/gursimarsingh/opencv_zoo/tree/mcc_model/models/macbeth_chart_detector)
+  — `frozen_inference_graph.pb`, sha1 `fae7dbef14c4ae1fca76f3662220fbd460ed5ed6`
+
+> **`num_detections` is not a detection count.** It reports the post-NMS slot count — 100 on the
+> example image, where exactly one chart is present. Threshold on `detection_scores` instead;
+> iterating `num_detections` yields 99 phantom boxes.
+
+## Usage
+
+### Python
+```bash
+python demo.py --model macbeth_chart_detector_2026sep.onnx --image example_outputs/input_image.png --output example_outputs/output_image.png --conf 0.3
+```
+
+On the provided `example_outputs/input_image.png` (900x463) it reports one detection:
+
+```
+macbeth_chart_detector 1 detections
+  0.582  x1=237 y1=79 x2=650 y2=368
+```
+
+`demo.py` requires OpenCV 5.1 or newer, for `cv.dnn.ENGINE_OPENCV`. On OpenCV 5.0 that constant
+does not exist (it has `ENGINE_CLASSIC` / `ENGINE_NEW`); drop the second argument to
+`readNetFromONNX` to use the default engine instead.
+
+## Conversion
+
+Exported from the frozen TensorFlow graph with tf2onnx (opset 18) via
+[convert_to_onnx.py](./convert_to_onnx.py) — input `image_tensor:0`, outputs
+`detection_boxes:0`, `detection_scores:0`, `detection_classes:0`, `num_detections:0`.
+Requires `tensorflow`, `tf2onnx` and `onnx`.
+
+```bash
+python convert_to_onnx.py --pb frozen_inference_graph.pb
+```
+
+The graph needs no special handling: its weights are plain float32 (no `quantize_weights` /
+`Dequantize` nodes) and all four detection heads are present in the frozen graph.
+
+### Conversion accuracy
+
+Verified against the original `.pb` under TensorFlow 2.15.1, feeding both the identical uint8
+buffer:
+
+| | top score | box |
+|---|---|---|
+| TensorFlow `.pb` | 0.582205 | `0.171078 0.263475 0.794357 0.721806` |
+| ONNX (onnxruntime) | 0.582205 | `0.171078 0.263475 0.794356 0.721806` |
+
+The conversion is faithful to within one float32 ULP.
+
+## Known issue: OpenCV's DNN engine
+
+The conversion is correct, but **OpenCV's built-in DNN engine cannot currently run this model.**
+On OpenCV 5.0.0 it aborts before producing output:
+
+```
+net_impl2.cpp: (-215:Assertion failed) buf.shape() == m.shape() in function 'forwardGraph'
+```
+
+The same failure affects the other converted Faster R-CNN / Mask R-CNN models in this
+repository, so it is a limitation of the engine's handling of these graphs rather than
+something specific to this model. On builds where the graph does run, the score comes out
+around 0.02 instead of 0.582, because `Resize` with
+`coordinate_transformation_mode="tf_crop_and_resize"` and a dynamic ROI — the ROI-pooling step
+of the second stage — is not evaluated correctly, so every region proposal is classified from
+the wrong features.
+
+Until that is fixed in `modules/dnn`, treat the ONNX file as correct (onnxruntime and
+TensorFlow agree exactly) and the OpenCV-engine results as unreliable.
+
+## License
+See [LICENSE](./LICENSE) — Apache License 2.0, taken from the upstream
+[opencv_zoo](https://github.com/gursimarsingh/opencv_zoo) repository that distributes the
+original frozen graph.

macbeth_chart_detector/convert_to_onnx.py

@@ -0,0 +1,40 @@
+import argparse
+import datetime
+
+import onnx
+import tensorflow as tf
+import tf2onnx
+
+
+def load_graph_def(pb_path):
+    with tf.io.gfile.GFile(pb_path, "rb") as f:
+        graph_def = tf.compat.v1.GraphDef()
+        graph_def.ParseFromString(f.read())
+    return graph_def
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Export the Macbeth chart detector frozen graph to ONNX")
+    parser.add_argument("--pb", default="../pb/frozen_inference_graph.pb")
+    parser.add_argument("--opset", type=int, default=18)
+    args = parser.parse_args()
+
+    graph_def = load_graph_def(args.pb)
+
+    model_proto, _ = tf2onnx.convert.from_graph_def(
+        graph_def,
+        input_names=["image_tensor:0"],
+        output_names=["detection_boxes:0", "detection_scores:0", "detection_classes:0", "num_detections:0"],
+        opset=args.opset,
+    )
+    onnx.checker.check_model(model_proto)
+
+    stamp = datetime.datetime.now().strftime("%Y%b").lower()
+    onnx_path = "macbeth_chart_detector_%s.onnx" % stamp
+    with open(onnx_path, "wb") as f:
+        f.write(model_proto.SerializeToString())
+    print("wrote", onnx_path)
+
+
+if __name__ == "__main__":
+    main()

macbeth_chart_detector/demo.py

@@ -0,0 +1,59 @@
+import argparse
+import os
+
+import cv2 as cv
+import numpy as np
+
+here = os.path.dirname(os.path.abspath(__file__))
+
+# TF Object Detection API heads, in the order the graph declares them.
+OUTPUTS = ["detection_boxes:0", "detection_scores:0", "detection_classes:0", "num_detections:0"]
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Macbeth colour chart detection (ONNX) demo")
+    parser.add_argument("--model", default=os.path.join(here, "macbeth_chart_detector_2026sep.onnx"))
+    parser.add_argument("--image", default=os.path.join(here, "example_outputs", "input_image.png"))
+    parser.add_argument("--output", default=os.path.join(here, "example_outputs", "output_image.png"))
+    parser.add_argument("--conf", type=float, default=0.3, help="confidence threshold")
+    args = parser.parse_args()
+
+    img = cv.imread(args.image)
+    if img is None:
+        raise SystemExit("could not read image: %s" % args.image)
+
+    # The network takes raw uint8 RGB in NHWC layout at the image's own resolution:
+    # the graph resizes internally (keep-aspect-ratio, min side 768 / max side 1024),
+    # so do not pre-resize and do not use blobFromImage (that would give NCHW).
+    blob = cv.cvtColor(img, cv.COLOR_BGR2RGB)[None]
+
+    net = cv.dnn.readNetFromONNX(args.model, cv.dnn.ENGINE_OPENCV)
+    net.setInput(blob)
+    boxes, scores, _classes, _num = net.forward(OUTPUTS)
+
+    boxes = boxes.reshape(-1, 4)
+    scores = scores.reshape(-1)
+
+    # Threshold on the scores rather than on num_detections: that head reports the
+    # post-NMS slot count (100), not the number of charts actually found. The single
+    # class is the chart itself, so detection_classes carries no information here.
+    keep = np.nonzero(scores >= args.conf)[0]
+
+    h, w = img.shape[:2]
+    out = img.copy()
+    print("macbeth_chart_detector", len(keep), "detections")
+    for i in keep:
+        ymin, xmin, ymax, xmax = boxes[i]          # normalized, y first
+        p1 = (int(round(xmin * w)), int(round(ymin * h)))
+        p2 = (int(round(xmax * w)), int(round(ymax * h)))
+        cv.rectangle(out, p1, p2, (0, 255, 0), 2)
+        cv.putText(out, "chart %.2f" % scores[i], (p1[0], max(0, p1[1] - 5)),
+                   cv.FONT_HERSHEY_SIMPLEX, 0.6, (0, 255, 0), 2)
+        print("  %.3f  x1=%d y1=%d x2=%d y2=%d" % (scores[i], p1[0], p1[1], p2[0], p2[1]))
+
+    cv.imwrite(args.output, out)
+    print("wrote", args.output)
+
+
+if __name__ == "__main__":
+    main()

macbeth_chart_detector/macbeth_chart_detector_2026sep.onnx

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:356587d28bcea41d188a743b38f86e2c744fd892e3d41512b6a42b6af038f249
+size 51756941