Kezunlin's Blog

typedef Matrix< std::complex<double> , 2 , 2 > Eigen::Matrix2cd
typedef Matrix< std::complex<float> , 2 , 2 > Eigen::Matrix2cf
typedef Matrix< double , 2 , 2 > Eigen::Matrix2d
typedef Matrix< float , 2 , 2 > Eigen::Matrix2f
typedef Matrix< int , 2 , 2 > Eigen::Matrix2i
typedef Matrix< std::complex<double> , 2 , Dynamic> Eigen::Matrix2Xcd
typedef Matrix< std::complex<float> , 2 , Dynamic> Eigen::Matrix2Xcf
typedef Matrix< double , 2 , Dynamic> Eigen::Matrix2Xd
typedef Matrix< float , 2 , Dynamic> Eigen::Matrix2Xf
typedef Matrix< int , 2 , Dynamic> Eigen::Matrix2Xi
typedef Matrix< std::complex<double> , 3 , 3 > Eigen::Matrix3cd
########
transpose  转置
conjugate  共轭
adjoint    伴随

#include <Eigen/Dense>
using namespace Eigen;

void test0()
{
	//------------------------
	MatrixXd m(2,2);
	m(0,0) = 3;
	m(1,0) = 2.5;
	m(0,1) = -1;
	m(1,1) = m(1,0) + m(0,1);
	cout << "Here is the matrix m:\n" << m << endl;

	VectorXd v(2);
	v(0) = 4;
	v(1) = v(0) - 1;
	cout << "Here is the vector v:\n" << v << endl;

	//------------------------
	Matrix3f m2;
	m2 << 1, 2, 3,
		4, 5, 6,
		7, 8, 9;
	cout << m2 << endl;
}

void test1()
{
	// stats
	Eigen::Matrix2d mat;
	mat << 1, 2,
			3, 4;
	cout << "Here is mat.sum():       " << mat.sum()       << endl;
	cout << "Here is mat.prod():      " << mat.prod()      << endl;
	cout << "Here is mat.mean():      " << mat.mean()      << endl;
	cout << "Here is mat.minCoeff():  " << mat.minCoeff()  << endl; // min value = 1
	cout << "Here is mat.maxCoeff():  " << mat.maxCoeff()  << endl; // max value = 4
	cout << "Here is mat.trace():     " << mat.trace()     << endl; // 
}

/*
Here is mat.sum():       10
Here is mat.prod():      24
Here is mat.mean():      2.5
Here is mat.minCoeff():  1
Here is mat.maxCoeff():  4
Here is mat.trace():     5
*/

void test2()
{ 
	// l1-norm = |v1|+|v2|+...|vn|
	// l2-norm = v1*v1 + v2*v2+...vn*vn     squareNorm(), Norm()
	//  lpNorm< p >():  lpNorm< 1 >()   lpNorm< 2 >()

	VectorXf v(2);
	MatrixXf m(2,2), n(2,2);
	
	v << -1,
		2;
	
	m << 1,-2,
		-3,4;
	cout << "v.squaredNorm() = " << v.squaredNorm() << endl;
	cout << "v.norm() = " << v.norm() << endl;
	cout << "v.lpNorm<1>() = " << v.lpNorm<1>() << endl;
	cout << "v.lpNorm<Infinity>() = " << v.lpNorm<Infinity>() << endl; // max value
	cout << endl;
	cout << "m.squaredNorm() = " << m.squaredNorm() << endl;
	cout << "m.norm() = " << m.norm() << endl;
	cout << "m.lpNorm<1>() = " << m.lpNorm<1>() << endl;
	cout << "m.lpNorm<Infinity>() = " << m.lpNorm<Infinity>() << endl;  // max value


	n << 1,-2,
		-3,4;
	cout << "1-norm(n)     = " << n.cwiseAbs().colwise().sum().maxCoeff()
		<< " == "             << n.colwise().lpNorm<1>().maxCoeff() << endl;
	cout << "infty-norm(n) = " << n.cwiseAbs().rowwise().sum().maxCoeff()
		<< " == "             << n.rowwise().lpNorm<1>().maxCoeff() << endl;
}
/*
v.squaredNorm() = 5
v.norm() = 2.23607
v.lpNorm<1>() = 3
v.lpNorm<Infinity>() = 2

m.squaredNorm() = 30
m.norm() = 5.47723
m.lpNorm<1>() = 10
m.lpNorm<Infinity>() = 4


1-norm(n)     = 6 == 6
infty-norm(n) = 7 == 7
*/


void test3()
{
	// bool
	ArrayXXf a(2,2);
	
	a << 1,2,
		3,4;
	cout << "(a > 0).all()   = " << (a > 0).all() << endl; // bool 
	cout << "(a > 0).any()   = " << (a > 0).any() << endl; // bool
	cout << "(a > 0).count() = " << (a > 0).count() << endl; // int
	cout << endl;
	cout << "(a > 2).all()   = " << (a > 2).all() << endl;
	cout << "(a > 2).any()   = " << (a > 2).any() << endl;
	cout << "(a > 2).count() = " << (a > 2).count() << endl;
}
/*
(a > 0).all()   = 1
(a > 0).any()   = 1
(a > 0).count() = 4

(a > 2).all()   = 0
(a > 2).any()   = 1
(a > 2).count() = 2
*/

