Tag Archives: C++

Finding Memory leaking, Stack and Heap overflow

When you access an array index, C and C++ don’t do bound checking. Segmentation faults only happen when you try to read or write to a page that was not allocated (or try to do something on a page which isn’t permitted, e.g. trying to write to a read-only page), but since pages are usually pretty big (multiples of a few kilobytes), it often leaves you with lots of room to overflow.

If your array is on the stack, it can be even worse as the stack is usually pretty large (up to several megabytes). This is also the cause of security concerns: writing past the bounds of an array on the stack may overwrite the return address of the function
and lead to arbitrary code execution (the famous “buffer overflow” security breaches).

By setting the following flags you can find the issue:

set(CMAKE_CXX_FLAGS "-fsanitize=address ${CMAKE_CXX_FLAGS}")
set(CMAKE_CXX_FLAGS "-fno-omit-frame-pointer ${CMAKE_CXX_FLAGS}")

1 2	set(CMAKE_CXX_FLAGS "-fsanitize=address ${CMAKE_CXX_FLAGS}") set(CMAKE_CXX_FLAGS "-fno-omit-frame-pointer ${CMAKE_CXX_FLAGS}")

Example:

void heapBufferOverflow()
{
    int *x=new int[3];
    for(int i=0;i<100000000;i++)
    {
        std::cout<<"i is: "<<i <<std::endl;
        std::cout<< x[i] <<std::endl;
    }
}

void stackBufferOverflow()
{
    char x[2];
    for(int i=0;i<100000000;i++)
    {
        std::cout<<"i is: "<<i <<std::endl;
        std::cout<< x[i] <<std::endl;
    }
}

void heapBufferOverflow()

