admin, Author at Robotics with ROS

Roll, pitch, yaw using Eigen and KDL Frame

Leave a Comment / C++, Linear Algebra, ROS, Tutorials / admin

/*
yaw:
    A yaw is a counterclockwise rotation of alpha about the  z-axis. The rotation matrix is given by

    R_z

    |cos(alpha) -sin(alpha) 0|
    |sin(apha)   cos(alpha) 0|
    |    0            0     1|

pitch:
    R_y
    A pitch is a counterclockwise rotation of  beta about the  y-axis. The rotation matrix is given by

    |cos(beta)  0   sin(beta)|
    |0          1       0    |
    |-sin(beta) 0   cos(beta)|

roll:
    A roll is a counterclockwise rotation of  gamma about the  x-axis. The rotation matrix is given by
    R_x
    |1          0           0|
    |0 cos(gamma) -sin(gamma)|
    |0 sin(gamma)  cos(gamma)|



    It is important to note that   R_z R_y R_x performs the roll first, then the pitch, and finally the yaw
    Roration matrix: R_z*R_y*R_x
*/

    double roll, pitch, yaw;
    roll=M_PI/3;
    pitch=M_PI/4;
    yaw=M_PI/6;
    Eigen::AngleAxisd rollAngle(roll, Eigen::Vector3d::UnitX());
    Eigen::AngleAxisd pitchAngle(pitch, Eigen::Vector3d::UnitY());
    Eigen::AngleAxisd yawAngle(yaw, Eigen::Vector3d::UnitZ());




    Eigen::Quaternion<double> q =  yawAngle*pitchAngle *rollAngle;

    Eigen::Matrix3d rotationMatrix = q.matrix();
    std::cout<<rotationMatrix <<std::endl;

yaw:

A yaw is a counterclockwise rotation of alpha about the z-axis. The rotation matrix is given by

R_z

|cos(alpha) -sin(alpha) 0|

|sin(apha) cos(alpha) 0|

| 0 0 1|

pitch:

R_y

A pitch is a counterclockwise rotation of beta about the y-axis. The rotation matrix is given by

|cos(beta) 0 sin(beta)|

|0 1 0 |

|-sin(beta) 0 cos(beta)|

roll:

A roll is a counterclockwise rotation of gamma about the x-axis. The rotation matrix is given by

R_x

|1 0 0|

|0 cos(gamma) -sin(gamma)|

|0 sin(gamma) cos(gamma)|

It is important to note that R_z R_y R_x performs the roll first, then the pitch, and finally the yaw

Roration matrix: R_z*R_y*R_x

double roll, pitch, yaw;

roll=M_PI/3;

pitch=M_PI/4;

yaw=M_PI/6;

Eigen::AngleAxisd rollAngle(roll, Eigen::Vector3d::UnitX());

Eigen::AngleAxisd pitchAngle(pitch, Eigen::Vector3d::UnitY());

Eigen::AngleAxisd yawAngle(yaw, Eigen::Vector3d::UnitZ());

Eigen::Quaternion<double> q = yawAngle*pitchAngle *rollAngle;

Eigen::Matrix3d rotationMatrix = q.matrix();

std::cout<<rotationMatrix <<std::endl;

From Eigen documentation: If you are working with OpenGL 4×4 matrices then Affine3f and Affine3d are what you want. Since Eigen defaults to column-major storage, you can directly use the Transform::data() method to pass your transformation matrix to OpenGL. construct a Transform:

Transform t(AngleAxis(angle,axis));

1	Transform t(AngleAxis(angle,axis));

or like this:

Transform t;
t = AngleAxis(angle,axis);

1 2	Transform t; t = AngleAxis(angle,axis);

But note that unfortunately, because of […]

Roll, pitch, yaw using Eigen and KDL Frame Read More »

ROS packages for Dynamic Time Warping

Leave a Comment / C++, Machine Learning, ROS / admin

Dynamic Time Warping (DTW) is a method to align two sequences under certain constraints. For instance, two trajectories that are very similar but one of them performed in a longer time. The alignment should be is such way that minimizes the distance between these two sequences. Here I have done DTW between two-time series with python. I found a

ROS packages for Dynamic Time Warping Read More »

Gaussian Mixture Regression

Leave a Comment / C++, Machine Learning, Tutorials / admin

Gaussian Mixture Regression is basically Multivariate normal distribution with Conditional distribution. The more about the theory could be found at [1], [2], [3], [4]. For this work, I have added the functionality of adding Gaussian Mixture Regression to this project on the GitHub by forking the main project, my forked project can be download at here Github The main changes

Gaussian Mixture Regression Read More »

Expectation Maximization algorithm to obtain Gaussian mixture models for ROS

Leave a Comment / C++, Machine Learning, ROS, Tutorials / admin

I found a really good code at GitHub for fitting a Gaussian Mixture Model (GMM) with Expectation Maximization (EM) for ROS. There are so many parameters that you can change. Some of the most important ones are:

// minimum number of gaussians
#define PARAM_NAME_GAUSSIAN_COUNT_MIN    "gaussian_count_min"
#define PARAM_DEFAULT_GAUSSIAN_COUNT_MIN 1

// search will terminate when the gaussian count reaches this
#define PARAM_NAME_GAUSSIAN_COUNT_MAX    "gaussian_count_max"
#define PARAM_DEFAULT_GAUSSIAN_COUNT_MAX 10

// minimum number of gaussians

#define PARAM_NAME_GAUSSIAN_COUNT_MIN "gaussian_count_min"

#define PARAM_DEFAULT_GAUSSIAN_COUNT_MIN 1

// search will terminate when the gaussian count reaches this

#define PARAM_NAME_GAUSSIAN_COUNT_MAX "gaussian_count_max"

