Computer Vision Archives - Page 3 of 5

Finding Affine Transform with Linear Least Squares

3 Comments / Computer Vision, Image Processing, Linear Algebra, Tutorials / admin

linear least squares is a method of fitting a model to data in which the relation between data and unknown paramere can be expressed in a linear form. \( Ax=b\) \( X^{*}= \underset{x}{\mathrm{argmin}}= \|Ax-b\|^{2} =(A^{T}A)^{-1}A^{T}b \)

function M= affine_least_square(x0,y0, x1,y1, x2,y2, xp0,yp0, xp1,yp1, xp2,yp2)
% This function finds the affine transform between three points

% an affine transformation with a 3x3 affine transformation matrix: 
% 
% [M11 M12 M13]
% [M21 M22 M23]
% [M31 M32 M33]

%Since the third row is always [0 0 1] we can skip that.

% [x0 y0 1  0  0  0 ]     [M11]   [xp0]
% [0  0  0  x0 y0 1 ]     [M12]   [yp0] 
% [x1 y1 1  0  0  0 ]     [M13]   [xp1]
% [0  0  0  x1 y1 1 ]  *  [M21] = [yp1] 
% [x2 y2 1  0  0  0 ]     [M22]   [xp2] 
% [0  0  0  x2 y2 1 ]     [M23]   [yp2]
                          
%         A            *    X   =  B
%A -> 6x6
%X -> 6x1 in fact 
%X=A\B


A=[x0 y0 1  0  0  0 ; 0  0  0  x0 y0 1 ; x1 y1 1  0  0  0 ; 0  0  0  x1 y1 1 ; x2 y2 1  0  0  0;0  0  0  x2 y2 1];
B=[xp0; yp0; xp1;  yp1; xp2 ; yp2 ];


% X=A\B; 
% this is what we need but accroding to https://www.mathworks.com/matlabcentral/newsreader/view_thread/170201
%The following is better:
X=pinv(A)*B;

M11 =X(1,1);
M12 =X(2,1);  
M13 =X(3,1);
M21 =X(4,1);
M22 =X(5,1);
M23 =X(6,1);
M=[ M11 M12 M13; M21 M22 M23; 0 0 1];
end

function M= affine_least_square(x0,y0, x1,y1, x2,y2, xp0,yp0, xp1,yp1, xp2,yp2)

% This function finds the affine transform between three points

% an affine transformation with a 3x3 affine transformation matrix:

% [M11 M12 M13]

% [M21 M22 M23]

% [M31 M32 M33]

%Since the third row is always [0 0 1] we can skip that.

% [x0 y0 1 0 0 0 ] [M11] [xp0]

% [0 0 0 x0 y0 1 ] [M12] [yp0]

% [x1 y1 1 0 0 0 ] [M13] [xp1]

% [0 0 0 x1 y1 1 ] * [M21] = [yp1]

% [x2 y2 1 0 0 0 ] [M22] [xp2]

% [0 0 0 x2 y2 1 ] [M23] [yp2]

% A * X = B

%A -> 6x6

%X -> 6x1 in fact

%X=A\B

A=[x0 y0 1 0 0 0 ; 0 0 0 x0 y0 1 ; x1 y1 1 0 0 0 ; 0 0 0 x1 y1 1 ; x2 y2 1 0 0 0;0 0 0 x2 y2 1];

B=[xp0; yp0; xp1; yp1; xp2 ; yp2 ];

% X=A\B;

% this is what we need but accroding to https://www.mathworks.com/matlabcentral/newsreader/view_thread/170201

%The following is better:

X=pinv(A)*B;

M11 =X(1,1);

M12 =X(2,1);

M13 =X(3,1);

M21 =X(4,1);

M22 =X(5,1);

M23 =X(6,1);

M=[ M11 M12 M13; M21 M22 M23; 0 0 1];

end

And testing the code:

clc;
clear all;
%This is a simple test that project 3 point with an affine trasnform and
%then tries to find the transformation:
% tform.T and M' should be equal

%Points are located at:
x0=0;
y0=0; 
x1=1;
y1=0; 
x2=0;
y2=1;

p1=[x0,y0; x1,y1; x2,y2];

%We rotate them (a roll-rotation around Z axes) theta degree, first
%building the rotation matrix
theta=24;
A11=cosd(theta);
A12=-sind(theta);
A21=sind(theta);
A22=cosd(theta);
%Translation part
Tx=1;
Ty=2;

