Robotics with ROS

Mastering git, Part 2, Creating and managing repositories

Leave a Comment / Git, Tutorials / admin

Creating a bare repository

mkdir remote_repose1 remote_repose2
cd remote_repose1
git init --bare
cd ../remote_repose2
git init --bare

mkdir remote_repose1 remote_repose2

cd remote_repose1

git init --bare

cd ../remote_repose2

git init --bare

Creating a repositiy

mkdir repos1 repos2
cd repos1/
git init .

mkdir repos1 repos2

cd repos1/

git init .

Managing remotes You need to know how to handle your remote repositories in order to be able to work on any Git project. Remote repositories are copies of your project which are hosted elsewhere on the Internet or the network. You can have several of them, […]

Mastering git, Part 2, Creating and managing repositories Read More »

Mastering git, Part 1, setting up git environment, GUI, mergetool, difftool

Leave a Comment / Git, Tutorials / admin

Installing prerequisite

sudo apt-get install git-gui gitk meld kdiff3

1	sudo apt-get install git-gui gitk meld kdiff3

Configuring Git Environment First config your environment and set a proper merge/ diff tool. The settings in Linux are under/home/<username>/.gitconfig. If you don’t know where this file is located in your OS You can easily edit this file by:

git config --global -e

1	git config --global -e

All Git settings can be set or viewed via terminal, i.e:

git config --list --show-origin

1	git config --list --show-origin

Mastering git, Part 1, setting up git environment, GUI, mergetool, difftool 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 »

Rotation matrix, Quaternion, Axis angle, Euler angles and Rodrigues’ rotation explained

Leave a Comment / Manipulation, Tutorials / admin

Rotation matrix, Quaternion, Axis angle, Euler angles and Rodrigues’ rotation explained Read More »

How to find Essential and Fundamental Matrices

RGBD PCL point cloud from Stereo vision with ROS and OpenCV

Leave a Comment / Computer Vision, Image Processing, ROS, Tutorials / admin

In my other tutorial, I showed you how to calibrate you stereo camera. After Calibration, we can get disparity map and RGBD PCL point cloud from our stereo camera cool huh 🙂 1)Save the following text under “stereo_usb_cam_stream_publisher.launch”

<launch>

<arg name="video_device_right" default="/dev/video1" />
<arg name="video_device_left" default="/dev/video2" />

<arg name="image_width" default="640" />
<arg name="image_height" default="480" />

<arg name="right_image_namespace" default="stereo" />
<arg name="left_image_namespace" default="stereo" />

<arg name="right_image_node" default="right" />
<arg name="left_image_node" default="left" />

<arg name="image_topic_name_right" default="image_raw" />
<arg name="camera_info_topic_name_right" default="camera_info" />

<arg name="image_topic_name_left" default="image_raw" />
<arg name="camera_info_topic_name_left" default="camera_info" />



<arg name="left_camera_name" default="left" />
<arg name="right_camera_name" default="right" />

<arg name="left_camera_frame_id" default="left_camera" />
<arg name="right_camera_frame_id" default="right_camera" />

<arg name="framerate" default="30" />

<arg name="camera_info" default="false" />
<arg name="camera_info_path" default="stereo_camera_info" />
	  
<node ns="$(arg right_image_namespace)" name="$(arg right_image_node)" pkg="usb_cam" type="usb_cam_node" output="screen" >
	<param name="video_device" value="$(arg video_device_right)" />
	<param name="image_width" value="$(arg image_width)" />
	<param name="image_height" value="$(arg image_height)"/>
	<param name="pixel_format" value="yuyv" />
	<param name="io_method" value="mmap"/>
	<remap from="/usb_cam/image_raw" to="$(arg image_topic_name_right)" />
	<param name="framerate" value="$(arg framerate)"/> 
	<!-- if camera_info is available, we will use it-->
	<param name="camera_frame_id" value="$(arg right_camera_frame_id)" if="$(arg camera_info)" /> 
	<param name="camera_info_url" value="file://${ROS_HOME}/$(arg camera_info_path)/right.yaml" if="$(arg camera_info)"/>
	<param name="camera_name" value="narrow_stereo/$(arg right_camera_name)" if="$(arg camera_info)"/> 
	<remap from="/usb_cam/camera_info" to="$(arg camera_info_topic_name_right)" if="$(arg camera_info)"/>

</node>

<node ns="$(arg left_image_namespace)" name="$(arg left_image_node)" pkg="usb_cam" type="usb_cam_node" output="screen" >
	<param name="video_device" value="$(arg video_device_left)" />
	<param name="image_width" value="$(arg image_width)" />
	<param name="image_height" value="$(arg image_height)"/>
	<param name="pixel_format" value="yuyv" />
	<param name="io_method" value="mmap"/>
	<param name="framerate" value="$(arg framerate)"/> 
	<remap from="/usb_cam/image_raw" to="$(arg image_topic_name_left)"/>
	<!-- if camera_info is available, we will use it-->
	<param name="camera_frame_id" value="$(arg left_camera_frame_id)" if="$(arg camera_info)"/> 
	<param name="camera_name" value="narrow_stereo/$(arg left_camera_name)" if="$(arg camera_info)"/> 
	<param name="camera_info_url" value="file://${ROS_HOME}/$(arg camera_info_path)/left.yaml" if="$(arg camera_info)"/> 
	<remap from="/usb_cam/camera_info" to="$(arg camera_info_topic_name_left)" if="$(arg camera_info)"/>
