Обработка изображений на основе Вейвлет-преобразований

Вейвлет-преобразования учувствуют в обработке изображений достаточно весомо. Это может быть как поиск объекта на изображении, так и в роли компрессора, который позволяет используя быстрое преобразование Хаара сжимать изображение.

Учитывая, что существует специальная библиотека C++ Wavelet Libraries для языка C++, после выбора языка мы вполне можем использовать ее, как готовое решение.

Давайте рассмотрим возможности данной библиотеки.

Данная библиотека обладает хорошим обучающим материалом, в ней можно легко реализовать простейшие действия с вейвлет-преобразованием

Рис. 4.1 - 256 битовый обычный сигнал от Wavelet Libraries

#include <iostream>

#include <fstream>

#include "wavelet2s.h"

#include <vector>

#include <string>

#include <cmath>

#include <algorithm>

using namespace std;

void findthresh(vector<double> vector1, int N, double& t){

sort(vector1.begin(), vector1.end(), greater<double>());

t = vector1.at(N-1);

}

int main() {

cout " "********J- LEVEL DISCRETE WAVELET TRANSFORM IMPLEMENTATION*********" " endl;

cout " "This program accepts signal from the user in a file format " " endl;

cout " "and performs Discrete Wavelet Transform with specified " " endl;

cout " "wavelet. " " endl;

cout " " " " endl;

cout " " The Following Wavelets are in the Database: " " endl;

cout " " haar, db1, db2, db3, db4, db5, db6, db7, db8, db9, db10, " " endl;

cout " " db11, db12, db13, db14, db15. " " endl;

cout " " bior1.1, bio1.3, bior1.5, bior2.2, bior2.4,bior2.6,bior2.8, " " endl;

cout " " bior3.1, bior3.3, bior3.5, bior3.7, bior3.9, bior4.4," " endl;

cout " " bior5.5, bior6.8." " endl;

cout " " coif1, coif2, coif3, coif4, coif5." " endl;

cout " "Please Enter the Wavelet Name at the Prompt(No quotes) :" " endl;

string nm; // nm will store the name of Wavelet Family

cin " nm;

cout " "Enter the name of signal file at the Prompt eg., signal.txt :" " endl;

char inp[50];

cin " inp;

vector<double> sig;

ifstream sig_inp(inp);

if (!sig_inp.good()){

cout " "The File doesn't exist"" endl;

exit(1);

}

while (sig_inp) {

double temp;

sig_inp " temp;

sig.push_back(temp);

}

sig.pop_back();

vector<double> original;

original = sig;

cout " "Please Enter the Number of DWT Stages J :" " endl;

int J;

cin " J ;

vector<double> dwt_output, flag;

vector<int> length1;

// perform J-Level DWT

dwt(sig, J, nm, dwt_output,flag, length1);

// Performing Linear Approximation by using only first 100 coefficients

// Coefficients in dwt_output are stored as following

// dwt_output =[ Appx(J-1) Detail(J-1) Detail(J-2) .... Detail(0)]

int n_coef = 100; // Number of significant coefficients

int n_non_sig= dwt_output.size() - n_coef; // Number of Coefficients that will

// be set to zero

dwt_output.erase(dwt_output.end()- n_non_sig,dwt_output.end());

// Deleting last n_non_sig coefficients and replacing them with zeros

dwt_output.insert(dwt_output.end(),n_non_sig,0);

ofstream linearsig("linsig.txt");

for (unsigned int i = 0; i < dwt_output.size(); i++) {

linearsig " dwt_output[i] " endl;

}

// Finding IDWT with approximated coefficients

vector<double> output;

idwt(dwt_output, flag,nm,output, length1);

unsigned int count = output.size();

ofstream gnulinappx("gnulinappx.dat");

for (unsigned int i = 0;i < count; i++) {

gnulinappx " output[i] " endl;

}

gnulinappx.close();

// Performing Non Linear Approximation by using only most

// significant coefficients

vector<double> dwt_output2, flag2;

vector<int> length2;

// perform J-Level DWT

dwt(sig, J, nm, dwt_output2,flag2,length2);

double thresh = 0.0;

vector<double> temp_dwtoutput;

for (unsigned int i =0; i < dwt_output2.size();i++){

double temp = abs(dwt_output2[i]);

temp_dwtoutput.push_back(temp);

}

/*

for (unsigned int i =0; i < temp_dwtoutput.size(); i++){

cout " temp_dwtoutput[i] " endl;

}

*/

findthresh(temp_dwtoutput,n_coef, thresh);

for (unsigned int i = 0; i < dwt_output2.size();i++){

double temp = abs(dwt_output2[i]);

if (temp < thresh){

dwt_output2.at(i) = 0.0;

}

}

/*

for (unsigned int i =0; i < dwt_output2.size(); i++){

cout " dwt_output2[i] " endl;

}

*/

ofstream nonlinsig("nonlinsig.txt");

for (unsigned int i = 0; i < dwt_output2.size(); i++) {

nonlinsig " dwt_output2[i] " endl;

}

// Finding IDWT with approximated coefficients

vector<double> output2;

idwt(dwt_output2, flag2,nm,output2, length2);

unsigned int count2 = output2.size();

cout " count2 " endl;

ofstream gnunlappx("gnunlappx.dat");

for (unsigned int i = 0;i < count2; i++) {

gnunlappx " output2[i] " endl;

}

gnunlappx.close();

return 0;

}