{

int *x=new int[3];

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

{

std::cout<<"i is: "<<i <<std::endl;

std::cout<< x[i] <<std::endl;

}

void stackBufferOverflow()

{

char x[2];

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

{

std::cout<<"i is: "<<i <<std::endl;

std::cout<< x[i] <<std::endl;

}

References: [1]

Kalman Filter Explained With Python Code From Scratch

3 Replies

This snippet shows tracking mouse cursor with Python code from scratch and comparing the result with OpenCV. The CSV file that has been used are being created with below c++ code. A sample could be downloaded from here 1, 2, 3.

Python Kalman Filter

import numpy as np
np.set_printoptions(threshold=3)
np.set_printoptions(suppress=True)
from numpy import genfromtxt


#Notation used coming from: https://www.bzarg.com/p/how-a-kalman-filter-works-in-pictures/


def prediction(X_hat_t_1,P_t_1,F_t,B_t,U_t,Q_t):
    X_hat_t=F_t.dot(X_hat_t_1)+(B_t.dot(U_t).reshape(B_t.shape[0],-1) )
    P_t=np.diag(np.diag(F_t.dot(P_t_1).dot(F_t.transpose())))+Q_t
    return X_hat_t,P_t
    

def update(X_hat_t,P_t,Z_t,R_t,H_t):
    
    K_prime=P_t.dot(H_t.transpose()).dot( np.linalg.inv ( H_t.dot(P_t).dot(H_t.transpose()) +R_t ) )  
    print("K:\n",K_prime)
    
    X_t=X_hat_t+K_prime.dot(Z_t-H_t.dot(X_hat_t))
    P_t=P_t-K_prime.dot(H_t).dot(P_t)
    
    return X_t,P_t


acceleration=0
delta_t=1/20#milisecond

groundTruth = genfromtxt('data/groundTruth.csv', delimiter=',',skip_header=1)

#Observations: position_X, position_Y
measurmens = genfromtxt('data/measurmens.csv', delimiter=',',skip_header=1)


#Checking our result with OpenCV
opencvKalmanOutput = genfromtxt('data/kalmanv.csv', delimiter=',',skip_header=1)

#Transition matrix
F_t=np.array([ [1 ,0,delta_t,0] , [0,1,0,delta_t] , [0,0,1,0] , [0,0,0,1] ])

#Initial State cov
P_t= np.identity(4)*0.2

#Process cov
Q_t= np.identity(4)

#Control matrix
B_t=np.array( [ [0] , [0], [0] , [0] ])

#Control vector
U_t=acceleration

#Measurment Matrix
H_t = np.array([ [1, 0, 0, 0], [ 0, 1, 0, 0]])

#Measurment cov
R_t= np.identity(2)*5

# Initial State
X_hat_t = np.array( [[0],[0],[0],[0]] )
print("X_hat_t",X_hat_t.shape)
print("P_t",P_t.shape)
print("F_t",F_t.shape)
print("B_t",B_t.shape)
print("Q_t",Q_t.shape)
print("R_t",R_t.shape)
print("H_t",H_t.shape)

for i in range(measurmens.shape[0]):
    X_hat_t,P_hat_t = prediction(X_hat_t,P_t,F_t,B_t,U_t,Q_t)
    print("Prediction:")
    print("X_hat_t:\n",X_hat_t,"\nP_t:\n",P_t)
    
    Z_t=measurmens[i].transpose()
    Z_t=Z_t.reshape(Z_t.shape[0],-1)
    
    print(Z_t.shape)
    
    X_t,P_t=update(X_hat_t,P_hat_t,Z_t,R_t,H_t)
    print("Update:")
    print("X_t:\n",X_t,"\nP_t:\n",P_t)
    X_hat_t=X_t
    P_hat_t=P_t
    
    print("=========================================")
    print("Opencv Kalman Output:")
    print("X_t:\n",opencvKalmanOutput[i])

import numpy as np

np.set_printoptions(threshold=3)

np.set_printoptions(suppress=True)

from numpy import genfromtxt

#Notation used coming from: https://www.bzarg.com/p/how-a-kalman-filter-works-in-pictures/

def prediction(X_hat_t_1,P_t_1,F_t,B_t,U_t,Q_t):

X_hat_t=F_t.dot(X_hat_t_1)+(B_t.dot(U_t).reshape(B_t.shape[0],-1) )

P_t=np.diag(np.diag(F_t.dot(P_t_1).dot(F_t.transpose())))+Q_t

return X_hat_t,P_t

def update(X_hat_t,P_t,Z_t,R_t,H_t):

K_prime=P_t.dot(H_t.transpose()).dot( np.linalg.inv ( H_t.dot(P_t).dot(H_t.transpose()) +R_t ) )

print("K:\n",K_prime)

X_t=X_hat_t+K_prime.dot(Z_t-H_t.dot(X_hat_t))

P_t=P_t-K_prime.dot(H_t).dot(P_t)

return X_t,P_t

acceleration=0

delta_t=1/20#milisecond

groundTruth = genfromtxt('data/groundTruth.csv', delimiter=',',skip_header=1)

#Observations: position_X, position_Y

measurmens = genfromtxt('data/measurmens.csv', delimiter=',',skip_header=1)

#Checking our result with OpenCV

opencvKalmanOutput = genfromtxt('data/kalmanv.csv', delimiter=',',skip_header=1)

#Transition matrix

F_t=np.array([ [1 ,0,delta_t,0] , [0,1,0,delta_t] , [0,0,1,0] , [0,0,0,1] ])

#Initial State cov

P_t= np.identity(4)*0.2

#Process cov

Q_t= np.identity(4)

#Control matrix

B_t=np.array( [ [0] , [0], [0] , [0] ])

#Control vector

U_t=acceleration

#Measurment Matrix

H_t = np.array([ [1, 0, 0, 0], [ 0, 1, 0, 0]])

#Measurment cov

R_t= np.identity(2)*5

# Initial State

X_hat_t = np.array( [[0],[0],[0],[0]] )

print("X_hat_t",X_hat_t.shape)

print("P_t",P_t.shape)

print("F_t",F_t.shape)

print("B_t",B_t.shape)

print("Q_t",Q_t.shape)

print("R_t",R_t.shape)

print("H_t",H_t.shape)

for i in range(measurmens.shape[0]):

X_hat_t,P_hat_t = prediction(X_hat_t,P_t,F_t,B_t,U_t,Q_t)

print("Prediction:")

print("X_hat_t:\n",X_hat_t,"\nP_t:\n",P_t)

Z_t=measurmens[i].transpose()

Z_t=Z_t.reshape(Z_t.shape[0],-1)

print(Z_t.shape)

X_t,P_t=update(X_hat_t,P_hat_t,Z_t,R_t,H_t)

print("Update:")

print("X_t:\n",X_t,"\nP_t:\n",P_t)

X_hat_t=X_t

P_hat_t=P_t

print("=========================================")

print("Opencv Kalman Output:")

print("X_t:\n",opencvKalmanOutput[i])

C++ and OpenCV Kalman Filter

Rapidcsv has been downloaded from here

//http://www.morethantechnical.com/2011/06/17/simple-kalman-filter-for-tracking-using-opencv-2-2-w-code/
#include <iostream>
#include <vector>
#include <random>
#include <ctime>
#include <chrono>
#include <iomanip>

#include <Eigen/Dense>
#include <boost/random/mersenne_twister.hpp>
#include <boost/random/normal_distribution.hpp>

#include <opencv2/highgui/highgui.hpp>
#include <opencv2/video/tracking.hpp>
#include "rapidcsv.h"

namespace Eigen
{
    namespace internal
    {
        template<typename Scalar>
        struct scalar_normal_dist_op
        {
            static boost::mt19937 rng;    // The uniform pseudo-random algorithm
            mutable boost::normal_distribution<Scalar> norm;  // The gaussian combinator

            EIGEN_EMPTY_STRUCT_CTOR(scalar_normal_dist_op)

            template<typename Index>
            inline const Scalar operator() (Index, Index = 0) const { return norm(rng); }
        };

        template<typename Scalar> boost::mt19937 scalar_normal_dist_op<Scalar>::rng;

        template<typename Scalar>
        struct functor_traits<scalar_normal_dist_op<Scalar> >
        { enum
            { Cost = 50 * NumTraits<Scalar>::MulCost, PacketAccess = false, IsRepeatable = false };
        };
    }
}

template<typename Clock, typename Duration>
std::ostream &operator<<(std::ostream &stream,  const std::chrono::time_point<Clock, Duration> &time_point)
{
    const time_t time = Clock::to_time_t(time_point);
    struct tm tm;
    localtime_r(&time, &tm);
    return stream << std::put_time(&tm, "%c"); // Print standard date&time

}

auto start = std::chrono::high_resolution_clock::now();
int k=5;

Eigen::MatrixXd multivariateNormalDistribution()
{
    int size = 2; // Dimensionality (rows)
    int nn=1;     // How many samples (columns) to draw
    Eigen::internal::scalar_normal_dist_op<double> randN; // Gaussian functor
    //Eigen::internal::scalar_normal_dist_op<double>::rng.seed(1);
    auto elapsed = std::chrono::high_resolution_clock::now() - start;
    auto microseconds = std::chrono::duration_cast<std::chrono::microseconds>(elapsed).count();
    //std::cout<<"microseconds:" <<microseconds <<std::endl;
    Eigen::internal::scalar_normal_dist_op<double>::rng.seed(microseconds);
    Eigen::VectorXd mean(size);
    Eigen::MatrixXd covar(size,size);

    mean  <<  0,  0;
    covar <<  k*1e-0, 0,
       0,  k*1e-0;

    Eigen::MatrixXd normTransform(size,size);
    Eigen::LLT<Eigen::MatrixXd> cholSolver(covar);

    // We can only use the cholesky decomposition if
    // the covariance matrix is symmetric, pos-definite.
    // But a covariance matrix might be pos-semi-definite.
    // In that case, we'll go to an EigenSolver
    if (cholSolver.info()==Eigen::Success)
    {
    // Use cholesky solver
        normTransform = cholSolver.matrixL();
    }
    else
    {
        // Use eigen solver
        Eigen::SelfAdjointEigenSolver<Eigen::MatrixXd> eigenSolver(covar);
        normTransform = eigenSolver.eigenvectors() * eigenSolver.eigenvalues().cwiseSqrt().asDiagonal();
    }

    Eigen::MatrixXd samples = (normTransform * Eigen::MatrixXd::NullaryExpr(size,nn,randN)).colwise() + mean;
//    std::cout << "Mean\n" << mean << std::endl;
//    std::cout << "Covar\n" << covar << std::endl;
//    std::cout << "Samples\n" << samples << std::endl;
    return samples;
}

struct mouse_info_struct { int x,y; };
struct mouse_info_struct mouse_info = {-1,-1}, last_mouse;

std::vector<cv::Point> groundTruth,kalmanv,measurmens;

void on_mouse(int event, int x, int y, int flags, void* param) {
	{
		last_mouse = mouse_info;
		mouse_info.x = x;
		mouse_info.y = y;
	}
}

// plot points
#define drawCross( center, color, d )                                 \
cv::line( img, cv::Point( center.x - d, center.y - d ),                \
cv::Point( center.x + d, center.y + d ), color, 2, CV_AA, 0); \
cv::line( img, cv::Point( center.x + d, center.y - d ),                \
cv::Point( center.x - d, center.y + d ), color, 2, CV_AA, 0 )


int main (int argc, char * const argv[]) {
    cv::Mat img(500, 500, CV_8UC3);
    cv::KalmanFilter KF(4, 2, 0);
    cv::Mat_<float> state(4, 1); /* (x, y, Vx, Vy) */
    cv::Mat processNoise(4, 1, CV_32F);
    cv::Mat_<float> measurement(2,1); measurement.setTo(cv::Scalar(0));
    char code = char(-1);
	
    cv::namedWindow("Mouse Tracking with Kalman Filter");
    cv::setMouseCallback("Mouse Tracking with Kalman Filter", on_mouse, nullptr);
    double delta_t=1/20.0;
	
    for(;;)
    {
		if (mouse_info.x < 0 || mouse_info.y < 0) {
            imshow("Mouse Tracking with Kalman Filter", img);
            cv::waitKey(30);
			continue;
		}
        cv::Mat transitionMatrix=(cv::Mat_<float>(4, 4) << 1,0,delta_t,0,   0,1,0,delta_t,  0,0,1,0,  0,0,0,1);
        KF.transitionMatrix = transitionMatrix;
		
        setIdentity(KF.measurementMatrix);
        cv::setIdentity(KF.processNoiseCov, cv::Scalar::all(1e-0));
        cv::setIdentity(KF.measurementNoiseCov, cv::Scalar::all(k*1e-0));
        cv::setIdentity(KF.errorCovPost, cv::Scalar::all(.2));
        cv::setIdentity(KF.errorCovPre,cv::Scalar::all(.1));

        measurmens.clear();
        groundTruth.clear();
		kalmanv.clear();
        std::cout<< "measurementMatrix"<<std::endl;
        std::cout<<KF.measurementMatrix<<std::endl;
		
        for(;;)
        {
            std::cout<< "processNoiseCov"<<std::endl;
            std::cout<< KF.processNoiseCov<<std::endl;

            std::cout<< "measurementNoiseCov"<<std::endl;
            std::cout<< KF.measurementNoiseCov<<std::endl;

            std::cout<<"State Prior (before calling predict function):" <<std::endl;
            std::cout<<KF.statePre <<std::endl;

            std::cout<<"Cov Prior (before calling predict function):" <<std::endl;
            std::cout<<KF.errorCovPre <<std::endl;

            std::cout<<"Cov Posterior (before calling predict function):" <<std::endl;
            std::cout<<KF.errorCovPost <<std::endl;

            //KF.controlMatrix
            std::cout<<"My State Prediction:" <<std::endl;
            std::cout<<KF.transitionMatrix*KF.statePost<<std::endl;
            std::cout<<"My Cov Prediction:" <<std::endl;
            std::cout<<KF.transitionMatrix*KF.errorCovPost*KF.transitionMatrix.t()+KF.processNoiseCov<<std::endl;

            cv::Mat prediction = KF.predict();
            cv::Point predictPt(prediction.at<float>(0),prediction.at<float>(1));

            std::cout<<"OpenCV Prediction:" <<std::endl;

            std::cout<<"State Prior:" <<std::endl;
            std::cout<<KF.statePre <<std::endl;

            std::cout<<"OpenCV Cov Prior:" <<std::endl;
            std::cout<<KF.errorCovPre <<std::endl;


            measurement(0) = mouse_info.x+multivariateNormalDistribution()(0,0);
            measurement(1) = mouse_info.y+multivariateNormalDistribution()(1,0);

            cv::Point groundtruth(mouse_info.x,mouse_info.y);
            groundTruth.push_back(groundtruth);


            std::cout<<"Ground Truth:" <<std::endl;
            std::cout<< mouse_info.x<<" , "<<mouse_info.y <<std::endl;

            cv::Point measPt(measurement(0),measurement(1));
            measurmens.push_back(measPt);


            cv::Mat estimated = KF.correct(measurement);
            cv::Point statePt(estimated.at<float>(0),estimated.at<float>(1));
			kalmanv.push_back(statePt);

            std::cout<<"My State Posterior:" <<std::endl;
            std::cout<<KF.statePre+KF.gain*(measurement-KF.measurementMatrix*KF.statePre) <<std::endl;

            std::cout<<"My Cov Posterior:" <<std::endl;
            std::cout<<(cv::Mat::eye(4,4, CV_32F) - KF.gain*KF.measurementMatrix)*KF.errorCovPre <<std::endl;

            std::cout<<"Opencv State Posterior:" <<std::endl;
            std::cout<<KF.statePost <<std::endl;

            std::cout<<"Opencv Cov Posterior:" <<std::endl;
            std::cout<<KF.errorCovPost <<std::endl;

            std::cout<<"-----------------------------------------------" <<std::endl;
            multivariateNormalDistribution();

            img = cv::Scalar::all(0);
            drawCross( statePt, cv::Scalar(255,255,255), 5 );
            drawCross( measPt, cv::Scalar(0,0,255), 5 );
            for (std::size_t i = 0; i < groundTruth.size()-1; i++)
            {
                line(img, groundTruth[i], groundTruth[i+1], cv::Scalar(0,255,0), 1);
			}
            for (std::size_t i = 0; i < kalmanv.size()-1; i++)
            {
                line(img, kalmanv[i], kalmanv[i+1], cv::Scalar(255,0,0), 1);
			}
            for (std::size_t i = 0; i < measurmens.size()-1; i++)
            {
                line(img, measurmens[i], measurmens[i+1], cv::Scalar(0,255,255), 1);
            }
            cv::putText(img,"Noisy Measurements",cv::Point(10,10),cv::FONT_HERSHEY_PLAIN,1,cv::Scalar(0,255,255) 	);
            cv::putText(img,"Real Mouse Position(ground truth)",cv::Point(10,25),cv::FONT_HERSHEY_PLAIN,1,cv::Scalar(0,255,0));
            cv::putText(img,"Kalman Sate",cv::Point(10,35),cv::FONT_HERSHEY_PLAIN,1,cv::Scalar(255,0,0));


            imshow( "Mouse Tracking with Kalman Filter", img );
            code = char(cv::waitKey(1000.0*delta_t));
			
            if( code > 0 )
                break;
        }
        if( code == 27 || code == 'q' || code == 'Q' )
            break;
    }


    std::ofstream groundTruthfile("groundTruth.csv",std::ofstream::ate );
    groundTruthfile<<"x,y"<<std::endl;
    for (std::size_t i = 0; i < groundTruth.size(); i++)
    {
        groundTruthfile<<groundTruth[i].x << ","<<groundTruth[i].y <<std::endl;
    }
    groundTruthfile.close();




    std::ofstream kalmanvfile("kalmanv.csv",std::ofstream::ate );
    kalmanvfile<<"x,y"<<std::endl;
    for (std::size_t i = 0; i < kalmanv.size()-1; i++)
    {
        kalmanvfile<<kalmanv[i].x << ","<<kalmanv[i].y <<std::endl;
    }
    kalmanvfile.close();

    std::ofstream measurmensfile("measurmens.csv",std::ofstream::ate );
    measurmensfile<<"x,y"<<std::endl;
    for (std::size_t i = 0; i < kalmanv.size()-1; i++)
    {
        measurmensfile<<measurmens[i].x << ","<<measurmens[i].y <<std::endl;
    }
    measurmensfile.close();

    std::cout<<"~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~" <<std::endl;

    return 0;
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

252

253

254

255

256

257

258

259

260

261

262

263

264

265

266

267

268

269

270

271

272

273

274

275

276

277

278

279

280

281

282

283

//http://www.morethantechnical.com/2011/06/17/simple-kalman-filter-for-tracking-using-opencv-2-2-w-code/

#include <iostream>

#include <vector>

#include <random>

#include <ctime>

#include <chrono>

#include <iomanip>

#include <Eigen/Dense>

#include <boost/random/mersenne_twister.hpp>

#include <boost/random/normal_distribution.hpp>

#include <opencv2/highgui/highgui.hpp>

#include <opencv2/video/tracking.hpp>

#include "rapidcsv.h"

namespace Eigen

{

namespace internal

{

template<typename Scalar>

struct scalar_normal_dist_op

{

static boost::mt19937 rng; // The uniform pseudo-random algorithm

mutable boost::normal_distribution<Scalar> norm; // The gaussian combinator

EIGEN_EMPTY_STRUCT_CTOR(scalar_normal_dist_op)

template<typename Index>

inline const Scalar operator() (Index, Index = 0) const { return norm(rng); }

};

template<typename Scalar> boost::mt19937 scalar_normal_dist_op<Scalar>::rng;

template<typename Scalar>

struct functor_traits<scalar_normal_dist_op<Scalar> >

{ enum

{ Cost = 50 * NumTraits<Scalar>::MulCost, PacketAccess = false, IsRepeatable = false };

};

}

template<typename Clock, typename Duration>

std::ostream &operator<<(std::ostream &stream, const std::chrono::time_point<Clock, Duration> &time_point)

{

const time_t time = Clock::to_time_t(time_point);

struct tm tm;

localtime_r(&time, &tm);

return stream << std::put_time(&tm, "%c"); // Print standard date&time

}

auto start = std::chrono::high_resolution_clock::now();

int k=5;

Eigen::MatrixXd multivariateNormalDistribution()

{

int size = 2; // Dimensionality (rows)

int nn=1; // How many samples (columns) to draw

Eigen::internal::scalar_normal_dist_op<double> randN; // Gaussian functor

//Eigen::internal::scalar_normal_dist_op<double>::rng.seed(1);

auto elapsed = std::chrono::high_resolution_clock::now() - start;

auto microseconds = std::chrono::duration_cast<std::chrono::microseconds>(elapsed).count();

//std::cout<<"microseconds:" <<microseconds <<std::endl;

Eigen::internal::scalar_normal_dist_op<double>::rng.seed(microseconds);

Eigen::VectorXd mean(size);

Eigen::MatrixXd covar(size,size);

mean << 0, 0;

covar << k*1e-0, 0,

0, k*1e-0;

Eigen::MatrixXd normTransform(size,size);

Eigen::LLT<Eigen::MatrixXd> cholSolver(covar);

// We can only use the cholesky decomposition if

// the covariance matrix is symmetric, pos-definite.

// But a covariance matrix might be pos-semi-definite.

// In that case, we'll go to an EigenSolver

if (cholSolver.info()==Eigen::Success)

{

// Use cholesky solver

normTransform = cholSolver.matrixL();

}

else

{

// Use eigen solver

Eigen::SelfAdjointEigenSolver<Eigen::MatrixXd> eigenSolver(covar);

normTransform = eigenSolver.eigenvectors() * eigenSolver.eigenvalues().cwiseSqrt().asDiagonal();

}

Eigen::MatrixXd samples = (normTransform * Eigen::MatrixXd::NullaryExpr(size,nn,randN)).colwise() + mean;

// std::cout << "Mean\n" << mean << std::endl;

// std::cout << "Covar\n" << covar << std::endl;

// std::cout << "Samples\n" << samples << std::endl;

return samples;

}

struct mouse_info_struct { int x,y; };

struct mouse_info_struct mouse_info = {-1,-1}, last_mouse;

std::vector<cv::Point> groundTruth,kalmanv,measurmens;

void on_mouse(int event, int x, int y, int flags, void* param) {

{

last_mouse = mouse_info;

mouse_info.x = x;

mouse_info.y = y;

}

// plot points

#define drawCross( center, color, d ) \

cv::line( img, cv::Point( center.x - d, center.y - d ), \

cv::Point( center.x + d, center.y + d ), color, 2, CV_AA, 0); \

cv::line( img, cv::Point( center.x + d, center.y - d ), \

cv::Point( center.x - d, center.y + d ), color, 2, CV_AA, 0 )

int main (int argc, char * const argv[]) {

cv::Mat img(500, 500, CV_8UC3);

cv::KalmanFilter KF(4, 2, 0);

cv::Mat_<float> state(4, 1); /* (x, y, Vx, Vy) */

cv::Mat processNoise(4, 1, CV_32F);

cv::Mat_<float> measurement(2,1); measurement.setTo(cv::Scalar(0));

char code = char(-1);

cv::namedWindow("Mouse Tracking with Kalman Filter");

cv::setMouseCallback("Mouse Tracking with Kalman Filter", on_mouse, nullptr);

double delta_t=1/20.0;

for(;;)

{

if (mouse_info.x < 0 || mouse_info.y < 0) {

imshow("Mouse Tracking with Kalman Filter", img);

cv::waitKey(30);

continue;

}

cv::Mat transitionMatrix=(cv::Mat_<float>(4, 4) << 1,0,delta_t,0, 0,1,0,delta_t, 0,0,1,0, 0,0,0,1);

KF.transitionMatrix = transitionMatrix;

setIdentity(KF.measurementMatrix);

cv::setIdentity(KF.processNoiseCov, cv::Scalar::all(1e-0));

cv::setIdentity(KF.measurementNoiseCov, cv::Scalar::all(k*1e-0));

cv::setIdentity(KF.errorCovPost, cv::Scalar::all(.2));

cv::setIdentity(KF.errorCovPre,cv::Scalar::all(.1));

measurmens.clear();

groundTruth.clear();

kalmanv.clear();

std::cout<< "measurementMatrix"<<std::endl;

std::cout<<KF.measurementMatrix<<std::endl;

for(;;)

{

std::cout<< "processNoiseCov"<<std::endl;

std::cout<< KF.processNoiseCov<<std::endl;

std::cout<< "measurementNoiseCov"<<std::endl;

std::cout<< KF.measurementNoiseCov<<std::endl;

std::cout<<"State Prior (before calling predict function):" <<std::endl;

std::cout<<KF.statePre <<std::endl;

std::cout<<"Cov Prior (before calling predict function):" <<std::endl;

std::cout<<KF.errorCovPre <<std::endl;

std::cout<<"Cov Posterior (before calling predict function):" <<std::endl;

std::cout<<KF.errorCovPost <<std::endl;

//KF.controlMatrix

std::cout<<"My State Prediction:" <<std::endl;

std::cout<<KF.transitionMatrix*KF.statePost<<std::endl;

std::cout<<"My Cov Prediction:" <<std::endl;

std::cout<<KF.transitionMatrix*KF.errorCovPost*KF.transitionMatrix.t()+KF.processNoiseCov<<std::endl;

cv::Mat prediction = KF.predict();

cv::Point predictPt(prediction.at<float>(0),prediction.at<float>(1));

std::cout<<"OpenCV Prediction:" <<std::endl;

std::cout<<"State Prior:" <<std::endl;

std::cout<<KF.statePre <<std::endl;

std::cout<<"OpenCV Cov Prior:" <<std::endl;

std::cout<<KF.errorCovPre <<std::endl;

measurement(0) = mouse_info.x+multivariateNormalDistribution()(0,0);

measurement(1) = mouse_info.y+multivariateNormalDistribution()(1,0);

cv::Point groundtruth(mouse_info.x,mouse_info.y);

groundTruth.push_back(groundtruth);

std::cout<<"Ground Truth:" <<std::endl;

std::cout<< mouse_info.x<<" , "<<mouse_info.y <<std::endl;

cv::Point measPt(measurement(0),measurement(1));

measurmens.push_back(measPt);

cv::Mat estimated = KF.correct(measurement);

cv::Point statePt(estimated.at<float>(0),estimated.at<float>(1));

kalmanv.push_back(statePt);

std::cout<<"My State Posterior:" <<std::endl;

std::cout<<KF.statePre+KF.gain*(measurement-KF.measurementMatrix*KF.statePre) <<std::endl;

std::cout<<"My Cov Posterior:" <<std::endl;

std::cout<<(cv::Mat::eye(4,4, CV_32F) - KF.gain*KF.measurementMatrix)*KF.errorCovPre <<std::endl;

std::cout<<"Opencv State Posterior:" <<std::endl;

std::cout<<KF.statePost <<std::endl;

std::cout<<"Opencv Cov Posterior:" <<std::endl;

std::cout<<KF.errorCovPost <<std::endl;

std::cout<<"-----------------------------------------------" <<std::endl;

multivariateNormalDistribution();

img = cv::Scalar::all(0);

drawCross( statePt, cv::Scalar(255,255,255), 5 );

drawCross( measPt, cv::Scalar(0,0,255), 5 );

for (std::size_t i = 0; i < groundTruth.size()-1; i++)

{

line(img, groundTruth[i], groundTruth[i+1], cv::Scalar(0,255,0), 1);

}

for (std::size_t i = 0; i < kalmanv.size()-1; i++)

{

line(img, kalmanv[i], kalmanv[i+1], cv::Scalar(255,0,0), 1);

}

for (std::size_t i = 0; i < measurmens.size()-1; i++)

{

line(img, measurmens[i], measurmens[i+1], cv::Scalar(0,255,255), 1);

}

cv::putText(img,"Noisy Measurements",cv::Point(10,10),cv::FONT_HERSHEY_PLAIN,1,cv::Scalar(0,255,255) );

cv::putText(img,"Real Mouse Position(ground truth)",cv::Point(10,25),cv::FONT_HERSHEY_PLAIN,1,cv::Scalar(0,255,0));

cv::putText(img,"Kalman Sate",cv::Point(10,35),cv::FONT_HERSHEY_PLAIN,1,cv::Scalar(255,0,0));

imshow( "Mouse Tracking with Kalman Filter", img );

code = char(cv::waitKey(1000.0*delta_t));

if( code > 0 )

break;

}

if( code == 27 || code == 'q' || code == 'Q' )

break;

}

std::ofstream groundTruthfile("groundTruth.csv",std::ofstream::ate );

groundTruthfile<<"x,y"<<std::endl;

for (std::size_t i = 0; i < groundTruth.size(); i++)

{

groundTruthfile<<groundTruth[i].x << ","<<groundTruth[i].y <<std::endl;

}

groundTruthfile.close();

std::ofstream kalmanvfile("kalmanv.csv",std::ofstream::ate );

kalmanvfile<<"x,y"<<std::endl;

for (std::size_t i = 0; i < kalmanv.size()-1; i++)

{

kalmanvfile<<kalmanv[i].x << ","<<kalmanv[i].y <<std::endl;

}

kalmanvfile.close();

std::ofstream measurmensfile("measurmens.csv",std::ofstream::ate );

measurmensfile<<"x,y"<<std::endl;

for (std::size_t i = 0; i < kalmanv.size()-1; i++)

{

measurmensfile<<measurmens[i].x << ","<<measurmens[i].y <<std::endl;

}

measurmensfile.close();

std::cout<<"~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~" <<std::endl;

return 0;

}

Eigen Memory Mapping

Leave a reply

struct point {
    double a;
    double b;
};

void EigenMapExample()
{
    ////////////////////////////////////////First Example/////////////////////////////////////////
    Eigen::VectorXd solutionVec(12,1);
    solutionVec<<1,2,3,4,5,6,7,8,9,10,11,12;
    Eigen::Map<Eigen::MatrixXd> solutionColMajor(solutionVec.data(),4,3);

    Eigen::Map<Eigen::Matrix<double, 3, 4, Eigen::RowMajor> >solutionRowMajor (solutionVec.data());


    std::cout << "solutionColMajor: "<< std::endl;
    std::cout << solutionColMajor<< std::endl;

    std::cout << "solutionRowMajor"<< std::endl;
    std::cout << solutionRowMajor<< std::endl;

    ////////////////////////////////////////Second Example/////////////////////////////////////////

    // https://stackoverflow.com/questions/49813340/stdvectoreigenvector3d-to-eigenmatrixxd-eigen

    int array[9];
    for (int i = 0; i < 9; ++i) {
        array[i] = i;
    }

    Eigen::MatrixXi a(9, 1);
    a = Eigen::Map<Eigen::Matrix3i>(array);
    std::cout << a << std::endl;

    std::vector<point> pointsVec;
    point point1, point2, point3;

    point1.a = 1.0;
    point1.b = 1.5;

    point2.a = 2.4;
    point2.b = 3.5;

    point3.a = -1.3;
    point3.b = 2.4;

    pointsVec.push_back(point1);
    pointsVec.push_back(point2);
    pointsVec.push_back(point3);

    Eigen::Matrix2Xd pointsMatrix2d = Eigen::Map<Eigen::Matrix2Xd>(
        reinterpret_cast<double*>(pointsVec.data()), 2,  long(pointsVec.size()));

    Eigen::MatrixXd pointsMatrixXd = Eigen::Map<Eigen::MatrixXd>(
        reinterpret_cast<double*>(pointsVec.data()), 2, long(pointsVec.size()));

    std::cout << pointsMatrix2d << std::endl;
    std::cout << "==============================" << std::endl;
    std::cout << pointsMatrixXd << std::endl;
    std::cout << "==============================" << std::endl;

    std::vector<Eigen::Vector3d> eigenPointsVec;
    eigenPointsVec.push_back(Eigen::Vector3d(2, 4, 1));
    eigenPointsVec.push_back(Eigen::Vector3d(7, 3, 9));
    eigenPointsVec.push_back(Eigen::Vector3d(6, 1, -1));
    eigenPointsVec.push_back(Eigen::Vector3d(-6, 9, 8));

    Eigen::MatrixXd pointsMatrix = Eigen::Map<Eigen::MatrixXd>(eigenPointsVec[0].data(), 3, long(eigenPointsVec.size()));

    std::cout << pointsMatrix << std::endl;
    std::cout << "==============================" << std::endl;

    pointsMatrix = Eigen::Map<Eigen::MatrixXd>(reinterpret_cast<double*>(eigenPointsVec.data()), 3, long(eigenPointsVec.size()));

    std::cout << pointsMatrix << std::endl;

    std::vector<double> aa = { 1, 2, 3, 4 };
    Eigen::VectorXd b = Eigen::Map<Eigen::VectorXd, Eigen::Unaligned>(aa.data(), long(aa.size()));
}

struct point {

double a;

double b;

};

void EigenMapExample()

{

////////////////////////////////////////First Example/////////////////////////////////////////

Eigen::VectorXd solutionVec(12,1);

solutionVec<<1,2,3,4,5,6,7,8,9,10,11,12;

Eigen::Map<Eigen::MatrixXd> solutionColMajor(solutionVec.data(),4,3);

Eigen::Map<Eigen::Matrix<double, 3, 4, Eigen::RowMajor> >solutionRowMajor (solutionVec.data());

std::cout << "solutionColMajor: "<< std::endl;

std::cout << solutionColMajor<< std::endl;

std::cout << "solutionRowMajor"<< std::endl;

std::cout << solutionRowMajor<< std::endl;

////////////////////////////////////////Second Example/////////////////////////////////////////

// https://stackoverflow.com/questions/49813340/stdvectoreigenvector3d-to-eigenmatrixxd-eigen

int array[9];

for (int i = 0; i < 9; ++i) {

array[i] = i;

}

Eigen::MatrixXi a(9, 1);

a = Eigen::Map<Eigen::Matrix3i>(array);

std::cout << a << std::endl;

std::vector<point> pointsVec;

point point1, point2, point3;

point1.a = 1.0;

point1.b = 1.5;

point2.a = 2.4;

point2.b = 3.5;

point3.a = -1.3;

point3.b = 2.4;

pointsVec.push_back(point1);

pointsVec.push_back(point2);

pointsVec.push_back(point3);

Eigen::Matrix2Xd pointsMatrix2d = Eigen::Map<Eigen::Matrix2Xd>(

reinterpret_cast<double*>(pointsVec.data()), 2, long(pointsVec.size()));

Eigen::MatrixXd pointsMatrixXd = Eigen::Map<Eigen::MatrixXd>(

reinterpret_cast<double*>(pointsVec.data()), 2, long(pointsVec.size()));

std::cout << pointsMatrix2d << std::endl;

std::cout << "==============================" << std::endl;

std::cout << pointsMatrixXd << std::endl;

std::cout << "==============================" << std::endl;

std::vector<Eigen::Vector3d> eigenPointsVec;

eigenPointsVec.push_back(Eigen::Vector3d(2, 4, 1));

eigenPointsVec.push_back(Eigen::Vector3d(7, 3, 9));

eigenPointsVec.push_back(Eigen::Vector3d(6, 1, -1));

eigenPointsVec.push_back(Eigen::Vector3d(-6, 9, 8));

Eigen::MatrixXd pointsMatrix = Eigen::Map<Eigen::MatrixXd>(eigenPointsVec[0].data(), 3, long(eigenPointsVec.size()));

std::cout << pointsMatrix << std::endl;

std::cout << "==============================" << std::endl;

pointsMatrix = Eigen::Map<Eigen::MatrixXd>(reinterpret_cast<double*>(eigenPointsVec.data()), 3, long(eigenPointsVec.size()));

std::cout << pointsMatrix << std::endl;

std::vector<double> aa = { 1, 2, 3, 4 };

Eigen::VectorXd b = Eigen::Map<Eigen::VectorXd, Eigen::Unaligned>(aa.data(), long(aa.size()));

}

Decomposing Projection Using OpenCV and C++

Leave a reply

#include <opencv/cv.hpp>
#include <opencv2/core.hpp>
#include <opencv2/calib3d.hpp>
#include "transformation.hpp"

//https://www.cnblogs.com/shengguang/p/5932522.html
void HouseHolderQR(const cv::Mat &A, cv::Mat &Q, cv::Mat &R)
{
    assert ( A.channels() == 1 );
    assert ( A.rows >= A.cols );
    auto sign = [](double value) { return value >= 0 ? 1: -1; };
    const auto totalRows = A.rows;
    const auto totalCols = A.cols;
    R = A.clone();
    Q = cv::Mat::eye ( totalRows, totalRows, A.type() );
    for ( int col = 0; col < A.cols; ++ col )
    {
        cv::Mat matAROI = cv::Mat ( R, cv::Range ( col, totalRows ), cv::Range ( col, totalCols ) );
        cv::Mat y = matAROI.col ( 0 );
        auto yNorm = norm ( y );
        cv::Mat e1 = cv::Mat::eye ( y.rows, 1, A.type() );
        cv::Mat w = y + sign(y.at<double>(0,0)) *  yNorm * e1;
        cv::Mat v = w / norm( w );
        cv::Mat vT; cv::transpose(v, vT );
        cv::Mat I = cv::Mat::eye( matAROI.rows, matAROI.rows, A.type() );
        cv::Mat I_2VVT = I - 2 * v * vT;
        cv::Mat matH = cv::Mat::eye ( totalRows, totalRows, A.type() );
        cv::Mat matHROI = cv::Mat(matH, cv::Range ( col, totalRows ), cv::Range ( col, totalRows ) );
        I_2VVT.copyTo ( matHROI );
        R = matH * R;
        Q = Q * matH;
    }
}

int main()
{


/*
Thera are two notations for Projection Matrix

1)P=K[R|t]
                                                              ┌X┐
                                                      ┌R,t┐   |Y|
    X_Cam=R*X+t  ==> Homogeneous Coordinate ==> X_Cam=|0,1|   |Z|
                                                      └   ┘4x4└1┘4x1

                                         ┌X┐
                                ┌   ┐    |Y|
    image plane  <--x=K[I|0]3x4 |R,t|    |Z|
                                └0,1┘4x4 └1┘4x1

    P=K[R|t]

2)P=KR[I|-X0]
                                                              ┌X┐
                                                       ┌R -Rc┐|Y|
    X_Cam=R*[X_w-C]  ==> Homogeneous Coordinate ==>    |     ||Z|
                                                       └0  1 ┘└1┘
                                       ┌X┐
                                ┌R -Rc┐|Y|
    image plane  <--x=K[I|0]3x4 |0  1 ||Z|
                                └     ┘└1┘
    P=K[R|-RC]= KR[I|-C]


(1) and (2) ==> t=-RC

*/
    int numberOfPixelInHeight,numberOfPixelInWidth;
    double heightOfSensor, widthOfSensor;
    double focalLength=1.50;
    double mx, my, U0, V0;
    numberOfPixelInHeight=600;
    numberOfPixelInWidth=800;

    heightOfSensor=10;
    widthOfSensor=10;


    my=(numberOfPixelInHeight)/heightOfSensor ;
    U0=(numberOfPixelInHeight)/2 ;

    mx=(numberOfPixelInWidth)/widthOfSensor;
    V0=(numberOfPixelInWidth)/2;

    cv::Mat cameraMatrix = (cv::Mat_<double>(3,3) <<
    focalLength*mx, 0, V0,
    0,focalLength*my,U0,
    0,0,1);

    double tx,ty,tz,roll,pitch,yaw;

    tx=1.0;
    ty=2.1;
    tz=-1.4;

    cv::Mat translation = (cv::Mat_<double>(3,1) <<tx,ty,tz);

    cv::Vec3d theta;

    roll=+M_PI/4 ;
    pitch=+M_PI/10;
    yaw=-+M_PI/6;

    theta[0]=roll;
    theta[1]=pitch;
    theta[2]=yaw;
    cv::Mat rotation=eulerAnglesToRotationMatrix(theta);
    //1)P=K[R|t]
    cv::Mat R_T;
    cv::hconcat(rotation, translation, R_T);
    cv::Mat projectionMatrix=cameraMatrix*R_T;



    cv::Mat calculatedCameraMatrix,calculatedRotation,calculatedTranslation;

    cv::decomposeProjectionMatrix(projectionMatrix,calculatedCameraMatrix,calculatedRotation,calculatedTranslation);


    std::cout<<"==============================Ground Truth==============================" <<std::endl;

    std::cout<<"Rotation Matrix (Ground Truth)" <<std::endl;
    std::cout<<rotation <<std::endl;

    std::cout<<"Translation Matrix (Ground Truth)" <<std::endl;
    std::cout<<translation <<std::endl;

    std::cout<<"Camera Matrix (Ground Truth)" <<std::endl;
    std::cout<<cameraMatrix <<std::endl;

    std::cout<<"==============================Decomposing Using OpenCV==============================" <<std::endl;


    std::cout<<"Computed Rotation Matrix (OpenCV)" <<std::endl;
    std::cout<<calculatedRotation <<std::endl;

    std::cout<<"Computed Translation Matrix (OpenCV)" <<std::endl;
    //std::cout<<calculatedTranslation/calculatedTranslation.at<double>(3,0) <<std::endl;
    cv::Mat tempT=(cv::Mat_<double>(3,1)<<
                   calculatedTranslation.at<double>(0,0)/calculatedTranslation.at<double>(3,0),
                   calculatedTranslation.at<double>(1,0)/calculatedTranslation.at<double>(3,0),
                   calculatedTranslation.at<double>(2,0)/calculatedTranslation.at<double>(3,0));
    std::cout<<-rotation*tempT<<std::endl;

    std::cout<<"Computed Camera Matrix (OpenCV)" <<std::endl;
    std::cout<<calculatedCameraMatrix <<std::endl;

///////////////////////////////////////decomposing the projection matrix///////////////////////////////////////////

/*

    P=KR[I|-X0]=[H_inf3x3|h3x1]
    KR=H_inf3x3
    1)X0
    -KRX0=h3x1 => X0=-(KR)^-1*h3x1 ==>X0=-(H_inf3x3)^-1*h3x1
    2)K,R

    KR=H_inf3x3 =>(KR)^-1= H_inf3x3^-1 =>R^-1*K^-1=H_inf3x3^-1 | R^-1*K^-1=Q*R => R=Q^-1, K=R^-1
                                         H_inf3x3^-1=Q*R       |

*/


    cv::Mat H_inf3x3=(cv::Mat_<double>(3,3)<< projectionMatrix.at<double>(0,0),projectionMatrix.at<double>(0,1),projectionMatrix.at<double>(0,2)
                      ,projectionMatrix.at<double>(1,0),projectionMatrix.at<double>(1,1),projectionMatrix.at<double>(1,2)
                      ,projectionMatrix.at<double>(2,0),projectionMatrix.at<double>(2,1),projectionMatrix.at<double>(2,2));

    cv::Mat h3x1=(cv::Mat_<double>(3,1)<<projectionMatrix.at<double>(0,3),projectionMatrix.at<double>(1,3),projectionMatrix.at<double>(2,3) );



    cv::Mat Q,R;
    cv::Mat H_inf3x3_inv=H_inf3x3.inv();
    //R=Q^-1, K=R^-1


    HouseHolderQR(H_inf3x3_inv, Q, R);
    cv::Mat K=R.inv();

    std::cout<<"==============================Decomposing Using My Code==============================" <<std::endl;
    //due to homogeneity we divide it by last element
    std::cout<<"Estimated Camera Matrix\n"<<K/K.at<double>(2,2) <<std::endl;

    cv::Mat rotationMatrix=Q.inv();
    std::cout<<"Estimated Camera Rotation\n"<<rotationMatrix*-1 <<std::endl;

    std::cout<<"Estimated Camera Translation" <<std::endl;

    //t=-R*C, Q.inv()=R
    std::cout<<-1*(-Q.inv()*(-H_inf3x3.inv()*h3x1 ))<<std::endl;

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

#include <opencv/cv.hpp>

#include <opencv2/core.hpp>

#include <opencv2/calib3d.hpp>

#include "transformation.hpp"

//https://www.cnblogs.com/shengguang/p/5932522.html

void HouseHolderQR(const cv::Mat &A, cv::Mat &Q, cv::Mat &R)

{

assert ( A.channels() == 1 );

assert ( A.rows >= A.cols );

auto sign = [](double value) { return value >= 0 ? 1: -1; };

const auto totalRows = A.rows;

const auto totalCols = A.cols;

R = A.clone();

Q = cv::Mat::eye ( totalRows, totalRows, A.type() );

for ( int col = 0; col < A.cols; ++ col )

{

cv::Mat matAROI = cv::Mat ( R, cv::Range ( col, totalRows ), cv::Range ( col, totalCols ) );

cv::Mat y = matAROI.col ( 0 );

auto yNorm = norm ( y );

cv::Mat e1 = cv::Mat::eye ( y.rows, 1, A.type() );

cv::Mat w = y + sign(y.at<double>(0,0)) * yNorm * e1;

cv::Mat v = w / norm( w );

cv::Mat vT; cv::transpose(v, vT );

cv::Mat I = cv::Mat::eye( matAROI.rows, matAROI.rows, A.type() );

cv::Mat I_2VVT = I - 2 * v * vT;

cv::Mat matH = cv::Mat::eye ( totalRows, totalRows, A.type() );

cv::Mat matHROI = cv::Mat(matH, cv::Range ( col, totalRows ), cv::Range ( col, totalRows ) );

I_2VVT.copyTo ( matHROI );

R = matH * R;

Q = Q * matH;

}

int main()

{

Thera are two notations for Projection Matrix

1)P=K[R|t]

┌X┐

┌R,t┐ |Y|

X_Cam=R*X+t ==> Homogeneous Coordinate ==> X_Cam=|0,1| |Z|

└ ┘4x4└1┘4x1

┌X┐

┌ ┐ |Y|

image plane <--x=K[I|0]3x4 |R,t| |Z|

└0,1┘4x4 └1┘4x1

P=K[R|t]

2)P=KR[I|-X0]

┌X┐

┌R -Rc┐|Y|

X_Cam=R*[X_w-C] ==> Homogeneous Coordinate ==> | ||Z|

└0 1 ┘└1┘

┌X┐

┌R -Rc┐|Y|

image plane <--x=K[I|0]3x4 |0 1 ||Z|

└ ┘└1┘

P=K[R|-RC]= KR[I|-C]

(1) and (2) ==> t=-RC

int numberOfPixelInHeight,numberOfPixelInWidth;

double heightOfSensor, widthOfSensor;

double focalLength=1.50;

double mx, my, U0, V0;

numberOfPixelInHeight=600;

numberOfPixelInWidth=800;

heightOfSensor=10;

widthOfSensor=10;

my=(numberOfPixelInHeight)/heightOfSensor ;

U0=(numberOfPixelInHeight)/2 ;

mx=(numberOfPixelInWidth)/widthOfSensor;

V0=(numberOfPixelInWidth)/2;

cv::Mat cameraMatrix = (cv::Mat_<double>(3,3) <<

focalLength*mx, 0, V0,

0,focalLength*my,U0,

0,0,1);

double tx,ty,tz,roll,pitch,yaw;

tx=1.0;

ty=2.1;

tz=-1.4;

cv::Mat translation = (cv::Mat_<double>(3,1) <<tx,ty,tz);

cv::Vec3d theta;

roll=+M_PI/4 ;

pitch=+M_PI/10;

yaw=-+M_PI/6;

theta[0]=roll;

theta[1]=pitch;

theta[2]=yaw;

cv::Mat rotation=eulerAnglesToRotationMatrix(theta);

//1)P=K[R|t]

cv::Mat R_T;

cv::hconcat(rotation, translation, R_T);

cv::Mat projectionMatrix=cameraMatrix*R_T;

cv::Mat calculatedCameraMatrix,calculatedRotation,calculatedTranslation;

cv::decomposeProjectionMatrix(projectionMatrix,calculatedCameraMatrix,calculatedRotation,calculatedTranslation);

std::cout<<"==============================Ground Truth==============================" <<std::endl;

std::cout<<"Rotation Matrix (Ground Truth)" <<std::endl;

std::cout<<rotation <<std::endl;

std::cout<<"Translation Matrix (Ground Truth)" <<std::endl;

std::cout<<translation <<std::endl;

std::cout<<"Camera Matrix (Ground Truth)" <<std::endl;

std::cout<<cameraMatrix <<std::endl;

std::cout<<"==============================Decomposing Using OpenCV==============================" <<std::endl;

std::cout<<"Computed Rotation Matrix (OpenCV)" <<std::endl;

std::cout<<calculatedRotation <<std::endl;

std::cout<<"Computed Translation Matrix (OpenCV)" <<std::endl;

//std::cout<<calculatedTranslation/calculatedTranslation.at<double>(3,0) <<std::endl;

cv::Mat tempT=(cv::Mat_<double>(3,1)<<

calculatedTranslation.at<double>(0,0)/calculatedTranslation.at<double>(3,0),

calculatedTranslation.at<double>(1,0)/calculatedTranslation.at<double>(3,0),

calculatedTranslation.at<double>(2,0)/calculatedTranslation.at<double>(3,0));

std::cout<<-rotation*tempT<<std::endl;

std::cout<<"Computed Camera Matrix (OpenCV)" <<std::endl;

std::cout<<calculatedCameraMatrix <<std::endl;

///////////////////////////////////////decomposing the projection matrix///////////////////////////////////////////

P=KR[I|-X0]=[H_inf3x3|h3x1]

KR=H_inf3x3

1)X0

-KRX0=h3x1 => X0=-(KR)^-1*h3x1 ==>X0=-(H_inf3x3)^-1*h3x1

2)K,R

KR=H_inf3x3 =>(KR)^-1= H_inf3x3^-1 =>R^-1*K^-1=H_inf3x3^-1 | R^-1*K^-1=Q*R => R=Q^-1, K=R^-1

H_inf3x3^-1=Q*R |

cv::Mat H_inf3x3=(cv::Mat_<double>(3,3)<< projectionMatrix.at<double>(0,0),projectionMatrix.at<double>(0,1),projectionMatrix.at<double>(0,2)

,projectionMatrix.at<double>(1,0),projectionMatrix.at<double>(1,1),projectionMatrix.at<double>(1,2)

,projectionMatrix.at<double>(2,0),projectionMatrix.at<double>(2,1),projectionMatrix.at<double>(2,2));

cv::Mat h3x1=(cv::Mat_<double>(3,1)<<projectionMatrix.at<double>(0,3),projectionMatrix.at<double>(1,3),projectionMatrix.at<double>(2,3) );

cv::Mat Q,R;

cv::Mat H_inf3x3_inv=H_inf3x3.inv();

//R=Q^-1, K=R^-1

HouseHolderQR(H_inf3x3_inv, Q, R);

cv::Mat K=R.inv();

std::cout<<"==============================Decomposing Using My Code==============================" <<std::endl;

//due to homogeneity we divide it by last element

std::cout<<"Estimated Camera Matrix\n"<<K/K.at<double>(2,2) <<std::endl;

cv::Mat rotationMatrix=Q.inv();

std::cout<<"Estimated Camera Rotation\n"<<rotationMatrix*-1 <<std::endl;

std::cout<<"Estimated Camera Translation" <<std::endl;

//t=-R*C, Q.inv()=R

std::cout<<-1*(-Q.inv()*(-H_inf3x3.inv()*h3x1 ))<<std::endl;

And the output is:

==============================Ground Truth==============================
Rotation Matrix (Ground Truth)
[0.823639103546332, 0.5427868801100539, -0.1643199010764935;
 -0.4755282581475767, 0.5031184295835893, -0.7216264418079997;
 -0.3090169943749474, 0.6724985119639573, 0.6724985119639574]
Translation Matrix (Ground Truth)
[1;
 2.1;
 -1.4]
Camera Matrix (Ground Truth)
[120, 0, 400;
 0, 90, 300;
 0, 0, 1]
==============================Decomposing Using OpenCV==============================
Computed Rotation Matrix (OpenCV)
[0.823639103546332, 0.5427868801100539, -0.1643199010764936;
 -0.4755282581475769, 0.5031184295835893, -0.7216264418079997;
 -0.3090169943749474, 0.6724985119639573, 0.6724985119639574]
Computed Translation Matrix (OpenCV)
[0.9999999999999988;
 2.1;
 -1.4]
Computed Camera Matrix (OpenCV)
[120, -1.4210854715202e-14, 400;
 0, 90.00000000000001, 300;
 0, 0, 1]
==============================Decomposing Using My Code==============================
Estimated Camera Matrix
[120, -5.776629175002766e-14, 399.9999999999999;
 -5.608036291626306e-15, 89.99999999999994, 299.9999999999999;
 -1.49192016182457e-17, -1.561251128379126e-16, 1]
Estimated Camera Rotation
[0.8236391035463322, 0.5427868801100542, -0.1643199010764936;
 -0.4755282581475767, 0.5031184295835892, -0.7216264418079998;
 -0.3090169943749475, 0.6724985119639573, 0.6724985119639575]
Estimated Camera Translation
[1;
 2.099999999999999;
 -1.4]

==============================Ground Truth==============================

Rotation Matrix (Ground Truth)

[0.823639103546332, 0.5427868801100539, -0.1643199010764935;

-0.4755282581475767, 0.5031184295835893, -0.7216264418079997;

-0.3090169943749474, 0.6724985119639573, 0.6724985119639574]

Translation Matrix (Ground Truth)

[1;

2.1;

-1.4]

Camera Matrix (Ground Truth)

[120, 0, 400;

0, 90, 300;

0, 0, 1]

==============================Decomposing Using OpenCV==============================

Computed Rotation Matrix (OpenCV)

[0.823639103546332, 0.5427868801100539, -0.1643199010764936;

-0.4755282581475769, 0.5031184295835893, -0.7216264418079997;

-0.3090169943749474, 0.6724985119639573, 0.6724985119639574]

Computed Translation Matrix (OpenCV)

[0.9999999999999988;

2.1;

-1.4]

Computed Camera Matrix (OpenCV)

[120, -1.4210854715202e-14, 400;

0, 90.00000000000001, 300;

0, 0, 1]

==============================Decomposing Using My Code==============================

Estimated Camera Matrix

[120, -5.776629175002766e-14, 399.9999999999999;

-5.608036291626306e-15, 89.99999999999994, 299.9999999999999;

-1.49192016182457e-17, -1.561251128379126e-16, 1]

Estimated Camera Rotation

[0.8236391035463322, 0.5427868801100542, -0.1643199010764936;

-0.4755282581475767, 0.5031184295835892, -0.7216264418079998;

-0.3090169943749475, 0.6724985119639573, 0.6724985119639575]

Estimated Camera Translation

[1;

2.099999999999999;

-1.4]

How to use image_geometry and camera_info_manager in ROS

Leave a reply

camera_info_publisher.cpp:

#include <camera_info_manager/camera_info_manager.h>
int main(int argc, char** argv)
{
    ros::init(argc, argv, "camera_info_publisher");
    ros::NodeHandle nh;

    const std::string cname="prosilica";
    const std::string url="file://${ROS_HOME}/camera_info/prosilica.yaml";
    ros::Publisher pubCameraInfo = nh.advertise<sensor_msgs::CameraInfo>("camera/camera_info", 1);
    camera_info_manager::CameraInfoManager cinfo(nh,cname,url);
    sensor_msgs::CameraInfo msgCameraInfo;
    ros::Rate loop_rate(5);
    while (nh.ok())
    {
        msgCameraInfo=cinfo.getCameraInfo();
        pubCameraInfo.publish(msgCameraInfo);
        ros::spinOnce();
        loop_rate.sleep();
    }
}

#include <camera_info_manager/camera_info_manager.h>

int main(int argc, char** argv)

{

ros::init(argc, argv, "camera_info_publisher");

ros::NodeHandle nh;

const std::string cname="prosilica";

const std::string url="file://${ROS_HOME}/camera_info/prosilica.yaml";

ros::Publisher pubCameraInfo = nh.advertise<sensor_msgs::CameraInfo>("camera/camera_info", 1);

camera_info_manager::CameraInfoManager cinfo(nh,cname,url);

sensor_msgs::CameraInfo msgCameraInfo;

ros::Rate loop_rate(5);

while (nh.ok())

{

msgCameraInfo=cinfo.getCameraInfo();

pubCameraInfo.publish(msgCameraInfo);

ros::spinOnce();

loop_rate.sleep();

}

image_geometry_demo.cpp:

#include <ros/ros.h>
#include <image_geometry/pinhole_camera_model.h>

void cameraInfoCallback(const sensor_msgs::CameraInfoConstPtr& info_msg)
{
    std::cout<<"===============================cameraInfoCallback===============================" <<std::endl;
    image_geometry::PinholeCameraModel cam_model_;
    cam_model_.fromCameraInfo(info_msg);
    // projection_matrix is the matrix you should use if you don't want to use project3dToPixel() and want to use opencv API
    cv::Matx34d projection_matrix=cam_model_.fullProjectionMatrix();
    std::cout<<cam_model_.project3dToPixel(cv::Point3d(-0.1392072,-0.02571392, 2.50376511) )<<std::endl;
}

int main(int argc,char ** argv)
{
    ros::init(argc,argv,"image_geometry_demo",1);
    ros::NodeHandle nh;
    ros::Subscriber sub = nh.subscribe("camera/camera_info", 1000, cameraInfoCallback);
    ros::spin();
}

#include <ros/ros.h>

#include <image_geometry/pinhole_camera_model.h>

void cameraInfoCallback(const sensor_msgs::CameraInfoConstPtr& info_msg)

{

std::cout<<"===============================cameraInfoCallback===============================" <<std::endl;

image_geometry::PinholeCameraModel cam_model_;

cam_model_.fromCameraInfo(info_msg);

// projection_matrix is the matrix you should use if you don't want to use project3dToPixel() and want to use opencv API

cv::Matx34d projection_matrix=cam_model_.fullProjectionMatrix();

std::cout<<cam_model_.project3dToPixel(cv::Point3d(-0.1392072,-0.02571392, 2.50376511) )<<std::endl;

}

int main(int argc,char ** argv)

{

ros::init(argc,argv,"image_geometry_demo",1);

ros::NodeHandle nh;

ros::Subscriber sub = nh.subscribe("camera/camera_info", 1000, cameraInfoCallback);

ros::spin();

}

CMakeLists.txt

find_package(catkin REQUIRED COMPONENTS image_geometry camera_info_manager roscpp)

1	find_package(catkin REQUIRED COMPONENTS image_geometry camera_info_manager roscpp)

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

Leave a reply

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 to seems to have some problems.

cd build/cmake/ && mkdir build && cd build

cmake -DCMAKE_BUILD_TYPE=Release -DBUILD_SHARED_LIBS=ON -DCMAKE_INSTALL_PREFIX:PATH=~/usr .. && make -j8 all install

cd build/cmake/ && mkdir build && cd build

cmake -DCMAKE_BUILD_TYPE=Release -DBUILD_SHARED_LIBS=ON -DCMAKE_INSTALL_PREFIX:PATH=~/usr .. && make -j8 all install

2)SiftGPU

Prerequisite:

Install DevIl Image library

sudo apt-get install libdevil-dev

1	sudo apt-get install libdevil-dev

git clone https://github.com/pitzer/SiftGPU

1	git clone https://github.com/pitzer/SiftGPU

open makefile and enable siftgpu_enable_cuda

siftgpu_enable_cuda=1

1	siftgpu_enable_cuda=1

make -j8

make -j8

now go to bin directory and libsiftgpu.so to your vsfm bin directory

VSFM

1) Download the <a href="http://ccwu.me/vsfm/download/VisualSFM_linux_64bit.zip">vsfm</a> program
	1-1)cd vsfm
	1-2)make

2) Download <a href="https://grail.cs.washington.edu/projects/mcba/pba_v1.0.5.zip">PBA</a>
	2-1)If you have no GPU rename makefile_no_gpu to makefie
	2-2)make
	2-3)rename bin/libpba_no_gpu.so to libpba.so and copy it in the vsfm/bin

