#include <Ricom.h>

Public Member Functions
void	compute_kernel ()

void	compute_filter ()

void	include_filter ()

std::vector< int >	fftshift_map (int x, int y)

	Ricom_kernel ()

void	approximate_frequencies (size_t n_im)

void	draw_surfaces ()

	~Ricom_kernel ()

Public Attributes
int	kernel_size

bool	b_filter

std::array< int, 2 >	kernel_filter_frequency

int	k_width_sym

int	k_area

float	rotation

std::vector< float >	kernel_x

std::vector< float >	kernel_y

std::vector< float >	kernel_filter

std::vector< float >	f_approx

SDL_Surface *	srf_kx

SDL_Surface *	srf_ky

Detailed Description

Definition at line 52 of file Ricom.h.

Constructor & Destructor Documentation

◆ Ricom_kernel()

Ricom_kernel::Ricom_kernel ( )

inline

Definition at line 74 of file Ricom.h.

                   : kernel_size(5),
                     b_filter(false),
                     kernel_filter_frequency{1, 4},
                     k_width_sym(0),
                     k_area(0),
                     rotation(0.0),
                     kernel_x(),
                     kernel_y(),
                     kernel_filter(),
                     f_approx(),
                     srf_kx(), srf_ky()
    {
        compute_kernel();
    };

◆ ~Ricom_kernel()

Ricom_kernel::~Ricom_kernel ( )

inline

Definition at line 91 of file Ricom.h.

91{};

Member Function Documentation

◆ approximate_frequencies()

void Ricom_kernel::approximate_frequencies ( size_t n_im )

Definition at line 111 of file Ricom.cpp.

{
    f_approx.resize(nx_im);
    float f_max = 0;
    float k = kernel_size * 2;
    for (size_t i = 0; i < nx_im; i++)
    {
        float x = 2 * i * M_PI;
        f_approx[i] = (nx_im / x) * (1 - cos(k / 2 * (x / nx_im)));
        if (f_approx[i] > f_max)
        {
            f_max = f_approx[i];
        }
    }
    std::for_each(f_approx.begin(), f_approx.end(), [f_max](float &x) { x/=f_max; });
}

◆ compute_filter()

void Ricom_kernel::compute_filter ( )

Definition at line 66 of file Ricom.cpp.

{
    kernel_filter.assign(k_area, 0);
    float lb = pow(kernel_filter_frequency[0], 2);
    float ub = pow(kernel_filter_frequency[1], 2);
 
    for (int iy = 0; iy < k_width_sym; iy++)
    {
        for (int ix = 0; ix < k_width_sym; ix++)
        {
            float dist = pow(ix - kernel_size, 2) + pow(iy - kernel_size, 2);
            int ic = iy * k_width_sym + ix;
            if (dist <= ub && dist > lb)
            {
                kernel_filter[ic] = 1;
            }
        }
    }
}

◆ compute_kernel()

void Ricom_kernel::compute_kernel ( )

Definition at line 21 of file Ricom.cpp.

{
    float rot_rad = M_PI * rotation / 180;
    float cos_rot = cos(rot_rad);
    float sin_rot = sin(rot_rad);
 
    k_width_sym = kernel_size * 2 + 1;
    k_area = k_width_sym * k_width_sym;
    kernel_x.assign(k_area, 0);
    kernel_y.assign(k_area, 0);
 
    for (int iy = 0; iy < k_width_sym; iy++)
    {
        int iy_e = (iy + 1) * k_width_sym - 1;
        for (int ix = 0; ix < k_width_sym; ix++)
        {
            int ix_s = ix - kernel_size;
            int iy_s = iy - kernel_size;
            float d = ix_s * ix_s + iy_s * iy_s;
            int ix_e = k_area - iy_e + ix - 1;
 
            if (d > 0)
            {
                float ix_sd = (ix_s / d);
                float iy_sd = (iy_s / d);
                kernel_x[ix_e] = cos_rot * ix_sd - sin_rot * iy_sd;
                kernel_y[ix_e] = sin_rot * ix_sd + cos_rot * iy_sd;
            }
            else
            {
                kernel_y[ix_e] = 0;
                kernel_x[ix_e] = 0;
            }
        }
    }
 
    // Add filter
    if (b_filter)
    {
        compute_filter();
        include_filter();
    }
}

