DEV Community: Srikanth Anantharam

(A case for) Creating a stack-allocated Stack container in C++

Srikanth Anantharam — Fri, 06 Oct 2023 18:01:57 +0000

I've always looked inside the C++ STL and wondered why the library provided stack container is not allocated on the stack section but is actually allocated on the heap.

A container which is allocated on stack would be handy in embedded systems where the resource is constrained and the heap is costly.

So, can we really create a container that is allocated on the stack?

If you are also wondering the same, then this article is for you.

First, let's get some of the basics straight:

A stack is a data structure that follows the last-in-first-out (LIFO) principle, meaning the last item to get into a stack will be the first to get out of the stack. Think of it as a stack of plates - you add or remove the plates from the top of the stack.
When we create a stack of items we are going to specify the capacity of the stack, i.e., the number of items it can hold, which will be a static value. We will be specifying the capacity of the stack without losing the generalization capability of the container.
We are going to call the operation of adding an item to the stack as enstack()ing.
The operation of removing an item is going to be called destack()ing.
Other operations are:

i. top() for accessing the topmost item.

ii. height() will calculate the height of the stack.

iii. is_empty() will tell whether the stack is empty.

iv. is_full() will tell whether the stack is full.

v. clear() will remove everything from the stack.

With the above priming, let's get started with some code.

You will generally tend to create a Stack container with fields like this:

#include <cstddef>

template<typename T>
class Stack {
private:
    T* _dynamic_array;
    std::size_t _capacity;
    std::size_t _top;
};

This is loosely similar to the std::stack in the C++ STL and hence needs to allocate the dynamic_array pointer on the heap.

How can we make the Stack stack-allocated and hence defined at compile-time?

One might write the code similar to the following to represent a stack-allocated stack container with the following fields.

#include <cstddef>

template<typename T>
class Stack {
private:
    static const std::size_t _CAPACITY = 100;
    T _static_array[_CAPACITY];
    std::size_t _top;
};

Here the capacity is hard coded within the container itself, which is not such a good idea. What if we want to have different stacks with different capacities? This approach is not going to help.

We want to make the capacity as configurable as the item type that the Stack can hold. The solution is to make the capacity a template argument.

#include <cstddef>

template<typename T, std::size_t capacity>
class Stack {
private:
    T _stack[capacity];
    std::size_t _top = 0;
};

Now we can create a stack-allocated Stack data structure holding items of type int with capacity 100 as follows:

Stack<int, 100> s;

But one problem remains. One could still create a heap-allocated Stack data structure by using the new operator as follows:

auto *s = new Stack<int, 100>;

Can we completely prevent one from allocating an object on heap? Yes, we can do this by making the new operator private as follows:

#include <cstddef>

template<typename T, std::size_t capacity>
class Stack {
private:
    T _stack[capacity];
    std::size_t _top = 0;

    static void * operator new(std::size_t); // To prevent heap allocation of scalar objects
    static void * operator new [] (std::size_t); // To prevent heap allocation of array of objects

public:
    // Implement all the earlier mentioned operations here
};

The complete code for this Stack container with all the earlier mentioned operations implemented is available here.

Try online in a new Codespace

Swapping the position of the two words in a string represented by a singly linked list

Srikanth Anantharam — Sat, 23 Sep 2023 12:44:05 +0000

Recently I've been giving interviews as my last contract got completed. In one of the interviews, I was asked to write a data structure for a string using a singly linked list. The constraint was that the string would have exactly two words separated by a space. The task was to swap the position of the two words in an efficient way.

I started thinking and at the high level, it looked like a simple task where I had to just restructure the list by reassigning some of the pointers.

After some deliberation, I started writing the code to accomplish the task. Working with linked lists is something that we programmers rarely do in the real world. So, It took me a while to complete even half of the task (i.e., to move the second word to the beginning) and due to time constraints I couldn't complete the task during the interview. But I endured post the call and completed the task.

So, the following is the code for the algorithm that I came up with taking into account the edge cases that I could think of. I have tried to name the variables to be intuitive and have given some comments to improve the understanding.

