kornia-rs

First stable 0.1.15. Everything in the 0.1.15-rc.* entries below ships here,
plus the following changes since rc.5.

Security hardening across the workspace. A repo-wide audit fixed
memory-safety bugs that untrusted input could reach, each with a regression
test; upgrading is recommended for anyone decoding untrusted images or files.

• AprilTag detection: heap overflow in the RLE run buffer on images with
  1-pixel stripes.
• kornia-bow: out-of-bounds read and unbounded allocation from crafted
  vocabulary files; cyclic vocabularies no longer hang traversal.
• kornia-tensor / kornia-image: shape and size arithmetic is checked
  everywhere; serde/bincode and Arrow imports validate layouts;
  permute_axes rejects non-permutations; sum_elements no longer writes out
  of bounds on strided tensors.
• kornia-imgproc: out-of-bounds reads/writes in normalize_rgb_u8,
  warp_affine_u8/warp_perspective_u8 (CPU and the CUDA affine kernel),
  f32 remap/interpolate_pixel, and the nearest/bicubic resize row
  kernels; a data race in Canny's parallel hysteresis; panics on empty images
  and oversized kernels.
• kornia-io: decoders cap declared images at 2^30 pixels and allocate
  fallibly (decompression bombs no longer abort the process); PNG/TIFF reject
  mismatched bit depth / channel counts; GStreamer URLs, device paths and file
  paths can no longer inject pipeline elements (file locations are set as
  element properties, so Windows paths work); V4L2 never re-queues a buffer a
  live frame still references.
• Python bindings: non-contiguous or misaligned numpy arrays, size overflow in
  resize_normalize_to_tensor, uninitialised YUV decoder output, read-only or
  aliased out= arrays, and a DLPack import leak are fixed.
• C++ bindings: overflow-checked dimensions and null-pointer checks at the FFI
  boundary.
• CI and supply chain: actions pinned to commit SHAs, read-only default
  workflow token, release jobs gated behind pypi / crates-io environments,
  a weekly cargo audit job, and SECURITY.md with a private reporting
  channel.

Breaking (security-related): Tensor::get_unchecked /
TensorView::get_unchecked are now unsafe fn; permute_axes,
as_contiguous and TensorStorage::layout return Result; from_raw_parts
and TryFrom<Tensor3> for Image reject mismatched layouts; Arrow imports are
read-only; the GStreamer *_pipeline_description helpers return Result;
several error enums gained variants; f32 remap zero-fills out-of-range
samples.

Stereo rectification runs on CUDA, byte-exact with the CPU path.
StereoRectifier now resamples through the residency-dispatched remap_u8, and
StereoRectifier::to_cuda(&stream) returns a CudaStereoRectifier that keeps
both eyes' maps device-resident and rectifies device frames zero-copy via
rectify_left_device/rectify_right_device. The two
backends produce identical bytes by kornia-imgproc's tested CPU↔CUDA contract,
so demoting to CPU on a CUDA failure is lossless. Border semantics changed
deliberately with the unification: source coordinates in the [w-1, w) band now
clamp-sample the edge texel (previously black; exactly w-1 sampled the edge under
both), and blending is Q10 fixed point.

Breaking: StereoRectifier::rectify_left/right are now into-style —
(&self, src, &mut dst) -> Result<(), StereoError> — matching imgproc's into-style convention;
left_map()/right_map() became left_maps()/right_maps() returning the x/y
planes remap_u8 consumes directly.

CUDA and NEON SIFT, bit-exact with cv::SIFT. Scale space, detection,
orientation and descriptors reproduce OpenCV bit-for-bit on CPU (NEON) and
CUDA, with deterministic keypoint and matcher output order; the vertical blur
is register-tiled and descriptor atomics are warp-aggregated.

kornia-calib: multi-camera extrinsic calibration. New crate calibrating a
rig from an AprilTag grid plus optional natural-feature tracks via bundle
adjustment, now publishable (planar pose moved to
kornia_3d::pose::planar). It returns the full reconstruction, bundle-adjusts
during incremental growth, picks the bootstrap pair on geometry, filters
outlier observations, and supports depth/orientation/motion priors and a
sequential() preset for video capture. Breaking:
ReconstructionConfig is split out of CalibConfig.

Bundle adjustment and pose. The Schur BA gains intrinsics (radial term,
free focal and k1), a block-sparse reduced camera system, orientation and
constant-velocity priors, and per-phase instrumentation; PnP refinement
supports robust (Huber) losses, and RANSAC gains SPRT early rejection
(use_sprt in Python). Sim3::exp/log are now true inverses.

CUDA remap and new filters. remap (f32 and u8) dispatches to CUDA when
images and maps are device-resident; Laplacian and integral-image filters run
on CPU and GPU; OpenCV parity checks now cover resize, warp-affine and
morphology on CUDA.

Tensors and memory. Element-wise and reduction ops dispatch on
MemoryDomain (CPU/GPU); UnifiedResource / CudaUnifiedAllocator add CUDA
managed memory and PinnedWcAllocator write-combined pinned host memory for
CPU→GPU streaming; tensors and images can borrow host buffers zero-copy.

I/O. RVL gains its run-length phase (5.7× instead of 3.0× compression on
live depth), a temporal-delta variant (RVLD) and a slice encoder; zero-copy
slice encoders for turbojpeg RGB and gray16 PNG.

Python. Windows ARM64 wheels; histogram, colour-check and pyramid APIs
filled in.

Full changelog: v0.1.14...v0.1.15

Connected components 3-5x faster on CPU, ~2x on GPU. The CPU path
now indexes its union-find by run id instead of pixel index (tables stay
cache-resident rather than costing two full-image allocations per call)
and scans rows with u64 word tricks that skip 8 background/foreground
pixels per step; the CUDA path replaces the serial 1-thread-per-row init
with a block-parallel ballot/shared-scan run-start kernel, a
warp-shuffle compaction scan, and a u16 rank array. 1080p,
stream-synchronized, labels still exactly equal to cv2's CCL_WU
(SAUF): CPU 4.9-6.1 ms → 0.67-1.40 ms — now faster than OpenCV's
default (Spaghetti) algorithm on every tested content/connectivity
(1.1-2.2x); GPU 2.5-3.0 ms → 1.09-1.60 ms — faster than or tied with
cv2's default except many-small-components 8-connectivity content
(0.82x), where Spaghetti's specialized decision tree still wins against
the fixed 5-kernel pipeline cost. VPI has no CCL op.

CUDA module cleanup + faster pyramid borders. The per-module CUDA
error enums and check_slice/get_kernel helpers of the newer kernel
families (histogram, CLAHE, bilateral, median, Canny, CCL) are now
generated from one shared definition (public error types unchanged), and
the pyramid kernels use a single-fold reflect_101 variant for their
±2-tap borders instead of the integer-modulo form — 1080p u8 pyrdown
0.62 → 0.44 ms, bit-exactness pinned by the existing parity suites.

cuda-fusion example + docs. New runnable example
(examples/cuda_fusion) showing the kernel-fusion API (build/exec model
borrowed from the Fused Kernel Library; scoped to linear per-pixel
transform chains — documented explicitly as narrower than FKL):
composing the DNN-preprocess chain and a novel resize→normalize→gray
chain from the stage library, printing the generated CUDA source, and a
sustained benchmark (~0.13 ms/frame, 1080p → 640×640 CHW on Orin). The
README documents pipeline composition, batching, the custom-FusedStage
recipe, and the f32-intermediate precision contract.

Connected-component labeling (CPU and CUDA), label-exact with OpenCV's
SAUF. New connected_components for u8 single-channel masks
(kornia_rs.imgproc.connected_components in Python, returning
(n, labels) with int32 labels), matching
cv2.connectedComponentsWithAlgorithm(..., cv2.CCL_WU) label-for-label:
background 0, components numbered in raster order of first appearance,
for both 4- and 8-connectivity. (cv2's default 8-way algorithm, BBDT,
produces the same partition with a different numbering.) The CPU path is
a run-based min-index union-find; the CUDA path is an atomicMin
label-equivalence fixpoint with row-run initialization plus a device
compaction — device labels are identical to the CPU's; the union phase
is a single lock-free pass (Komura atomicMin-with-retry union, atomic
path halving), no iteration loop. Python Image gains int32 (label map)
dtype support. Measured 1080p: GPU 4.3 ms vs cv2 5.8 ms on dense 40%
noise (1.3×); sparse-blob content is fixed-overhead-bound (task #38
tracks the block-local rewrite). CPU is a stripe-parallel run-based
union-find (~22 ms dense; SAUF two-pass is the same follow-up).

