Разработка программно-математического обеспечения корреляционного совмещения изображений с использованием быстрого преобразования Фурье

Текст модуля Unit1_log.h:

//---------------------------------------------------------------------------

#ifndef Unit1_logH

#define Unit1_logH

//---------------------------------------------------------------------------

#include <Classes.hpp>

#include <Controls.hpp>

#include <StdCtrls.hpp>

#include <Forms.hpp>

#include <ExtCtrls.hpp>

#include <Dialogs.hpp>

#include <ExtDlgs.hpp>

#include <ComCtrls.hpp>

#include <Menus.hpp>

//---------------------------------------------------------------------------

class TForm1 : public TForm

{

__published: // IDE-managed Components

TOpenPictureDialog *OpenPictureDialog1;

TRadioButton *RadioButton1;

TGroupBox *GroupBox1;

TButton *Button1;

TImage *Image1;

TGroupBox *GroupBox2;

TImage *Image5;

TImage *Image6;

TButton *Button4;

TButton *Button5;

TEdit *Edit1;

TEdit *Edit2;

TGroupBox *GroupBox3;

TButton *Button2;

TButton *Button3;

TImage *Image2;

TImage *Image3;

TImage *Image4;

TLabel *Label1;

TLabel *Label2;

TMainMenu *MainMenu1;

TMenuItem *N1;

TMenuItem *N2;

TMenuItem *N3;

TMenuItem *N4;

TMenuItem *N5;

TMenuItem *N6;

TMenuItem *N7;

TMenuItem *N8;

TMenuItem *N9;

TMenuItem *N10;

TMenuItem *N11;

TMenuItem *N12;

TMenuItem *N13;

TButton *Button6;

TSavePictureDialog *SavePictureDialog1;

TButton *Button7;

void __fastcall Button1Click(TObject *Sender);

void __fastcall Button2Click(TObject *Sender);

void __fastcall Button3Click(TObject *Sender);

void __fastcall FormCreate(TObject *Sender);

void __fastcall Button4Click(TObject *Sender);

void __fastcall Button5Click(TObject *Sender);

void __fastcall N4Click(TObject *Sender);

void __fastcall N2Click(TObject *Sender);

void __fastcall N6Click(TObject *Sender);

void __fastcall N7Click(TObject *Sender);

void __fastcall N9Click(TObject *Sender);

void __fastcall N10Click(TObject *Sender);

void __fastcall N13Click(TObject *Sender);

void __fastcall Button7Click(TObject *Sender);

void __fastcall Button6Click(TObject *Sender);

private: // User declarations

public: // User declarations

__fastcall TForm1(TComponent* Owner);

};

//---------------------------------------------------------------------------

extern PACKAGE TForm1 *Form1;

//---------------------------------------------------------------------------

#endif

Текст модуля Unit1_log.cpp:

//---------------------------------------------------------------------------

#include <vcl.h>

#pragma hdrstop

#include "io.h"

#include "fcntl.h"

#include "unit1_log.h"

#include "math.h"

#include "stdio.h"

#include "Unit1_log.h"

//---------------------------------------------------------------------------

#pragma package(smart_init)

#pragma resource "*.dfm"

TForm1 *Form1;

typedef

PBMP_Arr [160000];

PBMP_Arr *Ptr0; // исходное РЛС-изображение

PBMP_Arr *Ptr1; // Фурье-образ РЛС-изображения (A)

PBMP_Arr *Ptr2; // Фурье-образ РЛС-изображения (B)

PBMP_Arr *Ptr3; // восстановленное РЛС-изображение

typedef struct {

TLogPalette lpal;

TPaletteEntry dummy[256];

} LogPal;

int i_c;

int i_c2;

int kol_k;

int f1;

unsigned char f[160000]; // исходное РЛС-изображение

long double f1_v[160000]; // восстановленное РЛС-изображение

unsigned char f1_vc[160000]; // восстановленное РЛС-изображение

unsigned char f2[160000]; // ? --

unsigned char f7[160000]; // ? массив фрагмента для контура корреляции

// Переменные для Фурье-образа РЛС

long double a1_tmp; // промежуточная переменная

long double a2_tmp; // промежуточная переменная

