DEV Community: San Askaruly

A Visual Guide to Affine Transformations: Translation, Scaling, Rotation, and Shear

San Askaruly — Thu, 05 Dec 2024 10:00:00 +0000

Image credits: murray, Stack Exchange

What is affine transformation exactly?

Affine transformation is a technique used in image processing to modify the geometry of an image while preserving certain properties. It's a combination of linear transformations that can change an image's position, size, shape, and orientation [1, 2].

In simple terms, affine transformations allow you to:

Move the image (translation)
Resize the image (scaling)
Tilt or slant the image (shear)
Rotate the image (rotation)

These transformations can be applied individually or combined to achieve various effects [1, 2]. The key characteristic of affine transformations is that they preserve:

Straight lines (they remain straight after transformation)
Parallel lines (they stay parallel after transformation)
Ratios of distances between points on a line [3, 4]

Why is it useful to know

In the context of image processing, affine transformations are commonly used to:

Correct distortions in images, such as those caused by camera angles or lens effects
Align or register multiple images
Prepare images for further analysis or processing

For example, in satellite imagery, affine transformations help correct distortions from wide-angle lenses and create accurate, flat maps from curved Earth images [2]. This makes it easier to analyze and work with the imagery without having to account for distortions.

Outline of this post

In this tutorial, we will cover and visualize common affine transformations: translation, scaling, shear and rotation. We will use Python code from OpenCV and NumPy libraries. The post is structured as follows:

Definitions
Translation
Scale
Shear
- Shear in X-direction
- Shear in Y-direction
Rotation
References

Source code: https://github.com/tuttelikz/notes/blob/main/affine/code.ipynb

Definitions

Mathematically, an affine transformation is a relation between two images that can be expressed as a matrix multiplication (linear transformation), $A$ , followed by a vector addition (translation), $B$ .

T=A\cdot\begin{vmatrix} x \\ y \end{vmatrix}+B=\begin{vmatrix} a_{00} & a_{01} \\ a_{10} & a_{11} \end{vmatrix}\cdot\begin{vmatrix} x \\ y \end{vmatrix}+\begin{vmatrix} b_{00} \\ b_{01} \end{vmatrix}

T=\begin{vmatrix*}[r] a_{00}x+a_{01}y+b_{00}\\ a_{10}x+a_{11}y+b_{10} \end{vmatrix*}

In Python, affine transformation can be realized using cv2.warpAffine. However, we should supply the $2 \times 3$ transformation matrix, $M$ .

import cv2

src = cv2.imread("images/lena.jpg")
h, w = src.shape[:2]

# M is affine transformation matrix which shall be defined
warp_dst = cv2.warpAffine(
    src=src, M=M, dsize=(w, h)
)

Translation

To perform image translation, the elements of $A$ and $B$ should be as follows:
$A=\begin{vmatrix} a_{00} & a_{01} \\ a_{10} & a_{11} \end{vmatrix}=\begin{vmatrix} 1 & 0 \\ 0 & 1 \end{vmatrix}$

$B=\begin{vmatrix} b_{00} \\ b_{01} \end{vmatrix}=\begin{vmatrix} dx \\ dy \end{vmatrix}$
where $d x$ is desired shift in horizontal direction, whereas $d y$ represents shift in vertical direction. Remembering that affine transformation is $T=A\cdot\begin{vmatrix} x \\ y \end{vmatrix}+B$ , we can simply derive a translation transformation for the simplest case. Let's take as an example four coordinates: $(0, 0), (0, 1), (1, 0), (1, 1)$ and derive where each of these points should be located after translation:

$\rightarrow A'=(dx, dy)$
$\rightarrow B'=(dx, 1+dy)$
$\rightarrow C'=(1+dx, dy)$
$\rightarrow D'=(1+dx, 1+dy)$

To be able to translate an image using cv2.warpAffine mentioned previously, $2 \times 3$ transformation matrix $M$ can be created using NumPy as follows:

import numpy as np

