C++ Archives - Page 3 of 6 - Robotics with ROS

Clang format and code beautifier for Qt Creator

Leave a Comment / C++, Tutorials / admin

Clang format and code beautifier for Qt Creator Different developers use different styles with different IDE (i.e some people use space, some use tab) which may cause lots of changes in your git repository. One solution to this is to use some standard code formatting and beautifier. clang is a great tool for this purpose […]

Clang format and code beautifier for Qt Creator Read More »

Human detection and Pose Estimation with Deep Learning for Sport Analysis

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

Pose estimation and tracking human is one the key step in sports analysis. Here is in this work I used openpose for analysis of player in a Bundesliga game HSV Hamburg vs Bayer München. Warning: the video might be disturbing for HSV fans 🙂 Original Video Analyzed Video Original Video Analyzed Video Original Video Analyzed Video Original Video

Human detection and Pose Estimation with Deep Learning for Sport Analysis Read More »

Breadth-first search (BFS) and Depth-first search (DSF) Algorithm with Python and C++

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

Python Implementation BFS traverse:

Root='a'
g.nodes[Root]['visited']=True
print Root 
Q=[Root]
BFS_travrse(Q,g)

Root='a'

g.nodes[Root]['visited']=True

print Root

Q=[Root]

BFS_travrse(Q,g)

DFS traverse:

Root='a'
print Root
g.nodes[Root]['visited']=True
coloring_tree(g)
DFS_travrse(Root,g)

Root='a'

print Root

g.nodes[Root]['visited']=True

coloring_tree(g)

DFS_travrse(Root,g)

import networkx as nx
import matplotlib.pyplot as plt
from networkx.drawing.nx_agraph import write_dot, graphviz_layout


def coloring_tree(G):

    visited_list=[]
    for i in G.nodes():
        visited_list.append( g.nodes[i]['visited'] )
    
    graph_color_map=[]
    for i  in visited_list:
        if i:
            color='blue'
        else:
            color='red'
        graph_color_map.append(color)
    pos =graphviz_layout(G, prog='dot')
    nx.draw(G, pos, with_labels=True, arrows=True,node_color =  graph_color_map)
    #plt.savefig('nx_test.png')
    plt.show()
    
    return

def DFS_travrse(N,G):
    neighbors =G.neighbors(N)
    size=len( list(neighbors))
    if size==0:
        return
    neighbors =G.neighbors(N)
    for neighbor in neighbors:
        G.nodes[neighbor]['visited']=True
        coloring_tree(G)
        DFS_travrse(neighbor,G)
    return

def BFS_travrse(Q,G):
    if len(Q)==0:
        return
    Root=Q[0]
    Q=Q[1:len(Q)]
    neighbors =G.neighbors(Root)
    for neighbor in neighbors:
        print neighbor
        coloring_tree(G)
        G.nodes[neighbor]['visited']=True
        Q.append(neighbor)
 
    BFS_travrse(Q,G)
    return


g=nx.DiGraph()
g.add_node('a',visited=False)
g.add_node('b',visited=False)
g.add_node('c',visited=False)
g.add_node('d',visited=False)
g.add_node('e',visited=False)
g.add_node('f',visited=False)
g.add_node('g',visited=False)
g.add_node('h',visited=False)


g.add_edge('a','b')
g.add_edge('a','c')
g.add_edge('b','e')
g.add_edge('b','d')
g.add_edge('e','h')
g.add_edge('c','f')
g.add_edge('c','g')

import networkx as nx

import matplotlib.pyplot as plt

from networkx.drawing.nx_agraph import write_dot, graphviz_layout

def coloring_tree(G):

visited_list=[]

for i in G.nodes():

visited_list.append( g.nodes[i]['visited'] )

graph_color_map=[]

for i in visited_list:

if i:

color='blue'

else:

color='red'

graph_color_map.append(color)

pos =graphviz_layout(G, prog='dot')

nx.draw(G, pos, with_labels=True, arrows=True,node_color = graph_color_map)

#plt.savefig('nx_test.png')

plt.show()

return

def DFS_travrse(N,G):

neighbors =G.neighbors(N)

size=len( list(neighbors))

if size==0:

return

neighbors =G.neighbors(N)

for neighbor in neighbors:

G.nodes[neighbor]['visited']=True

coloring_tree(G)

DFS_travrse(neighbor,G)

return

def BFS_travrse(Q,G):

if len(Q)==0:

return

Root=Q[0]

Q=Q[1:len(Q)]

neighbors =G.neighbors(Root)

for neighbor in neighbors:

print neighbor

coloring_tree(G)

G.nodes[neighbor]['visited']=True

Q.append(neighbor)

BFS_travrse(Q,G)