3) Download <a href="https://github.com/pmoulon/CMVS-PMVS">CMVS-PMVS</a>
	3-1)cd CMVS-PMVS-master/program
	3-2)mkdir build && cd build
	3-3)cmake ../ && make -j8
	3-4)copy cmvs, genOption, pmvs2 from build/main into  vsfm/bin

4) copy libsiftgpu.so from previous section to vsfm/bin

5) Run:
  export LD_LIBRARY_PATH=$PWD:$LD_LIBRARY_PATH
  ./VisualSFM

1) Download the <a href="http://ccwu.me/vsfm/download/VisualSFM_linux_64bit.zip">vsfm</a> program

1-1)cd vsfm

1-2)make

2) Download <a href="https://grail.cs.washington.edu/projects/mcba/pba_v1.0.5.zip">PBA</a>

2-1)If you have no GPU rename makefile_no_gpu to makefie

2-2)make

2-3)rename bin/libpba_no_gpu.so to libpba.so and copy it in the vsfm/bin

3) Download <a href="https://github.com/pmoulon/CMVS-PMVS">CMVS-PMVS</a>

3-1)cd CMVS-PMVS-master/program

3-2)mkdir build && cd build

3-3)cmake ../ && make -j8

3-4)copy cmvs, genOption, pmvs2 from build/main into vsfm/bin

