Degree:

I will be using a pseudorandom generated set of points that can serve to test multiple algorithms that use points in their processing step. In particular, we can use a normal distribution to generate those points. Specifically, 2D points for our 2D OpenGL baseline. In addition, I’d prefer that the geometries created from these points fall more or less within the center of our OpenGL window. For this , I will be using a sigmoid function to map the domain $(-\infty, \infty)$ from the normal distribution to the range (-1, 1). This is the needed range since OpenGL processes our 2D coordinates in the range (-1, 1) and then transforms that to window coordinates in the range (SCREEN_WIDTH, SCREEN_HEIGHT).

We can get a set of pseudorandom points using the template class std::normal_distribution from STL. Starting from an uniform random generator to get a mean and a standard deviation value, which serve as arguments for the std::normal_distribution constructor. After that we simply need to obtain the sample value that is returned from the std::normal_distribution object, and apply the sigmoid function for the mapping.

Implementation

At first, I decided to use the follwing sigmoid function $f(x) = \frac{e^{2x} - 1}{e^{2x} + 1}$. But, I wanted to avoid the use of exponents. Instead, I used the following sigmoid function for the actual implementation

This allow for an easy and fast calculation along with the mapping in the necessary range. Thus, this sigmoid function does the mapping $f(x) : (-\infty, \infty) \to (-1, 1)$.

void Normal_Distribution(float * sample) {

    static std::random_device rd;
    static std::mt19937 gen(rd());                                         // Mersenne twister PRNG
    static std::default_random_engine generator;
    static std::uniform_real_distribution<double> distribution(0.0, 1.0);

    static const float mean = distribution(generator);
    static const float std_dev = distribution(generator);
                                            
    static std::normal_distribution<float> normal_distribution(mean, std_dev); // instance of class std::normal_distribution with specific mean and stddev

    float x = normal_distribution(gen);
    *sample = x / (1 + std::abs(x)); // *sample in range (-1, 1) using sigmoid function
}

Find source code in my github repository for the project opengl_2D_baseline

A bitfield defined in big endian platform can present a problem in a little endian based platform. Indeed, for big endian the Most Significant Bit (MSB) would be a the top of the bitfield, while it would be the Least Significant Bit (LSB) for little endian. A quick and dirty solution would be to start using a swapping function where needed to change endianess accordingly. Of course, it would be advisible to change the bitfield itself to the prefer endianess, like for example this compiler switch in linux kernel. But for the sake of explanation let’s suppose it is not possible to change the bitfield structure.

In addition, let’s suppose that we need to keep the nibbles in a specific ordered sequence. In other words, the order of the nibble sequence determines the validity of the information. This case would be true for an API expecting a sequence of flags from a bitfield in which each flag is one bit. The flags are expected in specific order, where the MSB comes first.

How It Works

By taking the value and dividing it in half, we can move the front to the back half, and the back half to the front half. We achieve this by first clearing the halfs that we want

Consequently, we can move each half to it’s expected place. This is achieve using the right and left shift operator moving the bit sequence by 32 bits in each direction.

Then, it is just a matter of using the OR operator to get complete the swapped value.

Finally, repeat this recipe for the next 2 bytes, 1 byte, and the nibbles. That will reverse the order sequence of the byte list based on the nibbles.

typedef unsigned long long uint64;

void Swap_Nibbles_64Bit(uint64& val) {
    val = (val & 0x00000000FFFFFFFF) << 32 | (val & 0xFFFFFFFF00000000) >> 32; // remove line for 32-bit swap
    val = (val & 0x0000FFFF0000FFFF) << 16 | (val & 0xFFFF0000FFFF0000) >> 16;
    val = (val & 0x00FF00FF00FF00FF) << 8  | (val & 0xFF00FF00FF00FF00) >> 8;
    val = (val & 0x0F0F0F0F0F0F0F0F) << 4  | (val & 0xF0F0F0F0F0F0F0F0) >> 4;	// remove line for byte swap
}

A nice thing about this function, is that by removing the last or the first line, we can make a 32-bit swap and a byte swapp respectively.

Degree:

Introduction

The deCasteljau’s algorithm introduces a way to create Bezier curves through the evaluation of Bernstein polynomials. A Bezier curve is a parametric polynomial curve that uses polynomials for its coordinates functions [1]. Consequently, an nth-degree Bezier curve is defined by