Canny edge detection (CPU and CUDA), byte-for-byte with OpenCV. New
canny for u8 single-channel images (kornia_rs.imgproc.canny in
Python), matching cv2.Canny exactly — the all-integer pipeline (Sobel
3×3 CV_16S replicate-border gradients, L1/L2 magnitude with cv2's
threshold clamp-and-square rules, the fixed-point TG22 sector test with
cv2's exact per-sector tie-breaks, and hysteresis as pure reachability)
transcribes cv2's semantics, so CPU, GPU and cv2 agree on every byte.
CPU is NEON-vectorized end to end (separable Sobel, magnitude, a
branchless 4-lane NMS evaluating all three sector tests and selecting by
mask, map finalize) with hysteresis as a parallel tile-worklist flood
(round 1 floods from strong seeds, woken rounds re-scan only tile
boundary rings); the CUDA path runs fused sobel+magnitude, NMS, an
active-tile-worklist block-fixpoint hysteresis (blocks read-and-clear
their own worklist entries — no per-sweep buffer resets) and finalize.
(VPI's CUDA Canny uses a different algorithm — ~5% differing pixels vs
cv2, and its L2 threshold semantics diverge from the standard convention
— so it is not byte-comparable.) Measured 1080p under load: GPU
1.6–4.3 ms ≈ 2.1–2.6× cv2.Canny CPU; kornia CPU 3.4–5.7 ms ≈ 1.2–1.6×
cv2.

Median blur + bilateral filter (CPU and CUDA), byte-for-byte with
OpenCV — median also bit-identical to VPI. New median_blur (u8, 3×3
and 5×5, replicate borders, exact sorting-network medians — NEON on CPU,
register networks on CUDA; cv2.medianBlur and VPI's CUDA MedianFilter
agree bit-for-bit here, so kornia matches BOTH) and bilateral_filter
(u8 C1, cv2.bilateralFilter mirrored end to end: its own SIMD exp
polynomial for the color table, circular taps, reflect_101 borders, fma
accumulation — including cv2's different tap-summation order between its
16-pixel SIMD region and its scalar row tail; VPI's bilateral uses a
different formula and is not byte-comparable). CPU and GPU outputs are
byte-identical. The CPU paths are NEON-vectorized — 3×3 median via the
exact med3(max-lows, med-mids, min-highs) column identity with rolling
vext-shared column sorts and two output rows per pass; 5×5 via rolling
sorted columns feeding a 71-exchange selection network (derived from
Smith's 99 by greedy deletion, proven exact on the sorted-column input
subspace via the zero-one principle — pinned by a unit test over all 6^5
column-sorted 0-1 patterns); bilateral 16 lanes per tap — and beat
OpenCV's CPU on 5×5 median (1.15×) and bilateral (1.1×), with 3×3 median
at 0.77× (both sides at the DRAM wall). out= supported on the CPU
paths. Measured 1080p sustained (GPU, stream-synchronized): median3 0.31 ms
(1.1× cv2, 2.3× VPI), median5 1.18 ms (1.5× cv2, 1.1× VPI), bilateral
d=5 3.24 ms (2.9× cv2; VPI's non-comparable variant is faster).

CLAHE (CPU and CUDA), byte-for-byte with OpenCV. New clahe for u8
single-channel images (kornia_rs.imgproc.clahe in Python), matching
cv2.createCLAHE(clip, grid).apply() exactly — including OpenCV's
reflect_101 tile padding rule, integer clip limit with two-phase excess
redistribution, f32 LUT quantization (round-half-to-even) and the f32
bilinear blend of the four surrounding tile LUTs with the exact FMA
contraction OpenCV's aarch64 wheels compile to (calibrated empirically:
22 configurations, zero differing bytes). CPU and GPU outputs are
byte-identical (f32::mul_add / explicit fmaf, mirrored expression
trees). The CPU interpolation stage is NEON-vectorized with packed
per-span LUT tables (one gather per pixel; identical bytes, pure
access-pattern change). The Python binding takes out= on the CPU path.
Measured 1080p sustained (stream-synchronized): GPU 0.54 ms ≈ 7.1× and
CPU 1.9 ms ≈ 2.1× cv2.createCLAHE CPU (VPI has no CLAHE op).

GPU histogram + equalize_hist (CPU and CUDA), byte-for-byte with
OpenCV. New equalize_hist for u8 single-channel images on CPU and
device (kornia_rs.imgproc.equalize_hist in Python), matching
cv2.equalizeHist exactly — including its f32 round-half-to-even LUT
rounding and identity behavior on constant images. compute_histogram
now routes device images to a CUDA shared-memory-bins kernel whose counts
are exactly equal to the CPU's for any bin count. CPU and GPU equalize
outputs are byte-identical.

GPU Gaussian pyramids + PyramidPlan. pyrdown_f32 (one fused
5×5-Gaussian+subsample kernel), pyrup_f32 (polyphase pair), pyrdown_u8
and pyrup_u8 (separable [1,4,6,4,1] integer pairs) now route device
images to CUDA kernels that are bit-identical (f32) / byte-identical (u8)
to the CPU paths, including the reflect_101 borders and 1-pixel-wide
degenerate sources. PyramidPlan preallocates every level buffer so a
steady-state pyramid build launches kernels only (CUDA-Graph-capturable);
its levels are bit-identical to build_pyramid. Measured 1080p: pyrdown
u8 RGB 0.62 ms (4.1× OpenCV CPU), 4-level f32 plan 0.68 ms.

Faster Lanczos-3 warps on CUDA; sub-ULP output change in Lanczos warp/remap
sampling. The warp kernels now derive all six tap weights per axis from four
sin(πx) evaluations instead of twelve, using the sinc lattice's periodicity
(sin(π(frac+n)) = ±sin(π·frac)); the CPU sampler (lanczos_sample, used by
warp_affine/warp_perspective/remap with InterpolationMode::Lanczos) is
refactored identically, so CPU and GPU remain bit-exact to each other. Absolute
values shift by ≤1e-6 relative to previous releases (weights are identical in
real arithmetic, rounding differs). Measured on Jetson AGX Orin (locked
clocks, 1080p→1080p 3-channel f32): warp-affine lanczos 5.49→4.26 ms,
warp-perspective lanczos 5.93→4.28 ms sustained.

GPU separable filters: gaussian, box, sobel, scharr. New CUDA separable
engine (cuda/filter.rs) with residency dispatch on gaussian_blur,
box_blur, sobel, scharr (f32) and gaussian_blur_u8, box_blur_u8 —
f32 paths bit-identical to the CPU engine (skip-zero border, sequential
taps, fmad-free), u8 paths byte-identical to the Q8 striped blur (replicate
borders) and the 3×3 binomial fast path, with the u8 kernel/sigma routing
decided by one selector shared with the CPU. Python gaussian_blur /
box_blur accept device images; new imgproc.sobel (f32, numpy + device).
Measured 1080p vs OpenCV CPU: gaussian 5×5 u8 RGB 9.2×, box 5×5 9.5×,
sobel-3 f32 13×. The u8 binomial tails/edges now use the same nested
halving-add rounding as the SIMD bulk (≤1 LSB shift on border bytes vs
previous releases).

u8 color conversions are now byte-for-byte with OpenCV. Three alignments
(CPU and CUDA changed together, so device output stays assert_eq!-equal to
host): u8 grayscale now uses cv2's exact Q14 formula
((4899·R + 9617·G + 1868·B + 8192) >> 14; ±1 LSB vs previous releases);
yuv_from_rgb/rgb_from_yuv switch to the classic Y'UV chroma constants
cv2 and kornia-python use (0.492/0.877 forward, 1.140/2.032/−0.395/−0.581
inverse) instead of Cb/Cr in YUV order — a semantic change for chroma
values; and Bayer demosaic adopts cv2's border rule (the 1-px frame is the
interior neighbour's result). Verified byte-exact against cv2 for
yuv (both directions), bayer (all pixels), ycbcr, bgr, rgba and colormap;
gray matches cv2's documented formula exactly (cv2's own NEON build deviates
from its spec on ~0.25% of pixels). BGR/YCbCr/colormap already matched.