4) copy libsiftgpu.so from previous section to vsfm/bin

5) Run:

export LD_LIBRARY_PATH=$PWD:$LD_LIBRARY_PATH

./VisualSFM

you can see the some of my results here:

Note: if you don’t have cuda or Nvidia driver you can use your CPU but then you have to limit your file image size and sift binary should be available in your vsfm/bin directory.

Download http://www.cs.ubc.ca/~lowe/keypoints/siftDemoV4.zip and make it and copy the sift binary to vsfm/bin.

2)Colmap

The installation fo this one is almost straightforward except you need the latest version of Ceres Solver (do not use the one binary package from Ubuntu they are old and they won’t work). So download and make and install the Ceres Solver using the following:

cmake -DCMAKE_BUILD_TYPE=Release -DCMAKE_INSTALL_PREFIX:PATH=~/usr .. && make -j8 all install

1	cmake -DCMAKE_BUILD_TYPE=Release -DCMAKE_INSTALL_PREFIX:PATH=~/usr .. && make -j8 all install

Now in the colmap CMakeList.txt add the following line:

set(Ceres_DIR "$ENV{HOME}/usr/lib/cmake/Ceres")

1	set(Ceres_DIR "$ENV{HOME}/usr/lib/cmake/Ceres")

just before “find_package(Ceres REQUIRED)”