The set $\{\textbf{P}\}$ are called control points, and the $B_{i,n}(u)$ are Bernstein polynomials. The control points are the geometric coefficients of the Bezier curve and the Bernstein polynomials are basis functions. Therefore, the curve $\textbf{C(u)}$ can be expressed as a linear combination of the control points and Bernstein polynomials. Consequently, the deCasteljau’s algorithm recursively iterates over the control points to produce a numerical stable Bezier curve.

Bernstein polynomials gives a formulation for building Bezier curves of any degree. The Bernstein polynomials $B_{i,n}$ are defined as

\begin{equation} B_{i,n}(u) = \frac{n!}{i!(n-i)!}u^i(1-u)^{n-i} \qquad 0 \leq u \leq 1. \end{equation}

However, the deCasteljau’s algorithm avoids the direct calculation of factorials. Instead, it exploits the Bernstein polynomials property where $B_{0,n}(0) = B_{n,n}(1) = 1$, and it produces a point on the curve by recursion. In addition, the partition of unity property $ \sum^n_{i=0}B_{i,n}(u) = 1 \quad \forall u \in [0,1]$ ensures the interpolation between the control points.

Example

For this example, let’s create a quadratic Bezier curve. A quadratic Bezier curve represents the case for $n = 2$ in the definition above. Using the property $B_{0,n}(0) = B_{n,n}(1) = 1$ the Bernstein polynomials take the following form

This a direct result of using the recursive property of the basis functions. In addition, from the figure below shows the set of recursive dependency for the of $B_{1,2}$

Then the curve formed by control points $\{ \textbf{P}_0, \textbf{P}_1, \textbf{P}_2 \}$ is

Implementation

OpenGL Setup

For drawing the curve I will be using modern OpenGL; the setup will use vertex and fragment shaders. I followed this tutorial for the basic setup. In addition, the data will be computed with the CPU, then with pass this data to OpenGL drawing functions for the GPU to draw it.

For the implementation, the algorithm will be encapsulated in a class. A curve class will contain the algorithm, so we could reuse it and implement other algorithms for curve creation.

deCasteljau Algorithm

We would like to display a 2D curve, therefore, having a struct with an x and y coordinates will come very handy. By defining a struct Point with two coordinates we can create a vector of points, which can then be used for the algorithm. Thus, it just makes sense to create a vector that holds a collection of 2D points for the control points. In addition, we will use the same data structure to copy the control points in a temporary vector of points, which will produce the points for the Bezier curve.

#ifndef CURVE_H
#define CURVE_H

#include <vector>
struct Point {
    float x;
    float y;
};

class Curve{
public:
    Curve() = default;
    const std::vector<float>& deCasteljau(std::vector<float>& ctrl_pts);
private:
    void deCasteljau_Subroutine(float u);
    void Vector_To_Points(std::vector<float>& ctrl_pts);
    std::vector<float> m_curve;
    std::vector<Point> m_ctrl_pts;
};
#endif

static const float m_res = 0.001f;

const std::vector<float>& Curve::deCasteljau(std::vector<float>& ctrl_pts){
    Vector_To_Points(ctrl_pts);

    if(!m_curve.empty()) m_curve.clear();

    for(float u = 0.0f; u < 1.0f; u += m_res){
        deCasteljau_Subroutine(u);
    }

    return m_curve;
}

void Curve::deCasteljau_Subroutine(float u){
    std::vector<Point> tmp_ctrl_pts(m_ctrl_pts);
    for(int i = 1; i < tmp_ctrl_pts.size(); i++){
        for(int j = 0; j < tmp_ctrl_pts.size() - i; j++){
            tmp_ctrl_pts[j].x = (1.0f - u) * tmp_ctrl_pts[j].x + u * (tmp_ctrl_pts[j + 1].x);
            tmp_ctrl_pts[j].y = (1.0f - u) * tmp_ctrl_pts[j].y + u * (tmp_ctrl_pts[j + 1].y);
        }
    }

    m_curve.emplace_back(tmp_ctrl_pts[0].x);
    m_curve.emplace_back(tmp_ctrl_pts[0].y);
    m_curve.emplace_back(0.0f);             // the curve lives in the xy plane (x, y, z = 0)
}

The code for the project can be found here.

References

[1]https://en.wikipedia.org/wiki/B%C3%A9zier_curve