Python: every color conversion with a CUDA kernel now accepts a device
Image. Previously ~10 GPU color paths existed in the Rust crates but the
Python surface raised "no GPU kernel for a device Image": HLS, Luv, XYZ,
linear-RGB (f32 pairs), planar YUV (u8 and f32 pairs), plus the f32 arms
of YCbCr, sepia and gray (imgproc.gray_from_rgb on an f32 device image now
returns a device gray f32 image). u8 arms stay bit-exact with the CPU path;
f32 arms follow the existing tolerance contract. Covered by device-vs-CPU
parity tests and a memory-leak loop over the new arms.

u8 CUDA morphology (dilate / erode), bit-identical to the CPU ops, plus
first-time Python bindings. dilate / erode route u8 device images
(1/3/4-channel) to a CUDA kernel that samples the exact tap multiset the CPU
does — same active structuring-element offsets, same border index mapping
for all five padding modes — so min/max output is byte-for-byte equal
(assert_eq! parity tests over box/cross/ellipse and even-sized kernels).
The structuring element is cached on-device per geometry (Jetson pageable
H2D tail; warm path is CUDA-Graph-capturable). New
kornia_rs.imgproc.dilate / erode Python functions cover the numpy u8 CPU
path and u8 device images alike. Non-u8 device pairs error with the typed
no-GPU-kernel message instead of touching device memory from the CPU.

u8 CUDA warps (bilinear), bit-identical to the CPU fast paths — which are
now bit-identical to each other too. warp_affine_u8 and
warp_perspective_u8 route u8 device images (1/3/4-channel) to new
integer-only CUDA kernels that mirror the CPU's per-row span math and
Q16/Q10 fixed-point sampling exactly; kornia_rs.imgproc.warp_affine /
warp_perspective accept u8 device images including out=. Along the way
the CPU u8 perspective warp switched from incremental coordinate updates
(nx += dnx per column, with a SIMD reciprocal estimate) to direct
per-column evaluation with exact IEEE division — scalar, NEON, and AVX2 now
produce identical bytes instead of agreeing "up to sub-ULP noise". Output
shifts by at most one Q10 quantum on some pixels relative to earlier
releases; benchmarks show no measurable CPU cost (the division latency hides
behind the 4-lane structure).

u8 CUDA resize — every mode, bit-identical to the CPU fast paths. Camera
data is u8; until now the GPU only resized f32 (4× the memory traffic once you
count the conversion). resize_fast_u8_aa (Rust) and kornia_rs.imgproc.resize
(Python, including out=) now route u8 device images — 1/3/4-channel — to new
integer-only CUDA kernels covering the full CPU cascade: exact-2× pyramid fast
paths, nearest, Q14 bilinear, and antialiased/plain separable bicubic and
Lanczos-3. The coordinate and weight tables are built by the same host
functions the CPU uses and uploaded once per geometry (a device-side LUT
cache — Jetson pageable H2D uploads have a ~250 µs average latency tail that
otherwise dominates, and the warm path is CUDA-Graph-capturable), so device
output is byte-for-byte equal to host output (asserted with assert_eq!
across modes, channel counts, odd sizes, and extreme downscales). Measured on
Jetson Orin at 1080p→720p u8 RGB (median, out= reuse): nearest 0.22 ms,
bilinear 0.38 ms, bicubic 1.20 ms — faster than VPI-CUDA on every comparable
op (5.4× / 3.4× / 1.1×) and 3–6× ahead of OpenCV CPU. Kernel compile failures
now surface as errors instead of panics across all resize launchers.

Python: out= and CUDA Graphs for allocation-free frame loops. The device
geometry ops accept a preallocated device out= image (torch-style, returned
back); kornia_rs.cuda.Stream.new() creates a capturable non-default stream;
and kornia_rs.cuda.Graph.capture(f, retain, stream) records an
allocation-free op sequence for microsecond-overhead replay(). Measured on
Jetson Orin (1080p→720p f32 resize, per frame with sync): 1.31 ms → 0.62 ms
with out= on a created stream → 0.42 ms with graph replay — 20× the
naive pattern of two days ago, byte-exact output preserved through capture.

Jetson/CUDA: per-call device allocations no longer stall frame loops. The
default CUDA memory pool releases freed blocks back to the OS at every stream
synchronization (release threshold 0), so a per-frame op(); sync() pattern
re-paid the full allocation cost each frame — ~8.5 ms/frame of alloc/free churn
for 1080p f32 on Jetson Orin. kornia-tensor now raises the pool's release
threshold once per device at first allocation: the same loop drops to 1.3
ms/frame (and pipelined use improves 1.08 → 0.60 ms). Applies to every device
op (color conversions included).

Bicubic and Lanczos-3 for the f32 geometry ops, byte-exact CPU↔GPU.
resize, warp_affine, warp_perspective, and remap accept
InterpolationMode::Bicubic and ::Lanczos on the CPU, and device images
route to the previously launcher-only CUDA kernels — all six now reachable
from the public API, with bit-identical output between backends. Lanczos
weights use a shared deterministic sin(πx) polynomial (libm/CUDA sinf
rounding differs between platforms); resize-lanczos builds its per-axis weight
tables on the host once per call, shared verbatim with the GPU launcher —
which also made the GPU kernels up to 27% faster than the old __sinf path.
Hot-loop interpolation dispatch is hoisted per mode, making CPU f32 resize
~30% faster and warp-perspective ~7% faster than before.

Python: GPU resize and warps. kornia_rs.imgproc.resize / warp_affine /
warp_perspective now accept a device Image (f32, 3-channel) and run the
CUDA kernels, returning a device Image — output bit-identical to the CPU f32
path. numpy u8 inputs behave exactly as before; a device image with an
unsupported dtype/channel count raises instead of silently copying to the
host. out= is unsupported on the device path.

resize_native is renamed to resize (clean rename, no alias).

GPU resize and warps from the high-level API. resize (né resize_native),
warp_affine, and warp_perspective now run on the GPU when called with
device-resident images (Image::to_cuda / zeros_cuda), with bit-identical
output to the CPU path. Same rules as the color conversions: both operands
must be on the same device (mixed pairs are a typed error, no implicit
transfers), and unsupported dtype/channel combinations error instead of
silently falling back (the GPU kernels are 3-channel f32).

OpenCV-compatible resize (opt-in). New resize_opencv_u8 / resize_opencv_f32
reproduce OpenCV's reference INTER_LINEAR (u8: 11-bit fixed point; f32:
separable float) and floor-based INTER_NEAREST semantics, for migrating from
or cross-validating against cv2 pipelines. Validated against 72 reference
vectors generated by cv2.resize on Jetson Orin. Notable empirical finding
encoded in the tests: a shipped cv2 wheel is not internally byte-consistent for
INTER_LINEAR — the aarch64 wheel routes different channel counts and scales
through different backends (OpenCV, Carotene, Arm KleidiCV) whose bits disagree
with each other and with OpenCV's own reference arithmetic (u8 up to 2 LSB, f32
up to 3 ulp), so the tests assert exact bytes for nearest and a measured ≤2 LSB
/ ≤4 ulp corridor for linear; our reference arithmetic itself is pinned
byte-exactly by unit vectors.

CPU and CUDA warp-affine / warp-perspective are now byte-exact (f32,
bilinear + nearest): the CPU evaluates the source coordinate per pixel with the
same expression tree as the kernels (no more per-row accumulation drift), the
perspective kernels divide by w directly instead of multiplying by a
reciprocal, and the interpolation expression shapes match — parity tests assert
f32::to_bits equality on rotations, shears, and projective homographies.
Fixes a real GPU artifact along the way: cos(90°) is an ulp of noise rather
than zero, and the old strict border test zero-filled edge pixels of exact
right-angle rotations (splitting rows into half-warped, half-black); validity
of a near-constant axis is now judged on its row constant on both CPU and GPU.
No measured throughput change on Jetson Orin (CPU and GPU within run-to-run
jitter).

CPU and CUDA resize are now byte-exact. NVRTC kernels compile with
--fmad=false (no automatic FP contraction), and the resize coordinate and
bilinear arithmetic use the identical expression shapes on both sides, so
resize_native and the CUDA resize kernels produce bit-identical f32 output —
asserted by parity tests across dyadic and non-dyadic sizes. Kernels that want
fused multiply-adds keep them via explicit fmaf() (unaffected by the flag);
no measured throughput change on Jetson Orin. The bilinear_interpolation
restructure (weights formed before the tap products) shifts f32 bilinear
output by up to 1 ulp in every consumer — warp_perspective, remap, and
the optical-flow border path, not just resize.