dx = 20 # shift in X (pixels)
dy = 50 # shift in Y (pixels)
M = np.array([
    [1,0,dx],
    [0,1,dy]
]).astype(np.float32)

And here is the output of image translation:

Note: You may have noticed that translation of the image is inverted when compared to the graph. This is because in an image, the origin is at the top-left corner, and the y-axis goes down, while in a typical coordinate system, the origin is at the bottom-left, and the y-axis goes up.

Scale

To perform image scaling, the elements of $A$ and $B$ should be as follows:
$A=\begin{vmatrix} a_{00} & a_{01} \\ a_{10} & a_{11} \end{vmatrix}=\begin{vmatrix} wx & 0 \\ 0 & wy \end{vmatrix}$

$B=\begin{vmatrix} b_{00} \\ b_{01} \end{vmatrix}=\begin{vmatrix} 0 \\ 0 \end{vmatrix}$

where $w x$ is desired scaling in horizontal direction, whereas $w y$ represents scaling in vertical direction. Remembering that affine transformation is $T=A\cdot\begin{vmatrix} x \\ y \end{vmatrix}+B$ , we can simply derive a scaling transformation for the simplest case. Let's take as an example four coordinates: $(0, 0), (0, 1), (1, 0), (1, 1)$ and derive where each of these points should be located after scaling:

$\rightarrow A'=(0, 0)$
$\rightarrow B'=(0, wy)$
$\rightarrow C'=(wx, 0)$
$\rightarrow D'=(wx, wy)$ To be able to scale an image using cv2.warpAffine mentioned previously, $2 \times 3$ transformation matrix $M$ can be created using NumPy as follows:

import numpy as np

wx = 2 # scale in horizontal direction
wy = 3 # scale in vertical direction
M = np.array([
    [wx,0,0],
    [0,wy,0]
]).astype(np.float32)

And here is the output of image scaling:

Shear

Shear in X direction

To perform shear in X direction, the elements of $A$ and $B$ should be as follows:
$A=\begin{vmatrix} a_{00} & a_{01} \\ a_{10} & a_{11} \end{vmatrix}=\begin{vmatrix} 1 & \tan\phi \\ 0 & 1 \end{vmatrix}$

$B=\begin{vmatrix} b_{00} \\ b_{01} \end{vmatrix}=\begin{vmatrix} 0 \\ 0 \end{vmatrix}$

where $tan⁡ϕ\tan\phi$ represents amount of the horizontal shear. Remembering that affine transformation is $T=A\cdot\begin{vmatrix} x \\ y \end{vmatrix}+B$ , we can simply derive a horizontal shearing for the simplest case. Let's take as an example four coordinates: $(0, 0), (0, 1), (1, 0), (1, 1)$ and derive where each of these points should be located after shearing:

$\rightarrow A'=(0, 0)$
$\rightarrow B'=(\tan\phi, 1)$
$\rightarrow C'=(1, 0)$
$\rightarrow D'=(1+\tan\phi, 1)$ To be able to horizontally shear an image using cv2.warpAffine mentioned previously, $2 \times 3$ transformation matrix $M$ can be created using NumPy as follows:

import numpy as np

phi = math.pi/8
M = np.array([
    [1,math.tan(phi),0], # amount of shear in X direction
    [0,1,0]
]).astype(np.float32)

And here is the output of image shear in X direction:

Shear in Y direction

To perform shear in Y direction, the elements of $A$ and $B$ should be as follows:
$A=\begin{vmatrix} a_{00} & a_{01} \\ a_{10} & a_{11} \end{vmatrix}=\begin{vmatrix} 1 & 0 \\ \tan\psi & 1 \end{vmatrix}$

$B=\begin{vmatrix} b_{00} \\ b_{01} \end{vmatrix}=\begin{vmatrix} 0 \\ 0 \end{vmatrix}$

where $tan⁡ψ\tan\psi$ represents amount of the vertical shear. Remembering that affine transformation is $T=A\cdot\begin{vmatrix} x \\ y \end{vmatrix}+B$ , we can simply derive a vertical shearing transformation for the simplest case. Let's take as an example four coordinates: $(0, 0), (0, 1), (1, 0), (1, 1)$ and derive where each of these points should be located after shearing:

