因为有matlab代码需要在opencv上实现，遇到了./的问题，在网上参考了许多代码，但是与matlab的结果不符，于是自己着手实现了一下，与matlab验证证明是正确的。
Mat cmplxDivision(Mat m1, Mat m2) {
int rows = m2.rows;//矩阵的行数以及列数
int cols = m2.cols;

Mat m1_2[2], m2_2[2];//用于存放矩阵的实部和虚部
Mat m1_rea, m1_ima, m2_rea, m2_ima;//用于分开存放实部和虚部，便于计算

split(m1, m1_2);
split(m2, m2_2);

m1_rea = m1_2[0];
m1_ima = m1_2[1];
m2_rea = m2_2[0];
m2_ima = m2_2[1];

Mat result1(rows, cols, CV_64FC1);//存放用于计算的实部
Mat result2(rows, cols, CV_64FC1);//存放用于计算的虚部
//(a+bi)/(c+di)=(ac+bd)/(c^2+d^2) +((bc-ad)/(c^2+d^2))i
for (int i = 0; i < rows; i++)
{
	for (int j = 0; j < cols; j++)
	{
		result1.at<double>(i, j) = (m1_rea.at<double>(i, j)*m2_rea.at<double>(i, j) + m1_ima.at<double>(i, j)*m2_ima.at<double>(i, j)) / (m2_rea.at<double>(i, j)*m2_rea.at<double>(i, j)+ m2_ima.at<double>(i, j)*m2_ima.at<double>(i, j));
		result2.at<double>(i, j) = (m1_ima.at<double>(i, j)*m2_rea.at<double>(i, j) - m1_rea.at<double>(i, j)*m2_ima.at<double>(i, j)) / (m2_rea.at<double>(i, j)*m2_rea.at<double>(i, j) + m2_ima.at<double>(i, j)*m2_ima.at<double>(i, j));
	}
}

Mat result_2[2] = { result1 ,result2 };
Mat result;
merge(result_2, 2, result);
return result;

}

实现复数类
**

【问题描述】
实现复数类

add-复数相加

sub-复数相减

mul-复数相乘

div- 复数相除
【样例输入】
1 2 3 4
【样例输出】
c1: 1 + 2i
c2: 3 + 4i
c3: 0 + 0i
c1+c2 = 4 + 6i
c1-c2 = -2 + -2i
c1*c2 = -5 + 10i
c1/c2 = 0.44 + 0.08i
#include <iostream>

using namespace std;

class ComplexNumber
{
private:
    double real,imaginary;
public:
    ComplexNumber();
    ComplexNumber(double ,double );
    double Getreal();
    double Getimaginary();
    ComplexNumber add(ComplexNumber );
    ComplexNumber sub(ComplexNumber );
    ComplexNumber mul(ComplexNumber );
    ComplexNumber div(ComplexNumber );
    void output();
};
ComplexNumber::ComplexNumber()
{
    cin>>real>>imaginary;
}
ComplexNumber::ComplexNumber(double r,double i)
{
    real=r;
    imaginary=i;
}
double ComplexNumber::Getreal()
{
    return real;
}
double ComplexNumber::Getimaginary()
{
    return imaginary;
}
ComplexNumber ComplexNumber:: add(ComplexNumber cn)
{
    ComplexNumber c;
    c.real=real+cn.real;
    c.imaginary=imaginary+cn.imaginary;
    return c;
}
ComplexNumber ComplexNumber:: sub(ComplexNumber cn)
{
    ComplexNumber c;
    c.real=real-cn.real;
    c.imaginary=imaginary-cn.imaginary;
    return c;
}
ComplexNumber ComplexNumber:: mul(ComplexNumber cn)
{
    ComplexNumber c;
    c.real=real*cn.real-imaginary*cn.imaginary;
    c.imaginary=imaginary*cn.real+real*cn.imaginary;
    return c;
}
ComplexNumber ComplexNumber:: div(ComplexNumber cn)
{
    ComplexNumber c;
    c.real=(real*cn.real+imaginary*cn.imaginary)/(cn.real*cn.real+cn.imaginary*cn.imaginary);
    c.imaginary=(imaginary*cn.real-real*cn.imaginary)/(cn.real*cn.real+cn.imaginary*cn.imaginary);
    return c;
}
void ComplexNumber::output()
{
    cout<<real<<" + "<<imaginary<<"i"<<endl;
}
int main()
{
   ComplexNumber c3(0,0);
   ComplexNumber c1,c2;
   cout<<"c1: ";
   c1.output();
   cout<<"c2: ";
   c2.output();
   cout<<"c3: ";
   c3.output();
   c3=c1.add(c2);
   cout<<"c1+c2 = ";
   c3.output();
   c3=c1.sub(c2);
   cout<<"c1-c2 = ";
   c3.output();
   c3=c1.mul(c2);
   cout<<"c1*c2 = ";
   c3.output();
   c3=c1.div(c2);
   cout<<"c1/c2 = ";
   c3.output();
    return 0;
}

