Learn Practical Approach to OpenCV using Kotlin

Install the IntelliJ IDE (community edition) on Windows, download and install the OpenCV library, create a new Kotlin project, configure OpenCV, and verify the setup with a basic file.

Learn to set up a Kotlin JVM project for OpenCV on Windows, extract the OpenCV library, and configure the jar and native dll dependencies for image scanning.

Learn how to install and run OpenCV on Windows with Kotlin, covering dependency setup, loading native libraries, classpath configuration, and handling common runtime errors.

Follow Linux OpenCV installation steps from the docs, build the OpenCV jar and native libraries, and reference them in your IntelliJ Kotlin project using the GitHub workflow.

Modify the build.gradle to set the local OpenCV jar path and native path, accounting for Windows, Mac, and Linux directory differences.

Learn to checkout code versions from a repository using IDE or terminal, switch branches, and reset changes with git commands such as git checkout, git status, and git reset --hard.

Apply a set of common image filters in OpenCV using Kotlin, including negative, black-and-white, denoising, sharpening, smoothing, and crisper effects, as you move from concept to code.

Explore OpenCV APIs via the docs, then implement a Kotlin negative image filter in a filters package, set up tests with TDD, and load the native library.

Learn to perform a negative image transformation with OpenCV in Kotlin by loading an image from resources, handling absolute paths, and addressing OpenCV Java library path issues.

Explore creating a negative image in Kotlin using OpenCV by applying bitwise not, testing input/output semantics, and saving results for visual verification.

Explore how the OpenCV threshold API converts grayscale images to binary using fixed level thresholding, detailing input and destination images, threshold and max value, and methods like dynamic and triangle.

Learn to apply binary thresholding in OpenCV with Kotlin by converting color images to grayscale, applying a 128 threshold, and saving the black-and-white result.

Explore thresholding with otsu thresholding and triangle thresholding to convert images to binary, compare manual and automatic thresholds, and apply histogram equalization and adaptive histogram equalization to improve results.

Apply thresholding in OpenCV using Kotlin with a grayscale image, experimenting with clip limit and grid size, and compare manual, auto, and normalized thresholds to improve text visibility.

Explores thresholding by trying different parameters and comparing results, and demonstrates code refactoring by extracting grayscale conversion and adaptive histogram equalization into dedicated functions for clearer Kotlin OpenCV workflow.

Implement a grayscale filter that converts a color image to grayscale using an OpenCV approach in Kotlin, with tests and refactoring toward reusable image filters.

Explore how to remove noise from images using OpenCV denoise APIs, including fast non-local means and primal-dual approaches, with color images spanning three channels.

Explore denoising with the FastNL mean denoise API to remove noise from a color image, implementing a remove noise filter, configuring h, window size, and search window through tests.

Apply fastnl mean denoise and colored denoise APIs in OpenCV with Kotlin to remove image noise while balancing detail loss through the h parameter and window sizes.

Explore image sharpening in OpenCV using Kotlin by implementing a custom sharpening filter, and compare gaussian blur for noise removal with Laplacian edge enhancement.

Implement sharpening in OpenCV with a Laplacian filter by converting to grayscale, applying Laplacian to highlight edges, and observing edge enhancement despite noise through practical notebook experiments.

Learn how to sharpen color images by combining Gaussian blur with a Laplacian filter, then switch to YUV space and process the luminance channel for stronger edges.

Sharpen the color image by processing the y channel with blur and noise reduction. Merge the sharpened y into rgb output and compare it to the original for enhanced detail.

Learn how to refactor a sharpening routine in OpenCV with Kotlin by extracting the Y channel in a YCbCr color space, sharpening it, and merging it back after blur.

Explore smoothing techniques in OpenCV using Kotlin, including averaging, Gaussian blur, median blur, and bilateral filtering, with emphasis on low pass filtering to remove noise while preserving edges.

Implement gaussian smoothing in OpenCV with Kotlin, test its effects on color images, and explore normalization and YUV conversion to preserve edges while reducing noise.

