TokenVector.Vision 1.0.0

TokenVector.Vision: Ultra-High Performance Zero-GC Computer Vision & Tensor Transforms Engine

TokenVector.Vision is an industrial-grade, zero-allocation computer vision and image transformation engine engineered for high-throughput AI pipelines, real-time video streams, and deep learning training/inference runtimes.

🎯 Core Applications & Use Cases

1. High-Speed Image Preprocessing for AI & Deep Learning (CNN, ViT, YOLO, ResNet)

Converts raw images into deep-learning-ready planar tensors $[Channels, Height, Width]$ with SIMD-accelerated spatial resizing (ResizeTransform), cropping (CropTransforms), flipping (GeometricTransforms), color augmentation (ColorJitterTransform), and statistical normalization (NormalizeTransform).

2. Elimination of GC Pauses (Zero-GC for Real-Time Video & Camera Streams)

Standard .NET vision libraries allocate objects on the managed heap, triggering garbage collection cycles that cause frame drops and latency spikes. TokenVector.Vision utilizes 100% 64-byte aligned unmanaged memory (byte*, float*) via ImageBuffer, guaranteeing 0 bytes GC allocation on hot execution paths for jitter-free real-time streaming.

3. 3.24x Speedup with Fused 1-Pass Operator (ResizeNormalizeCHW)

Traditional vision pipelines execute 3 separate passes with 3 roundtrips to system RAM (Resize $\to$ Normalize $\to$ Transpose HWC -> CHW). TokenVector.Vision fuses all three stages into a single CPU loop, keeping intermediate pixel representations entirely inside SIMD AVX2 registers and L1 cache, eliminating RAM bandwidth bottlenecks.

4. Zero-Copy Interoperability with TokenVector.Numerics

Through NumericsBridge, ImageBuffer binds directly into NDArray<float> or NDArray<byte> in 0 nanoseconds ($O(1)$ pointer wrapping), eliminating memory duplication between image processing and numerical tensor math.

5. Classical Computer Vision & Multi-Threaded DataLoader

• Spatial Filters: Includes 2D spatial convolution (Convolution2D), separable 1D Gaussian blur (GaussianBlur), Sobel/Laplacian gradient filters (EdgeDetection), and a full 5-stage Canny Edge Detector with Non-Maximum Suppression (CannyDetector).

5. Classical Computer Vision & Multi-Threaded DataLoader

• Spatial Filters: Includes 2D spatial convolution (Convolution2D), separable 1D Gaussian blur (GaussianBlur), Sobel/Laplacian gradient filters (EdgeDetection), and a full 5-stage Canny Edge Detector with Non-Maximum Suppression (CannyDetector).
• Vision DataLoader: Implements a bounded-channel double-buffering prefetching pipeline (VisionDataLoader) that prepares Batch $N+1$ on unmanaged memory while Batch $N$ is being processed by compute kernels.

6. Full-Stack AI Object Detection Suite (YOLO / DETR) & Annotation

• YOLO Letterbox Transform: LetterboxTransform provides aspect-ratio-preserving resize with gray padding (default 114 for YOLOv8/v9/v11), including exact coordinate inversion mapping LetterboxMetadata.InverseTransform.
• Non-Maximum Suppression (NMS): Zero-heap suppression engine NonMaximumSuppression.Filter executing 3,183.7 NMS operations/sec on 1,000 dense YOLO candidate boxes.
• Zero-GC Visual Painter: ImagePainter renders Bounding Boxes, alpha masks, keypoints, and ASCII bitmap text labels directly onto unmanaged ImageBuffer at 156.0 FPS on 1080p frames.
• Contiguous Batch Tensor Collation: BatchOps.StackNCHW merges individual $[C, H, W]$ buffers into a single unified $[N, C, H, W]$ tensor in contiguous unmanaged RAM.

🏗️ Ecosystem Flow

