general.c

Go to the documentation of this file.

 /* -- Includes -- */
/* system libraries */
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
/* project libraries */
#include "general.h"

/* -- Defines -- */

/* -- Functions -- */

int general_bytes2int(unsigned char byte_high, unsigned char byte_low)
{
    int num;

    //Convert to int (two's complement)
    if((byte_high & (1 << 7)) == (1 << 7))
    {
        num = (byte_low + (byte_high << 8)) - 0xFFFF;
    }
    else
    {
        num = byte_low + (byte_high << 8);
    }

    return num;
}

unsigned int general_bytes2uint(unsigned char byte_high, unsigned char byte_low)
{
    int num;

    //Convert to unsigned int
    num = byte_low + (byte_high << 8);

    return num;
}

void general_int2bytes(int integer, unsigned char *byte_high, unsigned char *byte_low)
{
    int num = integer;

    // Çonevrt integer to 2 bytes
    // If number is negative
    if(num < 0)
    {
        num += 0xFFFF;
    }
    // Split
    *byte_high = (num >> 8) & 0xFF;
    *byte_low = (num) & 0xFF;
}

double general_gaussrand(double mu, double sigma)
{
    static double V1, V2, S;
    static int phase = 0;
    double X;

    if(phase == 0)
    {
        do
        {
            double U1 = (double)rand() / RAND_MAX;
            double U2 = (double)rand() / RAND_MAX;

            V1 = 2 * U1 - 1;
            V2 = 2 * U2 - 1;
            S = V1 * V1 + V2 * V2;
        } while(S >= 1 || S == 0);

        X = V1 * sqrt(-2 * log(S) / S);
    }
    else
    {
        X = V2 * sqrt(-2 * log(S) / S);
    }

    phase = 1 - phase;

    return X * sigma + mu;
}

float general_gaussian(float mu, float sigma, int x)
{
    return exp(- (pow((mu - x), 2)) / (pow(sigma, 2)) / 2.0) / sqrt(M_PI * 2 * (pow(sigma, 2)));
}

float general_dist_squared(int x1, int y1, int x2, int y2)
{
    return pow(x1 - x2, 2) + pow(y1 - y2, 2);
}

float general_dist2seg(int x, int y, int p1[], int p2[])
{
    float l2 = general_dist_squared(p1[0], p1[1], p2[0], p2[1]);

    if (l2 == 0)
        return general_dist_squared(x, y, p1[0], p1[1]);

    float t = ((x - p1[0]) * (p2[0] - p1[0]) + (y - p1[1]) * (p2[1] - p1[1])) / l2;

    if (t < 0)
        return general_dist_squared(x, y, p1[0], p1[1]);

    if (t > 1)
        return general_dist_squared(x, y, p2[0], p2[1]);

    return general_dist_squared(x, y, (p1[0] + t * (p2[0] - p1[0])), (p1[1] + t * (p2[1] - p1[1])));
}

void general_circle(int **arr, int cx, int cy, int radius)
{
    int error = -radius;
    int x = radius;
    int y = 0;

    while (x >= y)
    {
        general_circle_eight_points(arr, cx, cy, x, y);

        error += y;
        ++y;
        error += y;

        if (error >= 0)
        {
            error -= x;
            --x;
            error -= x;
        }
    }
}

void general_circle_eight_points(int **arr, int cx, int cy, int x, int y)
{
    general_circle_four_points(arr, cx, cy, x, y);
    if (x != y)
    {
        general_circle_four_points(arr, cx, cy, y, x);
    }
}

void general_circle_four_points(int **arr, int cx, int cy, int x, int y)
{
    general_circle_horizontal_line(arr, cx - x, cy + y, 2 * x + 1);
    general_circle_horizontal_line(arr, cx - x, cy - y, 2 * x + 1);
}

void general_circle_horizontal_line(int **arr, int x, int y, int len)
{
    // Local variables
    int i;
    
    for(i = 0; i < len; i++)
    {
        arr[x + i][y] = 1;
    }
}