AlbumentationsX is a production-grade Python library for fast, flexible image augmentation in deep learning and computer vision pipelines. It provides a comprehensive catalog of 70+ transforms covering pixel-level (blur, noise, color, weather effects), geometric (flip, rotate, crop, resize, distortion, perspective), dropout (coarse, grid, mask, pixel), mixing (mosaic, copy-paste, overlay), and domain adaptation (FDA, histogram matching, stain normalization). The library supports 2D and 3D data, including images, masks, bounding boxes (HBB and OBB), keypoints, and volumes, with seamless integration into PyTorch via tensor transforms. Its architecture is built on a clean inheritance hierarchy (BasicTransform → DualTransform/ImageOnlyTransform/Transform3D) with Pydantic-based parameter validation, serialization to JSON/YAML, and deterministic replay via ReplayCompose. The codebase is backed by an extensive test suite (property-based, regression, contract, and golden vector tests), ASV benchmarks, and a sophisticated CI/CD system with path-aware planning, performance budgets, and legal integrity checks. Telemetry (opt-out) collects anonymous usage statistics to guide development. While primarily a software library, it incorporates research-level transforms (e.g., PlanckianJitter, HEStain, dithering) and is used in both academic and production settings.
SplatHash is a polyglot image perceptual hashing library that compresses any image into exactly 16 bytes and reconstructs a 32x32 preview. The algorithm decomposes images into a background color and six Gaussian blobs (Splats) using Oklab color space, finds optimal Splat positions via sequential matching pursuit, refines weights with ridge regression, and packs everything into 128 bits. Implementations exist in Go (reference), TypeScript, and Python, all producing bit-identical output for cross-language parity. The system is designed for use as image placeholders during loading, prioritizing decode speed over encode speed.
Boost.GIL (Generic Image Library) is a mature, header-only C++14 library for generic image processing, part of the Boost collection. It abstracts image representations from algorithms using template metaprogramming, enabling compile-time polymorphism and performance comparable to hand-written code for specific image types. The library provides core abstractions for pixels, channels, color spaces, image views, locators, and iterators, alongside a comprehensive I/O extension supporting JPEG, PNG, TIFF, BMP, PNM, Targa, and RAW formats. Image processing capabilities include convolution, thresholding (binary, adaptive, Otsu), histogram equalization/matching, morphological operations, edge detection (Sobel, Scharr, Harris, Hessian), Hough transforms (lines, circles), anisotropic diffusion, Lanczos resampling, and rasterization of geometric primitives. The library is designed for both application development and research, with a strong emphasis on extensibility, performance, and portability across compilers. While primarily a production-quality library, its extensive use of concepts and metafunctions also makes it a valuable resource for studying generic programming patterns in C++.
Rastermill is a Node.js image processing library that provides a unified API for probing, transparency inspection, and encoding (resize, convert, byte-budget search). It uses Photon (WASM) in-process for common formats (PNG, JPEG, GIF, WebP, BMP) and falls back to native tools (sips, ImageMagick, GraphicsMagick, ffmpeg, Windows System.Drawing) for formats like HEIC/AVIF or when quality-controlled WebP is needed. The library enforces pixel budgets to prevent decompression bombs, strips metadata by default, handles EXIF/HEIF orientation, and supports cancellation via AbortSignal. It is designed for server-side and agent-facing media pipelines. The codebase is a single well-structured TypeScript module with comprehensive tests and CI coverage.
Pixelorama is a full-featured open-source pixel art editor built with the Godot Engine (GDScript). It provides a professional-grade environment for creating pixel art, sprites, tiles, and animations. The application includes a rich set of drawing tools (pencil, line, curve, shape tools, bucket, gradient, shading), selection tools (rectangle, ellipse, lasso, magic wand, color select), and a comprehensive layer system supporting pixel, group, tilemap, 3D, and audio layers. Animation is handled through a timeline with keyframe interpolation, onion skinning, and frame tags. The editor supports a variety of import and export formats including Aseprite, Krita, Photoshop, Piskel, PNG, GIF, APNG, MP4 (via FFmpeg), and its own .pxo project format. It features a dockable UI, customizable shortcuts, extension support, shader-based non-destructive layer effects, and a built-in noise generator and gradient editor. The codebase demonstrates a well-structured tool inheritance hierarchy, a robust undo/redo system, and several reusable custom UI widgets and addons.
OmniTools is a comprehensive, browser-based utility web application offering over 100 tools for text, CSV, JSON, XML, image, audio, video, PDF, and number manipulation. All processing occurs client-side using WebAssembly (FFmpeg, Ghostscript, Tesseract) and pure JavaScript, ensuring no data leaves the user's device. The application is built with React 18, TypeScript, Material UI, and Vite, and is fully internationalized with 11 languages. It follows a consistent tool architecture: each tool is defined via a `defineTool()` function with metadata, lazy-loaded components, and a uniform UI pattern using `ToolContent` wrapper, reusable input/result components, and dynamic option rendering. The codebase demonstrates strong engineering practices with extensive unit tests (Vitest), end-to-end tests (Playwright), CI/CD pipelines (GitHub Actions, Docker multi-platform builds, Netlify deployment), and a well-organized file structure. While the project is actively maintained and well-crafted, it exhibits some boilerplate duplication across tools and a large dependency surface that could introduce maintenance overhead.
imageproc is a Rust library providing a comprehensive suite of image processing operations built on top of the `image` crate. It includes a wide range of filters (Gaussian blur, bilateral, median, sharpen), geometric transformations (rotation, scaling, warping, projection), drawing primitives (lines, shapes, text with font rendering), feature detection (FAST corners, BRIEF descriptors, Hough lines, HoG, Haar-like features), contrast manipulation (histogram equalization, Otsu thresholding), morphology (dilation, erosion, structuring elements), distance transforms, template matching, seam carving, image hashing, and noise addition. The library is designed for performance with extensive use of `unsafe` code where justified, and provides both mutable and immutable API variants, as well as parallel execution via the `rayon` feature. It serves as a practical tool for computer vision and graphics editors, with a focus on correctness and reproducibility (regression tests against reference images). The crate is modular, with each major operation in its own file, and includes many examples demonstrating realistic workflows like edge detection, object matching, and text overlay. While not a research project, it implements classic computer vision algorithms with modern Rust idioms and is actively maintained with regular releases.
The sentinel2-cloud-detector repository provides a Python package (s2cloudless) for detecting clouds in Sentinel-2 satellite imagery. It implements a pixel-based cloud detector using a pre-trained LightGBM model that takes Sentinel-2 spectral bands as input and outputs cloud probability maps or binary masks with optional post-processing (convolution and dilation). The package is designed as a reusable library for integration into remote sensing workflows. The architecture consists of three core modules: cloud_detector.py (containing the main S2PixelCloudDetector class), pixel_classifier.py (a generic wrapper for applying pixel-wise classifiers over image data), and utils.py (helper functions for data loading and image processing operations). The PixelClassifier class is particularly notable for its reusability, as it decouples the classification logic from the specific model and can work with any classifier adhering to the scikit-learn API (e.g., scikit-learn models, LightGBM). The package includes comprehensive unit tests, CI/CD pipelines for multiple Python versions, and follows modern packaging standards for distribution via PyPI and Conda. The package actively maintains compatibility with current dependencies (lightgbm, numpy, opencv, sentinelhub) and avoids deprecated APIs. It demonstrates strong software engineering practices through clear separation of concerns, type hints, and comprehensive documentation. While the S2PixelCloudDetector class is tailored to the specific cloud detection use case, the underlying PixelClassifier utility represents a broadly applicable pattern for pixel-wise image classification tasks.
Upscayl is a cross-platform desktop application for AI-powered image upscaling, built with Electron and Next.js. It uses Real-ESRGAN models via the ncnn inference engine (Vulkan backend) to upscale images by 2x-4x. The application provides a rich UI with model selection, batch processing, double upscaling, custom model support, and extensive settings (GPU selection, tile size, TTA mode, metadata preservation). It also includes a cloud API (Upscayl Cloud) for server-side upscaling, documented via OpenAPI. The codebase is well-structured with clear separation between Electron main process and Next.js renderer, using Jotai for state management, Radix UI primitives, and a comprehensive localization system supporting 17 languages. While primarily an application, it contains pre-trained neural network model files (.param, .bin) that are research artifacts, giving it a hybrid character.
A comprehensive tool for removing watermarks from Gemini AI-generated images and videos. It provides multiple deployment options: a Chrome extension, a Tampermonkey userscript, an npm package (SDK), a CLI, and an AI agent skill. The core algorithm uses mathematically exact reverse alpha blending with pre-calibrated alpha maps to remove the Gemini logo without degrading underlying image quality. The system includes a sophisticated pipeline for detection, candidate selection, alpha trial, repair, and quality evaluation, with support for both image and video watermark removal. The repository is hybrid: while primarily an application, it contains an extensive set of data/research scripts for benchmarking, alpha profile analysis, video residual analysis, and release quality gating, reflecting a data-driven development approach. The codebase is well-structured with clear separation of concerns, extensive test coverage, and modular components that can be reused in other projects.
ADetailer is a script extension for AUTOMATIC1111's Stable Diffusion Web UI that performs automatic object detection and inpainting. After an initial image is generated, it runs detection models (YOLOv8, YOLO World, MediaPipe face detection/mesh) to identify objects such as faces, hands, or persons. It creates masks from the detections and performs targeted inpainting on those regions using separate prompts, denoising strength, and other configurable parameters. The extension supports multiple detection models per run, ControlNet integration for guided inpainting, and various mask preprocessing options (dilation/erosion, offset, merge, invert, filtering by area/confidence). It also provides a REST API for querying version, schema, and available models. Architecturally, ADetailer is a plugin that hooks into the webui's script system. It consists of several internal modules: `adetailer/` contains the core detection logic (ultralytics and mediapipe wrappers), mask processing functions, argument validation using pydantic, and utility functions for model management. The `aaaaaa/` module provides webui-specific helpers for compatibility, UI generation, and rich traceback formatting. The `controlnet_ext/` module handles ControlNet integration for both standard and Forge versions. The main script `scripts/!adetailer.py` orchestrates the entire pipeline: argument parsing, detection, mask preprocessing, and inpainting for each detected object. Key features include: support for multiple detection models simultaneously, configurable per-tab settings, dynamic denoising strength based on bounding box size, optimal crop size calculation for inpainting (SDXL and free modes), XYZ grid support for batch experimentation, and a comprehensive settings panel in the webui. The codebase demonstrates good engineering practices with type hints, pydantic validation, comprehensive tests, and clean separation of concerns.
This is a high-performance SVG rendering library for Node.js, Deno, Bun, and browsers, powered by the Rust `resvg` engine. It converts SVG to PNG/AVIF with support for cropping, scaling, background colors, custom fonts (including WOFF2), bounding box extraction, and simplified SVG output. The library is implemented as a native addon via `napi-rs` for optimal speed on server-side runtimes, and also ships a WebAssembly build for browsers and edge environments. The codebase is well-structured, with clean separation between Rust core (rendering, option handling, font management) and JavaScript/TypeScript bindings. It includes comprehensive test suites, cross-platform CI/CD with prebuilt binaries for 18+ platforms, and thorough examples. The architecture demonstrates high craftsmanship in memory management (ObjectFinalize), error handling (panic catching), and pattern reuse (shared crop logic between NAPI and WASM).
This is a WPF desktop application (.NET Framework 4.8) that provides a graphical user interface for the rimage image compression command-line tool. The application allows users to batch convert images with various codecs (MozJPEG, WebP, AVIF, PNG, JPEG XL, etc.), control quality, quantization, dithering, output suffixes, resize options, and output directory policies. It features a dual-pane layout with a file list on the left and conversion settings on the right, live progress tracking, light/dark theme following the Windows system setting, and bilingual Chinese/English UI. The rimage backend executable is embedded and verified by SHA-256 hash and version probe before use. The codebase demonstrates solid engineering: clean separation between core logic (command building, validation, job execution) and UI (view models, converters, custom controls), comprehensive unit tests covering both logic and integration with the backend, and attention to edge cases (trailing backslash quoting, metadata-driven output paths, chunked job execution for progress reporting). The repository is actively maintained with a clear MIT license.
napari-chatgpt (Omega) is an LLM-powered autonomous agent designed as a napari plugin for interactive image analysis. It enables users to interact with the napari viewer via natural language through a chat interface, either embedded in napari or via a web-based UI. The system processes user commands by leveraging LLMs (via LiteMind) to select and execute appropriate tools for tasks such as image loading, segmentation, denoising, widget creation, viewer control, web search, and code execution. The architecture centers around a plugin-contributed dock widget that launches a chat interface, which communicates with a FastAPI/WebSocket backend. The backend hosts the Omega agent, which uses a modular tool system where each tool (e.g., for file operations, segmentation, or web requests) inherits from a base class and is responsible for executing specific actions. The agent can iteratively refine its actions through dialogue, enabling complex workflows like 'segment nuclei and show measurement statistics'. Key external dependencies include napari (>=0.5), LiteMind, LLM provider libraries (OpenAI, Anthropic, Google), FastAPI, Qt bindings, and scientific libraries like scikit-image, Cellpose, and StarDist.
JavaCV is a Java wrapper library for computer vision and multimedia processing, providing bindings to OpenCV, FFmpeg, and other native libraries via JavaCPP Presets. It offers a unified abstraction layer for video capture (FrameGrabber), recording (FrameRecorder), filtering (FrameFilter), and frame conversion (FrameConverter), with concrete implementations for file, stream, camera, and depth sensor sources. The library also includes advanced computer vision capabilities such as geometric and color calibration, image alignment (Gauss-Newton), projective transformations, blob analysis, marker detection for augmented reality, and OpenCL-accelerated image processing. It is primarily a library (not a standalone application), with sample programs demonstrating real-time video streaming, face detection, object tracking, and projector-camera systems. The codebase is large and well-structured, with abstract base classes and reusable patterns, but shows signs of technical drift due to reliance on deprecated OpenCV APIs (IplImage) and legacy native SDKs. Maintenance is active, with frequent updates to keep pace with upstream library versions.
rclip is a command-line semantic photo search tool that indexes local image collections using a CLIP model (OpenCLIP ViT-B/32-256) and supports natural-language, image-to-image, and combined queries with boolean operations. The core architecture is monolithic: a Python package with modules for model inference (ONNX/CoreML), SQLite-based feature caching, image preprocessing, and a Textual terminal user interface for interactive browsing. It is fully offline and privacy-preserving, supporting a wide range of image formats including HEIC, raw (CR2, DNG, ARW), and standard web formats. The tool is distributed via PyPI, Snap, AppImage, Homebrew, and Windows MSI, with careful compliance management for third-party licenses, codecs, and model artifacts. It includes an extensive test suite (unit and end-to-end), CI/CD via GitHub Actions, and a compliance toolkit that enforces license policies during builds. The codebase is well-structured and demonstrates good engineering practices, though it relies on a pinned version of textual-image that uses a private API, introducing some technical drift risk.
This is a favicon API service built with TypeScript, Hono, and Bun that fetches and serves website favicons. The application provides a single HTTP endpoint that accepts a domain parameter, discovers favicons from multiple sources (HTML link tags, web manifest, common locations), optionally falls back to Google's favicon API, processes images (resize/format conversion), and returns either the image or JSON metadata. It's designed to be stateless and deployed behind a caching layer (CDN or reverse proxy) for production use. The codebase demonstrates strong modular architecture with clear separation of concerns, proper error handling, security features like SSRF protection, and comprehensive test coverage.
Tachyon is a production-grade serverless image resizing service built on AWS Lambda and S3. It takes HTTP requests that specify a path to an S3 object and query parameters (width, height, crop, quality, format, etc.), fetches the original image from S3 using the AWS SDK v3, resizes/transcodes it in-memory using the Sharp library (with support for animated GIF/WebP/PNG and smart cropping via smartcrop-sharp), and streams the result back to the client with appropriate cache headers. It natively supports presigned S3 URLs for accessing private objects by implementing a custom request signer that re-attaches presigned query parameters to the S3 GetObject call—bypassing the default SDK signing. The function is designed to be deployed as a single Lambda behind a Function URL (response streaming) or API Gateway, and includes a local development server for testing. While its primary use case is WordPress media handling (as part of the Human Made ecosystem), the core resizing and S3-fetching logic is framework-agnostic and could be adapted to any serverless image processing pipeline.
ZXing (Zebra Crossing) is a mature, multi-format barcode image processing library written in Java. It provides both decoding and encoding capabilities for over 15 1D and 2D symbologies, including QR Code, Data Matrix, Aztec, PDF417, UPC/EAN, Code 128, and many more. The core library is platform-independent, with additional modules for Android (Barcode Scanner app), Java SE (command-line tools), and web applications (a decode servlet and a GWT-based generator). The architecture follows a clean Reader/Writer interface pattern, with format-specific implementations decoupled from common infrastructure like Reed-Solomon error correction, binarization, and perspective transformation. The library is in maintenance mode: no new features are planned, but bug fixes and minor enhancements from the community are accepted. The Android app is deprecated and does not work on Android 14. Despite its age, the codebase remains a reference implementation for barcode standards and is widely ported to other languages.
google-images-download is a Python application for searching and downloading images from Google Images. It functions as both a command-line tool and a library that can be imported into other Python scripts. The system uses Selenium with Chrome to handle JavaScript-heavy Google Images pages, automatically manages chromedriver via webdriver-manager, and supports extensive filtering options (size, color, format, usage rights, etc.). Key features include filename sanitization for cross-platform compatibility, metadata extraction, similar image search, and robust error handling for network issues. The architecture is monolithic with a clear separation between argument parsing, URL building, browser automation, and download execution.