Demonstrate smoothing with a bilateral filter on color images, compare it with Gaussian smoothing, and analyze how histogram equalization and normalization affect edge preservation and noise reduction.

apply smoothing to a defined region of an image with OpenCV and Kotlin, using region to blur concepts and Gaussian filtering, plus tests to verify partial versus full-image smoothing.

Refactor tests by extracting common assertions into a Kotlin utility, switch to are equal checks, and validate size, channel, and type for grayscale and color images.

Explores unsharp masking to sharpen images by subtracting a Gaussian blurred version to create a mask, then adding it back to enhance details and local contrast using OpenCV.

Learn to implement an unsharp mask filter in Kotlin with OpenCV, sharpening color images by working on the luminance channel in YUV, using Gaussian blur, a mask, and a boost.

Apply a variety of image filters in OpenCV with Kotlin, including negative, black and white, grayscale, denoising, sharpening, and smoothing via a unified filter interface and a custom algorithm.

Explore OpenCV geometric transformations, focusing on rotating images and applying scaling, translation, affine and perspective transforms, with code examples and practical implementation.

Learn to rotate images with the OpenCV Kotlin API, using a source image and DST, and apply 90 degree clockwise, 180, or 270 degree rotations via rotate_90_clockwise, rotate_180, and rotate_270.

Explore implementing rotation transformation in OpenCV using Kotlin, including a rotate API, test setup, and verifying output shape and type for a 90-degree clockwise rotation.

Refactor rotation logic by extracting rotation into the constructor and introducing a rotation direction enum, making the code flexible. Sometimes we need non-90-degree rotations, but the API restricts 90-degree increments.

Learn to rotate images in Kotlin using OpenCV by applying a 2d rotation matrix and warpAffine, leveraging getRotationMatrix2D, center, angle, and scaling concepts.

Rotate an image by a specified angle using a 2D rotation matrix. Center-based rotation in Kotlin with fixed and arbitrary directions, and observe black filling.

Learn how to scale images with OpenCV's resize API in Kotlin, by specifying output size or scale factors and choosing interpolation methods for shrinking or enlarging.

Explore scaling up images in OpenCV using Kotlin by applying the resize API with inter_linear and inter_cubic interpolation.

Learn to implement scaling down in OpenCV with Kotlin by adding a configurable scaling transformation, controlling output size, scale in x and y, and default algorithms, validated by tests.

Explore scaling in OpenCV with Kotlin by applying different x and y scale factors, selecting a scale type and interpolation such as linear and cubic to scale images.

Explore translation in OpenCV using Kotlin: shift an image in x and y with a 2x3 transformation matrix and affine operations.

Implement translation transformation in Kotlin using OpenCV, create a 2x3 transformation matrix, configure shift in x and y, and validate image size and type with tests.

Straighten warped documents with perspective transform in OpenCV using Kotlin by selecting four noncollinear points, computing a three-by-three matrix, and applying warp perspective for a corrected image.

Learn how to implement perspective transformation in OpenCV with Kotlin by selecting four source and destination points, computing the perspective transformation matrix, and validating results with tests.

Refactor perspective transformation to derive the destination size from the source points by computing max width and max height, with optional user-supplied destination and dynamic validation.

Learn practical OpenCV techniques in Kotlin, including rotating images with a transformation matrix, scaling, translating, and applying perspective transforms using four points.

Explore histogram equalization to balance dark and light areas and enhance image contrast. Learn how OpenCV's equalizeHist distributes intensity values across the full range, often after converting to grayscale.

Learn to apply histogram equalization for grayscale images using OpenCV in Kotlin, implementing contrast enhancement, testing, and visualization while handling single-channel limitations.

Learn how to apply histogram equalization to color images in OpenCV with Kotlin by converting to YUV, equalizing the Y channel, and merging channels back to produce enhanced color images.

