Understanding and Implementing a Simple Krita Stabilizer

This article explores the core concept behind Krita's stabilizer functionality, which helps create smoother lines when drawing digitally. We will implement a simplified version of a stabilizer in C++ to demonstrate the underlying principles.

Fundamental Concepts / Prerequisites

Before diving into the implementation, a basic understanding of the following is assumed:

• **Vector mathematics:** Basic operations on 2D vectors (addition, subtraction, scalar multiplication).
• **Interpolation:** The concept of linear interpolation (LERP) for smoothing values.
• **C++ syntax:** Familiarity with C++ programming concepts, including classes and basic data structures.

Implementation in C++

The following C++ code demonstrates a simple stabilizer that averages a certain number of previous input points to smooth the output.

#include <iostream>
#include <vector>

// Structure to represent a 2D point
struct Point {
  float x;
  float y;
};

// Stabilizer class
class Stabilizer {
private:
  int bufferSize; // Number of points to average
  std::vector<Point> pointBuffer; // Buffer to store previous points
  int currentIndex; // Index to the current position in the buffer

public:
  // Constructor
  Stabilizer(int size) : bufferSize(size), currentIndex(0) {
    pointBuffer.resize(bufferSize);
  }

  // Process a new input point and return the stabilized point
  Point processPoint(Point inputPoint) {
    // Store the input point in the buffer
    pointBuffer[currentIndex] = inputPoint;

    // Calculate the average of all points in the buffer
    Point averagePoint = {0.0f, 0.0f};
    for (int i = 0; i < bufferSize; ++i) {
      averagePoint.x += pointBuffer[i].x;
      averagePoint.y += pointBuffer[i].y;
    }
    averagePoint.x /= bufferSize;
    averagePoint.y /= bufferSize;

    // Update the current index (circular buffer)
    currentIndex = (currentIndex + 1) % bufferSize;

    return averagePoint;
  }
};

int main() {
  // Example Usage
  Stabilizer stabilizer(5); // Stabilize using 5 previous points

  Point p1 = {10.0f, 10.0f};
  Point p2 = {11.0f, 12.0f};
  Point p3 = {9.0f, 11.0f};
  Point p4 = {10.5f, 9.5f};
  Point p5 = {11.5f, 10.5f};
  Point p6 = {10.0f, 10.0f};


  Point s1 = stabilizer.processPoint(p1);
  Point s2 = stabilizer.processPoint(p2);
  Point s3 = stabilizer.processPoint(p3);
  Point s4 = stabilizer.processPoint(p4);
  Point s5 = stabilizer.processPoint(p5);
  Point s6 = stabilizer.processPoint(p6);


  std::cout << "Stabilized Point 1: (" << s1.x << ", " << s1.y << ")" << std::endl;
  std::cout << "Stabilized Point 2: (" << s2.x << ", " << s2.y << ")" << std::endl;
  std::cout << "Stabilized Point 3: (" << s3.x << ", " << s3.y << ")" << std::endl;
  std::cout << "Stabilized Point 4: (" << s4.x << ", " << s4.y << ")" << std::endl;
  std::cout << "Stabilized Point 5: (" << s5.x << ", " << s5.y << ")" << std::endl;
  std::cout << "Stabilized Point 6: (" << s6.x << ", " << s6.y << ")" << std::endl;


  return 0;
}

Code Explanation

The code defines a Stabilizer class that implements a basic moving average filter. Here's a breakdown:

First, we define a Point struct to represent 2D coordinates.

The Stabilizer class:

• The `bufferSize` variable defines how many previous points should be averaged.
• The `pointBuffer` is a vector used to store the previous input points in a circular buffer fashion.
• The `currentIndex` keeps track of the next available position in the buffer to be overwritten.

The processPoint method:

• It stores the current input point into `pointBuffer` at the `currentIndex`.
• Calculates the average of all the points stored in `pointBuffer`.
• Increments `currentIndex` using the modulo operator (`%`) to implement the circular buffer behavior.
• Returns the calculated average point, representing the stabilized coordinate.

The main function demonstrates basic usage. It creates a Stabilizer object, and then passes a series of Points to the Stabilizer and prints the resulting stabilized points.

Complexity Analysis

The time complexity of the processPoint method is O(N), where N is the bufferSize. This is because the code iterates through the entire buffer to calculate the average for each input point. The space complexity is O(N) as well, due to the pointBuffer which stores N points.

Alternative Approaches

An alternative approach is to use an Exponential Moving Average (EMA). Instead of averaging all the points in the buffer, EMA gives more weight to recent points and exponentially less weight to older points. This can provide a faster response time to changes in the input, compared to the moving average approach used in the above implementation. The EMA approach can be implemented with O(1) time complexity, but still requires storing the previously calculated average, resulting in O(1) space complexity.

Conclusion

This article demonstrated a simplified implementation of a Krita stabilizer using a moving average approach. While this implementation provides a basic level of stabilization, more sophisticated techniques like EMA can be explored to further improve performance and responsiveness. Understanding these fundamental concepts allows for the development of more advanced digital drawing tools and features.