2通道复数Mat的共轭

代码如下



cv::Mat conj4mat(cv::Mat src) {
        if (src.channels() != 2) {
            std::cout << "func CONJ4MAT : channels parameters error!" << std::endl;
            return Mat();
        }
        int cols = src.cols;// 表示x轴
        int rows = src.rows;// 表示y轴
        cv::Mat result = cv::Mat::zeros(cv::Size(cols, rows), CV_32FC2);
        /*核心思想：
            将图像按照每一行的顺序，进行展开，成为一个长的向量。
            例如一个Size(640,480)的图像，展开后，向量的长度为 640*480
        */
        std::vector<cv::Mat> channels;//用于存放实部和虚部，channels[0]存放的是实部，channels[1]存放的是虚部
        std::complex<double>* conj4mat = new std::complex<double>[cols * rows]; //用于存放展开后的复数向量
        std::complex<double> temp;
        cv::split(src, channels);
        int k = 0;//用于存放数据到复数数组里的索引，其最大值应该为 rows * cols
        double real = 0, imag = 0;

        //前向计算过程
        for (size_t i = 0; i < cols; i++) {
            for (size_t j = 0; j < rows; j++) {
                real = channels[0].at<float>(j, i);
                imag = channels[1].at<float>(j, i);
                temp = std::complex<double>(real, imag);

                conj4mat[k] = temp;
                k++;
            }
        }
        k = 0;
        std::complex<double> middle;
        //反向释放数据到Mat
        for (size_t i = 0; i < cols; i++) {
            for (size_t j = 0; j < rows; j++) {
                middle = std::conj(conj4mat[k]);
                real = middle.real();
                imag = middle.imag();
                channels[0].at<float>(j, i) = real;
                channels[1].at<float>(j, i) = imag;

                k++;
            }
        }

        // 将求得的结果合并为一个Mat
        merge(channels, result);
        return result;
    }



两个复数Mat的直积



cv::Mat cmplxMul(cv::Mat m1, cv::Mat m2) {
    //assert(m1.rows != m2.rows,"相乘矩阵的维度不一致");
    //assert(m1.cols != m2.cols,"相乘矩阵的维度不一致");

    int rows = m1.rows;//矩阵的行数以及列数
    int cols = m1.cols;

    cv::Mat result = cv::Mat::zeros(rows, cols,CV_32FC2);

    //用于存放实部[0]以及虚部[1]
    vector<Mat> channels_m1;
    vector<Mat> channels_m2;
    vector<Mat> channels_result;

    split(m1, channels_m1);
    split(m2, channels_m2);
    split(result, channels_result);

    //用于将矩阵形式的复数转换乘向量
    vector<std::complex<float>> complex_result;


    std::complex<float> m1_c;
    std::complex<float> m2_c;

    //分解m1以及m2中的复数
    for (size_t i = 0; i < rows; i++) {
        for (size_t j = 0; j < cols; j++) {
            m1_c = std::complex<float>(
                channels_m1[0].at<float>(i, j),
                channels_m1[1].at<float>(i, j));
            m2_c = std::complex<float>(
                channels_m2[0].at<float>(i, j),
                channels_m2[1].at<float>(i, j));
            complex_result.push_back(m1_c * m2_c);
        }
    }

    int k = 0;
    //反向释放数据到Mat
    for (size_t i = 0; i < rows; i++) {
        for (size_t j = 0; j < cols; j++) {
            channels_result[0].at<float>(i, j) = complex_result[k].real();
            channels_result[1].at<float>(i, j) = complex_result[k].imag();
            k++;
        }
    }

    merge(channels_result, result);

    return result;
}