long double b1_tmp; // промежуточная переменная

long double b2_tmp; // промежуточная переменная

long double a_new[400][400]; // А-Фурье (РЛС)

long double b_new[400][400]; // В-Фурье (РЛС)

unsigned char a_new_uc[400][400]; // А-Фурье (РЛС) 256гр

unsigned char b_new_uc[400][400]; // В-Фурье (РЛС) 256гр

unsigned char a_new_uc_tmp[160000];// А-Фурье (РЛС) 256гр - одном

unsigned char b_new_uc_tmp[160000];// В-Фурье (РЛС) 256гр - одном

// Переменные для Фурье-образа А-Д

long double a1_tmp2; // промежуточная переменная

long double a2_tmp2; // промежуточная переменная

long double b1_tmp2; // промежуточная переменная

long double b2_tmp2; // промежуточная переменная

long double a_new2[400][400]; // А-Фурье (А-Д)

long double b_new2[400][400]; // В-Фурье (А-Д)

unsigned char a_new_uc2[400][400]; // А-Фурье (А-Д) 256гр

unsigned char b_new_uc2[400][400]; // В-Фурье (А-Д) 256гр

unsigned char a_new_uc_tmp2[160000];// А-Фурье (А-Д) 256гр - одном

unsigned char b_new_uc_tmp2[160000];// В-Фурье (А-Д) 256гр - одном

int i1, i2, i, j;

unsigned char f_new[400][400];

long double korr_b[160000]; // корр

long double korr_b_tmp[400][400];

unsigned char korr_b_uc[160000];//

long double korr_b_max;

int pik_a_x;

int pik_a_y;

int pik_b_x;

int pik_b_y;

int pik_a;

int pik_b;

int k,l;

Graphics::TBitmap *Bmp0 = new Graphics::TBitmap();

Graphics::TBitmap *Bmp1 = new Graphics::TBitmap();

Graphics::TBitmap *Bmp2 = new Graphics::TBitmap();

Graphics::TBitmap *Bmp3 = new Graphics::TBitmap();

//---------------------------------------------------------------------------

void __fastcall TForm1::FormCreate(TObject *Sender)

{

//Запрещение выполнения операций до загрузки исходного РЛИ

Button2->Enabled=false;

Button3->Enabled=false;

Button4->Enabled=false;

Button5->Enabled=false;

Button6->Enabled=false;

Button7->Enabled=false;

N6->Enabled=false;

N7->Enabled=false;

N9->Enabled=false;

N10->Enabled=false;

}

//---------------------------------------------------------------------------

__fastcall TForm1::TForm1(TComponent* Owner)

: TForm(Owner)

{

}

//---------------------------------------------------------------------------

void __fastcall TForm1::Button1Click(TObject *Sender)

{ //Окрытие исходного изображения

try

{

if (OpenPictureDialog1->Execute())

Bmp0->LoadFromFile(OpenPictureDialog1->FileName);

Bmp0->PixelFormat = pf8bit;

Ptr0 = (PBMP_Arr *)Bmp0->ScanLine[Bmp0->Height-1];

for (i_c=Bmp0->Height-1;i_c>=0;i_c--)

CopyMemory((void *)&f[Bmp0->Width*i_c],Bmp0->ScanLine[i_c],Bmp0->Width);

Image1->Width = Bmp0->Width;

Image1->Height = Bmp0->Height;

Image1->Canvas->Draw(0,0, Bmp0);

//разрешение выполнения операций

Button2->Enabled=true;

Button4->Enabled=true;

Button5->Enabled=true;

N6->Enabled=true;

N9->Enabled=true;

N10->Enabled=true;

//Загрузка исходного РЛИ в соответствующих массив

i = 0;

for (i1=0;i1<Bmp0->Height;i1++)

{

for (i2=0;i2<Bmp0->Width;i2++)

{

if (RadioButton1->Checked == True)

{

f_new[i1][i2] = 0x01 && f[i];

f2[i] = 0x01 && f[i];

}

else

{

f_new[i1][i2] = f[i];

f2[i] = f[i];

}

i++;

}

}

}

//обработка попытки открытия изображения неподходящего формата

catch(Exception *ex)

{

MessageBox(NULL, "Выбран неверный формат изображения", "Ошибка!", MB_OK | MB_ICONERROR);

}

}