Introduce gamma correction for dark image enhancement in OpenCV with Kotlin, explaining the non-linear power-law formula, gamma encoding and decoding, and preparing code implementation for contrast improvement.

Implement gamma correction in OpenCV with Kotlin by building a gamma correction class and a contrast enhancement interface, testing grayscale and non-gray images with a gamma around 0.5.

Implement gamma correction for grayscale images in Kotlin OpenCV, map 0–255 values through a gamma power curve, and iterate pixels to update the output image.

Learn how gamma correction enhances dark regions in color images using OpenCV with Kotlin, showcasing a gamma value of 0.8 and the need to align input type, channel, and size.

Learn how clahe enables adaptive histogram equalization by dividing images into tiles, clipping high bins at a contrast limit, and applying bilinear interpolation to preserve details.

Learn contrast limited adaptive histogram equalization (CLAHE) in OpenCV with Kotlin, configuring clip limit and tile grid size to enhance grayscale images and extend to color images.

Explore applying adaptive histogram equalization (CLAHE) to color images by processing the Y component, adjusting clip limits, and comparing results with global histogram equalization.

Understand how to correct saturation by adjusting contrast and brightness with OpenCV, using the convert to API via alpha and beta, and compare saturation-only methods with gamma correction.

Apply saturation correction using alpha and beta to grayscale and color images in OpenCV with Kotlin, and compare results to gamma while testing with practical configurations.

Explore a side-by-side comparison of enhancement algorithms in OpenCV, including gamma correction, contrast and saturation adjustments, histogram equalization, and adaptive histogram equalization, focused on selecting major details while discarding others.

Explore how imadjust algorithm (from matlab) compares to OpenCV approaches in Kotlin, evaluating histogram equalization, region based histogram equalization, saturation correction, and gamma correction for image enhancement.

Explore how the image intensity adjustment API maps input to output, saturates, and adjusts contrast for grayscale and RGB, with low in, high in, low out, high out and gamma.

Learn a Kotlin-based OpenCV custom enhancement algorithm for single-channel images, using input and output bounds, saturation handling, and a cumulative histogram approach to determine bounds and map pixels.

Explore a grayscale contrast enhancement using a custom imadjust algorithm. Implement histogram and cumulative histogram based bounds with saturation percent to adjust pixel values, then extend to color later.

Refactor and parameterize the image contrast pipeline in kotlin by introducing a config class with saturation, input and output bounds, histogram usage, and a linear transformation for color image transformations.

Demonstrate adding a color image test in OpenCV with Kotlin, using a contrast png, validating input type matches color images, and comparing results with official website and Matlab.

Learn to extend OpenCV with Kotlin from grayscale to color images by using the y component of YUV, extracting and merging it back, and adding color channel checks.

Refactor and test a color image enhancement pipeline in Kotlin using OpenCV, exploring config-driven saturation and input/output bounds to improve color transformation. Apply and compare multiple config variations.

Learn practical approaches to OpenCV using Kotlin by applying enhancement algorithms such as histogram equalization, adaptive histogram equalization, saturation, gamma correction, and a custom Matlab-inspired method.

Learn to apply image filters and transformations such as scaling, translation, and rotation in OpenCV with Kotlin, and explore contrast enhancement algorithms and adding text or diagrams to images.

Learn to add text to images using OpenCV in Kotlin, exploring text APIs, styling, positioning, rotating text, applying effects, and extending to add shapes or objects to images.

Learn to render text on images with OpenCV, choosing font, size, color, thickness, and anti-aliasing, use text size API to allocate space, and explore drawing rectangles and polylines in Kotlin.

Implement a text operation in a Kotlin OpenCV project to add text to images, with configurable position, font, color, and thickness, while fitting text within image boundaries.

Learn how to render text in OpenCV with Kotlin by drawing rectangles around text and adding shapes like logos, using adjustable thickness, font, scale, and origin.

Learn to add rotated text to an image using OpenCV in Kotlin by creating an empty image, applying a rotation, and merging the rotated text onto the image.