Результатом моей дипломной работы стало приложение для компрессии изображений с помощью вейвлет преобразований. Архитектура проекта достаточно проста.

Вейвлетное сжатие - общее название класса методов кодирования изображений, использующих двумерное вейвлет-разложение кодируемого изображения. Во многих источниках литературы сказано, что это сжатие обязательно с колоссальными потерями. На примере своего приложения, я протестировал, используя двукратное сжатие.

Основной сценарий сжатия:

· Загружаем изображение из файла;

· Конвертируем загруженное изображение в байтовый массив RGB-значений;

· Перекодируем RGB в YCrCb с квантованием итоговых цветовых компонентов;

· Применяем вейвлет;

· Переводим многомерный массив в одномерный (плоский);

· Сжимаем полученный поток любыми доступными средствами (например GZip).

· Коэффициенты для сжатия в представленном коде подобраны с целью получения минимального по размеру выходного файла, но с возможностью, что-то разглядеть.

Рис. 4.2 - внешний вид главного окна приложения

Рис. 4.3 - внешний вид главного окна при 2-кратном сжатии изображения

Заключение

В результате проделанной работы был рассмотрен алгоритм вейвлет-преобразований изображений, реализованный в приложении для сжатия изображений.

Для достижения поставленной цели были решены следующие задачи:

1) Изучена теоретическую часть по теме ВКР

2) Подготовлено необходимое программное обеспечение

3) Разработать приложение для обработки изображений

4) Описать основные возможности разработанного приложения

Можно подвести вывод, что вейвлет-преобразования много участвуют в естественных науках, инженерном деле, математике (включая прикладную). Наиболее широко ДВП используется в кодировании сигналов, где свойства преобразования используются для уменьшения избыточности в представлении дискретных сигналов, часто-- как первый этап в компрессии данных.

Список использованных источников

#include <iostream>

#include <fstream>

#include <vector>

#include <string>

#include <complex>

#include <cmath>

#include <algorithm>

#include "wavelet2d.h"

#include "cv.h"

#include "highgui.h"

#include "cxcore.h"

using namespace std;

using namespace cv;

void* maxval(vector<vector<double> > &arr, double &max){

max = 0;

for (unsigned int i =0; i < arr.size(); i++) {

for (unsigned int j =0; j < arr[0].size(); j++) {

if (max <= arr[i][j]){

max = arr[i][j];

}

}

}

return 0;

}

void* maxval1(vector<double> &arr, double &max){

max = 0;

for (unsigned int i =0; i < arr.size(); i++) {

if (max <= arr[i]){

max = arr[i];

}

}

return 0;

}