$\rightarrow A'=(0, 0)$
$\rightarrow B'=(0, 1)$
$\rightarrow C'=(1, \tan\psi)$
$\rightarrow D'=(1, 1+\tan\psi)$ To be able to vertically shear an image using cv2.warpAffine mentioned previously, $2 \times 3$ transformation matrix $M$ can be created using NumPy as follows:

import numpy as np

psi = math.pi/10
M = np.array([
    [1,0,0],
    [math.tan(psi),1,0] # amount of shear in Y direction
]).astype(np.float32)

And here is the output of image shear in Y direction:

Rotation

To perform rotation, the elements of $A$ and $B$ should be as follows:
$A=\begin{vmatrix} a_{00} & a_{01} \\ a_{10} & a_{11} \end{vmatrix}=\begin{vmatrix} \cos\theta & -\sin\theta \\ \sin\theta & \cos\theta \end{vmatrix}$

$B=\begin{vmatrix} b_{00} \\ b_{01} \end{vmatrix}=\begin{vmatrix} 0 \\ 0 \end{vmatrix}$

where $θ\theta$ represents desired angle of the rotation. Remembering that affine transformation is $T=A\cdot\begin{vmatrix} x \\ y \end{vmatrix}+B$ , we can simply derive a rotation transformation for the simplest case. Let's take as an example four coordinates: $(0, 0), (0, 1), (1, 0), (1, 1)$ and derive where each of these points should be located after rotation:

$\rightarrow A'=(0, 0)$
$\rightarrow B'=(-\sin\theta, \cos\theta)$
$\rightarrow C'=(\cos\theta, \sin\theta)$
$\rightarrow D'=(\cos\theta-\sin\theta, \sin\theta+\cos\theta)$ To be able to rotate an image using cv2.warpAffine mentioned previously, $2 \times 3$ transformation matrix $M$ can be created using NumPy as follows:

import numpy as np
import math

angle = math.pi/6 # rotation angle
M = np.array([
    [math.cos(angle),-math.sin(angle),0],
    [math.sin(angle),math.cos(angle),0]
]).astype(np.float32)

And here is the output of image rotation:

References

[1] Educative. What is affine transformation? Educative. Retrieved from https://www.educative.io/answers/what-is-affine-transformation
[2] MathWorks. Affine transformation. MathWorks. Retrieved from https://www.mathworks.com/discovery/affine-transformation.html
[3] Hughes, R. Affine transformation. University of Edinburgh. Retrieved from https://homepages.inf.ed.ac.uk/rbf/HIPR2/affine.htm
[4] Wikipedia. Affine transformation. Wikipedia. Retrieved from https://en.wikipedia.org/wiki/Affine_transformation

Thanks for reading! Stay tuned for more content, and feel free to share your thoughts and feedback! Your reactions help me improve and create even more useful posts 🙂

Alternate URL: https://github.com/tuttelikz/notes/tree/main/affine

How to use OpenMP to parallelize C++ using Visual studio

San Askaruly — Sun, 01 Dec 2024 10:00:00 +0000

Parallel programming is the process of breaking down a large task into smaller sub-tasks that can be executed simultaneously, thus utilizing the available computing resources more efficiently. OpenMP is a widely used API for parallel programming in C++. It allows developers to write parallel code easily and efficiently by adding simple compiler directives to their existing code.

The OpenMP C++ application program interface lets us write applications that effectively use multiple processors. In this tutorial, we will cover how to run a parallel code in Visual C++, which supports the OpenMP 2.0 standard.

Outline

Configure C++ project
- Create a new C++ project
- Enable OpenMP support
Run code
- Add code for parallel loop and Run

Source code: https://github.com/tuttelikz/notes/tree/main/openmp-vs/OpenMPApp

Configure CPP project

Create a new cpp project

Open Visual Studio > Create a new project > Set "C++", "Windows" and "Console" filters to find the template > click Next