and now you can make and install it. You can see some of my results here:

In the next post, I will show you how can you do that in OpenCV.

Examples of Dynamic Programming with C++ and Matlab

Leave a reply

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 here and the recursive part is in the following lines:

for x=2:rows
    for y=1:cols  
        M(x+1,y+1)=score_matrix(x,y)+ min( [M(x-1+1,y-1 +1) , M(x-1+1,y+1), M(x-1+1,y+1+1) ] );
    end
end

for x=2:rows

for y=1:cols

M(x+1,y+1)=score_matrix(x,y)+ min( [M(x-1+1,y-1 +1) , M(x-1+1,y+1), M(x-1+1,y+1+1) ] );

end

The examples are taken from “Competitive Programmer’s Handbook” written by Antti Laaksonen.

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

Leave a reply

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 the maximum possible pixel value of the image. For instance if the image is uint8, it will be 255.

ref = imread('pout.tif');
A = imnoise(ref,'salt & pepper', 0.02);
%%%%%%%%%%%%%%%%or we can apply gaussian noise%%%%%%%%%%%%%%%%
%A = imnoise(ref, 'gaussian', 0, 0.003);

[M,N]=size(ref);

SE = (double(A) - double(ref)) .^ 2; % Squared Error
MSE=sum( sum( SE  ) ) /(M*N); %Mean Square Error
MAXI=255;
fprintf('\n PSNR is:')
10*log10((MAXI^2)/MSE)