return

g=nx.DiGraph()

g.add_node('a',visited=False)

g.add_node('b',visited=False)

g.add_node('c',visited=False)

g.add_node('d',visited=False)

g.add_node('e',visited=False)

g.add_node('f',visited=False)

g.add_node('g',visited=False)

g.add_node('h',visited=False)

g.add_edge('a','b')

g.add_edge('a','c')

g.add_edge('b','e')

g.add_edge('b','d')

g.add_edge('e','h')

g.add_edge('c','f')

g.add_edge('c','g')

C++ Implementation

#include <algorithm>
#include <iostream>
#include <memory>

class node
{
public:
    std::vector<std::shared_ptr<node> > leaves;
    double data;
};

void populateTree(std::shared_ptr<node> rootNodePtr)
{
/*
                   -1
                  /   \
                3       7
              /  \    /
             4    1  5
*/

    rootNodePtr->data=-1;
    std::shared_ptr<node>  leftNodePtr,rightNodePtr;
    std::shared_ptr<node>  leftNode1stKidPtr,leftNode2ndtKidPtr, rightNode1stKidPtr;

    leftNodePtr.reset(new node) ;
    rightNodePtr.reset(new node);
    rootNodePtr->leaves.push_back(leftNodePtr);
    rootNodePtr->leaves.push_back(rightNodePtr);

    leftNodePtr->data=3;
    rightNodePtr->data=7;

    leftNode1stKidPtr.reset(new node);
    leftNode2ndtKidPtr.reset(new node);
    rightNode1stKidPtr.reset(new node);

    leftNode1stKidPtr->data=4;
    leftNode2ndtKidPtr->data=1;
    rightNode1stKidPtr->data=5;

    leftNodePtr->leaves.push_back(leftNode1stKidPtr);
    leftNodePtr->leaves.push_back(leftNode2ndtKidPtr);

    rightNodePtr->leaves.push_back(rightNode1stKidPtr);

}

void DFS(std::shared_ptr<node> rootNode)
{
    std::cout<<rootNode->data <<std::endl;
    for(auto n:rootNode->leaves)
        DFS(n);
}

void BFS(std::shared_ptr<node> rootNode)
{

    for(auto n:rootNode->leaves)
        std::cout<<n->data <<std::endl;

    for(auto n:rootNode->leaves)
        BFS(n);
}
int main()
{
    std::shared_ptr<node> tree(new node);
    populateTree(tree);
    DFS(tree);
    BFS(tree); 
}

#include <algorithm>

#include <iostream>

#include <memory>

class node

{

public:

std::vector<std::shared_ptr<node> > leaves;

double data;

};

void populateTree(std::shared_ptr<node> rootNodePtr)

{

-1

/ \

3 7

/ \ /

4 1 5

rootNodePtr->data=-1;

std::shared_ptr<node> leftNodePtr,rightNodePtr;

std::shared_ptr<node> leftNode1stKidPtr,leftNode2ndtKidPtr, rightNode1stKidPtr;

leftNodePtr.reset(new node) ;

rightNodePtr.reset(new node);

rootNodePtr->leaves.push_back(leftNodePtr);

rootNodePtr->leaves.push_back(rightNodePtr);

leftNodePtr->data=3;

rightNodePtr->data=7;

leftNode1stKidPtr.reset(new node);

leftNode2ndtKidPtr.reset(new node);

rightNode1stKidPtr.reset(new node);

leftNode1stKidPtr->data=4;

leftNode2ndtKidPtr->data=1;

rightNode1stKidPtr->data=5;

leftNodePtr->leaves.push_back(leftNode1stKidPtr);

leftNodePtr->leaves.push_back(leftNode2ndtKidPtr);

rightNodePtr->leaves.push_back(rightNode1stKidPtr);

}

void DFS(std::shared_ptr<node> rootNode)

{

std::cout<<rootNode->data <<std::endl;

for(auto n:rootNode->leaves)

DFS(n);

}

void BFS(std::shared_ptr<node> rootNode)

{

for(auto n:rootNode->leaves)

std::cout<<n->data <<std::endl;

for(auto n:rootNode->leaves)

BFS(n);

}

int main()

{

std::shared_ptr<node> tree(new node);

populateTree(tree);

DFS(tree);

BFS(tree);

}

Breadth-first search (BFS) and Depth-first search (DSF) Algorithm with Python and C++ Read More »

How to use OpenCV 3 Contribution Modules

Leave a Comment / C++, Tutorials / admin

OpenCV Contribution Modules are developed code from the community of OpenCV and are not very stable but after they got stable they will be part f OpenCV. Anyhow, there are a lot of cool modules there (fuzzy logic, sfm, cnn, …) that made me have look at them and try them. gflags