Fix text intensity issues in rotated text using Kotlin OpenCV by cloning the image, iterating pixels, destructuring color values, and conditionally updating the output with an intermediate image.

Refactor a text rendering module by extracting text size, best position, and add text to helper methods, improving readability, reducing duplication, and preserving functionality in OpenCV with Kotlin.

Explore advanced text operations in OpenCV using Kotlin, applying perspective transform to add rotated text and refine source point ordering for accurate transformation.

Refactor code to perform perspective transformation on text, introducing configurable transform parameters and point-based options to flexibly control how text images are transformed with OpenCV in Kotlin.

Learn how to add text to images, perform transformations like rotation and perspective transforms, and apply effects to add objects and style to images.

Explore implementing an undo mechanism for image processing in a Kotlin OpenCV project by managing state and applying design patterns to revert changes.

Explore a command-driven editor with state management, snapshots, and undo for image changes. See how the client, editor, and backup components track operations and restore previous image states.

Learn how the memento design pattern enables backup and undo in image editing for OpenCV projects using Kotlin, by saving image states in a history stack.

Explore the command design pattern as a behavioral pattern that wraps filter requests (gray, black and white, contrast) into command objects for an editor (the invoker) to execute, enabling delegation.

This code refactoring in the OpenCV Kotlin project moves config to parameters, improves readability, reuses utilities, and reduces coupling while keeping all tests passing.

Implement the editor and state manager for the image editor, enabling active image handling, image retrieval, and basic testing setup, with future interaction and backup of states.

Implement a Kotlin-based editor state manager to track image edits, initialize with an image, expose the active image via a safe clone, and validate behavior with tests.

Learn how a Kotlin OpenCV project uses a state manager and image editor to initialize, set and get the active image, and reset state with operation stacks and tests.

Implement and test reset of the image and its operation list using the state manager, ensuring the reset is invoked once and clears the operation list.

Explore implementing a snapshot (memento) pattern in a Kotlin OpenCV workflow. Model editor state with immutable images and operation history to enable undo and restore via a caretaker.

The editor creates snapshots that the caretaker maintains as a stack, enabling undo to restore previous states, with the state manager supplying operation info and active image.

Explore building a snapshot backup manager in a practical OpenCV Kotlin workflow, implementing a stack-based snapshot history, adding snapshots, and preparing for undo operations with tests and mocks.

Implement undo by restoring the last snapshot via the backup manager and updating the editor’s state. Verify that the backup manager calls snapshot.restore to revert the editor and image operations.

Implement undo by wiring the editor to call backup manager's run last snapshot to restore the image to its original state, validating the last snapshot is used during undo.

Demonstrate the client editor interaction using the command pattern, define a command interface for filters, contrasts, and transformations, and explain state, backup, and invoker-driven execution for reverts.

Implement a rotate command in a Kotlin image editor using a command interface, interacting with the editor to get and set the active image via rotation transformation, with unit tests.

Refactor the image editor to accept a command, implement a rotate command, and verify backup creation and command execution through tests using mocks.

Learn how the editor and client implement and test a robust operation type system to store image state changes, including rotation commands and parameter handling, with state manager integration.

Run tests to diagnose failures, implement missing operation types and rotation transform parameters, and refine mocks to complete the editor and client workflow for OpenCV in Kotlin.

Explore implementing a Kotlin OpenCV client with a command-based image editor, enabling rotation, black-and-white filtering, and undo via a state and backup manager.

Apply the abstract factory pattern to decouple object creation from concrete implementations, enabling families of related objects via factories for filters and transformations, and isolating client code from construction details.

Refactor the code to use a factory method for creating filter and transformation instances, replacing concrete dependencies with mocks and validating calls in unit tests.

Refactor OpenCV Kotlin code using a filter factory and contrast factory to create grayscale and adaptive histogram operations, decoupling from concrete implementations and validating changes with tests.