figure,imshow(A, []);
figure,imshow(ref, []);
figure,imshow(SE, []);


%%%%%%%%%%%%%%%%% using Matlab API %%%%%%%%%%%%%%%%
%MSE = immse(A, ref)
[peaksnr, snr] = psnr(A, ref);
fprintf('\n The Peak-SNR value is %0.4f', peaksnr);
fprintf('\n The SNR value is %0.4f \n', snr);

ref = imread('pout.tif');

A = imnoise(ref,'salt & pepper', 0.02);

%%%%%%%%%%%%%%%%or we can apply gaussian noise%%%%%%%%%%%%%%%%

%A = imnoise(ref, 'gaussian', 0, 0.003);

[M,N]=size(ref);

SE = (double(A) - double(ref)) .^ 2; % Squared Error

MSE=sum( sum( SE ) ) /(M*N); %Mean Square Error

MAXI=255;

fprintf('\n PSNR is:')

10*log10((MAXI^2)/MSE)

figure,imshow(A, []);

figure,imshow(ref, []);

figure,imshow(SE, []);

%%%%%%%%%%%%%%%%% using Matlab API %%%%%%%%%%%%%%%%

%MSE = immse(A, ref)

[peaksnr, snr] = psnr(A, ref);

fprintf('\n The Peak-SNR value is %0.4f', peaksnr);