void test4()
{
	// get min/max index
	Eigen::MatrixXf m(2,2);
	
	m << 1, 2,
		3, 4;

	//get location of maximum
	MatrixXf::Index maxRow, maxCol;
	float max = m.maxCoeff(&maxRow, &maxCol);

	//get location of minimum
	MatrixXf::Index minRow, minCol;
	float min = m.minCoeff(&minRow, &minCol);

	cout << "Max: " << max <<  ", at: " << maxRow << "," << maxCol << endl;
	cout << "Min: " << min <<  ", at: " << minRow << "," << minCol << endl;
}
/*
Max: 4, at: 1,1
Min: 1, at: 0,0
*/

void test5()
{
	// colwise rowwise
	Eigen::MatrixXf mat(2,4);
	mat << 1, 2, 6, 9,
			3, 1, 7, 2;
	
	std::cout << "Column's maximum: " << std::endl
	<< mat.colwise().maxCoeff() << std::endl;

	std::cout << "Row's maximum: " << std::endl
	<< mat.rowwise().maxCoeff() << std::endl;
}
/*
Column's maximum: 
3 2 7 9
Row's maximum: 
9
7
*/

void test6()
{
	// colwise + max/min
	MatrixXf mat(2,4);
	mat << 1, 2, 6, 9,
			3, 1, 7, 2;
	
	MatrixXf::Index   maxIndex;
	float maxSum = mat.colwise().sum().maxCoeff(&maxIndex);
	
	std::cout << "Maximum sum at position " << maxIndex << std::endl;
	std::cout << "The corresponding vector is: " << std::endl;
	std::cout << mat.col( maxIndex ) << std::endl;
	std::cout << "And its sum is is: " << maxSum << std::endl;
}
/*
Maximum sum at position 2
The corresponding vector is: 
6
7
And its sum is is: 13
*/

void test7()
{
	// broadcast with vector
	Eigen::MatrixXf mat(2,4);
	Eigen::VectorXf v(2);
	
	mat << 1, 2, 6, 9,
			3, 1, 7, 2;
			
	v << 0,
		1;
		
	//add v to each column of m
	mat.colwise() += v;
	//mat += v; // ERROR
	
	std::cout << "Broadcasting result: " << std::endl;
	std::cout << mat << std::endl;
}
/*
Broadcasting result: 
1 2 6 9
4 2 8 3
*/

void test8()
{
	Eigen::MatrixXf m(2,4);
	Eigen::VectorXf v(2);
	
	m << 1, 23, 6, 9,
		3, 11, 7, 2;
		
	v << 2,
		3;
	MatrixXf::Index index;
	// find nearest neighbour
	(m.colwise() - v).colwise().squaredNorm().minCoeff(&index);
	cout << "Nearest neighbour is column " << index << ":" << endl;
	cout << m.col(index) << endl;
}
/*
Nearest neighbour is column 0:
1
3
*/

void test_eigen3()
{
	//test0();
	//test1();
	//test2();
	//test3();
	//test4();
	//test5();
	//test6();
	//test7();
	test8();
}

#pragma once
#include "algorithm_shared_export.h" 

#include <iostream>

#include <opencv2/opencv.hpp>  // Mat

struct SHARED_EXPORT Point
{
    float x, y;
};

typedef struct {
    int H;
	int W;
    int C;
    float *data;
} image_float_t;

typedef struct {
    int H;
	int W;
    int C;
    unsigned char *data;
} image_char_t;

class SHARED_EXPORT MyClass
{
    public:
        MyClass(int id);
        int add(int a, int b);
        float addf(float a, float b);
        void print_point(Point* p);
    
    private:
        int id_;
};


#ifdef __cplusplus
extern "C" {
#endif

    // pure C API (can not overload)
    SHARED_EXPORT int add(int a, int b);
    SHARED_EXPORT float addf(float a, float b);
    SHARED_EXPORT void print_point(Point* p);

    // warpper for c++ class
    SHARED_EXPORT void wrapper_init_class(int id);
    SHARED_EXPORT void wrapper_free_class();

    SHARED_EXPORT int wrapper_add(int a, int b);
    SHARED_EXPORT float wrapper_addf(float a, float b);
    SHARED_EXPORT void wrapper_print_point(Point* p);
    
    SHARED_EXPORT void process_image_float(image_float_t im);
    SHARED_EXPORT void process_image_char(image_char_t im);

#ifdef __cplusplus	
}
#endif 

#include "api.h"

// c++ class impl

MyClass::MyClass(int id)
	:id_(id)
{

}

int MyClass::add(int a, int b)
{
	return a + b;
}

float MyClass::addf(float a, float b)
{
	return a + b;
}

void MyClass::print_point(Point* p)
{
	if (p)
		printf("position x %f y %f \n", p->x, p->y);
	printf("myclass id = %d \n", id_);
}


