Название: Основы радиосвязи и телевидения (С.П. Новицкий, В.Н. Попантонопуло, )

Жанр: Технические

Просмотров: 779


Литература

(к лабораторной работе № 3)

 

Телевидение. Учебник для вузов / В.Е Джакония, А.А. Гоголь, Я.В. Друзин и др.; под ред. В.Е. Джаконии. – М.: Радио и связь, 2000. – 640 с.

Методы передачи изображений. Сокращение избыточности / Под ред. У.К. Прэтта. Перевод с англ. под ред. Л.С. Виленчика. – М.: Радио и связь, 1983, разд. 6.3. – 264 с.

Мамчев Г.В. Цифровое телевизионное вещание: Учеб. Посо-

бие. – Новосибирск: Изд-во СибГУТИ, 2001. – 198 с.

Прэтт У. Цифровая обработка изображений: Пер с англ. – М.: Мир, 1982. Кн. 1. – 312 с.; Кн. 2. – 480 с.

Птачек М. Цифровое телевидение. Теория и техника: Пер. с чешск. под ред. Л. С. Виленчика. – М.: Радио и связь, 1990. – 528 с.

Цифровое телевидение /Под ред М. И. Кривошеева. – М.: Связь, 1980. – 264 с.

Батист И. И., Новицкий С. П. Современные системы телевидения: Учеб. Пособие. – Ч. 2. – Новосибирск: Изд-во НГТУ, 1999. – 122 с.

Пат. 4937666 US, кл. Н 04 N 7/12, 1990; EP заявка А2, 0467040, кл. Н 04 N 7/137, 1991.

Пат. 2117412 РФ, кл. H 04 N 7/36 // БИ № 22, 1998.

Пат. 2217881 РФ. Способ определения подвижных и неподвижных блоков изображения и их кодирования (декодирования) при записи-передаче (воспроизведении) изображения / С.П. Новицкий,

В.Н. Попантонопуло, А.Л. Печников, В.В. Некрасов // БИ № 33, 2003.

Пат. 2219680 РФ. Устройство для определения подвижных и неподвижных блоков изображения и их кодирования декодирования) при записи-передаче (воспроизведении) изображения/ С.П. Новицкий,

В.Н. Попантонопуло А.Л. Печников, В.В. Некрасов // БИ № 35, 2003.

Ватолин Д.С. Алгоритмы сжатия изображений: Метод. посо-

бие. – М: – МГУ, 1999. – 76 с.

 

Приложение 3.1

 

БЛОК-СХЕМА АЛГОРИТМА ПОИСКА

В ПРЕДШЕСТВУЮЩЕМ КАДРЕ БЛОКА, ИДЕНТИЧНОГО ТЕКУЩЕМУ БЛОКУ ТЕКУЩЕГО КАДРА

 

 

Приложение 3.2

 

// Пример реализации на языке программирования С++

// блок-схемы алгоритма поиска схожих блоков

// смежных кадров изображения

 

//  1. Формирование массивов входных и выходных данных

 

// 1.1. Входные данные:

 

// 1) F2 – указатель на двумерный массив целых (int **),

// содержащий информацию о пикселях текущего кадра;

// 2) F1 – указатель на двумерный массив целых (int **),

// содержащий информацию о пикселях предыдущего кадра;

// 3) frszX*frszY – размеры кадров в пикселях(int);

// 4) blksz – размер блоков поиска в пикселях(int);

// 5) fldsz – размер поля поиска в блоках(int);

// 6) arsz – размер области попиксельного поиска в блоках(int);

// 7) tresh – величина порога(float).

 

// 1.2. Выходные данные:

 

// 1) Flag – указатель на массив флагов(int **);

// 2) R_adrX,R_adrY – указатели на массивы относительных адресов(int **);

// 3) P_adrX,P_adrY – указатели на массивы косвенных адресов(int **).

#include «math.h»

bool ALGFUNC( int **F2, int **F1, int frszX, int frszY, int blksz, int fldsz, int arsz, float tresh, int **FLAG, int **R_adrX, int **R_adrY, int **P_adrX, int **P_adrY)// Функция алгоритма