fprintf('\n The SNR value is %0.4f \n', snr);

double getPSNR(const Mat& I1, const Mat& I2)
{
 Mat s1;
 absdiff(I1, I2, s1);       // |I1 - I2|
 s1.convertTo(s1, CV_32F);  // cannot make a square on 8 bits
 s1 = s1.mul(s1);           // |I1 - I2|^2

 Scalar s = sum(s1);         // sum elements per channel

 double sse = s.val[0] + s.val[1] + s.val[2]; // sum channels

 if( sse <= 1e-10) // for small values return zero
     return 0;
 else
 {
     double  mse =sse /(double)(I1.channels() * I1.total());
     double psnr = 10.0*log10((255*255)/mse);
     return psnr;
 }
}

double getPSNR(const Mat& I1, const Mat& I2)

{

Mat s1;

absdiff(I1, I2, s1); // |I1 - I2|

s1.convertTo(s1, CV_32F); // cannot make a square on 8 bits

s1 = s1.mul(s1); // |I1 - I2|^2

Scalar s = sum(s1); // sum elements per channel

double sse = s.val[0] + s.val[1] + s.val[2]; // sum channels

if( sse <= 1e-10) // for small values return zero

return 0;

else

{

double mse =sse /(double)(I1.channels() * I1.total());

double psnr = 10.0*log10((255*255)/mse);

return psnr;

}

Ref [1],[2], [3], 4

get template parameter name and type with Boost demangle

Leave a reply

Have you ever tied to get the type of a variable by its name? for instance “int” or “string“?

The following code snippet shows how to use boost demangle to get the type:

#include <boost/units/detail/utility.hpp>
#include <boost/shared_ptr.hpp>
template
<typename T>
void foo(boost::shared_ptr<T> var)
{
    std::string var_type= boost::units::detail::demangle(typeid(*var.get()).name());



    if(var_type.find("int") !=std::string::npos )
    {
        std::cout<<"Type of var is int" <<std::endl;
    }else if(var_type.find("float") !=std::string::npos )
    {
        std::cout<<"Type of var is int" <<std::endl;
    }
    else
    {
        std::cout<<"Type of var is "<<var_type <<std::endl;
    }


}


int main()
{


    boost::shared_ptr<int > x_ptr(new int );
    *x_ptr=10;
    foo(x_ptr);

    boost::shared_ptr<float > y_ptr(new float );
    *y_ptr=10.3;
    foo(y_ptr);


    boost::shared_ptr<double > z_ptr(new double );
    *z_ptr=10.3;
    foo(z_ptr);

    return 0;
}

#include <boost/units/detail/utility.hpp>

#include <boost/shared_ptr.hpp>

template

void foo(boost::shared_ptr<T> var)

{

std::string var_type= boost::units::detail::demangle(typeid(*var.get()).name());

if(var_type.find("int") !=std::string::npos )

{

std::cout<<"Type of var is int" <<std::endl;

}else if(var_type.find("float") !=std::string::npos )

{

std::cout<<"Type of var is int" <<std::endl;

}

else

{

std::cout<<"Type of var is "<<var_type <<std::endl;

}

int main()

{

boost::shared_ptr<int > x_ptr(new int );

*x_ptr=10;

foo(x_ptr);

boost::shared_ptr<float > y_ptr(new float );

*y_ptr=10.3;

foo(y_ptr);

boost::shared_ptr<double > z_ptr(new double );

*z_ptr=10.3;

foo(z_ptr);

return 0;

}

Finding roll, pitch yaw from 3X3 rotation matrix with Eigen

Leave a reply

/*  http://planning.cs.uiuc.edu/node103.html

    |r11 r12 r13 |
    |r21 r22 r23 |
    |r31 r32 r33 |

    yaw: alpha=arctan(r21/r11)
    pitch: beta=arctan(-r31/sqrt( r32^2+r33^2 ) )
    roll: gamma=arctan(r32/r33)
*/
    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<<"roll is Pi/" <<M_PI/atan2( rotationMatrix(2,1),rotationMatrix(2,2) ) <<std::endl;
    std::cout<<"pitch: Pi/" <<M_PI/atan2( -rotationMatrix(2,0), std::pow( rotationMatrix(2,1)*rotationMatrix(2,1) +rotationMatrix(2,2)*rotationMatrix(2,2) ,0.5  )  ) <<std::endl;
    std::cout<<"yaw is Pi/" <<M_PI/atan2( rotationMatrix(1,0),rotationMatrix(0,0) ) <<std::endl;

/* http://planning.cs.uiuc.edu/node103.html

|r11 r12 r13 |

|r21 r22 r23 |

|r31 r32 r33 |

yaw: alpha=arctan(r21/r11)

pitch: beta=arctan(-r31/sqrt( r32^2+r33^2 ) )

roll: gamma=arctan(r32/r33)

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<<"roll is Pi/" <<M_PI/atan2( rotationMatrix(2,1),rotationMatrix(2,2) ) <<std::endl;

std::cout<<"pitch: Pi/" <<M_PI/atan2( -rotationMatrix(2,0), std::pow( rotationMatrix(2,1)*rotationMatrix(2,1) +rotationMatrix(2,2)*rotationMatrix(2,2) ,0.5 ) ) <<std::endl;

std::cout<<"yaw is Pi/" <<M_PI/atan2( rotationMatrix(1,0),rotationMatrix(0,0) ) <<std::endl;