int main() {

IplImage* img = cvLoadImage("snow.jpg");

if (!img){

cout " " Can't read Image. Try Different Format." " endl;

exit(1);

}

int height, width;

height = img->height;

width = img->width;

int nc = img->nChannels;

// uchar* ptr2 =(uchar*) img->imageData;

int pix_depth = img->depth;

CvSize size;

size.width =width;

size.height=height;

cout " "depth" " pix_depth " "Channels" " nc " endl;

cvNamedWindow("Original Image", CV_WINDOW_AUTOSIZE);

cvShowImage("Original Image", img);

cvWaitKey();

cvDestroyWindow("Original Image");

cvSaveImage("orig.bmp",img);

int rows =(int) height;

int cols =(int) width;

Mat matimg(img);

vector<vector<double> > vec1(rows, vector<double>(cols));

int k =1;

for (int i=0; i < rows; i++) {

for (int j =0; j < cols; j++){

unsigned char temp;

temp = ((uchar*) matimg.data + i * matimg.step)[j * matimg.elemSize() + k ];

vec1[i][j] = (double) temp;

}

}

string nm = "db3";

vector<double> l1,h1,l2,h2;

filtcoef(nm,l1,h1,l2,h2);

// unsigned int lf=l1.size();

// int rows_n =(int) (rows+ J*(lf-1));

// int cols_n =(int) (cols + J * (lf -1));

// Finding 2D DWT Transform of the image using symetric extension algorithm

// Extension is set to 3 (eg., int e = 3)

vector<int> length;

vector<double> output,flag;

int J =3;

dwt_2d_sym(vec1,J,nm,output,flag,length);

double max;

vector<int> length2;

// This algorithm computes DWT of image of any given size. Together with convolution and

// subsampling operations it is clear that subsampled images are of different length than

// dyadic length images. In order to compute the "effective" size of DWT we do additional

// calculations.

dwt_output_dim_sym(length,length2,J);

// length2 is gives the integer vector that contains the size of subimages that will

// combine to form the displayed output image. The last two entries of length2 gives the

// size of DWT (rows_n by cols_n)

int siz = length2.size();

int rows_n=length2[siz-2];

int cols_n = length2[siz-1];

vector<vector< double> > dwtdisp(rows_n, vector<double>(cols_n));

dispDWT(output,dwtdisp, length,length2, J);

// dispDWT returns the 2D object dwtdisp which will be displayed using OPENCV's image

// handling functions

vector<vector<double> > dwt_output= dwtdisp;

maxval(dwt_output,max);// max value is needed to take care of overflow which happens because

// of convolution operations performed on unsigned 8 bit images

//Displaying Scaled Image

// Creating Image in OPENCV

IplImage *cvImg; // image used for output

CvSize imgSize; // size of output image

imgSize.width = cols_n;

imgSize.height = rows_n;

cvImg = cvCreateImage(imgSize, 8, 1);

// dwt_hold is created to hold the dwt output as further operations need to be

// carried out on dwt_output in order to display scaled images.

vector<vector<double> > dwt_hold(rows_n, vector<double>(cols_n));

dwt_hold = dwt_output;

// Setting coefficients of created image to the scaled DWT output values

for (int i = 0; i < imgSize.height; i++) {

for (int j = 0; j < imgSize.width; j++){

if (dwt_output[i][j] <= 0.0){

dwt_output[i][j] = 0.0;

}

if (i <= (length2[0]) && j <= (length2[1])) {

((uchar*)(cvImg->imageData + cvImg->widthStep*i))[j] =

(char) ((dwt_output[i][j] / max) * 255.0);

} else {

((uchar*)(cvImg->imageData + cvImg->widthStep*i))[j] =

(char) (dwt_output[i][j]) ;

}

}

}

cvNamedWindow("DWT Image", 1); // creation of a visualisation window

cvShowImage("DWT Image", cvImg); // image visualisation

cvWaitKey();

cvDestroyWindow("DWT Image");

cvSaveImage("dwt.bmp",cvImg);

// Finding IDWT

vector<vector<double> > idwt_output(rows, vector<double>(cols));

idwt_2d_sym(output,flag, nm, idwt_output,length);

//Displaying Reconstructed Image

IplImage *dvImg;

CvSize dvSize; // size of output image

dvSize.width = idwt_output[0].size();

dvSize.height = idwt_output.size();

cout " idwt_output.size() " idwt_output[0].size() " endl;

dvImg = cvCreateImage(dvSize, 8, 1);

for (int i = 0; i < dvSize.height; i++)

for (int j = 0; j < dvSize.width; j++)

((uchar*)(dvImg->imageData + dvImg->widthStep*i))[j] =

(char) (idwt_output[i][j]) ;

cvNamedWindow("Reconstructed Image", 1); // creation of a visualisation window

cvShowImage("Reconstructed Image", dvImg); // image visualisation

cvWaitKey();

cvDestroyWindow("Reconstructed Image");

cvSaveImage("recon.bmp",dvImg);

return 0;

}

Размещено на Allbest.ru