//---------------------------------------------------------------------------

void __fastcall TForm1::Button2Click(TObject *Sender)

{

//разрешение выполнения операций

Button3->Enabled=true;

Button6->Enabled=true;

Button7->Enabled=true;

N7->Enabled=true;

//основной цикл Фурье-преобразования

//Более подробное описание - в пояснительной записке

//к дипломному проекту

kol_k = 100;

for (k=0;k<Bmp0->Height;k++)

{

for (l=0;l<Bmp0->Width;l++)

{

a1_tmp = 0;

b1_tmp = 0;

for (i1=0;i1<Bmp0->Height;i1++)

{

a2_tmp = 0;

b2_tmp = 0;

for (i2=0;i2<Bmp0->Width;i2++)

{

a2_tmp = a2_tmp + f_new[i1][i2]*cos(2*M_PI*k*i1/Bmp0->Height + 2*M_PI*l*i2/Bmp0->Width);

b2_tmp = b2_tmp + f_new[i1][i2]*sin(2*M_PI*k*i1/Bmp0->Height + 2*M_PI*l*i2/Bmp0->Width);

}

a1_tmp = a1_tmp + a2_tmp;

b1_tmp = b1_tmp + b2_tmp;

}

a_new[k][l] = a1_tmp / Bmp0->Height / Bmp0->Width;

b_new[k][l] = b1_tmp * (-1) / Bmp0->Height / Bmp0->Width;

}

}

i = 0;

for (i1=0;i1<Bmp0->Height;i1++)

for (i2=0;i2<Bmp0->Width;i2++)

{

a_new_uc[i1][i2] = floor(a_new[i1][i2] + 0.5);

a_new_uc_tmp[i] = a_new_uc[i1][i2];

b_new_uc[i1][i2] = floor(b_new[i1][i2] + 0.5);

b_new_uc_tmp[i] = b_new_uc[i1][i2];

i++;

}

// Вывод коэффициента A в графической форме

Bmp1->PixelFormat = pf8bit; //формат

Bmp1->Width = Bmp0->Width; //ширина

Bmp1->Height = Bmp0->Height;//высота

Ptr1 = (PBMP_Arr *)Bmp1->ScanLine[Bmp1->Height-1];

LogPal SysPal;

TCanvas *tempCanvas = new TCanvas;

HWND notUsed;

tempCanvas->Handle = GetDeviceContext(notUsed);

SysPal.lpal.palVersion = 0x300;

SysPal.lpal.palNumEntries = 256;

GetSystemPaletteEntries(tempCanvas->Handle,0,256,SysPal.lpal.palPalEntry);

for(i=0;i<=255;i++)

{

SysPal.lpal.palPalEntry[i].peRed = i; //красный канал

SysPal.lpal.palPalEntry[i].peGreen = i;//зеленый канал

SysPal.lpal.palPalEntry[i].peBlue = i; //синий канал

}

Bmp1->Palette = CreatePalette((const tagLOGPALETTE *)&SysPal.lpal);

Ptr1 = (PBMP_Arr *)Bmp1->ScanLine[Bmp1->Height-1];

for (i_c=Bmp0->Height-1;i_c>=0;i_c--)

CopyMemory(Bmp1->ScanLine[i_c],(void *)&a_new_uc_tmp[(Bmp1->Width)*i_c],Bmp1->Width);

Image2->Width = Bmp0->Width;

Image2->Height = Bmp0->Height;

Image2->Canvas->Draw(0,0, Bmp1);

// Вывод коэффициента B

Bmp2->PixelFormat = pf8bit; //формат

Bmp2->Width = Bmp0->Width; //ширина

Bmp2->Height = Bmp0->Height;//высота

Ptr2 = (PBMP_Arr *)Bmp2->ScanLine[Bmp2->Height-1];

LogPal SysPal2;

TCanvas *tempCanvas2 = new TCanvas;

HWND notUsed2;

tempCanvas2->Handle = GetDeviceContext(notUsed2);

SysPal2.lpal.palVersion = 0x300;

SysPal2.lpal.palNumEntries = 256;

GetSystemPaletteEntries(tempCanvas2->Handle,0,256,SysPal2.lpal.palPalEntry);

for(i=0;i<=255;i++)

{

SysPal2.lpal.palPalEntry[i].peRed = i; //красный канал

SysPal2.lpal.palPalEntry[i].peGreen = i;//зеленый канал

SysPal2.lpal.palPalEntry[i].peBlue = i; //синий канал

}

Bmp2->Palette = CreatePalette((const tagLOGPALETTE *)&SysPal2.lpal);

Ptr2 = (PBMP_Arr *)Bmp2->ScanLine[Bmp2->Height-1];

for (i_c=Bmp0->Height-1;i_c>=0;i_c--)

CopyMemory(Bmp2->ScanLine[i_c],(void *)&b_new_uc_tmp[(Bmp2->Width)*i_c],Bmp2->Width);

Image3->Width = Bmp0->Width;

Image3->Height = Bmp0->Height;

Image3->Canvas->Draw(0,0, Bmp2);

}