{

 

// 2. Расчет количества блоков в кадре по горизонтали и вертикали

 

int N_x=frszX/blksz;

int N_y=frszY/blksz;

// Разбиение текущего кадра на массив блоков>>>

// динамическое выделение памяти под массив блоков

int ****BC;

BC=new int ***[N_x];

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

{

BC[i]=new int**[N_y];

for(int j=0;j<N_y;j++)

{

BC[i][j]=new int *[blksz];

for(int k=0;k<blksz;k++)

{

BC[i][j][k]=new int [blksz];

} } }

 

//  3. Разбиение текущего кадра на блоки

 

for(int m=0;m<N_x;m++)

{

for(int n=0;n<N_y;n++)

{

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

{

for(int j=0;j<blksz;j++)

{

BC[m][n][i][j]=F2[m*(blksz-1)+i][n*(blksz-1)+j];

}}}}// <<<

 

//  4. Начало алгоритма поиска

 

for(int m=0;m<N_x;m++)

{

for(int n=0;n<N_y;n++)

{

// расчет координат текущего блока текущего кадра

int Xblk=m*blksz;

int Yblk=n*blksz;

// расчет координат поля поиска соответствующего текущему блоку текущего кадра

int Xfld=Xblk-(fldsz-blksz)/2;

int Yfld=Yblk-(fldsz-blksz)/2;

// формирование поля поиска предыдущего кадра >>>

// Динамическое выделение памяти под поле поиска

int **FLD;

FLD=new int *[fldsz];

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

{

FLD[i]=new int [fldsz];

}

 

// 5. Формирование поля поиска из предыдущего кадра

 

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

{

for(int j=0;j<fldsz;j++)

{

FLD[i][j]=F1[Xfld+i][Yfld+j];

} }// <<<

// расчет количества блоков в поле поиска по вертикали и горизонтали

int NF=fldsz/blksz;

// разбиение поля поиска на массив блоков предыдущего кадра>>>

// Динамическое выделение памяти под массив блоков

int ****BF;

BF=new int ***[NF];

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

{

BF[i]=new int**[NF];

for(int j=0;j<NF;j++)

{

BF[i][j]=new int *[blksz];

for(int k=0;k<blksz;k++)

{

BF[i][j][k]=new int [blksz];

} } }

// Разбиение поля поиска на блоки

for(int a=0;a<NF;a++)

{

for(int b=0;b<NF;b++)

{

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

{

for(int j=0;j<blksz;j++)

{

BF[a][b][i][j]=FLD[a*(blksz-1)+i][b*(blksz-1)+j];

} } }

}// <<<

// переменная для хранения минимальной ошибки сравнения float sg_min=10000.

 

//  6. Поблочный поиск

 

// Начало поблочного поиска

for(int a=0;a<NF;a++)

{

for(int b=0;b<NF;b++)

{

// переменная для накопления суммы квадратов разностей

float SUM=0;

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

{

for(int j=0;j<blksz;j++)

{

SUM+=(float)(BC[m][n][i][j]-BF[a][b][i][j])*

(float)(BC[m][n][i][j]-BF[a][b][i][j]);

} }

// расчет СКО

int sg=sqrt(SUM)/(blksz*blksz);

 

// сравнение ошибки сравнения с порогом

if(sg<tresh)

{

FLAG[m][n]=0x001;

R_adrX[m][n]=a;

R_adrY[m][n]=b;

goto END;

}

// сравнение с минимальной ошибкой сравнения

if(sg<sg_min)

{

sg_min=sg;

R_adrX[m][n]=a;

R_adrY[m][n]=b;

}

}

}// конец поблочного поиска

 

// 7. Расчет координат  блока  попиксельного  поиска  в  поле

//  предыдущего кадра с минимальной ошибкой сравнения

 

int Xmin=R_adrX[m][n]*blksz;

int Ymin=R_adrY[m][n]*blksz;

// расчет координат области попиксельного поиска

int Xar=Xmin-(arsz-blksz)/2;

int Yar=Ymin-(arsz-blksz)/2;

// формирование области попиксельного поиска предыдущего кадра >>>

// Динамическое выделение памяти под область попиксельного поиска

int **AR;

AR=new int *[arsz];

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

{

AR[i]=new int [arsz];

}

// формирование области попиксельного поиска из поля поиска

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

{

for(int j=0;j<arsz;j++)

{

AR[i][j]=FLD[Xar+i][Yar+j];

}

}// <<<

 

// 8. Расчет количества блоков в области попиксельного

//  поиска  предыдущего кадра по вертикали и горизонтали

 

// int NA=(arsz-blksz)+1;

// распространение области попиксельного поиска на массив блоков предыдущего кадра>>>

// Динамическое выделение памяти под массив блоков

int ****BA;

BA=new int ***[NA];

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

{

BA[i]=new int**[NA];

for(int j=0;j<NA;j++)

{

BA[i][j]=new int *[blksz];

for(int k=0;k<blksz;k++)

{

BA[i][j][k]=new int [blksz]. }

}

}

//  9. Разбиение области попиксельного поиска на блоки

 

for(int c=0;c<NA;c++)

{

for(int d=0;d<NA;d++)

{

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

{

for(int j=0;j<blksz;j++)

{

BA[c][d][i][j]=AR[c*+i][d*+j];

}

}

}

}

// <<<

// переменная для хранения минимальной ошибки сравнения sg_min=10000.

 

// 10. Попиксельный поиск идентичного блока в предшест-

//    вующем кадре

 

// Начало попиксельного поиска

for(int c=0;c<NA;c++)

{

for(int d=0;d<NA;d++)

{

// переменная для накопления суммы квадратов разностей

int SUM=0;

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

{

for(int j=0;j<blksz;j++)

{

SUM+=(float)(BC[m][n][i][j]-BA[c][d][i][j])*

(float)(BC[m][n][i][j]-BA[c][d][i][j]);

}

}

// расчет СКО

int sg=sqrt(SUM)/(blksz*blksz);

// сравнение ошибки сравнения с порогом

if(sg<tresh)

{

FLAG[m][n]=0x010;

P_adrX[m][n]=c;

P_adrY[m][n]=d;

goto END;

}

// сравнение с минимальной ошибкой сравнения

if(sg<sg_min)

{

sg_min=sg;

P_adrX[m][n]=c;

P_adrY[m][n]=d;

FLAG[m][n]=0x100;

}

} }// Конец попиксельного поиска

END:

}

}// Конец алгоритма поиска

return true;

}