BREAKING — resize_native now samples on the half-pixel grid. The f32
resize previously used align-corners (sx = x * (src-1)/(dst-1)); it now uses
the pixel-center convention (sx = (x + 0.5) * src/dst - 0.5) shared by
OpenCV, Pillow, ONNX Resize (half_pixel default), PyTorch
(align_corners=False), and NVIDIA VPI. Pixel values change for every
non-identity resize — typically a sub-pixel content shift. The u8 fast paths
(resize_fast_*) are unaffected. This also makes the CPU and CUDA resize
sample the same grid (resize_native was the sole align-corners holdout —
the fused CPU preprocess path and the CUDA kernels already sampled
half-pixel), and CPU/GPU parity is now tested.

• kornia_imgproc::cuda::resize: launchers take a new PixelMapping
  parameter (HalfPixel — the default convention — or AlignCorners to
  reproduce pre-change output); kernels generalized to per-axis affine
  coefficients with no measured throughput change on Jetson Orin.

GPU/CUDA wheels. pip install --pre kornia-rs now ships the kornia_rs.cuda module on Linux. Universal wheel: runs on CPU when no GPU, activates CUDA at runtime when an NVIDIA driver + nvrtc are present. See the README GPU/CUDA section for the API + runtime requirements.

Verified on Jetson Orin: kr.cuda.is_available() → True, GPU gray_from_rgb matches CPU exactly.

Install

pip install --pre kornia-rs
cargo add kornia-imgproc@0.1.15-rc.4

Full changelog: v0.1.15-rc.3...v0.1.15-rc.4

Two fixes on top of rc.2:

• #985 AprilTag adaptive-threshold white bias — small/glary Tag36H11 markers decode.
• #979 CUDA texture-object warp-affine kernels — border-mode cuts warp divergence on rotated images.

Try it: cargo add kornia-imgproc@0.1.15-rc.3 · pip install --pre kornia-rs

Full changelog: v0.1.15-rc.2...v0.1.15-rc.3

First pre-release since 0.1.14. Try before stable 0.1.15: cargo add kornia-imgproc@0.1.15-rc.1 · pip install --pre kornia-rs

CUDA / GPU