Explore how to implement undo of image edits by managing state, applying the necessary changes, and handling backup and editor-client interactions. Publish a shareable OpenCV Kotlin library for developers.

Package your OpenCV Kotlin code as a library for image processing in Android, web, or desktop apps, and publish it with a CI pipeline using GitHub packages.

Demonstrate how to publish a Kotlin Gradle project to GitHub packages by configuring authentication with a personal access token, selecting Gradle Kotlin DSL, and manually publishing artifacts to a repository.

Publish a Kotlin OpenCV library, resolve duplicate artifact errors, and access the artifact by importing it into a desktop IntelliJ project and an Android app.

Publish to GitHub packages and access the OpenCV Kotlin library from another project, using a read-only token, and apply perspective transform, boosting, and rotation.

Package your code as a library and publish it via Maven or GitHub packages, handling credentials. Then build a Gradle-based CI pipeline to run tests and automate publishing.

Explore CI options and implement a GitHub Actions workflow to publish OpenCV builds to GitHub packages for a Kotlin project, including setting up JDK and building jar and native binaries.

Set up a GitHub action to archive OpenCV artifacts and build with Gradle. Configure publishing to GitHub packages using Griddle and secret environment variables for user and key.

Refactor the Gradle build and library publish workflow for an OpenCV Kotlin project by incorporating environment-driven jar and native paths, CI workspace discovery, and parallel local and CI execution.

The lecture guides debugging a GitHub workflow for an OpenCV Kotlin project, updating a branch with a readme and badge, fixing an action upload artifact error, and re-running CI.

Learn how to debug a Gradle build for an OpenCV project in Kotlin, identify failures, and implement caching of OpenCV jar and binary artifacts to speed up builds.

Define caching for the OpenCV artifact with a cache key and patterns to restore from cache, skip runs when a cache hit occurs, and cache results otherwise.

Increment the artifact version to resolve a version-conflict in the publish library workflow, then push to GitHub package and verify the update on the packages page.

Learn to add a CI test pipeline for OpenCV in Kotlin, building from source, caching artifacts, and running unit and integration tests on Windows and Ubuntu before publishing the jar.

Build and verify a full CI/CD pipeline for a Kotlin OpenCV package, publishing to GitHub packages or Maven repositories and automating integration and unit tests.

Explore how to integrate the OpenCV library into Android apps with Kotlin, import dependencies, and use the image editor for document scanning and image processing.

Clone the image scanner library from GitHub, set up GitHub properties and OpenCV jar paths, and configure your Android project to run the image editor in Kotlin.

Import the OpenCV SDK into Android Studio by selecting import module and pointing to the OpenCV SDK directory, then name the module for automatic indexing and setup.

Learn how to integrate the OpenCV SDK in a Kotlin project by managing modules and dependencies, and explore a reactive image editor workflow with dependency injection.

Demonstrate a practical OpenCV Kotlin workflow by showcasing an Android MVVM image editor that applies negative and rotate filters, supports undo, and runs via an emulator.

Import and test a custom library in an Android app, add a Maven repository entry, fix issues, and explore a few image editor operations.

Explore OpenCV with Kotlin to auto-detect a document in an image, outline its boundary, crop it, and prepare for OCR across Android, Windows, Mac, and Linux.

Learn a Kotlin OpenCV workflow to enhance details, remove noise, thresholding to binary, dilate edges, detect Canny edges, and locate document corners with hog lines, k-means, and Graham scan.

Demonstrates a Kotlin OpenCV workflow from grayscale conversion and contrast enhancement through binary thresholding and edge detection, to line detection and boundary estimation using Graham scan and convex hull.

Demonstrate end-to-end region-of-interest detection in OpenCV with Kotlin, applying grayscale filtering, contrast enhancement, thresholding, edge detection, convex hull via graham scan, and perspective crop.

Explore how to automatically detect a document in an image and crop it using OpenCV with Kotlin, demonstrated through examples like Adobe Scan, by writing code in the module.