Enable OpenMP support

Navigate to Project > Properties

Then C/C++ > Language > Open MP Support > Choose "Yes" > Apply > OK

Importanly, make sure precompiled headers are off by Precompiled Headers > Precompiled Header > Not Using Precompiled Headers > Apply > OK

Run code

Add code to `OpenMPApp.cpp` and Run

To test OpenMP functionality in C++ project, we defined a simple sum function which calculates result using conventional serial loop and parallel loop. Add the following code to OpenMPApp.cpp

#include <chrono> 
#include <iostream> 
#include <omp.h>

using namespace std;

// Serial for loop
int sum_serial(int n)
{
    int sum = 0;
    for (int i = 0; i <= n; ++i) {
        sum += i;
    }
    cout << "Serial result: " << sum
        << endl;

    return sum;
}

// Parallel for loop
int sum_parallel(int n)
{
    int sum = 0;
#pragma omp parallel for reduction(+ : sum) 
    for (int i = 0; i <= n; ++i) {
        sum += i;
    }
    cout << "Parallel result: " << sum
        << endl;

    return sum;
}

int main()
{
    int num_threads = 8;
    omp_set_num_threads(num_threads);

    const int n = 100000000;

    auto start_time
        = chrono::high_resolution_clock::now();
    int result_serial = sum_serial(n);
    auto end_time
        = chrono::high_resolution_clock::now();
    chrono::duration<double> serial_duration = end_time - start_time;

    start_time = chrono::high_resolution_clock::now();
    int result_parallel = sum_parallel(n);
    end_time = chrono::high_resolution_clock::now();
    chrono::duration<double> parallel_duration = end_time - start_time;

    cout << "Serial time elapsed: "
        << serial_duration.count() << " seconds"
        << endl;
    cout << "Parallel time elapsed: "
        << parallel_duration.count() << " seconds"
        << endl;
    cout << "Speedup for " << num_threads << " threads: "
        << serial_duration.count()
        / parallel_duration.count()
        << endl;

    return 0;
}

Press Start debugging to see the result

Thanks for reading! Stay tuned for more content, and feel free to share your thoughts and feedback! Your reactions help me improve and create even more useful posts 🙂

Alternate URL: https://github.com/tuttelikz/notes/tree/main/openmp-vs

Integrating OpenCV with Visual Studio C++

San Askaruly — Sat, 23 Nov 2024 10:00:00 +0000

To build an application with OpenCV we need to do two things, as stated in official docs:

Tell to the compiler how the OpenCV library looks;

We can do this by setting the path where the library files are and specify in which one of them to look.

Tell to the linker from where to get the functions or data structures of OpenCV;

During the build the linker will look into these libraries and add the definitions and implementation of all used functions and data structures to the executable file.

Outline

Get OpenCV
- Download OpenCV
- Extract downloaded archive
Configure C++ project
- Create a new C++ project
- Specify Include directories
- Modify Linkers
- Define Post-build events
Run code

Source code: https://github.com/tuttelikz/notes/tree/main/opencv-vs/OpenCVApp

Get OpenCV

Download OpenCV

Download latest OpenCV from the official Github repository: https://github.com/opencv/opencv/releases/tag/4.10.0, choose the one which ends with "windows.exe"

Extract downloaded archive

Specify a folder to extract (We will further call it "source-dir") > Extract

Confirm the extraction is completed to "source-dir"

Configure CPP project

Create a new cpp project

Open Visual Studio > Create a new project > Set "C++", "Windows" and "Console" filters to find the template > click Next

Give a project name

Set any name to the project > click Create

Set configuration

Solution configuration should be set same as follows: Configuration > "Release", Platform > "x64"

Specify Include directories

Navigate to Project > Properties

Then C/C++ > Additional Include Directories > Edit

Specify the build directory including the parent "source-dir", where OpenCV was extracted, eg. [source-dir]\opencv\build\include > OK

Modify Linkers

In the same properties menu choose Linker > Input