git clone https://github.com/gflags/gflags
cd gflags
cmake -S . -B build -DCMAKE_BUILD_TYPE=Release -DBUILD_SHARED_LIBS=ON -DCMAKE_INSTALL_PREFIX:PATH=~/usr 
cmake --build build -j8
cmake --install build

git clone https://github.com/gflags/gflags

cd gflags

cmake -S . -B build -DCMAKE_BUILD_TYPE=Release -DBUILD_SHARED_LIBS=ON -DCMAKE_INSTALL_PREFIX:PATH=~/usr

cmake --build build -j8

cmake --install build

2) glog

How to use OpenCV 3 Contribution Modules Read More »

Open source Structure-from-Motion and Multi-View Stereo tools with C++

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

Structure-from-Motion (SFM) is genuinely an interesting topic in computer vision, Basically making 3D structure from something 2D is absolutely mesmerizing 🙂 There two open source yet very robust tools for SFM, which sometimes compiling them might be complicated, here I will share my experience with you. 1)VisualSFM Prerequisite: 1)Glew Download the glew from SF at http://glew.sourceforge.net/. Do NOT get it from Github as

Open source Structure-from-Motion and Multi-View Stereo tools with C++ Read More »

Computing OpticalFlow with OpenCV

1 Comment / C++, Computer Vision, Tutorials / admin

There are two main approaches for computing optical flow, computing optical flow for all pixel or computing optical flow for corners. 1. Computing optical flow for all pixel 2. Computing optical flow for corners

Computing OpticalFlow with OpenCV Read More »

Finding Homography Matrix using Singular-value Decomposition and RANSAC in OpenCV and Matlab

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

Solving a Homography problem leads to solving a set of homogeneous linear equations such below: \begin{equation} \left( \begin{array}{ccccccccc} -x1 & -y1 & -1 & 0 & 0 & 0 & x1*xp1 & y1*xp1 & xp1\\ 0 & 0 & 0 & -x1 & -y1 & -1 & x1*yp1 & y1*yp1 & yp1\\ -x2 & -y2 &

Finding Homography Matrix using Singular-value Decomposition and RANSAC in OpenCV and Matlab Read More »

Examples of Dynamic Programming with C++ and Matlab

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

In this tutorial, I will give you examples of using dynamic programming for solving the following problems: 1)Minimum number of coins for summing X.

int c[]={1,3,4}; // value of coins
int k=3; //number of cpins that we have

/*
The d[20] array is for memorization, for instance if we computed f_coin_problem_memo(3),
we put this value in d[3] and we don't compute it again, we just use d[3] instead of f_coin_problem_memo(3)
*/
int d[20];
int f_coin_problem_memo(int x)
{
    if (x < 0) return 1e9;
    if (x == 0) return 0;
    if (d[x]) return d[x];
    int u = 1e9;
    int u_old = 1e9;
    for (int i = 0; i < k; i++)
    {
        u_old=u;
        u = std::min(u, f_coin_problem_memo(x-c[i]) +1);
    }
    d[x] = u;
    return d[x];
}

int c[]={1,3,4}; // value of coins

int k=3; //number of cpins that we have

The d[20] array is for memorization, for instance if we computed f_coin_problem_memo(3),

we put this value in d[3] and we don't compute it again, we just use d[3] instead of f_coin_problem_memo(3)

int d[20];

int f_coin_problem_memo(int x)

{

if (x < 0) return 1e9;

if (x == 0) return 0;

if (d[x]) return d[x];

int u = 1e9;

int u_old = 1e9;

for (int i = 0; i < k; i++)

{

u_old=u;

u = std::min(u, f_coin_problem_memo(x-c[i]) +1);

}

d[x] = u;

return d[x];

}

The minimum number of coins from the set {1,3,4} to sum up value of 12 is:
3

1 2	The minimum number of coins from the set {1,3,4} to sum up value of 12 is: 3

2)The most (least) costly path on a grid (dynamic time warping).

finding a path in an n × n grid from the upper-left corner to the lower-right corner. We are only allowed
 to move right or down.

1,1  1,2 .... 1,X
2,1  2,2 .... 2,X
.
.
.
Y,1  Y,2 .... Y,X


3 7 9 2 7
9 8 3 5 5
1 7 9 8 5
3 8 6 4 10
6 3 9 7 8

*/

int grid[5][5]={{3,7, 9, 2, 7},{9, 8, 3 ,5 ,5},{1, 7 ,9 ,8 ,5},{3, 8, 6 ,4 ,10},{6, 3 ,9 ,7 ,8}};
int memo[5][5]{{-1,-1,-1,-1,-1},{-1,-1,-1,-1,-1},{-1,-1,-1,-1,-1},{-1,-1,-1,-1,-1},{-1,-1,-1,-1,-1}};