$$\text{File / Camera Stream} \xrightarrow[\text{Zero-GC / Letterbox / SIMD}]{\textbf{TokenVector.Vision}} \text{Tensor } [N, C, H, W] \xrightarrow[\text{Zero-Copy}]{\textbf{TokenVector.Numerics}} \text{AI Model } (\text{YOLO / ViT Inference}) \xrightarrow[\text{NMS / ImagePainter}]{\textbf{TokenVector.Vision}} \text{Annotated Image}$$

🚀 Quick Start Example

A. Image Classification Pipeline (CNN / ViT)

using TokenVector.Vision.Common;
using TokenVector.Vision.Codecs;
using TokenVector.Vision.Transforms;
using TokenVector.Vision.Interop;
using TokenVector.Numerics.Core;

// 1. Decode image into unmanaged ImageBuffer
using var image = ImageDecoder.Instance.DecodeFile("sample.bmp");

// 2. Execute Fused 1-Pass Operator: Resize (224x224) + Normalize (ImageNet) + Transpose (CHW)
ReadOnlySpan<float> mean = [0.485f, 0.456f, 0.406f];
ReadOnlySpan<float> std = [0.229f, 0.224f, 0.225f];
using var planarBuffer = FusedTransforms.ResizeNormalizeCHW(image, 224, 224, mean, std);

// 3. Zero-Copy export to TokenVector.Numerics NDArray<float> tensor
using NDArray<float> tensor = planarBuffer.ToNDArray(MemoryLayout.CHW);
Console.WriteLine($"Tensor Shape: [{string.Join(", ", tensor.Shape)}]"); // [3, 224, 224]

B. Object Detection Pipeline (YOLO & Visual Annotation)

using TokenVector.Vision.Detection;
using TokenVector.Vision.Drawing;

// 1. YOLO Letterbox preprocessing (1080p -> 640x640 with pad 114)
using var letterboxImg = LetterboxTransform.Apply(image, 640, 640, padValue: 114, out var metadata);

// 2. Filter dense bounding boxes with NMS
BoundingBox[] rawPredictions = GetModelOutputBoxes(); // Model raw output
BoundingBox[] keptBoxes = NonMaximumSuppression.Filter(rawPredictions, iouThreshold: 0.5f, scoreThreshold: 0.25f);

// 3. Inverse-map coordinates to original image and draw annotations (Zero-GC)
foreach (var box in keptBoxes)
{
    var origBox = metadata.InverseTransform(box);
    ImagePainter.DrawBoundingBox(image, origBox, label: $"OBJ: {origBox.Score:P0}", RgbColor.Green, thickness: 2, fillAlpha: 0.2f);
}

📊 Performance Comparison

🧪 Quality Assurance, Test Report & Stress Benchmarks

Empirical validation results on 28 CPU Cores, Windows 11 64-bit, .NET 8 Native AOT:

1. Functional Unit Tests Summary (26/26 PASS - 100%)

2. Extreme Stress & Chaos Test Results

• 4K UHD (3840x2160) Zero-GC: Continuous 200 4K frames transformed to $3 \times 224 \times 224$ Tensor at 1,526.1 FPS (0.66 ms/frame) with 0 Bytes GC allocation.
• 28 Cores Extreme Concurrency: 5,000 complex pipelines executed in parallel across 28 cores in 1.21s (4,130.1 pipelines/sec), 100% memory reclaimed, zero leaks.
• 10,000 Continuous Stream Frames: 10,000 consecutive HD frames processed at 1,656.7 FPS with flat Working Set drift (1.55 MB).
• Canny Edge Detection 1024x1024: 50 full 5-stage Canny cycles executed at 81.66 ms / Megapixel.

3. Head-to-Head Competitor Stress Benchmark

3.1. High-Load Preprocessing & Stream Torture

3.2. Object Detection & Visual Annotation Benchmarks

📜 License

MIT License. Copyright (c) 2026 TokenVector Project Team.