#include <iostream>
#include <stdexcept>
#include <cstring>

using namespace std;

/**
 * @brief This class represents a string as a singly linked list.
 */
class StringAsSinglyLinkedList {
private:
    /**
     * @brief This nested class represents a node in the linked list.
     */
    class Node {
        char data; /** The character that represents the data stored in the node. */
        Node * next; /** A pointer to the next node in the linked list. */
        /**
         * @brief A constructor that creates a new node with the given data and next pointer.
         * @param data The character that represents the data stored in the node.
         * @param next A pointer to the next node in the linked list.
         */
        Node(const char data, Node * next) : data(data), next(next) {}
        friend class StringAsSinglyLinkedList;
    };
    Node * head; /**< A pointer to the first node in the linked list. */
    Node * tail; /**< A pointer to the last node in the linked list. */

public:
    /**
     * @brief A constructor that creates a new instance of the StringAsSinglyLinkedList class with the given C-style string.
     * @param s The C-style string to initialize the linked list with. The string must be contain exactly one space character.
     */
    StringAsSinglyLinkedList(const char * s) : head(nullptr), tail(nullptr) {
        Node * node = nullptr;
        for (int i = strlen(s) - 1; i >= 0; i--) {
            node = new Node(s[i], node);
            if (i == 0) {
                tail = node;
            }
        }
        head = node;
    }

    /**
     * @brief A method that restructures the linked list by effectively swapping the first word and the second word in the list.
     * It does this by finding the first space character in the list, breaking the list at that point,
     * and then appending the first part of the list to the end of the second part.
     */
    void restructure() {
        Node * current_node = head;
        Node * end_of_the_first_word = nullptr;
        // Loop to find the end of the first word and the space character in the string.
        while(current_node) {
            if (current_node->data == ' ') {
                break;
            }
            end_of_the_first_word = current_node;
            current_node = current_node->next;
        }
        if (current_node) { // Check to make sure the string contains a space character.
            if (current_node->next) { // Check to make sure the string contains more than one word.
                Node * node_containing_space = current_node; // Create a node to store the node containing the space character.
                Node * temporary_node = head; // Create a temporary node to store the head.
                head = node_containing_space->next; // Make the head point to the beginning of the second word.
                tail = end_of_the_first_word; // Make the tail point to the end of the first word.
                end_of_the_first_word->next = nullptr; // Break the list at the end of the first word.
                current_node = head;
                // Loop to find the end of the second word.
                while(current_node->next) {
                    current_node = current_node->next;
                }
                current_node->next = node_containing_space; // Append the space character to the end of the second word.
                node_containing_space->next = temporary_node; // Append the first word to the end of the second word.
            }
        }
    }

    /**
     * @brief A method that displays the characters in the linked list in their original order.
     */
    void display() {
        Node * node = head;
        while(node) {
            cout << node->data;
            node = node->next;
        }
        cout << endl;
    }

    /**
     * @brief A destructor that frees the memory allocated for the linked list.
     */
    ~StringAsSinglyLinkedList() {
        while(head) {
            Node * node = head->next;
            delete head;
            head = node;
        }
    }
};

/**
 * @brief The main function creates an instance of the StringAsSinglyLinkedList class with the string "Srikanth Anantharam".
 * It then displays the original string and the restructured string by calling the display method before and after calling the restructure method, respectively.
 * @return 0 if the program exits successfully.
 */
int main()
{
    auto sasll = StringAsSinglyLinkedList("Srikanth Anantharam");
    sasll.display();
    sasll.restructure();
    sasll.display();

    return 0;
}

Thanks to the reddit user witcher_rat for pointing out. There is an idiomatic way to do this using the STL. The following is the code for the same.

#include <forward_list>
#include <iostream>
#include <string_view>

/**
 * @brief A class that represents a string as a singly linked list.
 */
struct String final {
    /**
     * @brief Constructs a String object from a string view.
     * @param sv The string view to construct the String object from.
     */
    String(std::string_view sv) : chars(sv.begin(), sv.end()) {}