• CUDA color conversions — residency-aware dispatch, fused camera preprocessing, faster than OpenCV + VPI (#966)
• kornia_rs.cuda Python module — GPU color conv + fused preprocess, pinned-staging, zero-copy DLPack import into torch/TensorRT (#969, #970, #972)
• cudarc device-memory integration: CudaResource/CudaAllocator, Tensor::to_cuda, CudaKernel (#950)
• GPU resize kernels (nearest + bilinear) via CubeCL (#946); GPU image→tensor Preprocessor (#960)
• DLPack interop for Tensor/Image + kornia-py, bidirectional with torch (#951)

imgproc

• CPU warp-affine rewrite — incremental coords, analytical valid-range skip, 16-row Rayon chunks; 2–2.5× faster nearest, bilinear now beats cv2 CPU (#971)
• Preprocessor builder — RGBA source, mean/std normalize, configurable pad (#964)

AprilTag

• 3D pose estimation + SIMD-accelerated detector (#959)
• Dedup no longer drops repeated tag ids (#973)

Breaking

• Removed the compile-time allocator type param on Tensor/Image; runtime AllocHandle + host-default constructors (#955). Migration: Image<f32, 3, CpuAllocator> → Image<f32, 3>.

Full changelog: v0.1.14...v0.1.15-rc.1

The headline: turbojpeg is finally reachable from the Python API.

In 0.1.13 we shipped wheels with libjpeg-turbo compiled into the binary, but the Python-facing symbols (kr.io.encode_image_jpegturbo, decode_image_jpegturbo, read_image_jpegturbo, write_image_jpegturbo, ImageEncoder, ImageDecoder) were silently absent because the #[cfg(feature = "turbojpeg")] gates in kornia-py/src/*.rs check kornia-py's own feature flag, not the kornia-io dep's. We had set the dep flag but never activated kornia-py's. 0.1.14 fixes that with default = ["turbojpeg"], so the gates fire on every default build.

Verification: the kornia-py Python test suite that asserts these symbols exist (e.g. test_decode_image_jpegturbo, test_compress_decompress, test_write_read_jpegturbo) is now passing on Linux + macOS + Windows.

Other changes since v0.1.13

• Windows CI fix: windows-latest GitHub runners no longer ship Visual Studio 2022 (only 2026 Preview), which broke cmake auto-detection. Switched to CMAKE_GENERATOR=Ninja + ilammy/msvc-dev-cmd so the libjpeg-turbo build is VS-version-agnostic.
• Single source of truth for the turbojpeg feature: dropped the redundant features = ["turbojpeg"] on the kornia-io dep line. Now --no-default-features actually skips the libjpeg-turbo cmake build (was previously always forced on).
• Pre-commit / rustfmt / toml-fmt CI fixes from the 0.1.12 release flow.

How to use turbojpeg from Python

import kornia_rs as kr

# Fast JPEG encode (libjpeg-turbo SIMD path)
enc = kr.io.ImageEncoder()
jpeg_bytes = enc.encode(img, quality=85)

# Fast JPEG decode
dec = kr.io.ImageDecoder()
arr = dec.decode(jpeg_bytes)

The pure-Rust jpeg-encoder fallback is still used when libjpeg-turbo init fails, so building with --no-default-features continues to work.

Full diff: v0.1.13...v0.1.14

Changes

• turbojpeg enabled by default in published wheels (2-4× faster JPEG encode/decode vs pure-Rust fallback)
• Windows CI fixed: pin CMAKE_GENERATOR=Visual Studio 17 2022 to prevent cmake auto-selecting VS 2026 preview
• All turbojpeg code paths gated behind #[cfg(feature = "turbojpeg")] — pure-Rust fallback still works for source builds without cmake

What's new

3D / Bundle Adjustment

• Schur-complement bundle adjustment — dense reduced camera system (k3d.bundle_adjust_schur)
• SE(3) pose graph optimization (k3d.pose_graph_optimize)
• Cheirality-robust BA with pose-only mode and fixed-point gauge (k3d.bundle_adjust)
• IRLS Huber + Cauchy robust loss for BA
• solve_pnp_ransac moved into k3d namespace

RANSAC

• Generic RANSAC framework with NEON+AVX2 scorer and LO-RANSAC
• Homography estimator with rayon parallel scoring
• BA robust-kernel wiring

Segmentation + Depth (kornia_rs.segmentation, kornia_rs.depth)

• COCO RLE ↔ mask encode/decode (NEON-accelerated transpose)
• depth.sample_depth — sample depth under segmentation masks (median or mean, parallel via rayon)
  • 19× speedup on mean path vs pure Python (Jetson Orin, 480×640, 16 masks)

Colormap (kornia_rs.imgproc.apply_colormap, Image.colormap())

• 21 OpenCV-compatible colormaps (viridis, turbo, jet, …)
• NEON-accelerated LUT lookup (vqtbl4q_u8, 16 px/iter)

IO — RVL depth codec (kornia_rs.io)

• encode_image_rvl / decode_image_rvl — lossless Run-Length Variable depth compression
• write_image_rvl / read_image_rvl — file IO
• ~3–5× compression on typical depth frames; zeros (missing depth) pack to a single nibble
• NEON-accelerated delta+zigzag phase on aarch64
• Wire format: RVL1 magic + width/height header

IO — In-memory PNG-16 + PIL-parity (kornia_rs.io, Image)

• encode_image_png_{rgb8,rgba8,gray8,rgb16,rgba16,gray16} — symmetric in-memory PNG encode
• Image class natively holds uint16 (depth maps)
• Image.save(fp) accepts path or file-like (BytesIO, S3 objects)
• Image.encode(format) — in-memory bytes for JPEG and PNG

IO — Zero-copy + WebP/TIFF

• Zero-copy IO path improvements
• WebP and TIFF in encode/save/decode/load

Upgrading

pip install --upgrade kornia-rs

kornia-rs v0.1.11

First release in 6 months (since v0.1.10, Nov 2025), bundling 122 commits across the Rust core, Python bindings, and C++ surface.

New crates

• kornia-vlm — VLM stack with paligemma + SmolVLM (#391, #397, #398, #404, #405)
• kornia-pnp — PnP solvers + factor-graph optimization (#439, #664)
• kornia-lie — Lie groups on glam-rs: SO2/SE2/SO3/SE3/RxSO3/Sim3 + jacobians (#303, #376, #389, #395, #401, #407, #633, #746)
• kornia-nn — Linear / DNN ops with SIMD (#386, #378)
• kornia-apriltag — Full AprilTag detection pipeline (#380, #406, #410, #419, #420, #429, #433, #435, #438, #444, #458)
• kornia-algebra — Shared linear algebra (#558, #692, #697)
• v4l2 / v4l — Camera capture with mmap + control trait (#359, #437, #441, #582)

Python bindings (kornia-py)

• PIL-parity Image API with zero-copy numpy interop (#839, #894, #896)
• u16 / f32 dtype support across IO and imgproc
• WebP encode/decode (#651), TIFF buffer encoders, JPEG-turbo
• AprilTag bindings (#565), DecodeTagsConfig.tag_families getter (#883)
• Python 3.14t free-threaded build support (#888)
• Auto-detected read_image() (#571), zero-copy gstreamer images (#387)

Performance

• Cross-arch SIMD: AVX2 (x86_64) + NEON (aarch64) for ORB / FAST / imgproc (#839, #887)
• Two-view pose + essential/fundamental matrix estimation (#688)
• Pyramid (#622, #629, #654), separable_filter (#612), draw_line (#685)
• flip_v memcpy (#650), cast/scale (#662), tensor as_contiguous (#663)
• Histogram parallelism (#447), DoG response memory (#705)
• QuickDecode -8x and -770x memory reductions (#618, #626)
• Linear-time euclidean distance transform (#658)
• SVD optimized (#516)

Imgproc

• Morphological operations (#653)
• Suzuki–Abe contour finding (#767)
• Adaptive threshold (#384)
• undistort_points (#623)
• Padding function (#510)
• adjust_brightness (#554), GFTT response (#757)
• Robust loss support (Identity, Huber, Cauchy) for LM solver (#708)

IO

• WebP support (#651), JPEG encoder bytes / Image from ptr (#549)
• EXIF metadata extraction + auto-orientation (#640, #760)
• Zero-copy gstreamer (#387), v4l2 mmap (#437)
• Decoupled device/dtype selection (#800)

Examples & infra

• ROS2 / Zenoh examples with shared memory (#594, #597, #581)
• copper, dora, foxglove, paligemma, smol_vlm / smol_vlm2 examples
• pixi for infra/CI (#599), dependabot configuration (#721)
• C++ bindings: unified Image API (#543, #550)

Fixes

• decode_gray8 returns Image<u8, 1> with correct pitch (#880)
• Interpolation panics replaced with Result (#777)
• Removed unsafe transmute in vlm preprocessors (#754)
• TileIterator refactored to safe Rust (#742)
• ICP geometric metric assertions (#722, #723), ORB fixes (#693)
• Cross-platform build (#814), maturin>=1.9 pin for py3.14t (#888)
• Exact Givens rotation for svd3_f64 stability (#697)
• PartialEq derived on Lie groups (#746)

Distribution

• 46 wheels on PyPI: linux (x86_64 + aarch64), macOS (x86_64 + arm64), windows × Python 3.8–3.14 + 3.13t / 3.14t free-threaded
• Cross-arch SIMD verified at wheel-build time (objdump-grep gate for AVX2 / NEON)

Full Changelog: v0.1.10...v0.1.11

What's Changed

• bump version 0.1.10-rc1 by @edgarriba in #369
• Fix: README.md - Minor fixes and formatting by @AS1100K in #372
• Implement Video Reader by @AS1100K in #356
• fix sdist and add trove classifiers by @ngoldbaum in #374
• Add support for custom Allocator for Image by @AS1100K in #373
• Create kornia-lie crate on top of glam-rs by @andrew-shc in #303
• remove static from tensor allocator by @edgarriba in #375
• chore: bump version of rerun and criterion, fix warnings by @edgarriba in #377
• kornia_lie: implement mul traits and fixes by @edgarriba in #376
• tensor-ops: Implement dnn ops linear layer with simd by @edgarriba in #378
• fix: make So2 hat matrix skew symmetric by @cjpurackal in #379
• Update ONNX example to use ort 2.0.0-rc.10 by @AS1100K in #382
• Use std::hint::black_box instead of criterion::black_box because it’s deprecated by @AS1100K in #381
• Add kornia-apriltag crate by @AS1100K in #380
• Improve linear layer with matrix multiply and crate kornia-nn by @edgarriba in #386
• Fix kornia-io docs.rs not building by @AS1100K in #388
• Implement Zero copy images from gstreamer by @edgarriba in #387
• Rtsp example test fixes by @edgarriba in #385
• adds draw_polygon and draw_filled_polygon functions. by @TomatoChocolate12 in #353
• chore: clippy fixes and image allocators by @edgarriba in #392
• Kornia vlm crate skeleton by @edgarriba in #391
• lie: fix se2 random roundtrip test by @edgarriba in #389
• Add Adaptive Threshold Binary function by @AS1100K in #384
• lie: fix col major issues and relax aarch64 epsilon tests by @edgarriba in #396
• feat: add left and right jacobians for SE2 and SO2 by @cjpurackal in #395
• vlm: implement paligemma using candle by @edgarriba in #398
• use bincode from workspace for loading pointclouds by @edgarriba in #403
• create paligemma example by @edgarriba in #404
• vlm: make paligemma inference image allocator agnostic by @edgarriba in #405
• feat: add se3 jacobains and fix log->exp->log roundtrip issue by @cjpurackal in #401
• feat: add rplus,rminus,lplus,lminus for lie groups by @cjpurackal in #407
• Add Connected Components for AprilTag detection by @AS1100K in #406
• Add gradient cluster detection by @AS1100K in #410
• Replace clippy-action with direct cargo clippy command by @AS1100K in #412
• implement v4l2 crate by @edgarriba in #359
• bump tiff version to 0.10 by @edgarriba in #413
• deprecate image-rs crate by @edgarriba in #414
• io: Alias gstreamer module by @edgarriba in #415
• chore: fix clippy issues and warnings by @edgarriba in #417
• separate internal conv bit functions by @edgarriba in #416
• image: implement Arrow support for image by @edgarriba in #418
• dora: use upstream dora nodes for the examples by @edgarriba in #421
• examples: bump copper version to 0.8.0 by @edgarriba in #422
• imgproc: bump fir to 5.1.* by @edgarriba in #423
• Integrate SmolVLM candle version into kornia-vlm by @andrew-shc in #397
• Add Quad Fitting by @AS1100K in #419
• Remove license-file from smol_vlm example by @AS1100K in #424
• vlm: fix lint with print and logging by @edgarriba in #425
• Add Apriltag Decoding by @AS1100K in #420
• fix: v4l no longer borking macos by @m0sys in #431
• Add support for multiple AprilTag Families by @AS1100K in #429
• Add TagFamilyKind::all method and use it in DecodeTagsConfig by @AS1100K in #433
• Reset sharpening buffer for every Quad by @AS1100K in #435
• implement v4l with mmap and improve controls by @edgarriba in #437
• Add AprilTag detection example by @AS1100K in #436
• Update apriltag-imgs submodule URL by @AS1100K in #440
• V4l camera control trait by @edgarriba in #441
• Add AprilTag Benchmark by @AS1100K in #438
• io: expose decode jpeg image info by @edgarriba in #442
• Blur ksize auto by @m0sys in #434
• filter: fix linter and better readability for blur filter by @edgarriba in #443
• pref(histogram.rs): parallelized histogram generation by @dhruvkjain in #447
• Feat: Add kornia-pnp by @cjpurackal in #439
• Add image downscaling support in AprilTag Detection by @AS1100K in #444
• Add benchmark aprilgrid-rs by @AS1100K in #458
• English Spelling changes by @Askari-Defense in #483
• Fix CI by @AS1100K in #488
• docs: Add contributor guidelines by @cjpurackal in #482
• interpolation fix by @andrew-shc in #470
• MKL issue in candle fixed by @andrew-shc in #469
• smolvlm main change (rebased) by @andrew-shc in #491
• removed unwraps in SmolVLM by @andrew-shc in #493
• convo example by @andrew-shc in #474
• SmolVLM example + validations by @andrew-shc in #471
• SmolVLM conversational example hotfix by @andrew-shc in #494
• Update SmolVLM example READMEs by @andrew-shc in #495
• video example by @andrew-shc in #473
• Distortion option for pnp crate by @jeffin07 in #480
• feat(image): added is_contiguous and to_contiguous for Image solving kornia-py/image.rs todo by @dhruvkjain in #448
• SmolVLM2: decoder & text processor by @andrew-shc in #499
• feat: Add RANSAC and PnP benchmarking by @cjpurackal in #463
• SmolVLM2: Custom weights by @andrew-shc in #507
• Add support for Python 3.14 by @ngoldbaum in #520
• Change variable names of transform_point to avoid shadowing by @PabloDArandaR in #522
• smolvlm2 video processing + images by @andrew-shc in #506
• fix clippy errors by @edgarriba in #528
• corrected Bresenham circle offsets in FAST feature detector by @sidd-27 in #527
• optimized build6x10 by @sidd-27 in #523
• incorrect sign in so2 hat function by @sidd-27 in #518
• color: implement rgb from rgba by @edgarriba in #526
• Improve README.md: fix typos, update accuracy, enhance structure by @Copilot in #530
• bug : fixed incorrect filtering by @sidd-27 in #533
• fixed bug in se2 exp by @sidd-27 in #534
• bug fix in so3 exp by @sidd-27 in #535
• color: implement bgra to rgb conversion by @edgarriba in #536
• bug fixing across the lie crate by @sidd-27 in #537
• perf: removed SVD for a more specialized solver by @sidd-27 in #524

New Contributors

• @cjpurackal made their first contribution in #379
• @TomatoChocolate12 made their first contribution in #353
• @m0sys made their first contribution in #431
• @dhruvkjain made their first contribution in #447
• @Askari-Defense made their first contribution in #483
• @PabloDArandaR made their first contribution in #522
• @sidd-27 made their first contribution in #527
• @Copilot made their first contribution in #530

Full Changelog: v0.1.9...v0.1.10

What's Changed

• bump version 0.1.9-rc1 by @edgarriba in https://github.com/kornia/kornia-rs/pull/211
• build: remove unused docker images by @johnnv1 in https://github.com/kornia/kornia-rs/pull/212
• Simplify stream capture and remove thread by @edgarriba in https://github.com/kornia/kornia-rs/pull/213
• refactor ci pipelines by @edgarriba in https://github.com/kornia/kornia-rs/pull/219
• Grayscale Example Fixed by @jeffin07 in https://github.com/kornia/kornia-rs/pull/218
• fix (ci): ensure py versions by @johnnv1 in https://github.com/kornia/kornia-rs/pull/215
• Use Gstreamer Buffer map in StreamCapture by @edgarriba in https://github.com/kornia/kornia-rs/pull/216
• return array in std_mean by @edgarriba in https://github.com/kornia/kornia-rs/pull/221
• implement png read routines by @edgarriba in https://github.com/kornia/kornia-rs/pull/222
• chore (ci): uv run pytest by @johnnv1 in https://github.com/kornia/kornia-rs/pull/224
• Update README with DIscord invite link by @edgarriba in https://github.com/kornia/kornia-rs/pull/227
• image: implement image getter and setter for dev purpose by @edgarriba in https://github.com/kornia/kornia-rs/pull/230
• Implement Box blur fast filter that could approximate gaussian filter by @light-le in https://github.com/kornia/kornia-rs/pull/223
• add CI for 3.13 by @ngoldbaum in https://github.com/kornia/kornia-rs/pull/232
• kornia_io: refactor jpegturbo api and specify image types by @edgarriba in https://github.com/kornia/kornia-rs/pull/233
• chore: fix readme docs in top level kornia package by @edgarriba in https://github.com/kornia/kornia-rs/pull/234
• chore: bump version to v0.1.9-rc2 by @edgarriba in https://github.com/kornia/kornia-rs/pull/235
• py: expose icp algorithm to pyo3 by @edgarriba in https://github.com/kornia/kornia-rs/pull/236
• color: implement gray from rgb as u8 by @edgarriba in https://github.com/kornia/kornia-rs/pull/238
• chore: update rerun and rand dependencies version by @edgarriba in https://github.com/kornia/kornia-rs/pull/237
• update bincode to 2.0.0 and fix ci by @edgarriba in https://github.com/kornia/kornia-rs/pull/259
• implement dot_product, cosine_similarity/matrix for tensor ops; add shape mismatch e… by @Force1ess in https://github.com/kornia/kornia-rs/pull/242
• Implement SVD for Mat3x3 by @prikshitsingh24 in https://github.com/kornia/kornia-rs/pull/241
• Added additional functions for kornia tensors by @aayushhzz in https://github.com/kornia/kornia-rs/pull/264
• implement dog_response; improve doc of gaussian_blur by @Force1ess in https://github.com/kornia/kornia-rs/pull/261
• Moved Arithmetic functions to tensor-ops by @aayushhzz in https://github.com/kornia/kornia-rs/pull/272
• chore: fix clippy and check errors by @edgarriba in https://github.com/kornia/kornia-rs/pull/279
• tensops: fix self reference for internal methods by @edgarriba in https://github.com/kornia/kornia-rs/pull/280
• Add dora-rs example with multi cam by @edgarriba in https://github.com/kornia/kornia-rs/pull/258
• imgproc: implement generic types for separable_filter by @edgarriba in https://github.com/kornia/kornia-rs/pull/283
• Implemented Pyrup by @Saga690 in https://github.com/kornia/kornia-rs/pull/285
• feat: implement spatial_gradient by @Puellaquae in https://github.com/kornia/kornia-rs/pull/260
• Replacing argument parser clap with argh. by @kylekam in https://github.com/kornia/kornia-rs/pull/289
• implement copper example with multi cam by @edgarriba in https://github.com/kornia/kornia-rs/pull/287
• Implement image map by @edgarriba in https://github.com/kornia/kornia-rs/pull/294
• chore: fix compilation issue with rerun and arrow-arith by @edgarriba in https://github.com/kornia/kornia-rs/pull/308
• remove unused kornia-viz experimental code by @edgarriba in https://github.com/kornia/kornia-rs/pull/313
• implemented harris_response by @andrew-shc in https://github.com/kornia/kornia-rs/pull/267
• fix separable filter overflows by @edgarriba in https://github.com/kornia/kornia-rs/pull/296
• copper: update the sobel task to use image map for casting by @edgarriba in https://github.com/kornia/kornia-rs/pull/295
• chore: fix clippy errors by @edgarriba in https://github.com/kornia/kornia-rs/pull/316
• Update python bindings to be compatible with free-threading, add CI by @ngoldbaum in https://github.com/kornia/kornia-rs/pull/315
• Use pytest-run-parallel in free-threaded CI by @ngoldbaum in https://github.com/kornia/kornia-rs/pull/318
• Remove unnecessary unsafe Send/Sync impl for StreamCaptureError by @ngoldbaum in https://github.com/kornia/kornia-rs/pull/320
• implement fast feature detector by @edgarriba in https://github.com/kornia/kornia-rs/pull/240
• Fix CI by @AS1100K in https://github.com/kornia/kornia-rs/pull/330
• Add sccache to ci by @TempestBirds729804 in https://github.com/kornia/kornia-rs/pull/298
• Add JPEG image encoding and decoding functions by @AS1100K in https://github.com/kornia/kornia-rs/pull/327
• io: upgrade gsreamer to 0.23.5 and initialize by @edgarriba in https://github.com/kornia/kornia-rs/pull/329
• Fix kornia-io docs not building on docs.rs by @AS1100K in https://github.com/kornia/kornia-rs/pull/328
• Extend PNG encoding and decoding support by @AS1100K in https://github.com/kornia/kornia-rs/pull/332
• python: improve encoders mutability by @edgarriba in https://github.com/kornia/kornia-rs/pull/334
• declare support for the free-threaded build by @ngoldbaum in https://github.com/kornia/kornia-rs/pull/340
• Fix CI due to outdated package index by @AS1100K in https://github.com/kornia/kornia-rs/pull/346
• Update python release automation, add free-threaded builds by @ngoldbaum in https://github.com/kornia/kornia-rs/pull/347
• Fix CI issue with sccache by @AS1100K in https://github.com/kornia/kornia-rs/pull/350
• Decode Images directly from raw bytes by @AS1100K in https://github.com/kornia/kornia-rs/pull/336
• Add frozen attribute to Python wrapper classes by @AS1100K in https://github.com/kornia/kornia-rs/pull/349
• Fix typo by @AS1100K in https://github.com/kornia/kornia-rs/pull/358
• Update rerun 23.1 by @edgarriba in https://github.com/kornia/kornia-rs/pull/361
• python: image shape argument as tuple by @edgarriba in https://github.com/kornia/kornia-rs/pull/362
• io: implement image tiff read and write by @edgarriba in https://github.com/kornia/kornia-rs/pull/363
• python: decouple png read write functions by @edgarriba in https://github.com/kornia/kornia-rs/pull/364
• python: rework jpeg and jpegturbo decoders by @edgarriba in https://github.com/kornia/kornia-rs/pull/365
• merge kernels into tensor-ops crate by @edgarriba in https://github.com/kornia/kornia-rs/pull/366
• linalg: rename svd mod and add to kornia parent by @edgarriba in https://github.com/kornia/kornia-rs/pull/367
• bump version to 0.1.9 by @edgarriba in https://github.com/kornia/kornia-rs/pull/368

New Contributors

• @light-le made their first contribution in https://github.com/kornia/kornia-rs/pull/223
• @Force1ess made their first contribution in https://github.com/kornia/kornia-rs/pull/242
• @prikshitsingh24 made their first contribution in https://github.com/kornia/kornia-rs/pull/241
• @aayushhzz made their first contribution in https://github.com/kornia/kornia-rs/pull/264
• @Saga690 made their first contribution in https://github.com/kornia/kornia-rs/pull/285
• @Puellaquae made their first contribution in https://github.com/kornia/kornia-rs/pull/260
• @kylekam made their first contribution in https://github.com/kornia/kornia-rs/pull/289
• @andrew-shc made their first contribution in https://github.com/kornia/kornia-rs/pull/267
• @AS1100K made their first contribution in https://github.com/kornia/kornia-rs/pull/330
• @TempestBirds729804 made their first contribution in https://github.com/kornia/kornia-rs/pull/298

Full Changelog: https://github.com/kornia/kornia-rs/compare/v0.1.8...v0.1.9

What's Changed

• bump version to 0.1.7 by @edgarriba in https://github.com/kornia/kornia-rs/pull/165
• Fix github python release by @edgarriba in https://github.com/kornia/kornia-rs/pull/166
• Add experimental Kornia viz by @edgarriba in https://github.com/kornia/kornia-rs/pull/175
• create kornia-3d crate with ply reader and rerun example by @edgarriba in https://github.com/kornia/kornia-rs/pull/177
• Implement Colmap reader by @edgarriba in https://github.com/kornia/kornia-rs/pull/180
• Implement Iterative Closest Point algorithm and 3d utils by @edgarriba in https://github.com/kornia/kornia-rs/pull/182
• reorganize dependencies by @edgarriba in https://github.com/kornia/kornia-rs/pull/183
• support python 3.13 by @edgarriba in https://github.com/kornia/kornia-rs/pull/184
• implement XYZRgbNormalsProperty in ply parser by @edgarriba in https://github.com/kornia/kornia-rs/pull/187
• Bumpt fast resize by @edgarriba in https://github.com/kornia/kornia-rs/pull/192
• Implement kornia3d::pose for homography and affine by @edgarriba in https://github.com/kornia/kornia-rs/pull/194
• rename kornia-core to kornia-tensor by @edgarriba in https://github.com/kornia/kornia-rs/pull/195
• implement hessian response by @edgarriba in https://github.com/kornia/kornia-rs/pull/196
• Implement Imgproc filters by @edgarriba in https://github.com/kornia/kornia-rs/pull/199
• chore (kornia-py): makefile w/ uv, and extend python ci by @johnnv1 in https://github.com/kornia/kornia-rs/pull/200
• fix separable_filter regression by @edgarriba in https://github.com/kornia/kornia-rs/pull/201
• Fix kornia-serve imports by @edgarriba in https://github.com/kornia/kornia-rs/pull/202
• remove kornia-serve by @edgarriba in https://github.com/kornia/kornia-rs/pull/203
• refactor (just): move make to just cmd runner by @johnnv1 in https://github.com/kornia/kornia-rs/pull/204
• chore (ci): ensure support to all py versions of releases by @johnnv1 in https://github.com/kornia/kornia-rs/pull/205
• feat (devcontainer): setup devcontainer for vscode by @johnnv1 in https://github.com/kornia/kornia-rs/pull/206
• chore (readme): update supported py versions by @johnnv1 in https://github.com/kornia/kornia-rs/pull/207
• create Image and Tensor/Storage from parts by @edgarriba in https://github.com/kornia/kornia-rs/pull/208
• implement bincode for tensor by @edgarriba in https://github.com/kornia/kornia-rs/pull/209
• Release 0.1.8 by @edgarriba in https://github.com/kornia/kornia-rs/pull/210

Full Changelog: https://github.com/kornia/kornia-rs/compare/v0.1.7...v0.1.8

What's Changed

• Release 0.1.5 by @edgarriba in https://github.com/kornia/kornia-rs/pull/96
• Refactor crates by @edgarriba in https://github.com/kornia/kornia-rs/pull/97
• Histogram example update by @edgarriba in https://github.com/kornia/kornia-rs/pull/98
• Handle errors gracefully by @edgarriba in https://github.com/kornia/kornia-rs/pull/99
• Stream capture API by @edgarriba in https://github.com/kornia/kornia-rs/pull/101
• refactor signatures to allow preallocation by @edgarriba in https://github.com/kornia/kornia-rs/pull/102
• remove new_size and implement cast_and_scale by @edgarriba in https://github.com/kornia/kornia-rs/pull/105
• Update rerun 18 by @edgarriba in https://github.com/kornia/kornia-rs/pull/106
• TensorStorage improvements by @edgarriba in https://github.com/kornia/kornia-rs/pull/107
• remove new_size from warp_affine and warp_perspective by @edgarriba in https://github.com/kornia/kornia-rs/pull/108
• Fix README filename being incorrect by @liamkinne in https://github.com/kornia/kornia-rs/pull/110
• Simplify handling paths by using impl AsRef<Path> for JPEG functions by @liamkinne in https://github.com/kornia/kornia-rs/pull/111
• Implement TensorView by @edgarriba in https://github.com/kornia/kornia-rs/pull/109
• Deprecate ndarray phase1 by @edgarriba in https://github.com/kornia/kornia-rs/pull/114
• Improve Rust benchmarks by @edgarriba in https://github.com/kornia/kornia-rs/pull/115
• Ndarray deprecation by @edgarriba in https://github.com/kornia/kornia-rs/pull/116
• Close streamer with termination and other stability fixes by @edgarriba in https://github.com/kornia/kornia-rs/pull/123
• implement Tensor into_vec by @edgarriba in https://github.com/kornia/kornia-rs/pull/125
• implement tensorview as_contiguous by @edgarriba in https://github.com/kornia/kornia-rs/pull/128
• onnxruntime example for rtdetr by @edgarriba in https://github.com/kornia/kornia-rs/pull/104
• make meshgrid improvements by @edgarriba in https://github.com/kornia/kornia-rs/pull/131
• Refactor hflip, vflip functions to allow preallocation by @emilmgeorge in https://github.com/kornia/kornia-rs/pull/117
• support async closure in the stream camera by @edgarriba in https://github.com/kornia/kornia-rs/pull/133
• Implement H264 VideoWritter with gstreamer by @edgarriba in https://github.com/kornia/kornia-rs/pull/135
• Fix illegal access in warp_perspective by @emilmgeorge in https://github.com/kornia/kornia-rs/pull/141
• Release cargo packages by @edgarriba in https://github.com/kornia/kornia-rs/pull/140
• Tensor get bounds check by @jandremarais in https://github.com/kornia/kornia-rs/pull/144
• Tensor display by @jandremarais in https://github.com/kornia/kornia-rs/pull/146
• Fix TensorStorage memory deallocation by @emilmgeorge in https://github.com/kornia/kornia-rs/pull/145
• Improve Video writer workflow and others by @edgarriba in https://github.com/kornia/kornia-rs/pull/150
• improve image tensor conversions by @edgarriba in https://github.com/kornia/kornia-rs/pull/151
• Implement more imgproc functionality by @edgarriba in https://github.com/kornia/kornia-rs/pull/152
• implement hconcat operator by @edgarriba in https://github.com/kornia/kornia-rs/pull/153
• implement a crop function by @edgarriba in https://github.com/kornia/kornia-rs/pull/155
• create new crate for core-ops by @jandremarais in https://github.com/kornia/kornia-rs/pull/142
• implement draw_line in kornia-improc by @edgarriba in https://github.com/kornia/kornia-rs/pull/158
• Getting started README Fix by @jeffin07 in https://github.com/kornia/kornia-rs/pull/160
• pin ort and ort-sys to v2.0.0.rc8 and add half feature by @edgarriba in https://github.com/kornia/kornia-rs/pull/163
• make the stream capture error thread-safe by @edgarriba in https://github.com/kornia/kornia-rs/pull/162
• Implement Tensor Buffer by @edgarriba in https://github.com/kornia/kornia-rs/pull/156
• remove tokio from video capture and simplify pipeline by @edgarriba in https://github.com/kornia/kornia-rs/pull/164

New Contributors

• @liamkinne made their first contribution in https://github.com/kornia/kornia-rs/pull/110
• @emilmgeorge made their first contribution in https://github.com/kornia/kornia-rs/pull/117
• @jandremarais made their first contribution in https://github.com/kornia/kornia-rs/pull/144
• @jeffin07 made their first contribution in https://github.com/kornia/kornia-rs/pull/160

Full Changelog: https://github.com/kornia/kornia-rs/compare/v0.1.5...v0.1.7

What's Changed

• fix webcam videorate by @edgarriba in https://github.com/kornia/kornia-rs/pull/71
• initial kornia-serve by @edgarriba in https://github.com/kornia/kornia-rs/pull/72
• wrap results in tests by @edgarriba in https://github.com/kornia/kornia-rs/pull/73
• update rerun 0.16.0 and use log_static by @edgarriba in https://github.com/kornia/kornia-rs/pull/74
• implement warp_perspective by @edgarriba in https://github.com/kornia/kornia-rs/pull/75
• implement rgb to hsv by @edgarriba in https://github.com/kornia/kornia-rs/pull/76
• implement in_range, bitwise_and by @edgarriba in https://github.com/kornia/kornia-rs/pull/77
• make turbojpeg optional by @edgarriba in https://github.com/kornia/kornia-rs/pull/78
• create kornia_rs::Interpolation module by @edgarriba in https://github.com/kornia/kornia-rs/pull/79
• implement image undistortion by @edgarriba in https://github.com/kornia/kornia-rs/pull/80
• refactor tensor by @edgarriba in https://github.com/kornia/kornia-rs/pull/84
• bump version 0.1.4 by @edgarriba in https://github.com/kornia/kornia-rs/pull/85
• add tensor errors and element wise ops by @edgarriba in https://github.com/kornia/kornia-rs/pull/86
• Fix macos python release by @edgarriba in https://github.com/kornia/kornia-rs/pull/87
• add zeros, and compute offset by @edgarriba in https://github.com/kornia/kornia-rs/pull/88
• Implement Tensor Memory allocator by @edgarriba in https://github.com/kornia/kornia-rs/pull/89
• feat: enhance add weighted by @johnnv1 in https://github.com/kornia/kornia-rs/pull/90
• docs: fix typo in readme by @truh in https://github.com/kornia/kornia-rs/pull/94
• handle gracefulle webcam / gstreamer errors by @edgarriba in https://github.com/kornia/kornia-rs/pull/93
• make io::stream module by @edgarriba in https://github.com/kornia/kornia-rs/pull/95

New Contributors

• @johnnv1 made their first contribution in https://github.com/kornia/kornia-rs/pull/90
• @truh made their first contribution in https://github.com/kornia/kornia-rs/pull/94

Full Changelog: https://github.com/kornia/kornia-rs/compare/v0.1.3...v0.1.5

What's Changed

• fix webcam videorate by @edgarriba in https://github.com/kornia/kornia-rs/pull/71
• initial kornia-serve by @edgarriba in https://github.com/kornia/kornia-rs/pull/72
• wrap results in tests by @edgarriba in https://github.com/kornia/kornia-rs/pull/73
• update rerun 0.16.0 and use log_static by @edgarriba in https://github.com/kornia/kornia-rs/pull/74
• implement warp_perspective by @edgarriba in https://github.com/kornia/kornia-rs/pull/75
• implement rgb to hsv by @edgarriba in https://github.com/kornia/kornia-rs/pull/76
• implement in_range, bitwise_and by @edgarriba in https://github.com/kornia/kornia-rs/pull/77
• make turbojpeg optional by @edgarriba in https://github.com/kornia/kornia-rs/pull/78
• create kornia_rs::Interpolation module by @edgarriba in https://github.com/kornia/kornia-rs/pull/79
• implement image undistortion by @edgarriba in https://github.com/kornia/kornia-rs/pull/80
• refactor tensor by @edgarriba in https://github.com/kornia/kornia-rs/pull/84

Full Changelog: https://github.com/kornia/kornia-rs/compare/v0.1.3...v0.1.4

What's Changed

• implement std mean by @edgarriba in https://github.com/kornia/kornia-rs/pull/63
• implement compute histogram by @edgarriba in https://github.com/kornia/kornia-rs/pull/62
• add compute_histogram python bindings by @edgarriba in https://github.com/kornia/kornia-rs/pull/64
• add Image to tensor built in utils by @edgarriba in https://github.com/kornia/kornia-rs/pull/65
• Add io::WebcamCapture via gstreamer by @edgarriba in https://github.com/kornia/kornia-rs/pull/61
• [prototype] ImageDtype trait to implement resize for various dtypes by @gau-nernst in https://github.com/kornia/kornia-rs/pull/68
• Add Warp affine by @gau-nernst in https://github.com/kornia/kornia-rs/pull/67
• add rotate example by @edgarriba in https://github.com/kornia/kornia-rs/pull/69

Full Changelog: https://github.com/kornia/kornia-rs/compare/v0.1.2...v0.1.3

What's Changed

• bump version 0.1.1 by @edgarriba in https://github.com/kornia/kornia-rs/pull/42
• Add python sdist by @edgarriba in https://github.com/kornia/kornia-rs/pull/50
• ci improvements by @edgarriba in https://github.com/kornia/kornia-rs/pull/52
• deprecate .image_size() in favour if img.size() by @edgarriba in https://github.com/kornia/kornia-rs/pull/55
• add kornia_rs::metrics by @edgarriba in https://github.com/kornia/kornia-rs/pull/56
• add more benchmarks for jpeg by @edgarriba in https://github.com/kornia/kornia-rs/pull/58
• implement fast image resize by @edgarriba in https://github.com/kornia/kornia-rs/pull/59

Full Changelog: https://github.com/kornia/kornia-rs/compare/v0.1.1...v0.1.2

What's Changed

• Fix rust release by @edgarriba in https://github.com/kornia/kornia-rs/pull/38
• use memmap2 to read images and fixes by @edgarriba in https://github.com/kornia/kornia-rs/pull/41

Full Changelog: https://github.com/kornia/kornia-rs/compare/v0.1.0...v0.1.1

What's Changed

• switch to maturin by @edgarriba in https://github.com/kornia/kornia-rs/pull/4
• implement dlpack, dlpack_device, for numpy conversions by @edgarriba in https://github.com/kornia/kornia-rs/pull/5
• add release docker and bump to 0.0.2 by @edgarriba in https://github.com/kornia/kornia-rs/pull/7
• Workflow reimplementation by @carlosb1 in https://github.com/kornia/kornia-rs/pull/8
• Added upload wheel by @carlosb1 in https://github.com/kornia/kornia-rs/pull/9
• bump version 0.0.3 by @edgarriba in https://github.com/kornia/kornia-rs/pull/10
• build release many link by @edgarriba in https://github.com/kornia/kornia-rs/pull/11
• Create release_docker.yml by @edgarriba in https://github.com/kornia/kornia-rs/pull/12
• add version and fix tests by @edgarriba in https://github.com/kornia/kornia-rs/pull/13
• remove need docker step by @edgarriba in https://github.com/kornia/kornia-rs/pull/14
• remove i686 from release by @edgarriba in https://github.com/kornia/kornia-rs/pull/15
• use upstream dlpack-rs crate by @edgarriba in https://github.com/kornia/kornia-rs/pull/18
• Default jpegturbo, udpate version to 0.0.6 and more improvements by @edgarriba in https://github.com/kornia/kornia-rs/pull/23
• Add support for aarch64 via docker by @edgarriba in https://github.com/kornia/kornia-rs/pull/25
• update readme before release 0.0.6 by @edgarriba in https://github.com/kornia/kornia-rs/pull/26
• Fix memory release by @edgarriba in https://github.com/kornia/kornia-rs/pull/27
• Add installation instruction to README by @gau-nernst in https://github.com/kornia/kornia-rs/pull/28
• Build MacOS ARM64 binaries with GHA by @gau-nernst in https://github.com/kornia/kornia-rs/pull/29
• refactor project by @edgarriba in https://github.com/kornia/kornia-rs/pull/32

New Contributors

• @edgarriba made their first contribution in https://github.com/kornia/kornia-rs/pull/4
• @gau-nernst made their first contribution in https://github.com/kornia/kornia-rs/pull/28

Full Changelog: https://github.com/kornia/kornia-rs/commits/v0.1.0