#define PARAM_DEFAULT_GAUSSIAN_COUNT_MAX 10

To find the optimal number of components, it uses Bayesian information criterion (BIC). There are other methods to find

Expectation Maximization algorithm to obtain Gaussian mixture models for ROS Read More »

Generating multivariate normal distribution samples using C++11 and Eigen library.

Leave a Comment / C++, Linear Algebra, Machine Learning / admin

Eigen is a great tool for matrix operations, here I found a small piece of code in Github that enables you to generate multivariate normal distribution samples using C++11 and Eigen library. The below is an example:

#include <fstream>
#include <Eigen/Eigen>
#include <Eigen/Core>
#include <Eigen/Dense>
#include "eigenmvn.h"



int main(int argc, char ** argv)
{
	//number of columns
	const uint n_cols = 2; 
	// number of rows
	const uint n_rows = 5000; 

	Eigen::Matrix<float, Eigen::Dynamic, Eigen::Dynamic> total_gaussian_data_eigen, first_gaussian_data_eigen,second_gaussian_data_eigen;
	first_gaussian_data_eigen.setZero(n_rows,n_cols);
	second_gaussian_data_eigen.setZero(n_rows,n_cols);
	//2*n_rows since we want to concat first and second and put it in this matrix
	total_gaussian_data_eigen.setZero(2*n_rows,n_cols);



	Eigen::Vector2f mean;
	Eigen::Matrix2f covar;
	float theta;

	mean << 0,0; // Set the mean
	
	/* our covar matrix:
	|10  0|
	|0   1|
	*/
	covar <<10,0,0,1;

	//first gaussian
	Eigen::EigenMultivariateNormal<float> normX_solver1(mean,covar);
	first_gaussian_data_eigen<< normX_solver1.samples(n_rows).transpose() ;
	
	
	//secodn gaussian
	mean << 4,4; // Set the mean
// 	Create a covariance matrix rotated clockwise by theta
	theta=M_PI/4.0;
	covar=genCovar(1,4,theta);
	
	Eigen::EigenMultivariateNormal<float> normX_solver2(mean,covar);
	second_gaussian_data_eigen<<normX_solver2.samples(n_rows).transpose() ;


	//concating two gaussians
	total_gaussian_data_eigen<<first_gaussian_data_eigen,second_gaussian_data_eigen;

	
	//writing data into output in csv format
    std::cout<<"x,y\n";
    for (uint i = 0; i < total_gaussian_data_eigen.rows(); i++)
    {
        for (uint h = 0; h < n_cols-1; h++)
        {
                    std::cout<<total_gaussian_data_eigen(i,h);
                    std::cout<<",";
        }
        std::cout<<total_gaussian_data_eigen(i,n_cols-1);
        std::cout<<std::endl;
    }

}

#include <fstream>

#include <Eigen/Eigen>

#include <Eigen/Core>

#include <Eigen/Dense>

#include "eigenmvn.h"

int main(int argc, char ** argv)

{

//number of columns

const uint n_cols = 2;

// number of rows

const uint n_rows = 5000;

Eigen::Matrix<float, Eigen::Dynamic, Eigen::Dynamic> total_gaussian_data_eigen, first_gaussian_data_eigen,second_gaussian_data_eigen;

first_gaussian_data_eigen.setZero(n_rows,n_cols);

second_gaussian_data_eigen.setZero(n_rows,n_cols);

//2*n_rows since we want to concat first and second and put it in this matrix

total_gaussian_data_eigen.setZero(2*n_rows,n_cols);

Eigen::Vector2f mean;

Eigen::Matrix2f covar;

float theta;

mean << 0,0; // Set the mean

/* our covar matrix:

|10 0|

|0 1|

covar <<10,0,0,1;

//first gaussian

Eigen::EigenMultivariateNormal<float> normX_solver1(mean,covar);

first_gaussian_data_eigen<< normX_solver1.samples(n_rows).transpose() ;

//secodn gaussian

mean << 4,4; // Set the mean

// Create a covariance matrix rotated clockwise by theta

theta=M_PI/4.0;

covar=genCovar(1,4,theta);

Eigen::EigenMultivariateNormal<float> normX_solver2(mean,covar);

second_gaussian_data_eigen<<normX_solver2.samples(n_rows).transpose() ;

//concating two gaussians

total_gaussian_data_eigen<<first_gaussian_data_eigen,second_gaussian_data_eigen;

//writing data into output in csv format

std::cout<<"x,y\n";

for (uint i = 0; i < total_gaussian_data_eigen.rows(); i++)

{

for (uint h = 0; h < n_cols-1; h++)

{

std::cout<<total_gaussian_data_eigen(i,h);

std::cout<<",";

}

std::cout<<total_gaussian_data_eigen(i,n_cols-1);

std::cout<<std::endl;

}

Generating multivariate normal distribution samples using C++11 and Eigen library. 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 »

Ackermann steering car robot model with simulation in Gazebo

3 Comments / ROS, Tutorials / admin

Most of the wheeled robots in ROS use move_base to move the robot. move_base geometry model is based on differential drive which basically transforms a velocity command (twist message) into a command for rotating the left and the right wheels at a different speed which enable the car to turn into the right or left or goes straight. But cars

Ackermann steering car robot model with simulation in Gazebo Read More »

Autonomous navigation of two wheels differential drive robot in Gazebo

1 Comment / ROS / admin

Two wheels differential drive robot (with two caster wheels). List of installed sensors: • Velodyne VLP-16. • Velodyne HDL-32E. • Hokuyo Laser scanner. • IMU. • Microsoft Kinect/Asus Xtion Pro. • RGB Camera. You can manually control the robot with Joystick controller for mapping robot environment. Autonomous navigation is possible by setting goal pose.

Autonomous navigation of two wheels differential drive robot in Gazebo 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.