    /**
     * @brief Restructures the string by swapping the first word and the second word.
     */
    void restructure()
    {
        auto it = chars.begin();
        if (it == chars.end()) return; // return if the string is empty

        for (auto prev = it++; it != chars.end(); ++it, ++prev) {
            if (*it == ' ') { // if we find a space
                // use splice_after to move the space to the beginning
                // the first argument to splice_after is the position to move the element to
                // the second argument is the list to move the element from
                // the third argument is the position of the element to move
                chars.splice_after(chars.before_begin(), chars, prev);

                // and then move the remaining chars to the beginning
                // the first argument to splice_after is the position to move the elements to
                // the second argument is the list to move the elements from
                // the third and fourth arguments are the range of elements to move
                chars.splice_after(chars.before_begin(), chars, prev, chars.end());
                return;
            }
        }
    }

    /**
     * @brief Outputs the string to an output stream.
     * @param os The output stream to output the string to.
     * @param s The String object to output.
     * @return The output stream.
     */
    friend std::ostream& operator<<(std::ostream& os, const String& s)
    {
        for (auto c : s.chars) os << c;
        return os;
    }

  private:
    std::forward_list<char> chars;
};

/**
 * @brief The main function that demonstrates the String class.
 * @return 0 on success.
 */
int main() {
    String name("Srikanth Anantharam");
    std::cout << name << std::endl;
    name.restructure();
    std::cout << name << std::endl;
}

Link to the code

Try online in a new Codespace

Converting any class into a Singleton class in C++

Srikanth Anantharam — Thu, 31 Aug 2023 16:03:36 +0000

Singleton is one of the creational design patterns. A singleton class has only one instance and provides a global point of access to that instance. It's commonly used when you want to restrict the instantiation of a class to a single object, which can be useful for scenarios where you need a single point of control or coordination.

Following are some of the prominent features of Singleton class:

Private constructor: The key idea behind the Singleton pattern is to make the class's constructor private, preventing external code from directly creating instances of the class.
Static instance: Inside the class, you have a static object that holds the single instance of the class. This instance is usually created the first time it's requested and then reused.
Static method: You provide a static method that acts as the global access point to the single instance. This method checks if an instance already exists and either returns the existing one or creates a new instance if needed.
Thread safety: In multithreaded environments, it's important to ensure that the creation of the instance is thread-safe.
Global access: The Singleton instance can be accessed globally, allowing different parts of your codebase to interact with the same instance of the class.

In this article, I am introducing an approach using which we can convert any class into a Singleton class with minimum effort. To achieve this we are going to create what is called a mixin. Without further ado let's create the SingletonMixin.

SingletonMixin is going to be a template class
The default constructor is protected to prevent direct instantiation
The destructor is virtual and protected so that it can be overridden in a derived class
The copy constructor and copy assignment constructor are also disabled to ensure a single instance is present at any point in time
The core logic of the singleton instance creation is implemented inside the getInstance method

#include <iostream>

using namespace std;

template <typename T>
class SingletonMixin {
public:
    static T& getInstance() {
        static T instance;  // Guaranteed to be created and destroyed once in a thread-safe way
        return instance;
    }

    SingletonMixin(const SingletonMixin&) = delete;             // Disable copy constructor
    SingletonMixin& operator=(const SingletonMixin&) = delete;  // Disable copy assignment constructor

protected:
    SingletonMixin() {
        // Protected constructor to prevent direct instantiation
        cout << "SingletonMixin constructor called: " << this << endl;
    }
    virtual ~SingletonMixin() {
        cout << "SingletonMixin destructor called: " << this << endl;
    }
};

Now let's take for example the following code. It represents a simple class called MyClass which has a default constructor and a single public method implemented. Whereas in real-world use cases, we can have many more methods.

class MyClass {
public:
    void showMessage() {
        cout << "Hello from MyClass!" << endl;
    }
    MyClass() {
        cout << "MyClass constructor called: " << this << endl;
    };
};

We can convert MyClass into a singleton class in the following way:

First, we inherit from SingletonMixin<MyClass>
Make the default constructor private and SingletonMixin<MyClass> a friend class of MyClass, so that MyClass can only be instantiated from the SingletonMixin<MyClass> class.

class MyClass : public SingletonMixin<MyClass> {
public:
    void showMessage() {
        cout << "Hello from MyClass!" << endl;
    }

private:
    MyClass() {
        cout << "MyClass constructor called: " << this << endl;
    };
    friend class SingletonMixin<MyClass>;
};

To create/access the singleton instance of MyClass we can call the getInstance method on MyClass class. We can call it as many times as we want, we are going to receive the same instance of the MyClass class. We can verify it printing out the address of the instance.

#include <thread>

void thread_function(const char * s) {
    this_thread::sleep_for(chrono::milliseconds(1000));
    MyClass& singleton = MyClass::getInstance();
    cout << s << ": " << &singleton << endl << flush;
}

int main() {
    thread thread_1(thread_function, "thread 1");
    thread thread_2(thread_function, "thread 2");

    MyClass& singleton1 = MyClass::getInstance();
    MyClass& singleton2 = MyClass::getInstance();
    MyClass& singleton3 = MyClass::getInstance();

    cout << &singleton1 << ", " << &singleton2 << ", " << &singleton3 << endl;

    thread_1.join();
    thread_2.join();

    return 0;
}

💡
Since this approach uses the default constructor to create the singleton instance, one could use getter and setter methods to access (read/write) any member variables that may become part of MyClass.

Link to the code

Try online in a new Codespace

A tutorial for accessing C/C++ functions within a shared library (.dll/.so/.dylib) from Rust

Srikanth Anantharam — Sun, 04 Dec 2022 08:30:12 +0000

[19-09-2023] Updates:

Add instructions and code for an alternative way to build and run using build.rs and cmake-rs
Fix the reason why not to link to C++ functions directly
Include <cstring> in the code and use free instead of delete as strdup generally uses malloc to allocate
Update code and add information to prevent memory leakage when returning a heap-allocated object through the FFI
Removed libc dependency in favour of std::ffi in the Rust wrapper
In the C/C++ example, used cmake instead of msbuild as it is more cross-platform.

Background

At my workplace, we are developing algorithms for a cloud-based analysis app. The algorithms are written in C++ and exported as a shared library to be used by the middleware in Java and the front end in JavaScript. Everything was working except for one problem, the service we had deployed faced the issue of memory pile-up. And since all the different components were tightly coupled it became very difficult to debug the issue.

So, after some discussion, we decided to decouple the different components by running the C++ algorithms as a REST web service.

We searched for C++ libraries to develop the REST endpoint but found that either they were not maintained or were extremely hard to set up.

Having some prior experience with Rust (especially REST web service development using Actix), I suggested that we could develop a wrapper in Rust and write the REST web API using some framework like Actix. I knew it was possible to wrap C/C++ code in Rust but not how. I searched for and found bits and pieces here and there but not a complete tutorial. This article is my attempt to compile all the information that I found and present it as a tutorial. I assume you already have some familiarity with C/C++, CMake, and Rust.

Introduction

Let's start with some of the basics first.

Consider, we are developing a shared library named c_cpp. The shared library file will be called c_ccp.dll in Windows, libc_cpp.so in Linux, and libc_cpp.dylib in macOS.
It is not a good idea to link to C++ functions directly, as C++ doesn't have a stable ABI. Hence, If you are writing a C++ function you need to put it in your header(s) within the extern "C" { } block. This also tells the C++ compiler not to mangle its name.
If you are writing a C function you don't have to put it inside the extern "C" { } block, as the Rust compiler knows how to call it.

The C/C++ example

I am taking an example of a C++ function called introduce. Let's see what its function declaration in the header (c_cpp\include\lib.h) looks like.

#if defined(WIN32) || defined(_WIN32)
#define EXPORT __declspec(dllexport)
#else
#define EXPORT
#endif

extern "C" {
    EXPORT const char * introduce(const char * name, int age);
}