两个复数Mat的对应位相除



cv::Mat cmplxDivision(cv::Mat m1, cv::Mat m2) {
    //assert(m1.rows != m2.rows,"相乘矩阵的维度不一致");
    //assert(m1.cols != m2.cols,"相乘矩阵的维度不一致");

    int rows = m1.rows;//矩阵的行数以及列数
    int cols = m1.cols;

    cv::Mat result = cv::Mat::zeros(rows, cols, CV_32FC2);

    //用于存放实部[0]以及虚部[1]
    vector<Mat> channels_m1;
    vector<Mat> channels_m2;
    vector<Mat> channels_result;

    split(m1, channels_m1);
    split(m2, channels_m2);
    split(result, channels_result);

    //用于将矩阵形式的复数转换乘向量
    vector<std::complex<float>> complex_result;

    std::complex<float> m1_c;
    std::complex<float> m2_c;

    //分解m1以及m2中的复数
    for (size_t i = 0; i < rows; i++) {
        for (size_t j = 0; j < cols; j++) {
            m1_c = std::complex<float>(
                channels_m1[0].at<float>(i, j),
                channels_m1[1].at<float>(i, j));
            m2_c = std::complex<float>(
                channels_m2[0].at<float>(i, j),
                channels_m2[1].at<float>(i, j));
            complex_result.push_back(m1_c / m2_c);
        }
    }
    int k = 0;
    //反向释放数据到Mat
    for (size_t i = 0; i < rows; i++) {
        for (size_t j = 0; j < cols; j++) {
            channels_result[0].at<float>(i, j) = complex_result[k].real();
            channels_result[1].at<float>(i, j) = complex_result[k].imag();
            k++;
        }
    }
    merge(channels_result, result);
    return result;
}

1.重载和实现复数相除
#include<iostream

using namespace std;

class  complex

{

public:

complex ()

{ real = 0; imag = 0; }

complex(double r, double i) { real = r; imag = i; }

complex operator / (complex &c2);

void display();

private:

double real;

double imag;

}；

complex complex:: operator / (complex &c2)

{

complex c;

c.real = (realc2.real + imag * c2.imag) / ((c2， real + c2.imag)(C2, real + c2.imag));

c.imag = (inagc2.real 一realc2 imag) / ((c2, real + c2.imag)*(c2, real + c2.inag));

return c;

}
void complex : : disp1ay()

{

cout << “(”<< real <<","<< imag << “i)” << endl ;

}
int main()

{

complex c1(3，9), c2(6, 4)，c3;

c3 = c1 / c2;

cout << “c1/c2=”;

c3.display();

return 0;

}
2.重载和实现复数相减
a.友元的加入
#include <iostream

using namespace std;

class complex

{

public:

complex() { real = 0; imag = 0; }

complex(double r, double i) { real = r; imag = i; }

friend complex operator - (complex &c1, complex &c2);

void display();

private:

double real;

double imag;
};
complex operator - (complex &c1, complex &c2)

{

return(c1.real - c2.real, c1.imag - c2.imag);

}

void complex::display()

{

cout<<"("<< real<<","<< imag << “i)” << endl;

}

int main()

{

complex c1(3, 9), c2(8, 7), c3;

c3 = c1 - c2;

cout << “c1-c2”;

c3.display();

return 0;

}
b.类的的成员函数
#include<iostream

using namespace std;

class complex

{

public:

complex() { real = 0; imag = 0; }

complex(double r, double i) { real = r; imag = i; }

complex operator - (complex &c2);

void display();

private:

double real;

double imag;
};
complex complex:: operator - (complex &c2)

{

complex c;

c.real = real + c2.real;

c.imag = imag + c2.imag;

return c;

}

void complex:: display()

{

cout<<"("<< real <<","<<imag << “i)”<<endl;

}

int main()

{

complex c1(3, 9), c2(8, 7), c3;

c3 = c1 - c2;

cout << “c1-c2=”;

c3.display();

return 0;

}