C++和OpenGl实现的三维雷达波形模糊函数

原创 于 2018-09-13 19:51:21 发布 · 2.6k 阅读 · 17 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#C

本文介绍了如何使用C++和OpenGL来实现雷达波形的三维模糊函数，强调了模糊函数在雷达波形分析中的重要性，如分辨率和副瓣性能评估。作者分享了自己编写的OpenGL程序，该程序能够在MFC面板中运行，并提供优于MATLAB的视觉效果。程序源代码可在GitHub上获取，支持线性调频、二相编码和Frank等多种码信号的模糊函数绘制。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

模糊函数(Ambiguity Function，AF)是评价雷达波形优劣和进行波形分析的基本工具。它可以清晰直观的描述波形与对应匹配滤波器的特征。模糊函数在分析距离/速度分辨率、距离/多普勒模糊和副瓣性能方面应用广泛。

上面这句话粘自很多年前的硕士论文，在写这篇博客时，本人已经不搞雷达很多年，由于需要评价雷达发射波形的优劣，需要对设计波形进行模糊函数评价，借助matlab可以直接画出模糊函数图，而本人一贯不爱用matlab，所以看了两本OpenGl教材后，自己写了个模糊函数三维程序，基本思路就是按照幅度由低到高依次设置蓝/青/绿/黄/红，然后根据三点计算法线方向，设置光照，生成三维效果秒杀matlab，由于这个程序需要集成在mfc中，所以将mfc的panel控件作为整个OpenGl画布。代码如下：全部程序可以到我的GitHub主页下载，里面还包括遗传算法的具体实现。先贴几张效果图吧，可以生成线性调频/二相编码/Frank等多项码信号的模糊函数。

这个程序多年前写的，代码写的很垃圾，也没有很多注释，只是实现了功能，整个程序vs2008和vs2010都可以调试通过（需要先配置好OpenGl安装环境）

1.AmbiguityFunction.h

 /* Copyright (c) 2011-2013 Zhang Zhao(ZZ), zhangzhao0907@163.com
 *
 /*****************************************************************************
 *                               AmbiguityFunction.h
 *模糊函数类的头文件
 * Zhang Zhao, 2011-2013
 *****************************************************************************/

#pragma once

struct DataAF{
	double x;
	double z;
	double h;
};

class AmbiguityFunction
{
public:
	int i;
	int SignalChoose;
	DataAF Data[200][200];
public:
	AmbiguityFunction(void);
	AmbiguityFunction(int index);
	~AmbiguityFunction(void);

	void initDataSinalPulse(float pulseWidth=1,float Dopller=5);
	void initDataLFM(float pulseWidth=1,float Dopller=5);
	void initDataPulseSeries(float pulseWidth,float Dopller,float pulsePri,int N);
	void initDataPhaseCode(float pulseWidth,float Dopller, double Code[],int N);
	void initDataMultiPhaseCode(float pulseWidth,float Dopller, double Code[],int N);
	void initDataFrankPhaseCode(float pulseWidth,float Dopller, double Code[],int N);

	double GetMax(); 
	double GetMin();
	double SiglePulse(double T0,double T,double fd);
	double LFM(double T0,double T,double fd,double FM);
	double PulseSeries(double T0,double T,double fd,float TPri,int N);
	double PhaseCode(float t1,float td,float fd,double Code[],int N);
	double MultiPhaseCode(float t1,float td,float fd,double Code[],int N);
	double FrankPhaseCode(float t1,float td,float fd,double Code[],int N);
};

2.AmbiguityFunction.cpp

 /* Copyright (c) 2011-2013 Zhang Zhao(ZZ), zhangzhao0907@163.com
 *
 /*****************************************************************************
 *                               AmbiguityFunction.cpp
 *模糊函数类的实现文件
 * Zhang Zhao, 2011-2013
 *****************************************************************************/


#include "StdAfx.h"
#include "math.h"
#include "AmbiguityFunction.h"
#include "Complex.h"

#define pi 3.1415926

AmbiguityFunction::AmbiguityFunction(void)
{
	i=0;
	SignalChoose=0;
}

AmbiguityFunction::AmbiguityFunction(int index)
{
    i=index;
}

AmbiguityFunction::~AmbiguityFunction(void)
{
}

void AmbiguityFunction::initDataSinalPulse(float pulseWidth,float Dopller) 
{
	for (int i = 0;i<200;i++)
	{
		for (int j = 0;j<200;j++)
		{
			double measure=0.01;
			double x_m=measure*pulseWidth;
			double z_m=measure*Dopller;
			Data[i][j].x = i*x_m-100*x_m;
			Data[i][j].z = j*z_m-100*z_m;

			Data[i][j].h=2*SiglePulse(pulseWidth,Data[i][j].x,Data[i][j].z);

			Data[i][j].x/=pulseWidth;
			Data[i][j].z/=Dopller;
		}
	}
}


void AmbiguityFunction::initDataLFM(float pulseWidth,float Dopller)
{
	for (int i = 0;i<200;i++)
	{
		for (int j = 0;j<200;j++)
		{
			double measure=0.01;
			double x_m=measure*pulseWidth;
			double z_m=measure*Dopller;
			Data[i][j].x = i*x_m-100*x_m;
			Data[i][j].z = j*z_m-100*z_m;
			Data[i][j].h=2*LFM(pulseWidth,Data[i][j].x,Data[i][j].z,Dopller/pulseWidth);
			Data[i][j].x/=pulseWidth;
			Data[i][j].z/=Dopller;
		}
	}
}