The introduce function takes a C-style string (name) and an int (age) as parameters, constructs another string from the parameters, and returns it as a C-style string. In this tutorial, I'll be using Windows as the development platform. You should be able to easily adapt it to other platforms.

Following is the function definition in the source file (c_cpp\src\lib.cpp).

#include <sstream>
#include <cstring>
#include "lib.h"

std::stringstream ss;

const char * introduce(const char * name, int age) {
    ss.clear();
    ss << "Hi, I am " << name << ". My age is " << age << ".";
    return strdup(ss.str().c_str());
}

To the above code files, we will also add the deallocate_string function. This will aid in preventing memory leaks that can occur if the heap-allocated string is not deallocated. We are going to call this function from the Rust wrapper.

c_cpp\include\lib.h

#if defined(WIN32) || defined(_WIN32)
#define EXPORT __declspec(dllexport)
#else
#define EXPORT
#endif

extern "C" {
    EXPORT const char * introduce(const char * name, int age);

    EXPORT void deallocate_string(const char * s);
}

c_cpp\src\lib.cpp

#include <sstream>
#include <cstdlib>
#include <cstring>
#include "lib.h"

std::stringstream ss;

const char * introduce(const char * name, int age) {
    ss.clear();
    ss << "Hi, I am " << name << ". My age is " << age << ".";
    return strdup(ss.str().c_str());
}

void deallocate_string(const char * s) {
    free((void*)s);
}

I'm also going to create the main source file (c_cpp\src\main.cpp) to build an executable and quickly test my function.

#include <iostream>

#include "lib.h"

int main() {
    const char * s = introduce("Srikanth", 31);
    std::cout << s << std::endl;

    deallocate_string(s);

    return 0;
}

I will use CMake as the build tool. So, the following is my c_cpp\CMakeLists.txt file.

cmake_minimum_required(VERSION 3.24)

project("c_cpp")

include_directories(./include)

add_library(${PROJECT_NAME} SHARED ./src/lib.cpp)

add_executable(${PROJECT_NAME}_main ./src/main.cpp ./src/lib.cpp)

install(TARGETS ${PROJECT_NAME} DESTINATION .)

I'll build the shared library and the test executable using the following commands:

cd c_cpp
cmake -S . -B .\build\
cmake --build .\build\

Running the test executable should be straightforward:

C:\rust_ffi_c_cpp\c_cpp> .\build\Debug\c_cpp_main.exe
Hi, I am Srikanth. My age is 31.

The Rust wrapper

For developing the Rust wrapper I'm first going to create a library project using cargo.

C:\rust_ffi_c_cpp> cargo new --lib rust_ffi

Now replace the contents of the rust_ffi\src\lib.rs file with the following:

use std::{ffi::{CString, CStr, c_char, c_int}, error::Error};

#[link(name = "c_cpp")]  // name of the C shared library
extern "C" {
    fn introduce(name: *const c_char, age: c_int) -> *const c_char;

    fn deallocate_string(s: *const c_char);
}

fn get_str_slice_from_c_char_ptr<'a>(input_c_char: *const c_char) -> Result<&'a str, Box<dyn Error>> {
    let input_c_str = unsafe { CStr::from_ptr(input_c_char) };
    match input_c_str.to_str() {
        Ok(str_slice) => Ok(str_slice),
        Err(error) => Err(Box::new(error)),
    }
}

pub fn introduce_rust(name: &str, age: c_int) -> Result<String, Box<dyn Error>> {
    let name = CString::new(name)?;
    let introduction = unsafe { introduce(name.as_ptr(), age) };
    let introduction_string = get_str_slice_from_c_char_ptr(introduction)?.to_string();
    unsafe { deallocate_string(introduction) };
    Ok(introduction_string)
}

The first use line imports standard library features related to handling C-style strings, the C types and the Error trait.

The next block of code is where we specify the name of the C/C++ shared library and the function(s) within it that we are going to use. In our case, the signature of the function(s) should match those in the c_cpp\include\lib.h file.

The get_str_slice_from_c_char_ptr convenience function is the one that converts the raw const char * pointer from C to a &str in Rust. It makes use of an unsafe code block to accomplish this.