Then C/C++ > Additional Dependencies > Edit

Specify all ".lib" dependencies including the parent "source-dir", where OpenCV was extracted, eg. [source-dir]\opencv\build\x64\vc16\lib*.lib > OK

Define Post build events

If Windows path variable related to OpenCV is not set, the code execution cannot proceed.

Therefore, we must make sure that the required DLL files from OpenCV are copied to the project’s build directory. Instead of manually copying and pasting files after every build, this process can be automated using a post-build event. To do that, in properties menu, go to Build Events > Post-Build

Then, Command Line > Edit

Insert the following command, which tells Visual Studio to copy the OpenCV DLL into the appropriate build directory of your project:

xcopy [source-dir]\opencv\build\x64\vc16\bin\opencv_world4100.dll $(SolutionDir)$(Platform)\$(Configuration)\ /c /y > OK

After setting these parameters, make sure to click Apply > OK

Run code

Add code to `OpenCVApp.cpp` and Run

To test the imported library in C++ project, we defined a few functions from OpenCV to draw basic shapes. Add the following code to OpenCVApp.cpp

#include <opencv2/opencv.hpp>
#include <iostream>

int main() {
    // Create a blank image (black image) of size 400x400 with 3 color channels (RGB)
    cv::Mat image = cv::Mat::zeros(400, 400, CV_8UC3);

    // Draw a red circle at the center of the image
    cv::Point center(200, 200);  // Coordinates of the center
    int radius = 50;             // Radius of the circle
    cv::Scalar color(0, 0, 255); // Red color in BGR format (Blue, Green, Red)
    int thickness = -1;          // Thickness = -1 means filled circle
    cv::circle(image, center, radius, color, thickness);

    // Draw a green rectangle on the image
    cv::Rect rect(50, 50, 300, 100); // Rect(x, y, width, height)
    cv::Scalar rectColor(0, 255, 0); // Green color in BGR
    cv::rectangle(image, rect, rectColor, 2);

    // Display the image
    cv::imshow("Generated Image", image);

    // Wait for a key press
    cv::waitKey(0);

    // Clean up and close windows   
    cv::destroyAllWindows();

    return 0;
}

Press Start debugging to see the result

Thanks for reading! Stay tuned for more content, and feel free to share your thoughts and feedback! Your reactions help me improve and create even more useful posts 🙂

Alternate URL: https://github.com/tuttelikz/notes/tree/main/opencv-vs

Creating C++ DLL and using it in .NET

San Askaruly — Thu, 21 Nov 2024 10:00:00 +0000

When using C++ code in C#, we sometimes need to wrap the C++ code into a DLL (Dynamic Link Library) for several important reasons:

Interoperability

C# and C++ are fundamentally different languages with distinct runtime environments. C# runs on the .NET Common Language Runtime (CLR), while C++ typically runs as native code

Compilation and Linking

C++ code needs to be compiled into machine code that can be executed directly by the processor. C#, on the other hand, is compiled into intermediate language (IL) code that runs on the CLR

Reusability and Maintenance

Wrapping C++ code in a DLL promotes code reuse and easier maintenance

Outline

How to create a C++ DLL
Calling DLL function in .NET

How to create a cpp DLL

Source code: https://github.com/tuttelikz/notes/tree/main/cpp-dll-dotnet/CustomMath

Create a new DLL project

Open Visual Studio > Create a new project > Set "C++", "Windows" and "Library" filters to find the template > click Next

Give a project name

Set any name to the project > click Create

Create `operators.cpp`

Project > Add New Item > C++ File (.cpp) > Set name to .cpp file > Add

Add code to `operators.cpp`

We defined two simple functions as part of the library

#include "pch.h"

int multiply3(int n)
{
    return n * 3;
}

int add5(int n)
{
    return n + 5;
}

Create `operators.h`

Project > Add New Item > Header File (.h) > Set name to .h file > Add

Add code to `operators.h`

This code is responsible to export previously defined functions from the DLL

#pragma once
extern "C" __declspec(dllexport) int add5(int n);
extern "C" __declspec(dllexport) int multiply3(int n);