//---------------------------------------------------------------------------

void __fastcall TForm1::Button3Click(TObject *Sender)

{ // восстановление РЛИ

// Обратное Фурье-преобразование

i1 = 0;

i2 = 0;

i = 0;

for(i1=0;i1<Bmp0->Height;i1++)

{

for(i2=0;i2<Bmp0->Width;i2++)

{

f1_v[i1*Bmp0->Width + i2] = 0;

for (k=0;k<Bmp0->Height;k++)

{

for (l=0;l<Bmp0->Width;l++)

{

f1_v[i1*Bmp0->Width + i2] = f1_v[i1*Bmp0->Width + i2] +

a_new[k][l] * cos(2*M_PI*k*i1/Bmp0->Height + 2*M_PI*l*i2/Bmp0->Width) -

b_new[k][l] * sin(2*M_PI*k*i1/Bmp0->Height + 2*M_PI*l*i2/Bmp0->Width);

}

}

f1_v[i1*Bmp0->Width + i2] = f1_v[i1*Bmp0->Width + i2] * 1 ;

}

}

// восстановление РЛИ

// визуальное отображение восстановленного РЛИ

long int tmp_x;

if (RadioButton1->Checked == True)

{

for (i=0;i<(Bmp0->Height)*(Bmp0->Width);i++)

{

f1_vc[i] = floor (f1_v[i] + 0.5) * 256; //

if (f1_vc[i] > 255) f1_vc[i] = 255;

}

}

else

{

for (i=0;i<(Bmp0->Height)*(Bmp0->Width);i++)

{

f1_vc[i] = floor (f1_v[i] + 0.5); // * 255

}

}

// Вывод восстановленного РЛИ

Bmp3->PixelFormat = pf8bit;

Bmp3->Width = Bmp0->Width; //ширина

Bmp3->Height = Bmp0->Height;

Ptr3 = (PBMP_Arr *)Bmp3->ScanLine[Bmp3->Height-1];

LogPal SysPal3;

TCanvas *tempCanvas3 = new TCanvas;

HWND notUsed3;

tempCanvas3->Handle = GetDeviceContext(notUsed3);

SysPal3.lpal.palVersion = 0x300;

SysPal3.lpal.palNumEntries = 256;

GetSystemPaletteEntries(tempCanvas3->Handle,0,256,SysPal3.lpal.palPalEntry);

for(i=0;i<=255;i++)

{

SysPal3.lpal.palPalEntry[i].peRed = i;

SysPal3.lpal.palPalEntry[i].peGreen = i;

SysPal3.lpal.palPalEntry[i].peBlue = i;

}

Bmp3->Palette = CreatePalette((const tagLOGPALETTE *)&SysPal3.lpal);

Ptr3 = (PBMP_Arr *)Bmp3->ScanLine[Bmp3->Height-1];

for (i_c=Bmp0->Height-1;i_c>=0;i_c--)

CopyMemory(Bmp3->ScanLine[i_c],(void *)&f1_vc[(Bmp3->Width)*i_c],Bmp3->Width);

Image4->Width = Bmp0->Width;

Image4->Height = Bmp0->Height;

Image4->Canvas->Draw(0,0, Bmp3);

}