◆ draw_surfaces()

void Ricom_kernel::draw_surfaces ( )

Definition at line 128 of file Ricom.cpp.

{
    // Creating SDL Surface (holding the ricom image in CPU memory)
    srf_kx = SDL_CreateRGBSurface(0, k_width_sym, k_width_sym, 32, 0, 0, 0, 0);
    if (srf_kx == NULL)
    {
        std::cout << "Surface could not be created! SDL Error: " << SDL_GetError() << std::endl;
    }
    srf_ky = SDL_CreateRGBSurface(0, k_width_sym, k_width_sym, 32, 0, 0, 0, 0);
    if (srf_ky == NULL)
    {
        std::cout << "Surface could not be created! SDL Error: " << SDL_GetError() << std::endl;
    }
    // determine location index of value in memory
    std::pair kx_min_max = std::minmax_element(kernel_x.begin(), kernel_x.end());
    std::pair ky_min_max = std::minmax_element(kernel_y.begin(), kernel_y.end());
    // Update pixel at location
 
    for (int y = 0; y < k_width_sym; y++)
    {
        int ic = y * k_width_sym;
        for (int x = 0; x < k_width_sym; x++)
        {
            float valx = (kernel_x[ic + x] - kx_min_max.first[0]) / (kx_min_max.second[0] - kx_min_max.first[0]);
            SDL_Utils::draw_pixel(srf_kx, x, y, valx, 5);
            float valy = (kernel_y[ic + x] - ky_min_max.first[0]) / (ky_min_max.second[0] - ky_min_max.first[0]);
            SDL_Utils::draw_pixel(srf_ky, x, y, valy, 5);
        }
    }
}

◆ fftshift_map()

std::vector< int > Ricom_kernel::fftshift_map	(	int	x,
		int	y
	)

◆ include_filter()

void Ricom_kernel::include_filter ( )

Definition at line 87 of file Ricom.cpp.

{
    FFT2D fft2d(k_width_sym, k_width_sym);
    std::vector<std::complex<float>> x2c = FFT2D::r2c(kernel_x);
    std::vector<std::complex<float>> y2c = FFT2D::r2c(kernel_y);
    fft2d.fft(x2c, x2c);
    fft2d.fft(y2c, y2c);
    for (int id = 0; id < k_area; id++)
    {
        if (kernel_filter[id] == 0.0f)
        {
            x2c[id] = {0, 0};
            y2c[id] = {0, 0};
        }
    }
    fft2d.ifft(x2c, x2c);
    fft2d.ifft(y2c, y2c);
    for (int id = 0; id < k_area; id++)
    {
        kernel_x[id] = x2c[id].real();
        kernel_y[id] = y2c[id].real();
    }
}

Member Data Documentation

◆ b_filter

bool Ricom_kernel::b_filter

Definition at line 57 of file Ricom.h.

◆ f_approx

std::vector<float> Ricom_kernel::f_approx

Definition at line 65 of file Ricom.h.

◆ k_area

int Ricom_kernel::k_area

Definition at line 60 of file Ricom.h.

◆ k_width_sym

int Ricom_kernel::k_width_sym

Definition at line 59 of file Ricom.h.

◆ kernel_filter

std::vector<float> Ricom_kernel::kernel_filter

Definition at line 64 of file Ricom.h.

◆ kernel_filter_frequency

std::array<int, 2> Ricom_kernel::kernel_filter_frequency

Definition at line 58 of file Ricom.h.

◆ kernel_size

int Ricom_kernel::kernel_size

Definition at line 56 of file Ricom.h.

◆ kernel_x

std::vector<float> Ricom_kernel::kernel_x

Definition at line 62 of file Ricom.h.

◆ kernel_y

std::vector<float> Ricom_kernel::kernel_y

Definition at line 63 of file Ricom.h.

◆ rotation

float Ricom_kernel::rotation

Definition at line 61 of file Ricom.h.

◆ srf_kx

SDL_Surface* Ricom_kernel::srf_kx

Definition at line 66 of file Ricom.h.

◆ srf_ky

SDL_Surface* Ricom_kernel::srf_ky

Definition at line 67 of file Ricom.h.

The documentation for this class was generated from the following files:

src/Ricom.h
src/Ricom.cpp

Public Member Functions

Public Attributes