tform = affine2d([A11 A12 0; A21 A22 0; Tx Ty 1]);
fprintf('3x3 transformation matrix:')
tform.T

[x,y]=transformPointsForward(tform,p1(:,1),p1(:,2));
fprintf('transformed points:')
[x,y]


xp0=x(1,1);
yp0=y(1,1);
xp1=x(2,1);
yp1=y(2,1);
xp2=x(3,1);
yp2=y(3,1);



%finding the tranformation matrix from set of points and their respective
%transformed points:
M=affine_least_square(x0,y0, x1,y1, x2,y2, xp0,yp0, xp1,yp1, xp2,yp2);
fprintf('3x3 affine transformation matrix from least_squares:')
M'

tform = affine2d(M');
[x,y]=transformPointsForward(tform,p1(:,1),p1(:,2));
[x,y];

clc;

clear all;

%This is a simple test that project 3 point with an affine trasnform and

%then tries to find the transformation:

% tform.T and M' should be equal

%Points are located at:

x0=0;

y0=0;

x1=1;

y1=0;

x2=0;

y2=1;

p1=[x0,y0; x1,y1; x2,y2];

%We rotate them (a roll-rotation around Z axes) theta degree, first

%building the rotation matrix

theta=24;

A11=cosd(theta);

A12=-sind(theta);

A21=sind(theta);

A22=cosd(theta);

%Translation part

Tx=1;

Ty=2;

tform = affine2d([A11 A12 0; A21 A22 0; Tx Ty 1]);

fprintf('3x3 transformation matrix:')

tform.T

[x,y]=transformPointsForward(tform,p1(:,1),p1(:,2));

fprintf('transformed points:')

[x,y]

xp0=x(1,1);

yp0=y(1,1);

xp1=x(2,1);

yp1=y(2,1);

xp2=x(3,1);

yp2=y(3,1);

%finding the tranformation matrix from set of points and their respective

%transformed points:

M=affine_least_square(x0,y0, x1,y1, x2,y2, xp0,yp0, xp1,yp1, xp2,yp2);

fprintf('3x3 affine transformation matrix from least_squares:')

tform = affine2d(M');

[x,y]=transformPointsForward(tform,p1(:,1),p1(:,2));

[x,y];

3x3 transformation matrix:
ans =

    0.9135   -0.4067         0
    0.4067    0.9135         0
    1.0000    2.0000    1.0000

transformed points:
ans =

    1.0000    2.0000
    1.9135    1.5933
    1.4067    2.9135

3x3 affine transformation matrix from least_squares:
ans =

    0.9135   -0.4067         0
    0.4067    0.9135         0
    1.0000    2.0000    1.0000

3x3 transformation matrix:

ans =

0.9135 -0.4067 0

0.4067 0.9135 0

1.0000 2.0000 1.0000

transformed points:

ans =

1.0000 2.0000

1.9135 1.5933

1.4067 2.9135

3x3 affine transformation matrix from least_squares:

ans =

0.9135 -0.4067 0

0.4067 0.9135 0

1.0000 2.0000 1.0000

Finding Affine Transform with Linear Least Squares Read More »

Peak Signal-to-Noise Ratio (PSNR) in Image using OpenCV and Matlab

Leave a Comment / C++, Computer Vision, Image Processing, Matlab, Tutorials / admin

Peak signal-to-noise ratio (PSNR) shows the ratio between the maximum possible power of a signal and the power of the same image with noise. PSNR is usually expressed in logarithmic decibel scale. \( MSE =1/m*n \sum_{i=0}^{m-1} \sum_{j=0}^{n-1} [ Image( i,j) -NoisyImage( i,j) ] ^2 \) \( PSNR =10* \log_{10} \Bigg(MAXI^2/MSE\Bigg) \) MSE is Mean Square Error and MAXI is

Peak Signal-to-Noise Ratio (PSNR) in Image using OpenCV and Matlab Read More »

Seam Carving Algorithm for Content-Aware Image Resizing with Matlab Code

1 Comment / Computer Vision, Image Processing, Machine Learning, Tutorials / admin

Seam carving is an algorithm for resizing images while keeping the most prominent and conspicuous pixels in the image. The important pixels in an image are usually those who are located over horizontal or vertical edges, so to throw away some pixels we first find horizontal and vertical edges and store their magnitude as pixel

Seam Carving Algorithm for Content-Aware Image Resizing with Matlab Code Read More »

HARRIS Corner detector explained

4 Comments / Computer Vision, Image Processing, Linear Algebra, Machine Learning, Tutorials / admin

im = imread('chessboard.jpg');
im = double(rgb2gray(im))/255;

sigma = 5;
g = fspecial('gaussian', 2*sigma*3+1, sigma);
dx = [-1 0 1;-1 0 1; -1 0 1];
Ix = imfilter(im, dx, 'symmetric', 'same');
Iy = imfilter(im, dx', 'symmetric', 'same');
Ix2 = imfilter(Ix.^2, g, 'symmetric', 'same');
Iy2 = imfilter(Iy.^2, g, 'symmetric', 'same');
Ixy = imfilter(Ix.*Iy, g, 'symmetric', 'same');
k = 0.04; % k is between 0.04 and 0.06
% --- r = Det(M) - kTrace(M)^2 ---
r = (Ix2.*Iy2 - Ixy.^2) - k*(Ix2 + Iy2).^2;

norm_r = r - min(r(:));
norm_r = norm_r ./ max(norm_r(:));
subplot(1,2,1), imshow(im)
subplot(1,2,2), imshow(norm_r)


%hLocalMax = vision.LocalMaximaFinder;
%hLocalMax.MaximumNumLocalMaxima = 100;
%hLocalMax.NeighborhoodSize = [3 3];
%hLocalMax.Threshold = 0.05;
%location = step(hLocalMax, norm_r);

im = imread('chessboard.jpg');

im = double(rgb2gray(im))/255;

sigma = 5;

g = fspecial('gaussian', 2*sigma*3+1, sigma);

dx = [-1 0 1;-1 0 1; -1 0 1];

Ix = imfilter(im, dx, 'symmetric', 'same');

Iy = imfilter(im, dx', 'symmetric', 'same');

Ix2 = imfilter(Ix.^2, g, 'symmetric', 'same');

Iy2 = imfilter(Iy.^2, g, 'symmetric', 'same');

Ixy = imfilter(Ix.*Iy, g, 'symmetric', 'same');

k = 0.04; % k is between 0.04 and 0.06

% --- r = Det(M) - kTrace(M)^2 ---

r = (Ix2.*Iy2 - Ixy.^2) - k*(Ix2 + Iy2).^2;

norm_r = r - min(r(:));

norm_r = norm_r ./ max(norm_r(:));

subplot(1,2,1), imshow(im)

subplot(1,2,2), imshow(norm_r)

%hLocalMax = vision.LocalMaximaFinder;

%hLocalMax.MaximumNumLocalMaxima = 100;

%hLocalMax.NeighborhoodSize = [3 3];

%hLocalMax.Threshold = 0.05;

%location = step(hLocalMax, norm_r);

HARRIS Corner detector explained Read More »

Eigenvectors of PCL pointcloud (moment of inertia)

Leave a Comment / C++, Computer Vision, Tutorials / admin

The snippet below shows how to computer PCA eigenvectors and eigenvalues (in this case could be interpreted as the moment of inertia).

#include <pcl/features/moment_of_inertia_estimation.h>
#include <pcl/point_cloud.h>
#include <pcl/io/pcd_io.h>
#include <pcl/visualization/cloud_viewer.h>
#include <pcl/io/ply_io.h>

template <typename PointT>
void computeMomentOfInertia(boost::shared_ptr<pcl::PointCloud<PointT> > cloud_ptr)
{
	pcl::MomentOfInertiaEstimation <PointT> feature_extractor;
	feature_extractor.setInputCloud (cloud_ptr);
	feature_extractor.compute ();

	std::vector <float> moment_of_inertia;
	std::vector <float> eccentricity;


	pcl::PointXYZRGB min_point_AABB;
	pcl::PointXYZRGB max_point_AABB;
	pcl::PointXYZRGB min_point_OBB;
	pcl::PointXYZRGB max_point_OBB;
	pcl::PointXYZRGB position_OBB;


	Eigen::Matrix3f rotational_matrix_OBB;
	float major_value, middle_value, minor_value;
	Eigen::Vector3f major_vector, middle_vector, minor_vector;
	Eigen::Vector3f mass_center;

	feature_extractor.getMomentOfInertia (moment_of_inertia);
	feature_extractor.getEccentricity (eccentricity);
	feature_extractor.getAABB (min_point_AABB, max_point_AABB);
	feature_extractor.getOBB (min_point_OBB, max_point_OBB, position_OBB, rotational_matrix_OBB);
	feature_extractor.getEigenValues (major_value, middle_value, minor_value);
	feature_extractor.getEigenVectors (major_vector, middle_vector, minor_vector);
	feature_extractor.getMassCenter (mass_center);

	boost::shared_ptr<pcl::visualization::PCLVisualizer> viewer (new pcl::visualization::PCLVisualizer ("3D Viewer"));
	viewer->setBackgroundColor (0, 0, 0);
	viewer->addCoordinateSystem (0.1);
	viewer->initCameraParameters ();

	pcl::PointXYZ center (mass_center (0), mass_center (1), mass_center (2));
	pcl::PointXYZ x_axis (major_vector (0) + mass_center (0), major_vector (1) + mass_center (1), major_vector (2) + mass_center (2));
	pcl::PointXYZ y_axis (middle_vector (0) + mass_center (0), middle_vector (1) + mass_center (1), middle_vector (2) + mass_center (2));
	pcl::PointXYZ z_axis (minor_vector (0) + mass_center (0), minor_vector (1) + mass_center (1), minor_vector (2) + mass_center (2));

	viewer->addLine (center, x_axis, 1.0f, 0.0f, 0.0f, "major eigen vector");
	viewer->addLine (center, y_axis, 0.0f, 1.0f, 0.0f, "middle eigen vector");
	viewer->addLine (center, z_axis, 0.0f, 0.0f, 1.0f, "minor eigen vector");
	viewer->addPointCloud<pcl::PointXYZRGB> (cloud_ptr, "Moment Of Inertia (PCA Eigen Vector Axes)");
	
	while (!viewer->wasStopped ())
	{
		viewer->spinOnce ();
	}
}


int main(int argc, char **argv)
{
	pcl::PointCloud<pcl::PointXYZRGB>::Ptr cloudrgb_ptr(new pcl::PointCloud<pcl::PointXYZRGB>);
	pcl::PLYReader PLYFileReader;
	const int offset=0;
	PLYFileReader.read< pcl::PointXYZRGB >(argv[1],*cloudrgb_ptr,offset);
	//pcl::io::loadPCDFile(argv[1],*cloudrgb_ptr);
	computeMomentOfInertia(cloudrgb_ptr);
	return 0;
}

#include <pcl/features/moment_of_inertia_estimation.h>

#include <pcl/point_cloud.h>

#include <pcl/io/pcd_io.h>

#include <pcl/visualization/cloud_viewer.h>

#include <pcl/io/ply_io.h>

template <typename PointT>

void computeMomentOfInertia(boost::shared_ptr<pcl::PointCloud<PointT> > cloud_ptr)

{

pcl::MomentOfInertiaEstimation <PointT> feature_extractor;

feature_extractor.setInputCloud (cloud_ptr);

feature_extractor.compute ();

std::vector <float> moment_of_inertia;

std::vector <float> eccentricity;

pcl::PointXYZRGB min_point_AABB;

pcl::PointXYZRGB max_point_AABB;

pcl::PointXYZRGB min_point_OBB;

pcl::PointXYZRGB max_point_OBB;

pcl::PointXYZRGB position_OBB;

Eigen::Matrix3f rotational_matrix_OBB;

float major_value, middle_value, minor_value;

Eigen::Vector3f major_vector, middle_vector, minor_vector;

Eigen::Vector3f mass_center;

feature_extractor.getMomentOfInertia (moment_of_inertia);

feature_extractor.getEccentricity (eccentricity);

feature_extractor.getAABB (min_point_AABB, max_point_AABB);

feature_extractor.getOBB (min_point_OBB, max_point_OBB, position_OBB, rotational_matrix_OBB);

feature_extractor.getEigenValues (major_value, middle_value, minor_value);

feature_extractor.getEigenVectors (major_vector, middle_vector, minor_vector);

feature_extractor.getMassCenter (mass_center);

boost::shared_ptr<pcl::visualization::PCLVisualizer> viewer (new pcl::visualization::PCLVisualizer ("3D Viewer"));

viewer->setBackgroundColor (0, 0, 0);

viewer->addCoordinateSystem (0.1);

viewer->initCameraParameters ();

pcl::PointXYZ center (mass_center (0), mass_center (1), mass_center (2));

pcl::PointXYZ x_axis (major_vector (0) + mass_center (0), major_vector (1) + mass_center (1), major_vector (2) + mass_center (2));

pcl::PointXYZ y_axis (middle_vector (0) + mass_center (0), middle_vector (1) + mass_center (1), middle_vector (2) + mass_center (2));

pcl::PointXYZ z_axis (minor_vector (0) + mass_center (0), minor_vector (1) + mass_center (1), minor_vector (2) + mass_center (2));

viewer->addLine (center, x_axis, 1.0f, 0.0f, 0.0f, "major eigen vector");

viewer->addLine (center, y_axis, 0.0f, 1.0f, 0.0f, "middle eigen vector");

viewer->addLine (center, z_axis, 0.0f, 0.0f, 1.0f, "minor eigen vector");

viewer->addPointCloud<pcl::PointXYZRGB> (cloud_ptr, "Moment Of Inertia (PCA Eigen Vector Axes)");

while (!viewer->wasStopped ())

{

viewer->spinOnce ();

}

int main(int argc, char **argv)

{

pcl::PointCloud<pcl::PointXYZRGB>::Ptr cloudrgb_ptr(new pcl::PointCloud<pcl::PointXYZRGB>);

pcl::PLYReader PLYFileReader;

const int offset=0;

PLYFileReader.read< pcl::PointXYZRGB >(argv[1],*cloudrgb_ptr,offset);

//pcl::io::loadPCDFile(argv[1],*cloudrgb_ptr);

computeMomentOfInertia(cloudrgb_ptr);

return 0;

}

Eigenvectors of PCL pointcloud (moment of inertia) Read More »

A GUI ROS-package for cropping pcl pointcloud with dynamic reconfigure

2 Comments / C++, Computer Vision, Image Processing, ROS, Tutorials / admin

This ROS package enables you to crop the scene from Kinect (input topic type: PCL pointcloud). You can even enable fitting a plane to remove the ground from the scene and by adjusting correct parameter you can get the desired object from the scene. code available on my Github.

A GUI ROS-package for cropping pcl pointcloud with dynamic reconfigure Read More »

List of OpenCv matrix types and mapping numbers

Leave a Comment / C++, Computer Vision, Image Processing, Tutorials / admin

/*

            C1  C2   C3  C4
    CV_8U	0	8	16	24
    CV_8S	1	9	17	25
    CV_16U	2	10	18	26
    CV_16S	3	11	19	27
    CV_32S	4	12	20	28
    CV_32F	5	13	21	29
    CV_64F	6	14	22	30
    Unsigned 8bits uchar 0~255
    IplImage: IPL_DEPTH_8U
    Mat: CV_8UC1, CV_8UC2, CV_8UC3, CV_8UC4

    Signed 8bits char -128~127
    IplImage: IPL_DEPTH_8S
    Mat: CV_8SC1，CV_8SC2，CV_8SC3，CV_8SC4

    Unsigned 16bits ushort 0~65535
    IplImage: IPL_DEPTH_16U
    Mat: CV_16UC1，CV_16UC2，CV_16UC3，CV_16UC4

    Signed 16bits short -32768~32767
    IplImage: IPL_DEPTH_16S
    Mat: CV_16SC1，CV_16SC2，CV_16SC3，CV_16SC4

    Signed 32bits int -2147483648~2147483647
    IplImage: IPL_DEPTH_32S
    Mat: CV_32SC1，CV_32SC2，CV_32SC3，CV_32SC4

    Float 32bits float -1.18*10-38~3.40*10-38
    IplImage: IPL_DEPTH_32F
    Mat: CV_32FC1，CV_32FC2，CV_32FC3，CV_32FC4

    Double 64bits double
    Mat: CV_64FC1，CV_64FC2，CV_64FC3，CV_64FC4

    Unsigned 1bit bool
    IplImage: IPL_DEPTH_1U
*/
//example:

    int number_of_rows, number_of_columns;
    number_of_rows=3;
    number_of_columns=4;
    cv::Mat mat_CV_8U(number_of_rows, number_of_columns,CV_8UC1);
    std::cout<<"mat_CV_8U.type(): " <<mat_CV_8U.type() <<std::endl;


    cv::Mat mat_CV_64FC1(number_of_rows, number_of_columns,CV_64FC1);
    std::cout<<"mat_CV_64FC1.type(): " <<mat_CV_64FC1.type() <<std::endl;

C1 C2 C3 C4

CV_8U 0 8 16 24

CV_8S 1 9 17 25

CV_16U 2 10 18 26

CV_16S 3 11 19 27

CV_32S 4 12 20 28

CV_32F 5 13 21 29

CV_64F 6 14 22 30

Unsigned 8bits uchar 0~255

IplImage: IPL_DEPTH_8U

Mat: CV_8UC1, CV_8UC2, CV_8UC3, CV_8UC4

Signed 8bits char -128~127

IplImage: IPL_DEPTH_8S

Mat: CV_8SC1，CV_8SC2，CV_8SC3，CV_8SC4

Unsigned 16bits ushort 0~65535

IplImage: IPL_DEPTH_16U

Mat: CV_16UC1，CV_16UC2，CV_16UC3，CV_16UC4

Signed 16bits short -32768~32767

IplImage: IPL_DEPTH_16S

Mat: CV_16SC1，CV_16SC2，CV_16SC3，CV_16SC4

Signed 32bits int -2147483648~2147483647

IplImage: IPL_DEPTH_32S

Mat: CV_32SC1，CV_32SC2，CV_32SC3，CV_32SC4

Float 32bits float -1.18*10-38~3.40*10-38

IplImage: IPL_DEPTH_32F

Mat: CV_32FC1，CV_32FC2，CV_32FC3，CV_32FC4

Double 64bits double

Mat: CV_64FC1，CV_64FC2，CV_64FC3，CV_64FC4

Unsigned 1bit bool

IplImage: IPL_DEPTH_1U

//example:

int number_of_rows, number_of_columns;

number_of_rows=3;

number_of_columns=4;

cv::Mat mat_CV_8U(number_of_rows, number_of_columns,CV_8UC1);

std::cout<<"mat_CV_8U.type(): " <<mat_CV_8U.type() <<std::endl;

cv::Mat mat_CV_64FC1(number_of_rows, number_of_columns,CV_64FC1);

std::cout<<"mat_CV_64FC1.type(): " <<mat_CV_64FC1.type() <<std::endl;

ref: Special thanks to this post.

List of OpenCv matrix types and mapping numbers Read More »

Multi scale face detector using HOG features and support vector machine

Leave a Comment / Computer Vision, Image Processing, Machine Learning / admin

In this part, I trained an SVM over images of “face” or “not face” (36 × 36 pixels), using HOG features. I used VLFeat library for both HOG and the SVM. Example of face images: Example of nonface images: I divided the dataset into a training and a test set (80% and 20% respectively) and computed the HOG

Multi scale face detector using HOG features and support vector machine Read More »

2D pose estimation of human body using CNS and PCA

1 Comment / C++, Computer Vision, Image Processing, Linear Algebra, Machine Learning / admin

This work is the second part of my master thesis (part I). In this part, I developed an algorithm for 2D pose estimation of the human body. To do this, I created a software with QT that could generate 2D contours representing human body. Then I send these contours for evaluation to CNS(Contrast Normalized Sobel) [1]

2D pose estimation of human body using CNS and PCA Read More »

Human detection on mobile camera using HOG and tracking them using Kalman filter

1 Comment / Computer Vision, Image Processing, Machine Learning, Tutorials / admin

This is the part I of the work that I did for my master thesis (part II). In this work first, I computed HOG (Histogram of oriented gradients) on my images and then sent the computed histogram to a linear SVM (support vector machine). The SVM was trained with human and non-human images. The output of the classifier was

Human detection on mobile camera using HOG and tracking them using Kalman filter Read More »

Cookie	Duration	Description
cookielawinfo-checbox-analytics	11 months	This cookie is set by GDPR Cookie Consent plugin. The cookie is used to store the user consent for the cookies in the category "Analytics".
cookielawinfo-checbox-functional	11 months	The cookie is set by GDPR cookie consent to record the user consent for the cookies in the category "Functional".
cookielawinfo-checbox-others	11 months	This cookie is set by GDPR Cookie Consent plugin. The cookie is used to store the user consent for the cookies in the category "Other.
cookielawinfo-checkbox-necessary	11 months	This cookie is set by GDPR Cookie Consent plugin. The cookies is used to store the user consent for the cookies in the category "Necessary".
cookielawinfo-checkbox-performance	11 months	This cookie is set by GDPR Cookie Consent plugin. The cookie is used to store the user consent for the cookies in the category "Performance".
viewed_cookie_policy	11 months	The cookie is set by the GDPR Cookie Consent plugin and is used to store whether or not user has consented to the use of cookies. It does not store any personal data.