The introduce_rust function is the actual wrapper around the introduce C/C++ function. It takes the first input parameter as &str and converts it into a C-style string. The second parameter is an integer and is passed as it is. This function also makes use of an unsafe code block for the C function. Then it makes use of the get_str_slice_from_c_char_ptr convenience function to convert the returned C-style string into a Rust String. And it deallocates the c-string to prevent memory leakage.

In order to test that our approach actually works let's write a rust_ffi\src\main.rs. Following are its contents:

use std::error::Error;

use rust_ffi::introduce_rust;

fn main() -> Result<(), Box<dyn Error>> {
    let introduction = introduce_rust("Srikanth", 31)?;
    println!("{introduction}");
    Ok(())
}

We can build our project by using the following commands from the rust_ffi directory:

set RUSTFLAGS=-L..\c_cpp\build\Debug
cargo build

The first command sets the Rust linker flag -L to the path containing the C/C++ shared library. And the second command builds the project.

Now we can run the built Rust executable by using the following commands from the rust_ffi directory:

set PATH=..\c_cpp\build\Debug;%PATH%
target\debug\rust_ffi.exe

And voila we get our expected output:

Hi, I am Srikanth. My age is 31.

An alternative way to build and run the Rust wrapper using build.rs and cmake-rs

Being in the same Rust project modify rust_ffi\Cargo.toml to look like as follows:

[package]
name = "rust_ffi"
version = "0.1.0"
edition = "2021"
build = "build.rs"

# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

[dependencies]

[build-dependencies]
cmake = "0.1.50"

And add rust_ffi\build.rs with the following contents:

use std::path::Path;
use cmake::Config;

fn main()
{
    let dst = Config::new(Path::new("..").join("c_cpp")).build();

    println!("cargo:rustc-link-search=native={}", dst.display());
    println!("cargo:rustc-link-lib=dylib=c_cpp");
}

Now one can simply run from the rust_ffi directory, the command cargo build to build the C/C++ shared library and the Rust executable in one shot. One can also run the Rust executable by simply running the command cargo run.

Link to the code

Try online in a new Codespace

Correctly rotating an image to an arbitrary angle in OpenCV

Srikanth Anantharam — Sun, 11 Sep 2022 01:12:45 +0000

Introduction

Have you ever tried to rotate an image in OpenCV? It's damn simple, right?

You include the OpenCV headers:

#include <cmath>
#include <iostream>
#include <algorithm>
#include <opencv2/core.hpp>
#include <opencv2/imgproc.hpp>
#include <opencv2/highgui.hpp>

You load the image:

cv::Mat image = cv::imread("sria91.png");

Here's how my image looks:

You call cv::rotate. For example to rotate an image clockwise by 90 degrees:

cv::Mat rotated_image = cv::rotate(image, cv::ROTATE_90_CLOCKWISE);

And then you can display the image:

cv::imshow("Output", output_image);
cv::waitKey(10000);

Here's how the output_image looks:

But what if you wanted to rotate the image by an arbitrary angle say 23 degrees anti-clockwise? How would you go about that?

Naive approach

If you look at the OpenCV's official C++ tutorials you would be out of luck. But, if you dig deeper you might come across OpenCV's official Python tutorials and find this. Adapting the example on that page for rotation to C++ you could write the following:

cv::Mat input_image = cv::imread("sria91.png");
int rows = input_image.rows;
int cols = input_image.cols;
cv::Mat transformation_matrix = cv::getRotationMatrix2D(cv::Point2f((cols-1)/2.0, (rows-1)/2.0), 23, 1);
cv::Mat output_image;
cv::warpAffine(input_image, output_image, transformation_matrix, cv::Size(cols, rows));
cv::imshow("Output", output_image);
cv::waitKey(10000);

The result looks like this:

You would notice that something is not right. The output image is cropped from all around. How would you get an image that is rotated and also not cropped? I've got you covered. Follow along to find out.

The correct approach

This approach is based on the first principles.

The first thing you have to do is to construct the rotation matrix.