</node>
</launch>

</node>

</node>

</launch>

2) Then run the following node to publish both cameras and camera info (calibration matrix)

roslaunch stereo_usb_cam_stream_publisher.launch video_device_right:=/dev/video1 video_device_left:=/dev/video2 image_width:=640 image_height:=480 left_camera_name:=left right_camera_name:=right camera_info:=true camera_info_path:=stereo_camera_info

1	roslaunch stereo_usb_cam_stream_publisher.launch video_device_right:=/dev/video1 video_device_left:=/dev/video2 image_width:=640 image_height:=480 left_camera_name:=left right_camera_name:=right camera_info:=true camera_info_path:=stereo_camera_info

3) Run the

RGBD PCL point cloud from Stereo vision with ROS and OpenCV Read More »

Stereo Camera Calibration with ROS and OpenCV

5 Comments / Computer Vision, Image Processing, ROS, Tutorials / admin

In this tutorial, I’m gonna show you stereo camera calibration with ROS and OpenCV. So you need a pair of cameras, I bought a pair of this USB webcam which is okay for this task. 1)Save the following text under “stereo_usb_cam_stream_publisher.launch”

<launch>

<arg name="video_device_right" default="/dev/video1" />
<arg name="video_device_left" default="/dev/video2" />

<arg name="image_width" default="640" />
<arg name="image_height" default="480" />

<arg name="right_image_namespace" default="stereo" />
<arg name="left_image_namespace" default="stereo" />

<arg name="right_image_node" default="right" />
<arg name="left_image_node" default="left" />

<arg name="image_topic_name_right" default="image_raw" />
<arg name="camera_info_topic_name_right" default="camera_info" />

<arg name="image_topic_name_left" default="image_raw" />
<arg name="camera_info_topic_name_left" default="camera_info" />



<arg name="left_camera_name" default="left" />
<arg name="right_camera_name" default="right" />

<arg name="left_camera_frame_id" default="left_camera" />
<arg name="right_camera_frame_id" default="right_camera" />

<arg name="framerate" default="30" />

<arg name="camera_info" default="false" />
<arg name="camera_info_path" default="stereo_camera_info" />
	  
<node ns="$(arg right_image_namespace)" name="$(arg right_image_node)" pkg="usb_cam" type="usb_cam_node" output="screen" >
	<param name="video_device" value="$(arg video_device_right)" />
	<param name="image_width" value="$(arg image_width)" />
	<param name="image_height" value="$(arg image_height)"/>
	<param name="pixel_format" value="yuyv" />
	<param name="io_method" value="mmap"/>
	<remap from="/usb_cam/image_raw" to="$(arg image_topic_name_right)" />
	<param name="framerate" value="$(arg framerate)"/> 
	<!-- if camera_info is available, we will use it-->
	<param name="camera_frame_id" value="$(arg right_camera_frame_id)" if="$(arg camera_info)" /> 
	<param name="camera_info_url" value="file://${ROS_HOME}/$(arg camera_info_path)/right.yaml" if="$(arg camera_info)"/>
	<param name="camera_name" value="narrow_stereo/$(arg right_camera_name)" if="$(arg camera_info)"/> 
	<remap from="/usb_cam/camera_info" to="$(arg camera_info_topic_name_right)" if="$(arg camera_info)"/>

</node>

<node ns="$(arg left_image_namespace)" name="$(arg left_image_node)" pkg="usb_cam" type="usb_cam_node" output="screen" >
	<param name="video_device" value="$(arg video_device_left)" />
	<param name="image_width" value="$(arg image_width)" />
	<param name="image_height" value="$(arg image_height)"/>
	<param name="pixel_format" value="yuyv" />
	<param name="io_method" value="mmap"/>
	<param name="framerate" value="$(arg framerate)"/> 
	<remap from="/usb_cam/image_raw" to="$(arg image_topic_name_left)"/>
	<!-- if camera_info is available, we will use it-->
	<param name="camera_frame_id" value="$(arg left_camera_frame_id)" if="$(arg camera_info)"/> 
	<param name="camera_name" value="narrow_stereo/$(arg left_camera_name)" if="$(arg camera_info)"/> 
	<param name="camera_info_url" value="file://${ROS_HOME}/$(arg camera_info_path)/left.yaml" if="$(arg camera_info)"/> 
	<remap from="/usb_cam/camera_info" to="$(arg camera_info_topic_name_left)" if="$(arg camera_info)"/>
</node>
</launch>

</node>

</node>

</launch>

2)Then run the following node to publish both cameras.

roslaunch stereo_usb_cam_stream_publisher.launch video_device_right:=/dev/video1 video_device_left:=/dev/video2 image_width:=640 image_height:=480 left_camera_name:=left right_camera_name:=right

1	roslaunch stereo_usb_cam_stream_publisher.launch video_device_right:=/dev/video1 video_device_left:=/dev/video2 image_width:=640 image_height:=480 left_camera_name:=left right_camera_name:=right

3)Now call the calibration node:

Stereo Camera Calibration with ROS and OpenCV 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 »

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.