void AmbiguityFunction::initDataPulseSeries(float pulseWidth,float Dopller,float pulsePri,int N)
{
	for (int i = 0;i<200;i++)
	{
		for (int j = 0;j<200;j++)
		{
			double measure=0.01;
			double x_m=measure*((pulsePri*(N-1))+0.133);
			double z_m=measure*(Dopller+0.133);
			Data[i][j].x = i*x_m-100*x_m;
			Data[i][j].z = j*z_m-100*z_m;
			Data[i][j].h=2*PulseSeries(pulseWidth,Data[i][j].x,Data[i][j].z,pulsePri,N);
			Data[i][j].x/=((pulsePri*(N-1))+0.133);
			Data[i][j].z/=(Dopller+0.133);
			//Trace("%f,%f,%f",Data[i][j].x,Data[i][j].x,Data[i][j].x);
		}
	}
}


double AmbiguityFunction::GetMax()
{
	double TmpMax = Data[0][0].h;
	for (int i = 0;i<200;i++)
	{
		for (int j=0;j<200;j++)
		{
			TmpMax = max((double)Data[i][j].h,(double)TmpMax);
		}
	}
	return TmpMax;
}

double AmbiguityFunction::GetMin() 
{
	double Tmpmin = Data[0][0].h;

	for (int i = 0;i<200;i++)
	{
		for (int j=0;j<200;j++)
		{
			Tmpmin = min((double)Data[i][j].h,(double)Tmpmin);
		}
	}
	return Tmpmin;
}

double AmbiguityFunction::SiglePulse(double T0,double T, double fd)
{
		double TempT=1-fabs(T)/T0;
		double TempTC=pi*fd*(T0-fabs(T));
		double TempSin;
		double eps=0.000001;

		TempSin=sin(TempTC+eps);
		TempSin/=(TempTC+eps);

		return fabs(TempSin*TempT);//*(TempSin*TempT);
}

double AmbiguityFunction::LFM(double T0,double T, double fd,double FM)
{
		double TempT=1-fabs(T)/T0;
		double TempTC=pi*T0*(FM*T+fd)*TempT;
		double TempSin;
		if(TempTC==0.0)
			TempSin=1;
		else
		{
			TempSin=sin(TempTC);
			TempSin/=TempTC;
		}
		return fabs(TempSin*TempT);//*(TempSin*TempT);
}



double AmbiguityFunction::PulseSeries(double T0,double T,double fd,float TPri,int N)
{
	double AmbiValue=0.0;
	double TempLeft;
	double TempRight;
	double eps=0.000001;

	for(int q=-(N-1);q<=N-1;q++)
	{
		double TempC=pi*fd*(N-fabs((double)q)*TPri);
		double TempSin=sin(TempC+eps);

		double fm=(pi*fd*TPri);
		double fmSin=sin(fm+eps);

		TempRight=TempSin/fmSin;

		if(TempRight==1)
			TempRight=(N-fabs((double)q)*TPri)/TPri;

		TempRight=fabs(TempRight);

		if(fabs(T-q*TPri)<=T0)
		{
			TempLeft=SiglePulse(T0,T-q*TPri,fd);
			AmbiValue+=(TempRight*TempLeft);
		}

	}
	AmbiValue/=N;

	return fabs (AmbiValue);
}




void AmbiguityFunction::initDataPhaseCode(float pulseWidth,float Dopller,double Code[],int N)   //N为子脉冲个数，pulseWidth为子脉冲宽度
{
	for (int i = 0;i<200;i++)
	{
		for (int j = 0;j<200;j++)
		{
			double measure=0.01;
			double x_m=measure*pulseWidth*N;
			double z_m=measure*Dopller;
			Data[i][j].x = i*x_m-100*x_m;
			Data[i][j].z = j*z_m-100*z_m;

			Data[i][j].h=2*PhaseCode(pulseWidth,Data[i][j].x,Data[i][j].z,Code,N);

			Data[i][j].x/=(pulseWidth*N);
			Data[i][j].z/=Dopller;
		}
	}
}





double AmbiguityFunction::PhaseCode (float t1,float td,float fd,double Code[],int N)
{
	double AmbiValue=0.0;
	Complex Value;
	Complex TempLeft;
	Complex TempRight;

	/////////////////////////////////////////////////////计算第一个公式的值，为复数
	for(int m=-(N-1);m<=N-1;m++)
	{
		if(fabs(td-m*t1)<=t1)
		{
			double sinC=pi*fd*(t1-fabs(td-m*t1));
			double sinValue=sin(sinC);
			double middle=sinValue/sinC;            //中间值

			if(sinC==0)
				middle=1;

            double right=(t1-fabs(td-m*t1))/t1;     //右边值

			double ejC=pi*fd*(t1-(td-m*t1));
			Complex ejLeft;
			ejLeft.ej (ejC);
			TempLeft=ejLeft*(middle*right);
		}
		else
		{
			TempLeft.SetVal(0,0);
		}


		/////////////////////////////////////////////////////计算第二个公式的值，为复数
		if(m>=0)
		{
			TempRight.SetVal (0,0);
			for(int k=0;k<=N-1-m;k++)
			{
				double ejC=2*pi*fd*k*t1;
				Complex ejRight;
				ejRight.ej(ejC);
				double Ck=Code[k]*Code[k+m];
				//ejRight=ejRight*Ck;
				TempRight+=(ejRight*Ck);
			}
			TempRight/=N;
		}
		else
		{
			TempRight.SetVal (0,0);
			for(int k=-m;k<=N-1;k++)
			{
				d
最低0.47元/天 解锁文章

200万优质内容无限畅学
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值