extern means that the entity has external linkage, i.e. is visible outside its translation unit (C or CPP file).
__declspec(dllexport) means that the symbol should be exported from a DLL. It is used when compiling the code that goes into the DLL.

Sources:

Calling DLL function in dotnet

Source code: https://github.com/tuttelikz/notes/tree/main/cpp-dll-dotnet/ClientApp

Create a console application

Open Visual Studio > Create a new project > Set "C#", "Windows" and "Console" filters to find the template > click Next

Give a project name

Set any name to the project > click Create

Create `CustomMathApi.cs`

Project > Add Class > Class > Set name to .cs file > Add

Add code to `CustomMathApi.cs`

A separate wrapper C# class is created to import DLL functions and interface calls from C#, like an API.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Runtime.InteropServices;
using System.Text;
using System.Threading.Tasks;

namespace CustomMathAPI
{
    public static class CustomMath
    {
        private const string _dllImportPath = @"C:\Users\saska\source\repos\notes\cpp-dll-dotnet\CustomMath\x64\Debug\CustomMath.dll";
        [DllImport(_dllImportPath, CallingConvention = CallingConvention.Cdecl)]
        public static extern int add5(int n);
        [DllImport(_dllImportPath, CallingConvention = CallingConvention.Cdecl)]
        public static extern int multiply3(int n);
    }
}

We should use System.Runtime.InteropServices
_dllImportPath is used to define a DLL function in managed code

Sources:

https://learn.microsoft.com/en-us/dotnet/api/system.runtime.interopservices.dllimportattribute.callingconvention?view=net-8.0#system-runtime-interopservices-dllimportattribute-callingconvention

Add code to `Program.cs`

This code calls the imported DLL functions and prints the result

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using CustomMathAPI;

namespace ClientApp
{
    internal class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine($"Calling dll CustomMath.add5(4): {CustomMath.add5(4)}");
            Console.WriteLine($"Calling dll CustomMath.multiply3(4): {CustomMath.multiply3(4)}");
            Console.ReadLine();
        }
    }
}

Check the output

Run the code to see the result: Debug > Start Debugging

Note: Solution configuration should be set same as DLL (Configuration > "Debug", Platform > "x64")

Thanks for reading! Stay tuned for more content, and feel free to share your thoughts and feedback! Your reactions help me improve and create even more useful posts 🙂

Alternate URL: https://github.com/tuttelikz/notes/tree/main/cpp-dll-dotnet

DEV Community: San Askaruly

A Visual Guide to Affine Transformations: Translation, Scaling, Rotation, and Shear

What is affine transformation exactly?

Why is it useful to know

Outline of this post

Definitions

Translation

Scale

Shear

Shear in X direction

Shear in Y direction

Rotation

References

How to use OpenMP to parallelize C++ using Visual studio

Outline

Configure CPP project

Create a new cpp project

Enable OpenMP support

Run code

Add code to OpenMPApp.cpp and Run

Integrating OpenCV with Visual Studio C++

Outline

Get OpenCV

Download OpenCV

Extract downloaded archive

Configure CPP project

Create a new cpp project

Give a project name

Set configuration

Specify Include directories

Modify Linkers

Define Post build events

Run code

Add code to OpenCVApp.cpp and Run

Creating C++ DLL and using it in .NET

Outline

How to create a cpp DLL

Create a new DLL project

Give a project name

Create operators.cpp

Add code to operators.cpp

Create operators.h

Add code to operators.h

Calling DLL function in dotnet

Create a console application

Give a project name

Create CustomMathApi.cs

Add code to CustomMathApi.cs

Add code to Program.cs

Check the output

Add code to `OpenMPApp.cpp` and Run

Add code to `OpenCVApp.cpp` and Run

Create `operators.cpp`

Add code to `operators.cpp`

Create `operators.h`

Add code to `operators.h`

Create `CustomMathApi.cs`

Add code to `CustomMathApi.cs`

Add code to `Program.cs`