//---------------------------------------------------------------------------

void __fastcall TForm1::Button4Click(TObject *Sender)

{

//Процедура поворота РЛИ на произвольный угол

try{

int angle=StrToFloat(Edit1->Text); //угол поворота

Graphics::TBitmap *SrcBitmap=new Graphics::TBitmap;

Graphics::TBitmap *DestBitmap=new Graphics::TBitmap;

SrcBitmap=Image1->Picture->Bitmap;

// преобразуем градусы в радианы

float radians=(2*3.1416*angle)/360;

float cosine=(float)cos(radians);

float sine=(float)sin(radians);

float Point1x=(-SrcBitmap->Height*sine);

float Point1y=(SrcBitmap->Height*cosine);

float Point2x=(SrcBitmap->Width*cosine-SrcBitmap->Height*sine);

float Point2y=(SrcBitmap->Height*cosine+SrcBitmap->Width*sine);

float Point3x=(SrcBitmap->Width*cosine);

float Point3y=(SrcBitmap->Width*sine);

//Расчет координат результирующего изображения

float minx=0;

if (minx>Point1x)

{minx=Point1x;}

if (minx>Point2x)

{minx=Point2x;}

if (minx>Point3x)

{minx=Point3x;}

//Расчет координат результирующего изображения

float miny=0;

if (miny>Point1y)

{miny=Point1y;}

if (miny>Point2y)

{miny=Point2y;}

if (miny>Point3y)

{miny=Point3y;}

//Расчет координат результирующего изображения

float maxx=Point1x;

if (maxx<Point2x)

{maxx=Point2x;}

if (maxx<Point3x)

{maxx=Point3x;}

//Расчет координат результирующего изображения

float maxy=Point1y;

if (maxy<Point2y)

{maxy=Point2y;}

if (maxy<Point3y)

{maxy=Point3y;}

//Расчет координат результирующего изображения

int DestBitmapWidth=2*(int)ceil(maxx-minx);

int DestBitmapHeight=2*(int)ceil(maxy-miny);

DestBitmap->Height=DestBitmapHeight;

DestBitmap->Width=DestBitmapWidth;

//отображение повернутого РЛИ

for(int x=0;x<DestBitmapWidth;x++)

{

for(int y=0;y<DestBitmapHeight;y++)

{

int SrcBitmapx=(int)((x+minx)*cosine+(y+miny)*sine);

int SrcBitmapy=(int)((y+miny)*cosine-(x+minx)*sine);

if(SrcBitmapx>=0&&SrcBitmapx<SrcBitmap->Width&&SrcBitmapy>=0&&

SrcBitmapy<SrcBitmap->Height)

{

DestBitmap->Canvas->Pixels[x][y]=

SrcBitmap->Canvas->Pixels[SrcBitmapx][SrcBitmapy];

}

}

}

Image5->Picture->Bitmap=DestBitmap;

DestBitmap = NULL;

SrcBitmap = NULL;

}

catch(Exception *ex)

{

MessageBox(NULL, "Неверно задан угол поворота", "Ошибка!", MB_OK | MB_ICONERROR);

}

}

//---------------------------------------------------------------------------

void __fastcall TForm1::Button5Click(TObject *Sender)

{

//процедура масштабирования исходного РЛИ

try{

if (StrToFloat(Edit2->Text)>50 | StrToFloat(Edit2->Text)<0)

{MessageBox(NULL, "Масштаб слишком велик или мал", "Ошибка!", MB_OK | MB_ICONERROR);}

else {

for (int i=0; i<Image6->Width;i++)

{

for (int j=0; j<Image6->Height;j++)

{

Image6->Canvas->Pixels[i][j]=(255,255,255);

}

}

int WidthSource, HeightSource; // исходные размеры

int WidthDest, HeightDest; // конечные размеры

Graphics::TBitmap *sour = new Graphics::TBitmap();

Graphics::TBitmap *dest = new Graphics::TBitmap();

Image6->Height=Image1->Height*StrToFloat(Edit2->Text);

Image6->Width=Image1->Width*StrToFloat(Edit2->Text);

sour=Image1->Picture->Bitmap;

WidthSource = sour->Width;

HeightSource = sour->Height;