#ifdef __cplusplus
extern "C" {
#endif

	// pure C API impl
    int add(int a, int b)
    {
        return a + b;
    }

    float addf(float a, float b)
    {
        return a + b;
    }

    void print_point(Point* p)
    {
        if (p)
            printf("position x %f y %f \n", p->x, p->y);
    }


	// warpper for c++ class
    void wrapper_init_class(int id)
	{
		my = new MyClass(id);
	}

    void wrapper_free_class()
	{
		if (my)
		{
			delete my;
		}
	}

    int wrapper_add(int a, int b)
	{
		return my->add(a,b);
	}

    float wrapper_addf(float a, float b)
	{
		return my->addf(a,b);
	}

    void wrapper_print_point(Point* p)
	{
		return my->print_point(p);
	}

//(1) bgr, hwc, 0-255    h*W*C+w*C+c     int index = h*im.W*im.C + (w*im.C + c); 
	//(2) bgr, chw, 0-255    c*H*W+h*W+w     int index = c*im.H*im.W + (h*im.W + w);

	float get_image_pixel_hwc(const image_float_t& im, int h, int w, int c)
	{
		//(1) bgr, hwc, 0-255    h*W*C+w*C+c     int index = h*im.W*im.C + (w*im.C + c); 
		int index = h*im.W*im.C + (w*im.C + c); 
		return im.data[index];
	}

	float get_image_pixel_chw(const image_float_t& im, int h, int w, int c)
	{
		//(2) bgr, chw, 0-255    c*H*W+h*W+w     int index = c*im.H*im.W + (h*im.W + w);
		int index = c*im.H*im.W + (h*im.W + w);
		return im.data[index];
	}

	cv::Mat image_float_to_mat(const image_float_t& im)
	{
		// bgr,hwc, 0-255
		cv::Mat mat(im.H, im.W, CV_8UC3);
		for(int h=0; h< im.H; ++h)
		{
			cv::Vec3b *p = mat.ptr<cv::Vec3b>(h);
			for(int w=0; w < im.W; ++w)
			{
				for(int c=0; c< im.C; ++c)
				{
					// b,g,r
					(*p)[c] = (unsigned char)get_image_pixel_hwc(im, h, w, c); 
				}
				p++;
			}
		}
		return mat;
	}

	// same as image_float_to_mat, but faster
	cv::Mat image_float_to_mat2(const image_float_t& im)
	{
		// bgr,hwc, 0-255
		cv::Mat mat(im.H, im.W, CV_8UC3);
		const float* p_data = im.data;

		for(int h=0; h< im.H; ++h)
		{
			cv::Vec3b *p = mat.ptr<cv::Vec3b>(h);
			for(int w=0; w < im.W; ++w)
			{
				for(int c=0; c< im.C; ++c)
				{
					// b,g,r
					(*p)[c] = (unsigned char)(*p_data++); 
				}
				p++; // for width
			}
		}
		return mat;
	}


	cv::Mat image_char_to_mat(const image_char_t& im)
	{
		// bgr,hwc, 0-255
		cv::Mat mat(im.H, im.W, CV_8UC3, im.data);
		return mat; // data in python
	}

    void process_image_float(image_float_t im)
	{
		cv::Mat mat = image_float_to_mat2(im);

		cv::imwrite("result2.jpg", mat);
		std::cout<<" saved image to result.jpg"<< std::endl;
	}

	void process_image_char(image_char_t im)
	{
		cv::Mat mat = image_char_to_mat(im);

		cv::imwrite("result3.jpg", mat);
		std::cout<<" saved image to result.jpg"<< std::endl;
	}

#ifdef __cplusplus	
}
#endif 

#pragma once

typedef struct {
    int H;
    int W;
    int C;
    unsigned char *data;
} image_char_t;


#ifdef __cplusplus
extern "C" {
#endif

    SHARED_EXPORT void process_image_char(image_char_t im);

#ifdef __cplusplus	
}
#endif 

#include "api.h"

#include <opencv2/opencv.hpp>  // Mat
#include <opencv2/imgproc.hpp> // cvtColor
#include <opencv2/highgui.hpp> // imdecode imshow


#ifdef __cplusplus
extern "C" {
#endif

	void process_image_char(image_char_t im)
	{
		cv::Mat mat(im.H, im.W, CV_8UC3, im.data);

		cv::imwrite("result.jpg", mat);
		std::cout<<" saved image to result.jpg"<< std::endl;
	}

#ifdef __cplusplus	
}
#endif 

std::string table_filepath = "./table_f.bin";
std::ifstream ifs(table_filepath, std::ifstream::binary);
int rows = 4;
int cols = 5; // xy

for(int y=0; y<rows; ++y)
{
	for(int x=0;x<cols;++x)
	{
		float distance_x;
		ifs.read(reinterpret_cast<char*>(&distance_x), sizeof(float)); 
		std::cout<< distance_x << std::endl;

		float distance_y;
		ifs.read(reinterpret_cast<char*>(&distance_y), sizeof(float)); 
		std::cout<< distance_y << std::endl;
	}
}
ifs.close();