double angle = 23;  // in degrees
double angle_in_radians = angle * M_PI / 180;
cv::Mat rotation_matrix = cv::Mat::eye(3, 3, CV_64F);
rotation_matrix.at<double>(0, 0) = cos(angle_in_radians);
rotation_matrix.at<double>(0, 1) = -sin(angle_in_radians);
rotation_matrix.at<double>(1, 0) = sin(angle_in_radians);
rotation_matrix.at<double>(1, 1) = cos(angle_in_radians);

Then you construct the translation matrix.

cv::Mat translation_matrix = cv::Mat::eye(3, 3, CV_64F);
translation_matrix.at<double>(0, 2) = - rows / 2;
translation_matrix.at<double>(1, 2) = - cols / 2;

Collect the coordinates for corners of the image.

cv::Mat corners = cv::Mat::ones(3, 4, CV_64F);
corners.at<double>(0, 0) = 0;
corners.at<double>(1, 0) = 0;
corners.at<double>(0, 1) = 0;
corners.at<double>(1, 1) = cols - 1;
corners.at<double>(0, 2) = rows - 1;
corners.at<double>(1, 2) = cols - 1;
corners.at<double>(0, 3) = rows - 1;
corners.at<double>(1, 3) = 0;

Find the coordinates of the corners of the image when its center is translated to the origin and rotated by angle.

cv::Mat new_corners = (rotation_matrix * translation_matrix) * corners;

Calculate the rows and columns for the output image.

double *p_new_corners;
p_new_corners = new_corners.row(0).ptr<double>();
int max_rows = *max_element(p_new_corners, p_new_corners+4);
int min_rows = *min_element(p_new_corners, p_new_corners+4);
p_new_corners = new_corners.row(1).ptr<double>();
int max_cols = *max_element(p_new_corners, p_new_corners+4);
int min_cols = *min_element(p_new_corners, p_new_corners+4);
int new_rows = max_rows - min_rows + 1;
int new_cols = max_cols - min_cols + 1;

Construct the new_translation_matrix to translate the image's center from the origin.

cv::Mat new_translation_matrix = cv::Mat::eye(3, 3, CV_64F);
new_translation_matrix.at<double>(0, 2) = new_rows / 2;
new_translation_matrix.at<double>(1, 2) = new_cols / 2;

Compute the inverse_transformation_matrix to map the coordinates from output_image to input_image.

cv::Mat inverse_transformation_matrix = (new_translation_matrix * rotation_matrix * translation_matrix).inv();

Now you allocate the memory for the output_image.

cv::Mat output_image(new_rows, new_cols, input_image.type());

Finally rotate and display the image.

cv::Mat new_point = cv::Mat::ones(3, 1, CV_64F);
for (int new_row=0; new_row<new_rows; new_row++) {
    for (int new_col=0; new_col<new_cols; new_col++) {
        new_point.at<double>(0, 0) = new_row;
        new_point.at<double>(1, 0) = new_col;
        cv::Mat point = inverse_transformation_matrix * new_point;
        int row = point.at<double>(0, 0);
        int col = point.at<double>(1, 0);
        if (row >= 0 && row < rows && col >= 0 && col < cols) {
            output_image.at<cv::Vec3b>(cv::Point(new_col, new_row)) = input_image.at<cv::Vec3b>(cv::Point(col, row));
        }
    }
}
cv::imshow("Output", input_image);
cv::waitKey(10000);

And the result looks like this:

Link to the code

Try online in a new Codespace

Need help on implementing client-server communication in Python

Srikanth Anantharam — Tue, 17 Mar 2020 15:17:42 +0000

I'm trying to create a client-server model using Python where the client sends a request. The server receives it and spawn a process/thread to handle the request and when it's done sends the result back to the client. The server should be able to handle multiple clients and hence multiple requests without any issues. The server must have some kind of session management maintaining client & request details. How should I implement this. Can someone help me?

This is my first big task at work & I'm excited.

semver: A specification on versioning anything.

Srikanth Anantharam — Fri, 15 Nov 2019 14:43:14 +0000

https://semver.org/