std::vector<int>x_solution,y_solution;

int f_paths_in_grid(int y,int x)
{
    if((x==0)&& (y==0))
    {
        memo[y][x]=grid[0][0];
    }
    else if (x==0)
    {
        if(memo[y][x]<0)
        {
            memo[y][x] =f_paths_in_grid(y-1,x) +grid[y][x];
        }
    }
    else if(y==0)
    {
       if(memo[y][x]<0)
       {
            memo[y][x]=f_paths_in_grid(y,x-1) +grid[y][x];
       }
    }
   else if(memo[y][x]<0)
   {
        memo[y][x]=std::max(f_paths_in_grid(y,x-1)  ,f_paths_in_grid(y-1,x)  )+grid[y][x];
    }
    return  memo[y][x];
}

finding a path in an n × n grid from the upper-left corner to the lower-right corner. We are only allowed

to move right or down.

1,1 1,2 .... 1,X

2,1 2,2 .... 2,X

Y,1 Y,2 .... Y,X

3 7 9 2 7

9 8 3 5 5

1 7 9 8 5

3 8 6 4 10

6 3 9 7 8

int grid[5][5]={{3,7, 9, 2, 7},{9, 8, 3 ,5 ,5},{1, 7 ,9 ,8 ,5},{3, 8, 6 ,4 ,10},{6, 3 ,9 ,7 ,8}};

int memo[5][5]{{-1,-1,-1,-1,-1},{-1,-1,-1,-1,-1},{-1,-1,-1,-1,-1},{-1,-1,-1,-1,-1},{-1,-1,-1,-1,-1}};

std::vector<int>x_solution,y_solution;

int f_paths_in_grid(int y,int x)

{

if((x==0)&& (y==0))

{

memo[y][x]=grid[0][0];

}

else if (x==0)

{

if(memo[y][x]<0)

{

memo[y][x] =f_paths_in_grid(y-1,x) +grid[y][x];

}

else if(y==0)

{

if(memo[y][x]<0)

{

memo[y][x]=f_paths_in_grid(y,x-1) +grid[y][x];

}

else if(memo[y][x]<0)

{

memo[y][x]=std::max(f_paths_in_grid(y,x-1) ,f_paths_in_grid(y-1,x) )+grid[y][x];

}

return memo[y][x];

}

maximum sum on a path from the upper-left corner to the lower-right corner is:
67
3|10|19|21|28|
---------------
12|20|23|28|33|
---------------
13|27|36|44|49|
---------------
16|35|42|48|59|
---------------
22|38|51|58|67|
---------------

maximum sum on a path from the upper-left corner to the lower-right corner is:

3|10|19|21|28|

---------------

12|20|23|28|33|

---------------

13|27|36|44|49|

---------------

16|35|42|48|59|

---------------

22|38|51|58|67|

---------------

3)Levenshtein edit distance.

int LevenshteinDistance(std::string s, std::string t )
{
  int cost;

  /* base case: empty strings */
  if (s.length() == 0) return t.length();
  if (t.length() == 0) return s.length();

  /* test if last characters of the strings match */
  if (s.at(s.length()-1)  == t.at(t.length()-1) )
      cost = 0;
  else
      cost = 1;

  /* return minimum of delete char from s, delete char from t, and delete char from both */

  return std::min(   std::min(LevenshteinDistance(s.substr(0, s.size()-1 ),t ) + 1,LevenshteinDistance(s  , t.substr(0, t.size()-1 )) + 1 )    ,  LevenshteinDistance(s.substr(0, s.size()-1 ), t.substr(0, t.size()-1 )) + cost );
}

int LevenshteinDistance(std::string s, std::string t )

{

int cost;

/* base case: empty strings */

if (s.length() == 0) return t.length();

if (t.length() == 0) return s.length();

/* test if last characters of the strings match */

if (s.at(s.length()-1) == t.at(t.length()-1) )

cost = 0;

else

cost = 1;

/* return minimum of delete char from s, delete char from t, and delete char from both */

return std::min( std::min(LevenshteinDistance(s.substr(0, s.size()-1 ),t ) + 1,LevenshteinDistance(s , t.substr(0, t.size()-1 )) + 1 ) , LevenshteinDistance(s.substr(0, s.size()-1 ), t.substr(0, t.size()-1 )) + cost );

}

The Levenshtein distance between saturday and sunday is:
3

1 2	The Levenshtein distance between saturday and sunday is: 3

4)Seam Carving. I have written a tutorial on that

Examples of Dynamic Programming with C++ and Matlab 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 »

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 »

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.